Updated docs to 2.4.3 rc

Rair hangs on library installation fixed.

.gitattributes

@@ -0,0 +1,55 @@
+.git*       export-ignore
+
+*           text=auto
+*           whitespace=!indent,trail,space
+
+*.py        text whitespace=tab-in-indent,trail,space,fix
+*.cpp       text whitespace=tab-in-indent,trail,space,fix
+*.hpp       text whitespace=tab-in-indent,trail,space,fix
+*.cxx       text whitespace=tab-in-indent,trail,space,fix
+*.hxx       text whitespace=tab-in-indent,trail,space,fix
+*.mm        text whitespace=tab-in-indent,trail,space,fix
+*.c         text whitespace=tab-in-indent,trail,space,fix
+*.h         text whitespace=tab-in-indent,trail,space,fix
+*.i         text whitespace=tab-in-indent,trail,space,fix
+*.java      text whitespace=tab-in-indent,trail,space,fix
+*.cu        text whitespace=tab-in-indent,trail,space,fix
+*.cl        text whitespace=tab-in-indent,trail,space,fix
+
+*.cmake     text whitespace=tab-in-indent,trail,space,fix
+*.cmakein   text whitespace=tab-in-indent,trail,space,fix
+*.in        text whitespace=tab-in-indent,trail,space,fix
+CMakeLists.txt  text whitespace=tab-in-indent,trail,space,fix
+
+*.rst       text whitespace=tab-in-indent,trail,space,fix
+
+*.png       binary
+*.jepg      binary
+*.jpg       binary
+*.exr       binary
+*.ico       binary
+
+*.a         binary
+*.so        binary
+*.dll       binary
+
+*.pdf       binary
+*.pbxproj   binary
+*.vec       binary
+*.doc       binary
+
+*.css_t     text
+*.qrc       text
+*.qss       text
+*.S         text
+
+*.xml       -text
+*.yml       -text
+
+*.vcproj    text eol=crlf merge=union
+*.cproject  text eol=crlf merge=union
+*.bat       text eol=crlf
+*.cmd       text eol=crlf
+*.cmd.tmpl  text eol=crlf
+
+*.sh        text eol=lf

.gitignore

@@ -0,0 +1,8 @@
+*.pyc
+.DS_Store
+refman.rst
+OpenCV4Tegra/
+*.user
+.sw[a-z]
+.*.swp
+tags

3rdparty/CMakeLists.txt

@@ -1,18 +0,0 @@
-if(NOT ZLIB_FOUND)
-    add_subdirectory(zlib)
-endif()
-if(WITH_JASPER AND NOT JASPER_FOUND)
-    add_subdirectory(libjasper)
-endif()
-if(WITH_JPEG AND NOT JPEG_FOUND)
-    add_subdirectory(libjpeg)
-endif()
-if(WITH_PNG AND NOT PNG_FOUND)
-    add_subdirectory(libpng)
-endif()
-if(WITH_TIFF AND NOT TIFF_FOUND)
-    add_subdirectory(libtiff)
-endif()
-if(WIN32)
-    add_subdirectory(ffmpeg)
-endif()

3rdparty/ffmpeg/CMakeLists.txt

@@ -1,20 +0,0 @@
-project(opencv_ffmpeg)
-
-if(MSVC64 OR MINGW64)
-   set(FFMPEG_SUFFIX _64)
-endif()
-
-set(module_bare_name "opencv_ffmpeg${FFMPEG_SUFFIX}.dll")
-set(module_name "${CMAKE_CURRENT_SOURCE_DIR}/${module_bare_name}")
-
-get_target_property(bin_dir opencv_traincascade LOCATION)
-get_filename_component(bin_dir ${bin_dir} PATH) 
-
-message(STATUS "ffmpeg output dir: ${bin_dir}")
-
-add_custom_target(opencv_ffmpeg ALL
-                  COMMAND ${CMAKE_COMMAND} -E copy
-                    ${module_name} ${bin_dir}/${module_bare_name}
-                  COMMENT "Copying ${module_name} to the output directory")
-
-install(FILES ${module_name} DESTINATION bin COMPONENT main)

3rdparty/ffmpeg/ffmpeg_version.cmake

@@ -0,0 +1,11 @@
+set(NEW_FFMPEG 1)
+set(HAVE_FFMPEG_CODEC 1)
+set(HAVE_FFMPEG_FORMAT 1)
+set(HAVE_FFMPEG_UTIL 1)
+set(HAVE_FFMPEG_SWSCALE 1)
+set(HAVE_GENTOO_FFMPEG 1)
+
+set(ALIASOF_libavcodec_VERSION 53.61.100)
+set(ALIASOF_libavformat_VERSION 53.32.100)
+set(ALIASOF_libavutil_VERSION 51.35.100)
+set(ALIASOF_libswscale_VERSION 2.1.100)

3rdparty/ilmimf/README

@@ -1,123 +0,0 @@
-ABOUT THE OPENEXR LIBRARIES
-----------------------------
-
-Half is a class that encapsulates our 16-bit floating-point format.
-
-IlmThread is a thread abstraction library for use with IlmImf.  It
-currently supports pthreads and Windows threads.
-
-IlmImf is our "EXR" file format for storing 16-bit FP images.
-
-Imath is a math library.  IlmImf only uses a subset of it,
-but we're releasing the full library because it's easier for us to 
-maintain, and we think it'll be useful to others.
-
-Iex is an exception-handling library.
-
-See the IlmImfExamples directory for some code that demonstrates how
-to use the IlmImf library to read and write OpenEXR files.  The doc
-directory contains some high-level documentation and history about the
-OpenEXR format.
-
-If you have questions about using the OpenEXR libraries, you may want
-to join our developer mailing list.  See http://www.openexr.com for
-details.
-
-
-LICENSE
--------
-
-The OpenEXR source code distribution is free software.  See the file
-named COPYING (included in this distribution) for details.
-
-
-WHAT'S INCLUDED
----------------
-
-Besides the core OpenEXR libraries, the release includes several 
-utilities for reading, writing, viewing, and manipulating OpenEXR 
-images.  These include:
-
-  * exrdisplay, an image viewer.
-  * exrheader, a utility for dumping header information.
-  * exrstdattr, a utility for modifying OpenEXR standard attributes.
-  * exrmaketiled, for generating tiled and rip/mipmapped images.
-  * exrenvmap, for creating OpenEXR environment maps.
-  * exrmakepreview, for creating preview images for OpenEXR files.
-
-exrdisplay requires FLTK 1.1 or greater and OpenGL.  exrdisplay
-supports fragment shaders if you have the Nvidia Cg SDK and a graphics
-card capable of running fp30 profile fragment shaders.  See
-exrdisplay/README for details.
-
-We have also released an OpenEXR display driver for Renderman, a file
-I/O plugin for Shake, and a file I/O plugin for Adobe Photoshop (on
-both Windows and MacOS).  These are packaged separately.  Go to
-http://www.openexr.com to download them.  NOTE: the most recent
-versions of these applications now have native support for OpenEXR, so
-you should only use our open-source versions of the plugins if you
-have an older version of the application.
-
-
-BUILDING OPENEXR
-----------------
-
-Building OpenEXR requires the zlib library.  If you want to build the
-'exrdisplay' image viewer, you'll also need FLTK 1.1, but this program
-is not required to use OpenEXR's libraries in your application.
-exrdisplay can also accelerate the display of OpenEXR images if you
-have the NVIDIA Cg SDK.
-
-Your OS distribution may already include these libraries, or supply
-packages for them.  That is the preferred way to obtain them for use
-with OpenEXR.  If not, you can obtain the source code for zlib and
-FLTK from:
-
-   http://www.zlib.net
-   http://www.fltk.org
-
-and you can download the NVIDIA Cg SDK from
-http://developer.nvidia.com.
-
-If you're building OpenEXR on a Windows platform, see README.win32 for
-instructions on how to build OpenEXR.  The remainder of this file
-applies only to GNU/Linux or other UNIX-like systems.
-
-After installing the required libraries, to build OpenEXR on
-GNU/Linux or other UNIX-like systems, do this:
-
-./configure
-make
-make install
-
-unless you obtained OpenEXR directly from CVS, in which case you
-should first read README.CVS.
-
-If you have the Nvidia Cg SDK and you want to build support for
-fragment shaders into exrdisplay, specify the path to the SDK using
-the "--with-cg-prefix" flag.  There are some additional compile-time
-configuration options available; type `./configure --help` for more
-information.
-
-See README.OSX for details on building OpenEXR in MacOS X.
-
-Do `make check` to run the OpenEXR confidence tests.  They should all
-pass; if you find a test that does not pass on your system, please let
-us know.
-
-Other UNIX variants haven't been tested, but should be easy to build.
-Let us know if you're having problems porting OpenEXR to a particular
-platform.
-
-All include files needed to use the OpenEXR libraries are installed in the 
-OpenEXR subdirectory of the install prefix, e.g. /usr/local/include/OpenEXR.
-
-
-USING OPENEXR IN YOUR APPLICATIONS
-----------------------------------
-
-On systems with support for pkg-config, use `pkg-config --cflags
-OpenEXR` for the C++ flags required to compile against OpenEXR
-headers; and `pkg-config --libs OpenEXR` for the linker flags required
-to link against OpenEXR libraries.
-

3rdparty/include/MultiMon.h

@@ -0,0 +1,502 @@
+//=============================================================================
+//
+// multimon.h -- Stub module that fakes multiple monitor apis on Win32 OSes
+//               without them.
+//
+// By using this header your code will get back default values from
+// GetSystemMetrics() for new metrics, and the new multimonitor APIs
+// will act like only one display is present on a Win32 OS without
+// multimonitor APIs.
+//
+// Exactly one source must include this with COMPILE_MULTIMON_STUBS defined.
+//
+// Copyright (c) Microsoft Corporation. All rights reserved.
+//
+//=============================================================================
+
+#ifdef __cplusplus
+extern "C" {            // Assume C declarations for C++
+#endif // __cplusplus
+
+//
+// If we are building with Win95/NT4 headers, we need to declare
+// the multimonitor-related metrics and APIs ourselves.
+//
+#ifndef SM_CMONITORS
+
+#define SM_XVIRTUALSCREEN       76
+#define SM_YVIRTUALSCREEN       77
+#define SM_CXVIRTUALSCREEN      78
+#define SM_CYVIRTUALSCREEN      79
+#define SM_CMONITORS            80
+#define SM_SAMEDISPLAYFORMAT    81
+
+// HMONITOR is already declared if WINVER >= 0x0500 in windef.h
+// This is for components built with an older version number.
+//
+#if !defined(HMONITOR_DECLARED) && (WINVER < 0x0500)
+DECLARE_HANDLE(HMONITOR);
+#define HMONITOR_DECLARED
+#endif
+
+#define MONITOR_DEFAULTTONULL       0x00000000
+#define MONITOR_DEFAULTTOPRIMARY    0x00000001
+#define MONITOR_DEFAULTTONEAREST    0x00000002
+
+#define MONITORINFOF_PRIMARY        0x00000001
+
+typedef struct tagMONITORINFO
+{
+    DWORD   cbSize;
+    RECT    rcMonitor;
+    RECT    rcWork;
+    DWORD   dwFlags;
+} MONITORINFO, *LPMONITORINFO;
+
+#ifndef CCHDEVICENAME
+#define CCHDEVICENAME 32
+#endif
+
+#ifdef __cplusplus
+typedef struct tagMONITORINFOEXA : public tagMONITORINFO
+{
+    CHAR        szDevice[CCHDEVICENAME];
+} MONITORINFOEXA, *LPMONITORINFOEXA;
+typedef struct tagMONITORINFOEXW : public tagMONITORINFO
+{
+    WCHAR       szDevice[CCHDEVICENAME];
+} MONITORINFOEXW, *LPMONITORINFOEXW;
+#ifdef UNICODE
+typedef MONITORINFOEXW MONITORINFOEX;
+typedef LPMONITORINFOEXW LPMONITORINFOEX;
+#else
+typedef MONITORINFOEXA MONITORINFOEX;
+typedef LPMONITORINFOEXA LPMONITORINFOEX;
+#endif // UNICODE
+#else // ndef __cplusplus
+typedef struct tagMONITORINFOEXA
+{
+    MONITORINFO;
+    CHAR        szDevice[CCHDEVICENAME];
+} MONITORINFOEXA, *LPMONITORINFOEXA;
+typedef struct tagMONITORINFOEXW
+{
+    MONITORINFO;
+    WCHAR       szDevice[CCHDEVICENAME];
+} MONITORINFOEXW, *LPMONITORINFOEXW;
+#ifdef UNICODE
+typedef MONITORINFOEXW MONITORINFOEX;
+typedef LPMONITORINFOEXW LPMONITORINFOEX;
+#else
+typedef MONITORINFOEXA MONITORINFOEX;
+typedef LPMONITORINFOEXA LPMONITORINFOEX;
+#endif // UNICODE
+#endif
+
+typedef BOOL (CALLBACK* MONITORENUMPROC)(HMONITOR, HDC, LPRECT, LPARAM);
+
+#ifndef DISPLAY_DEVICE_ATTACHED_TO_DESKTOP
+typedef struct _DISPLAY_DEVICEA {
+    DWORD  cb;
+    CHAR   DeviceName[32];
+    CHAR   DeviceString[128];
+    DWORD  StateFlags;
+    CHAR   DeviceID[128];
+    CHAR   DeviceKey[128];
+} DISPLAY_DEVICEA, *PDISPLAY_DEVICEA, *LPDISPLAY_DEVICEA;
+typedef struct _DISPLAY_DEVICEW {
+    DWORD  cb;
+    WCHAR  DeviceName[32];
+    WCHAR  DeviceString[128];
+    DWORD  StateFlags;
+    WCHAR  DeviceID[128];
+    WCHAR  DeviceKey[128];
+} DISPLAY_DEVICEW, *PDISPLAY_DEVICEW, *LPDISPLAY_DEVICEW;
+#ifdef UNICODE
+typedef DISPLAY_DEVICEW DISPLAY_DEVICE;
+typedef PDISPLAY_DEVICEW PDISPLAY_DEVICE;
+typedef LPDISPLAY_DEVICEW LPDISPLAY_DEVICE;
+#else
+typedef DISPLAY_DEVICEA DISPLAY_DEVICE;
+typedef PDISPLAY_DEVICEA PDISPLAY_DEVICE;
+typedef LPDISPLAY_DEVICEA LPDISPLAY_DEVICE;
+#endif // UNICODE
+
+#define DISPLAY_DEVICE_ATTACHED_TO_DESKTOP 0x00000001
+#define DISPLAY_DEVICE_MULTI_DRIVER        0x00000002
+#define DISPLAY_DEVICE_PRIMARY_DEVICE      0x00000004
+#define DISPLAY_DEVICE_MIRRORING_DRIVER    0x00000008
+#define DISPLAY_DEVICE_VGA_COMPATIBLE      0x00000010
+#endif
+
+#endif  // SM_CMONITORS
+
+#undef GetMonitorInfo
+#undef GetSystemMetrics
+#undef MonitorFromWindow
+#undef MonitorFromRect
+#undef MonitorFromPoint
+#undef EnumDisplayMonitors
+#undef EnumDisplayDevices
+
+//
+// Define COMPILE_MULTIMON_STUBS to compile the stubs;
+// otherwise, you get the declarations.
+//
+#ifdef COMPILE_MULTIMON_STUBS
+
+//-----------------------------------------------------------------------------
+//
+// Implement the API stubs.
+//
+//-----------------------------------------------------------------------------
+
+#ifndef _MULTIMON_USE_SECURE_CRT
+#if defined(__GOT_SECURE_LIB__) && __GOT_SECURE_LIB__ >= 200402L
+#define _MULTIMON_USE_SECURE_CRT 1
+#else
+#define _MULTIMON_USE_SECURE_CRT 0
+#endif
+#endif
+
+#ifndef MULTIMON_FNS_DEFINED
+
+int      (WINAPI* g_pfnGetSystemMetrics)(int) = NULL;
+HMONITOR (WINAPI* g_pfnMonitorFromWindow)(HWND, DWORD) = NULL;
+HMONITOR (WINAPI* g_pfnMonitorFromRect)(LPCRECT, DWORD) = NULL;
+HMONITOR (WINAPI* g_pfnMonitorFromPoint)(POINT, DWORD) = NULL;
+BOOL     (WINAPI* g_pfnGetMonitorInfo)(HMONITOR, LPMONITORINFO) = NULL;
+BOOL     (WINAPI* g_pfnEnumDisplayMonitors)(HDC, LPCRECT, MONITORENUMPROC, LPARAM) = NULL;
+BOOL     (WINAPI* g_pfnEnumDisplayDevices)(PVOID, DWORD, PDISPLAY_DEVICE,DWORD) = NULL;
+BOOL     g_fMultiMonInitDone = FALSE;
+BOOL     g_fMultimonPlatformNT = FALSE;
+
+#endif
+
+BOOL IsPlatformNT()
+{
+    OSVERSIONINFOA osvi = {0};
+    osvi.dwOSVersionInfoSize = sizeof(osvi);
+    GetVersionExA((OSVERSIONINFOA*)&osvi);
+    return (VER_PLATFORM_WIN32_NT == osvi.dwPlatformId);
+}
+
+BOOL InitMultipleMonitorStubs(void)
+{
+    HMODULE hUser32;
+    if (g_fMultiMonInitDone)
+    {
+        return g_pfnGetMonitorInfo != NULL;
+    }
+
+    g_fMultimonPlatformNT = IsPlatformNT();
+    hUser32 = GetModuleHandle(TEXT("USER32"));
+    if (hUser32 &&
+        (*(FARPROC*)&g_pfnGetSystemMetrics    = GetProcAddress(hUser32,"GetSystemMetrics")) != NULL &&
+        (*(FARPROC*)&g_pfnMonitorFromWindow   = GetProcAddress(hUser32,"MonitorFromWindow")) != NULL &&
+        (*(FARPROC*)&g_pfnMonitorFromRect     = GetProcAddress(hUser32,"MonitorFromRect")) != NULL &&
+        (*(FARPROC*)&g_pfnMonitorFromPoint    = GetProcAddress(hUser32,"MonitorFromPoint")) != NULL &&
+        (*(FARPROC*)&g_pfnEnumDisplayMonitors = GetProcAddress(hUser32,"EnumDisplayMonitors")) != NULL &&
+#ifdef UNICODE
+        (*(FARPROC*)&g_pfnEnumDisplayDevices  = GetProcAddress(hUser32,"EnumDisplayDevicesW")) != NULL &&
+        (*(FARPROC*)&g_pfnGetMonitorInfo      = g_fMultimonPlatformNT ? GetProcAddress(hUser32,"GetMonitorInfoW") :
+                                                GetProcAddress(hUser32,"GetMonitorInfoA")) != NULL
+#else
+        (*(FARPROC*)&g_pfnGetMonitorInfo      = GetProcAddress(hUser32,"GetMonitorInfoA")) != NULL &&
+        (*(FARPROC*)&g_pfnEnumDisplayDevices  = GetProcAddress(hUser32,"EnumDisplayDevicesA")) != NULL
+#endif
+    ) {
+        g_fMultiMonInitDone = TRUE;
+        return TRUE;
+    }
+    else
+    {
+        g_pfnGetSystemMetrics    = NULL;
+        g_pfnMonitorFromWindow   = NULL;
+        g_pfnMonitorFromRect     = NULL;
+        g_pfnMonitorFromPoint    = NULL;
+        g_pfnGetMonitorInfo      = NULL;
+        g_pfnEnumDisplayMonitors = NULL;
+        g_pfnEnumDisplayDevices  = NULL;
+
+        g_fMultiMonInitDone = TRUE;
+        return FALSE;
+    }
+}
+
+//-----------------------------------------------------------------------------
+//
+// fake implementations of Monitor APIs that work with the primary display
+// no special parameter validation is made since these run in client code
+//
+//-----------------------------------------------------------------------------
+
+int WINAPI
+xGetSystemMetrics(int nIndex)
+{
+    if (InitMultipleMonitorStubs())
+        return g_pfnGetSystemMetrics(nIndex);
+
+    switch (nIndex)
+    {
+    case SM_CMONITORS:
+    case SM_SAMEDISPLAYFORMAT:
+        return 1;
+
+    case SM_XVIRTUALSCREEN:
+    case SM_YVIRTUALSCREEN:
+        return 0;
+
+    case SM_CXVIRTUALSCREEN:
+        nIndex = SM_CXSCREEN;
+        break;
+
+    case SM_CYVIRTUALSCREEN:
+        nIndex = SM_CYSCREEN;
+        break;
+    }
+
+    return GetSystemMetrics(nIndex);
+}
+
+#define xPRIMARY_MONITOR ((HMONITOR)0x12340042)
+
+HMONITOR WINAPI
+xMonitorFromPoint(POINT ptScreenCoords, DWORD dwFlags)
+{
+    if (InitMultipleMonitorStubs())
+        return g_pfnMonitorFromPoint(ptScreenCoords, dwFlags);
+
+    if ((dwFlags & (MONITOR_DEFAULTTOPRIMARY | MONITOR_DEFAULTTONEAREST)) ||
+        ((ptScreenCoords.x >= 0) &&
+        (ptScreenCoords.x < GetSystemMetrics(SM_CXSCREEN)) &&
+        (ptScreenCoords.y >= 0) &&
+        (ptScreenCoords.y < GetSystemMetrics(SM_CYSCREEN))))
+    {
+        return xPRIMARY_MONITOR;
+    }
+
+    return NULL;
+}
+
+HMONITOR WINAPI
+xMonitorFromRect(LPCRECT lprcScreenCoords, DWORD dwFlags)
+{
+    if (InitMultipleMonitorStubs())
+        return g_pfnMonitorFromRect(lprcScreenCoords, dwFlags);
+
+    if ((dwFlags & (MONITOR_DEFAULTTOPRIMARY | MONITOR_DEFAULTTONEAREST)) ||
+        ((lprcScreenCoords->right > 0) &&
+        (lprcScreenCoords->bottom > 0) &&
+        (lprcScreenCoords->left < GetSystemMetrics(SM_CXSCREEN)) &&
+        (lprcScreenCoords->top < GetSystemMetrics(SM_CYSCREEN))))
+    {
+        return xPRIMARY_MONITOR;
+    }
+
+    return NULL;
+}
+
+HMONITOR WINAPI
+xMonitorFromWindow(HWND hWnd, DWORD dwFlags)
+{
+    WINDOWPLACEMENT wp;
+
+    if (InitMultipleMonitorStubs())
+        return g_pfnMonitorFromWindow(hWnd, dwFlags);
+
+    if (dwFlags & (MONITOR_DEFAULTTOPRIMARY | MONITOR_DEFAULTTONEAREST))
+        return xPRIMARY_MONITOR;
+
+    if (IsIconic(hWnd) ?
+            GetWindowPlacement(hWnd, &wp) :
+            GetWindowRect(hWnd, &wp.rcNormalPosition)) {
+
+        return xMonitorFromRect(&wp.rcNormalPosition, dwFlags);
+    }
+
+    return NULL;
+}
+
+BOOL WINAPI
+xGetMonitorInfo(HMONITOR hMonitor, __inout LPMONITORINFO lpMonitorInfo)
+{
+    RECT rcWork;
+
+    if (InitMultipleMonitorStubs())
+    {
+        BOOL f = g_pfnGetMonitorInfo(hMonitor, lpMonitorInfo);
+#ifdef UNICODE
+        if (f && !g_fMultimonPlatformNT && (lpMonitorInfo->cbSize >= sizeof(MONITORINFOEX)))
+        {
+            MultiByteToWideChar(CP_ACP, 0,
+                (LPSTR)((MONITORINFOEX*)lpMonitorInfo)->szDevice, -1,
+                ((MONITORINFOEX*)lpMonitorInfo)->szDevice, (sizeof(((MONITORINFOEX*)lpMonitorInfo)->szDevice)/sizeof(TCHAR)));
+        }
+#endif
+        return f;
+    }
+
+    if ((hMonitor == xPRIMARY_MONITOR) &&
+        lpMonitorInfo &&
+        (lpMonitorInfo->cbSize >= sizeof(MONITORINFO)) &&
+        SystemParametersInfoA(SPI_GETWORKAREA, 0, &rcWork, 0))
+    {
+        lpMonitorInfo->rcMonitor.left = 0;
+        lpMonitorInfo->rcMonitor.top  = 0;
+        lpMonitorInfo->rcMonitor.right  = GetSystemMetrics(SM_CXSCREEN);
+        lpMonitorInfo->rcMonitor.bottom = GetSystemMetrics(SM_CYSCREEN);
+        lpMonitorInfo->rcWork = rcWork;
+        lpMonitorInfo->dwFlags = MONITORINFOF_PRIMARY;
+
+        if (lpMonitorInfo->cbSize >= sizeof(MONITORINFOEX))
+        {
+#ifdef UNICODE
+            MultiByteToWideChar(CP_ACP, 0, "DISPLAY", -1, ((MONITORINFOEX*)lpMonitorInfo)->szDevice, (sizeof(((MONITORINFOEX*)lpMonitorInfo)->szDevice)/sizeof(TCHAR)));
+#else // UNICODE
+#if _MULTIMON_USE_SECURE_CRT
+            strncpy_s(((MONITORINFOEX*)lpMonitorInfo)->szDevice, (sizeof(((MONITORINFOEX*)lpMonitorInfo)->szDevice)/sizeof(TCHAR)), TEXT("DISPLAY"), (sizeof(((MONITORINFOEX*)lpMonitorInfo)->szDevice)/sizeof(TCHAR)) - 1);
+#else
+            lstrcpyn(((MONITORINFOEX*)lpMonitorInfo)->szDevice, TEXT("DISPLAY"), (sizeof(((MONITORINFOEX*)lpMonitorInfo)->szDevice)/sizeof(TCHAR)));
+#endif // _MULTIMON_USE_SECURE_CRT
+#endif // UNICODE
+        }
+
+        return TRUE;
+    }
+
+    return FALSE;
+}
+
+BOOL WINAPI
+xEnumDisplayMonitors(
+        HDC             hdcOptionalForPainting,
+        LPCRECT         lprcEnumMonitorsThatIntersect,
+        MONITORENUMPROC lpfnEnumProc,
+        LPARAM          dwData)
+{
+    RECT rcLimit;
+
+    if (InitMultipleMonitorStubs()) {
+        return g_pfnEnumDisplayMonitors(
+                hdcOptionalForPainting,
+                lprcEnumMonitorsThatIntersect,
+                lpfnEnumProc,
+                dwData);
+    }
+
+    if (!lpfnEnumProc)
+        return FALSE;
+
+    rcLimit.left   = 0;
+    rcLimit.top    = 0;
+    rcLimit.right  = GetSystemMetrics(SM_CXSCREEN);
+    rcLimit.bottom = GetSystemMetrics(SM_CYSCREEN);
+
+    if (hdcOptionalForPainting)
+    {
+        RECT    rcClip;
+        POINT   ptOrg;
+
+        switch (GetClipBox(hdcOptionalForPainting, &rcClip))
+        {
+        default:
+            if (!GetDCOrgEx(hdcOptionalForPainting, &ptOrg))
+                return FALSE;
+
+            OffsetRect(&rcLimit, -ptOrg.x, -ptOrg.y);
+            if (IntersectRect(&rcLimit, &rcLimit, &rcClip) &&
+                (!lprcEnumMonitorsThatIntersect ||
+                     IntersectRect(&rcLimit, &rcLimit, lprcEnumMonitorsThatIntersect))) {
+
+                break;
+            }
+            //fall thru
+        case NULLREGION:
+             return TRUE;
+        case ERROR:
+             return FALSE;
+        }
+    } else {
+        if (    lprcEnumMonitorsThatIntersect &&
+                !IntersectRect(&rcLimit, &rcLimit, lprcEnumMonitorsThatIntersect)) {
+
+            return TRUE;
+        }
+    }
+
+    return lpfnEnumProc(
+            xPRIMARY_MONITOR,
+            hdcOptionalForPainting,
+            &rcLimit,
+            dwData);
+}
+
+BOOL WINAPI
+xEnumDisplayDevices(
+    PVOID Unused,
+    DWORD iDevNum,
+    __inout PDISPLAY_DEVICE lpDisplayDevice,
+    DWORD dwFlags)
+{
+    if (InitMultipleMonitorStubs())
+        return g_pfnEnumDisplayDevices(Unused, iDevNum, lpDisplayDevice, dwFlags);
+
+    if (Unused != NULL)
+        return FALSE;
+
+    if (iDevNum != 0)
+        return FALSE;
+
+    if (lpDisplayDevice == NULL || lpDisplayDevice->cb < sizeof(DISPLAY_DEVICE))
+        return FALSE;
+
+#ifdef UNICODE
+    MultiByteToWideChar(CP_ACP, 0, "DISPLAY", -1, lpDisplayDevice->DeviceName, (sizeof(lpDisplayDevice->DeviceName)/sizeof(TCHAR)));
+    MultiByteToWideChar(CP_ACP, 0, "DISPLAY", -1, lpDisplayDevice->DeviceString, (sizeof(lpDisplayDevice->DeviceString)/sizeof(TCHAR)));
+#else // UNICODE
+#if _MULTIMON_USE_SECURE_CRT
+    strncpy_s((LPTSTR)lpDisplayDevice->DeviceName, (sizeof(lpDisplayDevice->DeviceName)/sizeof(TCHAR)), TEXT("DISPLAY"), (sizeof(lpDisplayDevice->DeviceName)/sizeof(TCHAR)) - 1);
+    strncpy_s((LPTSTR)lpDisplayDevice->DeviceString, (sizeof(lpDisplayDevice->DeviceString)/sizeof(TCHAR)), TEXT("DISPLAY"), (sizeof(lpDisplayDevice->DeviceName)/sizeof(TCHAR)) - 1);
+#else
+    lstrcpyn((LPTSTR)lpDisplayDevice->DeviceName,   TEXT("DISPLAY"), (sizeof(lpDisplayDevice->DeviceName)/sizeof(TCHAR)));
+    lstrcpyn((LPTSTR)lpDisplayDevice->DeviceString, TEXT("DISPLAY"), (sizeof(lpDisplayDevice->DeviceString)/sizeof(TCHAR)));
+#endif // _MULTIMON_USE_SECURE_CRT
+#endif // UNICODE
+
+    lpDisplayDevice->StateFlags = DISPLAY_DEVICE_ATTACHED_TO_DESKTOP | DISPLAY_DEVICE_PRIMARY_DEVICE;
+
+    return TRUE;
+}
+
+#undef xPRIMARY_MONITOR
+#undef COMPILE_MULTIMON_STUBS
+
+#else   // COMPILE_MULTIMON_STUBS
+
+extern int  WINAPI xGetSystemMetrics(int);
+extern HMONITOR WINAPI xMonitorFromWindow(HWND, DWORD);
+extern HMONITOR WINAPI xMonitorFromRect(LPCRECT, DWORD);
+extern HMONITOR WINAPI xMonitorFromPoint(POINT, DWORD);
+extern BOOL WINAPI xGetMonitorInfo(HMONITOR, LPMONITORINFO);
+extern BOOL WINAPI xEnumDisplayMonitors(HDC, LPCRECT, MONITORENUMPROC, LPARAM);
+extern BOOL WINAPI xEnumDisplayDevices(PVOID, DWORD, PDISPLAY_DEVICE, DWORD);
+
+#endif  // COMPILE_MULTIMON_STUBS
+
+//
+// build defines that replace the regular APIs with our versions
+//
+#define GetSystemMetrics    xGetSystemMetrics
+#define MonitorFromWindow   xMonitorFromWindow
+#define MonitorFromRect     xMonitorFromRect
+#define MonitorFromPoint    xMonitorFromPoint
+#define GetMonitorInfo      xGetMonitorInfo
+#define EnumDisplayMonitors xEnumDisplayMonitors
+#define EnumDisplayDevices  xEnumDisplayDevices
+
+#ifdef __cplusplus
+}
+#endif  // __cplusplus
+
+

3rdparty/include/dshow/audevcod.h

@@ -9,20 +9,20 @@ extern "C" {
 #endif
 
 typedef enum _tagSND_DEVICE_ERROR {
-	SNDDEV_ERROR_Open = 1,       
-	SNDDEV_ERROR_Close = 2,       
-	SNDDEV_ERROR_GetCaps = 3,       
-	SNDDEV_ERROR_PrepareHeader = 4,
-	SNDDEV_ERROR_UnprepareHeader = 5,       
-	SNDDEV_ERROR_Reset = 6,
-	SNDDEV_ERROR_Restart = 7,       
-	SNDDEV_ERROR_GetPosition = 8,       
-	SNDDEV_ERROR_Write = 9,
-	SNDDEV_ERROR_Pause = 10,       
-	SNDDEV_ERROR_Stop = 11,       
-	SNDDEV_ERROR_Start = 12,       
-	SNDDEV_ERROR_AddBuffer = 13,
-	SNDDEV_ERROR_Query = 14
+    SNDDEV_ERROR_Open = 1,
+    SNDDEV_ERROR_Close = 2,
+    SNDDEV_ERROR_GetCaps = 3,
+    SNDDEV_ERROR_PrepareHeader = 4,
+    SNDDEV_ERROR_UnprepareHeader = 5,
+    SNDDEV_ERROR_Reset = 6,
+    SNDDEV_ERROR_Restart = 7,
+    SNDDEV_ERROR_GetPosition = 8,
+    SNDDEV_ERROR_Write = 9,
+    SNDDEV_ERROR_Pause = 10,
+    SNDDEV_ERROR_Stop = 11,
+    SNDDEV_ERROR_Start = 12,
+    SNDDEV_ERROR_AddBuffer = 13,
+    SNDDEV_ERROR_Query = 14
 } SNDDEV_ERR;
 
 #ifdef __cplusplus

3rdparty/include/dshow/bdatypes.h

@@ -10,20 +10,20 @@ extern "C" {
 
 /*--- DirectShow Reference - DirectShow Enumerated Types */
 typedef enum {
-	MEDIA_TRANSPORT_PACKET,
-	MEDIA_ELEMENTARY_STREAM,
-	MEDIA_MPEG2_PSI,
-	MEDIA_TRANSPORT_PAYLOAD
+    MEDIA_TRANSPORT_PACKET,
+    MEDIA_ELEMENTARY_STREAM,
+    MEDIA_MPEG2_PSI,
+    MEDIA_TRANSPORT_PAYLOAD
 } MEDIA_SAMPLE_CONTENT;
 /*--- DirectShow Reference - DirectShow Structures */
 typedef struct {
-	DWORD dwOffset;
-	DWORD dwPacketLength;
-	DWORD dwStride;
+    DWORD dwOffset;
+    DWORD dwPacketLength;
+    DWORD dwStride;
 } MPEG2_TRANSPORT_STRIDE;
 typedef struct {
-	ULONG ulPID;
-	MEDIA_SAMPLE_CONTENT MediaSampleContent ;
+    ULONG ulPID;
+    MEDIA_SAMPLE_CONTENT MediaSampleContent ;
 } PID_MAP;
 
 #ifdef __cplusplus

3rdparty/include/dshow/ddraw.h

@@ -322,7 +322,7 @@ typedef struct IDirectDrawGammaControl *LPDIRECTDRAWGAMMACONTROL;
 #define DDSCAPS_OPTIMIZED		0x80000000
 
 typedef struct _DDSCAPS {
-	DWORD	dwCaps;	/* capabilities of surface wanted */
+    DWORD	dwCaps;	/* capabilities of surface wanted */
 } DDSCAPS,*LPDDSCAPS;
 
 /* DDSCAPS2.dwCaps2 */
@@ -368,21 +368,21 @@ typedef struct _DDSCAPS {
 #define DDSCAPS2_STEREOSURFACELEFT      0x00080000
 
 typedef struct _DDSCAPS2 {
-	DWORD	dwCaps;	/* capabilities of surface wanted */
-	DWORD   dwCaps2; /* additional capabilities */
-	DWORD   dwCaps3; /* reserved capabilities */
-	__extension__ union {
-	  DWORD dwCaps4; /* low word is the depth for a volume texture */
-	  DWORD dwVolumeDepth;
-	} DUMMYUNIONNAME1;
+    DWORD	dwCaps;	/* capabilities of surface wanted */
+    DWORD   dwCaps2; /* additional capabilities */
+    DWORD   dwCaps3; /* reserved capabilities */
+    __extension__ union {
+      DWORD dwCaps4; /* low word is the depth for a volume texture */
+      DWORD dwVolumeDepth;
+    } DUMMYUNIONNAME1;
 } DDSCAPS2,*LPDDSCAPS2;
 
 typedef struct _DDSCAPSEX {
     DWORD	dwCaps2;
     DWORD	dwCaps3;
     __extension__ union {
-	DWORD	dwCaps4;
-	DWORD	dwVolumeDepth;
+    DWORD	dwCaps4;
+    DWORD	dwVolumeDepth;
     } DUMMYUNIONNAME1;
 } DDSCAPSEX,*LPDDSCAPSEX;
 
@@ -712,12 +712,12 @@ typedef DDCAPS *LPDDCAPS;
 
 typedef struct _DDCOLORKEY
 {
-	DWORD	dwColorSpaceLowValue;/* low boundary of color space that is to
+    DWORD	dwColorSpaceLowValue;/* low boundary of color space that is to
                                       * be treated as Color Key, inclusive
-				      */
-	DWORD	dwColorSpaceHighValue;/* high boundary of color space that is
+                      */
+    DWORD	dwColorSpaceHighValue;/* high boundary of color space that is
                                        * to be treated as Color Key, inclusive
-				       */
+                       */
 } DDCOLORKEY,*LPDDCOLORKEY;
 
 /* ddCKEYCAPS bits */
@@ -746,40 +746,40 @@ typedef struct _DDPIXELFORMAT {
     DWORD	dwFlags;                /* 4: pixel format flags */
     DWORD	dwFourCC;               /* 8: (FOURCC code) */
     __extension__ union {
-	DWORD	dwRGBBitCount;          /* C: how many bits per pixel */
-	DWORD	dwYUVBitCount;          /* C: how many bits per pixel */
-	DWORD	dwZBufferBitDepth;      /* C: how many bits for z buffers */
-	DWORD	dwAlphaBitDepth;        /* C: how many bits for alpha channels*/
-	DWORD	dwLuminanceBitCount;
-	DWORD	dwBumpBitCount;
+    DWORD	dwRGBBitCount;          /* C: how many bits per pixel */
+    DWORD	dwYUVBitCount;          /* C: how many bits per pixel */
+    DWORD	dwZBufferBitDepth;      /* C: how many bits for z buffers */
+    DWORD	dwAlphaBitDepth;        /* C: how many bits for alpha channels*/
+    DWORD	dwLuminanceBitCount;
+    DWORD	dwBumpBitCount;
     } DUMMYUNIONNAME1;
     __extension__ union {
-	DWORD	dwRBitMask;             /* 10: mask for red bit*/
-	DWORD	dwYBitMask;             /* 10: mask for Y bits*/
-	DWORD	dwStencilBitDepth;
-	DWORD	dwLuminanceBitMask;
-	DWORD	dwBumpDuBitMask;
+    DWORD	dwRBitMask;             /* 10: mask for red bit*/
+    DWORD	dwYBitMask;             /* 10: mask for Y bits*/
+    DWORD	dwStencilBitDepth;
+    DWORD	dwLuminanceBitMask;
+    DWORD	dwBumpDuBitMask;
     } DUMMYUNIONNAME2;
     __extension__ union {
-	DWORD	dwGBitMask;             /* 14: mask for green bits*/
-	DWORD	dwUBitMask;             /* 14: mask for U bits*/
-	DWORD	dwZBitMask;
-	DWORD	dwBumpDvBitMask;
+    DWORD	dwGBitMask;             /* 14: mask for green bits*/
+    DWORD	dwUBitMask;             /* 14: mask for U bits*/
+    DWORD	dwZBitMask;
+    DWORD	dwBumpDvBitMask;
     } DUMMYUNIONNAME3;
     __extension__ union {
-	DWORD   dwBBitMask;             /* 18: mask for blue bits*/
-	DWORD   dwVBitMask;             /* 18: mask for V bits*/
-	DWORD	dwStencilBitMask;
-	DWORD	dwBumpLuminanceBitMask;
+    DWORD   dwBBitMask;             /* 18: mask for blue bits*/
+    DWORD   dwVBitMask;             /* 18: mask for V bits*/
+    DWORD	dwStencilBitMask;
+    DWORD	dwBumpLuminanceBitMask;
     } DUMMYUNIONNAME4;
     __extension__ union {
-    	DWORD	dwRGBAlphaBitMask;	/* 1C: mask for alpha channel */
-    	DWORD	dwYUVAlphaBitMask;	/* 1C: mask for alpha channel */
-	DWORD	dwLuminanceAlphaBitMask;
-	DWORD	dwRGBZBitMask;		/* 1C: mask for Z channel */
-	DWORD	dwYUVZBitMask;		/* 1C: mask for Z channel */
+        DWORD	dwRGBAlphaBitMask;	/* 1C: mask for alpha channel */
+        DWORD	dwYUVAlphaBitMask;	/* 1C: mask for alpha channel */
+    DWORD	dwLuminanceAlphaBitMask;
+    DWORD	dwRGBZBitMask;		/* 1C: mask for Z channel */
+    DWORD	dwYUVZBitMask;		/* 1C: mask for Z channel */
     } DUMMYUNIONNAME5;
-    					/* 20: next structure */
+                        /* 20: next structure */
 } DDPIXELFORMAT,*LPDDPIXELFORMAT;
 
 #ifndef MAKEFOURCC
@@ -980,79 +980,79 @@ typedef struct _DDPIXELFORMAT {
 
 typedef struct _DDSURFACEDESC
 {
-	DWORD	dwSize;		/* 0: size of the DDSURFACEDESC structure*/
-	DWORD	dwFlags;	/* 4: determines what fields are valid*/
-	DWORD	dwHeight;	/* 8: height of surface to be created*/
-	DWORD	dwWidth;	/* C: width of input surface*/
-	__extension__ union {
-		LONG	lPitch;	/* 10: distance to start of next line (return value only)*/
-		DWORD	dwLinearSize;
-	} DUMMYUNIONNAME1;
-	DWORD	dwBackBufferCount;/* 14: number of back buffers requested*/
-	__extension__ union {
-		DWORD	dwMipMapCount;/* 18:number of mip-map levels requested*/
-		DWORD	dwZBufferBitDepth;/*18: depth of Z buffer requested*/
-		DWORD	dwRefreshRate;/* 18:refresh rate (used when display mode is described)*/
-	} DUMMYUNIONNAME2;
-	DWORD	dwAlphaBitDepth;/* 1C:depth of alpha buffer requested*/
-	DWORD	dwReserved;	/* 20:reserved*/
-	LPVOID	lpSurface;	/* 24:pointer to the associated surface memory*/
-	DDCOLORKEY	ddckCKDestOverlay;/* 28: CK for dest overlay use*/
-	DDCOLORKEY	ddckCKDestBlt;	/* 30: CK for destination blt use*/
-	DDCOLORKEY	ddckCKSrcOverlay;/* 38: CK for source overlay use*/
-	DDCOLORKEY	ddckCKSrcBlt;	/* 40: CK for source blt use*/
-	DDPIXELFORMAT	ddpfPixelFormat;/* 48: pixel format description of the surface*/
-	DDSCAPS		ddsCaps;	/* 68: direct draw surface caps */
+    DWORD	dwSize;		/* 0: size of the DDSURFACEDESC structure*/
+    DWORD	dwFlags;	/* 4: determines what fields are valid*/
+    DWORD	dwHeight;	/* 8: height of surface to be created*/
+    DWORD	dwWidth;	/* C: width of input surface*/
+    __extension__ union {
+        LONG	lPitch;	/* 10: distance to start of next line (return value only)*/
+        DWORD	dwLinearSize;
+    } DUMMYUNIONNAME1;
+    DWORD	dwBackBufferCount;/* 14: number of back buffers requested*/
+    __extension__ union {
+        DWORD	dwMipMapCount;/* 18:number of mip-map levels requested*/
+        DWORD	dwZBufferBitDepth;/*18: depth of Z buffer requested*/
+        DWORD	dwRefreshRate;/* 18:refresh rate (used when display mode is described)*/
+    } DUMMYUNIONNAME2;
+    DWORD	dwAlphaBitDepth;/* 1C:depth of alpha buffer requested*/
+    DWORD	dwReserved;	/* 20:reserved*/
+    LPVOID	lpSurface;	/* 24:pointer to the associated surface memory*/
+    DDCOLORKEY	ddckCKDestOverlay;/* 28: CK for dest overlay use*/
+    DDCOLORKEY	ddckCKDestBlt;	/* 30: CK for destination blt use*/
+    DDCOLORKEY	ddckCKSrcOverlay;/* 38: CK for source overlay use*/
+    DDCOLORKEY	ddckCKSrcBlt;	/* 40: CK for source blt use*/
+    DDPIXELFORMAT	ddpfPixelFormat;/* 48: pixel format description of the surface*/
+    DDSCAPS		ddsCaps;	/* 68: direct draw surface caps */
 } DDSURFACEDESC,*LPDDSURFACEDESC;
 
 typedef struct _DDSURFACEDESC2
 {
-	DWORD	dwSize;		/* 0: size of the DDSURFACEDESC2 structure*/
-	DWORD	dwFlags;	/* 4: determines what fields are valid*/
-	DWORD	dwHeight;	/* 8: height of surface to be created*/
-	DWORD	dwWidth;	/* C: width of input surface*/
-	__extension__ union {
-		LONG	lPitch;	      /*10: distance to start of next line (return value only)*/
-		DWORD   dwLinearSize; /*10: formless late-allocated optimized surface size */
-	} DUMMYUNIONNAME1;
-	DWORD	dwBackBufferCount;/* 14: number of back buffers requested*/
-	__extension__ union {
-		DWORD	dwMipMapCount;/* 18:number of mip-map levels requested*/
-		DWORD	dwRefreshRate;/* 18:refresh rate (used when display mode is described)*/
-		DWORD   dwSrcVBHandle;/* 18:source used in VB::Optimize */
-	} DUMMYUNIONNAME2;
-	DWORD	dwAlphaBitDepth;/* 1C:depth of alpha buffer requested*/
-	DWORD	dwReserved;	/* 20:reserved*/
-	LPVOID	lpSurface;	/* 24:pointer to the associated surface memory*/
-	__extension__ union {
-		DDCOLORKEY	ddckCKDestOverlay; /* 28: CK for dest overlay use*/
-		DWORD 		dwEmptyFaceColor;  /* 28: color for empty cubemap faces */
-	} DUMMYUNIONNAME3;
-	DDCOLORKEY	ddckCKDestBlt;	/* 30: CK for destination blt use*/
-	DDCOLORKEY	ddckCKSrcOverlay;/* 38: CK for source overlay use*/
-	DDCOLORKEY	ddckCKSrcBlt;	/* 40: CK for source blt use*/
+    DWORD	dwSize;		/* 0: size of the DDSURFACEDESC2 structure*/
+    DWORD	dwFlags;	/* 4: determines what fields are valid*/
+    DWORD	dwHeight;	/* 8: height of surface to be created*/
+    DWORD	dwWidth;	/* C: width of input surface*/
+    __extension__ union {
+        LONG	lPitch;	      /*10: distance to start of next line (return value only)*/
+        DWORD   dwLinearSize; /*10: formless late-allocated optimized surface size */
+    } DUMMYUNIONNAME1;
+    DWORD	dwBackBufferCount;/* 14: number of back buffers requested*/
+    __extension__ union {
+        DWORD	dwMipMapCount;/* 18:number of mip-map levels requested*/
+        DWORD	dwRefreshRate;/* 18:refresh rate (used when display mode is described)*/
+        DWORD   dwSrcVBHandle;/* 18:source used in VB::Optimize */
+    } DUMMYUNIONNAME2;
+    DWORD	dwAlphaBitDepth;/* 1C:depth of alpha buffer requested*/
+    DWORD	dwReserved;	/* 20:reserved*/
+    LPVOID	lpSurface;	/* 24:pointer to the associated surface memory*/
+    __extension__ union {
+        DDCOLORKEY	ddckCKDestOverlay; /* 28: CK for dest overlay use*/
+        DWORD 		dwEmptyFaceColor;  /* 28: color for empty cubemap faces */
+    } DUMMYUNIONNAME3;
+    DDCOLORKEY	ddckCKDestBlt;	/* 30: CK for destination blt use*/
+    DDCOLORKEY	ddckCKSrcOverlay;/* 38: CK for source overlay use*/
+    DDCOLORKEY	ddckCKSrcBlt;	/* 40: CK for source blt use*/
 
-	__extension__ union {
-		DDPIXELFORMAT	ddpfPixelFormat;/* 48: pixel format description of the surface*/
-		DWORD 		dwFVF;	/* 48: vertex format description of vertex buffers */
-	} DUMMYUNIONNAME4;
-	DDSCAPS2	ddsCaps;  /* 68: DDraw surface caps */
-	DWORD		dwTextureStage; /* 78: stage in multitexture cascade */
+    __extension__ union {
+        DDPIXELFORMAT	ddpfPixelFormat;/* 48: pixel format description of the surface*/
+        DWORD 		dwFVF;	/* 48: vertex format description of vertex buffers */
+    } DUMMYUNIONNAME4;
+    DDSCAPS2	ddsCaps;  /* 68: DDraw surface caps */
+    DWORD		dwTextureStage; /* 78: stage in multitexture cascade */
 } DDSURFACEDESC2,*LPDDSURFACEDESC2;
 
 
 typedef struct _DDARGB {
-	BYTE	blue;
-	BYTE	green;
-	BYTE	red;
-	BYTE	alpha;
+    BYTE	blue;
+    BYTE	green;
+    BYTE	red;
+    BYTE	alpha;
 } DDARGB, *LPDDARGB;
 
 typedef struct _DDRGBA {
-	BYTE	red;
-	BYTE	green;
-	BYTE	blue;
-	BYTE	alpha;
+    BYTE	red;
+    BYTE	green;
+    BYTE	blue;
+    BYTE	alpha;
 } DDRGBA, *LPDDRGBA;
 
 
@@ -1066,22 +1066,22 @@ typedef struct _DDRGBA {
 #define DDCOLOR_COLORENABLE	0x00000040
 
 typedef struct {
-	DWORD	dwSize;
-	DWORD	dwFlags;
-	LONG	lBrightness;
-	LONG	lContrast;
-	LONG	lHue;
-	LONG	lSaturation;
-	LONG	lSharpness;
-	LONG	lGamma;
-	LONG	lColorEnable;
-	DWORD	dwReserved1;
+    DWORD	dwSize;
+    DWORD	dwFlags;
+    LONG	lBrightness;
+    LONG	lContrast;
+    LONG	lHue;
+    LONG	lSaturation;
+    LONG	lSharpness;
+    LONG	lGamma;
+    LONG	lColorEnable;
+    DWORD	dwReserved1;
 } DDCOLORCONTROL,*LPDDCOLORCONTROL;
 
 typedef struct {
-	WORD	red[256];
-	WORD	green[256];
-	WORD	blue[256];
+    WORD	red[256];
+    WORD	green[256];
+    WORD	blue[256];
 } DDGAMMARAMP,*LPDDGAMMARAMP;
 
 typedef BOOL (CALLBACK *LPDDENUMCALLBACKA)(GUID *, LPSTR, LPSTR, LPVOID);
@@ -1161,7 +1161,7 @@ typedef struct _DDBLTFX
     {
         DWORD   dwFillColor;                    /* color in RGB or Palettized */
         DWORD   dwFillDepth;                    /* depth value for z-buffer */
-	DWORD   dwFillPixel;			/* pixel val for RGBA or RGBZ */
+    DWORD   dwFillPixel;			/* pixel val for RGBA or RGBZ */
         LPDIRECTDRAWSURFACE lpDDSPattern;       /* Surface to use as pattern */
     } DUMMYUNIONNAME5;
     DDCOLORKEY  ddckDestColorkey;               /* DestColorkey override */

3rdparty/include/dshow/dsound.h

@@ -932,14 +932,14 @@ DECLARE_INTERFACE_(IDirectSoundNotify,IUnknown)
 #define DS3D_DEFAULTCONEOUTSIDEVOLUME   DSBVOLUME_MAX
 
 typedef struct _DS3DLISTENER {
-	DWORD				dwSize;
-	D3DVECTOR			vPosition;
-	D3DVECTOR			vVelocity;
-	D3DVECTOR			vOrientFront;
-	D3DVECTOR			vOrientTop;
-	D3DVALUE			flDistanceFactor;
-	D3DVALUE			flRolloffFactor;
-	D3DVALUE			flDopplerFactor;
+    DWORD				dwSize;
+    D3DVECTOR			vPosition;
+    D3DVECTOR			vVelocity;
+    D3DVECTOR			vOrientFront;
+    D3DVECTOR			vOrientTop;
+    D3DVALUE			flDistanceFactor;
+    D3DVALUE			flRolloffFactor;
+    D3DVALUE			flDopplerFactor;
 } DS3DLISTENER, *LPDS3DLISTENER;
 
 typedef const DS3DLISTENER *LPCDS3DLISTENER;
@@ -1019,16 +1019,16 @@ DECLARE_INTERFACE_(IDirectSound3DListener,IUnknown)
  * IDirectSound3DBuffer interface
  */
 typedef struct  _DS3DBUFFER {
-	DWORD				dwSize;
-	D3DVECTOR			vPosition;
-	D3DVECTOR			vVelocity;
-	DWORD				dwInsideConeAngle;
-	DWORD				dwOutsideConeAngle;
-	D3DVECTOR			vConeOrientation;
-	LONG				lConeOutsideVolume;
-	D3DVALUE			flMinDistance;
-	D3DVALUE			flMaxDistance;
-	DWORD				dwMode;
+    DWORD				dwSize;
+    D3DVECTOR			vPosition;
+    D3DVECTOR			vVelocity;
+    DWORD				dwInsideConeAngle;
+    DWORD				dwOutsideConeAngle;
+    D3DVECTOR			vConeOrientation;
+    LONG				lConeOutsideVolume;
+    D3DVALUE			flMinDistance;
+    D3DVALUE			flMaxDistance;
+    DWORD				dwMode;
 } DS3DBUFFER, *LPDS3DBUFFER;
 
 typedef const DS3DBUFFER *LPCDS3DBUFFER;

3rdparty/include/dshow/dvdmedia.h

@@ -24,24 +24,24 @@
 #define AMCONTROL_PAD_TO_16x9 0x00000004
 
 enum AM_MPEG2Level {
-	AM_MPEG2Level_Low = 1,
-	AM_MPEG2Level_Main,
-	AM_MPEG2Level_High1440,
-	AM_MPEG2Level_High
+    AM_MPEG2Level_Low = 1,
+    AM_MPEG2Level_Main,
+    AM_MPEG2Level_High1440,
+    AM_MPEG2Level_High
 };
 enum AM_MPEG2Profile {
-	AM_MPEG2Profile_Simple = 1,
-	AM_MPEG2Profile_Main,
-	AM_MPEG2Profile_SNRScalable,
-	AM_MPEG2Profile_SpatiallyScalable,
-	AM_MPEG2Profile_High
+    AM_MPEG2Profile_Simple = 1,
+    AM_MPEG2Profile_Main,
+    AM_MPEG2Profile_SNRScalable,
+    AM_MPEG2Profile_SpatiallyScalable,
+    AM_MPEG2Profile_High
 };
 typedef enum {
-	AM_RATE_ChangeRate = 1,
-	AM_RATE_FullDataRateMax = 2,
-	AM_RATE_ReverseDecode = 3,
-	AM_RATE_DecoderPosition = 4,
-	AM_RATE_DecoderVersion = 5
+    AM_RATE_ChangeRate = 1,
+    AM_RATE_FullDataRateMax = 2,
+    AM_RATE_ReverseDecode = 3,
+    AM_RATE_DecoderPosition = 4,
+    AM_RATE_DecoderVersion = 5
 } AM_PROPERTY_DVD_RATE_CHANGE;
 
 typedef struct tagVIDEOINFOHEADER2 {

3rdparty/include/dshow/evcode.h

@@ -58,8 +58,8 @@ extern "C" {
 #define EC_USER 0x8000
 /*--- DirectShow Reference - DirectShow Structures */
 typedef struct {
-	HRESULT hrStatus;
-	void   *pData;
+    HRESULT hrStatus;
+    void   *pData;
 } AM_WMT_EVENT_DATA;
 
 #ifdef __cplusplus

3rdparty/include/dshow/ksuuids.h

@@ -5,187 +5,187 @@
  */
 
 OUR_GUID_ENTRY(MEDIATYPE_MPEG2_PACK,
-		0x36523B13,0x8EE5,0x11d1,0x8C,0xA3,0x00,0x60,0xB0,0x57,0x66,0x4A)
+        0x36523B13,0x8EE5,0x11d1,0x8C,0xA3,0x00,0x60,0xB0,0x57,0x66,0x4A)
 
 OUR_GUID_ENTRY(MEDIATYPE_MPEG2_PES,
-		0xe06d8020,0xdb46,0x11cf,0xb4,0xd1,0x00,0x80,0x5f,0x6c,0xbb,0xea)
+        0xe06d8020,0xdb46,0x11cf,0xb4,0xd1,0x00,0x80,0x5f,0x6c,0xbb,0xea)
 
 OUR_GUID_ENTRY(MEDIASUBTYPE_MPEG2_WMDRM_TRANSPORT,
-		0x18BEC4EA,0x4676,0x450e,0xB4,0x78,0x0C,0xD8,0x4C,0x54,0xB3,0x27)
+        0x18BEC4EA,0x4676,0x450e,0xB4,0x78,0x0C,0xD8,0x4C,0x54,0xB3,0x27)
 
 OUR_GUID_ENTRY(MEDIASUBTYPE_MPEG2_VIDEO,
-		0xe06d8026,0xdb46,0x11cf,0xb4,0xd1,0x00,0x80,0x5f,0x6c,0xbb,0xea)
+        0xe06d8026,0xdb46,0x11cf,0xb4,0xd1,0x00,0x80,0x5f,0x6c,0xbb,0xea)
 
 OUR_GUID_ENTRY(FORMAT_MPEG2_VIDEO,
-		0xe06d80e3,0xdb46,0x11cf,0xb4,0xd1,0x00,0x80,0x5f,0x6c,0xbb,0xea)
+        0xe06d80e3,0xdb46,0x11cf,0xb4,0xd1,0x00,0x80,0x5f,0x6c,0xbb,0xea)
 
 OUR_GUID_ENTRY(FORMAT_VIDEOINFO2,
-		0xf72a76A0L,0xeb0a,0x11d0,0xac,0xe4,0x0,0x0,0xc0,0xcc,0x16,0xba)
+        0xf72a76A0L,0xeb0a,0x11d0,0xac,0xe4,0x0,0x0,0xc0,0xcc,0x16,0xba)
 
 OUR_GUID_ENTRY(MEDIASUBTYPE_MPEG2_PROGRAM,
-		0xe06d8022,0xdb46,0x11cf,0xb4,0xd1,0x00,0x80,0x05f,0x6c,0xbb,0xea)
+        0xe06d8022,0xdb46,0x11cf,0xb4,0xd1,0x00,0x80,0x05f,0x6c,0xbb,0xea)
 
 OUR_GUID_ENTRY(MEDIASUBTYPE_MPEG2_TRANSPORT,
-		0xe06d8023,0xdb46,0x11cf,0xb4,0xd1,0x00,0x80,0x05f,0x6c,0xbb,0xea)
+        0xe06d8023,0xdb46,0x11cf,0xb4,0xd1,0x00,0x80,0x05f,0x6c,0xbb,0xea)
 
 OUR_GUID_ENTRY(MEDIASUBTYPE_MPEG2_AUDIO,
-		0xe06d802b,0xdb46,0x11cf,0xb4,0xd1,0x00,0x80,0x05f,0x6c,0xbb,0xea)
+        0xe06d802b,0xdb46,0x11cf,0xb4,0xd1,0x00,0x80,0x05f,0x6c,0xbb,0xea)
 
 OUR_GUID_ENTRY(MEDIASUBTYPE_DOLBY_AC3,
-		0xe06d802c,0xdb46,0x11cf,0xb4,0xd1,0x00,0x80,0x05f,0x6c,0xbb,0xea)
+        0xe06d802c,0xdb46,0x11cf,0xb4,0xd1,0x00,0x80,0x05f,0x6c,0xbb,0xea)
 
 OUR_GUID_ENTRY(MEDIASUBTYPE_DVD_SUBPICTURE,
-		0xe06d802d,0xdb46,0x11cf,0xb4,0xd1,0x00,0x80,0x05f,0x6c,0xbb,0xea)
+        0xe06d802d,0xdb46,0x11cf,0xb4,0xd1,0x00,0x80,0x05f,0x6c,0xbb,0xea)
 
 OUR_GUID_ENTRY(MEDIASUBTYPE_DVD_LPCM_AUDIO,
-		0xe06d8032,0xdb46,0x11cf,0xb4,0xd1,0x00,0x80,0x05f,0x6c,0xbb,0xea)
+        0xe06d8032,0xdb46,0x11cf,0xb4,0xd1,0x00,0x80,0x05f,0x6c,0xbb,0xea)
 
 OUR_GUID_ENTRY(MEDIATYPE_DVD_ENCRYPTED_PACK,
-		0xed0b916a,0x044d,0x11d1,0xaa,0x78,0x00,0xc0,0x04f,0xc3,0x1d,0x60)
+        0xed0b916a,0x044d,0x11d1,0xaa,0x78,0x00,0xc0,0x04f,0xc3,0x1d,0x60)
 
 OUR_GUID_ENTRY(MEDIATYPE_DVD_NAVIGATION,
-		0xe06d802e,0xdb46,0x11cf,0xb4,0xd1,0x00,0x80,0x05f,0x6c,0xbb,0xea)
+        0xe06d802e,0xdb46,0x11cf,0xb4,0xd1,0x00,0x80,0x05f,0x6c,0xbb,0xea)
 
 OUR_GUID_ENTRY(MEDIASUBTYPE_DVD_NAVIGATION_PCI,
-		0xe06d802f,0xdb46,0x11cf,0xb4,0xd1,0x00,0x80,0x05f,0x6c,0xbb,0xea)
+        0xe06d802f,0xdb46,0x11cf,0xb4,0xd1,0x00,0x80,0x05f,0x6c,0xbb,0xea)
 
 OUR_GUID_ENTRY(MEDIASUBTYPE_DVD_NAVIGATION_DSI,
-		0xe06d8030,0xdb46,0x11cf,0xb4,0xd1,0x00,0x80,0x05f,0x6c,0xbb,0xea)
+        0xe06d8030,0xdb46,0x11cf,0xb4,0xd1,0x00,0x80,0x05f,0x6c,0xbb,0xea)
 
 OUR_GUID_ENTRY(MEDIASUBTYPE_DVD_NAVIGATION_PROVIDER,
-		0xe06d8031,0xdb46,0x11cf,0xb4,0xd1,0x00,0x80,0x05f,0x6c,0xbb,0xea)
+        0xe06d8031,0xdb46,0x11cf,0xb4,0xd1,0x00,0x80,0x05f,0x6c,0xbb,0xea)
 
 OUR_GUID_ENTRY(FORMAT_MPEG2Video,
-		0xe06d80e3,0xdb46,0x11cf,0xb4,0xd1,0x00,0x80,0x05f,0x6c,0xbb,0xea)
+        0xe06d80e3,0xdb46,0x11cf,0xb4,0xd1,0x00,0x80,0x05f,0x6c,0xbb,0xea)
 
 OUR_GUID_ENTRY(FORMAT_DolbyAC3,
-		0xe06d80e4,0xdb46,0x11cf,0xb4,0xd1,0x00,0x80,0x05f,0x6c,0xbb,0xea)
+        0xe06d80e4,0xdb46,0x11cf,0xb4,0xd1,0x00,0x80,0x05f,0x6c,0xbb,0xea)
 
 OUR_GUID_ENTRY(FORMAT_MPEG2Audio,
-		0xe06d80e5,0xdb46,0x11cf,0xb4,0xd1,0x00,0x80,0x05f,0x6c,0xbb,0xea)
+        0xe06d80e5,0xdb46,0x11cf,0xb4,0xd1,0x00,0x80,0x05f,0x6c,0xbb,0xea)
 
 OUR_GUID_ENTRY(FORMAT_DVD_LPCMAudio,
-		0xe06d80e6,0xdb46,0x11cf,0xb4,0xd1,0x00,0x80,0x05f,0x6c,0xbb,0xea)
+        0xe06d80e6,0xdb46,0x11cf,0xb4,0xd1,0x00,0x80,0x05f,0x6c,0xbb,0xea)
 
 OUR_GUID_ENTRY(AM_KSPROPSETID_AC3,
-		0xBFABE720,0x6E1F,0x11D0,0xBC,0xF2,0x44,0x45,0x53,0x54,0x00,0x00)
+        0xBFABE720,0x6E1F,0x11D0,0xBC,0xF2,0x44,0x45,0x53,0x54,0x00,0x00)
 
 OUR_GUID_ENTRY(AM_KSPROPSETID_DvdSubPic,
-		0xac390460,0x43af,0x11d0,0xbd,0x6a,0x00,0x35,0x05,0xc1,0x03,0xa9)
+        0xac390460,0x43af,0x11d0,0xbd,0x6a,0x00,0x35,0x05,0xc1,0x03,0xa9)
 
 OUR_GUID_ENTRY(AM_KSPROPSETID_CopyProt,
-		0x0E8A0A40,0x6AEF,0x11D0,0x9E,0xD0,0x00,0xA0,0x24,0xCA,0x19,0xB3)
+        0x0E8A0A40,0x6AEF,0x11D0,0x9E,0xD0,0x00,0xA0,0x24,0xCA,0x19,0xB3)
 
 OUR_GUID_ENTRY(AM_KSPROPSETID_TSRateChange,
-		0xa503c5c0,0x1d1d,0x11d1,0xad,0x80,0x44,0x45,0x53,0x54,0x0,0x0)
+        0xa503c5c0,0x1d1d,0x11d1,0xad,0x80,0x44,0x45,0x53,0x54,0x0,0x0)
 
 OUR_GUID_ENTRY(AM_KSPROPSETID_MPEG4_MediaType_Attributes,
-		0xff6c4bfa,0x7a9,0x4c7b,0xa2,0x37,0x67,0x2f,0x9d,0x68,0x6,0x5f)
+        0xff6c4bfa,0x7a9,0x4c7b,0xa2,0x37,0x67,0x2f,0x9d,0x68,0x6,0x5f)
 
 OUR_GUID_ENTRY(AM_KSCATEGORY_CAPTURE,
-		0x65E8773DL,0x8F56,0x11D0,0xA3,0xB9,0x00,0xA0,0xC9,0x22,0x31,0x96)
+        0x65E8773DL,0x8F56,0x11D0,0xA3,0xB9,0x00,0xA0,0xC9,0x22,0x31,0x96)
 
 OUR_GUID_ENTRY(AM_KSCATEGORY_RENDER,
-		0x65E8773EL,0x8F56,0x11D0,0xA3,0xB9,0x00,0xA0,0xC9,0x22,0x31,0x96)
+        0x65E8773EL,0x8F56,0x11D0,0xA3,0xB9,0x00,0xA0,0xC9,0x22,0x31,0x96)
 
 OUR_GUID_ENTRY(AM_KSCATEGORY_DATACOMPRESSOR,
-		0x1E84C900L,0x7E70,0x11D0,0xA5,0xD6,0x28,0xDB,0x04,0xC1,0x00,0x00)
+        0x1E84C900L,0x7E70,0x11D0,0xA5,0xD6,0x28,0xDB,0x04,0xC1,0x00,0x00)
 
 OUR_GUID_ENTRY(AM_KSCATEGORY_AUDIO,
-		0x6994AD04L,0x93EF,0x11D0,0xA3,0xCC,0x00,0xA0,0xC9,0x22,0x31,0x96)
+        0x6994AD04L,0x93EF,0x11D0,0xA3,0xCC,0x00,0xA0,0xC9,0x22,0x31,0x96)
 
 OUR_GUID_ENTRY(AM_KSCATEGORY_VIDEO,
-		0x6994AD05L,0x93EF,0x11D0,0xA3,0xCC,0x00,0xA0,0xC9,0x22,0x31,0x96)
+        0x6994AD05L,0x93EF,0x11D0,0xA3,0xCC,0x00,0xA0,0xC9,0x22,0x31,0x96)
 
 OUR_GUID_ENTRY(AM_KSCATEGORY_TVTUNER,
-		0xa799a800L,0xa46d,0x11d0,0xa1,0x8c,0x00,0xa0,0x24,0x01,0xdc,0xd4)
+        0xa799a800L,0xa46d,0x11d0,0xa1,0x8c,0x00,0xa0,0x24,0x01,0xdc,0xd4)
 
 OUR_GUID_ENTRY(AM_KSCATEGORY_CROSSBAR,
-		0xa799a801L,0xa46d,0x11d0,0xa1,0x8c,0x00,0xa0,0x24,0x01,0xdc,0xd4)
+        0xa799a801L,0xa46d,0x11d0,0xa1,0x8c,0x00,0xa0,0x24,0x01,0xdc,0xd4)
 
 OUR_GUID_ENTRY(AM_KSCATEGORY_TVAUDIO,
-		0xa799a802L,0xa46d,0x11d0,0xa1,0x8c,0x00,0xa0,0x24,0x01,0xdc,0xd4)
+        0xa799a802L,0xa46d,0x11d0,0xa1,0x8c,0x00,0xa0,0x24,0x01,0xdc,0xd4)
 
 OUR_GUID_ENTRY(AM_KSCATEGORY_VBICODEC,
-		0x07dad660L,0x22f1,0x11d1,0xa9,0xf4,0x00,0xc0,0x4f,0xbb,0xde,0x8f)
+        0x07dad660L,0x22f1,0x11d1,0xa9,0xf4,0x00,0xc0,0x4f,0xbb,0xde,0x8f)
 
 OUR_GUID_ENTRY(AM_KSCATEGORY_SPLITTER,
-		0x0A4252A0L,0x7E70,0x11D0,0xA5,0xD6,0x28,0xDB,0x04,0xC1,0x00,0x00)
+        0x0A4252A0L,0x7E70,0x11D0,0xA5,0xD6,0x28,0xDB,0x04,0xC1,0x00,0x00)
 
 OUR_GUID_ENTRY(IID_IKsInterfaceHandler,
-		0xD3ABC7E0L,0x9A61,0x11D0,0xA4,0x0D,0x00,0xA0,0xC9,0x22,0x31,0x96)
+        0xD3ABC7E0L,0x9A61,0x11D0,0xA4,0x0D,0x00,0xA0,0xC9,0x22,0x31,0x96)
 
 OUR_GUID_ENTRY(IID_IKsDataTypeHandler,
-		0x5FFBAA02L,0x49A3,0x11D0,0x9F,0x36,0x00,0xAA,0x00,0xA2,0x16,0xA1)
+        0x5FFBAA02L,0x49A3,0x11D0,0x9F,0x36,0x00,0xAA,0x00,0xA2,0x16,0xA1)
 
 OUR_GUID_ENTRY(IID_IKsPin,
-		0xb61178d1L,0xa2d9,0x11cf,0x9e,0x53,0x00,0xaa,0x00,0xa2,0x16,0xa1)
+        0xb61178d1L,0xa2d9,0x11cf,0x9e,0x53,0x00,0xaa,0x00,0xa2,0x16,0xa1)
 
 OUR_GUID_ENTRY(IID_IKsControl,
-		0x28F54685L,0x06FD,0x11D2,0xB2,0x7A,0x00,0xA0,0xC9,0x22,0x31,0x96)
+        0x28F54685L,0x06FD,0x11D2,0xB2,0x7A,0x00,0xA0,0xC9,0x22,0x31,0x96)
 
 OUR_GUID_ENTRY(IID_IKsPinFactory,
-		0xCD5EBE6BL,0x8B6E,0x11D1,0x8A,0xE0,0x00,0xA0,0xC9,0x22,0x31,0x96)
+        0xCD5EBE6BL,0x8B6E,0x11D1,0x8A,0xE0,0x00,0xA0,0xC9,0x22,0x31,0x96)
 
 OUR_GUID_ENTRY(AM_INTERFACESETID_Standard,
-		0x1A8766A0L,0x62CE,0x11CF,0xA5,0xD6,0x28,0xDB,0x04,0xC1,0x00,0x00)
+        0x1A8766A0L,0x62CE,0x11CF,0xA5,0xD6,0x28,0xDB,0x04,0xC1,0x00,0x00)
 
 #if ( (NTDDI_VERSION >= NTDDI_WINXPSP2) && (NTDDI_VERSION < NTDDI_WS03) ) || (NTDDI_VERSION >= NTDDI_WS03SP1)
 OUR_GUID_ENTRY(MEDIATYPE_MPEG2_SECTIONS,
-		0x455f176c,0x4b06,0x47ce,0x9a,0xef,0x8c,0xae,0xf7,0x3d,0xf7,0xb5)
+        0x455f176c,0x4b06,0x47ce,0x9a,0xef,0x8c,0xae,0xf7,0x3d,0xf7,0xb5)
 
 OUR_GUID_ENTRY(MEDIASUBTYPE_MPEG2_VERSIONED_TABLES,
-		0x1ed988b0,0x3ffc,0x4523,0x87,0x25,0x34,0x7b,0xee,0xc1,0xa8,0xa0)
+        0x1ed988b0,0x3ffc,0x4523,0x87,0x25,0x34,0x7b,0xee,0xc1,0xa8,0xa0)
 
 OUR_GUID_ENTRY(MEDIASUBTYPE_ATSC_SI,
-		0xb3c7397c,0xd303,0x414d,0xb3,0x3c,0x4e,0xd2,0xc9,0xd2,0x97,0x33)
+        0xb3c7397c,0xd303,0x414d,0xb3,0x3c,0x4e,0xd2,0xc9,0xd2,0x97,0x33)
 
 OUR_GUID_ENTRY(MEDIASUBTYPE_DVB_SI,
-		0xe9dd31a3,0x221d,0x4adb,0x85,0x32,0x9a,0xf3,0x9,0xc1,0xa4,0x8)
+        0xe9dd31a3,0x221d,0x4adb,0x85,0x32,0x9a,0xf3,0x9,0xc1,0xa4,0x8)
 
 OUR_GUID_ENTRY(MEDIASUBTYPE_ISDB_SI,
-		0xe89ad298,0x3601,0x4b06,0xaa,0xec,0x9d,0xde,0xed,0xcc,0x5b,0xd0)
+        0xe89ad298,0x3601,0x4b06,0xaa,0xec,0x9d,0xde,0xed,0xcc,0x5b,0xd0)
 
 OUR_GUID_ENTRY(MEDIASUBTYPE_TIF_SI,
-		0xec232eb2,0xcb96,0x4191,0xb2,0x26,0xe,0xa1,0x29,0xf3,0x82,0x50)
+        0xec232eb2,0xcb96,0x4191,0xb2,0x26,0xe,0xa1,0x29,0xf3,0x82,0x50)
 
 OUR_GUID_ENTRY(MEDIASUBTYPE_MPEG2DATA,
-		0xc892e55b,0x252d,0x42b5,0xa3,0x16,0xd9,0x97,0xe7,0xa5,0xd9,0x95)
+        0xc892e55b,0x252d,0x42b5,0xa3,0x16,0xd9,0x97,0xe7,0xa5,0xd9,0x95)
 #endif
 /* ( (NTDDI_VERSION >= NTDDI_WINXPSP2) && (NTDDI_VERSION < NTDDI_WS03) ) ||
-						(NTDDI_VERSION >= NTDDI_WS03SP1) */
+                        (NTDDI_VERSION >= NTDDI_WS03SP1) */
 
 #if (NTDDI_VERSION >= NTDDI_WINXP)
 OUR_GUID_ENTRY(MEDIASUBTYPE_MPEG2_TRANSPORT_STRIDE,
-		0x138aa9a4,0x1ee2,0x4c5b,0x98,0x8e,0x19,0xab,0xfd,0xbc,0x8a,0x11)
+        0x138aa9a4,0x1ee2,0x4c5b,0x98,0x8e,0x19,0xab,0xfd,0xbc,0x8a,0x11)
 
 OUR_GUID_ENTRY(MEDIASUBTYPE_MPEG2_UDCR_TRANSPORT,
-		0x18BEC4EA,0x4676,0x450e,0xB4,0x78,0x0C,0xD8,0x4C,0x54,0xB3,0x27)
+        0x18BEC4EA,0x4676,0x450e,0xB4,0x78,0x0C,0xD8,0x4C,0x54,0xB3,0x27)
 
 OUR_GUID_ENTRY(MEDIASUBTYPE_MPEG2_PBDA_TRANSPORT_RAW,
-		0x0d7aed42,0xcb9a,0x11db,0x97,0x5,0x0,0x50,0x56,0xc0,0x0,0x8)
+        0x0d7aed42,0xcb9a,0x11db,0x97,0x5,0x0,0x50,0x56,0xc0,0x0,0x8)
 
 OUR_GUID_ENTRY(MEDIASUBTYPE_MPEG2_PBDA_TRANSPORT_PROCESSED,
-		0xaf748dd4,0xd80,0x11db,0x97,0x5,0x0,0x50,0x56,0xc0,0x0,0x8)
+        0xaf748dd4,0xd80,0x11db,0x97,0x5,0x0,0x50,0x56,0xc0,0x0,0x8)
 
 OUR_GUID_ENTRY(MEDIASUBTYPE_DTS,
-		0xe06d8033,0xdb46,0x11cf,0xb4,0xd1,0x00,0x80,0x05f,0x6c,0xbb,0xea)
+        0xe06d8033,0xdb46,0x11cf,0xb4,0xd1,0x00,0x80,0x05f,0x6c,0xbb,0xea)
 
 OUR_GUID_ENTRY(MEDIASUBTYPE_SDDS,
-		0xe06d8034,0xdb46,0x11cf,0xb4,0xd1,0x00,0x80,0x05f,0x6c,0xbb,0xea)
+        0xe06d8034,0xdb46,0x11cf,0xb4,0xd1,0x00,0x80,0x05f,0x6c,0xbb,0xea)
 
 OUR_GUID_ENTRY(AM_KSPROPSETID_DVD_RateChange,
-		0x3577eb09,0x9582,0x477f,0xb2,0x9c,0xb0,0xc4,0x52,0xa4,0xff,0x9a)
+        0x3577eb09,0x9582,0x477f,0xb2,0x9c,0xb0,0xc4,0x52,0xa4,0xff,0x9a)
 
 OUR_GUID_ENTRY(AM_KSPROPSETID_DvdKaraoke,
-		0xae4720ae,0xaa71,0x42d8,0xb8,0x2a,0xff,0xfd,0xf5,0x8b,0x76,0xfd)
+        0xae4720ae,0xaa71,0x42d8,0xb8,0x2a,0xff,0xfd,0xf5,0x8b,0x76,0xfd)
 
 OUR_GUID_ENTRY(AM_KSPROPSETID_FrameStep,
-		0xc830acbd,0xab07,0x492f,0x88,0x52,0x45,0xb6,0x98,0x7c,0x29,0x79)
+        0xc830acbd,0xab07,0x492f,0x88,0x52,0x45,0xb6,0x98,0x7c,0x29,0x79)
 #endif /* NTDDI_VERSION >= NTDDI_WINXP */
 
 #if (NTDDI_VERSION >= NTDDI_WS03SP1)
 OUR_GUID_ENTRY(AM_KSCATEGORY_VBICODEC_MI,
-		0x9c24a977,0x951,0x451a,0x80,0x6,0xe,0x49,0xbd,0x28,0xcd,0x5f)
+        0x9c24a977,0x951,0x451a,0x80,0x6,0xe,0x49,0xbd,0x28,0xcd,0x5f)
 #endif /* NTDDI_VERSION >= NTDDI_WS03SP1 */
 

3rdparty/include/dshow/strmif.h

@@ -2097,12 +2097,12 @@ typedef LONGLONG REFERENCE_TIME;
     DWORD dwMerit;
     union {
       struct {
-	ULONG cPins;
-	const REGFILTERPINS *rgPins;
+    ULONG cPins;
+    const REGFILTERPINS *rgPins;
       };
       struct {
-	ULONG cPins2;
-	const REGFILTERPINS2 *rgPins2;
+    ULONG cPins2;
+    const REGFILTERPINS2 *rgPins2;
       };
     };
   } REGFILTER2;

3rdparty/include/ffmpeg_/libavcodec/dxva2.h

@@ -25,8 +25,11 @@
 
 #include <stdint.h>
 
+#include <d3d9.h>
 #include <dxva2api.h>
 
+#define FF_DXVA2_WORKAROUND_SCALING_LIST_ZIGZAG 1 ///< Work around for DXVA2 and old UVD/UVD+ ATI video cards
+
 /**
  * This structure is used to provides the necessary configurations and data
  * to the DXVA2 FFmpeg HWAccel implementation.

3rdparty/include/ffmpeg_/libavcodec/vaapi.h

@@ -27,8 +27,8 @@
 #include <stdint.h>
 
 /**
- * \defgroup VAAPI_Decoding VA API Decoding
- * \ingroup Decoder
+ * @defgroup VAAPI_Decoding VA API Decoding
+ * @ingroup Decoder
  * @{
  */
 

3rdparty/include/ffmpeg_/libavcodec/vda.h

@@ -0,0 +1,168 @@
+/*
+ * VDA HW acceleration
+ *
+ * copyright (c) 2011 Sebastien Zwickert
+ *
+ * This file is part of FFmpeg.
+ *
+ * FFmpeg is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * FFmpeg is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with FFmpeg; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#ifndef AVCODEC_VDA_H
+#define AVCODEC_VDA_H
+
+#include <pthread.h>
+#include <stdint.h>
+
+// emmintrin.h is unable to compile with -std=c99 -Werror=missing-prototypes
+// http://openradar.appspot.com/8026390
+#undef __GNUC_STDC_INLINE__
+
+#define Picture QuickdrawPicture
+#include <VideoDecodeAcceleration/VDADecoder.h>
+#undef Picture
+
+/**
+ *  This structure is used to store a decoded frame information and data.
+ */
+typedef struct {
+    /**
+    * The PTS of the frame.
+    *
+    * - encoding: unused
+    * - decoding: Set/Unset by libavcodec.
+    */
+    int64_t             pts;
+
+    /**
+    * The CoreVideo buffer that contains the decoded data.
+    *
+    * - encoding: unused
+    * - decoding: Set/Unset by libavcodec.
+    */
+    CVPixelBufferRef    cv_buffer;
+
+    /**
+    * A pointer to the next frame.
+    *
+    * - encoding: unused
+    * - decoding: Set/Unset by libavcodec.
+    */
+    struct vda_frame    *next_frame;
+} vda_frame;
+
+/**
+ * This structure is used to provide the necessary configurations and data
+ * to the VDA FFmpeg HWAccel implementation.
+ *
+ * The application must make it available as AVCodecContext.hwaccel_context.
+ */
+struct vda_context {
+    /**
+    * VDA decoder object.
+    *
+    * - encoding: unused
+    * - decoding: Set/Unset by libavcodec.
+    */
+    VDADecoder          decoder;
+
+    /**
+    * VDA frames queue ordered by presentation timestamp.
+    *
+    * - encoding: unused
+    * - decoding: Set/Unset by libavcodec.
+    */
+    vda_frame           *queue;
+
+    /**
+    * Mutex for locking queue operations.
+    *
+    * - encoding: unused
+    * - decoding: Set/Unset by libavcodec.
+    */
+    pthread_mutex_t     queue_mutex;
+
+    /**
+    * The frame width.
+    *
+    * - encoding: unused
+    * - decoding: Set/Unset by user.
+    */
+    int                 width;
+
+    /**
+    * The frame height.
+    *
+    * - encoding: unused
+    * - decoding: Set/Unset by user.
+    */
+    int                 height;
+
+    /**
+    * The frame format.
+    *
+    * - encoding: unused
+    * - decoding: Set/Unset by user.
+    */
+    int                 format;
+
+    /**
+    * The pixel format for output image buffers.
+    *
+    * - encoding: unused
+    * - decoding: Set/Unset by user.
+    */
+    OSType              cv_pix_fmt_type;
+
+    /**
+    * The current bitstream buffer.
+    *
+    * - encoding: unused
+    * - decoding: Set/Unset by libavcodec.
+    */
+    uint8_t             *bitstream;
+
+    /**
+    * The current size of the bitstream.
+    *
+    * - encoding: unused
+    * - decoding: Set/Unset by libavcodec.
+    */
+    int                 bitstream_size;
+
+    /**
+    * The reference size used for fast reallocation.
+    *
+    * - encoding: unused
+    * - decoding: Set/Unset by libavcodec.
+    */
+    int                 ref_size;
+};
+
+/** Create the video decoder. */
+int ff_vda_create_decoder(struct vda_context *vda_ctx,
+                          uint8_t *extradata,
+                          int extradata_size);
+
+/** Destroy the video decoder. */
+int ff_vda_destroy_decoder(struct vda_context *vda_ctx);
+
+/** Return the top frame of the queue. */
+vda_frame *ff_vda_queue_pop(struct vda_context *vda_ctx);
+
+/** Release the given frame. */
+void ff_vda_release_vda_frame(vda_frame *frame);
+
+#endif /* AVCODEC_VDA_H */

3rdparty/include/ffmpeg_/libavcodec/vdpau.h

@@ -25,7 +25,7 @@
 #define AVCODEC_VDPAU_H
 
 /**
- * \defgroup Decoder VDPAU Decoder and Renderer
+ * @defgroup Decoder VDPAU Decoder and Renderer
  *
  * VDPAU hardware acceleration has two modules
  * - VDPAU decoding
@@ -38,25 +38,25 @@
  * and rendering (API calls) are done as part of the VDPAU
  * presentation (vo_vdpau.c) module.
  *
- * \defgroup  VDPAU_Decoding VDPAU Decoding
- * \ingroup Decoder
+ * @defgroup  VDPAU_Decoding VDPAU Decoding
+ * @ingroup Decoder
  * @{
  */
 
 #include <vdpau/vdpau.h>
 #include <vdpau/vdpau_x11.h>
 
-/** \brief The videoSurface is used for rendering. */
+/** @brief The videoSurface is used for rendering. */
 #define FF_VDPAU_STATE_USED_FOR_RENDER 1
 
 /**
- * \brief The videoSurface is needed for reference/prediction.
+ * @brief The videoSurface is needed for reference/prediction.
  * The codec manipulates this.
  */
 #define FF_VDPAU_STATE_USED_FOR_REFERENCE 2
 
 /**
- * \brief This structure is used as a callback between the FFmpeg
+ * @brief This structure is used as a callback between the FFmpeg
  * decoder (vd_) and presentation (vo_) module.
  * This is used for defining a video frame containing surface,
  * picture parameter, bitstream information etc which are passed

3rdparty/include/ffmpeg_/libavcodec/version.h

@@ -21,8 +21,8 @@
 #define AVCODEC_VERSION_H
 
 #define LIBAVCODEC_VERSION_MAJOR 53
-#define LIBAVCODEC_VERSION_MINOR  7
-#define LIBAVCODEC_VERSION_MICRO  0
+#define LIBAVCODEC_VERSION_MINOR 61
+#define LIBAVCODEC_VERSION_MICRO 100
 
 #define LIBAVCODEC_VERSION_INT  AV_VERSION_INT(LIBAVCODEC_VERSION_MAJOR, \
                                                LIBAVCODEC_VERSION_MINOR, \
@@ -51,7 +51,7 @@
 #define FF_API_ANTIALIAS_ALGO   (LIBAVCODEC_VERSION_MAJOR < 54)
 #endif
 #ifndef FF_API_REQUEST_CHANNELS
-#define FF_API_REQUEST_CHANNELS (LIBAVCODEC_VERSION_MAJOR < 54)
+#define FF_API_REQUEST_CHANNELS (LIBAVCODEC_VERSION_MAJOR < 55)
 #endif
 #ifndef FF_API_OPT_H
 #define FF_API_OPT_H            (LIBAVCODEC_VERSION_MAJOR < 54)
@@ -68,5 +68,63 @@
 #ifndef FF_API_GET_PIX_FMT_NAME
 #define FF_API_GET_PIX_FMT_NAME (LIBAVCODEC_VERSION_MAJOR < 54)
 #endif
+#ifndef FF_API_ALLOC_CONTEXT
+#define FF_API_ALLOC_CONTEXT    (LIBAVCODEC_VERSION_MAJOR < 54)
+#endif
+#ifndef FF_API_AVCODEC_OPEN
+#define FF_API_AVCODEC_OPEN     (LIBAVCODEC_VERSION_MAJOR < 54)
+#endif
+#ifndef FF_API_DRC_SCALE
+#define FF_API_DRC_SCALE        (LIBAVCODEC_VERSION_MAJOR < 54)
+#endif
+#ifndef FF_API_ER
+#define FF_API_ER               (LIBAVCODEC_VERSION_MAJOR < 54)
+#endif
+#ifndef FF_API_AVCODEC_INIT
+#define FF_API_AVCODEC_INIT     (LIBAVCODEC_VERSION_MAJOR < 54)
+#endif
+#ifndef FF_API_X264_GLOBAL_OPTS
+#define FF_API_X264_GLOBAL_OPTS (LIBAVCODEC_VERSION_MAJOR < 54)
+#endif
+#ifndef FF_API_MPEGVIDEO_GLOBAL_OPTS
+#define FF_API_MPEGVIDEO_GLOBAL_OPTS (LIBAVCODEC_VERSION_MAJOR < 54)
+#endif
+#ifndef FF_API_LAME_GLOBAL_OPTS
+#define FF_API_LAME_GLOBAL_OPTS  (LIBAVCODEC_VERSION_MAJOR < 54)
+#endif
+#ifndef FF_API_SNOW_GLOBAL_OPTS
+#define FF_API_SNOW_GLOBAL_OPTS  (LIBAVCODEC_VERSION_MAJOR < 54)
+#endif
+#ifndef FF_API_MJPEG_GLOBAL_OPTS
+#define FF_API_MJPEG_GLOBAL_OPTS (LIBAVCODEC_VERSION_MAJOR < 54)
+#endif
+#ifndef FF_API_GET_ALPHA_INFO
+#define FF_API_GET_ALPHA_INFO    (LIBAVCODEC_VERSION_MAJOR < 54)
+#endif
+#ifndef FF_API_PARSE_FRAME
+#define FF_API_PARSE_FRAME (LIBAVCODEC_VERSION_MAJOR < 54)
+#endif
+#ifndef FF_API_INTERNAL_CONTEXT
+#define FF_API_INTERNAL_CONTEXT (LIBAVCODEC_VERSION_MAJOR < 54)
+#endif
+#ifndef FF_API_TIFFENC_COMPLEVEL
+#define FF_API_TIFFENC_COMPLEVEL (LIBAVCODEC_VERSION_MAJOR < 54)
+#endif
+#ifndef FF_API_DATA_POINTERS
+#define FF_API_DATA_POINTERS (LIBAVCODEC_VERSION_MAJOR < 54)
+#endif
+#ifndef FF_API_OLD_DECODE_AUDIO
+#define FF_API_OLD_DECODE_AUDIO (LIBAVCODEC_VERSION_MAJOR < 55)
+#endif
+#ifndef FF_API_OLD_TIMECODE
+#define FF_API_OLD_TIMECODE (LIBAVCODEC_VERSION_MAJOR < 54)
+#endif
+
+#ifndef FF_API_AVFRAME_AGE
+#define FF_API_AVFRAME_AGE (LIBAVCODEC_VERSION_MAJOR < 54)
+#endif
+#ifndef FF_API_OLD_ENCODE_AUDIO
+#define FF_API_OLD_ENCODE_AUDIO (LIBAVCODEC_VERSION_MAJOR < 55)
+#endif
 
 #endif /* AVCODEC_VERSION_H */

3rdparty/include/ffmpeg_/libavdevice/avdevice.h

@@ -19,12 +19,34 @@
 #ifndef AVDEVICE_AVDEVICE_H
 #define AVDEVICE_AVDEVICE_H
 
+/**
+ * @file
+ * @ingroup lavd
+ * Main libavdevice API header
+ */
+
+/**
+ * @defgroup lavd Special devices muxing/demuxing library
+ * @{
+ * Libavdevice is a complementary library to @ref libavf "libavformat". It
+ * provides various "special" platform-specific muxers and demuxers, e.g. for
+ * grabbing devices, audio capture and playback etc. As a consequence, the
+ * (de)muxers in libavdevice are of the AVFMT_NOFILE type (they use their own
+ * I/O functions). The filename passed to avformat_open_input() often does not
+ * refer to an actually existing file, but has some special device-specific
+ * meaning - e.g. for the x11grab device it is the display name.
+ *
+ * To use libavdevice, simply call avdevice_register_all() to register all
+ * compiled muxers and demuxers. They all use standard libavformat API.
+ * @}
+ */
+
 #include "libavutil/avutil.h"
 #include "libavformat/avformat.h"
 
 #define LIBAVDEVICE_VERSION_MAJOR 53
-#define LIBAVDEVICE_VERSION_MINOR  1
-#define LIBAVDEVICE_VERSION_MICRO  1
+#define LIBAVDEVICE_VERSION_MINOR  4
+#define LIBAVDEVICE_VERSION_MICRO 100
 
 #define LIBAVDEVICE_VERSION_INT AV_VERSION_INT(LIBAVDEVICE_VERSION_MAJOR, \
                                                LIBAVDEVICE_VERSION_MINOR, \
@@ -34,10 +56,6 @@
                                            LIBAVDEVICE_VERSION_MICRO)
 #define LIBAVDEVICE_BUILD       LIBAVDEVICE_VERSION_INT
 
-#ifndef FF_API_V4L
-#define FF_API_V4L              (LIBAVDEVICE_VERSION_MAJOR < 54)
-#endif
-
 /**
  * Return the LIBAVDEVICE_VERSION_INT constant.
  */

3rdparty/include/ffmpeg_/libavformat/avio.h

@@ -22,12 +22,14 @@
 
 /**
  * @file
+ * @ingroup lavf_io
  * Buffered I/O operations
  */
 
 #include <stdint.h>
 
 #include "libavutil/common.h"
+#include "libavutil/dict.h"
 #include "libavutil/log.h"
 
 #include "libavformat/version.h"
@@ -35,6 +37,22 @@
 
 #define AVIO_SEEKABLE_NORMAL 0x0001 /**< Seeking works like for a local file */
 
+/**
+ * Callback for checking whether to abort blocking functions.
+ * AVERROR_EXIT is returned in this case by the interrupted
+ * function. During blocking operations, callback is called with
+ * opaque as parameter. If the callback returns 1, the
+ * blocking operation will be aborted.
+ *
+ * No members can be added to this struct without a major bump, if
+ * new elements have been added after this struct in AVFormatContext
+ * or AVIOContext.
+ */
+typedef struct {
+    int (*callback)(void*);
+    void *opaque;
+} AVIOInterruptCB;
+
 /**
  * Bytestream IO Context.
  * New fields can be added to the end with minor version bumps.
@@ -48,6 +66,21 @@
  *       function pointers specified in avio_alloc_context()
  */
 typedef struct {
+#if !FF_API_OLD_AVIO
+    /**
+     * A class for private options.
+     *
+     * If this AVIOContext is created by avio_open2(), av_class is set and
+     * passes the options down to protocols.
+     *
+     * If this AVIOContext is manually allocated, then av_class may be set by
+     * the caller.
+     *
+     * warning -- this field can be NULL, be sure to not pass this AVIOContext
+     * to any av_opt_* functions in that case.
+     */
+    AVClass *av_class;
+#endif
     unsigned char *buffer;  /**< Start of the buffer. */
     int buffer_size;        /**< Maximum buffer size */
     unsigned char *buf_ptr; /**< Current position in the buffer */
@@ -87,6 +120,12 @@ typedef struct {
      * A combination of AVIO_SEEKABLE_ flags or 0 when the stream is not seekable.
      */
     int seekable;
+
+    /**
+     * max filesize, used to limit allocations
+     * This field is internal to libavformat and access from outside is not allowed.
+     */
+     int64_t maxsize;
 } AVIOContext;
 
 /* unbuffered I/O */
@@ -109,9 +148,11 @@ typedef struct URLContext {
     void *priv_data;
     char *filename; /**< specified URL */
     int is_connected;
+    AVIOInterruptCB interrupt_callback;
 } URLContext;
 
 #define URL_PROTOCOL_FLAG_NESTED_SCHEME 1 /*< The protocol name can be the first part of a nested protocol scheme */
+#define URL_PROTOCOL_FLAG_NETWORK       2 /*< The protocol uses network */
 
 /**
  * @deprecated This struct is to be made private. Use the higher-level
@@ -169,7 +210,7 @@ attribute_deprecated int url_poll(URLPollEntry *poll_table, int n, int timeout);
  * Warning: non-blocking protocols is work-in-progress; this flag may be
  * silently ignored.
  */
-#define URL_FLAG_NONBLOCK 4
+#define URL_FLAG_NONBLOCK 8
 
 typedef int URLInterruptCB(void);
 extern URLInterruptCB *url_interrupt_cb;
@@ -178,6 +219,7 @@ extern URLInterruptCB *url_interrupt_cb;
  * @defgroup old_url_funcs Old url_* functions
  * The following functions are deprecated. Use the buffered API based on #AVIOContext instead.
  * @{
+ * @ingroup lavf_io
  */
 attribute_deprecated int url_open_protocol (URLContext **puc, struct URLProtocol *up,
                                             const char *url, int flags);
@@ -238,6 +280,7 @@ attribute_deprecated AVIOContext *av_alloc_put_byte(
  * @defgroup old_avio_funcs Old put_/get_*() functions
  * The following functions are deprecated. Use the "avio_"-prefixed functions instead.
  * @{
+ * @ingroup lavf_io
  */
 attribute_deprecated int          get_buffer(AVIOContext *s, unsigned char *buf, int size);
 attribute_deprecated int          get_partial_buffer(AVIOContext *s, unsigned char *buf, int size);
@@ -275,6 +318,7 @@ attribute_deprecated int64_t av_url_read_fseek (AVIOContext *h,    int stream_in
  * @defgroup old_url_f_funcs Old url_f* functions
  * The following functions are deprecated, use the "avio_"-prefixed functions instead.
  * @{
+ * @ingroup lavf_io
  */
 attribute_deprecated int url_fopen( AVIOContext **s, const char *url, int flags);
 attribute_deprecated int url_fclose(AVIOContext *s);
@@ -285,11 +329,7 @@ attribute_deprecated int64_t url_fsize(AVIOContext *s);
 #define URL_EOF (-1)
 attribute_deprecated int url_fgetc(AVIOContext *s);
 attribute_deprecated int url_setbufsize(AVIOContext *s, int buf_size);
-#ifdef __GNUC__
-attribute_deprecated int url_fprintf(AVIOContext *s, const char *fmt, ...) __attribute__ ((__format__ (__printf__, 2, 3)));
-#else
-attribute_deprecated int url_fprintf(AVIOContext *s, const char *fmt, ...);
-#endif
+attribute_deprecated int url_fprintf(AVIOContext *s, const char *fmt, ...) av_printf_format(2, 3);
 attribute_deprecated void put_flush_packet(AVIOContext *s);
 attribute_deprecated int url_open_dyn_buf(AVIOContext **s);
 attribute_deprecated int url_open_dyn_packet_buf(AVIOContext **s, int max_packet_size);
@@ -357,13 +397,17 @@ attribute_deprecated int url_exist(const char *url);
  */
 int avio_check(const char *url, int flags);
 
+#if FF_API_OLD_INTERRUPT_CB
 /**
  * The callback is called in blocking functions to test regulary if
  * asynchronous interruption is needed. AVERROR_EXIT is returned
  * in this case by the interrupted function. 'NULL' means no interrupt
  * callback is given.
+ * @deprecated Use interrupt_callback in AVFormatContext/avio_open2
+ *             instead.
  */
-void avio_set_interrupt_cb(int (*interrupt_cb)(void));
+attribute_deprecated void avio_set_interrupt_cb(int (*interrupt_cb)(void));
+#endif
 
 /**
  * Allocate and initialize an AVIOContext for buffered I/O. It must be later
@@ -463,11 +507,7 @@ int64_t avio_size(AVIOContext *s);
 int url_feof(AVIOContext *s);
 
 /** @warning currently size is limited */
-#ifdef __GNUC__
-int avio_printf(AVIOContext *s, const char *fmt, ...) __attribute__ ((__format__ (__printf__, 2, 3)));
-#else
-int avio_printf(AVIOContext *s, const char *fmt, ...);
-#endif
+int avio_printf(AVIOContext *s, const char *fmt, ...) av_printf_format(2, 3);
 
 void avio_flush(AVIOContext *s);
 
@@ -564,6 +604,26 @@ int avio_get_str16be(AVIOContext *pb, int maxlen, char *buf, int buflen);
  */
 int avio_open(AVIOContext **s, const char *url, int flags);
 
+/**
+ * Create and initialize a AVIOContext for accessing the
+ * resource indicated by url.
+ * @note When the resource indicated by url has been opened in
+ * read+write mode, the AVIOContext can be used only for writing.
+ *
+ * @param s Used to return the pointer to the created AVIOContext.
+ * In case of failure the pointed to value is set to NULL.
+ * @param flags flags which control how the resource indicated by url
+ * is to be opened
+ * @param int_cb an interrupt callback to be used at the protocols level
+ * @param options  A dictionary filled with protocol-private options. On return
+ * this parameter will be destroyed and replaced with a dict containing options
+ * that were not found. May be NULL.
+ * @return 0 in case of success, a negative value corresponding to an
+ * AVERROR code in case of failure
+ */
+int avio_open2(AVIOContext **s, const char *url, int flags,
+               const AVIOInterruptCB *int_cb, AVDictionary **options);
+
 /**
  * Close the resource accessed by the AVIOContext s and free it.
  * This function can only be used if s was opened by avio_open().
@@ -619,13 +679,13 @@ int     avio_pause(AVIOContext *h, int pause);
  *        If stream_index is (-1) the timestamp should be in AV_TIME_BASE
  *        units from the beginning of the presentation.
  *        If a stream_index >= 0 is used and the protocol does not support
- *        seeking based on component streams, the call will fail with ENOTSUP.
+ *        seeking based on component streams, the call will fail.
  * @param timestamp timestamp in AVStream.time_base units
  *        or if there is no stream specified then in AV_TIME_BASE units.
  * @param flags Optional combination of AVSEEK_FLAG_BACKWARD, AVSEEK_FLAG_BYTE
  *        and AVSEEK_FLAG_ANY. The protocol may silently ignore
  *        AVSEEK_FLAG_BACKWARD and AVSEEK_FLAG_ANY, but AVSEEK_FLAG_BYTE will
- *        fail with ENOTSUP if used and not supported.
+ *        fail if used and not supported.
  * @return >= 0 on success
  * @see AVInputFormat::read_seek
  */

3rdparty/include/ffmpeg_/libavformat/version.h

@@ -21,11 +21,17 @@
 #ifndef AVFORMAT_VERSION_H
 #define AVFORMAT_VERSION_H
 
+/**
+ * @file
+ * @ingroup libavf
+ * Libavformat version macros
+ */
+
 #include "libavutil/avutil.h"
 
 #define LIBAVFORMAT_VERSION_MAJOR 53
-#define LIBAVFORMAT_VERSION_MINOR  4
-#define LIBAVFORMAT_VERSION_MICRO  0
+#define LIBAVFORMAT_VERSION_MINOR 32
+#define LIBAVFORMAT_VERSION_MICRO 100
 
 #define LIBAVFORMAT_VERSION_INT AV_VERSION_INT(LIBAVFORMAT_VERSION_MAJOR, \
                                                LIBAVFORMAT_VERSION_MINOR, \
@@ -44,9 +50,6 @@
 #ifndef FF_API_OLD_METADATA2
 #define FF_API_OLD_METADATA2           (LIBAVFORMAT_VERSION_MAJOR < 54)
 #endif
-#ifndef FF_API_READ_SEEK
-#define FF_API_READ_SEEK               (LIBAVFORMAT_VERSION_MAJOR < 54)
-#endif
 #ifndef FF_API_OLD_AVIO
 #define FF_API_OLD_AVIO                (LIBAVFORMAT_VERSION_MAJOR < 54)
 #endif
@@ -77,5 +80,50 @@
 #ifndef FF_API_FLAG_RTP_HINT
 #define FF_API_FLAG_RTP_HINT           (LIBAVFORMAT_VERSION_MAJOR < 54)
 #endif
+#ifndef FF_API_AVSTREAM_QUALITY
+#define FF_API_AVSTREAM_QUALITY        (LIBAVFORMAT_VERSION_MAJOR < 54)
+#endif
+#ifndef FF_API_LOOP_INPUT
+#define FF_API_LOOP_INPUT              (LIBAVFORMAT_VERSION_MAJOR < 54)
+#endif
+#ifndef FF_API_LOOP_OUTPUT
+#define FF_API_LOOP_OUTPUT             (LIBAVFORMAT_VERSION_MAJOR < 54)
+#endif
+#ifndef FF_API_TIMESTAMP
+#define FF_API_TIMESTAMP               (LIBAVFORMAT_VERSION_MAJOR < 54)
+#endif
+#ifndef FF_API_FILESIZE
+#define FF_API_FILESIZE                (LIBAVFORMAT_VERSION_MAJOR < 54)
+#endif
+#ifndef FF_API_MUXRATE
+#define FF_API_MUXRATE                 (LIBAVFORMAT_VERSION_MAJOR < 54)
+#endif
+#ifndef FF_API_RTSP_URL_OPTIONS
+#define FF_API_RTSP_URL_OPTIONS        (LIBAVFORMAT_VERSION_MAJOR < 54)
+#endif
+#ifndef FF_API_NEW_STREAM
+#define FF_API_NEW_STREAM              (LIBAVFORMAT_VERSION_MAJOR < 54)
+#endif
+#ifndef FF_API_PRELOAD
+#define FF_API_PRELOAD                 (LIBAVFORMAT_VERSION_MAJOR < 54)
+#endif
+#ifndef FF_API_STREAM_COPY
+#define FF_API_STREAM_COPY             (LIBAVFORMAT_VERSION_MAJOR < 54)
+#endif
+#ifndef FF_API_SEEK_PUBLIC
+#define FF_API_SEEK_PUBLIC             (LIBAVFORMAT_VERSION_MAJOR < 54)
+#endif
+#ifndef FF_API_REORDER_PRIVATE
+#define FF_API_REORDER_PRIVATE         (LIBAVFORMAT_VERSION_MAJOR < 54)
+#endif
+#ifndef FF_API_OLD_INTERRUPT_CB
+#define FF_API_OLD_INTERRUPT_CB        (LIBAVFORMAT_VERSION_MAJOR < 54)
+#endif
+#ifndef FF_API_SET_PTS_INFO
+#define FF_API_SET_PTS_INFO            (LIBAVFORMAT_VERSION_MAJOR < 54)
+#endif
+#ifndef FF_API_CLOSE_INPUT_FILE
+#define FF_API_CLOSE_INPUT_FILE        (LIBAVFORMAT_VERSION_MAJOR < 55)
+#endif
 
 #endif /* AVFORMAT_VERSION_H */

3rdparty/include/ffmpeg_/libavutil/adler32.h

@@ -25,6 +25,7 @@
 #include "attributes.h"
 
 /**
+ * @ingroup lavu_crypto
  * Calculate the Adler32 checksum of a buffer.
  *
  * Passing the return value to a subsequent av_adler32_update() call

3rdparty/include/ffmpeg_/libavutil/aes.h

@@ -23,6 +23,12 @@
 
 #include <stdint.h>
 
+/**
+ * @defgroup lavu_aes AES
+ * @ingroup lavu_crypto
+ * @{
+ */
+
 extern const int av_aes_size;
 
 struct AVAES;
@@ -44,4 +50,8 @@ int av_aes_init(struct AVAES *a, const uint8_t *key, int key_bits, int decrypt);
  */
 void av_aes_crypt(struct AVAES *a, uint8_t *dst, const uint8_t *src, int count, uint8_t *iv, int decrypt);
 
+/**
+ * @}
+ */
+
 #endif /* AVUTIL_AES_H */

3rdparty/include/ffmpeg_/libavutil/attributes.h

@@ -40,6 +40,14 @@
 #endif
 #endif
 
+#ifndef av_noreturn
+#if AV_GCC_VERSION_AT_LEAST(2,5)
+#    define av_noreturn __attribute__((noreturn))
+#else
+#    define av_noreturn
+#endif
+#endif
+
 #ifndef av_noinline
 #if AV_GCC_VERSION_AT_LEAST(3,1)
 #    define av_noinline __attribute__((noinline))
@@ -88,6 +96,24 @@
 #endif
 #endif
 
+/**
+ * Disable warnings about deprecated features
+ * This is useful for sections of code kept for backward compatibility and
+ * scheduled for removal.
+ */
+#ifndef AV_NOWARN_DEPRECATED
+#if AV_GCC_VERSION_AT_LEAST(4,6)
+#    define AV_NOWARN_DEPRECATED(code) \
+        _Pragma("GCC diagnostic push") \
+        _Pragma("GCC diagnostic ignored \"-Wdeprecated-declarations\"") \
+        code \
+        _Pragma("GCC diagnostic pop")
+#else
+#    define AV_NOWARN_DEPRECATED(code) code
+#endif
+#endif
+
+
 #ifndef av_unused
 #if defined(__GNUC__)
 #    define av_unused __attribute__((unused))
@@ -127,8 +153,10 @@
 
 #ifdef __GNUC__
 #    define av_builtin_constant_p __builtin_constant_p
+#    define av_printf_format(fmtpos, attrpos) __attribute__((__format__(__printf__, fmtpos, attrpos)))
 #else
 #    define av_builtin_constant_p(x) 0
+#    define av_printf_format(fmtpos, attrpos)
 #endif
 
 #endif /* AVUTIL_ATTRIBUTES_H */

3rdparty/include/ffmpeg_/libavutil/audioconvert.h

@@ -29,7 +29,15 @@
  * audio conversion routines
  */
 
-/* Audio channel masks */
+/**
+ * @addtogroup lavu_audio
+ * @{
+ */
+
+/**
+ * @defgroup channel_masks Audio channel masks
+ * @{
+ */
 #define AV_CH_FRONT_LEFT             0x00000001
 #define AV_CH_FRONT_RIGHT            0x00000002
 #define AV_CH_FRONT_CENTER           0x00000004
@@ -50,33 +58,68 @@
 #define AV_CH_TOP_BACK_RIGHT         0x00020000
 #define AV_CH_STEREO_LEFT            0x20000000  ///< Stereo downmix.
 #define AV_CH_STEREO_RIGHT           0x40000000  ///< See AV_CH_STEREO_LEFT.
+#define AV_CH_WIDE_LEFT              0x0000000080000000ULL
+#define AV_CH_WIDE_RIGHT             0x0000000100000000ULL
+#define AV_CH_SURROUND_DIRECT_LEFT   0x0000000200000000ULL
+#define AV_CH_SURROUND_DIRECT_RIGHT  0x0000000400000000ULL
 
 /** Channel mask value used for AVCodecContext.request_channel_layout
     to indicate that the user requests the channel order of the decoder output
     to be the native codec channel order. */
-#define AV_CH_LAYOUT_NATIVE          0x8000000000000000LL
+#define AV_CH_LAYOUT_NATIVE          0x8000000000000000ULL
 
-/* Audio channel convenience macros */
+/**
+ * @}
+ * @defgroup channel_mask_c Audio channel convenience macros
+ * @{
+ * */
 #define AV_CH_LAYOUT_MONO              (AV_CH_FRONT_CENTER)
 #define AV_CH_LAYOUT_STEREO            (AV_CH_FRONT_LEFT|AV_CH_FRONT_RIGHT)
+#define AV_CH_LAYOUT_2POINT1           (AV_CH_LAYOUT_STEREO|AV_CH_LOW_FREQUENCY)
 #define AV_CH_LAYOUT_2_1               (AV_CH_LAYOUT_STEREO|AV_CH_BACK_CENTER)
 #define AV_CH_LAYOUT_SURROUND          (AV_CH_LAYOUT_STEREO|AV_CH_FRONT_CENTER)
+#define AV_CH_LAYOUT_3POINT1           (AV_CH_LAYOUT_SURROUND|AV_CH_LOW_FREQUENCY)
 #define AV_CH_LAYOUT_4POINT0           (AV_CH_LAYOUT_SURROUND|AV_CH_BACK_CENTER)
+#define AV_CH_LAYOUT_4POINT1           (AV_CH_LAYOUT_4POINT0|AV_CH_LOW_FREQUENCY)
 #define AV_CH_LAYOUT_2_2               (AV_CH_LAYOUT_STEREO|AV_CH_SIDE_LEFT|AV_CH_SIDE_RIGHT)
 #define AV_CH_LAYOUT_QUAD              (AV_CH_LAYOUT_STEREO|AV_CH_BACK_LEFT|AV_CH_BACK_RIGHT)
 #define AV_CH_LAYOUT_5POINT0           (AV_CH_LAYOUT_SURROUND|AV_CH_SIDE_LEFT|AV_CH_SIDE_RIGHT)
 #define AV_CH_LAYOUT_5POINT1           (AV_CH_LAYOUT_5POINT0|AV_CH_LOW_FREQUENCY)
 #define AV_CH_LAYOUT_5POINT0_BACK      (AV_CH_LAYOUT_SURROUND|AV_CH_BACK_LEFT|AV_CH_BACK_RIGHT)
 #define AV_CH_LAYOUT_5POINT1_BACK      (AV_CH_LAYOUT_5POINT0_BACK|AV_CH_LOW_FREQUENCY)
+#define AV_CH_LAYOUT_6POINT0           (AV_CH_LAYOUT_5POINT0|AV_CH_BACK_CENTER)
+#define AV_CH_LAYOUT_6POINT0_FRONT     (AV_CH_LAYOUT_2_2|AV_CH_FRONT_LEFT_OF_CENTER|AV_CH_FRONT_RIGHT_OF_CENTER)
+#define AV_CH_LAYOUT_HEXAGONAL         (AV_CH_LAYOUT_5POINT0_BACK|AV_CH_BACK_CENTER)
+#define AV_CH_LAYOUT_6POINT1           (AV_CH_LAYOUT_5POINT1|AV_CH_BACK_CENTER)
+#define AV_CH_LAYOUT_6POINT1_BACK      (AV_CH_LAYOUT_5POINT1_BACK|AV_CH_BACK_CENTER)
+#define AV_CH_LAYOUT_6POINT1_FRONT     (AV_CH_LAYOUT_6POINT0_FRONT|AV_CH_LOW_FREQUENCY)
 #define AV_CH_LAYOUT_7POINT0           (AV_CH_LAYOUT_5POINT0|AV_CH_BACK_LEFT|AV_CH_BACK_RIGHT)
+#define AV_CH_LAYOUT_7POINT0_FRONT     (AV_CH_LAYOUT_5POINT0|AV_CH_FRONT_LEFT_OF_CENTER|AV_CH_FRONT_RIGHT_OF_CENTER)
 #define AV_CH_LAYOUT_7POINT1           (AV_CH_LAYOUT_5POINT1|AV_CH_BACK_LEFT|AV_CH_BACK_RIGHT)
-#define AV_CH_LAYOUT_7POINT1_WIDE      (AV_CH_LAYOUT_5POINT1_BACK|AV_CH_FRONT_LEFT_OF_CENTER|AV_CH_FRONT_RIGHT_OF_CENTER)
+#define AV_CH_LAYOUT_7POINT1_WIDE      (AV_CH_LAYOUT_5POINT1|AV_CH_FRONT_LEFT_OF_CENTER|AV_CH_FRONT_RIGHT_OF_CENTER)
+#define AV_CH_LAYOUT_OCTAGONAL         (AV_CH_LAYOUT_5POINT0|AV_CH_BACK_LEFT|AV_CH_BACK_CENTER|AV_CH_BACK_RIGHT)
 #define AV_CH_LAYOUT_STEREO_DOWNMIX    (AV_CH_STEREO_LEFT|AV_CH_STEREO_RIGHT)
 
 /**
- * Return a channel layout id that matches name, 0 if no match.
+ * @}
  */
-int64_t av_get_channel_layout(const char *name);
+
+/**
+ * Return a channel layout id that matches name, 0 if no match.
+ * name can be one or several of the following notations,
+ * separated by '+' or '|':
+ * - the name of an usual channel layout (mono, stereo, 4.0, quad, 5.0,
+ *   5.0(side), 5.1, 5.1(side), 7.1, 7.1(wide), downmix);
+ * - the name of a single channel (FL, FR, FC, LFE, BL, BR, FLC, FRC, BC,
+ *   SL, SR, TC, TFL, TFC, TFR, TBL, TBC, TBR, DL, DR);
+ * - a number of channels, in decimal, optionnally followed by 'c', yielding
+ *   the default channel layout for that number of channels (@see
+ *   av_get_default_channel_layout);
+ * - a channel layout mask, in hexadecimal starting with "0x" (see the
+ *   AV_CH_* macros).
+ + Example: "stereo+FC" = "2+FC" = "2c+1c" = "0x7"
+ */
+uint64_t av_get_channel_layout(const char *name);
 
 /**
  * Return a description of a channel layout.
@@ -85,11 +128,20 @@ int64_t av_get_channel_layout(const char *name);
  * @param buf put here the string containing the channel layout
  * @param buf_size size in bytes of the buffer
  */
-void av_get_channel_layout_string(char *buf, int buf_size, int nb_channels, int64_t channel_layout);
+void av_get_channel_layout_string(char *buf, int buf_size, int nb_channels, uint64_t channel_layout);
 
 /**
  * Return the number of channels in the channel layout.
  */
-int av_get_channel_layout_nb_channels(int64_t channel_layout);
+int av_get_channel_layout_nb_channels(uint64_t channel_layout);
+
+/**
+ * Return default channel layout for a given number of channels.
+ */
+int64_t av_get_default_channel_layout(int nb_channels);
+
+/**
+ * @}
+ */
 
 #endif /* AVUTIL_AUDIOCONVERT_H */

3rdparty/include/ffmpeg_/libavutil/avstring.h

@@ -22,6 +22,12 @@
 #define AVUTIL_AVSTRING_H
 
 #include <stddef.h>
+#include "attributes.h"
+
+/**
+ * @addtogroup lavu_string
+ * @{
+ */
 
 /**
  * Return non-zero if pfx is a prefix of str. If it is, *ptr is set to
@@ -71,7 +77,7 @@ char *av_stristr(const char *haystack, const char *needle);
  * @param size size of destination buffer
  * @return the length of src
  *
- * WARNING: since the return value is the length of src, src absolutely
+ * @warning since the return value is the length of src, src absolutely
  * _must_ be a properly 0-terminated string, otherwise this will read beyond
  * the end of the buffer and possibly crash.
  */
@@ -89,9 +95,9 @@ size_t av_strlcpy(char *dst, const char *src, size_t size);
  * @param size size of destination buffer
  * @return the total length of src and dst
  *
- * WARNING: since the return value use the length of src and dst, these absolutely
- * _must_ be a properly 0-terminated strings, otherwise this will read beyond
- * the end of the buffer and possibly crash.
+ * @warning since the return value use the length of src and dst, these
+ * absolutely _must_ be a properly 0-terminated strings, otherwise this
+ * will read beyond the end of the buffer and possibly crash.
  */
 size_t av_strlcat(char *dst, const char *src, size_t size);
 
@@ -107,7 +113,17 @@ size_t av_strlcat(char *dst, const char *src, size_t size);
  * @return the length of the string that would have been generated
  *  if enough space had been available
  */
-size_t av_strlcatf(char *dst, size_t size, const char *fmt, ...);
+size_t av_strlcatf(char *dst, size_t size, const char *fmt, ...) av_printf_format(3, 4);
+
+/**
+ * Print arguments following specified format into a large enough auto
+ * allocated buffer. It is similar to GNU asprintf().
+ * @param fmt printf-compatible format string, specifying how the
+ *            following parameters are used.
+ * @return the allocated string
+ * @note You have to free the string yourself with av_free().
+ */
+char *av_asprintf(const char *fmt, ...) av_printf_format(1, 2);
 
 /**
  * Convert a number to a av_malloced string.
@@ -130,4 +146,64 @@ char *av_d2str(double d);
  */
 char *av_get_token(const char **buf, const char *term);
 
+/**
+ * Split the string into several tokens which can be accessed by
+ * successive calls to av_strtok().
+ *
+ * A token is defined as a sequence of characters not belonging to the
+ * set specified in delim.
+ *
+ * On the first call to av_strtok(), s should point to the string to
+ * parse, and the value of saveptr is ignored. In subsequent calls, s
+ * should be NULL, and saveptr should be unchanged since the previous
+ * call.
+ *
+ * This function is similar to strtok_r() defined in POSIX.1.
+ *
+ * @param s the string to parse, may be NULL
+ * @param delim 0-terminated list of token delimiters, must be non-NULL
+ * @param saveptr user-provided pointer which points to stored
+ * information necessary for av_strtok() to continue scanning the same
+ * string. saveptr is updated to point to the next character after the
+ * first delimiter found, or to NULL if the string was terminated
+ * @return the found token, or NULL when no token is found
+ */
+char *av_strtok(char *s, const char *delim, char **saveptr);
+
+/**
+ * Locale-independent conversion of ASCII characters to uppercase.
+ */
+static inline int av_toupper(int c)
+{
+    if (c >= 'a' && c <= 'z')
+        c ^= 0x20;
+    return c;
+}
+
+/**
+ * Locale-independent conversion of ASCII characters to lowercase.
+ */
+static inline int av_tolower(int c)
+{
+    if (c >= 'A' && c <= 'Z')
+        c ^= 0x20;
+    return c;
+}
+
+/**
+ * Locale-independent case-insensitive compare.
+ * @note This means only ASCII-range characters are case-insensitive
+ */
+int av_strcasecmp(const char *a, const char *b);
+
+/**
+ * Locale-independent case-insensitive compare.
+ * @note This means only ASCII-range characters are case-insensitive
+ */
+int av_strncasecmp(const char *a, const char *b, size_t n);
+
+/**
+ * @}
+ */
+
 #endif /* AVUTIL_AVSTRING_H */

3rdparty/include/ffmpeg_/libavutil/avutil.h

@@ -26,6 +26,96 @@
  * external API header
  */
 
+/**
+ * @mainpage
+ *
+ * @section libav_intro Introduction
+ *
+ * This document describe the usage of the different libraries
+ * provided by FFmpeg.
+ *
+ * @li @ref libavc "libavcodec" encoding/decoding library
+ * @li @subpage libavfilter graph based frame editing library
+ * @li @ref libavf "libavformat" I/O and muxing/demuxing library
+ * @li @ref lavd "libavdevice" special devices muxing/demuxing library
+ * @li @ref lavu "libavutil" common utility library
+ * @li @subpage libpostproc post processing library
+ * @li @subpage libswscale  color conversion and scaling library
+ *
+ */
+
+/**
+ * @defgroup lavu Common utility functions
+ *
+ * @brief
+ * libavutil contains the code shared across all the other FFmpeg
+ * libraries
+ *
+ * @note In order to use the functions provided by avutil you must include
+ * the specific header.
+ *
+ * @{
+ *
+ * @defgroup lavu_crypto Crypto and Hashing
+ *
+ * @{
+ * @}
+ *
+ * @defgroup lavu_math Maths
+ * @{
+ *
+ * @}
+ *
+ * @defgroup lavu_string String Manipulation
+ *
+ * @{
+ *
+ * @}
+ *
+ * @defgroup lavu_mem Memory Management
+ *
+ * @{
+ *
+ * @}
+ *
+ * @defgroup lavu_data Data Structures
+ * @{
+ *
+ * @}
+ *
+ * @defgroup lavu_audio Audio related
+ *
+ * @{
+ *
+ * @}
+ *
+ * @defgroup lavu_error Error Codes
+ *
+ * @{
+ *
+ * @}
+ *
+ * @defgroup lavu_misc Other
+ *
+ * @{
+ *
+ * @defgroup lavu_internal Internal
+ *
+ * Not exported functions, for internal usage only
+ *
+ * @{
+ *
+ * @}
+ */
+
+
+/**
+ * @defgroup preproc_misc Preprocessor String Macros
+ *
+ * String manipulation macros
+ *
+ * @{
+ */
 
 #define AV_STRINGIFY(s)         AV_TOSTRING(s)
 #define AV_TOSTRING(s) #s
@@ -35,13 +125,37 @@
 
 #define AV_PRAGMA(s) _Pragma(#s)
 
+/**
+ * @}
+ */
+
+/**
+ * @defgroup version_utils Library Version Macros
+ *
+ * Useful to check and match library version in order to maintain
+ * backward compatibility.
+ *
+ * @{
+ */
+
 #define AV_VERSION_INT(a, b, c) (a<<16 | b<<8 | c)
 #define AV_VERSION_DOT(a, b, c) a ##.## b ##.## c
 #define AV_VERSION(a, b, c) AV_VERSION_DOT(a, b, c)
 
+/**
+ * @}
+ *
+ * @defgroup lavu_ver Version and Build diagnostics
+ *
+ * Macros and function useful to check at compiletime and at runtime
+ * which version of libavutil is in use.
+ *
+ * @{
+ */
+
 #define LIBAVUTIL_VERSION_MAJOR 51
-#define LIBAVUTIL_VERSION_MINOR  9
-#define LIBAVUTIL_VERSION_MICRO  1
+#define LIBAVUTIL_VERSION_MINOR 35
+#define LIBAVUTIL_VERSION_MICRO 100
 
 #define LIBAVUTIL_VERSION_INT   AV_VERSION_INT(LIBAVUTIL_VERSION_MAJOR, \
                                                LIBAVUTIL_VERSION_MINOR, \
@@ -54,8 +168,16 @@
 #define LIBAVUTIL_IDENT         "Lavu" AV_STRINGIFY(LIBAVUTIL_VERSION)
 
 /**
+ * @}
+ *
+ * @defgroup depr_guards Deprecation guards
  * Those FF_API_* defines are not part of public API.
  * They may change, break or disappear at any time.
+ *
+ * They are used mostly internally to mark code that will be removed
+ * on the next major version.
+ *
+ * @{
  */
 #ifndef FF_API_OLD_EVAL_NAMES
 #define FF_API_OLD_EVAL_NAMES (LIBAVUTIL_VERSION_MAJOR < 52)
@@ -66,6 +188,21 @@
 #ifndef FF_API_FIND_OPT
 #define FF_API_FIND_OPT                 (LIBAVUTIL_VERSION_MAJOR < 52)
 #endif
+#ifndef FF_API_AV_FIFO_PEEK
+#define FF_API_AV_FIFO_PEEK             (LIBAVUTIL_VERSION_MAJOR < 52)
+#endif
+#ifndef FF_API_OLD_AVOPTIONS
+#define FF_API_OLD_AVOPTIONS            (LIBAVUTIL_VERSION_MAJOR < 52)
+#endif
+
+/**
+ * @}
+ */
+
+/**
+ * @addtogroup lavu_ver
+ * @{
+ */
 
 /**
  * Return the LIBAVUTIL_VERSION_INT constant.
@@ -82,16 +219,41 @@ const char *avutil_configuration(void);
  */
 const char *avutil_license(void);
 
+/**
+ * @}
+ */
+
+/**
+ * @addtogroup lavu_media Media Type
+ * @brief Media Type
+ */
+
 enum AVMediaType {
-    AVMEDIA_TYPE_UNKNOWN = -1,
+    AVMEDIA_TYPE_UNKNOWN = -1,  ///< Usually treated as AVMEDIA_TYPE_DATA
     AVMEDIA_TYPE_VIDEO,
     AVMEDIA_TYPE_AUDIO,
-    AVMEDIA_TYPE_DATA,
+    AVMEDIA_TYPE_DATA,          ///< Opaque data information usually continuous
     AVMEDIA_TYPE_SUBTITLE,
-    AVMEDIA_TYPE_ATTACHMENT,
+    AVMEDIA_TYPE_ATTACHMENT,    ///< Opaque data information usually sparse
     AVMEDIA_TYPE_NB
 };
 
+/**
+ * Return a string describing the media_type enum, NULL if media_type
+ * is unknown.
+ */
+const char *av_get_media_type_string(enum AVMediaType media_type);
+
+/**
+ * @defgroup lavu_const Constants
+ * @{
+ *
+ * @defgroup lavu_enc Encoding specific
+ *
+ * @note those definition should move to avcodec
+ * @{
+ */
+
 #define FF_LAMBDA_SHIFT 7
 #define FF_LAMBDA_SCALE (1<<FF_LAMBDA_SHIFT)
 #define FF_QP2LAMBDA 118 ///< factor to convert from H.263 QP to lambda
@@ -99,10 +261,46 @@ enum AVMediaType {
 
 #define FF_QUALITY_SCALE FF_LAMBDA_SCALE //FIXME maybe remove
 
+/**
+ * @}
+ * @defgroup lavu_time Timestamp specific
+ *
+ * FFmpeg internal timebase and timestamp definitions
+ *
+ * @{
+ */
+
+/**
+ * @brief Undefined timestamp value
+ *
+ * Usually reported by demuxer that work on containers that do not provide
+ * either pts or dts.
+ */
+
 #define AV_NOPTS_VALUE          INT64_C(0x8000000000000000)
+
+/**
+ * Internal time base represented as integer
+ */
+
 #define AV_TIME_BASE            1000000
+
+/**
+ * Internal time base represented as fractional value
+ */
+
 #define AV_TIME_BASE_Q          (AVRational){1, AV_TIME_BASE}
 
+/**
+ * @}
+ * @}
+ * @defgroup lavu_picture Image related
+ *
+ * AVPicture types, pixel formats and basic image planes manipulation.
+ *
+ * @{
+ */
+
 enum AVPictureType {
     AV_PICTURE_TYPE_NONE = 0, ///< Undefined
     AV_PICTURE_TYPE_I,     ///< Intra
@@ -123,6 +321,10 @@ enum AVPictureType {
  */
 char av_get_picture_type_char(enum AVPictureType pict_type);
 
+/**
+ * @}
+ */
+
 #include "common.h"
 #include "error.h"
 #include "mathematics.h"
@@ -131,4 +333,17 @@ char av_get_picture_type_char(enum AVPictureType pict_type);
 #include "log.h"
 #include "pixfmt.h"
 
+/**
+ * Return x default pointer in case p is NULL.
+ */
+static inline void *av_x_if_null(const void *p, const void *x)
+{
+    return (void *)(intptr_t)(p ? p : x);
+}
+
+/**
+ * @}
+ * @}
+ */
+
 #endif /* AVUTIL_AVUTIL_H */

3rdparty/include/ffmpeg_/libavutil/base64.h

@@ -23,6 +23,13 @@
 
 #include <stdint.h>
 
+/**
+ * @defgroup lavu_base64 Base64
+ * @ingroup lavu_crypto
+ * @{
+ */
+
+
 /**
  * Decode a base64-encoded string.
  *
@@ -51,4 +58,8 @@ char *av_base64_encode(char *out, int out_size, const uint8_t *in, int in_size);
  */
 #define AV_BASE64_SIZE(x)  (((x)+2) / 3 * 4 + 1)
 
+ /**
+  * @}
+  */
+
 #endif /* AVUTIL_BASE64_H */

3rdparty/include/ffmpeg_/libavutil/bswap.h

@@ -65,29 +65,14 @@ static av_always_inline av_const uint16_t av_bswap16(uint16_t x)
 #ifndef av_bswap32
 static av_always_inline av_const uint32_t av_bswap32(uint32_t x)
 {
-    x= ((x<<8)&0xFF00FF00) | ((x>>8)&0x00FF00FF);
-    x= (x>>16) | (x<<16);
-    return x;
+    return AV_BSWAP32C(x);
 }
 #endif
 
 #ifndef av_bswap64
 static inline uint64_t av_const av_bswap64(uint64_t x)
 {
-#if 0
-    x= ((x<< 8)&0xFF00FF00FF00FF00ULL) | ((x>> 8)&0x00FF00FF00FF00FFULL);
-    x= ((x<<16)&0xFFFF0000FFFF0000ULL) | ((x>>16)&0x0000FFFF0000FFFFULL);
-    return (x>>32) | (x<<32);
-#else
-    union {
-        uint64_t ll;
-        uint32_t l[2];
-    } w, r;
-    w.ll = x;
-    r.l[0] = av_bswap32 (w.l[1]);
-    r.l[1] = av_bswap32 (w.l[0]);
-    return r.ll;
-#endif
+    return (uint64_t)av_bswap32(x) << 32 | av_bswap32(x >> 32);
 }
 #endif
 

3rdparty/include/ffmpeg_/libavutil/common.h

@@ -220,8 +220,18 @@ static av_always_inline av_const int av_popcount_c(uint32_t x)
     return (x + (x >> 16)) & 0x3F;
 }
 
-#define MKTAG(a,b,c,d) ((a) | ((b) << 8) | ((c) << 16) | ((d) << 24))
-#define MKBETAG(a,b,c,d) ((d) | ((c) << 8) | ((b) << 16) | ((a) << 24))
+/**
+ * Count number of bits set to one in x
+ * @param x value to count bits of
+ * @return the number of bits set to one in x
+ */
+static av_always_inline av_const int av_popcount64_c(uint64_t x)
+{
+    return av_popcount(x) + av_popcount(x >> 32);
+}
+
+#define MKTAG(a,b,c,d) ((a) | ((b) << 8) | ((c) << 16) | ((unsigned)(d) << 24))
+#define MKBETAG(a,b,c,d) ((d) | ((c) << 8) | ((b) << 16) | ((unsigned)(a) << 24))
 
 /**
  * Convert a UTF-8 character (up to 4 bytes) to its 32-bit UCS-4 encoded form.
@@ -270,16 +280,16 @@ static av_always_inline av_const int av_popcount_c(uint32_t x)
         }\
     }\
 
-/*!
- * \def PUT_UTF8(val, tmp, PUT_BYTE)
+/**
+ * @def PUT_UTF8(val, tmp, PUT_BYTE)
  * Convert a 32-bit Unicode character to its UTF-8 encoded form (up to 4 bytes long).
- * \param val is an input-only argument and should be of type uint32_t. It holds
+ * @param val is an input-only argument and should be of type uint32_t. It holds
  * a UCS-4 encoded Unicode character that is to be converted to UTF-8. If
  * val is given as a function it is executed only once.
- * \param tmp is a temporary variable and should be of type uint8_t. It
+ * @param tmp is a temporary variable and should be of type uint8_t. It
  * represents an intermediate value during conversion that is to be
  * output by PUT_BYTE.
- * \param PUT_BYTE writes the converted UTF-8 bytes to any proper destination.
+ * @param PUT_BYTE writes the converted UTF-8 bytes to any proper destination.
  * It could be a function or a statement, and uses tmp as the input byte.
  * For example, PUT_BYTE could be "*output++ = tmp;" PUT_BYTE will be
  * executed up to 4 times for values in the valid UTF-8 range and up to
@@ -306,16 +316,16 @@ static av_always_inline av_const int av_popcount_c(uint32_t x)
         }\
     }
 
-/*!
- * \def PUT_UTF16(val, tmp, PUT_16BIT)
+/**
+ * @def PUT_UTF16(val, tmp, PUT_16BIT)
  * Convert a 32-bit Unicode character to its UTF-16 encoded form (2 or 4 bytes).
- * \param val is an input-only argument and should be of type uint32_t. It holds
+ * @param val is an input-only argument and should be of type uint32_t. It holds
  * a UCS-4 encoded Unicode character that is to be converted to UTF-16. If
  * val is given as a function it is executed only once.
- * \param tmp is a temporary variable and should be of type uint16_t. It
+ * @param tmp is a temporary variable and should be of type uint16_t. It
  * represents an intermediate value during conversion that is to be
  * output by PUT_16BIT.
- * \param PUT_16BIT writes the converted UTF-16 data to any proper destination
+ * @param PUT_16BIT writes the converted UTF-16 data to any proper destination
  * in desired endianness. It could be a function or a statement, and uses tmp
  * as the input byte.  For example, PUT_BYTE could be "*output++ = tmp;"
  * PUT_BYTE will be executed 1 or 2 times depending on input character.
@@ -385,3 +395,6 @@ static av_always_inline av_const int av_popcount_c(uint32_t x)
 #ifndef av_popcount
 #   define av_popcount      av_popcount_c
 #endif
+#ifndef av_popcount64
+#   define av_popcount64    av_popcount64_c
+#endif

3rdparty/include/ffmpeg_/libavutil/cpu.h

@@ -38,6 +38,8 @@
 #define AV_CPU_FLAG_SSE4         0x0100 ///< Penryn SSE4.1 functions
 #define AV_CPU_FLAG_SSE42        0x0200 ///< Nehalem SSE4.2 functions
 #define AV_CPU_FLAG_AVX          0x4000 ///< AVX functions: requires OS support even if YMM registers aren't used
+#define AV_CPU_FLAG_XOP          0x0400 ///< Bulldozer XOP functions
+#define AV_CPU_FLAG_FMA4         0x0800 ///< Bulldozer FMA4 functions
 #define AV_CPU_FLAG_IWMMXT       0x0100 ///< XScale IWMMXT
 #define AV_CPU_FLAG_ALTIVEC      0x0001 ///< standard
 

3rdparty/include/ffmpeg_/libavutil/dict.h

@@ -20,15 +20,56 @@
 /**
  * @file
  * Public dictionary API.
+ * @deprecated
+ *  AVDictionary is provided for compatibility with libav. It is both in
+ *  implementation as well as API inefficient. It does not scale and is
+ *  extremely slow with large dictionaries.
+ *  It is recommended that new code uses our tree container from tree.c/h
+ *  where applicable, which uses AVL trees to achieve O(log n) performance.
  */
 
 #ifndef AVUTIL_DICT_H
 #define AVUTIL_DICT_H
 
+/**
+ * @addtogroup lavu_dict AVDictionary
+ * @ingroup lavu_data
+ *
+ * @brief Simple key:value store
+ *
+ * @{
+ * Dictionaries are used for storing key:value pairs. To create
+ * an AVDictionary, simply pass an address of a NULL pointer to
+ * av_dict_set(). NULL can be used as an empty dictionary wherever
+ * a pointer to an AVDictionary is required.
+ * Use av_dict_get() to retrieve an entry or iterate over all
+ * entries and finally av_dict_free() to free the dictionary
+ * and all its contents.
+ *
+ * @code
+ * AVDictionary *d = NULL;                // "create" an empty dictionary
+ * av_dict_set(&d, "foo", "bar", 0);      // add an entry
+ *
+ * char *k = av_strdup("key");            // if your strings are already allocated,
+ * char *v = av_strdup("value");          // you can avoid copying them like this
+ * av_dict_set(&d, k, v, AV_DICT_DONT_STRDUP_KEY | AV_DICT_DONT_STRDUP_VAL);
+ *
+ * AVDictionaryEntry *t = NULL;
+ * while (t = av_dict_get(d, "", t, AV_DICT_IGNORE_SUFFIX)) {
+ *     <....>                             // iterate over all entries in d
+ * }
+ *
+ * av_dict_free(&d);
+ * @endcode
+ *
+ */
+
 #define AV_DICT_MATCH_CASE      1
 #define AV_DICT_IGNORE_SUFFIX   2
-#define AV_DICT_DONT_STRDUP_KEY 4
-#define AV_DICT_DONT_STRDUP_VAL 8
+#define AV_DICT_DONT_STRDUP_KEY 4   /**< Take ownership of a key that's been
+                                         allocated with av_malloc() and children. */
+#define AV_DICT_DONT_STRDUP_VAL 8   /**< Take ownership of a value that's been
+                                         allocated with av_malloc() and chilren. */
 #define AV_DICT_DONT_OVERWRITE 16   ///< Don't overwrite existing entries.
 #define AV_DICT_APPEND         32   /**< If the entry already exists, append to it.  Note that no
                                       delimiter is added, the strings are simply concatenated. */
@@ -74,8 +115,13 @@ int av_dict_set(AVDictionary **pm, const char *key, const char *value, int flags
 void av_dict_copy(AVDictionary **dst, AVDictionary *src, int flags);
 
 /**
- * Free all the memory allocated for an AVDictionary struct.
+ * Free all the memory allocated for an AVDictionary struct
+ * and all keys and values.
  */
 void av_dict_free(AVDictionary **m);
 
+/**
+ * @}
+ */
+
 #endif // AVUTIL_DICT_H

3rdparty/include/ffmpeg_/libavutil/error.h

@@ -27,6 +27,13 @@
 #include <errno.h>
 #include "avutil.h"
 
+/**
+ * @addtogroup lavu_error
+ *
+ * @{
+ */
+
+
 /* error handling */
 #if EDOM > 0
 #define AVERROR(e) (-(e))   ///< Returns a negative error code from a POSIX error code, to return from library functions.
@@ -38,6 +45,7 @@
 #endif
 
 #define AVERROR_BSF_NOT_FOUND      (-MKTAG(0xF8,'B','S','F')) ///< Bitstream filter not found
+#define AVERROR_BUG                (-MKTAG( 'B','U','G','!')) ///< Internal bug, also see AVERROR_BUG2
 #define AVERROR_DECODER_NOT_FOUND  (-MKTAG(0xF8,'D','E','C')) ///< Decoder not found
 #define AVERROR_DEMUXER_NOT_FOUND  (-MKTAG(0xF8,'D','E','M')) ///< Demuxer not found
 #define AVERROR_ENCODER_NOT_FOUND  (-MKTAG(0xF8,'E','N','C')) ///< Encoder not found
@@ -51,6 +59,13 @@
 #define AVERROR_PROTOCOL_NOT_FOUND (-MKTAG(0xF8,'P','R','O')) ///< Protocol not found
 #define AVERROR_STREAM_NOT_FOUND   (-MKTAG(0xF8,'S','T','R')) ///< Stream not found
 
+/**
+ * This is semantically identical to AVERROR_BUG
+ * it has been introduced in Libav after our AVERROR_BUG and with a modified value.
+ */
+#define AVERROR_BUG2               (-MKTAG( 'B','U','G',' '))
+#define AVERROR_UNKNOWN            (-MKTAG( 'U','N','K','N')) ///< Unknown error, typically from an external library
+
 /**
  * Put a description of the AVERROR code errnum in errbuf.
  * In case of failure the global variable errno is set to indicate the
@@ -65,4 +80,8 @@
  */
 int av_strerror(int errnum, char *errbuf, size_t errbuf_size);
 
+/**
+ * @}
+ */
+
 #endif /* AVUTIL_ERROR_H */

3rdparty/include/ffmpeg_/libavutil/eval.h

@@ -58,7 +58,7 @@ int av_expr_parse_and_eval(double *res, const char *s,
  * Parse an expression.
  *
  * @param expr a pointer where is put an AVExpr containing the parsed
- * value in case of successfull parsing, or NULL otherwise.
+ * value in case of successful parsing, or NULL otherwise.
  * The pointed to AVExpr must be freed with av_expr_free() by the user
  * when it is not needed anymore.
  * @param s expression as a zero terminated string, for example "1+2^3+5*5+sin(2/3)"

3rdparty/include/ffmpeg_/libavutil/fifo.h

@@ -25,6 +25,7 @@
 #define AVUTIL_FIFO_H
 
 #include <stdint.h>
+#include "avutil.h"
 
 typedef struct AVFifoBuffer {
     uint8_t *buffer;
@@ -41,20 +42,20 @@ AVFifoBuffer *av_fifo_alloc(unsigned int size);
 
 /**
  * Free an AVFifoBuffer.
- * @param *f AVFifoBuffer to free
+ * @param f AVFifoBuffer to free
  */
 void av_fifo_free(AVFifoBuffer *f);
 
 /**
  * Reset the AVFifoBuffer to the state right after av_fifo_alloc, in particular it is emptied.
- * @param *f AVFifoBuffer to reset
+ * @param f AVFifoBuffer to reset
  */
 void av_fifo_reset(AVFifoBuffer *f);
 
 /**
  * Return the amount of data in bytes in the AVFifoBuffer, that is the
  * amount of data you can read from it.
- * @param *f AVFifoBuffer to read from
+ * @param f AVFifoBuffer to read from
  * @return size
  */
 int av_fifo_size(AVFifoBuffer *f);
@@ -62,27 +63,27 @@ int av_fifo_size(AVFifoBuffer *f);
 /**
  * Return the amount of space in bytes in the AVFifoBuffer, that is the
  * amount of data you can write into it.
- * @param *f AVFifoBuffer to write into
+ * @param f AVFifoBuffer to write into
  * @return size
  */
 int av_fifo_space(AVFifoBuffer *f);
 
 /**
  * Feed data from an AVFifoBuffer to a user-supplied callback.
- * @param *f AVFifoBuffer to read from
+ * @param f AVFifoBuffer to read from
  * @param buf_size number of bytes to read
- * @param *func generic read function
- * @param *dest data destination
+ * @param func generic read function
+ * @param dest data destination
  */
 int av_fifo_generic_read(AVFifoBuffer *f, void *dest, int buf_size, void (*func)(void*, void*, int));
 
 /**
  * Feed data from a user-supplied callback to an AVFifoBuffer.
- * @param *f AVFifoBuffer to write to
- * @param *src data source; non-const since it may be used as a
+ * @param f AVFifoBuffer to write to
+ * @param src data source; non-const since it may be used as a
  * modifiable context by the function defined in func
  * @param size number of bytes to write
- * @param *func generic write function; the first parameter is src,
+ * @param func generic write function; the first parameter is src,
  * the second is dest_buf, the third is dest_buf_size.
  * func must return the number of bytes written to dest_buf, or <= 0 to
  * indicate no more data available to write.
@@ -93,7 +94,9 @@ int av_fifo_generic_write(AVFifoBuffer *f, void *src, int size, int (*func)(void
 
 /**
  * Resize an AVFifoBuffer.
- * @param *f AVFifoBuffer to resize
+ * In case of reallocation failure, the old FIFO is kept unchanged.
+ *
+ * @param f AVFifoBuffer to resize
  * @param size new AVFifoBuffer size in bytes
  * @return <0 for failure, >=0 otherwise
  */
@@ -101,16 +104,40 @@ int av_fifo_realloc2(AVFifoBuffer *f, unsigned int size);
 
 /**
  * Read and discard the specified amount of data from an AVFifoBuffer.
- * @param *f AVFifoBuffer to read from
+ * @param f AVFifoBuffer to read from
  * @param size amount of data to read in bytes
  */
 void av_fifo_drain(AVFifoBuffer *f, int size);
 
-static inline uint8_t av_fifo_peek(AVFifoBuffer *f, int offs)
+/**
+ * Return a pointer to the data stored in a FIFO buffer at a certain offset.
+ * The FIFO buffer is not modified.
+ *
+ * @param f    AVFifoBuffer to peek at, f must be non-NULL
+ * @param offs an offset in bytes, its absolute value must be less
+ *             than the used buffer size or the returned pointer will
+ *             point outside to the buffer data.
+ *             The used buffer size can be checked with av_fifo_size().
+ */
+static inline uint8_t *av_fifo_peek2(const AVFifoBuffer *f, int offs)
 {
     uint8_t *ptr = f->rptr + offs;
     if (ptr >= f->end)
-        ptr -= f->end - f->buffer;
-    return *ptr;
+        ptr = f->buffer + (ptr - f->end);
+    else if (ptr < f->buffer)
+        ptr = f->end - (f->buffer - ptr);
+    return ptr;
 }
+
+#if FF_API_AV_FIFO_PEEK
+/**
+ * @deprecated Use av_fifo_peek2() instead.
+ */
+attribute_deprecated
+static inline uint8_t av_fifo_peek(AVFifoBuffer *f, int offs)
+{
+    return *av_fifo_peek2(f, offs);
+}
+#endif
+
 #endif /* AVUTIL_FIFO_H */

3rdparty/include/ffmpeg_/libavutil/file.h

@@ -49,4 +49,13 @@ int av_file_map(const char *filename, uint8_t **bufptr, size_t *size,
  */
 void av_file_unmap(uint8_t *bufptr, size_t size);
 
+/**
+ * Wrapper to work around the lack of mkstemp() on mingw.
+ * Also, tries to create file in /tmp first, if possible.
+ * *prefix can be a character constant; *filename will be allocated internally.
+ * @return file descriptor of opened file (or -1 on error)
+ * and opened file name in **filename.
+ */
+int av_tempfile(const char *prefix, char **filename, int log_offset, void *log_ctx);
+
 #endif /* AVUTIL_FILE_H */

3rdparty/include/ffmpeg_/libavutil/imgutils.h

@@ -22,6 +22,9 @@
 /**
  * @file
  * misc image utilities
+ *
+ * @addtogroup lavu_picture
+ * @{
  */
 
 #include "avutil.h"
@@ -106,8 +109,8 @@ void av_image_copy_plane(uint8_t       *dst, int dst_linesize,
 /**
  * Copy image in src_data to dst_data.
  *
- * @param dst_linesize linesizes for the image in dst_data
- * @param src_linesize linesizes for the image in src_data
+ * @param dst_linesizes linesizes for the image in dst_data
+ * @param src_linesizes linesizes for the image in src_data
  */
 void av_image_copy(uint8_t *dst_data[4], int dst_linesizes[4],
                    const uint8_t *src_data[4], const int src_linesizes[4],
@@ -127,4 +130,9 @@ int av_image_check_size(unsigned int w, unsigned int h, int log_offset, void *lo
 
 int ff_set_systematic_pal2(uint32_t pal[256], enum PixelFormat pix_fmt);
 
+/**
+ * @}
+ */
+
+
 #endif /* AVUTIL_IMGUTILS_H */

3rdparty/include/ffmpeg_/libavutil/intfloat.h

@@ -0,0 +1,73 @@
+/*
+ * Copyright (c) 2011 Mans Rullgard
+ *
+ * This file is part of Libav.
+ *
+ * Libav is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * Libav is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with Libav; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#ifndef AVUTIL_INTFLOAT_H
+#define AVUTIL_INTFLOAT_H
+
+#include <stdint.h>
+#include "attributes.h"
+
+union av_intfloat32 {
+    uint32_t i;
+    float    f;
+};
+
+union av_intfloat64 {
+    uint64_t i;
+    double   f;
+};
+
+/**
+ * Reinterpret a 32-bit integer as a float.
+ */
+static av_always_inline float av_int2float(uint32_t i)
+{
+    union av_intfloat32 v = { .i = i };
+    return v.f;
+}
+
+/**
+ * Reinterpret a float as a 32-bit integer.
+ */
+static av_always_inline uint32_t av_float2int(float f)
+{
+    union av_intfloat32 v = { .f = f };
+    return v.i;
+}
+
+/**
+ * Reinterpret a 64-bit integer as a double.
+ */
+static av_always_inline double av_int2double(uint64_t i)
+{
+    union av_intfloat64 v = { .i = i };
+    return v.f;
+}
+
+/**
+ * Reinterpret a double as a 64-bit integer.
+ */
+static av_always_inline uint64_t av_double2int(double f)
+{
+    union av_intfloat64 v = { .f = f };
+    return v.i;
+}
+
+#endif /* AVUTIL_INTFLOAT_H */

3rdparty/include/ffmpeg_/libavutil/intfloat_readwrite.h

@@ -30,11 +30,11 @@ typedef struct AVExtFloat  {
     uint8_t mantissa[8];
 } AVExtFloat;
 
-double av_int2dbl(int64_t v) av_const;
-float av_int2flt(int32_t v) av_const;
-double av_ext2dbl(const AVExtFloat ext) av_const;
-int64_t av_dbl2int(double d) av_const;
-int32_t av_flt2int(float d) av_const;
-AVExtFloat av_dbl2ext(double d) av_const;
+attribute_deprecated double av_int2dbl(int64_t v) av_const;
+attribute_deprecated float av_int2flt(int32_t v) av_const;
+attribute_deprecated double av_ext2dbl(const AVExtFloat ext) av_const;
+attribute_deprecated int64_t av_dbl2int(double d) av_const;
+attribute_deprecated int32_t av_flt2int(float d) av_const;
+attribute_deprecated AVExtFloat av_dbl2ext(double d) av_const;
 
 #endif /* AVUTIL_INTFLOAT_READWRITE_H */

3rdparty/include/ffmpeg_/libavutil/log.h

@@ -23,13 +23,14 @@
 
 #include <stdarg.h>
 #include "avutil.h"
+#include "attributes.h"
 
 /**
  * Describe the class of an AVClass context structure. That is an
  * arbitrary struct of which the first field is a pointer to an
  * AVClass struct (e.g. AVCodecContext, AVFormatContext etc.).
  */
-typedef struct {
+typedef struct AVClass {
     /**
      * The name of the class; usually it is the same name as the
      * context structure type to which the AVClass is associated.
@@ -72,11 +73,19 @@ typedef struct {
     int parent_log_context_offset;
 
     /**
-     * A function for extended searching, e.g. in possible
-     * children objects.
+     * Return next AVOptions-enabled child or NULL
      */
-    const struct AVOption* (*opt_find)(void *obj, const char *name, const char *unit,
-                                       int opt_flags, int search_flags);
+    void* (*child_next)(void *obj, void *prev);
+
+    /**
+     * Return an AVClass corresponding to next potential
+     * AVOptions-enabled child.
+     *
+     * The difference between child_next and this is that
+     * child_next iterates over _already existing_ objects, while
+     * child_class_next iterates over _all possible_ children.
+     */
+    const struct AVClass* (*child_class_next)(const struct AVClass *prev);
 } AVClass;
 
 /* av_log API */
@@ -129,11 +138,7 @@ typedef struct {
  * subsequent arguments are converted to output.
  * @see av_vlog
  */
-#ifdef __GNUC__
-void av_log(void *avcl, int level, const char *fmt, ...) __attribute__ ((__format__ (__printf__, 3, 4)));
-#else
-void av_log(void *avcl, int level, const char *fmt, ...);
-#endif
+void av_log(void *avcl, int level, const char *fmt, ...) av_printf_format(3, 4);
 
 void av_vlog(void *avcl, int level, const char *fmt, va_list);
 int av_log_get_level(void);
@@ -142,6 +147,16 @@ void av_log_set_callback(void (*)(void*, int, const char*, va_list));
 void av_log_default_callback(void* ptr, int level, const char* fmt, va_list vl);
 const char* av_default_item_name(void* ctx);
 
+/**
+ * Format a line of log the same way as the default callback.
+ * @param line          buffer to receive the formated line
+ * @param line_size     size of the buffer
+ * @param print_prefix  used to store whether the prefix must be printed;
+ *                      must point to a persistent integer initially set to 1
+ */
+void av_log_format_line(void *ptr, int level, const char *fmt, va_list vl,
+                        char *line, int line_size, int *print_prefix);
+
 /**
  * av_dlog macros
  * Useful to print debug messages that shouldn't get compiled in normally.

3rdparty/include/ffmpeg_/libavutil/lzo.h

@@ -22,30 +22,37 @@
 #ifndef AVUTIL_LZO_H
 #define AVUTIL_LZO_H
 
+/**
+ * @defgroup lavu_lzo LZO
+ * @ingroup lavu_crypto
+ *
+ * @{
+ */
+
 #include <stdint.h>
 
 /** @name Error flags returned by av_lzo1x_decode
-  * \{ */
-//! end of the input buffer reached before decoding finished
+  * @{ */
+/// end of the input buffer reached before decoding finished
 #define AV_LZO_INPUT_DEPLETED 1
-//! decoded data did not fit into output buffer
+/// decoded data did not fit into output buffer
 #define AV_LZO_OUTPUT_FULL 2
-//! a reference to previously decoded data was wrong
+/// a reference to previously decoded data was wrong
 #define AV_LZO_INVALID_BACKPTR 4
-//! a non-specific error in the compressed bitstream
+/// a non-specific error in the compressed bitstream
 #define AV_LZO_ERROR 8
-/** \} */
+/** @} */
 
 #define AV_LZO_INPUT_PADDING 8
 #define AV_LZO_OUTPUT_PADDING 12
 
 /**
- * \brief Decodes LZO 1x compressed data.
- * \param out output buffer
- * \param outlen size of output buffer, number of bytes left are returned here
- * \param in input buffer
- * \param inlen size of input buffer, number of bytes left are returned here
- * \return 0 on success, otherwise a combination of the error flags above
+ * @brief Decodes LZO 1x compressed data.
+ * @param out output buffer
+ * @param outlen size of output buffer, number of bytes left are returned here
+ * @param in input buffer
+ * @param inlen size of input buffer, number of bytes left are returned here
+ * @return 0 on success, otherwise a combination of the error flags above
  *
  * Make sure all buffers are appropriately padded, in must provide
  * AV_LZO_INPUT_PADDING, out must provide AV_LZO_OUTPUT_PADDING additional bytes.
@@ -53,14 +60,18 @@
 int av_lzo1x_decode(void *out, int *outlen, const void *in, int *inlen);
 
 /**
- * \brief deliberately overlapping memcpy implementation
- * \param dst destination buffer; must be padded with 12 additional bytes
- * \param back how many bytes back we start (the initial size of the overlapping window)
- * \param cnt number of bytes to copy, must be >= 0
+ * @brief deliberately overlapping memcpy implementation
+ * @param dst destination buffer; must be padded with 12 additional bytes
+ * @param back how many bytes back we start (the initial size of the overlapping window), must be > 0
+ * @param cnt number of bytes to copy, must be >= 0
  *
  * cnt > back is valid, this will copy the bytes we just copied,
  * thus creating a repeating pattern with a period length of back.
  */
 void av_memcpy_backptr(uint8_t *dst, int back, int cnt);
 
+/**
+ * @}
+ */
+
 #endif /* AVUTIL_LZO_H */

3rdparty/include/ffmpeg_/libavutil/mathematics.h

@@ -57,6 +57,12 @@
 #define INFINITY       (1.0/0.0)
 #endif
 
+/**
+ * @addtogroup lavu_math
+ * @{
+ */
+
+
 enum AVRounding {
     AV_ROUND_ZERO     = 0, ///< Round toward zero.
     AV_ROUND_INF      = 1, ///< Round away from zero.
@@ -109,4 +115,8 @@ int av_compare_ts(int64_t ts_a, AVRational tb_a, int64_t ts_b, AVRational tb_b);
  */
 int64_t av_compare_mod(uint64_t a, uint64_t b, uint64_t mod);
 
+/**
+ * @}
+ */
+
 #endif /* AVUTIL_MATHEMATICS_H */

3rdparty/include/ffmpeg_/libavutil/md5.h

@@ -23,6 +23,12 @@
 
 #include <stdint.h>
 
+/**
+ * @defgroup lavu_md5 MD5
+ * @ingroup lavu_crypto
+ * @{
+ */
+
 extern const int av_md5_size;
 
 struct AVMD5;
@@ -32,5 +38,9 @@ void av_md5_update(struct AVMD5 *ctx, const uint8_t *src, const int len);
 void av_md5_final(struct AVMD5 *ctx, uint8_t *dst);
 void av_md5_sum(uint8_t *dst, const uint8_t *src, const int len);
 
+/**
+ * @}
+ */
+
 #endif /* AVUTIL_MD5_H */
 

3rdparty/include/ffmpeg_/libavutil/mem.h

@@ -27,8 +27,15 @@
 #define AVUTIL_MEM_H
 
 #include "attributes.h"
+#include "error.h"
 #include "avutil.h"
 
+/**
+ * @addtogroup lavu_mem
+ * @{
+ */
+
+
 #if defined(__INTEL_COMPILER) && __INTEL_COMPILER < 1110 || defined(__SUNPRO_C)
     #define DECLARE_ALIGNED(n,t,v)      t __attribute__ ((aligned (n))) v
     #define DECLARE_ASM_CONST(n,t,v)    const t __attribute__ ((aligned (n))) v
@@ -76,16 +83,26 @@ void *av_malloc(size_t size) av_malloc_attrib av_alloc_size(1);
  * Allocate or reallocate a block of memory.
  * If ptr is NULL and size > 0, allocate a new block. If
  * size is zero, free the memory block pointed to by ptr.
- * @param size Size in bytes for the memory block to be allocated or
- * reallocated.
  * @param ptr Pointer to a memory block already allocated with
  * av_malloc(z)() or av_realloc() or NULL.
+ * @param size Size in bytes for the memory block to be allocated or
+ * reallocated.
  * @return Pointer to a newly reallocated block or NULL if the block
  * cannot be reallocated or the function is used to free the memory block.
  * @see av_fast_realloc()
  */
 void *av_realloc(void *ptr, size_t size) av_alloc_size(2);
 
+/**
+ * Allocate or reallocate a block of memory.
+ * This function does the same thing as av_realloc, except:
+ * - It takes two arguments and checks the result of the multiplication for
+ *   integer overflow.
+ * - It frees the input block in case of failure, thus avoiding the memory
+ *   leak with the classic "buf = realloc(buf); if (!buf) return -1;".
+ */
+void *av_realloc_f(void *ptr, size_t nelem, size_t elsize);
+
 /**
  * Free a memory block which has been allocated with av_malloc(z)() or
  * av_realloc().
@@ -106,6 +123,18 @@ void av_free(void *ptr);
  */
 void *av_mallocz(size_t size) av_malloc_attrib av_alloc_size(1);
 
+/**
+ * Allocate a block of nmemb * size bytes with alignment suitable for all
+ * memory accesses (including vectors if available on the CPU) and
+ * zero all the bytes of the block.
+ * The allocation will fail if nmemb * size is greater than or equal
+ * to INT_MAX.
+ * @param nmemb
+ * @param size
+ * @return Pointer to the allocated block, NULL if it cannot be allocated.
+ */
+void *av_calloc(size_t nmemb, size_t size) av_malloc_attrib;
+
 /**
  * Duplicate the string s.
  * @param s string to be duplicated
@@ -132,4 +161,28 @@ void av_freep(void *ptr);
  */
 void av_dynarray_add(void *tab_ptr, int *nb_ptr, void *elem);
 
+/**
+ * Multiply two size_t values checking for overflow.
+ * @return  0 if success, AVERROR(EINVAL) if overflow.
+ */
+static inline int av_size_mult(size_t a, size_t b, size_t *r)
+{
+    size_t t = a * b;
+    /* Hack inspired from glibc: only try the division if nelem and elsize
+     * are both greater than sqrt(SIZE_MAX). */
+    if ((a | b) >= ((size_t)1 << (sizeof(size_t) * 4)) && a && t / a != b)
+        return AVERROR(EINVAL);
+    *r = t;
+    return 0;
+}
+
+/**
+ * Set the maximum size that may me allocated in one block.
+ */
+void av_max_alloc(size_t max);
+
+/**
+ * @}
+ */
+
 #endif /* AVUTIL_MEM_H */

3rdparty/include/ffmpeg_/libavutil/opt.h

@@ -30,9 +30,203 @@
 #include "rational.h"
 #include "avutil.h"
 #include "dict.h"
+#include "log.h"
+
+/**
+ * @defgroup avoptions AVOptions
+ * @ingroup lavu_data
+ * @{
+ * AVOptions provide a generic system to declare options on arbitrary structs
+ * ("objects"). An option can have a help text, a type and a range of possible
+ * values. Options may then be enumerated, read and written to.
+ *
+ * @section avoptions_implement Implementing AVOptions
+ * This section describes how to add AVOptions capabilities to a struct.
+ *
+ * All AVOptions-related information is stored in an AVClass. Therefore
+ * the first member of the struct must be a pointer to an AVClass describing it.
+ * The option field of the AVClass must be set to a NULL-terminated static array
+ * of AVOptions. Each AVOption must have a non-empty name, a type, a default
+ * value and for number-type AVOptions also a range of allowed values. It must
+ * also declare an offset in bytes from the start of the struct, where the field
+ * associated with this AVOption is located. Other fields in the AVOption struct
+ * should also be set when applicable, but are not required.
+ *
+ * The following example illustrates an AVOptions-enabled struct:
+ * @code
+ * typedef struct test_struct {
+ *     AVClass *class;
+ *     int      int_opt;
+ *     char    *str_opt;
+ *     uint8_t *bin_opt;
+ *     int      bin_len;
+ * } test_struct;
+ *
+ * static const AVOption options[] = {
+ *   { "test_int", "This is a test option of int type.", offsetof(test_struct, int_opt),
+ *     AV_OPT_TYPE_INT, { -1 }, INT_MIN, INT_MAX },
+ *   { "test_str", "This is a test option of string type.", offsetof(test_struct, str_opt),
+ *     AV_OPT_TYPE_STRING },
+ *   { "test_bin", "This is a test option of binary type.", offsetof(test_struct, bin_opt),
+ *     AV_OPT_TYPE_BINARY },
+ *   { NULL },
+ * };
+ *
+ * static const AVClass test_class = {
+ *     .class_name = "test class",
+ *     .item_name  = av_default_item_name,
+ *     .option     = options,
+ *     .version    = LIBAVUTIL_VERSION_INT,
+ * };
+ * @endcode
+ *
+ * Next, when allocating your struct, you must ensure that the AVClass pointer
+ * is set to the correct value. Then, av_opt_set_defaults() must be called to
+ * initialize defaults. After that the struct is ready to be used with the
+ * AVOptions API.
+ *
+ * When cleaning up, you may use the av_opt_free() function to automatically
+ * free all the allocated string and binary options.
+ *
+ * Continuing with the above example:
+ *
+ * @code
+ * test_struct *alloc_test_struct(void)
+ * {
+ *     test_struct *ret = av_malloc(sizeof(*ret));
+ *     ret->class = &test_class;
+ *     av_opt_set_defaults(ret);
+ *     return ret;
+ * }
+ * void free_test_struct(test_struct **foo)
+ * {
+ *     av_opt_free(*foo);
+ *     av_freep(foo);
+ * }
+ * @endcode
+ *
+ * @subsection avoptions_implement_nesting Nesting
+ *      It may happen that an AVOptions-enabled struct contains another
+ *      AVOptions-enabled struct as a member (e.g. AVCodecContext in
+ *      libavcodec exports generic options, while its priv_data field exports
+ *      codec-specific options). In such a case, it is possible to set up the
+ *      parent struct to export a child's options. To do that, simply
+ *      implement AVClass.child_next() and AVClass.child_class_next() in the
+ *      parent struct's AVClass.
+ *      Assuming that the test_struct from above now also contains a
+ *      child_struct field:
+ *
+ *      @code
+ *      typedef struct child_struct {
+ *          AVClass *class;
+ *          int flags_opt;
+ *      } child_struct;
+ *      static const AVOption child_opts[] = {
+ *          { "test_flags", "This is a test option of flags type.",
+ *            offsetof(child_struct, flags_opt), AV_OPT_TYPE_FLAGS, { 0 }, INT_MIN, INT_MAX },
+ *          { NULL },
+ *      };
+ *      static const AVClass child_class = {
+ *          .class_name = "child class",
+ *          .item_name  = av_default_item_name,
+ *          .option     = child_opts,
+ *          .version    = LIBAVUTIL_VERSION_INT,
+ *      };
+ *
+ *      void *child_next(void *obj, void *prev)
+ *      {
+ *          test_struct *t = obj;
+ *          if (!prev && t->child_struct)
+ *              return t->child_struct;
+ *          return NULL
+ *      }
+ *      const AVClass child_class_next(const AVClass *prev)
+ *      {
+ *          return prev ? NULL : &child_class;
+ *      }
+ *      @endcode
+ *      Putting child_next() and child_class_next() as defined above into
+ *      test_class will now make child_struct's options accessible through
+ *      test_struct (again, proper setup as described above needs to be done on
+ *      child_struct right after it is created).
+ *
+ *      From the above example it might not be clear why both child_next()
+ *      and child_class_next() are needed. The distinction is that child_next()
+ *      iterates over actually existing objects, while child_class_next()
+ *      iterates over all possible child classes. E.g. if an AVCodecContext
+ *      was initialized to use a codec which has private options, then its
+ *      child_next() will return AVCodecContext.priv_data and finish
+ *      iterating. OTOH child_class_next() on AVCodecContext.av_class will
+ *      iterate over all available codecs with private options.
+ *
+ * @subsection avoptions_implement_named_constants Named constants
+ *      It is possible to create named constants for options. Simply set the unit
+ *      field of the option the constants should apply to to a string and
+ *      create the constants themselves as options of type AV_OPT_TYPE_CONST
+ *      with their unit field set to the same string.
+ *      Their default_val field should contain the value of the named
+ *      constant.
+ *      For example, to add some named constants for the test_flags option
+ *      above, put the following into the child_opts array:
+ *      @code
+ *      { "test_flags", "This is a test option of flags type.",
+ *        offsetof(child_struct, flags_opt), AV_OPT_TYPE_FLAGS, { 0 }, INT_MIN, INT_MAX, "test_unit" },
+ *      { "flag1", "This is a flag with value 16", 0, AV_OPT_TYPE_CONST, { 16 }, 0, 0, "test_unit" },
+ *      @endcode
+ *
+ * @section avoptions_use Using AVOptions
+ * This section deals with accessing options in an AVOptions-enabled struct.
+ * Such structs in FFmpeg are e.g. AVCodecContext in libavcodec or
+ * AVFormatContext in libavformat.
+ *
+ * @subsection avoptions_use_examine Examining AVOptions
+ * The basic functions for examining options are av_opt_next(), which iterates
+ * over all options defined for one object, and av_opt_find(), which searches
+ * for an option with the given name.
+ *
+ * The situation is more complicated with nesting. An AVOptions-enabled struct
+ * may have AVOptions-enabled children. Passing the AV_OPT_SEARCH_CHILDREN flag
+ * to av_opt_find() will make the function search children recursively.
+ *
+ * For enumerating there are basically two cases. The first is when you want to
+ * get all options that may potentially exist on the struct and its children
+ * (e.g.  when constructing documentation). In that case you should call
+ * av_opt_child_class_next() recursively on the parent struct's AVClass.  The
+ * second case is when you have an already initialized struct with all its
+ * children and you want to get all options that can be actually written or read
+ * from it. In that case you should call av_opt_child_next() recursively (and
+ * av_opt_next() on each result).
+ *
+ * @subsection avoptions_use_get_set Reading and writing AVOptions
+ * When setting options, you often have a string read directly from the
+ * user. In such a case, simply passing it to av_opt_set() is enough. For
+ * non-string type options, av_opt_set() will parse the string according to the
+ * option type.
+ *
+ * Similarly av_opt_get() will read any option type and convert it to a string
+ * which will be returned. Do not forget that the string is allocated, so you
+ * have to free it with av_free().
+ *
+ * In some cases it may be more convenient to put all options into an
+ * AVDictionary and call av_opt_set_dict() on it. A specific case of this
+ * are the format/codec open functions in lavf/lavc which take a dictionary
+ * filled with option as a parameter. This allows to set some options
+ * that cannot be set otherwise, since e.g. the input file format is not known
+ * before the file is actually opened.
+ */
 
 enum AVOptionType{
-    FF_OPT_TYPE_FLAGS,
+    AV_OPT_TYPE_FLAGS,
+    AV_OPT_TYPE_INT,
+    AV_OPT_TYPE_INT64,
+    AV_OPT_TYPE_DOUBLE,
+    AV_OPT_TYPE_FLOAT,
+    AV_OPT_TYPE_STRING,
+    AV_OPT_TYPE_RATIONAL,
+    AV_OPT_TYPE_BINARY,  ///< offset must point to a pointer immediately followed by an int for the length
+    AV_OPT_TYPE_CONST = 128,
+#if FF_API_OLD_AVOPTIONS
+    FF_OPT_TYPE_FLAGS = 0,
     FF_OPT_TYPE_INT,
     FF_OPT_TYPE_INT64,
     FF_OPT_TYPE_DOUBLE,
@@ -41,6 +235,7 @@ enum AVOptionType{
     FF_OPT_TYPE_RATIONAL,
     FF_OPT_TYPE_BINARY,  ///< offset must point to a pointer immediately followed by an int for the length
     FF_OPT_TYPE_CONST=128,
+#endif
 };
 
 /**
@@ -111,6 +306,7 @@ attribute_deprecated
 const AVOption *av_find_opt(void *obj, const char *name, const char *unit, int mask, int flags);
 #endif
 
+#if FF_API_OLD_AVOPTIONS
 /**
  * Set the field of obj with the given name to value.
  *
@@ -129,25 +325,27 @@ const AVOption *av_find_opt(void *obj, const char *name, const char *unit, int m
  * similarly, '-' unsets a flag.
  * @param[out] o_out if non-NULL put here a pointer to the AVOption
  * found
- * @param alloc when 1 then the old value will be av_freed() and the
- *                     new av_strduped()
- *              when 0 then no av_free() nor av_strdup() will be used
+ * @param alloc this parameter is currently ignored
  * @return 0 if the value has been set, or an AVERROR code in case of
  * error:
- * AVERROR(ENOENT) if no matching option exists
+ * AVERROR_OPTION_NOT_FOUND if no matching option exists
  * AVERROR(ERANGE) if the value is out of range
  * AVERROR(EINVAL) if the value is not valid
+ * @deprecated use av_opt_set()
  */
+attribute_deprecated
 int av_set_string3(void *obj, const char *name, const char *val, int alloc, const AVOption **o_out);
 
-const AVOption *av_set_double(void *obj, const char *name, double n);
-const AVOption *av_set_q(void *obj, const char *name, AVRational n);
-const AVOption *av_set_int(void *obj, const char *name, int64_t n);
+attribute_deprecated const AVOption *av_set_double(void *obj, const char *name, double n);
+attribute_deprecated const AVOption *av_set_q(void *obj, const char *name, AVRational n);
+attribute_deprecated const AVOption *av_set_int(void *obj, const char *name, int64_t n);
+
 double av_get_double(void *obj, const char *name, const AVOption **o_out);
 AVRational av_get_q(void *obj, const char *name, const AVOption **o_out);
 int64_t av_get_int(void *obj, const char *name, const AVOption **o_out);
-const char *av_get_string(void *obj, const char *name, const AVOption **o_out, char *buf, int buf_len);
-const AVOption *av_next_option(void *obj, const AVOption *last);
+attribute_deprecated const char *av_get_string(void *obj, const char *name, const AVOption **o_out, char *buf, int buf_len);
+attribute_deprecated const AVOption *av_next_option(void *obj, const AVOption *last);
+#endif
 
 /**
  * Show the obj options.
@@ -160,8 +358,17 @@ const AVOption *av_next_option(void *obj, const AVOption *last);
  */
 int av_opt_show2(void *obj, void *av_log_obj, int req_flags, int rej_flags);
 
+/**
+ * Set the values of all AVOption fields to their default values.
+ *
+ * @param s an AVOption-enabled struct (its first member must be a pointer to AVClass)
+ */
 void av_opt_set_defaults(void *s);
+
+#if FF_API_OLD_AVOPTIONS
+attribute_deprecated
 void av_opt_set_defaults2(void *s, int mask, int flags);
+#endif
 
 /**
  * Parse the key/value pairs list in opts. For each key/value pair
@@ -214,8 +421,39 @@ int av_opt_flag_is_set(void *obj, const char *field_name, const char *flag_name)
  */
 int av_opt_set_dict(void *obj, struct AVDictionary **options);
 
+/**
+ * @defgroup opt_eval_funcs Evaluating option strings
+ * @{
+ * This group of functions can be used to evaluate option strings
+ * and get numbers out of them. They do the same thing as av_opt_set(),
+ * except the result is written into the caller-supplied pointer.
+ *
+ * @param obj a struct whose first element is a pointer to AVClass.
+ * @param o an option for which the string is to be evaluated.
+ * @param val string to be evaluated.
+ * @param *_out value of the string will be written here.
+ *
+ * @return 0 on success, a negative number on failure.
+ */
+int av_opt_eval_flags (void *obj, const AVOption *o, const char *val, int        *flags_out);
+int av_opt_eval_int   (void *obj, const AVOption *o, const char *val, int        *int_out);
+int av_opt_eval_int64 (void *obj, const AVOption *o, const char *val, int64_t    *int64_out);
+int av_opt_eval_float (void *obj, const AVOption *o, const char *val, float      *float_out);
+int av_opt_eval_double(void *obj, const AVOption *o, const char *val, double     *double_out);
+int av_opt_eval_q     (void *obj, const AVOption *o, const char *val, AVRational *q_out);
+/**
+ * @}
+ */
+
 #define AV_OPT_SEARCH_CHILDREN   0x0001 /**< Search in possible children of the
                                              given object first. */
+/**
+ *  The obj passed to av_opt_find() is fake -- only a double pointer to AVClass
+ *  instead of a required pointer to a struct containing AVClass. This is
+ *  useful for searching for options without needing to allocate the corresponding
+ *  object.
+ */
+#define AV_OPT_SEARCH_FAKE_OBJ   0x0002
 
 /**
  * Look for an option in an object. Consider only options which
@@ -223,6 +461,8 @@ int av_opt_set_dict(void *obj, struct AVDictionary **options);
  *
  * @param[in] obj A pointer to a struct whose first element is a
  *                pointer to an AVClass.
+ *                Alternatively a double pointer to an AVClass, if
+ *                AV_OPT_SEARCH_FAKE_OBJ search flag is set.
  * @param[in] name The name of the option to look for.
  * @param[in] unit When searching for named constants, name of the unit
  *                 it belongs to.
@@ -240,4 +480,124 @@ int av_opt_set_dict(void *obj, struct AVDictionary **options);
 const AVOption *av_opt_find(void *obj, const char *name, const char *unit,
                             int opt_flags, int search_flags);
 
+/**
+ * Look for an option in an object. Consider only options which
+ * have all the specified flags set.
+ *
+ * @param[in] obj A pointer to a struct whose first element is a
+ *                pointer to an AVClass.
+ *                Alternatively a double pointer to an AVClass, if
+ *                AV_OPT_SEARCH_FAKE_OBJ search flag is set.
+ * @param[in] name The name of the option to look for.
+ * @param[in] unit When searching for named constants, name of the unit
+ *                 it belongs to.
+ * @param opt_flags Find only options with all the specified flags set (AV_OPT_FLAG).
+ * @param search_flags A combination of AV_OPT_SEARCH_*.
+ * @param[out] target_obj if non-NULL, an object to which the option belongs will be
+ * written here. It may be different from obj if AV_OPT_SEARCH_CHILDREN is present
+ * in search_flags. This parameter is ignored if search_flags contain
+ * AV_OPT_SEARCH_FAKE_OBJ.
+ *
+ * @return A pointer to the option found, or NULL if no option
+ *         was found.
+ */
+const AVOption *av_opt_find2(void *obj, const char *name, const char *unit,
+                             int opt_flags, int search_flags, void **target_obj);
+
+/**
+ * Iterate over all AVOptions belonging to obj.
+ *
+ * @param obj an AVOptions-enabled struct or a double pointer to an
+ *            AVClass describing it.
+ * @param prev result of the previous call to av_opt_next() on this object
+ *             or NULL
+ * @return next AVOption or NULL
+ */
+const AVOption *av_opt_next(void *obj, const AVOption *prev);
+
+/**
+ * Iterate over AVOptions-enabled children of obj.
+ *
+ * @param prev result of a previous call to this function or NULL
+ * @return next AVOptions-enabled child or NULL
+ */
+void *av_opt_child_next(void *obj, void *prev);
+
+/**
+ * Iterate over potential AVOptions-enabled children of parent.
+ *
+ * @param prev result of a previous call to this function or NULL
+ * @return AVClass corresponding to next potential child or NULL
+ */
+const AVClass *av_opt_child_class_next(const AVClass *parent, const AVClass *prev);
+
+/**
+ * @defgroup opt_set_funcs Option setting functions
+ * @{
+ * Those functions set the field of obj with the given name to value.
+ *
+ * @param[in] obj A struct whose first element is a pointer to an AVClass.
+ * @param[in] name the name of the field to set
+ * @param[in] val The value to set. In case of av_opt_set() if the field is not
+ * of a string type, then the given string is parsed.
+ * SI postfixes and some named scalars are supported.
+ * If the field is of a numeric type, it has to be a numeric or named
+ * scalar. Behavior with more than one scalar and +- infix operators
+ * is undefined.
+ * If the field is of a flags type, it has to be a sequence of numeric
+ * scalars or named flags separated by '+' or '-'. Prefixing a flag
+ * with '+' causes it to be set without affecting the other flags;
+ * similarly, '-' unsets a flag.
+ * @param search_flags flags passed to av_opt_find2. I.e. if AV_OPT_SEARCH_CHILDREN
+ * is passed here, then the option may be set on a child of obj.
+ *
+ * @return 0 if the value has been set, or an AVERROR code in case of
+ * error:
+ * AVERROR_OPTION_NOT_FOUND if no matching option exists
+ * AVERROR(ERANGE) if the value is out of range
+ * AVERROR(EINVAL) if the value is not valid
+ */
+int av_opt_set       (void *obj, const char *name, const char *val, int search_flags);
+int av_opt_set_int   (void *obj, const char *name, int64_t     val, int search_flags);
+int av_opt_set_double(void *obj, const char *name, double      val, int search_flags);
+int av_opt_set_q     (void *obj, const char *name, AVRational  val, int search_flags);
+/**
+ * @}
+ */
+
+/**
+ * @defgroup opt_get_funcs Option getting functions
+ * @{
+ * Those functions get a value of the option with the given name from an object.
+ *
+ * @param[in] obj a struct whose first element is a pointer to an AVClass.
+ * @param[in] name name of the option to get.
+ * @param[in] search_flags flags passed to av_opt_find2. I.e. if AV_OPT_SEARCH_CHILDREN
+ * is passed here, then the option may be found in a child of obj.
+ * @param[out] out_val value of the option will be written here
+ * @return 0 on success, a negative error code otherwise
+ */
+/**
+ * @note the returned string will av_malloc()ed and must be av_free()ed by the caller
+ */
+int av_opt_get       (void *obj, const char *name, int search_flags, uint8_t   **out_val);
+int av_opt_get_int   (void *obj, const char *name, int search_flags, int64_t    *out_val);
+int av_opt_get_double(void *obj, const char *name, int search_flags, double     *out_val);
+int av_opt_get_q     (void *obj, const char *name, int search_flags, AVRational *out_val);
+/**
+ * @}
+ */
+/**
+ * Gets a pointer to the requested field in a struct.
+ * This function allows accessing a struct even when its fields are moved or
+ * renamed since the application making the access has been compiled,
+ *
+ * @returns a pointer to the field, it can be cast to the correct type and read
+ *          or written to.
+ */
+void *av_opt_ptr(const AVClass *avclass, void *obj, const char *name);
+/**
+ * @}
+ */
+
 #endif /* AVUTIL_OPT_H */

3rdparty/include/ffmpeg_/libavutil/parseutils.h

@@ -19,6 +19,8 @@
 #ifndef AVUTIL_PARSEUTILS_H
 #define AVUTIL_PARSEUTILS_H
 
+#include <time.h>
+
 #include "rational.h"
 
 /**
@@ -73,7 +75,7 @@ int av_parse_color(uint8_t *rgba_color, const char *color_string, int slen,
                    void *log_ctx);
 
 /**
- * Parses timestr and returns in *time a corresponding number of
+ * Parse timestr and return in *time a corresponding number of
  * microseconds.
  *
  * @param timeval puts here the number of microseconds corresponding
@@ -83,7 +85,7 @@ int av_parse_color(uint8_t *rgba_color, const char *color_string, int slen,
  * January, 1970 up to the time of the parsed date.  If timestr cannot
  * be successfully parsed, set *time to INT64_MIN.
 
- * @param datestr a string representing a date or a duration.
+ * @param timestr a string representing a date or a duration.
  * - If a date the syntax is:
  * @code
  * [{YYYY-MM-DD|YYYYMMDD}[T|t| ]]{{HH[:MM[:SS[.m...]]]}|{HH[MM[SS[.m...]]]}}[Z]
@@ -114,4 +116,9 @@ int av_parse_time(int64_t *timeval, const char *timestr, int duration);
  */
 int av_find_info_tag(char *arg, int arg_size, const char *tag1, const char *info);
 
+/**
+ * Convert the decomposed UTC time in tm to a time_t value.
+ */
+time_t av_timegm(struct tm *tm);
+
 #endif /* AVUTIL_PARSEUTILS_H */

3rdparty/include/ffmpeg_/libavutil/pixdesc.h

@@ -87,6 +87,8 @@ typedef struct AVPixFmtDescriptor{
 #define PIX_FMT_PAL       2 ///< Pixel format has a palette in data[1], values are indexes in this palette.
 #define PIX_FMT_BITSTREAM 4 ///< All values of a component are bit-wise packed end to end.
 #define PIX_FMT_HWACCEL   8 ///< Pixel format is an HW accelerated format.
+#define PIX_FMT_PLANAR   16 ///< At least one pixel component is not in the first data plane
+#define PIX_FMT_RGB      32 ///< The pixel format contains RGB-like data (as opposed to YUV/grayscale)
 
 /**
  * The array of all the pixel format descriptors.

3rdparty/include/ffmpeg_/libavutil/pixfmt.h

@@ -25,21 +25,21 @@
  * @file
  * pixel format definitions
  *
- * @warning This file has to be considered an internal but installed
- * header, so it should not be directly included in your projects.
  */
 
 #include "libavutil/avconfig.h"
 
 /**
- * Pixel format. Notes:
+ * Pixel format.
  *
+ * @note
  * PIX_FMT_RGB32 is handled in an endian-specific manner. An RGBA
  * color is put together as:
  *  (A << 24) | (R << 16) | (G << 8) | B
  * This is stored as BGRA on little-endian CPU architectures and ARGB on
  * big-endian CPUs.
  *
+ * @par
  * When the pixel format is palettized RGB (PIX_FMT_PAL8), the palettized
  * image data is stored in AVFrame.data[0]. The palette is transported in
  * AVFrame.data[1], is 1024 bytes long (256 4-byte entries) and is
@@ -49,13 +49,15 @@
  * This is important as many custom PAL8 video codecs that were designed
  * to run on the IBM VGA graphics adapter use 6-bit palette components.
  *
+ * @par
  * For all the 8bit per pixel formats, an RGB32 palette is in data[1] like
  * for pal8. This palette is filled in automatically by the function
  * allocating the picture.
  *
- * Note, make sure that all newly added big endian formats have pix_fmt&1==1
- *       and that all newly added little endian formats have pix_fmt&1==0
- *       this allows simpler detection of big vs little endian.
+ * @note
+ * make sure that all newly added big endian formats have pix_fmt&1==1
+ * and that all newly added little endian formats have pix_fmt&1==0
+ * this allows simpler detection of big vs little endian.
  */
 enum PixelFormat {
     PIX_FMT_NONE= -1,
@@ -143,17 +145,45 @@ enum PixelFormat {
     PIX_FMT_YUV420P9LE, ///< planar YUV 4:2:0, 13.5bpp, (1 Cr & Cb sample per 2x2 Y samples), little-endian
     PIX_FMT_YUV420P10BE,///< planar YUV 4:2:0, 15bpp, (1 Cr & Cb sample per 2x2 Y samples), big-endian
     PIX_FMT_YUV420P10LE,///< planar YUV 4:2:0, 15bpp, (1 Cr & Cb sample per 2x2 Y samples), little-endian
-    PIX_FMT_YUV422P10BE,///< planar YUV 4:2:2, 20bpp, (1 Cr & Cb sample per 2x1 Y samples), little-endian
-    PIX_FMT_YUV422P10LE,///< planar YUV 4:2:2, 20bpp, (1 Cr & Cb sample per 2x1 Y samples), big-endian
-    PIX_FMT_YUV444P9BE, ///< planar YUV 4:4:4, 27bpp, (1 Cr & Cb sample per 1x1 Y samples), little-endian
-    PIX_FMT_YUV444P9LE, ///< planar YUV 4:4:4, 27bpp, (1 Cr & Cb sample per 1x1 Y samples), big-endian
-    PIX_FMT_YUV444P10BE,///< planar YUV 4:4:4, 30bpp, (1 Cr & Cb sample per 1x1 Y samples), little-endian
-    PIX_FMT_YUV444P10LE,///< planar YUV 4:4:4, 30bpp, (1 Cr & Cb sample per 1x1 Y samples), big-endian
+    PIX_FMT_YUV422P10BE,///< planar YUV 4:2:2, 20bpp, (1 Cr & Cb sample per 2x1 Y samples), big-endian
+    PIX_FMT_YUV422P10LE,///< planar YUV 4:2:2, 20bpp, (1 Cr & Cb sample per 2x1 Y samples), little-endian
+    PIX_FMT_YUV444P9BE, ///< planar YUV 4:4:4, 27bpp, (1 Cr & Cb sample per 1x1 Y samples), big-endian
+    PIX_FMT_YUV444P9LE, ///< planar YUV 4:4:4, 27bpp, (1 Cr & Cb sample per 1x1 Y samples), little-endian
+    PIX_FMT_YUV444P10BE,///< planar YUV 4:4:4, 30bpp, (1 Cr & Cb sample per 1x1 Y samples), big-endian
+    PIX_FMT_YUV444P10LE,///< planar YUV 4:4:4, 30bpp, (1 Cr & Cb sample per 1x1 Y samples), little-endian
+    PIX_FMT_YUV422P9BE, ///< planar YUV 4:2:2, 18bpp, (1 Cr & Cb sample per 2x1 Y samples), big-endian
+    PIX_FMT_YUV422P9LE, ///< planar YUV 4:2:2, 18bpp, (1 Cr & Cb sample per 2x1 Y samples), little-endian
+    PIX_FMT_VDA_VLD,    ///< hardware decoding through VDA
 
+#ifdef AV_PIX_FMT_ABI_GIT_MASTER
+    PIX_FMT_RGBA64BE,  ///< packed RGBA 16:16:16:16, 64bpp, 16R, 16G, 16B, 16A, the 2-byte value for each R/G/B/A component is stored as big-endian
+    PIX_FMT_RGBA64LE,  ///< packed RGBA 16:16:16:16, 64bpp, 16R, 16G, 16B, 16A, the 2-byte value for each R/G/B/A component is stored as little-endian
+    PIX_FMT_BGRA64BE,  ///< packed RGBA 16:16:16:16, 64bpp, 16B, 16G, 16R, 16A, the 2-byte value for each R/G/B/A component is stored as big-endian
+    PIX_FMT_BGRA64LE,  ///< packed RGBA 16:16:16:16, 64bpp, 16B, 16G, 16R, 16A, the 2-byte value for each R/G/B/A component is stored as little-endian
+#endif
+    PIX_FMT_GBRP,      ///< planar GBR 4:4:4 24bpp
+    PIX_FMT_GBRP9BE,   ///< planar GBR 4:4:4 27bpp, big endian
+    PIX_FMT_GBRP9LE,   ///< planar GBR 4:4:4 27bpp, little endian
+    PIX_FMT_GBRP10BE,  ///< planar GBR 4:4:4 30bpp, big endian
+    PIX_FMT_GBRP10LE,  ///< planar GBR 4:4:4 30bpp, little endian
+    PIX_FMT_GBRP16BE,  ///< planar GBR 4:4:4 48bpp, big endian
+    PIX_FMT_GBRP16LE,  ///< planar GBR 4:4:4 48bpp, little endian
+
+#ifndef AV_PIX_FMT_ABI_GIT_MASTER
+    PIX_FMT_RGBA64BE=0x123,  ///< packed RGBA 16:16:16:16, 64bpp, 16R, 16G, 16B, 16A, the 2-byte value for each R/G/B/A component is stored as big-endian
+    PIX_FMT_RGBA64LE,  ///< packed RGBA 16:16:16:16, 64bpp, 16R, 16G, 16B, 16A, the 2-byte value for each R/G/B/A component is stored as little-endian
+    PIX_FMT_BGRA64BE,  ///< packed RGBA 16:16:16:16, 64bpp, 16B, 16G, 16R, 16A, the 2-byte value for each R/G/B/A component is stored as big-endian
+    PIX_FMT_BGRA64LE,  ///< packed RGBA 16:16:16:16, 64bpp, 16B, 16G, 16R, 16A, the 2-byte value for each R/G/B/A component is stored as little-endian
+#endif
+    PIX_FMT_0RGB=0x123+4,      ///< packed RGB 8:8:8, 32bpp, 0RGB0RGB...
+    PIX_FMT_RGB0,      ///< packed RGB 8:8:8, 32bpp, RGB0RGB0...
+    PIX_FMT_0BGR,      ///< packed BGR 8:8:8, 32bpp, 0BGR0BGR...
+    PIX_FMT_BGR0,      ///< packed BGR 8:8:8, 32bpp, BGR0BGR0...
     PIX_FMT_NB,        ///< number of pixel formats, DO NOT USE THIS if you want to link with shared libav* because the number of formats might differ between versions
 };
 
 #define PIX_FMT_Y400A PIX_FMT_GRAY8A
+#define PIX_FMT_GBR24P PIX_FMT_GBRP
 
 #if AV_HAVE_BIGENDIAN
 #   define PIX_FMT_NE(be, le) PIX_FMT_##be
@@ -165,6 +195,8 @@ enum PixelFormat {
 #define PIX_FMT_RGB32_1 PIX_FMT_NE(RGBA, ABGR)
 #define PIX_FMT_BGR32   PIX_FMT_NE(ABGR, RGBA)
 #define PIX_FMT_BGR32_1 PIX_FMT_NE(BGRA, ARGB)
+#define PIX_FMT_0RGB32  PIX_FMT_NE(0RGB, BGR0)
+#define PIX_FMT_0BGR32  PIX_FMT_NE(0BGR, RGB0)
 
 #define PIX_FMT_GRAY16 PIX_FMT_NE(GRAY16BE, GRAY16LE)
 #define PIX_FMT_RGB48  PIX_FMT_NE(RGB48BE,  RGB48LE)
@@ -177,6 +209,7 @@ enum PixelFormat {
 #define PIX_FMT_BGR444 PIX_FMT_NE(BGR444BE, BGR444LE)
 
 #define PIX_FMT_YUV420P9  PIX_FMT_NE(YUV420P9BE , YUV420P9LE)
+#define PIX_FMT_YUV422P9  PIX_FMT_NE(YUV422P9BE , YUV422P9LE)
 #define PIX_FMT_YUV444P9  PIX_FMT_NE(YUV444P9BE , YUV444P9LE)
 #define PIX_FMT_YUV420P10 PIX_FMT_NE(YUV420P10BE, YUV420P10LE)
 #define PIX_FMT_YUV422P10 PIX_FMT_NE(YUV422P10BE, YUV422P10LE)
@@ -185,4 +218,10 @@ enum PixelFormat {
 #define PIX_FMT_YUV422P16 PIX_FMT_NE(YUV422P16BE, YUV422P16LE)
 #define PIX_FMT_YUV444P16 PIX_FMT_NE(YUV444P16BE, YUV444P16LE)
 
+#define PIX_FMT_RGBA64 PIX_FMT_NE(RGBA64BE, RGBA64LE)
+#define PIX_FMT_BGRA64 PIX_FMT_NE(BGRA64BE, BGRA64LE)
+#define PIX_FMT_GBRP9     PIX_FMT_NE(GBRP9BE ,    GBRP9LE)
+#define PIX_FMT_GBRP10    PIX_FMT_NE(GBRP10BE,    GBRP10LE)
+#define PIX_FMT_GBRP16    PIX_FMT_NE(GBRP16BE,    GBRP16LE)
+
 #endif /* AVUTIL_PIXFMT_H */

3rdparty/include/ffmpeg_/libavutil/random_seed.h

@@ -22,10 +22,22 @@
 #define AVUTIL_RANDOM_SEED_H
 
 #include <stdint.h>
+/**
+ * @addtogroup lavu_crypto
+ * @{
+ */
 
 /**
  * Get a seed to use in conjunction with random functions.
+ * This function tries to provide a good seed at a best effort bases.
+ * Its possible to call this function multiple times if more bits are needed.
+ * It can be quite slow, which is why it should only be used as seed for a faster
+ * PRNG. The quality of the seed depends on the platform.
  */
 uint32_t av_get_random_seed(void);
 
+/**
+ * @}
+ */
+
 #endif /* AVUTIL_RANDOM_SEED_H */

3rdparty/include/ffmpeg_/libavutil/rational.h

@@ -32,6 +32,11 @@
 #include <limits.h>
 #include "attributes.h"
 
+/**
+ * @addtogroup lavu_math
+ * @{
+ */
+
 /**
  * rational number numerator/denominator
  */
@@ -132,4 +137,8 @@ int av_nearer_q(AVRational q, AVRational q1, AVRational q2);
  */
 int av_find_nearest_q_idx(AVRational q, const AVRational* q_list);
 
+/**
+ * @}
+ */
+
 #endif /* AVUTIL_RATIONAL_H */

3rdparty/include/ffmpeg_/libavutil/samplefmt.h

@@ -31,6 +31,13 @@ enum AVSampleFormat {
     AV_SAMPLE_FMT_S32,         ///< signed 32 bits
     AV_SAMPLE_FMT_FLT,         ///< float
     AV_SAMPLE_FMT_DBL,         ///< double
+
+    AV_SAMPLE_FMT_U8P,         ///< unsigned 8 bits, planar
+    AV_SAMPLE_FMT_S16P,        ///< signed 16 bits, planar
+    AV_SAMPLE_FMT_S32P,        ///< signed 32 bits, planar
+    AV_SAMPLE_FMT_FLTP,        ///< float, planar
+    AV_SAMPLE_FMT_DBLP,        ///< double, planar
+
     AV_SAMPLE_FMT_NB           ///< Number of sample formats. DO NOT USE if linking dynamically
 };
 
@@ -46,6 +53,14 @@ const char *av_get_sample_fmt_name(enum AVSampleFormat sample_fmt);
  */
 enum AVSampleFormat av_get_sample_fmt(const char *name);
 
+/**
+ * Return the planar<->packed alternative form of the given sample format, or
+ * AV_SAMPLE_FMT_NONE on error. If the passed sample_fmt is already in the
+ * requested planar/packed format, the format returned is the same as the
+ * input.
+ */
+enum AVSampleFormat av_get_alt_sample_fmt(enum AVSampleFormat sample_fmt, int planar);
+
 /**
  * Generate a string corresponding to the sample format with
  * sample_fmt, or a header if sample_fmt is negative.
@@ -78,48 +93,64 @@ int av_get_bits_per_sample_fmt(enum AVSampleFormat sample_fmt);
 int av_get_bytes_per_sample(enum AVSampleFormat sample_fmt);
 
 /**
- * Fill channel data pointers and linesizes for samples with sample
+ * Check if the sample format is planar.
+ *
+ * @param sample_fmt the sample format to inspect
+ * @return 1 if the sample format is planar, 0 if it is interleaved
+ */
+int av_sample_fmt_is_planar(enum AVSampleFormat sample_fmt);
+
+/**
+ * Get the required buffer size for the given audio parameters.
+ *
+ * @param[out] linesize calculated linesize, may be NULL
+ * @param nb_channels   the number of channels
+ * @param nb_samples    the number of samples in a single channel
+ * @param sample_fmt    the sample format
+ * @return              required buffer size, or negative error code on failure
+ */
+int av_samples_get_buffer_size(int *linesize, int nb_channels, int nb_samples,
+                               enum AVSampleFormat sample_fmt, int align);
+
+/**
+ * Fill channel data pointers and linesize for samples with sample
  * format sample_fmt.
  *
  * The pointers array is filled with the pointers to the samples data:
- * for planar, set the start point of each plane's data within the buffer,
+ * for planar, set the start point of each channel's data within the buffer,
  * for packed, set the start point of the entire buffer only.
  *
- * The linesize array is filled with the aligned size of each samples
- * plane, that is linesize[i] will contain the linesize of the plane i,
- * and will be zero for all the unused planes. All linesize values are
- * equal.
+ * The linesize array is filled with the aligned size of each channel's data
+ * buffer for planar layout, or the aligned size of the buffer for all channels
+ * for packed layout.
  *
- * @param pointers array to be filled with the pointer for each plane, may be NULL
- * @param linesizes array to be filled with the linesize, may be NULL
- * @param buf the pointer to a buffer containing the samples
- * @param nb_samples the number of samples in a single channel
- * @param planar 1 if the samples layout is planar, 0 if it is packed
- * @param nb_channels the number of channels
- * @return the total size of the buffer, a negative
- * error code in case of failure
+ * @param[out] audio_data  array to be filled with the pointer for each channel
+ * @param[out] linesize    calculated linesize
+ * @param buf              the pointer to a buffer containing the samples
+ * @param nb_channels      the number of channels
+ * @param nb_samples       the number of samples in a single channel
+ * @param sample_fmt       the sample format
+ * @param align            buffer size alignment (1 = no alignment required)
+ * @return                 0 on success or a negative error code on failure
  */
-int av_samples_fill_arrays(uint8_t *pointers[8], int linesizes[8],
-                           uint8_t *buf, int nb_channels, int nb_samples,
-                           enum AVSampleFormat sample_fmt, int planar, int align);
+int av_samples_fill_arrays(uint8_t **audio_data, int *linesize, uint8_t *buf,
+                           int nb_channels, int nb_samples,
+                           enum AVSampleFormat sample_fmt, int align);
 
 /**
- * Allocate a samples buffer for nb_samples samples, and
- * fill pointers and linesizes accordingly.
- * The allocated samples buffer has to be freed by using
- * av_freep(&pointers[0]).
+ * Allocate a samples buffer for nb_samples samples, and fill data pointers and
+ * linesize accordingly.
+ * The allocated samples buffer can be freed by using av_freep(&audio_data[0])
  *
- * @param nb_channels number of audio channels
- * @param nb_samples number of samples per channel
- * @param planar 1 if the samples layout is planar, 0 if packed,
- * @param align the value to use for buffer size alignment
- * @return the size in bytes required for the samples buffer, a negative
- * error code in case of failure
+ * @param[out] audio_data  array to be filled with the pointer for each channel
+ * @param[out] linesize    aligned size for audio buffer(s)
+ * @param nb_channels      number of audio channels
+ * @param nb_samples       number of samples per channel
+ * @param align            buffer size alignment (1 = no alignment required)
+ * @return                 0 on success or a negative error code on failure
  * @see av_samples_fill_arrays()
  */
-int av_samples_alloc(uint8_t *pointers[8], int linesizes[8],
-                     int nb_channels, int nb_samples,
-                     enum AVSampleFormat sample_fmt, int planar,
-                     int align);
+int av_samples_alloc(uint8_t **audio_data, int *linesize, int nb_channels,
+                     int nb_samples, enum AVSampleFormat sample_fmt, int align);
 
-#endif /* AVCORE_SAMPLEFMT_H */
+#endif /* AVUTIL_SAMPLEFMT_H */

3rdparty/include/ffmpeg_/libavutil/sha.h

@@ -23,6 +23,12 @@
 
 #include <stdint.h>
 
+/**
+ * @defgroup lavu_sha SHA
+ * @ingroup lavu_crypto
+ * @{
+ */
+
 extern const int av_sha_size;
 
 struct AVSHA;
@@ -53,4 +59,8 @@ void av_sha_update(struct AVSHA* context, const uint8_t* data, unsigned int len)
  */
 void av_sha_final(struct AVSHA* context, uint8_t *digest);
 
+/**
+ * @}
+ */
+
 #endif /* AVUTIL_SHA_H */

3rdparty/include/ffmpeg_/libswscale/swscale.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2001-2003 Michael Niedermayer <michaelni@gmx.at>
+ * Copyright (C) 2001-2011 Michael Niedermayer <michaelni@gmx.at>
  *
  * This file is part of FFmpeg.
  *
@@ -28,10 +28,12 @@
  */
 
 #include "libavutil/avutil.h"
+#include "libavutil/log.h"
+#include "libavutil/pixfmt.h"
 
 #define LIBSWSCALE_VERSION_MAJOR 2
-#define LIBSWSCALE_VERSION_MINOR 0
-#define LIBSWSCALE_VERSION_MICRO 0
+#define LIBSWSCALE_VERSION_MINOR 1
+#define LIBSWSCALE_VERSION_MICRO 100
 
 #define LIBSWSCALE_VERSION_INT  AV_VERSION_INT(LIBSWSCALE_VERSION_MAJOR, \
                                                LIBSWSCALE_VERSION_MINOR, \
@@ -58,17 +60,17 @@
 #endif
 
 /**
- * Returns the LIBSWSCALE_VERSION_INT constant.
+ * Return the LIBSWSCALE_VERSION_INT constant.
  */
 unsigned swscale_version(void);
 
 /**
- * Returns the libswscale build-time configuration.
+ * Return the libswscale build-time configuration.
  */
 const char *swscale_configuration(void);
 
 /**
- * Returns the libswscale license.
+ * Return the libswscale license.
  */
 const char *swscale_license(void);
 
@@ -125,7 +127,7 @@ const char *swscale_license(void);
 #define SWS_CS_DEFAULT        5
 
 /**
- * Returns a pointer to yuv<->rgb coefficients for the given colorspace
+ * Return a pointer to yuv<->rgb coefficients for the given colorspace
  * suitable for sws_setColorspaceDetails().
  *
  * @param colorspace One of the SWS_CS_* macros. If invalid,
@@ -133,7 +135,6 @@ const char *swscale_license(void);
  */
 const int *sws_getCoefficients(int colorspace);
 
-
 // when used for filters they must have an odd number of elements
 // coeffs cannot be shared between vectors
 typedef struct {
@@ -152,26 +153,26 @@ typedef struct {
 struct SwsContext;
 
 /**
- * Returns a positive value if pix_fmt is a supported input format, 0
+ * Return a positive value if pix_fmt is a supported input format, 0
  * otherwise.
  */
 int sws_isSupportedInput(enum PixelFormat pix_fmt);
 
 /**
- * Returns a positive value if pix_fmt is a supported output format, 0
+ * Return a positive value if pix_fmt is a supported output format, 0
  * otherwise.
  */
 int sws_isSupportedOutput(enum PixelFormat pix_fmt);
 
 /**
- * Allocates an empty SwsContext. This must be filled and passed to
+ * Allocate an empty SwsContext. This must be filled and passed to
  * sws_init_context(). For filling see AVOptions, options.c and
  * sws_setColorspaceDetails().
  */
 struct SwsContext *sws_alloc_context(void);
 
 /**
- * Initializes the swscaler context sws_context.
+ * Initialize the swscaler context sws_context.
  *
  * @return zero or positive value on success, a negative value on
  * error
@@ -179,14 +180,14 @@ struct SwsContext *sws_alloc_context(void);
 int sws_init_context(struct SwsContext *sws_context, SwsFilter *srcFilter, SwsFilter *dstFilter);
 
 /**
- * Frees the swscaler context swsContext.
+ * Free the swscaler context swsContext.
  * If swsContext is NULL, then does nothing.
  */
 void sws_freeContext(struct SwsContext *swsContext);
 
 #if FF_API_SWS_GETCONTEXT
 /**
- * Allocates and returns a SwsContext. You need it to perform
+ * Allocate and return an SwsContext. You need it to perform
  * scaling/conversion operations using sws_scale().
  *
  * @param srcW the width of the source image
@@ -208,7 +209,7 @@ struct SwsContext *sws_getContext(int srcW, int srcH, enum PixelFormat srcFormat
 #endif
 
 /**
- * Scales the image slice in srcSlice and puts the resulting scaled
+ * Scale the image slice in srcSlice and put the resulting scaled
  * slice in the image in dst. A slice is a sequence of consecutive
  * rows in an image.
  *
@@ -216,7 +217,7 @@ struct SwsContext *sws_getContext(int srcW, int srcH, enum PixelFormat srcFormat
  * top-bottom or bottom-top order. If slices are provided in
  * non-sequential order the behavior of the function is undefined.
  *
- * @param context   the scaling context previously created with
+ * @param c         the scaling context previously created with
  *                  sws_getContext()
  * @param srcSlice  the array containing the pointers to the planes of
  *                  the source slice
@@ -233,17 +234,9 @@ struct SwsContext *sws_getContext(int srcW, int srcH, enum PixelFormat srcFormat
  *                  the destination image
  * @return          the height of the output slice
  */
-int sws_scale(struct SwsContext *context, const uint8_t* const srcSlice[], const int srcStride[],
-              int srcSliceY, int srcSliceH, uint8_t* const dst[], const int dstStride[]);
-
-#if LIBSWSCALE_VERSION_MAJOR < 1
-/**
- * @deprecated Use sws_scale() instead.
- */
-int sws_scale_ordered(struct SwsContext *context, const uint8_t* const src[],
-                      int srcStride[], int srcSliceY, int srcSliceH,
-                      uint8_t* dst[], int dstStride[]) attribute_deprecated;
-#endif
+int sws_scale(struct SwsContext *c, const uint8_t *const srcSlice[],
+              const int srcStride[], int srcSliceY, int srcSliceH,
+              uint8_t *const dst[], const int dstStride[]);
 
 /**
  * @param inv_table the yuv2rgb coefficients, normally ff_yuv2rgb_coeffs[x]
@@ -261,35 +254,35 @@ int sws_getColorspaceDetails(struct SwsContext *c, int **inv_table,
                              int *brightness, int *contrast, int *saturation);
 
 /**
- * Allocates and returns an uninitialized vector with length coefficients.
+ * Allocate and return an uninitialized vector with length coefficients.
  */
 SwsVector *sws_allocVec(int length);
 
 /**
- * Returns a normalized Gaussian curve used to filter stuff
- * quality=3 is high quality, lower is lower quality.
+ * Return a normalized Gaussian curve used to filter stuff
+ * quality = 3 is high quality, lower is lower quality.
  */
 SwsVector *sws_getGaussianVec(double variance, double quality);
 
 /**
- * Allocates and returns a vector with length coefficients, all
+ * Allocate and return a vector with length coefficients, all
  * with the same value c.
  */
 SwsVector *sws_getConstVec(double c, int length);
 
 /**
- * Allocates and returns a vector with just one coefficient, with
+ * Allocate and return a vector with just one coefficient, with
  * value 1.0.
  */
 SwsVector *sws_getIdentityVec(void);
 
 /**
- * Scales all the coefficients of a by the scalar value.
+ * Scale all the coefficients of a by the scalar value.
  */
 void sws_scaleVec(SwsVector *a, double scalar);
 
 /**
- * Scales all the coefficients of a so that their sum equals height.
+ * Scale all the coefficients of a so that their sum equals height.
  */
 void sws_normalizeVec(SwsVector *a, double height);
 void sws_convVec(SwsVector *a, SwsVector *b);
@@ -298,20 +291,13 @@ void sws_subVec(SwsVector *a, SwsVector *b);
 void sws_shiftVec(SwsVector *a, int shift);
 
 /**
- * Allocates and returns a clone of the vector a, that is a vector
+ * Allocate and return a clone of the vector a, that is a vector
  * with the same coefficients as a.
  */
 SwsVector *sws_cloneVec(SwsVector *a);
 
-#if LIBSWSCALE_VERSION_MAJOR < 1
 /**
- * @deprecated Use sws_printVec2() instead.
- */
-attribute_deprecated void sws_printVec(SwsVector *a);
-#endif
-
-/**
- * Prints with av_log() a textual representation of the vector a
+ * Print with av_log() a textual representation of the vector a
  * if log_level <= av_log_level.
  */
 void sws_printVec2(SwsVector *a, AVClass *log_ctx, int log_level);
@@ -325,8 +311,7 @@ SwsFilter *sws_getDefaultFilter(float lumaGBlur, float chromaGBlur,
 void sws_freeFilter(SwsFilter *filter);
 
 /**
- * Checks if context can be reused, otherwise reallocates a new
- * one.
+ * Check if context can be reused, otherwise reallocate a new one.
  *
  * If context is NULL, just calls sws_getContext() to get a new
  * context. Otherwise, checks if the parameters are the ones already
@@ -344,7 +329,7 @@ struct SwsContext *sws_getCachedContext(struct SwsContext *context,
                                         SwsFilter *dstFilter, const double *param);
 
 /**
- * Converts an 8bit paletted frame into a frame with a color depth of 32-bits.
+ * Convert an 8-bit paletted frame into a frame with a color depth of 32 bits.
  *
  * The output frame will have the same packed format as the palette.
  *
@@ -356,7 +341,7 @@ struct SwsContext *sws_getCachedContext(struct SwsContext *context,
 void sws_convertPalette8ToPacked32(const uint8_t *src, uint8_t *dst, int num_pixels, const uint8_t *palette);
 
 /**
- * Converts an 8bit paletted frame into a frame with a color depth of 24 bits.
+ * Convert an 8-bit paletted frame into a frame with a color depth of 24 bits.
  *
  * With the palette format "ABCD", the destination frame ends up with the format "ABC".
  *
@@ -367,5 +352,12 @@ void sws_convertPalette8ToPacked32(const uint8_t *src, uint8_t *dst, int num_pix
  */
 void sws_convertPalette8ToPacked24(const uint8_t *src, uint8_t *dst, int num_pixels, const uint8_t *palette);
 
+/**
+ * Get the AVClass for swsContext. It can be used in combination with
+ * AV_OPT_SEARCH_FAKE_OBJ for examining options.
+ *
+ * @see av_opt_find().
+ */
+const AVClass *sws_get_class(void);
 
 #endif /* SWSCALE_SWSCALE_H */

3rdparty/include/msc_inttypes.h

@@ -1,32 +1,32 @@
 // ISO C9x  compliant inttypes.h for Microsoft Visual Studio
-// Based on ISO/IEC 9899:TC2 Committee draft (May 6, 2005) WG14/N1124 
-// 
+// Based on ISO/IEC 9899:TC2 Committee draft (May 6, 2005) WG14/N1124
+//
 //  Copyright (c) 2006 Alexander Chemeris
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are met:
-// 
+//
 //   1. Redistributions of source code must retain the above copyright notice,
 //      this list of conditions and the following disclaimer.
-// 
+//
 //   2. Redistributions in binary form must reproduce the above copyright
 //      notice, this list of conditions and the following disclaimer in the
 //      documentation and/or other materials provided with the distribution.
-// 
+//
 //   3. The name of the author may be used to endorse or promote products
 //      derived from this software without specific prior written permission.
-// 
+//
 // THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
 // WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
 // MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
 // EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
-// OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, 
+// OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
 // WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
 // OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
 // ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-// 
+//
 ///////////////////////////////////////////////////////////////////////////////
 
 #ifndef _MSC_VER // [

3rdparty/include/msc_stdint.h

@@ -1,32 +1,32 @@
 // ISO C9x  compliant stdint.h for Microsoft Visual Studio
-// Based on ISO/IEC 9899:TC2 Committee draft (May 6, 2005) WG14/N1124 
-// 
+// Based on ISO/IEC 9899:TC2 Committee draft (May 6, 2005) WG14/N1124
+//
 //  Copyright (c) 2006 Alexander Chemeris
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are met:
-// 
+//
 //   1. Redistributions of source code must retain the above copyright notice,
 //      this list of conditions and the following disclaimer.
-// 
+//
 //   2. Redistributions in binary form must reproduce the above copyright
 //      notice, this list of conditions and the following disclaimer in the
 //      documentation and/or other materials provided with the distribution.
-// 
+//
 //   3. The name of the author may be used to endorse or promote products
 //      derived from this software without specific prior written permission.
-// 
+//
 // THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
 // WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
 // MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
 // EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
-// OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, 
+// OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
 // WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
 // OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
 // ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-// 
+//
 ///////////////////////////////////////////////////////////////////////////////
 
 #ifndef _MSC_STDINT_H_ // [
@@ -39,7 +39,7 @@
 //   error C2733: second C linkage of overloaded function 'wmemchr' not allowed
 #if (_MSC_VER < 1300) && defined(__cplusplus)
    extern "C++" {
-#endif 
+#endif
 #     include <wchar.h>
 #if (_MSC_VER < 1300) && defined(__cplusplus)
    }

3rdparty/libjasper/CMakeLists.txt

@@ -2,57 +2,48 @@
 #  CMake file for libjasper. See root CMakeLists.txt
 #
 # ----------------------------------------------------------------------------
-project(libjasper)
+project(${JASPER_LIBRARY})
 
 
 add_definitions(-DEXCLUDE_MIF_SUPPORT -DEXCLUDE_PNM_SUPPORT -DEXCLUDE_BMP_SUPPORT -DEXCLUDE_RAS_SUPPORT  -DEXCLUDE_JPG_SUPPORT -DEXCLUDE_PGX_SUPPORT)
 
-# List of C++ files:
-include_directories(${CMAKE_CURRENT_SOURCE_DIR})
+ocv_include_directories(${CMAKE_CURRENT_SOURCE_DIR})
 
-# The .cpp files:
 file(GLOB lib_srcs *.c)
 file(GLOB lib_hdrs *.h)
 file(GLOB lib_ext_hdrs jasper/*.h)
 
 # ----------------------------------------------------------------------------------
-# 				Define the library target:
+#         Define the library target:
 # ----------------------------------------------------------------------------------
 
-set(the_target "libjasper")
+add_library(${JASPER_LIBRARY} STATIC ${lib_srcs} ${lib_hdrs} ${lib_ext_hdrs})
 
-add_library(${the_target} STATIC ${lib_srcs} ${lib_hdrs} ${lib_ext_hdrs})
+if(WIN32 AND NOT MINGW)
+  add_definitions(-DJAS_WIN_MSVC_BUILD)
+endif(WIN32 AND NOT MINGW)
 
-if(MSVC)
-    string(REPLACE "/W3" "/W0" CMAKE_C_FLAGS "${CMAKE_C_FLAGS}")
-    string(REPLACE "/W4" "/W0" CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}")
-    add_definitions(-DJAS_WIN_MSVC_BUILD)
-endif()
+ocv_warnings_disable(CMAKE_C_FLAGS -Wno-implicit-function-declaration -Wno-uninitialized -Wmissing-prototypes -Wmissing-declarations -Wunused -Wshadow -Wsign-compare)
+ocv_warnings_disable(CMAKE_C_FLAGS /wd4013 /wd4018 /wd4101 /wd4244 /wd4267 /wd4715) # vs2005
 
 if(UNIX)
-    if(CMAKE_COMPILER_IS_GNUCXX OR CV_ICC)
-        set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -fPIC")
-    endif()
+  if(CMAKE_COMPILER_IS_GNUCXX OR CV_ICC)
+    set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -fPIC")
+  endif()
 endif()
 
-if(CMAKE_COMPILER_IS_GNUCXX)
-    set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wno-implicit-function-declaration -Wno-unused")
-endif()
+set_target_properties(${JASPER_LIBRARY}
+  PROPERTIES
+  OUTPUT_NAME ${JASPER_LIBRARY}
+  DEBUG_POSTFIX "${OPENCV_DEBUG_POSTFIX}"
+  ARCHIVE_OUTPUT_DIRECTORY ${3P_LIBRARY_OUTPUT_PATH}
+  )
 
-
-
-set_target_properties(${the_target}
-	PROPERTIES
-	OUTPUT_NAME "${the_target}"
-	DEBUG_POSTFIX "${OPENCV_DEBUG_POSTFIX}"
-	ARCHIVE_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/3rdparty/${OPENCV_LIB_INSTALL_PATH}"
-	)
-	
 if(ENABLE_SOLUTION_FOLDERS)
-	set_target_properties(${the_target} PROPERTIES FOLDER "3rdparty")
-endif()	
-    
-if(NOT BUILD_SHARED_LIBS)
-    install(TARGETS ${the_target}
-	    ARCHIVE DESTINATION share/OpenCV/3rdparty/${OPENCV_LIB_INSTALL_PATH} COMPONENT main)
+  set_target_properties(${JASPER_LIBRARY} PROPERTIES FOLDER "3rdparty")
 endif()
+
+if(NOT BUILD_SHARED_LIBS)
+  install(TARGETS ${JASPER_LIBRARY} ARCHIVE DESTINATION ${OPENCV_3P_LIB_INSTALL_PATH} COMPONENT main)
+endif()
+

3rdparty/libjasper/changelog

@@ -0,0 +1,162 @@
+jasper (1.900.1-13) unstable; urgency=high
+
+  * Fix CVE-2011-4516 and CVE-2011-4517: Two buffer overflow issues possibly
+    exploitable via specially crafted input files (Closes: #652649)
+    Thanks to Red Hat and Michael Gilbert
+
+ -- Roland Stigge <stigge@antcom.de>  Wed, 04 Jan 2012 19:14:40 +0100
+
+jasper (1.900.1-12) unstable; urgency=low
+
+  * Added patch to fix filename buffer overflow, thanks to Jonas Smedegard
+    and Alex Cherepanov from ghostscript (Closes: #649833)
+
+ -- Roland Stigge <stigge@antcom.de>  Sun, 27 Nov 2011 19:56:01 +0100
+
+jasper (1.900.1-11) unstable; urgency=low
+
+  * Added Multiarch support, thanks to Colin Watson (Closes: #645118)
+
+ -- Roland Stigge <stigge@antcom.de>  Wed, 02 Nov 2011 17:16:10 +0100
+
+jasper (1.900.1-10) unstable; urgency=low
+
+  * Added debian/watch
+  * debian/patches/01-misc-fixes.patch:
+    - Separated out config.{guess,sub}
+
+ -- Roland Stigge <stigge@antcom.de>  Mon, 15 Aug 2011 19:09:29 +0200
+
+jasper (1.900.1-9) unstable; urgency=low
+
+  * Switch to dpkg-source 3.0 (quilt) format
+  * Using new dh 7 build system
+
+ -- Roland Stigge <stigge@antcom.de>  Tue, 12 Jul 2011 20:21:21 +0200
+
+jasper (1.900.1-8) unstable; urgency=low
+
+  * Removed unneeded .la file (Closes: #633162)
+  * debian/control:
+    - Standards-Version: 3.9.2
+    - use libjpeg8-dev instead of libjpeg62-dev
+
+ -- Roland Stigge <stigge@antcom.de>  Mon, 11 Jul 2011 21:27:24 +0200
+
+jasper (1.900.1-7) unstable; urgency=low
+
+  * Acknowledge NMU
+  * Added patch to fix Debian patch for CVE-2008-3521 (Closes: #506739)
+  * debian/control: Standards-Version: 3.8.4
+
+ -- Roland Stigge <stigge@antcom.de>  Sun, 21 Feb 2010 16:09:45 +0100
+
+jasper (1.900.1-6.1) unstable; urgency=low
+
+  * Non-maintainer upload.
+  * This is a fix for the GeoJP2 patch introduced in 1.900.1-5 which caused 
+    GDAL faulting. Thanks Even Rouault. (Closes: #553429)
+
+ -- Francesco Paolo Lovergine <frankie@debian.org>  Wed, 28 Oct 2009 09:39:28 +0100
+
+jasper (1.900.1-6) unstable; urgency=low
+
+  * Reverted to jasper 1.900.1-6 because 1.900.1-5.1 messed up (see #528543)
+    but 1.900.1-5 wasn't available anymore. (Closes: #514296, #528543)
+  * Re-applied patch from #275619 as in 1.900.1-5
+  * debian/control: Standards-Version: 3.8.2
+  * Applied patch by Nico Golde (Closes: #501021)
+     - CVE-2008-3522[0]: Buffer overflow.
+     - CVE-2008-3521[1]: unsecure temporary files handling.
+     - CVE-2008-3520[2]: Multiple integer overflows.
+
+ -- Roland Stigge <stigge@antcom.de>  Sat, 20 Jun 2009 15:21:16 +0200
+
+jasper (1.900.1-5.1) unstable; urgency=low
+
+  * Non-maintainer upload.
+  * add patches/02_security.dpatch to fix various CVEs (Closes: #501021):
+     + CVE-2008-3522[0]: Buffer overflow.
+     + CVE-2008-3521[1]: unsecure temporary files handling.
+     + CVE-2008-3520[2]: Multiple integer overflows.
+
+ -- Pierre Habouzit <madcoder@debian.org>  Sun, 12 Oct 2008 21:40:59 +0200
+
+jasper (1.900.1-5) unstable; urgency=low
+
+  * Added GeoJP2 patch by Sven Geggus <sven.geggus@iitb.fraunhofer.de>
+    (Closes: #275619)
+  * debian/control: Standards-Version: 3.8.0
+
+ -- Roland Stigge <stigge@antcom.de>  Sun, 08 Jun 2008 13:14:24 +0200
+
+jasper (1.900.1-4) unstable; urgency=low
+
+  * src/libjasper/jpc/jpc_dec.c: Extended assert() to accept 4 color
+    components (Closes: #469786)
+  * debian/rules: improve "make distclean", thanks to lintian
+  * debian/control:
+    - Standards-Version: 3.7.3
+    - ${Source-Version} -> ${binary:Version}
+    - Removed self-dependencies of libjasper-dev
+
+ -- Roland Stigge <stigge@antcom.de>  Sun, 09 Mar 2008 11:53:44 +0100
+
+jasper (1.900.1-3) unstable; urgency=low
+
+  * Fixed segfaults on broken images (Closes: #413041)
+
+ -- Roland Stigge <stigge@antcom.de>  Tue, 10 Apr 2007 10:05:10 +0200
+
+jasper (1.900.1-2) experimental; urgency=low
+
+  * Added jas_tmr.h to -dev package (Closes: #414705)
+
+ -- Roland Stigge <stigge@antcom.de>  Tue, 13 Mar 2007 14:23:58 +0100
+
+jasper (1.900.1-1) experimental; urgency=low
+
+  * New upstream release
+  * debian/control:
+    - Standards-Version: 3.7.2
+    - Build-Depends: freeglut3-dev instead of libglut3-dev (Closes: #394496)
+  * Renamed packages to libjasper1, libjasper-dev, libjasper-runtime according
+    to upstream shared library naming change
+
+ -- Roland Stigge <stigge@antcom.de>  Fri, 26 Jan 2007 14:22:18 +0100
+
+jasper (1.701.0-2) unstable; urgency=low
+
+  * Prevent compression of pdf documents in binary packages
+  * Added man pages for the executables (Closes: #250077)
+  * Again renamed binary packages to reflect Policy:
+      - libjasper-1.701-1
+      - libjasper-1.701-dev (Provides, Replaces and Conflicts: libjasper-dev)
+      - libjasper-runtime
+
+ -- Roland Stigge <stigge@antcom.de>  Sun, 20 Jun 2004 13:54:10 +0200
+
+jasper (1.701.0-1) unstable; urgency=low
+
+  * New maintainer (Closes: #217099)
+  * New upstream release (Closes: #217570)
+      - new DFSG-compliant license (Closes: #218999, #245075)
+      - includes newer libtool related files (Closes: #210383)
+  * debian/control:
+      - Standards-Version: 3.6.1
+      - Changed binary package names, fixed interdependencies (Closes: #211592)
+          libjasper-1.700-2 => libjasper1
+          libjasper-1.700-2-dev => libjasper-dev
+          libjasper-progs => libjasper-runtime
+        (new packages conflicting and replacing the old ones)
+      - Added libxi-dev, libxmu-dev, libxt-dev to Build-Depends
+        (Closes: #250481)
+
+ -- Roland Stigge <stigge@antcom.de>  Sat, 19 Jun 2004 23:19:32 +0200
+
+jasper (1.700.2-1) unstable; urgency=low
+
+  * Initial Release.
+
+ -- Christopher L Cheney <ccheney@debian.org>  Fri, 22 Aug 2003 01:30:00 -0500
+

3rdparty/libjasper/copyright

@@ -0,0 +1,62 @@
+This package was debianized by Christopher L Cheney <ccheney@debian.org> on
+Fri, 22 Aug 2003 01:33:34 -0500.
+
+The current maintainer is Roland Stigge <stigge@antcom.de>
+
+It was downloaded from http://www.ece.uvic.ca/~mdadams/jasper/
+
+Upstream Author: Michael Adams <mdadams@ece.uvic.ca>
+
+License:
+
+JasPer License Version 2.0
+
+Copyright (c) 1999-2000 Image Power, Inc.
+Copyright (c) 1999-2000 The University of British Columbia
+Copyright (c) 2001-2003 Michael David Adams
+
+All rights reserved.
+
+Permission is hereby granted, free of charge, to any person (the
+"User") obtaining a copy of this software and associated documentation
+files (the "Software"), to deal in the Software without restriction,
+including without limitation the rights to use, copy, modify, merge,
+publish, distribute, and/or sell copies of the Software, and to permit
+persons to whom the Software is furnished to do so, subject to the
+following conditions:
+
+1.  The above copyright notices and this permission notice (which
+includes the disclaimer below) shall be included in all copies or
+substantial portions of the Software.
+
+2.  The name of a copyright holder shall not be used to endorse or
+promote products derived from the Software without specific prior
+written permission.
+
+THIS DISCLAIMER OF WARRANTY CONSTITUTES AN ESSENTIAL PART OF THIS
+LICENSE.  NO USE OF THE SOFTWARE IS AUTHORIZED HEREUNDER EXCEPT UNDER
+THIS DISCLAIMER.  THE SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS
+"AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING
+BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+PARTICULAR PURPOSE AND NONINFRINGEMENT OF THIRD PARTY RIGHTS.  IN NO
+EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, OR ANY SPECIAL
+INDIRECT OR CONSEQUENTIAL DAMAGES, OR ANY DAMAGES WHATSOEVER RESULTING
+FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
+NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION
+WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.  NO ASSURANCES ARE
+PROVIDED BY THE COPYRIGHT HOLDERS THAT THE SOFTWARE DOES NOT INFRINGE
+THE PATENT OR OTHER INTELLECTUAL PROPERTY RIGHTS OF ANY OTHER ENTITY.
+EACH COPYRIGHT HOLDER DISCLAIMS ANY LIABILITY TO THE USER FOR CLAIMS
+BROUGHT BY ANY OTHER ENTITY BASED ON INFRINGEMENT OF INTELLECTUAL
+PROPERTY RIGHTS OR OTHERWISE.  AS A CONDITION TO EXERCISING THE RIGHTS
+GRANTED HEREUNDER, EACH USER HEREBY ASSUMES SOLE RESPONSIBILITY TO SECURE
+ANY OTHER INTELLECTUAL PROPERTY RIGHTS NEEDED, IF ANY.  THE SOFTWARE
+IS NOT FAULT-TOLERANT AND IS NOT INTENDED FOR USE IN MISSION-CRITICAL
+SYSTEMS, SUCH AS THOSE USED IN THE OPERATION OF NUCLEAR FACILITIES,
+AIRCRAFT NAVIGATION OR COMMUNICATION SYSTEMS, AIR TRAFFIC CONTROL
+SYSTEMS, DIRECT LIFE SUPPORT MACHINES, OR WEAPONS SYSTEMS, IN WHICH
+THE FAILURE OF THE SOFTWARE OR SYSTEM COULD LEAD DIRECTLY TO DEATH,
+PERSONAL INJURY, OR SEVERE PHYSICAL OR ENVIRONMENTAL DAMAGE ("HIGH
+RISK ACTIVITIES").  THE COPYRIGHT HOLDERS SPECIFICALLY DISCLAIM ANY
+EXPRESS OR IMPLIED WARRANTY OF FITNESS FOR HIGH RISK ACTIVITIES.
+

3rdparty/libjasper/jas_debug.c

@@ -4,15 +4,15 @@
  */
 
 /* __START_OF_JASPER_LICENSE__
- * 
+ *
  * JasPer License Version 2.0
- * 
+ *
  * Copyright (c) 2001-2006 Michael David Adams
  * Copyright (c) 1999-2000 Image Power, Inc.
  * Copyright (c) 1999-2000 The University of British Columbia
- * 
+ *
  * All rights reserved.
- * 
+ *
  * Permission is hereby granted, free of charge, to any person (the
  * "User") obtaining a copy of this software and associated documentation
  * files (the "Software"), to deal in the Software without restriction,
@@ -20,15 +20,15 @@
  * publish, distribute, and/or sell copies of the Software, and to permit
  * persons to whom the Software is furnished to do so, subject to the
  * following conditions:
- * 
+ *
  * 1.  The above copyright notices and this permission notice (which
  * includes the disclaimer below) shall be included in all copies or
  * substantial portions of the Software.
- * 
+ *
  * 2.  The name of a copyright holder shall not be used to endorse or
  * promote products derived from the Software without specific prior
  * written permission.
- * 
+ *
  * THIS DISCLAIMER OF WARRANTY CONSTITUTES AN ESSENTIAL PART OF THIS
  * LICENSE.  NO USE OF THE SOFTWARE IS AUTHORIZED HEREUNDER EXCEPT UNDER
  * THIS DISCLAIMER.  THE SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS
@@ -55,7 +55,7 @@
  * PERSONAL INJURY, OR SEVERE PHYSICAL OR ENVIRONMENTAL DAMAGE ("HIGH
  * RISK ACTIVITIES").  THE COPYRIGHT HOLDERS SPECIFICALLY DISCLAIM ANY
  * EXPRESS OR IMPLIED WARRANTY OF FITNESS FOR HIGH RISK ACTIVITIES.
- * 
+ *
  * __END_OF_JASPER_LICENSE__
  */
 
@@ -83,22 +83,22 @@ static int jas_dbglevel = 0;
 /* Set the library debug level. */
 int jas_setdbglevel(int dbglevel)
 {
-	int olddbglevel;
+    int olddbglevel;
 
-	/* Save the old debug level. */
-	olddbglevel = jas_dbglevel;
+    /* Save the old debug level. */
+    olddbglevel = jas_dbglevel;
 
-	/* Change the debug level. */
-	jas_dbglevel = dbglevel;
+    /* Change the debug level. */
+    jas_dbglevel = dbglevel;
 
-	/* Return the old debug level. */
-	return olddbglevel;
+    /* Return the old debug level. */
+    return olddbglevel;
 }
 
 /* Get the library debug level. */
 int jas_getdbglevel()
 {
-	return jas_dbglevel;
+    return jas_dbglevel;
 }
 
 /******************************************************************************\
@@ -108,30 +108,30 @@ int jas_getdbglevel()
 /* Perform formatted output to standard error. */
 int jas_eprintf(const char *fmt, ...)
 {
-	int ret;
-	va_list ap;
+    int ret;
+    va_list ap;
 
-	va_start(ap, fmt);
-	ret = vfprintf(stderr, fmt, ap);
-	va_end(ap);
-	return ret;
+    va_start(ap, fmt);
+    ret = vfprintf(stderr, fmt, ap);
+    va_end(ap);
+    return ret;
 }
 
 /* Dump memory to a stream. */
 int jas_memdump(FILE *out, void *data, size_t len)
 {
-	size_t i;
-	size_t j;
-	uchar *dp;
-	dp = data;
-	for (i = 0; i < len; i += 16) {
-		fprintf(out, "%04x:", (int)i);
-		for (j = 0; j < 16; ++j) {
-			if (i + j < len) {
-				fprintf(out, " %02x", dp[i + j]);
-			}
-		}
-		fprintf(out, "\n");
-	}
-	return 0;
+    size_t i;
+    size_t j;
+    uchar *dp;
+    dp = data;
+    for (i = 0; i < len; i += 16) {
+        fprintf(out, "%04x:", (int)i);
+        for (j = 0; j < 16; ++j) {
+            if (i + j < len) {
+                fprintf(out, " %02x", dp[i + j]);
+            }
+        }
+        fprintf(out, "\n");
+    }
+    return 0;
 }

3rdparty/libjasper/jas_getopt.c

@@ -2,19 +2,19 @@
  * Copyright (c) 1999-2000, Image Power, Inc. and the University of
  *   British Columbia.
  * Copyright (c) 2001-2002 Michael David Adams.
- * All rights reserved. 
+ * All rights reserved.
  */
 
 /* __START_OF_JASPER_LICENSE__
- * 
+ *
  * JasPer License Version 2.0
- * 
+ *
  * Copyright (c) 2001-2006 Michael David Adams
  * Copyright (c) 1999-2000 Image Power, Inc.
  * Copyright (c) 1999-2000 The University of British Columbia
- * 
+ *
  * All rights reserved.
- * 
+ *
  * Permission is hereby granted, free of charge, to any person (the
  * "User") obtaining a copy of this software and associated documentation
  * files (the "Software"), to deal in the Software without restriction,
@@ -22,15 +22,15 @@
  * publish, distribute, and/or sell copies of the Software, and to permit
  * persons to whom the Software is furnished to do so, subject to the
  * following conditions:
- * 
+ *
  * 1.  The above copyright notices and this permission notice (which
  * includes the disclaimer below) shall be included in all copies or
  * substantial portions of the Software.
- * 
+ *
  * 2.  The name of a copyright holder shall not be used to endorse or
  * promote products derived from the Software without specific prior
  * written permission.
- * 
+ *
  * THIS DISCLAIMER OF WARRANTY CONSTITUTES AN ESSENTIAL PART OF THIS
  * LICENSE.  NO USE OF THE SOFTWARE IS AUTHORIZED HEREUNDER EXCEPT UNDER
  * THIS DISCLAIMER.  THE SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS
@@ -57,7 +57,7 @@
  * PERSONAL INJURY, OR SEVERE PHYSICAL OR ENVIRONMENTAL DAMAGE ("HIGH
  * RISK ACTIVITIES").  THE COPYRIGHT HOLDERS SPECIFICALLY DISCLAIM ANY
  * EXPRESS OR IMPLIED WARRANTY OF FITNESS FOR HIGH RISK ACTIVITIES.
- * 
+ *
  * __END_OF_JASPER_LICENSE__
  */
 
@@ -91,78 +91,78 @@ char *jas_optarg = 0;
 
 static jas_opt_t *jas_optlookup(jas_opt_t *opts, char *name)
 {
-	jas_opt_t *opt;
+    jas_opt_t *opt;
 
-	for (opt = opts; opt->id >= 0 && opt->name; ++opt) {
-		if (!strcmp(opt->name, name)) {
-			return opt;
-		}
-	}
-	return 0;
+    for (opt = opts; opt->id >= 0 && opt->name; ++opt) {
+        if (!strcmp(opt->name, name)) {
+            return opt;
+        }
+    }
+    return 0;
 }
 
 int jas_getopt(int argc, char **argv, jas_opt_t *opts)
 {
-	char *cp;
-	int id;
-	int hasarg;
-	jas_opt_t *opt;
-	char *s;
+    char *cp;
+    int id;
+    int hasarg;
+    jas_opt_t *opt;
+    char *s;
 
-	if (!jas_optind) {
-		jas_optind = JAS_MIN(1, argc);
-	}
-	while (jas_optind < argc) {
-		s = cp = argv[jas_optind];
-		if (*cp == '-') {
-			/* We are processing an option. */
-			++jas_optind;
-			if (*++cp == '-') {
-				/* We are processing a long option. */
-				++cp;
-				if (*cp == '\0') {
-					/* This is the end of the options. */
-					return JAS_GETOPT_EOF;
-				}
-				if (!(opt = jas_optlookup(opts, cp))) {
-					if (jas_opterr) {
-						jas_eprintf("unknown long option %s\n", s);
-					}
-					return JAS_GETOPT_ERR;
-				}
-				hasarg = (opt->flags & JAS_OPT_HASARG) != 0;
-				id = opt->id;
-			} else {
-				/* We are processing a short option. */
-				if (strlen(cp) != 1 ||
-				  !(opt = jas_optlookup(opts, cp))) {
-					if (jas_opterr) {
-						jas_eprintf("unknown short option %s\n", s);
-					}
-					return JAS_GETOPT_ERR;
-				}
-				hasarg = (opt->flags & JAS_OPT_HASARG) != 0;
-				id = opt->id;
-			}
-			if (hasarg) {
-				/* The option has an argument. */
-				if (jas_optind >= argc) {
-					if (jas_opterr) {
-						jas_eprintf("missing argument for option %s\n", s);
-					}
-					return JAS_GETOPT_ERR;
-				}
-				jas_optarg = argv[jas_optind];
-				++jas_optind;
-			} else {
-				/* The option does not have an argument. */
-				jas_optarg = 0;
-			}
-			return id;
-		} else {
-			/* We are not processing an option. */
-			return JAS_GETOPT_EOF;
-		}
-	}
-	return JAS_GETOPT_EOF;
+    if (!jas_optind) {
+        jas_optind = JAS_MIN(1, argc);
+    }
+    while (jas_optind < argc) {
+        s = cp = argv[jas_optind];
+        if (*cp == '-') {
+            /* We are processing an option. */
+            ++jas_optind;
+            if (*++cp == '-') {
+                /* We are processing a long option. */
+                ++cp;
+                if (*cp == '\0') {
+                    /* This is the end of the options. */
+                    return JAS_GETOPT_EOF;
+                }
+                if (!(opt = jas_optlookup(opts, cp))) {
+                    if (jas_opterr) {
+                        jas_eprintf("unknown long option %s\n", s);
+                    }
+                    return JAS_GETOPT_ERR;
+                }
+                hasarg = (opt->flags & JAS_OPT_HASARG) != 0;
+                id = opt->id;
+            } else {
+                /* We are processing a short option. */
+                if (strlen(cp) != 1 ||
+                  !(opt = jas_optlookup(opts, cp))) {
+                    if (jas_opterr) {
+                        jas_eprintf("unknown short option %s\n", s);
+                    }
+                    return JAS_GETOPT_ERR;
+                }
+                hasarg = (opt->flags & JAS_OPT_HASARG) != 0;
+                id = opt->id;
+            }
+            if (hasarg) {
+                /* The option has an argument. */
+                if (jas_optind >= argc) {
+                    if (jas_opterr) {
+                        jas_eprintf("missing argument for option %s\n", s);
+                    }
+                    return JAS_GETOPT_ERR;
+                }
+                jas_optarg = argv[jas_optind];
+                ++jas_optind;
+            } else {
+                /* The option does not have an argument. */
+                jas_optarg = 0;
+            }
+            return id;
+        } else {
+            /* We are not processing an option. */
+            return JAS_GETOPT_EOF;
+        }
+    }
+    return JAS_GETOPT_EOF;
 }

3rdparty/libjasper/jas_iccdata.c

@@ -4,15 +4,15 @@
  */
 
 /* __START_OF_JASPER_LICENSE__
- * 
+ *
  * JasPer License Version 2.0
- * 
+ *
  * Copyright (c) 2001-2006 Michael David Adams
  * Copyright (c) 1999-2000 Image Power, Inc.
  * Copyright (c) 1999-2000 The University of British Columbia
- * 
+ *
  * All rights reserved.
- * 
+ *
  * Permission is hereby granted, free of charge, to any person (the
  * "User") obtaining a copy of this software and associated documentation
  * files (the "Software"), to deal in the Software without restriction,
@@ -20,15 +20,15 @@
  * publish, distribute, and/or sell copies of the Software, and to permit
  * persons to whom the Software is furnished to do so, subject to the
  * following conditions:
- * 
+ *
  * 1.  The above copyright notices and this permission notice (which
  * includes the disclaimer below) shall be included in all copies or
  * substantial portions of the Software.
- * 
+ *
  * 2.  The name of a copyright holder shall not be used to endorse or
  * promote products derived from the Software without specific prior
  * written permission.
- * 
+ *
  * THIS DISCLAIMER OF WARRANTY CONSTITUTES AN ESSENTIAL PART OF THIS
  * LICENSE.  NO USE OF THE SOFTWARE IS AUTHORIZED HEREUNDER EXCEPT UNDER
  * THIS DISCLAIMER.  THE SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS
@@ -55,7 +55,7 @@
  * PERSONAL INJURY, OR SEVERE PHYSICAL OR ENVIRONMENTAL DAMAGE ("HIGH
  * RISK ACTIVITIES").  THE COPYRIGHT HOLDERS SPECIFICALLY DISCLAIM ANY
  * EXPRESS OR IMPLIED WARRANTY OF FITNESS FOR HIGH RISK ACTIVITIES.
- * 
+ *
  * __END_OF_JASPER_LICENSE__
  */
 
@@ -64,454 +64,454 @@
 
 uchar jas_iccprofdata_srgb[] =
 {
-	0x00, 0x00, 0x0c, 0x48, 0x4c, 0x69, 0x6e, 0x6f,
-	0x02, 0x10, 0x00, 0x00, 0x6d, 0x6e, 0x74, 0x72,
-	0x52, 0x47, 0x42, 0x20, 0x58, 0x59, 0x5a, 0x20,
-	0x07, 0xce, 0x00, 0x02, 0x00, 0x09, 0x00, 0x06,
-	0x00, 0x31, 0x00, 0x00, 0x61, 0x63, 0x73, 0x70,
-	0x4d, 0x53, 0x46, 0x54, 0x00, 0x00, 0x00, 0x00,
-	0x49, 0x45, 0x43, 0x20, 0x73, 0x52, 0x47, 0x42,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf6, 0xd6,
-	0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0xd3, 0x2d,
-	0x48, 0x50, 0x20, 0x20, 0x00, 0x00, 0x00, 0x00,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x00, 0x00, 0x00, 0x11, 0x63, 0x70, 0x72, 0x74,
-	0x00, 0x00, 0x01, 0x50, 0x00, 0x00, 0x00, 0x33,
-	0x64, 0x65, 0x73, 0x63, 0x00, 0x00, 0x01, 0x84,
-	0x00, 0x00, 0x00, 0x6c, 0x77, 0x74, 0x70, 0x74,
-	0x00, 0x00, 0x01, 0xf0, 0x00, 0x00, 0x00, 0x14,
-	0x62, 0x6b, 0x70, 0x74, 0x00, 0x00, 0x02, 0x04,
-	0x00, 0x00, 0x00, 0x14, 0x72, 0x58, 0x59, 0x5a,
-	0x00, 0x00, 0x02, 0x18, 0x00, 0x00, 0x00, 0x14,
-	0x67, 0x58, 0x59, 0x5a, 0x00, 0x00, 0x02, 0x2c,
-	0x00, 0x00, 0x00, 0x14, 0x62, 0x58, 0x59, 0x5a,
-	0x00, 0x00, 0x02, 0x40, 0x00, 0x00, 0x00, 0x14,
-	0x64, 0x6d, 0x6e, 0x64, 0x00, 0x00, 0x02, 0x54,
-	0x00, 0x00, 0x00, 0x70, 0x64, 0x6d, 0x64, 0x64,
-	0x00, 0x00, 0x02, 0xc4, 0x00, 0x00, 0x00, 0x88,
-	0x76, 0x75, 0x65, 0x64, 0x00, 0x00, 0x03, 0x4c,
-	0x00, 0x00, 0x00, 0x86, 0x76, 0x69, 0x65, 0x77,
-	0x00, 0x00, 0x03, 0xd4, 0x00, 0x00, 0x00, 0x24,
-	0x6c, 0x75, 0x6d, 0x69, 0x00, 0x00, 0x03, 0xf8,
-	0x00, 0x00, 0x00, 0x14, 0x6d, 0x65, 0x61, 0x73,
-	0x00, 0x00, 0x04, 0x0c, 0x00, 0x00, 0x00, 0x24,
-	0x74, 0x65, 0x63, 0x68, 0x00, 0x00, 0x04, 0x30,
-	0x00, 0x00, 0x00, 0x0c, 0x72, 0x54, 0x52, 0x43,
-	0x00, 0x00, 0x04, 0x3c, 0x00, 0x00, 0x08, 0x0c,
-	0x67, 0x54, 0x52, 0x43, 0x00, 0x00, 0x04, 0x3c,
-	0x00, 0x00, 0x08, 0x0c, 0x62, 0x54, 0x52, 0x43,
-	0x00, 0x00, 0x04, 0x3c, 0x00, 0x00, 0x08, 0x0c,
-	0x74, 0x65, 0x78, 0x74, 0x00, 0x00, 0x00, 0x00,
-	0x43, 0x6f, 0x70, 0x79, 0x72, 0x69, 0x67, 0x68,
-	0x74, 0x20, 0x28, 0x63, 0x29, 0x20, 0x31, 0x39,
-	0x39, 0x38, 0x20, 0x48, 0x65, 0x77, 0x6c, 0x65,
-	0x74, 0x74, 0x2d, 0x50, 0x61, 0x63, 0x6b, 0x61,
-	0x72, 0x64, 0x20, 0x43, 0x6f, 0x6d, 0x70, 0x61,
-	0x6e, 0x79, 0x00, 0x00, 0x64, 0x65, 0x73, 0x63,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x12,
-	0x73, 0x52, 0x47, 0x42, 0x20, 0x49, 0x45, 0x43,
-	0x36, 0x31, 0x39, 0x36, 0x36, 0x2d, 0x32, 0x2e,
-	0x31, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x00, 0x00, 0x00, 0x00, 0x12, 0x73, 0x52, 0x47,
-	0x42, 0x20, 0x49, 0x45, 0x43, 0x36, 0x31, 0x39,
-	0x36, 0x36, 0x2d, 0x32, 0x2e, 0x31, 0x00, 0x00,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x58, 0x59, 0x5a, 0x20, 0x00, 0x00, 0x00, 0x00,
-	0x00, 0x00, 0xf3, 0x51, 0x00, 0x01, 0x00, 0x00,
-	0x00, 0x01, 0x16, 0xcc, 0x58, 0x59, 0x5a, 0x20,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x58, 0x59, 0x5a, 0x20, 0x00, 0x00, 0x00, 0x00,
-	0x00, 0x00, 0x6f, 0xa2, 0x00, 0x00, 0x38, 0xf5,
-	0x00, 0x00, 0x03, 0x90, 0x58, 0x59, 0x5a, 0x20,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x62, 0x99,
-	0x00, 0x00, 0xb7, 0x85, 0x00, 0x00, 0x18, 0xda,
-	0x58, 0x59, 0x5a, 0x20, 0x00, 0x00, 0x00, 0x00,
-	0x00, 0x00, 0x24, 0xa0, 0x00, 0x00, 0x0f, 0x84,
-	0x00, 0x00, 0xb6, 0xcf, 0x64, 0x65, 0x73, 0x63,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x16,
-	0x49, 0x45, 0x43, 0x20, 0x68, 0x74, 0x74, 0x70,
-	0x3a, 0x2f, 0x2f, 0x77, 0x77, 0x77, 0x2e, 0x69,
-	0x65, 0x63, 0x2e, 0x63, 0x68, 0x00, 0x00, 0x00,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x16, 0x49, 0x45, 0x43, 0x20, 0x68, 0x74, 0x74,
-	0x70, 0x3a, 0x2f, 0x2f, 0x77, 0x77, 0x77, 0x2e,
-	0x69, 0x65, 0x63, 0x2e, 0x63, 0x68, 0x00, 0x00,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x00, 0x00, 0x00, 0x00, 0x64, 0x65, 0x73, 0x63,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x2e,
-	0x49, 0x45, 0x43, 0x20, 0x36, 0x31, 0x39, 0x36,
-	0x36, 0x2d, 0x32, 0x2e, 0x31, 0x20, 0x44, 0x65,
-	0x66, 0x61, 0x75, 0x6c, 0x74, 0x20, 0x52, 0x47,
-	0x42, 0x20, 0x63, 0x6f, 0x6c, 0x6f, 0x75, 0x72,
-	0x20, 0x73, 0x70, 0x61, 0x63, 0x65, 0x20, 0x2d,
-	0x20, 0x73, 0x52, 0x47, 0x42, 0x00, 0x00, 0x00,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x2e, 0x49, 0x45, 0x43, 0x20, 0x36, 0x31, 0x39,
-	0x36, 0x36, 0x2d, 0x32, 0x2e, 0x31, 0x20, 0x44,
-	0x65, 0x66, 0x61, 0x75, 0x6c, 0x74, 0x20, 0x52,
-	0x47, 0x42, 0x20, 0x63, 0x6f, 0x6c, 0x6f, 0x75,
-	0x72, 0x20, 0x73, 0x70, 0x61, 0x63, 0x65, 0x20,
-	0x2d, 0x20, 0x73, 0x52, 0x47, 0x42, 0x00, 0x00,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x00, 0x00, 0x00, 0x00, 0x64, 0x65, 0x73, 0x63,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x2c,
-	0x52, 0x65, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63,
-	0x65, 0x20, 0x56, 0x69, 0x65, 0x77, 0x69, 0x6e,
-	0x67, 0x20, 0x43, 0x6f, 0x6e, 0x64, 0x69, 0x74,
-	0x69, 0x6f, 0x6e, 0x20, 0x69, 0x6e, 0x20, 0x49,
-	0x45, 0x43, 0x36, 0x31, 0x39, 0x36, 0x36, 0x2d,
-	0x32, 0x2e, 0x31, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x2c, 0x52,
-	0x65, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65,
-	0x20, 0x56, 0x69, 0x65, 0x77, 0x69, 0x6e, 0x67,
-	0x20, 0x43, 0x6f, 0x6e, 0x64, 0x69, 0x74, 0x69,
-	0x6f, 0x6e, 0x20, 0x69, 0x6e, 0x20, 0x49, 0x45,
-	0x43, 0x36, 0x31, 0x39, 0x36, 0x36, 0x2d, 0x32,
-	0x2e, 0x31, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x00, 0x00, 0x00, 0x00, 0x76, 0x69, 0x65, 0x77,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x13, 0xa4, 0xfe,
-	0x00, 0x14, 0x5f, 0x2e, 0x00, 0x10, 0xcf, 0x14,
-	0x00, 0x03, 0xed, 0xcc, 0x00, 0x04, 0x13, 0x0b,
-	0x00, 0x03, 0x5c, 0x9e, 0x00, 0x00, 0x00, 0x01,
-	0x58, 0x59, 0x5a, 0x20, 0x00, 0x00, 0x00, 0x00,
-	0x00, 0x4c, 0x09, 0x56, 0x00, 0x50, 0x00, 0x00,
-	0x00, 0x57, 0x1f, 0xe7, 0x6d, 0x65, 0x61, 0x73,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x00, 0x00, 0x02, 0x8f, 0x00, 0x00, 0x00, 0x02,
-	0x73, 0x69, 0x67, 0x20, 0x00, 0x00, 0x00, 0x00,
-	0x43, 0x52, 0x54, 0x20, 0x63, 0x75, 0x72, 0x76,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00,
-	0x00, 0x00, 0x00, 0x05, 0x00, 0x0a, 0x00, 0x0f,
-	0x00, 0x14, 0x00, 0x19, 0x00, 0x1e, 0x00, 0x23,
-	0x00, 0x28, 0x00, 0x2d, 0x00, 0x32, 0x00, 0x37,
-	0x00, 0x3b, 0x00, 0x40, 0x00, 0x45, 0x00, 0x4a,
-	0x00, 0x4f, 0x00, 0x54, 0x00, 0x59, 0x00, 0x5e,
-	0x00, 0x63, 0x00, 0x68, 0x00, 0x6d, 0x00, 0x72,
-	0x00, 0x77, 0x00, 0x7c, 0x00, 0x81, 0x00, 0x86,
-	0x00, 0x8b, 0x00, 0x90, 0x00, 0x95, 0x00, 0x9a,
-	0x00, 0x9f, 0x00, 0xa4, 0x00, 0xa9, 0x00, 0xae,
-	0x00, 0xb2, 0x00, 0xb7, 0x00, 0xbc, 0x00, 0xc1,
-	0x00, 0xc6, 0x00, 0xcb, 0x00, 0xd0, 0x00, 0xd5,
-	0x00, 0xdb, 0x00, 0xe0, 0x00, 0xe5, 0x00, 0xeb,
-	0x00, 0xf0, 0x00, 0xf6, 0x00, 0xfb, 0x01, 0x01,
-	0x01, 0x07, 0x01, 0x0d, 0x01, 0x13, 0x01, 0x19,
-	0x01, 0x1f, 0x01, 0x25, 0x01, 0x2b, 0x01, 0x32,
-	0x01, 0x38, 0x01, 0x3e, 0x01, 0x45, 0x01, 0x4c,
-	0x01, 0x52, 0x01, 0x59, 0x01, 0x60, 0x01, 0x67,
-	0x01, 0x6e, 0x01, 0x75, 0x01, 0x7c, 0x01, 0x83,
-	0x01, 0x8b, 0x01, 0x92, 0x01, 0x9a, 0x01, 0xa1,
-	0x01, 0xa9, 0x01, 0xb1, 0x01, 0xb9, 0x01, 0xc1,
-	0x01, 0xc9, 0x01, 0xd1, 0x01, 0xd9, 0x01, 0xe1,
-	0x01, 0xe9, 0x01, 0xf2, 0x01, 0xfa, 0x02, 0x03,
-	0x02, 0x0c, 0x02, 0x14, 0x02, 0x1d, 0x02, 0x26,
-	0x02, 0x2f, 0x02, 0x38, 0x02, 0x41, 0x02, 0x4b,
-	0x02, 0x54, 0x02, 0x5d, 0x02, 0x67, 0x02, 0x71,
-	0x02, 0x7a, 0x02, 0x84, 0x02, 0x8e, 0x02, 0x98,
-	0x02, 0xa2, 0x02, 0xac, 0x02, 0xb6, 0x02, 0xc1,
-	0x02, 0xcb, 0x02, 0xd5, 0x02, 0xe0, 0x02, 0xeb,
-	0x02, 0xf5, 0x03, 0x00, 0x03, 0x0b, 0x03, 0x16,
-	0x03, 0x21, 0x03, 0x2d, 0x03, 0x38, 0x03, 0x43,
-	0x03, 0x4f, 0x03, 0x5a, 0x03, 0x66, 0x03, 0x72,
-	0x03, 0x7e, 0x03, 0x8a, 0x03, 0x96, 0x03, 0xa2,
-	0x03, 0xae, 0x03, 0xba, 0x03, 0xc7, 0x03, 0xd3,
-	0x03, 0xe0, 0x03, 0xec, 0x03, 0xf9, 0x04, 0x06,
-	0x04, 0x13, 0x04, 0x20, 0x04, 0x2d, 0x04, 0x3b,
-	0x04, 0x48, 0x04, 0x55, 0x04, 0x63, 0x04, 0x71,
-	0x04, 0x7e, 0x04, 0x8c, 0x04, 0x9a, 0x04, 0xa8,
-	0x04, 0xb6, 0x04, 0xc4, 0x04, 0xd3, 0x04, 0xe1,
-	0x04, 0xf0, 0x04, 0xfe, 0x05, 0x0d, 0x05, 0x1c,
-	0x05, 0x2b, 0x05, 0x3a, 0x05, 0x49, 0x05, 0x58,
-	0x05, 0x67, 0x05, 0x77, 0x05, 0x86, 0x05, 0x96,
-	0x05, 0xa6, 0x05, 0xb5, 0x05, 0xc5, 0x05, 0xd5,
-	0x05, 0xe5, 0x05, 0xf6, 0x06, 0x06, 0x06, 0x16,
-	0x06, 0x27, 0x06, 0x37, 0x06, 0x48, 0x06, 0x59,
-	0x06, 0x6a, 0x06, 0x7b, 0x06, 0x8c, 0x06, 0x9d,
-	0x06, 0xaf, 0x06, 0xc0, 0x06, 0xd1, 0x06, 0xe3,
-	0x06, 0xf5, 0x07, 0x07, 0x07, 0x19, 0x07, 0x2b,
-	0x07, 0x3d, 0x07, 0x4f, 0x07, 0x61, 0x07, 0x74,
-	0x07, 0x86, 0x07, 0x99, 0x07, 0xac, 0x07, 0xbf,
-	0x07, 0xd2, 0x07, 0xe5, 0x07, 0xf8, 0x08, 0x0b,
-	0x08, 0x1f, 0x08, 0x32, 0x08, 0x46, 0x08, 0x5a,
-	0x08, 0x6e, 0x08, 0x82, 0x08, 0x96, 0x08, 0xaa,
-	0x08, 0xbe, 0x08, 0xd2, 0x08, 0xe7, 0x08, 0xfb,
-	0x09, 0x10, 0x09, 0x25, 0x09, 0x3a, 0x09, 0x4f,
-	0x09, 0x64, 0x09, 0x79, 0x09, 0x8f, 0x09, 0xa4,
-	0x09, 0xba, 0x09, 0xcf, 0x09, 0xe5, 0x09, 0xfb,
-	0x0a, 0x11, 0x0a, 0x27, 0x0a, 0x3d, 0x0a, 0x54,
-	0x0a, 0x6a, 0x0a, 0x81, 0x0a, 0x98, 0x0a, 0xae,
-	0x0a, 0xc5, 0x0a, 0xdc, 0x0a, 0xf3, 0x0b, 0x0b,
-	0x0b, 0x22, 0x0b, 0x39, 0x0b, 0x51, 0x0b, 0x69,
-	0x0b, 0x80, 0x0b, 0x98, 0x0b, 0xb0, 0x0b, 0xc8,
-	0x0b, 0xe1, 0x0b, 0xf9, 0x0c, 0x12, 0x0c, 0x2a,
-	0x0c, 0x43, 0x0c, 0x5c, 0x0c, 0x75, 0x0c, 0x8e,
-	0x0c, 0xa7, 0x0c, 0xc0, 0x0c, 0xd9, 0x0c, 0xf3,
-	0x0d, 0x0d, 0x0d, 0x26, 0x0d, 0x40, 0x0d, 0x5a,
-	0x0d, 0x74, 0x0d, 0x8e, 0x0d, 0xa9, 0x0d, 0xc3,
-	0x0d, 0xde, 0x0d, 0xf8, 0x0e, 0x13, 0x0e, 0x2e,
-	0x0e, 0x49, 0x0e, 0x64, 0x0e, 0x7f, 0x0e, 0x9b,
-	0x0e, 0xb6, 0x0e, 0xd2, 0x0e, 0xee, 0x0f, 0x09,
-	0x0f, 0x25, 0x0f, 0x41, 0x0f, 0x5e, 0x0f, 0x7a,
-	0x0f, 0x96, 0x0f, 0xb3, 0x0f, 0xcf, 0x0f, 0xec,
-	0x10, 0x09, 0x10, 0x26, 0x10, 0x43, 0x10, 0x61,
-	0x10, 0x7e, 0x10, 0x9b, 0x10, 0xb9, 0x10, 0xd7,
-	0x10, 0xf5, 0x11, 0x13, 0x11, 0x31, 0x11, 0x4f,
-	0x11, 0x6d, 0x11, 0x8c, 0x11, 0xaa, 0x11, 0xc9,
-	0x11, 0xe8, 0x12, 0x07, 0x12, 0x26, 0x12, 0x45,
-	0x12, 0x64, 0x12, 0x84, 0x12, 0xa3, 0x12, 0xc3,
-	0x12, 0xe3, 0x13, 0x03, 0x13, 0x23, 0x13, 0x43,
-	0x13, 0x63, 0x13, 0x83, 0x13, 0xa4, 0x13, 0xc5,
-	0x13, 0xe5, 0x14, 0x06, 0x14, 0x27, 0x14, 0x49,
-	0x14, 0x6a, 0x14, 0x8b, 0x14, 0xad, 0x14, 0xce,
-	0x14, 0xf0, 0x15, 0x12, 0x15, 0x34, 0x15, 0x56,
-	0x15, 0x78, 0x15, 0x9b, 0x15, 0xbd, 0x15, 0xe0,
-	0x16, 0x03, 0x16, 0x26, 0x16, 0x49, 0x16, 0x6c,
-	0x16, 0x8f, 0x16, 0xb2, 0x16, 0xd6, 0x16, 0xfa,
-	0x17, 0x1d, 0x17, 0x41, 0x17, 0x65, 0x17, 0x89,
-	0x17, 0xae, 0x17, 0xd2, 0x17, 0xf7, 0x18, 0x1b,
-	0x18, 0x40, 0x18, 0x65, 0x18, 0x8a, 0x18, 0xaf,
-	0x18, 0xd5, 0x18, 0xfa, 0x19, 0x20, 0x19, 0x45,
-	0x19, 0x6b, 0x19, 0x91, 0x19, 0xb7, 0x19, 0xdd,
-	0x1a, 0x04, 0x1a, 0x2a, 0x1a, 0x51, 0x1a, 0x77,
-	0x1a, 0x9e, 0x1a, 0xc5, 0x1a, 0xec, 0x1b, 0x14,
-	0x1b, 0x3b, 0x1b, 0x63, 0x1b, 0x8a, 0x1b, 0xb2,
-	0x1b, 0xda, 0x1c, 0x02, 0x1c, 0x2a, 0x1c, 0x52,
-	0x1c, 0x7b, 0x1c, 0xa3, 0x1c, 0xcc, 0x1c, 0xf5,
-	0x1d, 0x1e, 0x1d, 0x47, 0x1d, 0x70, 0x1d, 0x99,
-	0x1d, 0xc3, 0x1d, 0xec, 0x1e, 0x16, 0x1e, 0x40,
-	0x1e, 0x6a, 0x1e, 0x94, 0x1e, 0xbe, 0x1e, 0xe9,
-	0x1f, 0x13, 0x1f, 0x3e, 0x1f, 0x69, 0x1f, 0x94,
-	0x1f, 0xbf, 0x1f, 0xea, 0x20, 0x15, 0x20, 0x41,
-	0x20, 0x6c, 0x20, 0x98, 0x20, 0xc4, 0x20, 0xf0,
-	0x21, 0x1c, 0x21, 0x48, 0x21, 0x75, 0x21, 0xa1,
-	0x21, 0xce, 0x21, 0xfb, 0x22, 0x27, 0x22, 0x55,
-	0x22, 0x82, 0x22, 0xaf, 0x22, 0xdd, 0x23, 0x0a,
-	0x23, 0x38, 0x23, 0x66, 0x23, 0x94, 0x23, 0xc2,
-	0x23, 0xf0, 0x24, 0x1f, 0x24, 0x4d, 0x24, 0x7c,
-	0x24, 0xab, 0x24, 0xda, 0x25, 0x09, 0x25, 0x38,
-	0x25, 0x68, 0x25, 0x97, 0x25, 0xc7, 0x25, 0xf7,
-	0x26, 0x27, 0x26, 0x57, 0x26, 0x87, 0x26, 0xb7,
-	0x26, 0xe8, 0x27, 0x18, 0x27, 0x49, 0x27, 0x7a,
-	0x27, 0xab, 0x27, 0xdc, 0x28, 0x0d, 0x28, 0x3f,
-	0x28, 0x71, 0x28, 0xa2, 0x28, 0xd4, 0x29, 0x06,
-	0x29, 0x38, 0x29, 0x6b, 0x29, 0x9d, 0x29, 0xd0,
-	0x2a, 0x02, 0x2a, 0x35, 0x2a, 0x68, 0x2a, 0x9b,
-	0x2a, 0xcf, 0x2b, 0x02, 0x2b, 0x36, 0x2b, 0x69,
-	0x2b, 0x9d, 0x2b, 0xd1, 0x2c, 0x05, 0x2c, 0x39,
-	0x2c, 0x6e, 0x2c, 0xa2, 0x2c, 0xd7, 0x2d, 0x0c,
-	0x2d, 0x41, 0x2d, 0x76, 0x2d, 0xab, 0x2d, 0xe1,
-	0x2e, 0x16, 0x2e, 0x4c, 0x2e, 0x82, 0x2e, 0xb7,
-	0x2e, 0xee, 0x2f, 0x24, 0x2f, 0x5a, 0x2f, 0x91,
-	0x2f, 0xc7, 0x2f, 0xfe, 0x30, 0x35, 0x30, 0x6c,
-	0x30, 0xa4, 0x30, 0xdb, 0x31, 0x12, 0x31, 0x4a,
-	0x31, 0x82, 0x31, 0xba, 0x31, 0xf2, 0x32, 0x2a,
-	0x32, 0x63, 0x32, 0x9b, 0x32, 0xd4, 0x33, 0x0d,
-	0x33, 0x46, 0x33, 0x7f, 0x33, 0xb8, 0x33, 0xf1,
-	0x34, 0x2b, 0x34, 0x65, 0x34, 0x9e, 0x34, 0xd8,
-	0x35, 0x13, 0x35, 0x4d, 0x35, 0x87, 0x35, 0xc2,
-	0x35, 0xfd, 0x36, 0x37, 0x36, 0x72, 0x36, 0xae,
-	0x36, 0xe9, 0x37, 0x24, 0x37, 0x60, 0x37, 0x9c,
-	0x37, 0xd7, 0x38, 0x14, 0x38, 0x50, 0x38, 0x8c,
-	0x38, 0xc8, 0x39, 0x05, 0x39, 0x42, 0x39, 0x7f,
-	0x39, 0xbc, 0x39, 0xf9, 0x3a, 0x36, 0x3a, 0x74,
-	0x3a, 0xb2, 0x3a, 0xef, 0x3b, 0x2d, 0x3b, 0x6b,
-	0x3b, 0xaa, 0x3b, 0xe8, 0x3c, 0x27, 0x3c, 0x65,
-	0x3c, 0xa4, 0x3c, 0xe3, 0x3d, 0x22, 0x3d, 0x61,
-	0x3d, 0xa1, 0x3d, 0xe0, 0x3e, 0x20, 0x3e, 0x60,
-	0x3e, 0xa0, 0x3e, 0xe0, 0x3f, 0x21, 0x3f, 0x61,
-	0x3f, 0xa2, 0x3f, 0xe2, 0x40, 0x23, 0x40, 0x64,
-	0x40, 0xa6, 0x40, 0xe7, 0x41, 0x29, 0x41, 0x6a,
-	0x41, 0xac, 0x41, 0xee, 0x42, 0x30, 0x42, 0x72,
-	0x42, 0xb5, 0x42, 0xf7, 0x43, 0x3a, 0x43, 0x7d,
-	0x43, 0xc0, 0x44, 0x03, 0x44, 0x47, 0x44, 0x8a,
-	0x44, 0xce, 0x45, 0x12, 0x45, 0x55, 0x45, 0x9a,
-	0x45, 0xde, 0x46, 0x22, 0x46, 0x67, 0x46, 0xab,
-	0x46, 0xf0, 0x47, 0x35, 0x47, 0x7b, 0x47, 0xc0,
-	0x48, 0x05, 0x48, 0x4b, 0x48, 0x91, 0x48, 0xd7,
-	0x49, 0x1d, 0x49, 0x63, 0x49, 0xa9, 0x49, 0xf0,
-	0x4a, 0x37, 0x4a, 0x7d, 0x4a, 0xc4, 0x4b, 0x0c,
-	0x4b, 0x53, 0x4b, 0x9a, 0x4b, 0xe2, 0x4c, 0x2a,
-	0x4c, 0x72, 0x4c, 0xba, 0x4d, 0x02, 0x4d, 0x4a,
-	0x4d, 0x93, 0x4d, 0xdc, 0x4e, 0x25, 0x4e, 0x6e,
-	0x4e, 0xb7, 0x4f, 0x00, 0x4f, 0x49, 0x4f, 0x93,
-	0x4f, 0xdd, 0x50, 0x27, 0x50, 0x71, 0x50, 0xbb,
-	0x51, 0x06, 0x51, 0x50, 0x51, 0x9b, 0x51, 0xe6,
-	0x52, 0x31, 0x52, 0x7c, 0x52, 0xc7, 0x53, 0x13,
-	0x53, 0x5f, 0x53, 0xaa, 0x53, 0xf6, 0x54, 0x42,
-	0x54, 0x8f, 0x54, 0xdb, 0x55, 0x28, 0x55, 0x75,
-	0x55, 0xc2, 0x56, 0x0f, 0x56, 0x5c, 0x56, 0xa9,
-	0x56, 0xf7, 0x57, 0x44, 0x57, 0x92, 0x57, 0xe0,
-	0x58, 0x2f, 0x58, 0x7d, 0x58, 0xcb, 0x59, 0x1a,
-	0x59, 0x69, 0x59, 0xb8, 0x5a, 0x07, 0x5a, 0x56,
-	0x5a, 0xa6, 0x5a, 0xf5, 0x5b, 0x45, 0x5b, 0x95,
-	0x5b, 0xe5, 0x5c, 0x35, 0x5c, 0x86, 0x5c, 0xd6,
-	0x5d, 0x27, 0x5d, 0x78, 0x5d, 0xc9, 0x5e, 0x1a,
-	0x5e, 0x6c, 0x5e, 0xbd, 0x5f, 0x0f, 0x5f, 0x61,
-	0x5f, 0xb3, 0x60, 0x05, 0x60, 0x57, 0x60, 0xaa,
-	0x60, 0xfc, 0x61, 0x4f, 0x61, 0xa2, 0x61, 0xf5,
-	0x62, 0x49, 0x62, 0x9c, 0x62, 0xf0, 0x63, 0x43,
-	0x63, 0x97, 0x63, 0xeb, 0x64, 0x40, 0x64, 0x94,
-	0x64, 0xe9, 0x65, 0x3d, 0x65, 0x92, 0x65, 0xe7,
-	0x66, 0x3d, 0x66, 0x92, 0x66, 0xe8, 0x67, 0x3d,
-	0x67, 0x93, 0x67, 0xe9, 0x68, 0x3f, 0x68, 0x96,
-	0x68, 0xec, 0x69, 0x43, 0x69, 0x9a, 0x69, 0xf1,
-	0x6a, 0x48, 0x6a, 0x9f, 0x6a, 0xf7, 0x6b, 0x4f,
-	0x6b, 0xa7, 0x6b, 0xff, 0x6c, 0x57, 0x6c, 0xaf,
-	0x6d, 0x08, 0x6d, 0x60, 0x6d, 0xb9, 0x6e, 0x12,
-	0x6e, 0x6b, 0x6e, 0xc4, 0x6f, 0x1e, 0x6f, 0x78,
-	0x6f, 0xd1, 0x70, 0x2b, 0x70, 0x86, 0x70, 0xe0,
-	0x71, 0x3a, 0x71, 0x95, 0x71, 0xf0, 0x72, 0x4b,
-	0x72, 0xa6, 0x73, 0x01, 0x73, 0x5d, 0x73, 0xb8,
-	0x74, 0x14, 0x74, 0x70, 0x74, 0xcc, 0x75, 0x28,
-	0x75, 0x85, 0x75, 0xe1, 0x76, 0x3e, 0x76, 0x9b,
-	0x76, 0xf8, 0x77, 0x56, 0x77, 0xb3, 0x78, 0x11,
-	0x78, 0x6e, 0x78, 0xcc, 0x79, 0x2a, 0x79, 0x89,
-	0x79, 0xe7, 0x7a, 0x46, 0x7a, 0xa5, 0x7b, 0x04,
-	0x7b, 0x63, 0x7b, 0xc2, 0x7c, 0x21, 0x7c, 0x81,
-	0x7c, 0xe1, 0x7d, 0x41, 0x7d, 0xa1, 0x7e, 0x01,
-	0x7e, 0x62, 0x7e, 0xc2, 0x7f, 0x23, 0x7f, 0x84,
-	0x7f, 0xe5, 0x80, 0x47, 0x80, 0xa8, 0x81, 0x0a,
-	0x81, 0x6b, 0x81, 0xcd, 0x82, 0x30, 0x82, 0x92,
-	0x82, 0xf4, 0x83, 0x57, 0x83, 0xba, 0x84, 0x1d,
-	0x84, 0x80, 0x84, 0xe3, 0x85, 0x47, 0x85, 0xab,
-	0x86, 0x0e, 0x86, 0x72, 0x86, 0xd7, 0x87, 0x3b,
-	0x87, 0x9f, 0x88, 0x04, 0x88, 0x69, 0x88, 0xce,
-	0x89, 0x33, 0x89, 0x99, 0x89, 0xfe, 0x8a, 0x64,
-	0x8a, 0xca, 0x8b, 0x30, 0x8b, 0x96, 0x8b, 0xfc,
-	0x8c, 0x63, 0x8c, 0xca, 0x8d, 0x31, 0x8d, 0x98,
-	0x8d, 0xff, 0x8e, 0x66, 0x8e, 0xce, 0x8f, 0x36,
-	0x8f, 0x9e, 0x90, 0x06, 0x90, 0x6e, 0x90, 0xd6,
-	0x91, 0x3f, 0x91, 0xa8, 0x92, 0x11, 0x92, 0x7a,
-	0x92, 0xe3, 0x93, 0x4d, 0x93, 0xb6, 0x94, 0x20,
-	0x94, 0x8a, 0x94, 0xf4, 0x95, 0x5f, 0x95, 0xc9,
-	0x96, 0x34, 0x96, 0x9f, 0x97, 0x0a, 0x97, 0x75,
-	0x97, 0xe0, 0x98, 0x4c, 0x98, 0xb8, 0x99, 0x24,
-	0x99, 0x90, 0x99, 0xfc, 0x9a, 0x68, 0x9a, 0xd5,
-	0x9b, 0x42, 0x9b, 0xaf, 0x9c, 0x1c, 0x9c, 0x89,
-	0x9c, 0xf7, 0x9d, 0x64, 0x9d, 0xd2, 0x9e, 0x40,
-	0x9e, 0xae, 0x9f, 0x1d, 0x9f, 0x8b, 0x9f, 0xfa,
-	0xa0, 0x69, 0xa0, 0xd8, 0xa1, 0x47, 0xa1, 0xb6,
-	0xa2, 0x26, 0xa2, 0x96, 0xa3, 0x06, 0xa3, 0x76,
-	0xa3, 0xe6, 0xa4, 0x56, 0xa4, 0xc7, 0xa5, 0x38,
-	0xa5, 0xa9, 0xa6, 0x1a, 0xa6, 0x8b, 0xa6, 0xfd,
-	0xa7, 0x6e, 0xa7, 0xe0, 0xa8, 0x52, 0xa8, 0xc4,
-	0xa9, 0x37, 0xa9, 0xa9, 0xaa, 0x1c, 0xaa, 0x8f,
-	0xab, 0x02, 0xab, 0x75, 0xab, 0xe9, 0xac, 0x5c,
-	0xac, 0xd0, 0xad, 0x44, 0xad, 0xb8, 0xae, 0x2d,
-	0xae, 0xa1, 0xaf, 0x16, 0xaf, 0x8b, 0xb0, 0x00,
-	0xb0, 0x75, 0xb0, 0xea, 0xb1, 0x60, 0xb1, 0xd6,
-	0xb2, 0x4b, 0xb2, 0xc2, 0xb3, 0x38, 0xb3, 0xae,
-	0xb4, 0x25, 0xb4, 0x9c, 0xb5, 0x13, 0xb5, 0x8a,
-	0xb6, 0x01, 0xb6, 0x79, 0xb6, 0xf0, 0xb7, 0x68,
-	0xb7, 0xe0, 0xb8, 0x59, 0xb8, 0xd1, 0xb9, 0x4a,
-	0xb9, 0xc2, 0xba, 0x3b, 0xba, 0xb5, 0xbb, 0x2e,
-	0xbb, 0xa7, 0xbc, 0x21, 0xbc, 0x9b, 0xbd, 0x15,
-	0xbd, 0x8f, 0xbe, 0x0a, 0xbe, 0x84, 0xbe, 0xff,
-	0xbf, 0x7a, 0xbf, 0xf5, 0xc0, 0x70, 0xc0, 0xec,
-	0xc1, 0x67, 0xc1, 0xe3, 0xc2, 0x5f, 0xc2, 0xdb,
-	0xc3, 0x58, 0xc3, 0xd4, 0xc4, 0x51, 0xc4, 0xce,
-	0xc5, 0x4b, 0xc5, 0xc8, 0xc6, 0x46, 0xc6, 0xc3,
-	0xc7, 0x41, 0xc7, 0xbf, 0xc8, 0x3d, 0xc8, 0xbc,
-	0xc9, 0x3a, 0xc9, 0xb9, 0xca, 0x38, 0xca, 0xb7,
-	0xcb, 0x36, 0xcb, 0xb6, 0xcc, 0x35, 0xcc, 0xb5,
-	0xcd, 0x35, 0xcd, 0xb5, 0xce, 0x36, 0xce, 0xb6,
-	0xcf, 0x37, 0xcf, 0xb8, 0xd0, 0x39, 0xd0, 0xba,
-	0xd1, 0x3c, 0xd1, 0xbe, 0xd2, 0x3f, 0xd2, 0xc1,
-	0xd3, 0x44, 0xd3, 0xc6, 0xd4, 0x49, 0xd4, 0xcb,
-	0xd5, 0x4e, 0xd5, 0xd1, 0xd6, 0x55, 0xd6, 0xd8,
-	0xd7, 0x5c, 0xd7, 0xe0, 0xd8, 0x64, 0xd8, 0xe8,
-	0xd9, 0x6c, 0xd9, 0xf1, 0xda, 0x76, 0xda, 0xfb,
-	0xdb, 0x80, 0xdc, 0x05, 0xdc, 0x8a, 0xdd, 0x10,
-	0xdd, 0x96, 0xde, 0x1c, 0xde, 0xa2, 0xdf, 0x29,
-	0xdf, 0xaf, 0xe0, 0x36, 0xe0, 0xbd, 0xe1, 0x44,
-	0xe1, 0xcc, 0xe2, 0x53, 0xe2, 0xdb, 0xe3, 0x63,
-	0xe3, 0xeb, 0xe4, 0x73, 0xe4, 0xfc, 0xe5, 0x84,
-	0xe6, 0x0d, 0xe6, 0x96, 0xe7, 0x1f, 0xe7, 0xa9,
-	0xe8, 0x32, 0xe8, 0xbc, 0xe9, 0x46, 0xe9, 0xd0,
-	0xea, 0x5b, 0xea, 0xe5, 0xeb, 0x70, 0xeb, 0xfb,
-	0xec, 0x86, 0xed, 0x11, 0xed, 0x9c, 0xee, 0x28,
-	0xee, 0xb4, 0xef, 0x40, 0xef, 0xcc, 0xf0, 0x58,
-	0xf0, 0xe5, 0xf1, 0x72, 0xf1, 0xff, 0xf2, 0x8c,
-	0xf3, 0x19, 0xf3, 0xa7, 0xf4, 0x34, 0xf4, 0xc2,
-	0xf5, 0x50, 0xf5, 0xde, 0xf6, 0x6d, 0xf6, 0xfb,
-	0xf7, 0x8a, 0xf8, 0x19, 0xf8, 0xa8, 0xf9, 0x38,
-	0xf9, 0xc7, 0xfa, 0x57, 0xfa, 0xe7, 0xfb, 0x77,
-	0xfc, 0x07, 0xfc, 0x98, 0xfd, 0x29, 0xfd, 0xba,
-	0xfe, 0x4b, 0xfe, 0xdc, 0xff, 0x6d, 0xff, 0xff
+    0x00, 0x00, 0x0c, 0x48, 0x4c, 0x69, 0x6e, 0x6f,
+    0x02, 0x10, 0x00, 0x00, 0x6d, 0x6e, 0x74, 0x72,
+    0x52, 0x47, 0x42, 0x20, 0x58, 0x59, 0x5a, 0x20,
+    0x07, 0xce, 0x00, 0x02, 0x00, 0x09, 0x00, 0x06,
+    0x00, 0x31, 0x00, 0x00, 0x61, 0x63, 0x73, 0x70,
+    0x4d, 0x53, 0x46, 0x54, 0x00, 0x00, 0x00, 0x00,
+    0x49, 0x45, 0x43, 0x20, 0x73, 0x52, 0x47, 0x42,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf6, 0xd6,
+    0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0xd3, 0x2d,
+    0x48, 0x50, 0x20, 0x20, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x11, 0x63, 0x70, 0x72, 0x74,
+    0x00, 0x00, 0x01, 0x50, 0x00, 0x00, 0x00, 0x33,
+    0x64, 0x65, 0x73, 0x63, 0x00, 0x00, 0x01, 0x84,
+    0x00, 0x00, 0x00, 0x6c, 0x77, 0x74, 0x70, 0x74,
+    0x00, 0x00, 0x01, 0xf0, 0x00, 0x00, 0x00, 0x14,
+    0x62, 0x6b, 0x70, 0x74, 0x00, 0x00, 0x02, 0x04,
+    0x00, 0x00, 0x00, 0x14, 0x72, 0x58, 0x59, 0x5a,
+    0x00, 0x00, 0x02, 0x18, 0x00, 0x00, 0x00, 0x14,
+    0x67, 0x58, 0x59, 0x5a, 0x00, 0x00, 0x02, 0x2c,
+    0x00, 0x00, 0x00, 0x14, 0x62, 0x58, 0x59, 0x5a,
+    0x00, 0x00, 0x02, 0x40, 0x00, 0x00, 0x00, 0x14,
+    0x64, 0x6d, 0x6e, 0x64, 0x00, 0x00, 0x02, 0x54,
+    0x00, 0x00, 0x00, 0x70, 0x64, 0x6d, 0x64, 0x64,
+    0x00, 0x00, 0x02, 0xc4, 0x00, 0x00, 0x00, 0x88,
+    0x76, 0x75, 0x65, 0x64, 0x00, 0x00, 0x03, 0x4c,
+    0x00, 0x00, 0x00, 0x86, 0x76, 0x69, 0x65, 0x77,
+    0x00, 0x00, 0x03, 0xd4, 0x00, 0x00, 0x00, 0x24,
+    0x6c, 0x75, 0x6d, 0x69, 0x00, 0x00, 0x03, 0xf8,
+    0x00, 0x00, 0x00, 0x14, 0x6d, 0x65, 0x61, 0x73,
+    0x00, 0x00, 0x04, 0x0c, 0x00, 0x00, 0x00, 0x24,
+    0x74, 0x65, 0x63, 0x68, 0x00, 0x00, 0x04, 0x30,
+    0x00, 0x00, 0x00, 0x0c, 0x72, 0x54, 0x52, 0x43,
+    0x00, 0x00, 0x04, 0x3c, 0x00, 0x00, 0x08, 0x0c,
+    0x67, 0x54, 0x52, 0x43, 0x00, 0x00, 0x04, 0x3c,
+    0x00, 0x00, 0x08, 0x0c, 0x62, 0x54, 0x52, 0x43,
+    0x00, 0x00, 0x04, 0x3c, 0x00, 0x00, 0x08, 0x0c,
+    0x74, 0x65, 0x78, 0x74, 0x00, 0x00, 0x00, 0x00,
+    0x43, 0x6f, 0x70, 0x79, 0x72, 0x69, 0x67, 0x68,
+    0x74, 0x20, 0x28, 0x63, 0x29, 0x20, 0x31, 0x39,
+    0x39, 0x38, 0x20, 0x48, 0x65, 0x77, 0x6c, 0x65,
+    0x74, 0x74, 0x2d, 0x50, 0x61, 0x63, 0x6b, 0x61,
+    0x72, 0x64, 0x20, 0x43, 0x6f, 0x6d, 0x70, 0x61,
+    0x6e, 0x79, 0x00, 0x00, 0x64, 0x65, 0x73, 0x63,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x12,
+    0x73, 0x52, 0x47, 0x42, 0x20, 0x49, 0x45, 0x43,
+    0x36, 0x31, 0x39, 0x36, 0x36, 0x2d, 0x32, 0x2e,
+    0x31, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x12, 0x73, 0x52, 0x47,
+    0x42, 0x20, 0x49, 0x45, 0x43, 0x36, 0x31, 0x39,
+    0x36, 0x36, 0x2d, 0x32, 0x2e, 0x31, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x58, 0x59, 0x5a, 0x20, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0xf3, 0x51, 0x00, 0x01, 0x00, 0x00,
+    0x00, 0x01, 0x16, 0xcc, 0x58, 0x59, 0x5a, 0x20,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x58, 0x59, 0x5a, 0x20, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x6f, 0xa2, 0x00, 0x00, 0x38, 0xf5,
+    0x00, 0x00, 0x03, 0x90, 0x58, 0x59, 0x5a, 0x20,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x62, 0x99,
+    0x00, 0x00, 0xb7, 0x85, 0x00, 0x00, 0x18, 0xda,
+    0x58, 0x59, 0x5a, 0x20, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x24, 0xa0, 0x00, 0x00, 0x0f, 0x84,
+    0x00, 0x00, 0xb6, 0xcf, 0x64, 0x65, 0x73, 0x63,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x16,
+    0x49, 0x45, 0x43, 0x20, 0x68, 0x74, 0x74, 0x70,
+    0x3a, 0x2f, 0x2f, 0x77, 0x77, 0x77, 0x2e, 0x69,
+    0x65, 0x63, 0x2e, 0x63, 0x68, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x16, 0x49, 0x45, 0x43, 0x20, 0x68, 0x74, 0x74,
+    0x70, 0x3a, 0x2f, 0x2f, 0x77, 0x77, 0x77, 0x2e,
+    0x69, 0x65, 0x63, 0x2e, 0x63, 0x68, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x64, 0x65, 0x73, 0x63,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x2e,
+    0x49, 0x45, 0x43, 0x20, 0x36, 0x31, 0x39, 0x36,
+    0x36, 0x2d, 0x32, 0x2e, 0x31, 0x20, 0x44, 0x65,
+    0x66, 0x61, 0x75, 0x6c, 0x74, 0x20, 0x52, 0x47,
+    0x42, 0x20, 0x63, 0x6f, 0x6c, 0x6f, 0x75, 0x72,
+    0x20, 0x73, 0x70, 0x61, 0x63, 0x65, 0x20, 0x2d,
+    0x20, 0x73, 0x52, 0x47, 0x42, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x2e, 0x49, 0x45, 0x43, 0x20, 0x36, 0x31, 0x39,
+    0x36, 0x36, 0x2d, 0x32, 0x2e, 0x31, 0x20, 0x44,
+    0x65, 0x66, 0x61, 0x75, 0x6c, 0x74, 0x20, 0x52,
+    0x47, 0x42, 0x20, 0x63, 0x6f, 0x6c, 0x6f, 0x75,
+    0x72, 0x20, 0x73, 0x70, 0x61, 0x63, 0x65, 0x20,
+    0x2d, 0x20, 0x73, 0x52, 0x47, 0x42, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x64, 0x65, 0x73, 0x63,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x2c,
+    0x52, 0x65, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63,
+    0x65, 0x20, 0x56, 0x69, 0x65, 0x77, 0x69, 0x6e,
+    0x67, 0x20, 0x43, 0x6f, 0x6e, 0x64, 0x69, 0x74,
+    0x69, 0x6f, 0x6e, 0x20, 0x69, 0x6e, 0x20, 0x49,
+    0x45, 0x43, 0x36, 0x31, 0x39, 0x36, 0x36, 0x2d,
+    0x32, 0x2e, 0x31, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x2c, 0x52,
+    0x65, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65,
+    0x20, 0x56, 0x69, 0x65, 0x77, 0x69, 0x6e, 0x67,
+    0x20, 0x43, 0x6f, 0x6e, 0x64, 0x69, 0x74, 0x69,
+    0x6f, 0x6e, 0x20, 0x69, 0x6e, 0x20, 0x49, 0x45,
+    0x43, 0x36, 0x31, 0x39, 0x36, 0x36, 0x2d, 0x32,
+    0x2e, 0x31, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x76, 0x69, 0x65, 0x77,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x13, 0xa4, 0xfe,
+    0x00, 0x14, 0x5f, 0x2e, 0x00, 0x10, 0xcf, 0x14,
+    0x00, 0x03, 0xed, 0xcc, 0x00, 0x04, 0x13, 0x0b,
+    0x00, 0x03, 0x5c, 0x9e, 0x00, 0x00, 0x00, 0x01,
+    0x58, 0x59, 0x5a, 0x20, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x4c, 0x09, 0x56, 0x00, 0x50, 0x00, 0x00,
+    0x00, 0x57, 0x1f, 0xe7, 0x6d, 0x65, 0x61, 0x73,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x02, 0x8f, 0x00, 0x00, 0x00, 0x02,
+    0x73, 0x69, 0x67, 0x20, 0x00, 0x00, 0x00, 0x00,
+    0x43, 0x52, 0x54, 0x20, 0x63, 0x75, 0x72, 0x76,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x00, 0x05, 0x00, 0x0a, 0x00, 0x0f,
+    0x00, 0x14, 0x00, 0x19, 0x00, 0x1e, 0x00, 0x23,
+    0x00, 0x28, 0x00, 0x2d, 0x00, 0x32, 0x00, 0x37,
+    0x00, 0x3b, 0x00, 0x40, 0x00, 0x45, 0x00, 0x4a,
+    0x00, 0x4f, 0x00, 0x54, 0x00, 0x59, 0x00, 0x5e,
+    0x00, 0x63, 0x00, 0x68, 0x00, 0x6d, 0x00, 0x72,
+    0x00, 0x77, 0x00, 0x7c, 0x00, 0x81, 0x00, 0x86,
+    0x00, 0x8b, 0x00, 0x90, 0x00, 0x95, 0x00, 0x9a,
+    0x00, 0x9f, 0x00, 0xa4, 0x00, 0xa9, 0x00, 0xae,
+    0x00, 0xb2, 0x00, 0xb7, 0x00, 0xbc, 0x00, 0xc1,
+    0x00, 0xc6, 0x00, 0xcb, 0x00, 0xd0, 0x00, 0xd5,
+    0x00, 0xdb, 0x00, 0xe0, 0x00, 0xe5, 0x00, 0xeb,
+    0x00, 0xf0, 0x00, 0xf6, 0x00, 0xfb, 0x01, 0x01,
+    0x01, 0x07, 0x01, 0x0d, 0x01, 0x13, 0x01, 0x19,
+    0x01, 0x1f, 0x01, 0x25, 0x01, 0x2b, 0x01, 0x32,
+    0x01, 0x38, 0x01, 0x3e, 0x01, 0x45, 0x01, 0x4c,
+    0x01, 0x52, 0x01, 0x59, 0x01, 0x60, 0x01, 0x67,
+    0x01, 0x6e, 0x01, 0x75, 0x01, 0x7c, 0x01, 0x83,
+    0x01, 0x8b, 0x01, 0x92, 0x01, 0x9a, 0x01, 0xa1,
+    0x01, 0xa9, 0x01, 0xb1, 0x01, 0xb9, 0x01, 0xc1,
+    0x01, 0xc9, 0x01, 0xd1, 0x01, 0xd9, 0x01, 0xe1,
+    0x01, 0xe9, 0x01, 0xf2, 0x01, 0xfa, 0x02, 0x03,
+    0x02, 0x0c, 0x02, 0x14, 0x02, 0x1d, 0x02, 0x26,
+    0x02, 0x2f, 0x02, 0x38, 0x02, 0x41, 0x02, 0x4b,
+    0x02, 0x54, 0x02, 0x5d, 0x02, 0x67, 0x02, 0x71,
+    0x02, 0x7a, 0x02, 0x84, 0x02, 0x8e, 0x02, 0x98,
+    0x02, 0xa2, 0x02, 0xac, 0x02, 0xb6, 0x02, 0xc1,
+    0x02, 0xcb, 0x02, 0xd5, 0x02, 0xe0, 0x02, 0xeb,
+    0x02, 0xf5, 0x03, 0x00, 0x03, 0x0b, 0x03, 0x16,
+    0x03, 0x21, 0x03, 0x2d, 0x03, 0x38, 0x03, 0x43,
+    0x03, 0x4f, 0x03, 0x5a, 0x03, 0x66, 0x03, 0x72,
+    0x03, 0x7e, 0x03, 0x8a, 0x03, 0x96, 0x03, 0xa2,
+    0x03, 0xae, 0x03, 0xba, 0x03, 0xc7, 0x03, 0xd3,
+    0x03, 0xe0, 0x03, 0xec, 0x03, 0xf9, 0x04, 0x06,
+    0x04, 0x13, 0x04, 0x20, 0x04, 0x2d, 0x04, 0x3b,
+    0x04, 0x48, 0x04, 0x55, 0x04, 0x63, 0x04, 0x71,
+    0x04, 0x7e, 0x04, 0x8c, 0x04, 0x9a, 0x04, 0xa8,
+    0x04, 0xb6, 0x04, 0xc4, 0x04, 0xd3, 0x04, 0xe1,
+    0x04, 0xf0, 0x04, 0xfe, 0x05, 0x0d, 0x05, 0x1c,
+    0x05, 0x2b, 0x05, 0x3a, 0x05, 0x49, 0x05, 0x58,
+    0x05, 0x67, 0x05, 0x77, 0x05, 0x86, 0x05, 0x96,
+    0x05, 0xa6, 0x05, 0xb5, 0x05, 0xc5, 0x05, 0xd5,
+    0x05, 0xe5, 0x05, 0xf6, 0x06, 0x06, 0x06, 0x16,
+    0x06, 0x27, 0x06, 0x37, 0x06, 0x48, 0x06, 0x59,
+    0x06, 0x6a, 0x06, 0x7b, 0x06, 0x8c, 0x06, 0x9d,
+    0x06, 0xaf, 0x06, 0xc0, 0x06, 0xd1, 0x06, 0xe3,
+    0x06, 0xf5, 0x07, 0x07, 0x07, 0x19, 0x07, 0x2b,
+    0x07, 0x3d, 0x07, 0x4f, 0x07, 0x61, 0x07, 0x74,
+    0x07, 0x86, 0x07, 0x99, 0x07, 0xac, 0x07, 0xbf,
+    0x07, 0xd2, 0x07, 0xe5, 0x07, 0xf8, 0x08, 0x0b,
+    0x08, 0x1f, 0x08, 0x32, 0x08, 0x46, 0x08, 0x5a,
+    0x08, 0x6e, 0x08, 0x82, 0x08, 0x96, 0x08, 0xaa,
+    0x08, 0xbe, 0x08, 0xd2, 0x08, 0xe7, 0x08, 0xfb,
+    0x09, 0x10, 0x09, 0x25, 0x09, 0x3a, 0x09, 0x4f,
+    0x09, 0x64, 0x09, 0x79, 0x09, 0x8f, 0x09, 0xa4,
+    0x09, 0xba, 0x09, 0xcf, 0x09, 0xe5, 0x09, 0xfb,
+    0x0a, 0x11, 0x0a, 0x27, 0x0a, 0x3d, 0x0a, 0x54,
+    0x0a, 0x6a, 0x0a, 0x81, 0x0a, 0x98, 0x0a, 0xae,
+    0x0a, 0xc5, 0x0a, 0xdc, 0x0a, 0xf3, 0x0b, 0x0b,
+    0x0b, 0x22, 0x0b, 0x39, 0x0b, 0x51, 0x0b, 0x69,
+    0x0b, 0x80, 0x0b, 0x98, 0x0b, 0xb0, 0x0b, 0xc8,
+    0x0b, 0xe1, 0x0b, 0xf9, 0x0c, 0x12, 0x0c, 0x2a,
+    0x0c, 0x43, 0x0c, 0x5c, 0x0c, 0x75, 0x0c, 0x8e,
+    0x0c, 0xa7, 0x0c, 0xc0, 0x0c, 0xd9, 0x0c, 0xf3,
+    0x0d, 0x0d, 0x0d, 0x26, 0x0d, 0x40, 0x0d, 0x5a,
+    0x0d, 0x74, 0x0d, 0x8e, 0x0d, 0xa9, 0x0d, 0xc3,
+    0x0d, 0xde, 0x0d, 0xf8, 0x0e, 0x13, 0x0e, 0x2e,
+    0x0e, 0x49, 0x0e, 0x64, 0x0e, 0x7f, 0x0e, 0x9b,
+    0x0e, 0xb6, 0x0e, 0xd2, 0x0e, 0xee, 0x0f, 0x09,
+    0x0f, 0x25, 0x0f, 0x41, 0x0f, 0x5e, 0x0f, 0x7a,
+    0x0f, 0x96, 0x0f, 0xb3, 0x0f, 0xcf, 0x0f, 0xec,
+    0x10, 0x09, 0x10, 0x26, 0x10, 0x43, 0x10, 0x61,
+    0x10, 0x7e, 0x10, 0x9b, 0x10, 0xb9, 0x10, 0xd7,
+    0x10, 0xf5, 0x11, 0x13, 0x11, 0x31, 0x11, 0x4f,
+    0x11, 0x6d, 0x11, 0x8c, 0x11, 0xaa, 0x11, 0xc9,
+    0x11, 0xe8, 0x12, 0x07, 0x12, 0x26, 0x12, 0x45,
+    0x12, 0x64, 0x12, 0x84, 0x12, 0xa3, 0x12, 0xc3,
+    0x12, 0xe3, 0x13, 0x03, 0x13, 0x23, 0x13, 0x43,
+    0x13, 0x63, 0x13, 0x83, 0x13, 0xa4, 0x13, 0xc5,
+    0x13, 0xe5, 0x14, 0x06, 0x14, 0x27, 0x14, 0x49,
+    0x14, 0x6a, 0x14, 0x8b, 0x14, 0xad, 0x14, 0xce,
+    0x14, 0xf0, 0x15, 0x12, 0x15, 0x34, 0x15, 0x56,
+    0x15, 0x78, 0x15, 0x9b, 0x15, 0xbd, 0x15, 0xe0,
+    0x16, 0x03, 0x16, 0x26, 0x16, 0x49, 0x16, 0x6c,
+    0x16, 0x8f, 0x16, 0xb2, 0x16, 0xd6, 0x16, 0xfa,
+    0x17, 0x1d, 0x17, 0x41, 0x17, 0x65, 0x17, 0x89,
+    0x17, 0xae, 0x17, 0xd2, 0x17, 0xf7, 0x18, 0x1b,
+    0x18, 0x40, 0x18, 0x65, 0x18, 0x8a, 0x18, 0xaf,
+    0x18, 0xd5, 0x18, 0xfa, 0x19, 0x20, 0x19, 0x45,
+    0x19, 0x6b, 0x19, 0x91, 0x19, 0xb7, 0x19, 0xdd,
+    0x1a, 0x04, 0x1a, 0x2a, 0x1a, 0x51, 0x1a, 0x77,
+    0x1a, 0x9e, 0x1a, 0xc5, 0x1a, 0xec, 0x1b, 0x14,
+    0x1b, 0x3b, 0x1b, 0x63, 0x1b, 0x8a, 0x1b, 0xb2,
+    0x1b, 0xda, 0x1c, 0x02, 0x1c, 0x2a, 0x1c, 0x52,
+    0x1c, 0x7b, 0x1c, 0xa3, 0x1c, 0xcc, 0x1c, 0xf5,
+    0x1d, 0x1e, 0x1d, 0x47, 0x1d, 0x70, 0x1d, 0x99,
+    0x1d, 0xc3, 0x1d, 0xec, 0x1e, 0x16, 0x1e, 0x40,
+    0x1e, 0x6a, 0x1e, 0x94, 0x1e, 0xbe, 0x1e, 0xe9,
+    0x1f, 0x13, 0x1f, 0x3e, 0x1f, 0x69, 0x1f, 0x94,
+    0x1f, 0xbf, 0x1f, 0xea, 0x20, 0x15, 0x20, 0x41,
+    0x20, 0x6c, 0x20, 0x98, 0x20, 0xc4, 0x20, 0xf0,
+    0x21, 0x1c, 0x21, 0x48, 0x21, 0x75, 0x21, 0xa1,
+    0x21, 0xce, 0x21, 0xfb, 0x22, 0x27, 0x22, 0x55,
+    0x22, 0x82, 0x22, 0xaf, 0x22, 0xdd, 0x23, 0x0a,
+    0x23, 0x38, 0x23, 0x66, 0x23, 0x94, 0x23, 0xc2,
+    0x23, 0xf0, 0x24, 0x1f, 0x24, 0x4d, 0x24, 0x7c,
+    0x24, 0xab, 0x24, 0xda, 0x25, 0x09, 0x25, 0x38,
+    0x25, 0x68, 0x25, 0x97, 0x25, 0xc7, 0x25, 0xf7,
+    0x26, 0x27, 0x26, 0x57, 0x26, 0x87, 0x26, 0xb7,
+    0x26, 0xe8, 0x27, 0x18, 0x27, 0x49, 0x27, 0x7a,
+    0x27, 0xab, 0x27, 0xdc, 0x28, 0x0d, 0x28, 0x3f,
+    0x28, 0x71, 0x28, 0xa2, 0x28, 0xd4, 0x29, 0x06,
+    0x29, 0x38, 0x29, 0x6b, 0x29, 0x9d, 0x29, 0xd0,
+    0x2a, 0x02, 0x2a, 0x35, 0x2a, 0x68, 0x2a, 0x9b,
+    0x2a, 0xcf, 0x2b, 0x02, 0x2b, 0x36, 0x2b, 0x69,
+    0x2b, 0x9d, 0x2b, 0xd1, 0x2c, 0x05, 0x2c, 0x39,
+    0x2c, 0x6e, 0x2c, 0xa2, 0x2c, 0xd7, 0x2d, 0x0c,
+    0x2d, 0x41, 0x2d, 0x76, 0x2d, 0xab, 0x2d, 0xe1,
+    0x2e, 0x16, 0x2e, 0x4c, 0x2e, 0x82, 0x2e, 0xb7,
+    0x2e, 0xee, 0x2f, 0x24, 0x2f, 0x5a, 0x2f, 0x91,
+    0x2f, 0xc7, 0x2f, 0xfe, 0x30, 0x35, 0x30, 0x6c,
+    0x30, 0xa4, 0x30, 0xdb, 0x31, 0x12, 0x31, 0x4a,
+    0x31, 0x82, 0x31, 0xba, 0x31, 0xf2, 0x32, 0x2a,
+    0x32, 0x63, 0x32, 0x9b, 0x32, 0xd4, 0x33, 0x0d,
+    0x33, 0x46, 0x33, 0x7f, 0x33, 0xb8, 0x33, 0xf1,
+    0x34, 0x2b, 0x34, 0x65, 0x34, 0x9e, 0x34, 0xd8,
+    0x35, 0x13, 0x35, 0x4d, 0x35, 0x87, 0x35, 0xc2,
+    0x35, 0xfd, 0x36, 0x37, 0x36, 0x72, 0x36, 0xae,
+    0x36, 0xe9, 0x37, 0x24, 0x37, 0x60, 0x37, 0x9c,
+    0x37, 0xd7, 0x38, 0x14, 0x38, 0x50, 0x38, 0x8c,
+    0x38, 0xc8, 0x39, 0x05, 0x39, 0x42, 0x39, 0x7f,
+    0x39, 0xbc, 0x39, 0xf9, 0x3a, 0x36, 0x3a, 0x74,
+    0x3a, 0xb2, 0x3a, 0xef, 0x3b, 0x2d, 0x3b, 0x6b,
+    0x3b, 0xaa, 0x3b, 0xe8, 0x3c, 0x27, 0x3c, 0x65,
+    0x3c, 0xa4, 0x3c, 0xe3, 0x3d, 0x22, 0x3d, 0x61,
+    0x3d, 0xa1, 0x3d, 0xe0, 0x3e, 0x20, 0x3e, 0x60,
+    0x3e, 0xa0, 0x3e, 0xe0, 0x3f, 0x21, 0x3f, 0x61,
+    0x3f, 0xa2, 0x3f, 0xe2, 0x40, 0x23, 0x40, 0x64,
+    0x40, 0xa6, 0x40, 0xe7, 0x41, 0x29, 0x41, 0x6a,
+    0x41, 0xac, 0x41, 0xee, 0x42, 0x30, 0x42, 0x72,
+    0x42, 0xb5, 0x42, 0xf7, 0x43, 0x3a, 0x43, 0x7d,
+    0x43, 0xc0, 0x44, 0x03, 0x44, 0x47, 0x44, 0x8a,
+    0x44, 0xce, 0x45, 0x12, 0x45, 0x55, 0x45, 0x9a,
+    0x45, 0xde, 0x46, 0x22, 0x46, 0x67, 0x46, 0xab,
+    0x46, 0xf0, 0x47, 0x35, 0x47, 0x7b, 0x47, 0xc0,
+    0x48, 0x05, 0x48, 0x4b, 0x48, 0x91, 0x48, 0xd7,
+    0x49, 0x1d, 0x49, 0x63, 0x49, 0xa9, 0x49, 0xf0,
+    0x4a, 0x37, 0x4a, 0x7d, 0x4a, 0xc4, 0x4b, 0x0c,
+    0x4b, 0x53, 0x4b, 0x9a, 0x4b, 0xe2, 0x4c, 0x2a,
+    0x4c, 0x72, 0x4c, 0xba, 0x4d, 0x02, 0x4d, 0x4a,
+    0x4d, 0x93, 0x4d, 0xdc, 0x4e, 0x25, 0x4e, 0x6e,
+    0x4e, 0xb7, 0x4f, 0x00, 0x4f, 0x49, 0x4f, 0x93,
+    0x4f, 0xdd, 0x50, 0x27, 0x50, 0x71, 0x50, 0xbb,
+    0x51, 0x06, 0x51, 0x50, 0x51, 0x9b, 0x51, 0xe6,
+    0x52, 0x31, 0x52, 0x7c, 0x52, 0xc7, 0x53, 0x13,
+    0x53, 0x5f, 0x53, 0xaa, 0x53, 0xf6, 0x54, 0x42,
+    0x54, 0x8f, 0x54, 0xdb, 0x55, 0x28, 0x55, 0x75,
+    0x55, 0xc2, 0x56, 0x0f, 0x56, 0x5c, 0x56, 0xa9,
+    0x56, 0xf7, 0x57, 0x44, 0x57, 0x92, 0x57, 0xe0,
+    0x58, 0x2f, 0x58, 0x7d, 0x58, 0xcb, 0x59, 0x1a,
+    0x59, 0x69, 0x59, 0xb8, 0x5a, 0x07, 0x5a, 0x56,
+    0x5a, 0xa6, 0x5a, 0xf5, 0x5b, 0x45, 0x5b, 0x95,
+    0x5b, 0xe5, 0x5c, 0x35, 0x5c, 0x86, 0x5c, 0xd6,
+    0x5d, 0x27, 0x5d, 0x78, 0x5d, 0xc9, 0x5e, 0x1a,
+    0x5e, 0x6c, 0x5e, 0xbd, 0x5f, 0x0f, 0x5f, 0x61,
+    0x5f, 0xb3, 0x60, 0x05, 0x60, 0x57, 0x60, 0xaa,
+    0x60, 0xfc, 0x61, 0x4f, 0x61, 0xa2, 0x61, 0xf5,
+    0x62, 0x49, 0x62, 0x9c, 0x62, 0xf0, 0x63, 0x43,
+    0x63, 0x97, 0x63, 0xeb, 0x64, 0x40, 0x64, 0x94,
+    0x64, 0xe9, 0x65, 0x3d, 0x65, 0x92, 0x65, 0xe7,
+    0x66, 0x3d, 0x66, 0x92, 0x66, 0xe8, 0x67, 0x3d,
+    0x67, 0x93, 0x67, 0xe9, 0x68, 0x3f, 0x68, 0x96,
+    0x68, 0xec, 0x69, 0x43, 0x69, 0x9a, 0x69, 0xf1,
+    0x6a, 0x48, 0x6a, 0x9f, 0x6a, 0xf7, 0x6b, 0x4f,
+    0x6b, 0xa7, 0x6b, 0xff, 0x6c, 0x57, 0x6c, 0xaf,
+    0x6d, 0x08, 0x6d, 0x60, 0x6d, 0xb9, 0x6e, 0x12,
+    0x6e, 0x6b, 0x6e, 0xc4, 0x6f, 0x1e, 0x6f, 0x78,
+    0x6f, 0xd1, 0x70, 0x2b, 0x70, 0x86, 0x70, 0xe0,
+    0x71, 0x3a, 0x71, 0x95, 0x71, 0xf0, 0x72, 0x4b,
+    0x72, 0xa6, 0x73, 0x01, 0x73, 0x5d, 0x73, 0xb8,
+    0x74, 0x14, 0x74, 0x70, 0x74, 0xcc, 0x75, 0x28,
+    0x75, 0x85, 0x75, 0xe1, 0x76, 0x3e, 0x76, 0x9b,
+    0x76, 0xf8, 0x77, 0x56, 0x77, 0xb3, 0x78, 0x11,
+    0x78, 0x6e, 0x78, 0xcc, 0x79, 0x2a, 0x79, 0x89,
+    0x79, 0xe7, 0x7a, 0x46, 0x7a, 0xa5, 0x7b, 0x04,
+    0x7b, 0x63, 0x7b, 0xc2, 0x7c, 0x21, 0x7c, 0x81,
+    0x7c, 0xe1, 0x7d, 0x41, 0x7d, 0xa1, 0x7e, 0x01,
+    0x7e, 0x62, 0x7e, 0xc2, 0x7f, 0x23, 0x7f, 0x84,
+    0x7f, 0xe5, 0x80, 0x47, 0x80, 0xa8, 0x81, 0x0a,
+    0x81, 0x6b, 0x81, 0xcd, 0x82, 0x30, 0x82, 0x92,
+    0x82, 0xf4, 0x83, 0x57, 0x83, 0xba, 0x84, 0x1d,
+    0x84, 0x80, 0x84, 0xe3, 0x85, 0x47, 0x85, 0xab,
+    0x86, 0x0e, 0x86, 0x72, 0x86, 0xd7, 0x87, 0x3b,
+    0x87, 0x9f, 0x88, 0x04, 0x88, 0x69, 0x88, 0xce,
+    0x89, 0x33, 0x89, 0x99, 0x89, 0xfe, 0x8a, 0x64,
+    0x8a, 0xca, 0x8b, 0x30, 0x8b, 0x96, 0x8b, 0xfc,
+    0x8c, 0x63, 0x8c, 0xca, 0x8d, 0x31, 0x8d, 0x98,
+    0x8d, 0xff, 0x8e, 0x66, 0x8e, 0xce, 0x8f, 0x36,
+    0x8f, 0x9e, 0x90, 0x06, 0x90, 0x6e, 0x90, 0xd6,
+    0x91, 0x3f, 0x91, 0xa8, 0x92, 0x11, 0x92, 0x7a,
+    0x92, 0xe3, 0x93, 0x4d, 0x93, 0xb6, 0x94, 0x20,
+    0x94, 0x8a, 0x94, 0xf4, 0x95, 0x5f, 0x95, 0xc9,
+    0x96, 0x34, 0x96, 0x9f, 0x97, 0x0a, 0x97, 0x75,
+    0x97, 0xe0, 0x98, 0x4c, 0x98, 0xb8, 0x99, 0x24,
+    0x99, 0x90, 0x99, 0xfc, 0x9a, 0x68, 0x9a, 0xd5,
+    0x9b, 0x42, 0x9b, 0xaf, 0x9c, 0x1c, 0x9c, 0x89,
+    0x9c, 0xf7, 0x9d, 0x64, 0x9d, 0xd2, 0x9e, 0x40,
+    0x9e, 0xae, 0x9f, 0x1d, 0x9f, 0x8b, 0x9f, 0xfa,
+    0xa0, 0x69, 0xa0, 0xd8, 0xa1, 0x47, 0xa1, 0xb6,
+    0xa2, 0x26, 0xa2, 0x96, 0xa3, 0x06, 0xa3, 0x76,
+    0xa3, 0xe6, 0xa4, 0x56, 0xa4, 0xc7, 0xa5, 0x38,
+    0xa5, 0xa9, 0xa6, 0x1a, 0xa6, 0x8b, 0xa6, 0xfd,
+    0xa7, 0x6e, 0xa7, 0xe0, 0xa8, 0x52, 0xa8, 0xc4,
+    0xa9, 0x37, 0xa9, 0xa9, 0xaa, 0x1c, 0xaa, 0x8f,
+    0xab, 0x02, 0xab, 0x75, 0xab, 0xe9, 0xac, 0x5c,
+    0xac, 0xd0, 0xad, 0x44, 0xad, 0xb8, 0xae, 0x2d,
+    0xae, 0xa1, 0xaf, 0x16, 0xaf, 0x8b, 0xb0, 0x00,
+    0xb0, 0x75, 0xb0, 0xea, 0xb1, 0x60, 0xb1, 0xd6,
+    0xb2, 0x4b, 0xb2, 0xc2, 0xb3, 0x38, 0xb3, 0xae,
+    0xb4, 0x25, 0xb4, 0x9c, 0xb5, 0x13, 0xb5, 0x8a,
+    0xb6, 0x01, 0xb6, 0x79, 0xb6, 0xf0, 0xb7, 0x68,
+    0xb7, 0xe0, 0xb8, 0x59, 0xb8, 0xd1, 0xb9, 0x4a,
+    0xb9, 0xc2, 0xba, 0x3b, 0xba, 0xb5, 0xbb, 0x2e,
+    0xbb, 0xa7, 0xbc, 0x21, 0xbc, 0x9b, 0xbd, 0x15,
+    0xbd, 0x8f, 0xbe, 0x0a, 0xbe, 0x84, 0xbe, 0xff,
+    0xbf, 0x7a, 0xbf, 0xf5, 0xc0, 0x70, 0xc0, 0xec,
+    0xc1, 0x67, 0xc1, 0xe3, 0xc2, 0x5f, 0xc2, 0xdb,
+    0xc3, 0x58, 0xc3, 0xd4, 0xc4, 0x51, 0xc4, 0xce,
+    0xc5, 0x4b, 0xc5, 0xc8, 0xc6, 0x46, 0xc6, 0xc3,
+    0xc7, 0x41, 0xc7, 0xbf, 0xc8, 0x3d, 0xc8, 0xbc,
+    0xc9, 0x3a, 0xc9, 0xb9, 0xca, 0x38, 0xca, 0xb7,
+    0xcb, 0x36, 0xcb, 0xb6, 0xcc, 0x35, 0xcc, 0xb5,
+    0xcd, 0x35, 0xcd, 0xb5, 0xce, 0x36, 0xce, 0xb6,
+    0xcf, 0x37, 0xcf, 0xb8, 0xd0, 0x39, 0xd0, 0xba,
+    0xd1, 0x3c, 0xd1, 0xbe, 0xd2, 0x3f, 0xd2, 0xc1,
+    0xd3, 0x44, 0xd3, 0xc6, 0xd4, 0x49, 0xd4, 0xcb,
+    0xd5, 0x4e, 0xd5, 0xd1, 0xd6, 0x55, 0xd6, 0xd8,
+    0xd7, 0x5c, 0xd7, 0xe0, 0xd8, 0x64, 0xd8, 0xe8,
+    0xd9, 0x6c, 0xd9, 0xf1, 0xda, 0x76, 0xda, 0xfb,
+    0xdb, 0x80, 0xdc, 0x05, 0xdc, 0x8a, 0xdd, 0x10,
+    0xdd, 0x96, 0xde, 0x1c, 0xde, 0xa2, 0xdf, 0x29,
+    0xdf, 0xaf, 0xe0, 0x36, 0xe0, 0xbd, 0xe1, 0x44,
+    0xe1, 0xcc, 0xe2, 0x53, 0xe2, 0xdb, 0xe3, 0x63,
+    0xe3, 0xeb, 0xe4, 0x73, 0xe4, 0xfc, 0xe5, 0x84,
+    0xe6, 0x0d, 0xe6, 0x96, 0xe7, 0x1f, 0xe7, 0xa9,
+    0xe8, 0x32, 0xe8, 0xbc, 0xe9, 0x46, 0xe9, 0xd0,
+    0xea, 0x5b, 0xea, 0xe5, 0xeb, 0x70, 0xeb, 0xfb,
+    0xec, 0x86, 0xed, 0x11, 0xed, 0x9c, 0xee, 0x28,
+    0xee, 0xb4, 0xef, 0x40, 0xef, 0xcc, 0xf0, 0x58,
+    0xf0, 0xe5, 0xf1, 0x72, 0xf1, 0xff, 0xf2, 0x8c,
+    0xf3, 0x19, 0xf3, 0xa7, 0xf4, 0x34, 0xf4, 0xc2,
+    0xf5, 0x50, 0xf5, 0xde, 0xf6, 0x6d, 0xf6, 0xfb,
+    0xf7, 0x8a, 0xf8, 0x19, 0xf8, 0xa8, 0xf9, 0x38,
+    0xf9, 0xc7, 0xfa, 0x57, 0xfa, 0xe7, 0xfb, 0x77,
+    0xfc, 0x07, 0xfc, 0x98, 0xfd, 0x29, 0xfd, 0xba,
+    0xfe, 0x4b, 0xfe, 0xdc, 0xff, 0x6d, 0xff, 0xff
 };
 
 int jas_iccprofdata_srgblen = sizeof(jas_iccprofdata_srgb);
 
 uchar jas_iccprofdata_sgray[] = {
-	0x00, 0x00, 0x01, 0x8a, 0x00, 0x00, 0x00, 0x00,
-	0x02, 0x20, 0x00, 0x00, 0x73, 0x63, 0x6e, 0x72,
-	0x47, 0x52, 0x41, 0x59, 0x58, 0x59, 0x5a, 0x20,
-	0x07, 0xd3, 0x00, 0x01, 0x00, 0x1f, 0x00, 0x0d,
-	0x00, 0x35, 0x00, 0x21, 0x61, 0x63, 0x73, 0x70,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
-	0x4b, 0x4f, 0x44, 0x41, 0x73, 0x47, 0x72, 0x79,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf6, 0xd6,
-	0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0xd3, 0x2d,
-	0x4a, 0x50, 0x45, 0x47, 0x00, 0x00, 0x00, 0x00,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x00, 0x00, 0x00, 0x04, 0x64, 0x65, 0x73, 0x63,
-	0x00, 0x00, 0x00, 0xb4, 0x00, 0x00, 0x00, 0x86,
-	0x63, 0x70, 0x72, 0x74, 0x00, 0x00, 0x01, 0x3c,
-	0x00, 0x00, 0x00, 0x2b, 0x77, 0x74, 0x70, 0x74,
-	0x00, 0x00, 0x01, 0x68, 0x00, 0x00, 0x00, 0x14,
-	0x6b, 0x54, 0x52, 0x43, 0x00, 0x00, 0x01, 0x7c,
-	0x00, 0x00, 0x00, 0x0e, 0x64, 0x65, 0x73, 0x63,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x2c,
-	0x52, 0x65, 0x73, 0x74, 0x72, 0x69, 0x63, 0x74,
-	0x65, 0x64, 0x20, 0x49, 0x43, 0x43, 0x20, 0x70,
-	0x72, 0x6f, 0x66, 0x69, 0x6c, 0x65, 0x20, 0x64,
-	0x65, 0x73, 0x63, 0x72, 0x69, 0x62, 0x69, 0x6e,
-	0x67, 0x20, 0x73, 0x52, 0x47, 0x42, 0x2d, 0x67,
-	0x72, 0x65, 0x79, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x00, 0x00, 0x00, 0x00, 0x74, 0x65, 0x78, 0x74,
-	0x00, 0x00, 0x00, 0x00, 0x43, 0x6f, 0x70, 0x79,
-	0x72, 0x69, 0x67, 0x68, 0x74, 0x20, 0x32, 0x30,
-	0x30, 0x33, 0x20, 0x73, 0x52, 0x47, 0x42, 0x2d,
-	0x67, 0x72, 0x65, 0x79, 0x20, 0x52, 0x65, 0x66,
-	0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x00, 0x00,
-	0x58, 0x59, 0x5a, 0x20, 0x00, 0x00, 0x00, 0x00,
-	0x00, 0x00, 0xf3, 0x54, 0x00, 0x01, 0x00, 0x00,
-	0x00, 0x01, 0x16, 0xcf, 0x63, 0x75, 0x72, 0x76,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
-	0x01, 0xcd
+    0x00, 0x00, 0x01, 0x8a, 0x00, 0x00, 0x00, 0x00,
+    0x02, 0x20, 0x00, 0x00, 0x73, 0x63, 0x6e, 0x72,
+    0x47, 0x52, 0x41, 0x59, 0x58, 0x59, 0x5a, 0x20,
+    0x07, 0xd3, 0x00, 0x01, 0x00, 0x1f, 0x00, 0x0d,
+    0x00, 0x35, 0x00, 0x21, 0x61, 0x63, 0x73, 0x70,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
+    0x4b, 0x4f, 0x44, 0x41, 0x73, 0x47, 0x72, 0x79,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf6, 0xd6,
+    0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0xd3, 0x2d,
+    0x4a, 0x50, 0x45, 0x47, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x04, 0x64, 0x65, 0x73, 0x63,
+    0x00, 0x00, 0x00, 0xb4, 0x00, 0x00, 0x00, 0x86,
+    0x63, 0x70, 0x72, 0x74, 0x00, 0x00, 0x01, 0x3c,
+    0x00, 0x00, 0x00, 0x2b, 0x77, 0x74, 0x70, 0x74,
+    0x00, 0x00, 0x01, 0x68, 0x00, 0x00, 0x00, 0x14,
+    0x6b, 0x54, 0x52, 0x43, 0x00, 0x00, 0x01, 0x7c,
+    0x00, 0x00, 0x00, 0x0e, 0x64, 0x65, 0x73, 0x63,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x2c,
+    0x52, 0x65, 0x73, 0x74, 0x72, 0x69, 0x63, 0x74,
+    0x65, 0x64, 0x20, 0x49, 0x43, 0x43, 0x20, 0x70,
+    0x72, 0x6f, 0x66, 0x69, 0x6c, 0x65, 0x20, 0x64,
+    0x65, 0x73, 0x63, 0x72, 0x69, 0x62, 0x69, 0x6e,
+    0x67, 0x20, 0x73, 0x52, 0x47, 0x42, 0x2d, 0x67,
+    0x72, 0x65, 0x79, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x74, 0x65, 0x78, 0x74,
+    0x00, 0x00, 0x00, 0x00, 0x43, 0x6f, 0x70, 0x79,
+    0x72, 0x69, 0x67, 0x68, 0x74, 0x20, 0x32, 0x30,
+    0x30, 0x33, 0x20, 0x73, 0x52, 0x47, 0x42, 0x2d,
+    0x67, 0x72, 0x65, 0x79, 0x20, 0x52, 0x65, 0x66,
+    0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x00, 0x00,
+    0x58, 0x59, 0x5a, 0x20, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0xf3, 0x54, 0x00, 0x01, 0x00, 0x00,
+    0x00, 0x01, 0x16, 0xcf, 0x63, 0x75, 0x72, 0x76,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
+    0x01, 0xcd
 };
 
 int jas_iccprofdata_sgraylen = sizeof(jas_iccprofdata_sgray);

3rdparty/libjasper/jas_init.c

@@ -4,15 +4,15 @@
  */
 
 /* __START_OF_JASPER_LICENSE__
- * 
+ *
  * JasPer License Version 2.0
- * 
+ *
  * Copyright (c) 2001-2006 Michael David Adams
  * Copyright (c) 1999-2000 Image Power, Inc.
  * Copyright (c) 1999-2000 The University of British Columbia
- * 
+ *
  * All rights reserved.
- * 
+ *
  * Permission is hereby granted, free of charge, to any person (the
  * "User") obtaining a copy of this software and associated documentation
  * files (the "Software"), to deal in the Software without restriction,
@@ -20,15 +20,15 @@
  * publish, distribute, and/or sell copies of the Software, and to permit
  * persons to whom the Software is furnished to do so, subject to the
  * following conditions:
- * 
+ *
  * 1.  The above copyright notices and this permission notice (which
  * includes the disclaimer below) shall be included in all copies or
  * substantial portions of the Software.
- * 
+ *
  * 2.  The name of a copyright holder shall not be used to endorse or
  * promote products derived from the Software without specific prior
  * written permission.
- * 
+ *
  * THIS DISCLAIMER OF WARRANTY CONSTITUTES AN ESSENTIAL PART OF THIS
  * LICENSE.  NO USE OF THE SOFTWARE IS AUTHORIZED HEREUNDER EXCEPT UNDER
  * THIS DISCLAIMER.  THE SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS
@@ -55,7 +55,7 @@
  * PERSONAL INJURY, OR SEVERE PHYSICAL OR ENVIRONMENTAL DAMAGE ("HIGH
  * RISK ACTIVITIES").  THE COPYRIGHT HOLDERS SPECIFICALLY DISCLAIM ANY
  * EXPRESS OR IMPLIED WARRANTY OF FITNESS FOR HIGH RISK ACTIVITIES.
- * 
+ *
  * __END_OF_JASPER_LICENSE__
  */
 
@@ -74,89 +74,89 @@
 /* Initialize the image format table. */
 int jas_init()
 {
-	jas_image_fmtops_t fmtops;
-	int fmtid;
+    jas_image_fmtops_t fmtops;
+    int fmtid;
 
-	fmtid = 0;
+    fmtid = 0;
 
 #if !defined(EXCLUDE_MIF_SUPPORT)
-	fmtops.decode = mif_decode;
-	fmtops.encode = mif_encode;
-	fmtops.validate = mif_validate;
-	jas_image_addfmt(fmtid, "mif", "mif", "My Image Format (MIF)", &fmtops);
-	++fmtid;
+    fmtops.decode = mif_decode;
+    fmtops.encode = mif_encode;
+    fmtops.validate = mif_validate;
+    jas_image_addfmt(fmtid, "mif", "mif", "My Image Format (MIF)", &fmtops);
+    ++fmtid;
 #endif
 
 #if !defined(EXCLUDE_PNM_SUPPORT)
-	fmtops.decode = pnm_decode;
-	fmtops.encode = pnm_encode;
-	fmtops.validate = pnm_validate;
-	jas_image_addfmt(fmtid, "pnm", "pnm", "Portable Graymap/Pixmap (PNM)",
-	  &fmtops);
-	jas_image_addfmt(fmtid, "pnm", "pgm", "Portable Graymap/Pixmap (PNM)",
-	  &fmtops);
-	jas_image_addfmt(fmtid, "pnm", "ppm", "Portable Graymap/Pixmap (PNM)",
-	  &fmtops);
-	++fmtid;
+    fmtops.decode = pnm_decode;
+    fmtops.encode = pnm_encode;
+    fmtops.validate = pnm_validate;
+    jas_image_addfmt(fmtid, "pnm", "pnm", "Portable Graymap/Pixmap (PNM)",
+      &fmtops);
+    jas_image_addfmt(fmtid, "pnm", "pgm", "Portable Graymap/Pixmap (PNM)",
+      &fmtops);
+    jas_image_addfmt(fmtid, "pnm", "ppm", "Portable Graymap/Pixmap (PNM)",
+      &fmtops);
+    ++fmtid;
 #endif
 
 #if !defined(EXCLUDE_BMP_SUPPORT)
-	fmtops.decode = bmp_decode;
-	fmtops.encode = bmp_encode;
-	fmtops.validate = bmp_validate;
-	jas_image_addfmt(fmtid, "bmp", "bmp", "Microsoft Bitmap (BMP)", &fmtops);
-	++fmtid;
+    fmtops.decode = bmp_decode;
+    fmtops.encode = bmp_encode;
+    fmtops.validate = bmp_validate;
+    jas_image_addfmt(fmtid, "bmp", "bmp", "Microsoft Bitmap (BMP)", &fmtops);
+    ++fmtid;
 #endif
 
 #if !defined(EXCLUDE_RAS_SUPPORT)
-	fmtops.decode = ras_decode;
-	fmtops.encode = ras_encode;
-	fmtops.validate = ras_validate;
-	jas_image_addfmt(fmtid, "ras", "ras", "Sun Rasterfile (RAS)", &fmtops);
-	++fmtid;
+    fmtops.decode = ras_decode;
+    fmtops.encode = ras_encode;
+    fmtops.validate = ras_validate;
+    jas_image_addfmt(fmtid, "ras", "ras", "Sun Rasterfile (RAS)", &fmtops);
+    ++fmtid;
 #endif
 
 #if !defined(EXCLUDE_JP2_SUPPORT)
-	fmtops.decode = jp2_decode;
-	fmtops.encode = jp2_encode;
-	fmtops.validate = jp2_validate;
-	jas_image_addfmt(fmtid, "jp2", "jp2",
-	  "JPEG-2000 JP2 File Format Syntax (ISO/IEC 15444-1)", &fmtops);
-	++fmtid;
-	fmtops.decode = jpc_decode;
-	fmtops.encode = jpc_encode;
-	fmtops.validate = jpc_validate;
-	jas_image_addfmt(fmtid, "jpc", "jpc",
-	  "JPEG-2000 Code Stream Syntax (ISO/IEC 15444-1)", &fmtops);
-	++fmtid;
+    fmtops.decode = jp2_decode;
+    fmtops.encode = jp2_encode;
+    fmtops.validate = jp2_validate;
+    jas_image_addfmt(fmtid, "jp2", "jp2",
+      "JPEG-2000 JP2 File Format Syntax (ISO/IEC 15444-1)", &fmtops);
+    ++fmtid;
+    fmtops.decode = jpc_decode;
+    fmtops.encode = jpc_encode;
+    fmtops.validate = jpc_validate;
+    jas_image_addfmt(fmtid, "jpc", "jpc",
+      "JPEG-2000 Code Stream Syntax (ISO/IEC 15444-1)", &fmtops);
+    ++fmtid;
 #endif
 
 #if !defined(EXCLUDE_JPG_SUPPORT)
-	fmtops.decode = jpg_decode;
-	fmtops.encode = jpg_encode;
-	fmtops.validate = jpg_validate;
-	jas_image_addfmt(fmtid, "jpg", "jpg", "JPEG (ISO/IEC 10918-1)", &fmtops);
-	++fmtid;
+    fmtops.decode = jpg_decode;
+    fmtops.encode = jpg_encode;
+    fmtops.validate = jpg_validate;
+    jas_image_addfmt(fmtid, "jpg", "jpg", "JPEG (ISO/IEC 10918-1)", &fmtops);
+    ++fmtid;
 #endif
 
 #if !defined(EXCLUDE_PGX_SUPPORT)
-	fmtops.decode = pgx_decode;
-	fmtops.encode = pgx_encode;
-	fmtops.validate = pgx_validate;
-	jas_image_addfmt(fmtid, "pgx", "pgx", "JPEG-2000 VM Format (PGX)", &fmtops);
-	++fmtid;
+    fmtops.decode = pgx_decode;
+    fmtops.encode = pgx_encode;
+    fmtops.validate = pgx_validate;
+    jas_image_addfmt(fmtid, "pgx", "pgx", "JPEG-2000 VM Format (PGX)", &fmtops);
+    ++fmtid;
 #endif
 
-	/* We must not register the JasPer library exit handler until after
-	at least one memory allocation is performed.  This is desirable
-	as it ensures that the JasPer exit handler is called before the
-	debug memory allocator exit handler. */
-	atexit(jas_cleanup);
+    /* We must not register the JasPer library exit handler until after
+    at least one memory allocation is performed.  This is desirable
+    as it ensures that the JasPer exit handler is called before the
+    debug memory allocator exit handler. */
+    atexit(jas_cleanup);
 
-	return 0;
+    return 0;
 }
 
 void jas_cleanup()
 {
-	jas_image_clearfmts();
+    jas_image_clearfmts();
 }