MSVS 2013 Update 2 support

The first MSVS compiler C99 compliant enough to build x264.
Use `CC=cl ./configure` to compile with it.

.gitignore

@@ -39,6 +39,8 @@ checkasm
 *.mbtree
 *.temp
 *.pyc
+*.pgd
+*.pgc
 
 .digress_x264
 dataDec.txt

Makefile

@@ -190,7 +190,12 @@ $(OBJS) $(OBJASM) $(OBJSO) $(OBJCLI) $(OBJCHK): .depend
 
 .depend: config.mak
 	@rm -f .depend
+	@echo 'dependency file generation...'
+ifeq ($(COMPILER),CL)
+	@$(foreach SRC, $(addprefix $(SRCPATH)/, $(SRCS) $(SRCCLI) $(SRCSO)), $(SRCPATH)/tools/msvsdepend.sh "$(CC)" "$(CFLAGS)" "$(SRC)" "$(SRC:$(SRCPATH)/%.c=%.o)" 1>> .depend;)
+else
 	@$(foreach SRC, $(addprefix $(SRCPATH)/, $(SRCS) $(SRCCLI) $(SRCSO)), $(CC) $(CFLAGS) $(SRC) $(DEPMT) $(SRC:$(SRCPATH)/%.c=%.o) $(DEPMM) 1>> .depend;)
+endif
 
 config.mak:
 	./configure
@@ -221,15 +226,20 @@ fprofiled:
 	$(MAKE) clean
 	$(MAKE) x264$(EXE) CFLAGS="$(CFLAGS) $(PROF_GEN_CC)" LDFLAGS="$(LDFLAGS) $(PROF_GEN_LD)"
 	$(foreach V, $(VIDS), $(foreach I, 0 1 2 3 4 5 6 7, ./x264$(EXE) $(OPT$I) --threads 1 $(V) -o $(DEVNULL) ;))
+ifeq ($(COMPILER),CL)
+# Because Visual Studio timestamps the object files within the PGD, it fails to build if they change - only the executable should be deleted
+	rm -f x264$(EXE)
+else
 	rm -f $(SRC2:%.c=%.o)
+endif
 	$(MAKE) CFLAGS="$(CFLAGS) $(PROF_USE_CC)" LDFLAGS="$(LDFLAGS) $(PROF_USE_LD)"
-	rm -f $(SRC2:%.c=%.gcda) $(SRC2:%.c=%.gcno) *.dyn pgopti.dpi pgopti.dpi.lock
+	rm -f $(SRC2:%.c=%.gcda) $(SRC2:%.c=%.gcno) *.dyn pgopti.dpi pgopti.dpi.lock *.pgd *.pgc
 endif
 
 clean:
 	rm -f $(OBJS) $(OBJASM) $(OBJCLI) $(OBJSO) $(SONAME) *.a *.lib *.exp *.pdb x264 x264.exe .depend TAGS
 	rm -f checkasm checkasm.exe $(OBJCHK) $(GENERATED) x264_lookahead.clbin
-	rm -f $(SRC2:%.c=%.gcda) $(SRC2:%.c=%.gcno) *.dyn pgopti.dpi pgopti.dpi.lock
+	rm -f $(SRC2:%.c=%.gcda) $(SRC2:%.c=%.gcno) *.dyn pgopti.dpi pgopti.dpi.lock *.pgd *.pgc
 
 distclean: clean
 	rm -f config.mak x264_config.h config.h config.log x264.pc x264.def

common/osdep.h

@@ -48,7 +48,7 @@
 #define log2(x) (log(x)/0.693147180559945)
 #endif
 
-#ifdef __ICL
+#ifdef _MSC_VER
 #define inline __inline
 #define strcasecmp _stricmp
 #define strncasecmp _strnicmp
@@ -57,10 +57,6 @@
 #define S_ISREG(x) (((x) & S_IFMT) == S_IFREG)
 #endif
 
-#if (defined(__GNUC__) || defined(__INTEL_COMPILER)) && (ARCH_X86 || ARCH_X86_64)
-#define HAVE_X86_INLINE_ASM 1
-#endif
-
 #if !defined(isfinite) && (SYS_OPENBSD || SYS_SunOS)
 #define isfinite finite
 #endif
@@ -89,7 +85,7 @@ int x264_is_pipe( const char *path );
 #define x264_is_pipe(x)  0
 #endif
 
-#ifdef __ICL
+#ifdef _MSC_VER
 #define DECLARE_ALIGNED( var, n ) __declspec(align(n)) var
 #else
 #define DECLARE_ALIGNED( var, n ) var __attribute__((aligned(n)))
@@ -156,7 +152,7 @@ int x264_is_pipe( const char *path );
 #define x264_constant_p(x) __builtin_constant_p(x)
 #define x264_nonconstant_p(x) (!__builtin_constant_p(x))
 #else
-#ifdef __ICL
+#ifdef _MSC_VER
 #define ALWAYS_INLINE __forceinline
 #define NOINLINE __declspec(noinline)
 #else

configure

@@ -73,32 +73,36 @@ log_msg() {
     echo "$1" >> config.log
 }
 
-intel_cflags() {
-    # Intel Compiler issues an incredibly large number of warnings on any warning level,
+cc_cflags() {
+    # several non gcc compilers issue an incredibly large number of warnings on any warning level,
     # suppress them by disabling all warnings rather than having to use #pragmas to disable most of them
     for arg in $*; do
         [ $arg = -ffast-math ] && arg=
         [[ "$arg" = -falign-loops* ]] && arg=
         [ "$arg" = -fno-tree-vectorize ] && arg=
         [ "$arg" = -Wshadow ] && arg=
+        [ "$arg" = -Wno-maybe-uninitialized ] && arg=
         [[ "$arg" = -mpreferred-stack-boundary* ]] && arg=
         [[ "$arg" = -l* ]] && arg=
         [[ "$arg" = -L* ]] && arg=
-        if [ $compiler = ICL ]; then
+        if [ $compiler_style = MS ]; then
             [ "$arg" = -Wall ] && arg=-W0
+            [ "$arg" = -Werror ] && arg="-W3 -WX"
             [ "$arg" = -g ] && arg=-Z7
             [ "$arg" = -fomit-frame-pointer ] && arg=
             [ "$arg" = -s ] && arg=
             [ "$arg" = -fPIC ] && arg=
         else
             [ "$arg" = -Wall ] && arg=-w0
+            [ "$arg" = -Werror ] && arg="-w3 -Werror"
         fi
+        [ $compiler = CL -a "$arg" = -O3 ] && arg=-O2
 
         [ -n "$arg" ] && echo -n "$arg "
     done
 }
 
-icl_ldflags() {
+cl_ldflags() {
     for arg in $*; do
         arg=${arg/LIBPATH/libpath}
         [ ${arg#-libpath:} == $arg -a ${arg#-l} != $arg ] && arg=${arg#-l}.lib
@@ -106,6 +110,10 @@ icl_ldflags() {
         [ $arg = -Wl,--large-address-aware ] && arg=-largeaddressaware
         [ $arg = -s ] && arg=
         [ "$arg" = -Wl,-Bsymbolic ] && arg=
+        [ "$arg" = -fno-tree-vectorize ] && arg=
+        [ "$arg" = -Werror ] && arg=
+        [ "$arg" = -Wshadow ] && arg=
+        [ "$arg" = -Wmaybe-uninitialized ] && arg=
 
         arg=${arg/pthreadGC/pthreadVC}
         [ "$arg" = avifil32.lib ] && arg=vfw32.lib
@@ -135,9 +143,9 @@ cc_check() {
     fi
     rm -f conftest.c
     [ -n "$1" ] && echo "#include <$1>" > conftest.c
-    echo "int main () { $3 return 0; }" >> conftest.c
-    if [ $compiler = ICL ]; then
-        cc_cmd="$CC conftest.c $(intel_cflags $CFLAGS $2) -link $(icl_ldflags $2 $LDFLAGSCLI $LDFLAGS)"
+    echo "int main (void) { $3 return 0; }" >> conftest.c
+    if [ $compiler_style = MS ]; then
+        cc_cmd="$CC conftest.c $(cc_cflags $CFLAGS $2) -link $(cl_ldflags $2 $LDFLAGSCLI $LDFLAGS)"
     else
         cc_cmd="$CC conftest.c $CFLAGS $2 $LDFLAGSCLI $LDFLAGS -o conftest"
     fi
@@ -165,8 +173,12 @@ cpp_check() {
     rm -f conftest.c
     [ -n "$1" ] && echo "#include <$1>" > conftest.c
     echo -e "#if !($3) \n#error $4 \n#endif " >> conftest.c
-
-    if $CC conftest.c $CFLAGS $2 -E -o conftest >conftest.log 2>&1; then
+    if [ $compiler_style = MS ]; then
+        cpp_cmd="$CC conftest.c $(cc_cflags $CFLAGS $2) -P"
+    else
+        cpp_cmd="$CC conftest.c $CFLAGS $2 -E -o conftest"
+    fi
+    if $cpp_cmd >conftest.log 2>&1; then
         res=$?
         log_ok
     else
@@ -208,10 +220,10 @@ as_check() {
 rc_check() {
     log_check "whether $RC works"
     echo "$1" > conftest.rc
-    if [ $compiler = ICL ]; then
-        rc_cmd="$RC $RCFLAGS -foconftest.o conftest.rc"
-    else
+    if [ $compiler = GNU ]; then
         rc_cmd="$RC $RCFLAGS -o conftest.o conftest.rc"
+    else
+        rc_cmd="$RC $RCFLAGS -foconftest.o conftest.rc"
     fi
     if $rc_cmd >conftest.log 2>&1; then
         res=$?
@@ -278,6 +290,7 @@ pic="no"
 bit_depth="8"
 chroma_format="all"
 compiler="GNU"
+compiler_style="GNU"
 opencl="yes"
 
 CFLAGS="$CFLAGS -Wall -I. -I\$(SRCPATH)"
@@ -292,7 +305,7 @@ EXE=""
 
 # list of all preprocessor HAVE values we can define
 CONFIG_HAVE="MALLOC_H ALTIVEC ALTIVEC_H MMX ARMV6 ARMV6T2 NEON BEOSTHREAD POSIXTHREAD WIN32THREAD THREAD LOG2F SWSCALE \
-             LAVF FFMS GPAC AVS GPL VECTOREXT INTERLACED CPU_COUNT OPENCL THP LSMASH"
+             LAVF FFMS GPAC AVS GPL VECTOREXT INTERLACED CPU_COUNT OPENCL THP LSMASH X86_INLINE_ASM"
 
 # parse options
 
@@ -439,23 +452,35 @@ host="${host#*-}"
 host_vendor="${host%%-*}"
 host_os="${host#*-}"
 
-# test for use of Intel Compiler
+# test for use of compilers that require specific handling
+cc_base=`basename "$CC"`
+QPRE="-"
 if [[ $host_os = mingw* || $host_os = cygwin* ]]; then
-    if [[ `basename "$CC"` = icl* ]]; then
+    if [[ "$cc_base" = icl || "$cc_base" = icl.* ]]; then
         # Windows Intel Compiler creates dependency generation with absolute Windows paths, Cygwin's make does not support Windows paths.
         [[ $host_os = cygwin* ]] && die "Windows Intel Compiler support requires MSYS"
         compiler=ICL
+        compiler_style=MS
         CFLAGS="$CFLAGS -Qstd=c99 -nologo -Qms0 -DHAVE_STRING_H -I\$(SRCPATH)/extras"
         QPRE="-Q"
         `$CC 2>&1 | grep -q IA-32` && host_cpu=i486
         `$CC 2>&1 | grep -q "Intel(R) 64"` && host_cpu=x86_64
         cpp_check "" "" "_MSC_VER >= 1400" || die "Windows Intel Compiler support requires Visual Studio 2005 or newer"
+    elif [[ "$cc_base" = cl || "$cc_base" = cl.* ]]; then
+        # Standard Microsoft Visual Studio
+        # Dependency creation includes absolute windows paths, Cygwin's make does not support Windows paths.
+        [[ $host_os = cygwin* ]] && die "Microsoft Visual Studio support requires MSYS"
+        compiler=CL
+        compiler_style=MS
+        CFLAGS="$CFLAGS -nologo -DHAVE_STRING_H -I\$(SRCPATH)/extras"
+        `$CC 2>&1 | grep -q 'for x86'` && host_cpu=i486
+        `$CC 2>&1 | grep -q 'for x64'` && host_cpu=x86_64
+        cpp_check '' '' '_MSC_VER > 1800 || (_MSC_VER == 1800 && _MSC_FULL_VER >= 180030324)' || die "Microsoft Visual Studio support requires Visual Studio 2013 Update 2 or newer"
     fi
 else
-    if [[ `basename "$CC"` = icc* ]]; then
+    if [[ "$cc_base" = icc || "$cc_base" = icc.* ]]; then
         AR="xiar"
         compiler=ICC
-        QPRE="-"
     fi
 fi
 
@@ -520,7 +545,7 @@ case $host_os in
         EXE=".exe"
         DEVNULL="NUL"
         LDFLAGSCLI="$LDFLAGSCLI -lshell32"
-        [ $compiler = ICL ] && RC="${RC-rc}" || RC="${RC-${cross_prefix}windres}"
+        [ $compiler = GNU ] && RC="${RC-${cross_prefix}windres}" || RC="${RC-rc}"
         ;;
     sunos*|solaris*)
         SYS="SunOS"
@@ -571,7 +596,7 @@ case $host_cpu in
             fi
             CFLAGS="-m32 $CFLAGS"
             LDFLAGS="-m32 $LDFLAGS"
-        else
+        elif [ $compiler = ICC ]; then
             # icc on linux has various degrees of mod16 stack support
             if [ $SYS = LINUX ]; then
                 # < 11 is completely incapable of keeping a mod16 stack
@@ -583,8 +608,9 @@ case $host_cpu in
                 fi
                 # >= 12 defaults to a mod16 stack
             fi
-            # icl on windows has no mod16 stack support
-            [ $SYS = WINDOWS ] && stack_alignment=4
+        else # ICL/CL
+            # always a mod4 stack
+            stack_alignment=4
         fi
         if [ "$SYS" = MACOSX ]; then
             ASFLAGS="$ASFLAGS -f macho -DPREFIX"
@@ -688,7 +714,7 @@ log_msg ""
 
 cc_check || die "No working C compiler found."
 
-if [ $compiler != ICL ]; then
+if [ $compiler_style = GNU ]; then
     if cc_check '' -std=gnu99 'for( int i = 0; i < 9; i++ );' ; then
         CFLAGS="$CFLAGS -std=gnu99"
     elif cc_check '' -std=c99 'for( int i = 0; i < 9; i++ );' ; then
@@ -710,14 +736,7 @@ if [ $asm = auto -a \( $ARCH = X86 -o $ARCH = X86_64 \) ] ; then
         echo "If you really want to compile without asm, configure with --disable-asm."
         exit 1
     fi
-    if ! cc_check '' '' '__asm__("pabsw %xmm0, %xmm0");' ; then
-        VER=`(${cross_prefix}as --version || echo no gnu as) 2>/dev/null | head -n 1`
-        echo "Found $VER"
-        echo "Minimum version is binutils-2.17"
-        echo "Your compiler can't handle inline SSSE3 asm."
-        echo "If you really want to compile without asm, configure with --disable-asm."
-        exit 1
-    fi
+    cc_check '' '' '__asm__("pabsw %xmm0, %xmm0");' && define HAVE_X86_INLINE_ASM
     ASFLAGS="$ASFLAGS -Worphan-labels"
     define HAVE_MMX
     if [ $compiler = GNU ] && cc_check '' -mpreferred-stack-boundary=5 ; then
@@ -750,7 +769,7 @@ define SYS_$SYS
 define STACK_ALIGNMENT $stack_alignment
 ASFLAGS="$ASFLAGS -DSTACK_ALIGNMENT=$stack_alignment"
 
-# skip endianness check for Intel Compiler, as all supported platforms are little. the -ipo flag will also cause the check to fail
+# skip endianness check for Intel Compiler and MSVS, as all supported platforms are little. each have flags that will cause the check to fail as well
 if [ $compiler = GNU ]; then
     echo "int i[2] = {0x42494745,0}; double f[2] = {0x1.0656e6469616ep+102,0};" > conftest.c
     $CC $CFLAGS conftest.c -c -o conftest.o 2>/dev/null || die "endian test failed"
@@ -1067,17 +1086,18 @@ for var in $CONFIG_HAVE; do
     grep -q "HAVE_$var 1" config.h || define HAVE_$var 0
 done
 
-if [ $compiler = ICL ]; then
-    AR="xilib -nologo -out:"
-    DEPMM=-QMM
-    DEPMT=-QMT
+DEPMM="${QPRE}MM"
+DEPMT="${QPRE}MT"
+if [ $compiler_style = MS ]; then
+    AR="lib -nologo -out:"
+    LD="link -out:"
+    [ $compiler = ICL ] && AR="xi$AR" && LD="xi$LD"
     HAVE_GETOPT_LONG=0
-    LD="xilink -out:"
-    LDFLAGS="-nologo -incremental:no $(icl_ldflags $LDFLAGS)"
-    LDFLAGSCLI="$(icl_ldflags $LDFLAGSCLI)"
+    LDFLAGS="-nologo -incremental:no $(cl_ldflags $LDFLAGS)"
+    LDFLAGSCLI="$(cl_ldflags $LDFLAGSCLI)"
     LIBX264=libx264.lib
     RANLIB=
-    [ -n "$RC" ] && RCFLAGS="$RCFLAGS -I. -I\$(SRCPATH)/extras -fo"
+    [ -n "$RC" ] && RCFLAGS="$RCFLAGS -nologo -I. -I\$(SRCPATH)/extras -fo"
     STRIP=
     if [ $debug = yes ]; then
         LDFLAGS="-debug $LDFLAGS"
@@ -1085,27 +1105,37 @@ if [ $compiler = ICL ]; then
     else
         CFLAGS="-DNDEBUG $CFLAGS"
     fi
-else
+else # gcc/icc
+    DEPMM="$DEPMM -g0"
     AR="$AR rc "
-    DEPMM="-MM -g0"
-    DEPMT="-MT"
     LD="$CC -o "
     LIBX264=libx264.a
     [ -n "$RC" ] && RCFLAGS="$RCFLAGS -I. -o "
 fi
-if [ $compiler = GNU ]; then
-    PROF_GEN_CC="-fprofile-generate"
-    PROF_GEN_LD="-fprofile-generate"
-    PROF_USE_CC="-fprofile-use"
-    PROF_USE_LD="-fprofile-use"
-else
-    CFLAGS="$(intel_cflags $CFLAGS)"
+[ $compiler != GNU ] && CFLAGS="$(cc_cflags $CFLAGS)"
+if [ $compiler = ICC -o $compiler = ICL ]; then
     # icc does not define __SSE__ until SSE2 optimization and icl never defines it or _M_IX86_FP
     [ \( $ARCH = X86_64 -o $ARCH = X86 \) -a $asm = yes ] && ! cpp_check "" "" "defined(__SSE__)" && define __SSE__
     PROF_GEN_CC="${QPRE}prof-gen ${QPRE}prof-dir."
     PROF_GEN_LD=
     PROF_USE_CC="${QPRE}prof-use ${QPRE}prof-dir."
     PROF_USE_LD=
+elif [ $compiler = CL ]; then
+    # Visual Studio
+    # _M_IX86_FP is only defined on x86
+    [ $ARCH = X86 ] && cpp_check '' '' '_M_IX86_FP >= 1' && define __SSE__
+    [ $ARCH = X86_64 ] && define __SSE__
+    # As long as the cli application can't link against the dll, the dll can not be pgo'd.
+    # pgds are link flag specific and the -dll flag for creating the dll makes it unshareable with the cli
+    PROF_GEN_CC="-GL"
+    PROF_GEN_LD="-LTCG:PGINSTRUMENT"
+    PROF_USE_CC="-GL"
+    PROF_USE_LD="-LTCG:PGOPTIMIZE"
+else
+    PROF_GEN_CC="-fprofile-generate"
+    PROF_GEN_LD="-fprofile-generate"
+    PROF_USE_CC="-fprofile-use"
+    PROF_USE_LD="-fprofile-use"
 fi
 
 rm -f conftest*
@@ -1134,6 +1164,8 @@ ARCH=$ARCH
 SYS=$SYS
 CC=$CC
 CFLAGS=$CFLAGS
+COMPILER=$compiler
+COMPILER_STYLE=$compiler_style
 DEPMM=$DEPMM
 DEPMT=$DEPMT
 LD=$LD
@@ -1157,7 +1189,7 @@ PROF_USE_LD=$PROF_USE_LD
 HAVE_OPENCL=$opencl
 EOF
 
-if [ $compiler = ICL ]; then
+if [ $compiler_style = MS ]; then
     echo '%.o: %.c' >> config.mak
     echo '	$(CC) $(CFLAGS) -c -Fo$@ $<' >> config.mak
 fi
@@ -1171,7 +1203,7 @@ if [ "$shared" = "yes" ]; then
     API=$(grep '#define X264_BUILD' < ${SRCPATH}/x264.h | cut -f 3 -d ' ')
     if [ "$SYS" = "WINDOWS" -o "$SYS" = "CYGWIN" ]; then
         echo "SONAME=libx264-$API.dll" >> config.mak
-        if [ $compiler = ICL ]; then
+        if [ $compiler_style = MS ]; then
             echo 'IMPLIBNAME=libx264.dll.lib' >> config.mak
             # GNU ld on windows defaults to exporting all global functions if there are no explicit __declspec(dllexport) declarations
             # MSVC link does not act similarly, so it is required to make an export definition out of x264.h and use it at link time

input/avs.c

@@ -298,7 +298,10 @@ static int open_file( char *psz_filename, hnd_t *p_handle, video_info_t *info, c
             opt->input_range = opt->output_range;
         }
         const char *arg_name[] = { NULL, "interlaced", "matrix" };
-        AVS_Value arg_arr[] = { res, avs_new_value_bool( info->interlaced ), avs_new_value_string( matrix ) };
+        AVS_Value arg_arr[3];
+        arg_arr[0] = res;
+        arg_arr[1] = avs_new_value_bool( info->interlaced );
+        arg_arr[2] = avs_new_value_string( matrix );
         AVS_Value res2 = h->func.avs_invoke( h->env, conv_func, avs_new_value_array( arg_arr, arg_count ), arg_name );
         FAIL_IF_ERROR( avs_is_error( res2 ), "couldn't convert input clip to %s\n", csp )
         res = update_clip( h, &vi, res2, res );
@@ -308,7 +311,9 @@ static int open_file( char *psz_filename, hnd_t *p_handle, video_info_t *info, c
     {
         const char *levels = opt->output_range ? "TV->PC" : "PC->TV";
         x264_cli_log( "avs", X264_LOG_WARNING, "performing %s conversion\n", levels );
-        AVS_Value arg_arr[] = { res, avs_new_value_string( levels ) };
+        AVS_Value arg_arr[2];
+        arg_arr[0] = res;
+        arg_arr[1] = avs_new_value_string( levels );
         const char *arg_name[] = { NULL, "levels" };
         AVS_Value res2 = h->func.avs_invoke( h->env, "ColorYUV", avs_new_value_array( arg_arr, 2 ), arg_name );
         FAIL_IF_ERROR( avs_is_error( res2 ), "couldn't convert range: %s\n", avs_as_error( res2 ) )

tools/msvsdepend.sh

+#!/bin/sh
+# There's a lot of things going on here
+# expected arguments are $(CC) $(CFLAGS) $(SRC) $(OBJ)
+# 1) start the dependency line with the object argument
+# 2) need to add -Zs -showIncludes to the flags to have the compiler output list of include files without compilation
+# 3) look for notes in the output that start with "Note: including file:"
+# 4) retain only the filepath from the notes
+# 5) convert \ foldername separators to /
+# 6) escape spaces in the filepath
+# 7) remove system includes (hack: check for "/Program Files" string in filepath)
+# 8) sort and remove duplicate filepath entries
+# 9) convert newlines to spaces to collapse the dependencies into the one dependency line
+# 10) print a newline character, to properly separate dependency lines
+echo -n "$4: "
+$1 $2 $3 -Zs -showIncludes 2>&1 |
+    grep '^Note: including file:' |
+    sed 's/^Note: including file:[[:space:]]*\(.*\)$/\1/; s/\\/\//g; s/ /\\ /g' |
+    sed '/\/[Pp]rogram\\ [Ff]iles/d' |
+    sort | uniq |
+    tr -s '\n\r' ' '
+echo ''

x264.c

@@ -320,6 +320,8 @@ static void print_version_info( void )
     printf( "intel: %.2f (%d)\n", __INTEL_COMPILER / 100.f, __INTEL_COMPILER_BUILD_DATE );
 #elif defined(__GNUC__)
     printf( "gcc: " __VERSION__ "\n" );
+#elif defined(_MSC_FULL_VER)
+    printf( "msvc: %.2f (%u)\n", _MSC_VER / 100.f, _MSC_FULL_VER );
 #else
     printf( "using an unknown compiler\n" );
 #endif

x264.h

@@ -28,8 +28,8 @@
 #ifndef X264_X264_H
 #define X264_X264_H
 
-#if !defined(_STDINT_H) && !defined(_STDINT_H_) && !defined(_STDINT_H_INCLUDED) &&\
-    !defined(_INTTYPES_H) && !defined(_INTTYPES_H_)
+#if !defined(_STDINT_H) && !defined(_STDINT_H_) && !defined(_STDINT_H_INCLUDED) && !defined(_STDINT) &&\
+    !defined(_INTTYPES_H) && !defined(_INTTYPES_H_) && !defined(_INTTYPES)
 # ifdef _MSC_VER
 #  pragma message("You must include stdint.h or inttypes.h before x264.h")
 # else