Normalize line endings and whitespace

.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

3rdparty/ffmpeg/ffmpeg_version.cmake

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

3rdparty/include/dshow/audevcod.h

@@ -9,20 +9,20 @@ extern "C" {
 #endif
 
 typedef enum _tagSND_DEVICE_ERROR {
-	SNDDEV_ERROR_Open = 1,       
+    SNDDEV_ERROR_Open = 1,
-	SNDDEV_ERROR_Close = 2,       
+    SNDDEV_ERROR_Close = 2,
-	SNDDEV_ERROR_GetCaps = 3,       
+    SNDDEV_ERROR_GetCaps = 3,
-	SNDDEV_ERROR_PrepareHeader = 4,
+    SNDDEV_ERROR_PrepareHeader = 4,
-	SNDDEV_ERROR_UnprepareHeader = 5,       
+    SNDDEV_ERROR_UnprepareHeader = 5,
-	SNDDEV_ERROR_Reset = 6,
+    SNDDEV_ERROR_Reset = 6,
-	SNDDEV_ERROR_Restart = 7,       
+    SNDDEV_ERROR_Restart = 7,
-	SNDDEV_ERROR_GetPosition = 8,       
+    SNDDEV_ERROR_GetPosition = 8,
-	SNDDEV_ERROR_Write = 9,
+    SNDDEV_ERROR_Write = 9,
-	SNDDEV_ERROR_Pause = 10,       
+    SNDDEV_ERROR_Pause = 10,
-	SNDDEV_ERROR_Stop = 11,       
+    SNDDEV_ERROR_Stop = 11,
-	SNDDEV_ERROR_Start = 12,       
+    SNDDEV_ERROR_Start = 12,
-	SNDDEV_ERROR_AddBuffer = 13,
+    SNDDEV_ERROR_AddBuffer = 13,
-	SNDDEV_ERROR_Query = 14
+    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_TRANSPORT_PACKET,
-	MEDIA_ELEMENTARY_STREAM,
+    MEDIA_ELEMENTARY_STREAM,
-	MEDIA_MPEG2_PSI,
+    MEDIA_MPEG2_PSI,
-	MEDIA_TRANSPORT_PAYLOAD
+    MEDIA_TRANSPORT_PAYLOAD
 } MEDIA_SAMPLE_CONTENT;
 /*--- DirectShow Reference - DirectShow Structures */
 typedef struct {
-	DWORD dwOffset;
+    DWORD dwOffset;
-	DWORD dwPacketLength;
+    DWORD dwPacketLength;
-	DWORD dwStride;
+    DWORD dwStride;
 } MPEG2_TRANSPORT_STRIDE;
 typedef struct {
-	ULONG ulPID;
+    ULONG ulPID;
-	MEDIA_SAMPLE_CONTENT MediaSampleContent ;
+    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	dwCaps;	/* capabilities of surface wanted */
-	DWORD   dwCaps2; /* additional capabilities */
+    DWORD   dwCaps2; /* additional capabilities */
-	DWORD   dwCaps3; /* reserved capabilities */
+    DWORD   dwCaps3; /* reserved capabilities */
-	__extension__ union {
+    __extension__ union {
-	  DWORD dwCaps4; /* low word is the depth for a volume texture */
+      DWORD dwCaps4; /* low word is the depth for a volume texture */
-	  DWORD dwVolumeDepth;
+      DWORD dwVolumeDepth;
-	} DUMMYUNIONNAME1;
+    } DUMMYUNIONNAME1;
 } DDSCAPS2,*LPDDSCAPS2;
 
 typedef struct _DDSCAPSEX {
     DWORD	dwCaps2;
     DWORD	dwCaps3;
     __extension__ union {
-	DWORD	dwCaps4;
+    DWORD	dwCaps4;
-	DWORD	dwVolumeDepth;
+    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	dwRGBBitCount;          /* C: how many bits per pixel */
-	DWORD	dwYUVBitCount;          /* C: how many bits per pixel */
+    DWORD	dwYUVBitCount;          /* C: how many bits per pixel */
-	DWORD	dwZBufferBitDepth;      /* C: how many bits for z buffers */
+    DWORD	dwZBufferBitDepth;      /* C: how many bits for z buffers */
-	DWORD	dwAlphaBitDepth;        /* C: how many bits for alpha channels*/
+    DWORD	dwAlphaBitDepth;        /* C: how many bits for alpha channels*/
-	DWORD	dwLuminanceBitCount;
+    DWORD	dwLuminanceBitCount;
-	DWORD	dwBumpBitCount;
+    DWORD	dwBumpBitCount;
     } DUMMYUNIONNAME1;
     __extension__ union {
-	DWORD	dwRBitMask;             /* 10: mask for red bit*/
+    DWORD	dwRBitMask;             /* 10: mask for red bit*/
-	DWORD	dwYBitMask;             /* 10: mask for Y bits*/
+    DWORD	dwYBitMask;             /* 10: mask for Y bits*/
-	DWORD	dwStencilBitDepth;
+    DWORD	dwStencilBitDepth;
-	DWORD	dwLuminanceBitMask;
+    DWORD	dwLuminanceBitMask;
-	DWORD	dwBumpDuBitMask;
+    DWORD	dwBumpDuBitMask;
     } DUMMYUNIONNAME2;
     __extension__ union {
-	DWORD	dwGBitMask;             /* 14: mask for green bits*/
+    DWORD	dwGBitMask;             /* 14: mask for green bits*/
-	DWORD	dwUBitMask;             /* 14: mask for U bits*/
+    DWORD	dwUBitMask;             /* 14: mask for U bits*/
-	DWORD	dwZBitMask;
+    DWORD	dwZBitMask;
-	DWORD	dwBumpDvBitMask;
+    DWORD	dwBumpDvBitMask;
     } DUMMYUNIONNAME3;
     __extension__ union {
-	DWORD   dwBBitMask;             /* 18: mask for blue bits*/
+    DWORD   dwBBitMask;             /* 18: mask for blue bits*/
-	DWORD   dwVBitMask;             /* 18: mask for V bits*/
+    DWORD   dwVBitMask;             /* 18: mask for V bits*/
-	DWORD	dwStencilBitMask;
+    DWORD	dwStencilBitMask;
-	DWORD	dwBumpLuminanceBitMask;
+    DWORD	dwBumpLuminanceBitMask;
     } DUMMYUNIONNAME4;
     __extension__ union {
-    	DWORD	dwRGBAlphaBitMask;	/* 1C: mask for alpha channel */
+        DWORD	dwRGBAlphaBitMask;	/* 1C: mask for alpha channel */
-    	DWORD	dwYUVAlphaBitMask;	/* 1C: mask for alpha channel */
+        DWORD	dwYUVAlphaBitMask;	/* 1C: mask for alpha channel */
-	DWORD	dwLuminanceAlphaBitMask;
+    DWORD	dwLuminanceAlphaBitMask;
-	DWORD	dwRGBZBitMask;		/* 1C: mask for Z channel */
+    DWORD	dwRGBZBitMask;		/* 1C: mask for Z channel */
-	DWORD	dwYUVZBitMask;		/* 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	dwSize;		/* 0: size of the DDSURFACEDESC structure*/
-	DWORD	dwFlags;	/* 4: determines what fields are valid*/
+    DWORD	dwFlags;	/* 4: determines what fields are valid*/
-	DWORD	dwHeight;	/* 8: height of surface to be created*/
+    DWORD	dwHeight;	/* 8: height of surface to be created*/
-	DWORD	dwWidth;	/* C: width of input surface*/
+    DWORD	dwWidth;	/* C: width of input surface*/
-	__extension__ union {
+    __extension__ union {
-		LONG	lPitch;	/* 10: distance to start of next line (return value only)*/
+        LONG	lPitch;	/* 10: distance to start of next line (return value only)*/
-		DWORD	dwLinearSize;
+        DWORD	dwLinearSize;
-	} DUMMYUNIONNAME1;
+    } DUMMYUNIONNAME1;
-	DWORD	dwBackBufferCount;/* 14: number of back buffers requested*/
+    DWORD	dwBackBufferCount;/* 14: number of back buffers requested*/
-	__extension__ union {
+    __extension__ union {
-		DWORD	dwMipMapCount;/* 18:number of mip-map levels requested*/
+        DWORD	dwMipMapCount;/* 18:number of mip-map levels requested*/
-		DWORD	dwZBufferBitDepth;/*18: depth of Z buffer requested*/
+        DWORD	dwZBufferBitDepth;/*18: depth of Z buffer requested*/
-		DWORD	dwRefreshRate;/* 18:refresh rate (used when display mode is described)*/
+        DWORD	dwRefreshRate;/* 18:refresh rate (used when display mode is described)*/
-	} DUMMYUNIONNAME2;
+    } DUMMYUNIONNAME2;
-	DWORD	dwAlphaBitDepth;/* 1C:depth of alpha buffer requested*/
+    DWORD	dwAlphaBitDepth;/* 1C:depth of alpha buffer requested*/
-	DWORD	dwReserved;	/* 20:reserved*/
+    DWORD	dwReserved;	/* 20:reserved*/
-	LPVOID	lpSurface;	/* 24:pointer to the associated surface memory*/
+    LPVOID	lpSurface;	/* 24:pointer to the associated surface memory*/
-	DDCOLORKEY	ddckCKDestOverlay;/* 28: CK for dest overlay use*/
+    DDCOLORKEY	ddckCKDestOverlay;/* 28: CK for dest overlay use*/
-	DDCOLORKEY	ddckCKDestBlt;	/* 30: CK for destination blt use*/
+    DDCOLORKEY	ddckCKDestBlt;	/* 30: CK for destination blt use*/
-	DDCOLORKEY	ddckCKSrcOverlay;/* 38: CK for source overlay use*/
+    DDCOLORKEY	ddckCKSrcOverlay;/* 38: CK for source overlay use*/
-	DDCOLORKEY	ddckCKSrcBlt;	/* 40: CK for source blt use*/
+    DDCOLORKEY	ddckCKSrcBlt;	/* 40: CK for source blt use*/
-	DDPIXELFORMAT	ddpfPixelFormat;/* 48: pixel format description of the surface*/
+    DDPIXELFORMAT	ddpfPixelFormat;/* 48: pixel format description of the surface*/
-	DDSCAPS		ddsCaps;	/* 68: direct draw surface caps */
+    DDSCAPS		ddsCaps;	/* 68: direct draw surface caps */
 } DDSURFACEDESC,*LPDDSURFACEDESC;
 
 typedef struct _DDSURFACEDESC2
 {
-	DWORD	dwSize;		/* 0: size of the DDSURFACEDESC2 structure*/
+    DWORD	dwSize;		/* 0: size of the DDSURFACEDESC2 structure*/
-	DWORD	dwFlags;	/* 4: determines what fields are valid*/
+    DWORD	dwFlags;	/* 4: determines what fields are valid*/
-	DWORD	dwHeight;	/* 8: height of surface to be created*/
+    DWORD	dwHeight;	/* 8: height of surface to be created*/
-	DWORD	dwWidth;	/* C: width of input surface*/
+    DWORD	dwWidth;	/* C: width of input surface*/
-	__extension__ union {
+    __extension__ union {
-		LONG	lPitch;	      /*10: distance to start of next line (return value only)*/
+        LONG	lPitch;	      /*10: distance to start of next line (return value only)*/
-		DWORD   dwLinearSize; /*10: formless late-allocated optimized surface size */
+        DWORD   dwLinearSize; /*10: formless late-allocated optimized surface size */
-	} DUMMYUNIONNAME1;
+    } DUMMYUNIONNAME1;
-	DWORD	dwBackBufferCount;/* 14: number of back buffers requested*/
+    DWORD	dwBackBufferCount;/* 14: number of back buffers requested*/
-	__extension__ union {
+    __extension__ union {
-		DWORD	dwMipMapCount;/* 18:number of mip-map levels requested*/
+        DWORD	dwMipMapCount;/* 18:number of mip-map levels requested*/
-		DWORD	dwRefreshRate;/* 18:refresh rate (used when display mode is described)*/
+        DWORD	dwRefreshRate;/* 18:refresh rate (used when display mode is described)*/
-		DWORD   dwSrcVBHandle;/* 18:source used in VB::Optimize */
+        DWORD   dwSrcVBHandle;/* 18:source used in VB::Optimize */
-	} DUMMYUNIONNAME2;
+    } DUMMYUNIONNAME2;
-	DWORD	dwAlphaBitDepth;/* 1C:depth of alpha buffer requested*/
+    DWORD	dwAlphaBitDepth;/* 1C:depth of alpha buffer requested*/
-	DWORD	dwReserved;	/* 20:reserved*/
+    DWORD	dwReserved;	/* 20:reserved*/
-	LPVOID	lpSurface;	/* 24:pointer to the associated surface memory*/
+    LPVOID	lpSurface;	/* 24:pointer to the associated surface memory*/
-	__extension__ union {
+    __extension__ union {
-		DDCOLORKEY	ddckCKDestOverlay; /* 28: CK for dest overlay use*/
+        DDCOLORKEY	ddckCKDestOverlay; /* 28: CK for dest overlay use*/
-		DWORD 		dwEmptyFaceColor;  /* 28: color for empty cubemap faces */
+        DWORD 		dwEmptyFaceColor;  /* 28: color for empty cubemap faces */
-	} DUMMYUNIONNAME3;
+    } DUMMYUNIONNAME3;
-	DDCOLORKEY	ddckCKDestBlt;	/* 30: CK for destination blt use*/
+    DDCOLORKEY	ddckCKDestBlt;	/* 30: CK for destination blt use*/
-	DDCOLORKEY	ddckCKSrcOverlay;/* 38: CK for source overlay use*/
+    DDCOLORKEY	ddckCKSrcOverlay;/* 38: CK for source overlay use*/
-	DDCOLORKEY	ddckCKSrcBlt;	/* 40: CK for source blt use*/
+    DDCOLORKEY	ddckCKSrcBlt;	/* 40: CK for source blt use*/
 
-	__extension__ union {
+    __extension__ union {
-		DDPIXELFORMAT	ddpfPixelFormat;/* 48: pixel format description of the surface*/
+        DDPIXELFORMAT	ddpfPixelFormat;/* 48: pixel format description of the surface*/
-		DWORD 		dwFVF;	/* 48: vertex format description of vertex buffers */
+        DWORD 		dwFVF;	/* 48: vertex format description of vertex buffers */
-	} DUMMYUNIONNAME4;
+    } DUMMYUNIONNAME4;
-	DDSCAPS2	ddsCaps;  /* 68: DDraw surface caps */
+    DDSCAPS2	ddsCaps;  /* 68: DDraw surface caps */
-	DWORD		dwTextureStage; /* 78: stage in multitexture cascade */
+    DWORD		dwTextureStage; /* 78: stage in multitexture cascade */
 } DDSURFACEDESC2,*LPDDSURFACEDESC2;
 
 
 typedef struct _DDARGB {
-	BYTE	blue;
+    BYTE	blue;
-	BYTE	green;
+    BYTE	green;
-	BYTE	red;
+    BYTE	red;
-	BYTE	alpha;
+    BYTE	alpha;
 } DDARGB, *LPDDARGB;
 
 typedef struct _DDRGBA {
-	BYTE	red;
+    BYTE	red;
-	BYTE	green;
+    BYTE	green;
-	BYTE	blue;
+    BYTE	blue;
-	BYTE	alpha;
+    BYTE	alpha;
 } DDRGBA, *LPDDRGBA;
 
 
@@ -1066,22 +1066,22 @@ typedef struct _DDRGBA {
 #define DDCOLOR_COLORENABLE	0x00000040
 
 typedef struct {
-	DWORD	dwSize;
+    DWORD	dwSize;
-	DWORD	dwFlags;
+    DWORD	dwFlags;
-	LONG	lBrightness;
+    LONG	lBrightness;
-	LONG	lContrast;
+    LONG	lContrast;
-	LONG	lHue;
+    LONG	lHue;
-	LONG	lSaturation;
+    LONG	lSaturation;
-	LONG	lSharpness;
+    LONG	lSharpness;
-	LONG	lGamma;
+    LONG	lGamma;
-	LONG	lColorEnable;
+    LONG	lColorEnable;
-	DWORD	dwReserved1;
+    DWORD	dwReserved1;
 } DDCOLORCONTROL,*LPDDCOLORCONTROL;
 
 typedef struct {
-	WORD	red[256];
+    WORD	red[256];
-	WORD	green[256];
+    WORD	green[256];
-	WORD	blue[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;
+    DWORD				dwSize;
-	D3DVECTOR			vPosition;
+    D3DVECTOR			vPosition;
-	D3DVECTOR			vVelocity;
+    D3DVECTOR			vVelocity;
-	D3DVECTOR			vOrientFront;
+    D3DVECTOR			vOrientFront;
-	D3DVECTOR			vOrientTop;
+    D3DVECTOR			vOrientTop;
-	D3DVALUE			flDistanceFactor;
+    D3DVALUE			flDistanceFactor;
-	D3DVALUE			flRolloffFactor;
+    D3DVALUE			flRolloffFactor;
-	D3DVALUE			flDopplerFactor;
+    D3DVALUE			flDopplerFactor;
 } DS3DLISTENER, *LPDS3DLISTENER;
 
 typedef const DS3DLISTENER *LPCDS3DLISTENER;
@@ -1019,16 +1019,16 @@ DECLARE_INTERFACE_(IDirectSound3DListener,IUnknown)
  * IDirectSound3DBuffer interface
  */
 typedef struct  _DS3DBUFFER {
-	DWORD				dwSize;
+    DWORD				dwSize;
-	D3DVECTOR			vPosition;
+    D3DVECTOR			vPosition;
-	D3DVECTOR			vVelocity;
+    D3DVECTOR			vVelocity;
-	DWORD				dwInsideConeAngle;
+    DWORD				dwInsideConeAngle;
-	DWORD				dwOutsideConeAngle;
+    DWORD				dwOutsideConeAngle;
-	D3DVECTOR			vConeOrientation;
+    D3DVECTOR			vConeOrientation;
-	LONG				lConeOutsideVolume;
+    LONG				lConeOutsideVolume;
-	D3DVALUE			flMinDistance;
+    D3DVALUE			flMinDistance;
-	D3DVALUE			flMaxDistance;
+    D3DVALUE			flMaxDistance;
-	DWORD				dwMode;
+    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_Low = 1,
-	AM_MPEG2Level_Main,
+    AM_MPEG2Level_Main,
-	AM_MPEG2Level_High1440,
+    AM_MPEG2Level_High1440,
-	AM_MPEG2Level_High
+    AM_MPEG2Level_High
 };
 enum AM_MPEG2Profile {
-	AM_MPEG2Profile_Simple = 1,
+    AM_MPEG2Profile_Simple = 1,
-	AM_MPEG2Profile_Main,
+    AM_MPEG2Profile_Main,
-	AM_MPEG2Profile_SNRScalable,
+    AM_MPEG2Profile_SNRScalable,
-	AM_MPEG2Profile_SpatiallyScalable,
+    AM_MPEG2Profile_SpatiallyScalable,
-	AM_MPEG2Profile_High
+    AM_MPEG2Profile_High
 };
 typedef enum {
-	AM_RATE_ChangeRate = 1,
+    AM_RATE_ChangeRate = 1,
-	AM_RATE_FullDataRateMax = 2,
+    AM_RATE_FullDataRateMax = 2,
-	AM_RATE_ReverseDecode = 3,
+    AM_RATE_ReverseDecode = 3,
-	AM_RATE_DecoderPosition = 4,
+    AM_RATE_DecoderPosition = 4,
-	AM_RATE_DecoderVersion = 5
+    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;
+    HRESULT hrStatus;
-	void   *pData;
+    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;
+    ULONG cPins;
-	const REGFILTERPINS *rgPins;
+    const REGFILTERPINS *rgPins;
       };
       struct {
-	ULONG cPins2;
+    ULONG cPins2;
-	const REGFILTERPINS2 *rgPins2;
+    const REGFILTERPINS2 *rgPins2;
       };
     };
   } REGFILTER2;

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/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. */
+    /* Save the old debug level. */
-	olddbglevel = jas_dbglevel;
+    olddbglevel = jas_dbglevel;
 
-	/* Change the debug level. */
+    /* Change the debug level. */
-	jas_dbglevel = dbglevel;
+    jas_dbglevel = dbglevel;
 
-	/* Return the old debug level. */
+    /* Return the old debug level. */
-	return olddbglevel;
+    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;
+    int ret;
-	va_list ap;
+    va_list ap;
 
-	va_start(ap, fmt);
+    va_start(ap, fmt);
-	ret = vfprintf(stderr, fmt, ap);
+    ret = vfprintf(stderr, fmt, ap);
-	va_end(ap);
+    va_end(ap);
-	return ret;
+    return ret;
 }
 
 /* Dump memory to a stream. */
 int jas_memdump(FILE *out, void *data, size_t len)
 {
-	size_t i;
+    size_t i;
-	size_t j;
+    size_t j;
-	uchar *dp;
+    uchar *dp;
-	dp = data;
+    dp = data;
-	for (i = 0; i < len; i += 16) {
+    for (i = 0; i < len; i += 16) {
-		fprintf(out, "%04x:", (int)i);
+        fprintf(out, "%04x:", (int)i);
-		for (j = 0; j < 16; ++j) {
+        for (j = 0; j < 16; ++j) {
-			if (i + j < len) {
+            if (i + j < len) {
-				fprintf(out, " %02x", dp[i + j]);
+                fprintf(out, " %02x", dp[i + j]);
-			}
+            }
-		}
+        }
-		fprintf(out, "\n");
+        fprintf(out, "\n");
-	}
+    }
-	return 0;
+    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) {
+    for (opt = opts; opt->id >= 0 && opt->name; ++opt) {
-		if (!strcmp(opt->name, name)) {
+        if (!strcmp(opt->name, name)) {
-			return opt;
+            return opt;
-		}
+        }
-	}
+    }
-	return 0;
+    return 0;
 }
 
 int jas_getopt(int argc, char **argv, jas_opt_t *opts)
 {
-	char *cp;
+    char *cp;
-	int id;
+    int id;
-	int hasarg;
+    int hasarg;
-	jas_opt_t *opt;
+    jas_opt_t *opt;
-	char *s;
+    char *s;
 
-	if (!jas_optind) {
+    if (!jas_optind) {
-		jas_optind = JAS_MIN(1, argc);
+        jas_optind = JAS_MIN(1, argc);
-	}
+    }
-	while (jas_optind < argc) {
+    while (jas_optind < argc) {
-		s = cp = argv[jas_optind];
+        s = cp = argv[jas_optind];
-		if (*cp == '-') {
+        if (*cp == '-') {
-			/* We are processing an option. */
+            /* We are processing an option. */
-			++jas_optind;
+            ++jas_optind;
-			if (*++cp == '-') {
+            if (*++cp == '-') {
-				/* We are processing a long option. */
+                /* We are processing a long option. */
-				++cp;
+                ++cp;
-				if (*cp == '\0') {
+                if (*cp == '\0') {
-					/* This is the end of the options. */
+                    /* This is the end of the options. */
-					return JAS_GETOPT_EOF;
+                    return JAS_GETOPT_EOF;
-				}
+                }
-				if (!(opt = jas_optlookup(opts, cp))) {
+                if (!(opt = jas_optlookup(opts, cp))) {
-					if (jas_opterr) {
+                    if (jas_opterr) {
-						jas_eprintf("unknown long option %s\n", s);
+                        jas_eprintf("unknown long option %s\n", s);
-					}
+                    }
-					return JAS_GETOPT_ERR;
+                    return JAS_GETOPT_ERR;
-				}
+                }
-				hasarg = (opt->flags & JAS_OPT_HASARG) != 0;
+                hasarg = (opt->flags & JAS_OPT_HASARG) != 0;
-				id = opt->id;
+                id = opt->id;
-			} else {
+            } else {
-				/* We are processing a short option. */
+                /* We are processing a short option. */
-				if (strlen(cp) != 1 ||
+                if (strlen(cp) != 1 ||
-				  !(opt = jas_optlookup(opts, cp))) {
+                  !(opt = jas_optlookup(opts, cp))) {
-					if (jas_opterr) {
+                    if (jas_opterr) {
-						jas_eprintf("unknown short option %s\n", s);
+                        jas_eprintf("unknown short option %s\n", s);
-					}
+                    }
-					return JAS_GETOPT_ERR;
+                    return JAS_GETOPT_ERR;
-				}
+                }
-				hasarg = (opt->flags & JAS_OPT_HASARG) != 0;
+                hasarg = (opt->flags & JAS_OPT_HASARG) != 0;
-				id = opt->id;
+                id = opt->id;
-			}
+            }
-			if (hasarg) {
+            if (hasarg) {
-				/* The option has an argument. */
+                /* The option has an argument. */
-				if (jas_optind >= argc) {
+                if (jas_optind >= argc) {
-					if (jas_opterr) {
+                    if (jas_opterr) {
-						jas_eprintf("missing argument for option %s\n", s);
+                        jas_eprintf("missing argument for option %s\n", s);
-					}
+                    }
-					return JAS_GETOPT_ERR;
+                    return JAS_GETOPT_ERR;
-				}
+                }
-				jas_optarg = argv[jas_optind];
+                jas_optarg = argv[jas_optind];
-				++jas_optind;
+                ++jas_optind;
-			} else {
+            } else {
-				/* The option does not have an argument. */
+                /* The option does not have an argument. */
-				jas_optarg = 0;
+                jas_optarg = 0;
-			}
+            }
-			return id;
+            return id;
-		} else {
+        } else {
-			/* We are not processing an option. */
+            /* We are not processing an option. */
-			return JAS_GETOPT_EOF;
+            return JAS_GETOPT_EOF;
-		}
+        }
-	}
+    }
-	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,
+    0x00, 0x00, 0x0c, 0x48, 0x4c, 0x69, 0x6e, 0x6f,
-	0x02, 0x10, 0x00, 0x00, 0x6d, 0x6e, 0x74, 0x72,
+    0x02, 0x10, 0x00, 0x00, 0x6d, 0x6e, 0x74, 0x72,
-	0x52, 0x47, 0x42, 0x20, 0x58, 0x59, 0x5a, 0x20,
+    0x52, 0x47, 0x42, 0x20, 0x58, 0x59, 0x5a, 0x20,
-	0x07, 0xce, 0x00, 0x02, 0x00, 0x09, 0x00, 0x06,
+    0x07, 0xce, 0x00, 0x02, 0x00, 0x09, 0x00, 0x06,
-	0x00, 0x31, 0x00, 0x00, 0x61, 0x63, 0x73, 0x70,
+    0x00, 0x31, 0x00, 0x00, 0x61, 0x63, 0x73, 0x70,
-	0x4d, 0x53, 0x46, 0x54, 0x00, 0x00, 0x00, 0x00,
+    0x4d, 0x53, 0x46, 0x54, 0x00, 0x00, 0x00, 0x00,
-	0x49, 0x45, 0x43, 0x20, 0x73, 0x52, 0x47, 0x42,
+    0x49, 0x45, 0x43, 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, 0xf6, 0xd6,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf6, 0xd6,
-	0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0xd3, 0x2d,
+    0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0xd3, 0x2d,
-	0x48, 0x50, 0x20, 0x20, 0x00, 0x00, 0x00, 0x00,
+    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, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 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, 0x00, 0x11, 0x63, 0x70, 0x72, 0x74,
-	0x00, 0x00, 0x01, 0x50, 0x00, 0x00, 0x00, 0x33,
+    0x00, 0x00, 0x01, 0x50, 0x00, 0x00, 0x00, 0x33,
-	0x64, 0x65, 0x73, 0x63, 0x00, 0x00, 0x01, 0x84,
+    0x64, 0x65, 0x73, 0x63, 0x00, 0x00, 0x01, 0x84,
-	0x00, 0x00, 0x00, 0x6c, 0x77, 0x74, 0x70, 0x74,
+    0x00, 0x00, 0x00, 0x6c, 0x77, 0x74, 0x70, 0x74,
-	0x00, 0x00, 0x01, 0xf0, 0x00, 0x00, 0x00, 0x14,
+    0x00, 0x00, 0x01, 0xf0, 0x00, 0x00, 0x00, 0x14,
-	0x62, 0x6b, 0x70, 0x74, 0x00, 0x00, 0x02, 0x04,
+    0x62, 0x6b, 0x70, 0x74, 0x00, 0x00, 0x02, 0x04,
-	0x00, 0x00, 0x00, 0x14, 0x72, 0x58, 0x59, 0x5a,
+    0x00, 0x00, 0x00, 0x14, 0x72, 0x58, 0x59, 0x5a,
-	0x00, 0x00, 0x02, 0x18, 0x00, 0x00, 0x00, 0x14,
+    0x00, 0x00, 0x02, 0x18, 0x00, 0x00, 0x00, 0x14,
-	0x67, 0x58, 0x59, 0x5a, 0x00, 0x00, 0x02, 0x2c,
+    0x67, 0x58, 0x59, 0x5a, 0x00, 0x00, 0x02, 0x2c,
-	0x00, 0x00, 0x00, 0x14, 0x62, 0x58, 0x59, 0x5a,
+    0x00, 0x00, 0x00, 0x14, 0x62, 0x58, 0x59, 0x5a,
-	0x00, 0x00, 0x02, 0x40, 0x00, 0x00, 0x00, 0x14,
+    0x00, 0x00, 0x02, 0x40, 0x00, 0x00, 0x00, 0x14,
-	0x64, 0x6d, 0x6e, 0x64, 0x00, 0x00, 0x02, 0x54,
+    0x64, 0x6d, 0x6e, 0x64, 0x00, 0x00, 0x02, 0x54,
-	0x00, 0x00, 0x00, 0x70, 0x64, 0x6d, 0x64, 0x64,
+    0x00, 0x00, 0x00, 0x70, 0x64, 0x6d, 0x64, 0x64,
-	0x00, 0x00, 0x02, 0xc4, 0x00, 0x00, 0x00, 0x88,
+    0x00, 0x00, 0x02, 0xc4, 0x00, 0x00, 0x00, 0x88,
-	0x76, 0x75, 0x65, 0x64, 0x00, 0x00, 0x03, 0x4c,
+    0x76, 0x75, 0x65, 0x64, 0x00, 0x00, 0x03, 0x4c,
-	0x00, 0x00, 0x00, 0x86, 0x76, 0x69, 0x65, 0x77,
+    0x00, 0x00, 0x00, 0x86, 0x76, 0x69, 0x65, 0x77,
-	0x00, 0x00, 0x03, 0xd4, 0x00, 0x00, 0x00, 0x24,
+    0x00, 0x00, 0x03, 0xd4, 0x00, 0x00, 0x00, 0x24,
-	0x6c, 0x75, 0x6d, 0x69, 0x00, 0x00, 0x03, 0xf8,
+    0x6c, 0x75, 0x6d, 0x69, 0x00, 0x00, 0x03, 0xf8,
-	0x00, 0x00, 0x00, 0x14, 0x6d, 0x65, 0x61, 0x73,
+    0x00, 0x00, 0x00, 0x14, 0x6d, 0x65, 0x61, 0x73,
-	0x00, 0x00, 0x04, 0x0c, 0x00, 0x00, 0x00, 0x24,
+    0x00, 0x00, 0x04, 0x0c, 0x00, 0x00, 0x00, 0x24,
-	0x74, 0x65, 0x63, 0x68, 0x00, 0x00, 0x04, 0x30,
+    0x74, 0x65, 0x63, 0x68, 0x00, 0x00, 0x04, 0x30,
-	0x00, 0x00, 0x00, 0x0c, 0x72, 0x54, 0x52, 0x43,
+    0x00, 0x00, 0x00, 0x0c, 0x72, 0x54, 0x52, 0x43,
-	0x00, 0x00, 0x04, 0x3c, 0x00, 0x00, 0x08, 0x0c,
+    0x00, 0x00, 0x04, 0x3c, 0x00, 0x00, 0x08, 0x0c,
-	0x67, 0x54, 0x52, 0x43, 0x00, 0x00, 0x04, 0x3c,
+    0x67, 0x54, 0x52, 0x43, 0x00, 0x00, 0x04, 0x3c,
-	0x00, 0x00, 0x08, 0x0c, 0x62, 0x54, 0x52, 0x43,
+    0x00, 0x00, 0x08, 0x0c, 0x62, 0x54, 0x52, 0x43,
-	0x00, 0x00, 0x04, 0x3c, 0x00, 0x00, 0x08, 0x0c,
+    0x00, 0x00, 0x04, 0x3c, 0x00, 0x00, 0x08, 0x0c,
-	0x74, 0x65, 0x78, 0x74, 0x00, 0x00, 0x00, 0x00,
+    0x74, 0x65, 0x78, 0x74, 0x00, 0x00, 0x00, 0x00,
-	0x43, 0x6f, 0x70, 0x79, 0x72, 0x69, 0x67, 0x68,
+    0x43, 0x6f, 0x70, 0x79, 0x72, 0x69, 0x67, 0x68,
-	0x74, 0x20, 0x28, 0x63, 0x29, 0x20, 0x31, 0x39,
+    0x74, 0x20, 0x28, 0x63, 0x29, 0x20, 0x31, 0x39,
-	0x39, 0x38, 0x20, 0x48, 0x65, 0x77, 0x6c, 0x65,
+    0x39, 0x38, 0x20, 0x48, 0x65, 0x77, 0x6c, 0x65,
-	0x74, 0x74, 0x2d, 0x50, 0x61, 0x63, 0x6b, 0x61,
+    0x74, 0x74, 0x2d, 0x50, 0x61, 0x63, 0x6b, 0x61,
-	0x72, 0x64, 0x20, 0x43, 0x6f, 0x6d, 0x70, 0x61,
+    0x72, 0x64, 0x20, 0x43, 0x6f, 0x6d, 0x70, 0x61,
-	0x6e, 0x79, 0x00, 0x00, 0x64, 0x65, 0x73, 0x63,
+    0x6e, 0x79, 0x00, 0x00, 0x64, 0x65, 0x73, 0x63,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x12,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x12,
-	0x73, 0x52, 0x47, 0x42, 0x20, 0x49, 0x45, 0x43,
+    0x73, 0x52, 0x47, 0x42, 0x20, 0x49, 0x45, 0x43,
-	0x36, 0x31, 0x39, 0x36, 0x36, 0x2d, 0x32, 0x2e,
+    0x36, 0x31, 0x39, 0x36, 0x36, 0x2d, 0x32, 0x2e,
-	0x31, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x31, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x00, 0x00, 0x00, 0x00, 0x12, 0x73, 0x52, 0x47,
+    0x00, 0x00, 0x00, 0x00, 0x12, 0x73, 0x52, 0x47,
-	0x42, 0x20, 0x49, 0x45, 0x43, 0x36, 0x31, 0x39,
+    0x42, 0x20, 0x49, 0x45, 0x43, 0x36, 0x31, 0x39,
-	0x36, 0x36, 0x2d, 0x32, 0x2e, 0x31, 0x00, 0x00,
+    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,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    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,
+    0x58, 0x59, 0x5a, 0x20, 0x00, 0x00, 0x00, 0x00,
-	0x00, 0x00, 0xf3, 0x51, 0x00, 0x01, 0x00, 0x00,
+    0x00, 0x00, 0xf3, 0x51, 0x00, 0x01, 0x00, 0x00,
-	0x00, 0x01, 0x16, 0xcc, 0x58, 0x59, 0x5a, 0x20,
+    0x00, 0x01, 0x16, 0xcc, 0x58, 0x59, 0x5a, 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,
-	0x58, 0x59, 0x5a, 0x20, 0x00, 0x00, 0x00, 0x00,
+    0x58, 0x59, 0x5a, 0x20, 0x00, 0x00, 0x00, 0x00,
-	0x00, 0x00, 0x6f, 0xa2, 0x00, 0x00, 0x38, 0xf5,
+    0x00, 0x00, 0x6f, 0xa2, 0x00, 0x00, 0x38, 0xf5,
-	0x00, 0x00, 0x03, 0x90, 0x58, 0x59, 0x5a, 0x20,
+    0x00, 0x00, 0x03, 0x90, 0x58, 0x59, 0x5a, 0x20,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x62, 0x99,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x62, 0x99,
-	0x00, 0x00, 0xb7, 0x85, 0x00, 0x00, 0x18, 0xda,
+    0x00, 0x00, 0xb7, 0x85, 0x00, 0x00, 0x18, 0xda,
-	0x58, 0x59, 0x5a, 0x20, 0x00, 0x00, 0x00, 0x00,
+    0x58, 0x59, 0x5a, 0x20, 0x00, 0x00, 0x00, 0x00,
-	0x00, 0x00, 0x24, 0xa0, 0x00, 0x00, 0x0f, 0x84,
+    0x00, 0x00, 0x24, 0xa0, 0x00, 0x00, 0x0f, 0x84,
-	0x00, 0x00, 0xb6, 0xcf, 0x64, 0x65, 0x73, 0x63,
+    0x00, 0x00, 0xb6, 0xcf, 0x64, 0x65, 0x73, 0x63,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x16,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x16,
-	0x49, 0x45, 0x43, 0x20, 0x68, 0x74, 0x74, 0x70,
+    0x49, 0x45, 0x43, 0x20, 0x68, 0x74, 0x74, 0x70,
-	0x3a, 0x2f, 0x2f, 0x77, 0x77, 0x77, 0x2e, 0x69,
+    0x3a, 0x2f, 0x2f, 0x77, 0x77, 0x77, 0x2e, 0x69,
-	0x65, 0x63, 0x2e, 0x63, 0x68, 0x00, 0x00, 0x00,
+    0x65, 0x63, 0x2e, 0x63, 0x68, 0x00, 0x00, 0x00,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x16, 0x49, 0x45, 0x43, 0x20, 0x68, 0x74, 0x74,
+    0x16, 0x49, 0x45, 0x43, 0x20, 0x68, 0x74, 0x74,
-	0x70, 0x3a, 0x2f, 0x2f, 0x77, 0x77, 0x77, 0x2e,
+    0x70, 0x3a, 0x2f, 0x2f, 0x77, 0x77, 0x77, 0x2e,
-	0x69, 0x65, 0x63, 0x2e, 0x63, 0x68, 0x00, 0x00,
+    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, 0x00, 0x00, 0x00, 0x00,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 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, 0x64, 0x65, 0x73, 0x63,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x2e,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x2e,
-	0x49, 0x45, 0x43, 0x20, 0x36, 0x31, 0x39, 0x36,
+    0x49, 0x45, 0x43, 0x20, 0x36, 0x31, 0x39, 0x36,
-	0x36, 0x2d, 0x32, 0x2e, 0x31, 0x20, 0x44, 0x65,
+    0x36, 0x2d, 0x32, 0x2e, 0x31, 0x20, 0x44, 0x65,
-	0x66, 0x61, 0x75, 0x6c, 0x74, 0x20, 0x52, 0x47,
+    0x66, 0x61, 0x75, 0x6c, 0x74, 0x20, 0x52, 0x47,
-	0x42, 0x20, 0x63, 0x6f, 0x6c, 0x6f, 0x75, 0x72,
+    0x42, 0x20, 0x63, 0x6f, 0x6c, 0x6f, 0x75, 0x72,
-	0x20, 0x73, 0x70, 0x61, 0x63, 0x65, 0x20, 0x2d,
+    0x20, 0x73, 0x70, 0x61, 0x63, 0x65, 0x20, 0x2d,
-	0x20, 0x73, 0x52, 0x47, 0x42, 0x00, 0x00, 0x00,
+    0x20, 0x73, 0x52, 0x47, 0x42, 0x00, 0x00, 0x00,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x2e, 0x49, 0x45, 0x43, 0x20, 0x36, 0x31, 0x39,
+    0x2e, 0x49, 0x45, 0x43, 0x20, 0x36, 0x31, 0x39,
-	0x36, 0x36, 0x2d, 0x32, 0x2e, 0x31, 0x20, 0x44,
+    0x36, 0x36, 0x2d, 0x32, 0x2e, 0x31, 0x20, 0x44,
-	0x65, 0x66, 0x61, 0x75, 0x6c, 0x74, 0x20, 0x52,
+    0x65, 0x66, 0x61, 0x75, 0x6c, 0x74, 0x20, 0x52,
-	0x47, 0x42, 0x20, 0x63, 0x6f, 0x6c, 0x6f, 0x75,
+    0x47, 0x42, 0x20, 0x63, 0x6f, 0x6c, 0x6f, 0x75,
-	0x72, 0x20, 0x73, 0x70, 0x61, 0x63, 0x65, 0x20,
+    0x72, 0x20, 0x73, 0x70, 0x61, 0x63, 0x65, 0x20,
-	0x2d, 0x20, 0x73, 0x52, 0x47, 0x42, 0x00, 0x00,
+    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, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x00, 0x00, 0x00, 0x00, 0x64, 0x65, 0x73, 0x63,
+    0x00, 0x00, 0x00, 0x00, 0x64, 0x65, 0x73, 0x63,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x2c,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x2c,
-	0x52, 0x65, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63,
+    0x52, 0x65, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63,
-	0x65, 0x20, 0x56, 0x69, 0x65, 0x77, 0x69, 0x6e,
+    0x65, 0x20, 0x56, 0x69, 0x65, 0x77, 0x69, 0x6e,
-	0x67, 0x20, 0x43, 0x6f, 0x6e, 0x64, 0x69, 0x74,
+    0x67, 0x20, 0x43, 0x6f, 0x6e, 0x64, 0x69, 0x74,
-	0x69, 0x6f, 0x6e, 0x20, 0x69, 0x6e, 0x20, 0x49,
+    0x69, 0x6f, 0x6e, 0x20, 0x69, 0x6e, 0x20, 0x49,
-	0x45, 0x43, 0x36, 0x31, 0x39, 0x36, 0x36, 0x2d,
+    0x45, 0x43, 0x36, 0x31, 0x39, 0x36, 0x36, 0x2d,
-	0x32, 0x2e, 0x31, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x32, 0x2e, 0x31, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x2c, 0x52,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x2c, 0x52,
-	0x65, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65,
+    0x65, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65,
-	0x20, 0x56, 0x69, 0x65, 0x77, 0x69, 0x6e, 0x67,
+    0x20, 0x56, 0x69, 0x65, 0x77, 0x69, 0x6e, 0x67,
-	0x20, 0x43, 0x6f, 0x6e, 0x64, 0x69, 0x74, 0x69,
+    0x20, 0x43, 0x6f, 0x6e, 0x64, 0x69, 0x74, 0x69,
-	0x6f, 0x6e, 0x20, 0x69, 0x6e, 0x20, 0x49, 0x45,
+    0x6f, 0x6e, 0x20, 0x69, 0x6e, 0x20, 0x49, 0x45,
-	0x43, 0x36, 0x31, 0x39, 0x36, 0x36, 0x2d, 0x32,
+    0x43, 0x36, 0x31, 0x39, 0x36, 0x36, 0x2d, 0x32,
-	0x2e, 0x31, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    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, 0x76, 0x69, 0x65, 0x77,
+    0x00, 0x00, 0x00, 0x00, 0x76, 0x69, 0x65, 0x77,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x13, 0xa4, 0xfe,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x13, 0xa4, 0xfe,
-	0x00, 0x14, 0x5f, 0x2e, 0x00, 0x10, 0xcf, 0x14,
+    0x00, 0x14, 0x5f, 0x2e, 0x00, 0x10, 0xcf, 0x14,
-	0x00, 0x03, 0xed, 0xcc, 0x00, 0x04, 0x13, 0x0b,
+    0x00, 0x03, 0xed, 0xcc, 0x00, 0x04, 0x13, 0x0b,
-	0x00, 0x03, 0x5c, 0x9e, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x03, 0x5c, 0x9e, 0x00, 0x00, 0x00, 0x01,
-	0x58, 0x59, 0x5a, 0x20, 0x00, 0x00, 0x00, 0x00,
+    0x58, 0x59, 0x5a, 0x20, 0x00, 0x00, 0x00, 0x00,
-	0x00, 0x4c, 0x09, 0x56, 0x00, 0x50, 0x00, 0x00,
+    0x00, 0x4c, 0x09, 0x56, 0x00, 0x50, 0x00, 0x00,
-	0x00, 0x57, 0x1f, 0xe7, 0x6d, 0x65, 0x61, 0x73,
+    0x00, 0x57, 0x1f, 0xe7, 0x6d, 0x65, 0x61, 0x73,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
+    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, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x00, 0x00, 0x02, 0x8f, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x02, 0x8f, 0x00, 0x00, 0x00, 0x02,
-	0x73, 0x69, 0x67, 0x20, 0x00, 0x00, 0x00, 0x00,
+    0x73, 0x69, 0x67, 0x20, 0x00, 0x00, 0x00, 0x00,
-	0x43, 0x52, 0x54, 0x20, 0x63, 0x75, 0x72, 0x76,
+    0x43, 0x52, 0x54, 0x20, 0x63, 0x75, 0x72, 0x76,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00,
-	0x00, 0x00, 0x00, 0x05, 0x00, 0x0a, 0x00, 0x0f,
+    0x00, 0x00, 0x00, 0x05, 0x00, 0x0a, 0x00, 0x0f,
-	0x00, 0x14, 0x00, 0x19, 0x00, 0x1e, 0x00, 0x23,
+    0x00, 0x14, 0x00, 0x19, 0x00, 0x1e, 0x00, 0x23,
-	0x00, 0x28, 0x00, 0x2d, 0x00, 0x32, 0x00, 0x37,
+    0x00, 0x28, 0x00, 0x2d, 0x00, 0x32, 0x00, 0x37,
-	0x00, 0x3b, 0x00, 0x40, 0x00, 0x45, 0x00, 0x4a,
+    0x00, 0x3b, 0x00, 0x40, 0x00, 0x45, 0x00, 0x4a,
-	0x00, 0x4f, 0x00, 0x54, 0x00, 0x59, 0x00, 0x5e,
+    0x00, 0x4f, 0x00, 0x54, 0x00, 0x59, 0x00, 0x5e,
-	0x00, 0x63, 0x00, 0x68, 0x00, 0x6d, 0x00, 0x72,
+    0x00, 0x63, 0x00, 0x68, 0x00, 0x6d, 0x00, 0x72,
-	0x00, 0x77, 0x00, 0x7c, 0x00, 0x81, 0x00, 0x86,
+    0x00, 0x77, 0x00, 0x7c, 0x00, 0x81, 0x00, 0x86,
-	0x00, 0x8b, 0x00, 0x90, 0x00, 0x95, 0x00, 0x9a,
+    0x00, 0x8b, 0x00, 0x90, 0x00, 0x95, 0x00, 0x9a,
-	0x00, 0x9f, 0x00, 0xa4, 0x00, 0xa9, 0x00, 0xae,
+    0x00, 0x9f, 0x00, 0xa4, 0x00, 0xa9, 0x00, 0xae,
-	0x00, 0xb2, 0x00, 0xb7, 0x00, 0xbc, 0x00, 0xc1,
+    0x00, 0xb2, 0x00, 0xb7, 0x00, 0xbc, 0x00, 0xc1,
-	0x00, 0xc6, 0x00, 0xcb, 0x00, 0xd0, 0x00, 0xd5,
+    0x00, 0xc6, 0x00, 0xcb, 0x00, 0xd0, 0x00, 0xd5,
-	0x00, 0xdb, 0x00, 0xe0, 0x00, 0xe5, 0x00, 0xeb,
+    0x00, 0xdb, 0x00, 0xe0, 0x00, 0xe5, 0x00, 0xeb,
-	0x00, 0xf0, 0x00, 0xf6, 0x00, 0xfb, 0x01, 0x01,
+    0x00, 0xf0, 0x00, 0xf6, 0x00, 0xfb, 0x01, 0x01,
-	0x01, 0x07, 0x01, 0x0d, 0x01, 0x13, 0x01, 0x19,
+    0x01, 0x07, 0x01, 0x0d, 0x01, 0x13, 0x01, 0x19,
-	0x01, 0x1f, 0x01, 0x25, 0x01, 0x2b, 0x01, 0x32,
+    0x01, 0x1f, 0x01, 0x25, 0x01, 0x2b, 0x01, 0x32,
-	0x01, 0x38, 0x01, 0x3e, 0x01, 0x45, 0x01, 0x4c,
+    0x01, 0x38, 0x01, 0x3e, 0x01, 0x45, 0x01, 0x4c,
-	0x01, 0x52, 0x01, 0x59, 0x01, 0x60, 0x01, 0x67,
+    0x01, 0x52, 0x01, 0x59, 0x01, 0x60, 0x01, 0x67,
-	0x01, 0x6e, 0x01, 0x75, 0x01, 0x7c, 0x01, 0x83,
+    0x01, 0x6e, 0x01, 0x75, 0x01, 0x7c, 0x01, 0x83,
-	0x01, 0x8b, 0x01, 0x92, 0x01, 0x9a, 0x01, 0xa1,
+    0x01, 0x8b, 0x01, 0x92, 0x01, 0x9a, 0x01, 0xa1,
-	0x01, 0xa9, 0x01, 0xb1, 0x01, 0xb9, 0x01, 0xc1,
+    0x01, 0xa9, 0x01, 0xb1, 0x01, 0xb9, 0x01, 0xc1,
-	0x01, 0xc9, 0x01, 0xd1, 0x01, 0xd9, 0x01, 0xe1,
+    0x01, 0xc9, 0x01, 0xd1, 0x01, 0xd9, 0x01, 0xe1,
-	0x01, 0xe9, 0x01, 0xf2, 0x01, 0xfa, 0x02, 0x03,
+    0x01, 0xe9, 0x01, 0xf2, 0x01, 0xfa, 0x02, 0x03,
-	0x02, 0x0c, 0x02, 0x14, 0x02, 0x1d, 0x02, 0x26,
+    0x02, 0x0c, 0x02, 0x14, 0x02, 0x1d, 0x02, 0x26,
-	0x02, 0x2f, 0x02, 0x38, 0x02, 0x41, 0x02, 0x4b,
+    0x02, 0x2f, 0x02, 0x38, 0x02, 0x41, 0x02, 0x4b,
-	0x02, 0x54, 0x02, 0x5d, 0x02, 0x67, 0x02, 0x71,
+    0x02, 0x54, 0x02, 0x5d, 0x02, 0x67, 0x02, 0x71,
-	0x02, 0x7a, 0x02, 0x84, 0x02, 0x8e, 0x02, 0x98,
+    0x02, 0x7a, 0x02, 0x84, 0x02, 0x8e, 0x02, 0x98,
-	0x02, 0xa2, 0x02, 0xac, 0x02, 0xb6, 0x02, 0xc1,
+    0x02, 0xa2, 0x02, 0xac, 0x02, 0xb6, 0x02, 0xc1,
-	0x02, 0xcb, 0x02, 0xd5, 0x02, 0xe0, 0x02, 0xeb,
+    0x02, 0xcb, 0x02, 0xd5, 0x02, 0xe0, 0x02, 0xeb,
-	0x02, 0xf5, 0x03, 0x00, 0x03, 0x0b, 0x03, 0x16,
+    0x02, 0xf5, 0x03, 0x00, 0x03, 0x0b, 0x03, 0x16,
-	0x03, 0x21, 0x03, 0x2d, 0x03, 0x38, 0x03, 0x43,
+    0x03, 0x21, 0x03, 0x2d, 0x03, 0x38, 0x03, 0x43,
-	0x03, 0x4f, 0x03, 0x5a, 0x03, 0x66, 0x03, 0x72,
+    0x03, 0x4f, 0x03, 0x5a, 0x03, 0x66, 0x03, 0x72,
-	0x03, 0x7e, 0x03, 0x8a, 0x03, 0x96, 0x03, 0xa2,
+    0x03, 0x7e, 0x03, 0x8a, 0x03, 0x96, 0x03, 0xa2,
-	0x03, 0xae, 0x03, 0xba, 0x03, 0xc7, 0x03, 0xd3,
+    0x03, 0xae, 0x03, 0xba, 0x03, 0xc7, 0x03, 0xd3,
-	0x03, 0xe0, 0x03, 0xec, 0x03, 0xf9, 0x04, 0x06,
+    0x03, 0xe0, 0x03, 0xec, 0x03, 0xf9, 0x04, 0x06,
-	0x04, 0x13, 0x04, 0x20, 0x04, 0x2d, 0x04, 0x3b,
+    0x04, 0x13, 0x04, 0x20, 0x04, 0x2d, 0x04, 0x3b,
-	0x04, 0x48, 0x04, 0x55, 0x04, 0x63, 0x04, 0x71,
+    0x04, 0x48, 0x04, 0x55, 0x04, 0x63, 0x04, 0x71,
-	0x04, 0x7e, 0x04, 0x8c, 0x04, 0x9a, 0x04, 0xa8,
+    0x04, 0x7e, 0x04, 0x8c, 0x04, 0x9a, 0x04, 0xa8,
-	0x04, 0xb6, 0x04, 0xc4, 0x04, 0xd3, 0x04, 0xe1,
+    0x04, 0xb6, 0x04, 0xc4, 0x04, 0xd3, 0x04, 0xe1,
-	0x04, 0xf0, 0x04, 0xfe, 0x05, 0x0d, 0x05, 0x1c,
+    0x04, 0xf0, 0x04, 0xfe, 0x05, 0x0d, 0x05, 0x1c,
-	0x05, 0x2b, 0x05, 0x3a, 0x05, 0x49, 0x05, 0x58,
+    0x05, 0x2b, 0x05, 0x3a, 0x05, 0x49, 0x05, 0x58,
-	0x05, 0x67, 0x05, 0x77, 0x05, 0x86, 0x05, 0x96,
+    0x05, 0x67, 0x05, 0x77, 0x05, 0x86, 0x05, 0x96,
-	0x05, 0xa6, 0x05, 0xb5, 0x05, 0xc5, 0x05, 0xd5,
+    0x05, 0xa6, 0x05, 0xb5, 0x05, 0xc5, 0x05, 0xd5,
-	0x05, 0xe5, 0x05, 0xf6, 0x06, 0x06, 0x06, 0x16,
+    0x05, 0xe5, 0x05, 0xf6, 0x06, 0x06, 0x06, 0x16,
-	0x06, 0x27, 0x06, 0x37, 0x06, 0x48, 0x06, 0x59,
+    0x06, 0x27, 0x06, 0x37, 0x06, 0x48, 0x06, 0x59,
-	0x06, 0x6a, 0x06, 0x7b, 0x06, 0x8c, 0x06, 0x9d,
+    0x06, 0x6a, 0x06, 0x7b, 0x06, 0x8c, 0x06, 0x9d,
-	0x06, 0xaf, 0x06, 0xc0, 0x06, 0xd1, 0x06, 0xe3,
+    0x06, 0xaf, 0x06, 0xc0, 0x06, 0xd1, 0x06, 0xe3,
-	0x06, 0xf5, 0x07, 0x07, 0x07, 0x19, 0x07, 0x2b,
+    0x06, 0xf5, 0x07, 0x07, 0x07, 0x19, 0x07, 0x2b,
-	0x07, 0x3d, 0x07, 0x4f, 0x07, 0x61, 0x07, 0x74,
+    0x07, 0x3d, 0x07, 0x4f, 0x07, 0x61, 0x07, 0x74,
-	0x07, 0x86, 0x07, 0x99, 0x07, 0xac, 0x07, 0xbf,
+    0x07, 0x86, 0x07, 0x99, 0x07, 0xac, 0x07, 0xbf,
-	0x07, 0xd2, 0x07, 0xe5, 0x07, 0xf8, 0x08, 0x0b,
+    0x07, 0xd2, 0x07, 0xe5, 0x07, 0xf8, 0x08, 0x0b,
-	0x08, 0x1f, 0x08, 0x32, 0x08, 0x46, 0x08, 0x5a,
+    0x08, 0x1f, 0x08, 0x32, 0x08, 0x46, 0x08, 0x5a,
-	0x08, 0x6e, 0x08, 0x82, 0x08, 0x96, 0x08, 0xaa,
+    0x08, 0x6e, 0x08, 0x82, 0x08, 0x96, 0x08, 0xaa,
-	0x08, 0xbe, 0x08, 0xd2, 0x08, 0xe7, 0x08, 0xfb,
+    0x08, 0xbe, 0x08, 0xd2, 0x08, 0xe7, 0x08, 0xfb,
-	0x09, 0x10, 0x09, 0x25, 0x09, 0x3a, 0x09, 0x4f,
+    0x09, 0x10, 0x09, 0x25, 0x09, 0x3a, 0x09, 0x4f,
-	0x09, 0x64, 0x09, 0x79, 0x09, 0x8f, 0x09, 0xa4,
+    0x09, 0x64, 0x09, 0x79, 0x09, 0x8f, 0x09, 0xa4,
-	0x09, 0xba, 0x09, 0xcf, 0x09, 0xe5, 0x09, 0xfb,
+    0x09, 0xba, 0x09, 0xcf, 0x09, 0xe5, 0x09, 0xfb,
-	0x0a, 0x11, 0x0a, 0x27, 0x0a, 0x3d, 0x0a, 0x54,
+    0x0a, 0x11, 0x0a, 0x27, 0x0a, 0x3d, 0x0a, 0x54,
-	0x0a, 0x6a, 0x0a, 0x81, 0x0a, 0x98, 0x0a, 0xae,
+    0x0a, 0x6a, 0x0a, 0x81, 0x0a, 0x98, 0x0a, 0xae,
-	0x0a, 0xc5, 0x0a, 0xdc, 0x0a, 0xf3, 0x0b, 0x0b,
+    0x0a, 0xc5, 0x0a, 0xdc, 0x0a, 0xf3, 0x0b, 0x0b,
-	0x0b, 0x22, 0x0b, 0x39, 0x0b, 0x51, 0x0b, 0x69,
+    0x0b, 0x22, 0x0b, 0x39, 0x0b, 0x51, 0x0b, 0x69,
-	0x0b, 0x80, 0x0b, 0x98, 0x0b, 0xb0, 0x0b, 0xc8,
+    0x0b, 0x80, 0x0b, 0x98, 0x0b, 0xb0, 0x0b, 0xc8,
-	0x0b, 0xe1, 0x0b, 0xf9, 0x0c, 0x12, 0x0c, 0x2a,
+    0x0b, 0xe1, 0x0b, 0xf9, 0x0c, 0x12, 0x0c, 0x2a,
-	0x0c, 0x43, 0x0c, 0x5c, 0x0c, 0x75, 0x0c, 0x8e,
+    0x0c, 0x43, 0x0c, 0x5c, 0x0c, 0x75, 0x0c, 0x8e,
-	0x0c, 0xa7, 0x0c, 0xc0, 0x0c, 0xd9, 0x0c, 0xf3,
+    0x0c, 0xa7, 0x0c, 0xc0, 0x0c, 0xd9, 0x0c, 0xf3,
-	0x0d, 0x0d, 0x0d, 0x26, 0x0d, 0x40, 0x0d, 0x5a,
+    0x0d, 0x0d, 0x0d, 0x26, 0x0d, 0x40, 0x0d, 0x5a,
-	0x0d, 0x74, 0x0d, 0x8e, 0x0d, 0xa9, 0x0d, 0xc3,
+    0x0d, 0x74, 0x0d, 0x8e, 0x0d, 0xa9, 0x0d, 0xc3,
-	0x0d, 0xde, 0x0d, 0xf8, 0x0e, 0x13, 0x0e, 0x2e,
+    0x0d, 0xde, 0x0d, 0xf8, 0x0e, 0x13, 0x0e, 0x2e,
-	0x0e, 0x49, 0x0e, 0x64, 0x0e, 0x7f, 0x0e, 0x9b,
+    0x0e, 0x49, 0x0e, 0x64, 0x0e, 0x7f, 0x0e, 0x9b,
-	0x0e, 0xb6, 0x0e, 0xd2, 0x0e, 0xee, 0x0f, 0x09,
+    0x0e, 0xb6, 0x0e, 0xd2, 0x0e, 0xee, 0x0f, 0x09,
-	0x0f, 0x25, 0x0f, 0x41, 0x0f, 0x5e, 0x0f, 0x7a,
+    0x0f, 0x25, 0x0f, 0x41, 0x0f, 0x5e, 0x0f, 0x7a,
-	0x0f, 0x96, 0x0f, 0xb3, 0x0f, 0xcf, 0x0f, 0xec,
+    0x0f, 0x96, 0x0f, 0xb3, 0x0f, 0xcf, 0x0f, 0xec,
-	0x10, 0x09, 0x10, 0x26, 0x10, 0x43, 0x10, 0x61,
+    0x10, 0x09, 0x10, 0x26, 0x10, 0x43, 0x10, 0x61,
-	0x10, 0x7e, 0x10, 0x9b, 0x10, 0xb9, 0x10, 0xd7,
+    0x10, 0x7e, 0x10, 0x9b, 0x10, 0xb9, 0x10, 0xd7,
-	0x10, 0xf5, 0x11, 0x13, 0x11, 0x31, 0x11, 0x4f,
+    0x10, 0xf5, 0x11, 0x13, 0x11, 0x31, 0x11, 0x4f,
-	0x11, 0x6d, 0x11, 0x8c, 0x11, 0xaa, 0x11, 0xc9,
+    0x11, 0x6d, 0x11, 0x8c, 0x11, 0xaa, 0x11, 0xc9,
-	0x11, 0xe8, 0x12, 0x07, 0x12, 0x26, 0x12, 0x45,
+    0x11, 0xe8, 0x12, 0x07, 0x12, 0x26, 0x12, 0x45,
-	0x12, 0x64, 0x12, 0x84, 0x12, 0xa3, 0x12, 0xc3,
+    0x12, 0x64, 0x12, 0x84, 0x12, 0xa3, 0x12, 0xc3,
-	0x12, 0xe3, 0x13, 0x03, 0x13, 0x23, 0x13, 0x43,
+    0x12, 0xe3, 0x13, 0x03, 0x13, 0x23, 0x13, 0x43,
-	0x13, 0x63, 0x13, 0x83, 0x13, 0xa4, 0x13, 0xc5,
+    0x13, 0x63, 0x13, 0x83, 0x13, 0xa4, 0x13, 0xc5,
-	0x13, 0xe5, 0x14, 0x06, 0x14, 0x27, 0x14, 0x49,
+    0x13, 0xe5, 0x14, 0x06, 0x14, 0x27, 0x14, 0x49,
-	0x14, 0x6a, 0x14, 0x8b, 0x14, 0xad, 0x14, 0xce,
+    0x14, 0x6a, 0x14, 0x8b, 0x14, 0xad, 0x14, 0xce,
-	0x14, 0xf0, 0x15, 0x12, 0x15, 0x34, 0x15, 0x56,
+    0x14, 0xf0, 0x15, 0x12, 0x15, 0x34, 0x15, 0x56,
-	0x15, 0x78, 0x15, 0x9b, 0x15, 0xbd, 0x15, 0xe0,
+    0x15, 0x78, 0x15, 0x9b, 0x15, 0xbd, 0x15, 0xe0,
-	0x16, 0x03, 0x16, 0x26, 0x16, 0x49, 0x16, 0x6c,
+    0x16, 0x03, 0x16, 0x26, 0x16, 0x49, 0x16, 0x6c,
-	0x16, 0x8f, 0x16, 0xb2, 0x16, 0xd6, 0x16, 0xfa,
+    0x16, 0x8f, 0x16, 0xb2, 0x16, 0xd6, 0x16, 0xfa,
-	0x17, 0x1d, 0x17, 0x41, 0x17, 0x65, 0x17, 0x89,
+    0x17, 0x1d, 0x17, 0x41, 0x17, 0x65, 0x17, 0x89,
-	0x17, 0xae, 0x17, 0xd2, 0x17, 0xf7, 0x18, 0x1b,
+    0x17, 0xae, 0x17, 0xd2, 0x17, 0xf7, 0x18, 0x1b,
-	0x18, 0x40, 0x18, 0x65, 0x18, 0x8a, 0x18, 0xaf,
+    0x18, 0x40, 0x18, 0x65, 0x18, 0x8a, 0x18, 0xaf,
-	0x18, 0xd5, 0x18, 0xfa, 0x19, 0x20, 0x19, 0x45,
+    0x18, 0xd5, 0x18, 0xfa, 0x19, 0x20, 0x19, 0x45,
-	0x19, 0x6b, 0x19, 0x91, 0x19, 0xb7, 0x19, 0xdd,
+    0x19, 0x6b, 0x19, 0x91, 0x19, 0xb7, 0x19, 0xdd,
-	0x1a, 0x04, 0x1a, 0x2a, 0x1a, 0x51, 0x1a, 0x77,
+    0x1a, 0x04, 0x1a, 0x2a, 0x1a, 0x51, 0x1a, 0x77,
-	0x1a, 0x9e, 0x1a, 0xc5, 0x1a, 0xec, 0x1b, 0x14,
+    0x1a, 0x9e, 0x1a, 0xc5, 0x1a, 0xec, 0x1b, 0x14,
-	0x1b, 0x3b, 0x1b, 0x63, 0x1b, 0x8a, 0x1b, 0xb2,
+    0x1b, 0x3b, 0x1b, 0x63, 0x1b, 0x8a, 0x1b, 0xb2,
-	0x1b, 0xda, 0x1c, 0x02, 0x1c, 0x2a, 0x1c, 0x52,
+    0x1b, 0xda, 0x1c, 0x02, 0x1c, 0x2a, 0x1c, 0x52,
-	0x1c, 0x7b, 0x1c, 0xa3, 0x1c, 0xcc, 0x1c, 0xf5,
+    0x1c, 0x7b, 0x1c, 0xa3, 0x1c, 0xcc, 0x1c, 0xf5,
-	0x1d, 0x1e, 0x1d, 0x47, 0x1d, 0x70, 0x1d, 0x99,
+    0x1d, 0x1e, 0x1d, 0x47, 0x1d, 0x70, 0x1d, 0x99,
-	0x1d, 0xc3, 0x1d, 0xec, 0x1e, 0x16, 0x1e, 0x40,
+    0x1d, 0xc3, 0x1d, 0xec, 0x1e, 0x16, 0x1e, 0x40,
-	0x1e, 0x6a, 0x1e, 0x94, 0x1e, 0xbe, 0x1e, 0xe9,
+    0x1e, 0x6a, 0x1e, 0x94, 0x1e, 0xbe, 0x1e, 0xe9,
-	0x1f, 0x13, 0x1f, 0x3e, 0x1f, 0x69, 0x1f, 0x94,
+    0x1f, 0x13, 0x1f, 0x3e, 0x1f, 0x69, 0x1f, 0x94,
-	0x1f, 0xbf, 0x1f, 0xea, 0x20, 0x15, 0x20, 0x41,
+    0x1f, 0xbf, 0x1f, 0xea, 0x20, 0x15, 0x20, 0x41,
-	0x20, 0x6c, 0x20, 0x98, 0x20, 0xc4, 0x20, 0xf0,
+    0x20, 0x6c, 0x20, 0x98, 0x20, 0xc4, 0x20, 0xf0,
-	0x21, 0x1c, 0x21, 0x48, 0x21, 0x75, 0x21, 0xa1,
+    0x21, 0x1c, 0x21, 0x48, 0x21, 0x75, 0x21, 0xa1,
-	0x21, 0xce, 0x21, 0xfb, 0x22, 0x27, 0x22, 0x55,
+    0x21, 0xce, 0x21, 0xfb, 0x22, 0x27, 0x22, 0x55,
-	0x22, 0x82, 0x22, 0xaf, 0x22, 0xdd, 0x23, 0x0a,
+    0x22, 0x82, 0x22, 0xaf, 0x22, 0xdd, 0x23, 0x0a,
-	0x23, 0x38, 0x23, 0x66, 0x23, 0x94, 0x23, 0xc2,
+    0x23, 0x38, 0x23, 0x66, 0x23, 0x94, 0x23, 0xc2,
-	0x23, 0xf0, 0x24, 0x1f, 0x24, 0x4d, 0x24, 0x7c,
+    0x23, 0xf0, 0x24, 0x1f, 0x24, 0x4d, 0x24, 0x7c,
-	0x24, 0xab, 0x24, 0xda, 0x25, 0x09, 0x25, 0x38,
+    0x24, 0xab, 0x24, 0xda, 0x25, 0x09, 0x25, 0x38,
-	0x25, 0x68, 0x25, 0x97, 0x25, 0xc7, 0x25, 0xf7,
+    0x25, 0x68, 0x25, 0x97, 0x25, 0xc7, 0x25, 0xf7,
-	0x26, 0x27, 0x26, 0x57, 0x26, 0x87, 0x26, 0xb7,
+    0x26, 0x27, 0x26, 0x57, 0x26, 0x87, 0x26, 0xb7,
-	0x26, 0xe8, 0x27, 0x18, 0x27, 0x49, 0x27, 0x7a,
+    0x26, 0xe8, 0x27, 0x18, 0x27, 0x49, 0x27, 0x7a,
-	0x27, 0xab, 0x27, 0xdc, 0x28, 0x0d, 0x28, 0x3f,
+    0x27, 0xab, 0x27, 0xdc, 0x28, 0x0d, 0x28, 0x3f,
-	0x28, 0x71, 0x28, 0xa2, 0x28, 0xd4, 0x29, 0x06,
+    0x28, 0x71, 0x28, 0xa2, 0x28, 0xd4, 0x29, 0x06,
-	0x29, 0x38, 0x29, 0x6b, 0x29, 0x9d, 0x29, 0xd0,
+    0x29, 0x38, 0x29, 0x6b, 0x29, 0x9d, 0x29, 0xd0,
-	0x2a, 0x02, 0x2a, 0x35, 0x2a, 0x68, 0x2a, 0x9b,
+    0x2a, 0x02, 0x2a, 0x35, 0x2a, 0x68, 0x2a, 0x9b,
-	0x2a, 0xcf, 0x2b, 0x02, 0x2b, 0x36, 0x2b, 0x69,
+    0x2a, 0xcf, 0x2b, 0x02, 0x2b, 0x36, 0x2b, 0x69,
-	0x2b, 0x9d, 0x2b, 0xd1, 0x2c, 0x05, 0x2c, 0x39,
+    0x2b, 0x9d, 0x2b, 0xd1, 0x2c, 0x05, 0x2c, 0x39,
-	0x2c, 0x6e, 0x2c, 0xa2, 0x2c, 0xd7, 0x2d, 0x0c,
+    0x2c, 0x6e, 0x2c, 0xa2, 0x2c, 0xd7, 0x2d, 0x0c,
-	0x2d, 0x41, 0x2d, 0x76, 0x2d, 0xab, 0x2d, 0xe1,
+    0x2d, 0x41, 0x2d, 0x76, 0x2d, 0xab, 0x2d, 0xe1,
-	0x2e, 0x16, 0x2e, 0x4c, 0x2e, 0x82, 0x2e, 0xb7,
+    0x2e, 0x16, 0x2e, 0x4c, 0x2e, 0x82, 0x2e, 0xb7,
-	0x2e, 0xee, 0x2f, 0x24, 0x2f, 0x5a, 0x2f, 0x91,
+    0x2e, 0xee, 0x2f, 0x24, 0x2f, 0x5a, 0x2f, 0x91,
-	0x2f, 0xc7, 0x2f, 0xfe, 0x30, 0x35, 0x30, 0x6c,
+    0x2f, 0xc7, 0x2f, 0xfe, 0x30, 0x35, 0x30, 0x6c,
-	0x30, 0xa4, 0x30, 0xdb, 0x31, 0x12, 0x31, 0x4a,
+    0x30, 0xa4, 0x30, 0xdb, 0x31, 0x12, 0x31, 0x4a,
-	0x31, 0x82, 0x31, 0xba, 0x31, 0xf2, 0x32, 0x2a,
+    0x31, 0x82, 0x31, 0xba, 0x31, 0xf2, 0x32, 0x2a,
-	0x32, 0x63, 0x32, 0x9b, 0x32, 0xd4, 0x33, 0x0d,
+    0x32, 0x63, 0x32, 0x9b, 0x32, 0xd4, 0x33, 0x0d,
-	0x33, 0x46, 0x33, 0x7f, 0x33, 0xb8, 0x33, 0xf1,
+    0x33, 0x46, 0x33, 0x7f, 0x33, 0xb8, 0x33, 0xf1,
-	0x34, 0x2b, 0x34, 0x65, 0x34, 0x9e, 0x34, 0xd8,
+    0x34, 0x2b, 0x34, 0x65, 0x34, 0x9e, 0x34, 0xd8,
-	0x35, 0x13, 0x35, 0x4d, 0x35, 0x87, 0x35, 0xc2,
+    0x35, 0x13, 0x35, 0x4d, 0x35, 0x87, 0x35, 0xc2,
-	0x35, 0xfd, 0x36, 0x37, 0x36, 0x72, 0x36, 0xae,
+    0x35, 0xfd, 0x36, 0x37, 0x36, 0x72, 0x36, 0xae,
-	0x36, 0xe9, 0x37, 0x24, 0x37, 0x60, 0x37, 0x9c,
+    0x36, 0xe9, 0x37, 0x24, 0x37, 0x60, 0x37, 0x9c,
-	0x37, 0xd7, 0x38, 0x14, 0x38, 0x50, 0x38, 0x8c,
+    0x37, 0xd7, 0x38, 0x14, 0x38, 0x50, 0x38, 0x8c,
-	0x38, 0xc8, 0x39, 0x05, 0x39, 0x42, 0x39, 0x7f,
+    0x38, 0xc8, 0x39, 0x05, 0x39, 0x42, 0x39, 0x7f,
-	0x39, 0xbc, 0x39, 0xf9, 0x3a, 0x36, 0x3a, 0x74,
+    0x39, 0xbc, 0x39, 0xf9, 0x3a, 0x36, 0x3a, 0x74,
-	0x3a, 0xb2, 0x3a, 0xef, 0x3b, 0x2d, 0x3b, 0x6b,
+    0x3a, 0xb2, 0x3a, 0xef, 0x3b, 0x2d, 0x3b, 0x6b,
-	0x3b, 0xaa, 0x3b, 0xe8, 0x3c, 0x27, 0x3c, 0x65,
+    0x3b, 0xaa, 0x3b, 0xe8, 0x3c, 0x27, 0x3c, 0x65,
-	0x3c, 0xa4, 0x3c, 0xe3, 0x3d, 0x22, 0x3d, 0x61,
+    0x3c, 0xa4, 0x3c, 0xe3, 0x3d, 0x22, 0x3d, 0x61,
-	0x3d, 0xa1, 0x3d, 0xe0, 0x3e, 0x20, 0x3e, 0x60,
+    0x3d, 0xa1, 0x3d, 0xe0, 0x3e, 0x20, 0x3e, 0x60,
-	0x3e, 0xa0, 0x3e, 0xe0, 0x3f, 0x21, 0x3f, 0x61,
+    0x3e, 0xa0, 0x3e, 0xe0, 0x3f, 0x21, 0x3f, 0x61,
-	0x3f, 0xa2, 0x3f, 0xe2, 0x40, 0x23, 0x40, 0x64,
+    0x3f, 0xa2, 0x3f, 0xe2, 0x40, 0x23, 0x40, 0x64,
-	0x40, 0xa6, 0x40, 0xe7, 0x41, 0x29, 0x41, 0x6a,
+    0x40, 0xa6, 0x40, 0xe7, 0x41, 0x29, 0x41, 0x6a,
-	0x41, 0xac, 0x41, 0xee, 0x42, 0x30, 0x42, 0x72,
+    0x41, 0xac, 0x41, 0xee, 0x42, 0x30, 0x42, 0x72,
-	0x42, 0xb5, 0x42, 0xf7, 0x43, 0x3a, 0x43, 0x7d,
+    0x42, 0xb5, 0x42, 0xf7, 0x43, 0x3a, 0x43, 0x7d,
-	0x43, 0xc0, 0x44, 0x03, 0x44, 0x47, 0x44, 0x8a,
+    0x43, 0xc0, 0x44, 0x03, 0x44, 0x47, 0x44, 0x8a,
-	0x44, 0xce, 0x45, 0x12, 0x45, 0x55, 0x45, 0x9a,
+    0x44, 0xce, 0x45, 0x12, 0x45, 0x55, 0x45, 0x9a,
-	0x45, 0xde, 0x46, 0x22, 0x46, 0x67, 0x46, 0xab,
+    0x45, 0xde, 0x46, 0x22, 0x46, 0x67, 0x46, 0xab,
-	0x46, 0xf0, 0x47, 0x35, 0x47, 0x7b, 0x47, 0xc0,
+    0x46, 0xf0, 0x47, 0x35, 0x47, 0x7b, 0x47, 0xc0,
-	0x48, 0x05, 0x48, 0x4b, 0x48, 0x91, 0x48, 0xd7,
+    0x48, 0x05, 0x48, 0x4b, 0x48, 0x91, 0x48, 0xd7,
-	0x49, 0x1d, 0x49, 0x63, 0x49, 0xa9, 0x49, 0xf0,
+    0x49, 0x1d, 0x49, 0x63, 0x49, 0xa9, 0x49, 0xf0,
-	0x4a, 0x37, 0x4a, 0x7d, 0x4a, 0xc4, 0x4b, 0x0c,
+    0x4a, 0x37, 0x4a, 0x7d, 0x4a, 0xc4, 0x4b, 0x0c,
-	0x4b, 0x53, 0x4b, 0x9a, 0x4b, 0xe2, 0x4c, 0x2a,
+    0x4b, 0x53, 0x4b, 0x9a, 0x4b, 0xe2, 0x4c, 0x2a,
-	0x4c, 0x72, 0x4c, 0xba, 0x4d, 0x02, 0x4d, 0x4a,
+    0x4c, 0x72, 0x4c, 0xba, 0x4d, 0x02, 0x4d, 0x4a,
-	0x4d, 0x93, 0x4d, 0xdc, 0x4e, 0x25, 0x4e, 0x6e,
+    0x4d, 0x93, 0x4d, 0xdc, 0x4e, 0x25, 0x4e, 0x6e,
-	0x4e, 0xb7, 0x4f, 0x00, 0x4f, 0x49, 0x4f, 0x93,
+    0x4e, 0xb7, 0x4f, 0x00, 0x4f, 0x49, 0x4f, 0x93,
-	0x4f, 0xdd, 0x50, 0x27, 0x50, 0x71, 0x50, 0xbb,
+    0x4f, 0xdd, 0x50, 0x27, 0x50, 0x71, 0x50, 0xbb,
-	0x51, 0x06, 0x51, 0x50, 0x51, 0x9b, 0x51, 0xe6,
+    0x51, 0x06, 0x51, 0x50, 0x51, 0x9b, 0x51, 0xe6,
-	0x52, 0x31, 0x52, 0x7c, 0x52, 0xc7, 0x53, 0x13,
+    0x52, 0x31, 0x52, 0x7c, 0x52, 0xc7, 0x53, 0x13,
-	0x53, 0x5f, 0x53, 0xaa, 0x53, 0xf6, 0x54, 0x42,
+    0x53, 0x5f, 0x53, 0xaa, 0x53, 0xf6, 0x54, 0x42,
-	0x54, 0x8f, 0x54, 0xdb, 0x55, 0x28, 0x55, 0x75,
+    0x54, 0x8f, 0x54, 0xdb, 0x55, 0x28, 0x55, 0x75,
-	0x55, 0xc2, 0x56, 0x0f, 0x56, 0x5c, 0x56, 0xa9,
+    0x55, 0xc2, 0x56, 0x0f, 0x56, 0x5c, 0x56, 0xa9,
-	0x56, 0xf7, 0x57, 0x44, 0x57, 0x92, 0x57, 0xe0,
+    0x56, 0xf7, 0x57, 0x44, 0x57, 0x92, 0x57, 0xe0,
-	0x58, 0x2f, 0x58, 0x7d, 0x58, 0xcb, 0x59, 0x1a,
+    0x58, 0x2f, 0x58, 0x7d, 0x58, 0xcb, 0x59, 0x1a,
-	0x59, 0x69, 0x59, 0xb8, 0x5a, 0x07, 0x5a, 0x56,
+    0x59, 0x69, 0x59, 0xb8, 0x5a, 0x07, 0x5a, 0x56,
-	0x5a, 0xa6, 0x5a, 0xf5, 0x5b, 0x45, 0x5b, 0x95,
+    0x5a, 0xa6, 0x5a, 0xf5, 0x5b, 0x45, 0x5b, 0x95,
-	0x5b, 0xe5, 0x5c, 0x35, 0x5c, 0x86, 0x5c, 0xd6,
+    0x5b, 0xe5, 0x5c, 0x35, 0x5c, 0x86, 0x5c, 0xd6,
-	0x5d, 0x27, 0x5d, 0x78, 0x5d, 0xc9, 0x5e, 0x1a,
+    0x5d, 0x27, 0x5d, 0x78, 0x5d, 0xc9, 0x5e, 0x1a,
-	0x5e, 0x6c, 0x5e, 0xbd, 0x5f, 0x0f, 0x5f, 0x61,
+    0x5e, 0x6c, 0x5e, 0xbd, 0x5f, 0x0f, 0x5f, 0x61,
-	0x5f, 0xb3, 0x60, 0x05, 0x60, 0x57, 0x60, 0xaa,
+    0x5f, 0xb3, 0x60, 0x05, 0x60, 0x57, 0x60, 0xaa,
-	0x60, 0xfc, 0x61, 0x4f, 0x61, 0xa2, 0x61, 0xf5,
+    0x60, 0xfc, 0x61, 0x4f, 0x61, 0xa2, 0x61, 0xf5,
-	0x62, 0x49, 0x62, 0x9c, 0x62, 0xf0, 0x63, 0x43,
+    0x62, 0x49, 0x62, 0x9c, 0x62, 0xf0, 0x63, 0x43,
-	0x63, 0x97, 0x63, 0xeb, 0x64, 0x40, 0x64, 0x94,
+    0x63, 0x97, 0x63, 0xeb, 0x64, 0x40, 0x64, 0x94,
-	0x64, 0xe9, 0x65, 0x3d, 0x65, 0x92, 0x65, 0xe7,
+    0x64, 0xe9, 0x65, 0x3d, 0x65, 0x92, 0x65, 0xe7,
-	0x66, 0x3d, 0x66, 0x92, 0x66, 0xe8, 0x67, 0x3d,
+    0x66, 0x3d, 0x66, 0x92, 0x66, 0xe8, 0x67, 0x3d,
-	0x67, 0x93, 0x67, 0xe9, 0x68, 0x3f, 0x68, 0x96,
+    0x67, 0x93, 0x67, 0xe9, 0x68, 0x3f, 0x68, 0x96,
-	0x68, 0xec, 0x69, 0x43, 0x69, 0x9a, 0x69, 0xf1,
+    0x68, 0xec, 0x69, 0x43, 0x69, 0x9a, 0x69, 0xf1,
-	0x6a, 0x48, 0x6a, 0x9f, 0x6a, 0xf7, 0x6b, 0x4f,
+    0x6a, 0x48, 0x6a, 0x9f, 0x6a, 0xf7, 0x6b, 0x4f,
-	0x6b, 0xa7, 0x6b, 0xff, 0x6c, 0x57, 0x6c, 0xaf,
+    0x6b, 0xa7, 0x6b, 0xff, 0x6c, 0x57, 0x6c, 0xaf,
-	0x6d, 0x08, 0x6d, 0x60, 0x6d, 0xb9, 0x6e, 0x12,
+    0x6d, 0x08, 0x6d, 0x60, 0x6d, 0xb9, 0x6e, 0x12,
-	0x6e, 0x6b, 0x6e, 0xc4, 0x6f, 0x1e, 0x6f, 0x78,
+    0x6e, 0x6b, 0x6e, 0xc4, 0x6f, 0x1e, 0x6f, 0x78,
-	0x6f, 0xd1, 0x70, 0x2b, 0x70, 0x86, 0x70, 0xe0,
+    0x6f, 0xd1, 0x70, 0x2b, 0x70, 0x86, 0x70, 0xe0,
-	0x71, 0x3a, 0x71, 0x95, 0x71, 0xf0, 0x72, 0x4b,
+    0x71, 0x3a, 0x71, 0x95, 0x71, 0xf0, 0x72, 0x4b,
-	0x72, 0xa6, 0x73, 0x01, 0x73, 0x5d, 0x73, 0xb8,
+    0x72, 0xa6, 0x73, 0x01, 0x73, 0x5d, 0x73, 0xb8,
-	0x74, 0x14, 0x74, 0x70, 0x74, 0xcc, 0x75, 0x28,
+    0x74, 0x14, 0x74, 0x70, 0x74, 0xcc, 0x75, 0x28,
-	0x75, 0x85, 0x75, 0xe1, 0x76, 0x3e, 0x76, 0x9b,
+    0x75, 0x85, 0x75, 0xe1, 0x76, 0x3e, 0x76, 0x9b,
-	0x76, 0xf8, 0x77, 0x56, 0x77, 0xb3, 0x78, 0x11,
+    0x76, 0xf8, 0x77, 0x56, 0x77, 0xb3, 0x78, 0x11,
-	0x78, 0x6e, 0x78, 0xcc, 0x79, 0x2a, 0x79, 0x89,
+    0x78, 0x6e, 0x78, 0xcc, 0x79, 0x2a, 0x79, 0x89,
-	0x79, 0xe7, 0x7a, 0x46, 0x7a, 0xa5, 0x7b, 0x04,
+    0x79, 0xe7, 0x7a, 0x46, 0x7a, 0xa5, 0x7b, 0x04,
-	0x7b, 0x63, 0x7b, 0xc2, 0x7c, 0x21, 0x7c, 0x81,
+    0x7b, 0x63, 0x7b, 0xc2, 0x7c, 0x21, 0x7c, 0x81,
-	0x7c, 0xe1, 0x7d, 0x41, 0x7d, 0xa1, 0x7e, 0x01,
+    0x7c, 0xe1, 0x7d, 0x41, 0x7d, 0xa1, 0x7e, 0x01,
-	0x7e, 0x62, 0x7e, 0xc2, 0x7f, 0x23, 0x7f, 0x84,
+    0x7e, 0x62, 0x7e, 0xc2, 0x7f, 0x23, 0x7f, 0x84,
-	0x7f, 0xe5, 0x80, 0x47, 0x80, 0xa8, 0x81, 0x0a,
+    0x7f, 0xe5, 0x80, 0x47, 0x80, 0xa8, 0x81, 0x0a,
-	0x81, 0x6b, 0x81, 0xcd, 0x82, 0x30, 0x82, 0x92,
+    0x81, 0x6b, 0x81, 0xcd, 0x82, 0x30, 0x82, 0x92,
-	0x82, 0xf4, 0x83, 0x57, 0x83, 0xba, 0x84, 0x1d,
+    0x82, 0xf4, 0x83, 0x57, 0x83, 0xba, 0x84, 0x1d,
-	0x84, 0x80, 0x84, 0xe3, 0x85, 0x47, 0x85, 0xab,
+    0x84, 0x80, 0x84, 0xe3, 0x85, 0x47, 0x85, 0xab,
-	0x86, 0x0e, 0x86, 0x72, 0x86, 0xd7, 0x87, 0x3b,
+    0x86, 0x0e, 0x86, 0x72, 0x86, 0xd7, 0x87, 0x3b,
-	0x87, 0x9f, 0x88, 0x04, 0x88, 0x69, 0x88, 0xce,
+    0x87, 0x9f, 0x88, 0x04, 0x88, 0x69, 0x88, 0xce,
-	0x89, 0x33, 0x89, 0x99, 0x89, 0xfe, 0x8a, 0x64,
+    0x89, 0x33, 0x89, 0x99, 0x89, 0xfe, 0x8a, 0x64,
-	0x8a, 0xca, 0x8b, 0x30, 0x8b, 0x96, 0x8b, 0xfc,
+    0x8a, 0xca, 0x8b, 0x30, 0x8b, 0x96, 0x8b, 0xfc,
-	0x8c, 0x63, 0x8c, 0xca, 0x8d, 0x31, 0x8d, 0x98,
+    0x8c, 0x63, 0x8c, 0xca, 0x8d, 0x31, 0x8d, 0x98,
-	0x8d, 0xff, 0x8e, 0x66, 0x8e, 0xce, 0x8f, 0x36,
+    0x8d, 0xff, 0x8e, 0x66, 0x8e, 0xce, 0x8f, 0x36,
-	0x8f, 0x9e, 0x90, 0x06, 0x90, 0x6e, 0x90, 0xd6,
+    0x8f, 0x9e, 0x90, 0x06, 0x90, 0x6e, 0x90, 0xd6,
-	0x91, 0x3f, 0x91, 0xa8, 0x92, 0x11, 0x92, 0x7a,
+    0x91, 0x3f, 0x91, 0xa8, 0x92, 0x11, 0x92, 0x7a,
-	0x92, 0xe3, 0x93, 0x4d, 0x93, 0xb6, 0x94, 0x20,
+    0x92, 0xe3, 0x93, 0x4d, 0x93, 0xb6, 0x94, 0x20,
-	0x94, 0x8a, 0x94, 0xf4, 0x95, 0x5f, 0x95, 0xc9,
+    0x94, 0x8a, 0x94, 0xf4, 0x95, 0x5f, 0x95, 0xc9,
-	0x96, 0x34, 0x96, 0x9f, 0x97, 0x0a, 0x97, 0x75,
+    0x96, 0x34, 0x96, 0x9f, 0x97, 0x0a, 0x97, 0x75,
-	0x97, 0xe0, 0x98, 0x4c, 0x98, 0xb8, 0x99, 0x24,
+    0x97, 0xe0, 0x98, 0x4c, 0x98, 0xb8, 0x99, 0x24,
-	0x99, 0x90, 0x99, 0xfc, 0x9a, 0x68, 0x9a, 0xd5,
+    0x99, 0x90, 0x99, 0xfc, 0x9a, 0x68, 0x9a, 0xd5,
-	0x9b, 0x42, 0x9b, 0xaf, 0x9c, 0x1c, 0x9c, 0x89,
+    0x9b, 0x42, 0x9b, 0xaf, 0x9c, 0x1c, 0x9c, 0x89,
-	0x9c, 0xf7, 0x9d, 0x64, 0x9d, 0xd2, 0x9e, 0x40,
+    0x9c, 0xf7, 0x9d, 0x64, 0x9d, 0xd2, 0x9e, 0x40,
-	0x9e, 0xae, 0x9f, 0x1d, 0x9f, 0x8b, 0x9f, 0xfa,
+    0x9e, 0xae, 0x9f, 0x1d, 0x9f, 0x8b, 0x9f, 0xfa,
-	0xa0, 0x69, 0xa0, 0xd8, 0xa1, 0x47, 0xa1, 0xb6,
+    0xa0, 0x69, 0xa0, 0xd8, 0xa1, 0x47, 0xa1, 0xb6,
-	0xa2, 0x26, 0xa2, 0x96, 0xa3, 0x06, 0xa3, 0x76,
+    0xa2, 0x26, 0xa2, 0x96, 0xa3, 0x06, 0xa3, 0x76,
-	0xa3, 0xe6, 0xa4, 0x56, 0xa4, 0xc7, 0xa5, 0x38,
+    0xa3, 0xe6, 0xa4, 0x56, 0xa4, 0xc7, 0xa5, 0x38,
-	0xa5, 0xa9, 0xa6, 0x1a, 0xa6, 0x8b, 0xa6, 0xfd,
+    0xa5, 0xa9, 0xa6, 0x1a, 0xa6, 0x8b, 0xa6, 0xfd,
-	0xa7, 0x6e, 0xa7, 0xe0, 0xa8, 0x52, 0xa8, 0xc4,
+    0xa7, 0x6e, 0xa7, 0xe0, 0xa8, 0x52, 0xa8, 0xc4,
-	0xa9, 0x37, 0xa9, 0xa9, 0xaa, 0x1c, 0xaa, 0x8f,
+    0xa9, 0x37, 0xa9, 0xa9, 0xaa, 0x1c, 0xaa, 0x8f,
-	0xab, 0x02, 0xab, 0x75, 0xab, 0xe9, 0xac, 0x5c,
+    0xab, 0x02, 0xab, 0x75, 0xab, 0xe9, 0xac, 0x5c,
-	0xac, 0xd0, 0xad, 0x44, 0xad, 0xb8, 0xae, 0x2d,
+    0xac, 0xd0, 0xad, 0x44, 0xad, 0xb8, 0xae, 0x2d,
-	0xae, 0xa1, 0xaf, 0x16, 0xaf, 0x8b, 0xb0, 0x00,
+    0xae, 0xa1, 0xaf, 0x16, 0xaf, 0x8b, 0xb0, 0x00,
-	0xb0, 0x75, 0xb0, 0xea, 0xb1, 0x60, 0xb1, 0xd6,
+    0xb0, 0x75, 0xb0, 0xea, 0xb1, 0x60, 0xb1, 0xd6,
-	0xb2, 0x4b, 0xb2, 0xc2, 0xb3, 0x38, 0xb3, 0xae,
+    0xb2, 0x4b, 0xb2, 0xc2, 0xb3, 0x38, 0xb3, 0xae,
-	0xb4, 0x25, 0xb4, 0x9c, 0xb5, 0x13, 0xb5, 0x8a,
+    0xb4, 0x25, 0xb4, 0x9c, 0xb5, 0x13, 0xb5, 0x8a,
-	0xb6, 0x01, 0xb6, 0x79, 0xb6, 0xf0, 0xb7, 0x68,
+    0xb6, 0x01, 0xb6, 0x79, 0xb6, 0xf0, 0xb7, 0x68,
-	0xb7, 0xe0, 0xb8, 0x59, 0xb8, 0xd1, 0xb9, 0x4a,
+    0xb7, 0xe0, 0xb8, 0x59, 0xb8, 0xd1, 0xb9, 0x4a,
-	0xb9, 0xc2, 0xba, 0x3b, 0xba, 0xb5, 0xbb, 0x2e,
+    0xb9, 0xc2, 0xba, 0x3b, 0xba, 0xb5, 0xbb, 0x2e,
-	0xbb, 0xa7, 0xbc, 0x21, 0xbc, 0x9b, 0xbd, 0x15,
+    0xbb, 0xa7, 0xbc, 0x21, 0xbc, 0x9b, 0xbd, 0x15,
-	0xbd, 0x8f, 0xbe, 0x0a, 0xbe, 0x84, 0xbe, 0xff,
+    0xbd, 0x8f, 0xbe, 0x0a, 0xbe, 0x84, 0xbe, 0xff,
-	0xbf, 0x7a, 0xbf, 0xf5, 0xc0, 0x70, 0xc0, 0xec,
+    0xbf, 0x7a, 0xbf, 0xf5, 0xc0, 0x70, 0xc0, 0xec,
-	0xc1, 0x67, 0xc1, 0xe3, 0xc2, 0x5f, 0xc2, 0xdb,
+    0xc1, 0x67, 0xc1, 0xe3, 0xc2, 0x5f, 0xc2, 0xdb,
-	0xc3, 0x58, 0xc3, 0xd4, 0xc4, 0x51, 0xc4, 0xce,
+    0xc3, 0x58, 0xc3, 0xd4, 0xc4, 0x51, 0xc4, 0xce,
-	0xc5, 0x4b, 0xc5, 0xc8, 0xc6, 0x46, 0xc6, 0xc3,
+    0xc5, 0x4b, 0xc5, 0xc8, 0xc6, 0x46, 0xc6, 0xc3,
-	0xc7, 0x41, 0xc7, 0xbf, 0xc8, 0x3d, 0xc8, 0xbc,
+    0xc7, 0x41, 0xc7, 0xbf, 0xc8, 0x3d, 0xc8, 0xbc,
-	0xc9, 0x3a, 0xc9, 0xb9, 0xca, 0x38, 0xca, 0xb7,
+    0xc9, 0x3a, 0xc9, 0xb9, 0xca, 0x38, 0xca, 0xb7,
-	0xcb, 0x36, 0xcb, 0xb6, 0xcc, 0x35, 0xcc, 0xb5,
+    0xcb, 0x36, 0xcb, 0xb6, 0xcc, 0x35, 0xcc, 0xb5,
-	0xcd, 0x35, 0xcd, 0xb5, 0xce, 0x36, 0xce, 0xb6,
+    0xcd, 0x35, 0xcd, 0xb5, 0xce, 0x36, 0xce, 0xb6,
-	0xcf, 0x37, 0xcf, 0xb8, 0xd0, 0x39, 0xd0, 0xba,
+    0xcf, 0x37, 0xcf, 0xb8, 0xd0, 0x39, 0xd0, 0xba,
-	0xd1, 0x3c, 0xd1, 0xbe, 0xd2, 0x3f, 0xd2, 0xc1,
+    0xd1, 0x3c, 0xd1, 0xbe, 0xd2, 0x3f, 0xd2, 0xc1,
-	0xd3, 0x44, 0xd3, 0xc6, 0xd4, 0x49, 0xd4, 0xcb,
+    0xd3, 0x44, 0xd3, 0xc6, 0xd4, 0x49, 0xd4, 0xcb,
-	0xd5, 0x4e, 0xd5, 0xd1, 0xd6, 0x55, 0xd6, 0xd8,
+    0xd5, 0x4e, 0xd5, 0xd1, 0xd6, 0x55, 0xd6, 0xd8,
-	0xd7, 0x5c, 0xd7, 0xe0, 0xd8, 0x64, 0xd8, 0xe8,
+    0xd7, 0x5c, 0xd7, 0xe0, 0xd8, 0x64, 0xd8, 0xe8,
-	0xd9, 0x6c, 0xd9, 0xf1, 0xda, 0x76, 0xda, 0xfb,
+    0xd9, 0x6c, 0xd9, 0xf1, 0xda, 0x76, 0xda, 0xfb,
-	0xdb, 0x80, 0xdc, 0x05, 0xdc, 0x8a, 0xdd, 0x10,
+    0xdb, 0x80, 0xdc, 0x05, 0xdc, 0x8a, 0xdd, 0x10,
-	0xdd, 0x96, 0xde, 0x1c, 0xde, 0xa2, 0xdf, 0x29,
+    0xdd, 0x96, 0xde, 0x1c, 0xde, 0xa2, 0xdf, 0x29,
-	0xdf, 0xaf, 0xe0, 0x36, 0xe0, 0xbd, 0xe1, 0x44,
+    0xdf, 0xaf, 0xe0, 0x36, 0xe0, 0xbd, 0xe1, 0x44,
-	0xe1, 0xcc, 0xe2, 0x53, 0xe2, 0xdb, 0xe3, 0x63,
+    0xe1, 0xcc, 0xe2, 0x53, 0xe2, 0xdb, 0xe3, 0x63,
-	0xe3, 0xeb, 0xe4, 0x73, 0xe4, 0xfc, 0xe5, 0x84,
+    0xe3, 0xeb, 0xe4, 0x73, 0xe4, 0xfc, 0xe5, 0x84,
-	0xe6, 0x0d, 0xe6, 0x96, 0xe7, 0x1f, 0xe7, 0xa9,
+    0xe6, 0x0d, 0xe6, 0x96, 0xe7, 0x1f, 0xe7, 0xa9,
-	0xe8, 0x32, 0xe8, 0xbc, 0xe9, 0x46, 0xe9, 0xd0,
+    0xe8, 0x32, 0xe8, 0xbc, 0xe9, 0x46, 0xe9, 0xd0,
-	0xea, 0x5b, 0xea, 0xe5, 0xeb, 0x70, 0xeb, 0xfb,
+    0xea, 0x5b, 0xea, 0xe5, 0xeb, 0x70, 0xeb, 0xfb,
-	0xec, 0x86, 0xed, 0x11, 0xed, 0x9c, 0xee, 0x28,
+    0xec, 0x86, 0xed, 0x11, 0xed, 0x9c, 0xee, 0x28,
-	0xee, 0xb4, 0xef, 0x40, 0xef, 0xcc, 0xf0, 0x58,
+    0xee, 0xb4, 0xef, 0x40, 0xef, 0xcc, 0xf0, 0x58,
-	0xf0, 0xe5, 0xf1, 0x72, 0xf1, 0xff, 0xf2, 0x8c,
+    0xf0, 0xe5, 0xf1, 0x72, 0xf1, 0xff, 0xf2, 0x8c,
-	0xf3, 0x19, 0xf3, 0xa7, 0xf4, 0x34, 0xf4, 0xc2,
+    0xf3, 0x19, 0xf3, 0xa7, 0xf4, 0x34, 0xf4, 0xc2,
-	0xf5, 0x50, 0xf5, 0xde, 0xf6, 0x6d, 0xf6, 0xfb,
+    0xf5, 0x50, 0xf5, 0xde, 0xf6, 0x6d, 0xf6, 0xfb,
-	0xf7, 0x8a, 0xf8, 0x19, 0xf8, 0xa8, 0xf9, 0x38,
+    0xf7, 0x8a, 0xf8, 0x19, 0xf8, 0xa8, 0xf9, 0x38,
-	0xf9, 0xc7, 0xfa, 0x57, 0xfa, 0xe7, 0xfb, 0x77,
+    0xf9, 0xc7, 0xfa, 0x57, 0xfa, 0xe7, 0xfb, 0x77,
-	0xfc, 0x07, 0xfc, 0x98, 0xfd, 0x29, 0xfd, 0xba,
+    0xfc, 0x07, 0xfc, 0x98, 0xfd, 0x29, 0xfd, 0xba,
-	0xfe, 0x4b, 0xfe, 0xdc, 0xff, 0x6d, 0xff, 0xff
+    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,
+    0x00, 0x00, 0x01, 0x8a, 0x00, 0x00, 0x00, 0x00,
-	0x02, 0x20, 0x00, 0x00, 0x73, 0x63, 0x6e, 0x72,
+    0x02, 0x20, 0x00, 0x00, 0x73, 0x63, 0x6e, 0x72,
-	0x47, 0x52, 0x41, 0x59, 0x58, 0x59, 0x5a, 0x20,
+    0x47, 0x52, 0x41, 0x59, 0x58, 0x59, 0x5a, 0x20,
-	0x07, 0xd3, 0x00, 0x01, 0x00, 0x1f, 0x00, 0x0d,
+    0x07, 0xd3, 0x00, 0x01, 0x00, 0x1f, 0x00, 0x0d,
-	0x00, 0x35, 0x00, 0x21, 0x61, 0x63, 0x73, 0x70,
+    0x00, 0x35, 0x00, 0x21, 0x61, 0x63, 0x73, 0x70,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
-	0x4b, 0x4f, 0x44, 0x41, 0x73, 0x47, 0x72, 0x79,
+    0x4b, 0x4f, 0x44, 0x41, 0x73, 0x47, 0x72, 0x79,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf6, 0xd6,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf6, 0xd6,
-	0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0xd3, 0x2d,
+    0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0xd3, 0x2d,
-	0x4a, 0x50, 0x45, 0x47, 0x00, 0x00, 0x00, 0x00,
+    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, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 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, 0x04, 0x64, 0x65, 0x73, 0x63,
-	0x00, 0x00, 0x00, 0xb4, 0x00, 0x00, 0x00, 0x86,
+    0x00, 0x00, 0x00, 0xb4, 0x00, 0x00, 0x00, 0x86,
-	0x63, 0x70, 0x72, 0x74, 0x00, 0x00, 0x01, 0x3c,
+    0x63, 0x70, 0x72, 0x74, 0x00, 0x00, 0x01, 0x3c,
-	0x00, 0x00, 0x00, 0x2b, 0x77, 0x74, 0x70, 0x74,
+    0x00, 0x00, 0x00, 0x2b, 0x77, 0x74, 0x70, 0x74,
-	0x00, 0x00, 0x01, 0x68, 0x00, 0x00, 0x00, 0x14,
+    0x00, 0x00, 0x01, 0x68, 0x00, 0x00, 0x00, 0x14,
-	0x6b, 0x54, 0x52, 0x43, 0x00, 0x00, 0x01, 0x7c,
+    0x6b, 0x54, 0x52, 0x43, 0x00, 0x00, 0x01, 0x7c,
-	0x00, 0x00, 0x00, 0x0e, 0x64, 0x65, 0x73, 0x63,
+    0x00, 0x00, 0x00, 0x0e, 0x64, 0x65, 0x73, 0x63,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x2c,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x2c,
-	0x52, 0x65, 0x73, 0x74, 0x72, 0x69, 0x63, 0x74,
+    0x52, 0x65, 0x73, 0x74, 0x72, 0x69, 0x63, 0x74,
-	0x65, 0x64, 0x20, 0x49, 0x43, 0x43, 0x20, 0x70,
+    0x65, 0x64, 0x20, 0x49, 0x43, 0x43, 0x20, 0x70,
-	0x72, 0x6f, 0x66, 0x69, 0x6c, 0x65, 0x20, 0x64,
+    0x72, 0x6f, 0x66, 0x69, 0x6c, 0x65, 0x20, 0x64,
-	0x65, 0x73, 0x63, 0x72, 0x69, 0x62, 0x69, 0x6e,
+    0x65, 0x73, 0x63, 0x72, 0x69, 0x62, 0x69, 0x6e,
-	0x67, 0x20, 0x73, 0x52, 0x47, 0x42, 0x2d, 0x67,
+    0x67, 0x20, 0x73, 0x52, 0x47, 0x42, 0x2d, 0x67,
-	0x72, 0x65, 0x79, 0x00, 0x00, 0x00, 0x00, 0x00,
+    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, 0x00, 0x00, 0x00, 0x00,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 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, 0x74, 0x65, 0x78, 0x74,
-	0x00, 0x00, 0x00, 0x00, 0x43, 0x6f, 0x70, 0x79,
+    0x00, 0x00, 0x00, 0x00, 0x43, 0x6f, 0x70, 0x79,
-	0x72, 0x69, 0x67, 0x68, 0x74, 0x20, 0x32, 0x30,
+    0x72, 0x69, 0x67, 0x68, 0x74, 0x20, 0x32, 0x30,
-	0x30, 0x33, 0x20, 0x73, 0x52, 0x47, 0x42, 0x2d,
+    0x30, 0x33, 0x20, 0x73, 0x52, 0x47, 0x42, 0x2d,
-	0x67, 0x72, 0x65, 0x79, 0x20, 0x52, 0x65, 0x66,
+    0x67, 0x72, 0x65, 0x79, 0x20, 0x52, 0x65, 0x66,
-	0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x00, 0x00,
+    0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x00, 0x00,
-	0x58, 0x59, 0x5a, 0x20, 0x00, 0x00, 0x00, 0x00,
+    0x58, 0x59, 0x5a, 0x20, 0x00, 0x00, 0x00, 0x00,
-	0x00, 0x00, 0xf3, 0x54, 0x00, 0x01, 0x00, 0x00,
+    0x00, 0x00, 0xf3, 0x54, 0x00, 0x01, 0x00, 0x00,
-	0x00, 0x01, 0x16, 0xcf, 0x63, 0x75, 0x72, 0x76,
+    0x00, 0x01, 0x16, 0xcf, 0x63, 0x75, 0x72, 0x76,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
-	0x01, 0xcd
+    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;
+    jas_image_fmtops_t fmtops;
-	int fmtid;
+    int fmtid;
 
-	fmtid = 0;
+    fmtid = 0;
 
 #if !defined(EXCLUDE_MIF_SUPPORT)
-	fmtops.decode = mif_decode;
+    fmtops.decode = mif_decode;
-	fmtops.encode = mif_encode;
+    fmtops.encode = mif_encode;
-	fmtops.validate = mif_validate;
+    fmtops.validate = mif_validate;
-	jas_image_addfmt(fmtid, "mif", "mif", "My Image Format (MIF)", &fmtops);
+    jas_image_addfmt(fmtid, "mif", "mif", "My Image Format (MIF)", &fmtops);
-	++fmtid;
+    ++fmtid;
 #endif
 
 #if !defined(EXCLUDE_PNM_SUPPORT)
-	fmtops.decode = pnm_decode;
+    fmtops.decode = pnm_decode;
-	fmtops.encode = pnm_encode;
+    fmtops.encode = pnm_encode;
-	fmtops.validate = pnm_validate;
+    fmtops.validate = pnm_validate;
-	jas_image_addfmt(fmtid, "pnm", "pnm", "Portable Graymap/Pixmap (PNM)",
+    jas_image_addfmt(fmtid, "pnm", "pnm", "Portable Graymap/Pixmap (PNM)",
-	  &fmtops);
+      &fmtops);
-	jas_image_addfmt(fmtid, "pnm", "pgm", "Portable Graymap/Pixmap (PNM)",
+    jas_image_addfmt(fmtid, "pnm", "pgm", "Portable Graymap/Pixmap (PNM)",
-	  &fmtops);
+      &fmtops);
-	jas_image_addfmt(fmtid, "pnm", "ppm", "Portable Graymap/Pixmap (PNM)",
+    jas_image_addfmt(fmtid, "pnm", "ppm", "Portable Graymap/Pixmap (PNM)",
-	  &fmtops);
+      &fmtops);
-	++fmtid;
+    ++fmtid;
 #endif
 
 #if !defined(EXCLUDE_BMP_SUPPORT)
-	fmtops.decode = bmp_decode;
+    fmtops.decode = bmp_decode;
-	fmtops.encode = bmp_encode;
+    fmtops.encode = bmp_encode;
-	fmtops.validate = bmp_validate;
+    fmtops.validate = bmp_validate;
-	jas_image_addfmt(fmtid, "bmp", "bmp", "Microsoft Bitmap (BMP)", &fmtops);
+    jas_image_addfmt(fmtid, "bmp", "bmp", "Microsoft Bitmap (BMP)", &fmtops);
-	++fmtid;
+    ++fmtid;
 #endif
 
 #if !defined(EXCLUDE_RAS_SUPPORT)
-	fmtops.decode = ras_decode;
+    fmtops.decode = ras_decode;
-	fmtops.encode = ras_encode;
+    fmtops.encode = ras_encode;
-	fmtops.validate = ras_validate;
+    fmtops.validate = ras_validate;
-	jas_image_addfmt(fmtid, "ras", "ras", "Sun Rasterfile (RAS)", &fmtops);
+    jas_image_addfmt(fmtid, "ras", "ras", "Sun Rasterfile (RAS)", &fmtops);
-	++fmtid;
+    ++fmtid;
 #endif
 
 #if !defined(EXCLUDE_JP2_SUPPORT)
-	fmtops.decode = jp2_decode;
+    fmtops.decode = jp2_decode;
-	fmtops.encode = jp2_encode;
+    fmtops.encode = jp2_encode;
-	fmtops.validate = jp2_validate;
+    fmtops.validate = jp2_validate;
-	jas_image_addfmt(fmtid, "jp2", "jp2",
+    jas_image_addfmt(fmtid, "jp2", "jp2",
-	  "JPEG-2000 JP2 File Format Syntax (ISO/IEC 15444-1)", &fmtops);
+      "JPEG-2000 JP2 File Format Syntax (ISO/IEC 15444-1)", &fmtops);
-	++fmtid;
+    ++fmtid;
-	fmtops.decode = jpc_decode;
+    fmtops.decode = jpc_decode;
-	fmtops.encode = jpc_encode;
+    fmtops.encode = jpc_encode;
-	fmtops.validate = jpc_validate;
+    fmtops.validate = jpc_validate;
-	jas_image_addfmt(fmtid, "jpc", "jpc",
+    jas_image_addfmt(fmtid, "jpc", "jpc",
-	  "JPEG-2000 Code Stream Syntax (ISO/IEC 15444-1)", &fmtops);
+      "JPEG-2000 Code Stream Syntax (ISO/IEC 15444-1)", &fmtops);
-	++fmtid;
+    ++fmtid;
 #endif
 
 #if !defined(EXCLUDE_JPG_SUPPORT)
-	fmtops.decode = jpg_decode;
+    fmtops.decode = jpg_decode;
-	fmtops.encode = jpg_encode;
+    fmtops.encode = jpg_encode;
-	fmtops.validate = jpg_validate;
+    fmtops.validate = jpg_validate;
-	jas_image_addfmt(fmtid, "jpg", "jpg", "JPEG (ISO/IEC 10918-1)", &fmtops);
+    jas_image_addfmt(fmtid, "jpg", "jpg", "JPEG (ISO/IEC 10918-1)", &fmtops);
-	++fmtid;
+    ++fmtid;
 #endif
 
 #if !defined(EXCLUDE_PGX_SUPPORT)
-	fmtops.decode = pgx_decode;
+    fmtops.decode = pgx_decode;
-	fmtops.encode = pgx_encode;
+    fmtops.encode = pgx_encode;
-	fmtops.validate = pgx_validate;
+    fmtops.validate = pgx_validate;
-	jas_image_addfmt(fmtid, "pgx", "pgx", "JPEG-2000 VM Format (PGX)", &fmtops);
+    jas_image_addfmt(fmtid, "pgx", "pgx", "JPEG-2000 VM Format (PGX)", &fmtops);
-	++fmtid;
+    ++fmtid;
 #endif
 
-	/* We must not register the JasPer library exit handler until after
+    /* We must not register the JasPer library exit handler until after
-	at least one memory allocation is performed.  This is desirable
+    at least one memory allocation is performed.  This is desirable
-	as it ensures that the JasPer exit handler is called before the
+    as it ensures that the JasPer exit handler is called before the
-	debug memory allocator exit handler. */
+    debug memory allocator exit handler. */
-	atexit(jas_cleanup);
+    atexit(jas_cleanup);
 
-	return 0;
+    return 0;
 }
 
 void jas_cleanup()
 {
-	jas_image_clearfmts();
+    jas_image_clearfmts();
 }

3rdparty/libjasper/jas_malloc.c

@@ -6,15 +6,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,
@@ -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__
  */
 
@@ -101,68 +101,68 @@
 void *jas_malloc(size_t size)
 {
 #if defined(MEMALLOC_ALIGN2)
-	void *ptr;
+    void *ptr;
 abort();
-	if (posix_memalign(&ptr, MEMALLOC_ALIGNMENT, size)) {
+    if (posix_memalign(&ptr, MEMALLOC_ALIGNMENT, size)) {
-		return 0;
+        return 0;
-	}
+    }
-	return ptr;
+    return ptr;
 #endif
-	return malloc(size);
+    return malloc(size);
 }
 
 void jas_free(void *ptr)
 {
-	free(ptr);
+    free(ptr);
 }
 
 void *jas_realloc(void *ptr, size_t size)
 {
-	return ptr ? realloc(ptr, size) : malloc(size);
+    return ptr ? realloc(ptr, size) : malloc(size);
 }
 
 void *jas_realloc2(void *ptr, size_t nmemb, size_t size)
 {
-	if (!ptr)
+    if (!ptr)
-		return jas_alloc2(nmemb, size);
+        return jas_alloc2(nmemb, size);
-	if (nmemb && SIZE_MAX / nmemb < size) {
+    if (nmemb && SIZE_MAX / nmemb < size) {
-		errno = ENOMEM;
+        errno = ENOMEM;
-		return NULL;
+        return NULL;
-	}
+    }
-	return jas_realloc(ptr, nmemb * size);
+    return jas_realloc(ptr, nmemb * size);
 
 }
 
 void *jas_alloc2(size_t nmemb, size_t size)
 {
-	if (nmemb && SIZE_MAX / nmemb < size) {
+    if (nmemb && SIZE_MAX / nmemb < size) {
-		errno = ENOMEM;
+        errno = ENOMEM;
-		return NULL;
+        return NULL;
-	}
+    }
 
-	return jas_malloc(nmemb * size);
+    return jas_malloc(nmemb * size);
 }
 
 void *jas_alloc3(size_t a, size_t b, size_t c)
 {
-	size_t n;
+    size_t n;
 
-	if (a && SIZE_MAX / a < b) {
+    if (a && SIZE_MAX / a < b) {
-		errno = ENOMEM;
+        errno = ENOMEM;
-		return NULL;
+        return NULL;
-	}
+    }
 
-	return jas_alloc2(a*b, c);
+    return jas_alloc2(a*b, c);
 }
 
 void *jas_calloc(size_t nmemb, size_t size)
 {
-	void *ptr;
+    void *ptr;
 
-	ptr = jas_alloc2(nmemb, size);
+    ptr = jas_alloc2(nmemb, size);
-	if (ptr)
+    if (ptr)
-		memset(ptr, 0, nmemb*size);
+        memset(ptr, 0, nmemb*size);
-	return ptr;
+    return ptr;
 }
 
 #endif

3rdparty/libjasper/jas_seq.c

@@ -6,15 +6,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,
@@ -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__
  */
 
@@ -85,108 +85,108 @@
 
 jas_matrix_t *jas_seq2d_create(int xstart, int ystart, int xend, int yend)
 {
-	jas_matrix_t *matrix;
+    jas_matrix_t *matrix;
-	assert(xstart <= xend && ystart <= yend);
+    assert(xstart <= xend && ystart <= yend);
-	if (!(matrix = jas_matrix_create(yend - ystart, xend - xstart))) {
+    if (!(matrix = jas_matrix_create(yend - ystart, xend - xstart))) {
-		return 0;
+        return 0;
-	}
+    }
-	matrix->xstart_ = xstart;
+    matrix->xstart_ = xstart;
-	matrix->ystart_ = ystart;
+    matrix->ystart_ = ystart;
-	matrix->xend_ = xend;
+    matrix->xend_ = xend;
-	matrix->yend_ = yend;
+    matrix->yend_ = yend;
-	return matrix;
+    return matrix;
 }
 
 jas_matrix_t *jas_matrix_create(int numrows, int numcols)
 {
-	jas_matrix_t *matrix;
+    jas_matrix_t *matrix;
-	int i;
+    int i;
 
-	if (!(matrix = jas_malloc(sizeof(jas_matrix_t)))) {
+    if (!(matrix = jas_malloc(sizeof(jas_matrix_t)))) {
-		return 0;
+        return 0;
-	}
+    }
-	matrix->flags_ = 0;
+    matrix->flags_ = 0;
-	matrix->numrows_ = numrows;
+    matrix->numrows_ = numrows;
-	matrix->numcols_ = numcols;
+    matrix->numcols_ = numcols;
-	matrix->rows_ = 0;
+    matrix->rows_ = 0;
-	matrix->maxrows_ = numrows;
+    matrix->maxrows_ = numrows;
-	matrix->data_ = 0;
+    matrix->data_ = 0;
-	matrix->datasize_ = numrows * numcols;
+    matrix->datasize_ = numrows * numcols;
 
-	if (matrix->maxrows_ > 0) {
+    if (matrix->maxrows_ > 0) {
-		if (!(matrix->rows_ = jas_alloc2(matrix->maxrows_,
+        if (!(matrix->rows_ = jas_alloc2(matrix->maxrows_,
-		  sizeof(jas_seqent_t *)))) {
+          sizeof(jas_seqent_t *)))) {
-			jas_matrix_destroy(matrix);
+            jas_matrix_destroy(matrix);
-			return 0;
+            return 0;
-		}
+        }
-	}
+    }
 
-	if (matrix->datasize_ > 0) {
+    if (matrix->datasize_ > 0) {
-		if (!(matrix->data_ = jas_alloc2(matrix->datasize_,
+        if (!(matrix->data_ = jas_alloc2(matrix->datasize_,
-		  sizeof(jas_seqent_t)))) {
+          sizeof(jas_seqent_t)))) {
-			jas_matrix_destroy(matrix);
+            jas_matrix_destroy(matrix);
-			return 0;
+            return 0;
-		}
+        }
-	}
+    }
 
-	for (i = 0; i < numrows; ++i) {
+    for (i = 0; i < numrows; ++i) {
-		matrix->rows_[i] = &matrix->data_[i * matrix->numcols_];
+        matrix->rows_[i] = &matrix->data_[i * matrix->numcols_];
-	}
+    }
 
-	for (i = 0; i < matrix->datasize_; ++i) {
+    for (i = 0; i < matrix->datasize_; ++i) {
-		matrix->data_[i] = 0;
+        matrix->data_[i] = 0;
-	}
+    }
 
-	matrix->xstart_ = 0;
+    matrix->xstart_ = 0;
-	matrix->ystart_ = 0;
+    matrix->ystart_ = 0;
-	matrix->xend_ = matrix->numcols_;
+    matrix->xend_ = matrix->numcols_;
-	matrix->yend_ = matrix->numrows_;
+    matrix->yend_ = matrix->numrows_;
 
-	return matrix;
+    return matrix;
 }
 
 void jas_matrix_destroy(jas_matrix_t *matrix)
 {
-	if (matrix->data_) {
+    if (matrix->data_) {
-		assert(!(matrix->flags_ & JAS_MATRIX_REF));
+        assert(!(matrix->flags_ & JAS_MATRIX_REF));
-		jas_free(matrix->data_);
+        jas_free(matrix->data_);
-		matrix->data_ = 0;
+        matrix->data_ = 0;
-	}
+    }
-	if (matrix->rows_) {
+    if (matrix->rows_) {
-		jas_free(matrix->rows_);
+        jas_free(matrix->rows_);
-		matrix->rows_ = 0;
+        matrix->rows_ = 0;
-	}
+    }
-	jas_free(matrix);
+    jas_free(matrix);
 }
 
 jas_seq2d_t *jas_seq2d_copy(jas_seq2d_t *x)
 {
-	jas_matrix_t *y;
+    jas_matrix_t *y;
-	int i;
+    int i;
-	int j;
+    int j;
-	y = jas_seq2d_create(jas_seq2d_xstart(x), jas_seq2d_ystart(x), jas_seq2d_xend(x),
+    y = jas_seq2d_create(jas_seq2d_xstart(x), jas_seq2d_ystart(x), jas_seq2d_xend(x),
-	  jas_seq2d_yend(x));
+      jas_seq2d_yend(x));
-	assert(y);
+    assert(y);
-	for (i = 0; i < x->numrows_; ++i) {
+    for (i = 0; i < x->numrows_; ++i) {
-		for (j = 0; j < x->numcols_; ++j) {
+        for (j = 0; j < x->numcols_; ++j) {
-			*jas_matrix_getref(y, i, j) = jas_matrix_get(x, i, j);
+            *jas_matrix_getref(y, i, j) = jas_matrix_get(x, i, j);
-		}
+        }
-	}
+    }
-	return y;
+    return y;
 }
 
 jas_matrix_t *jas_matrix_copy(jas_matrix_t *x)
 {
-	jas_matrix_t *y;
+    jas_matrix_t *y;
-	int i;
+    int i;
-	int j;
+    int j;
-	y = jas_matrix_create(x->numrows_, x->numcols_);
+    y = jas_matrix_create(x->numrows_, x->numcols_);
-	for (i = 0; i < x->numrows_; ++i) {
+    for (i = 0; i < x->numrows_; ++i) {
-		for (j = 0; j < x->numcols_; ++j) {
+        for (j = 0; j < x->numcols_; ++j) {
-			*jas_matrix_getref(y, i, j) = jas_matrix_get(x, i, j);
+            *jas_matrix_getref(y, i, j) = jas_matrix_get(x, i, j);
-		}
+        }
-	}
+    }
-	return y;
+    return y;
 }
 
 /******************************************************************************\
@@ -196,39 +196,39 @@ jas_matrix_t *jas_matrix_copy(jas_matrix_t *x)
 void jas_seq2d_bindsub(jas_matrix_t *s, jas_matrix_t *s1, int xstart, int ystart,
   int xend, int yend)
 {
-	jas_matrix_bindsub(s, s1, ystart - s1->ystart_, xstart - s1->xstart_,
+    jas_matrix_bindsub(s, s1, ystart - s1->ystart_, xstart - s1->xstart_,
-	  yend - s1->ystart_ - 1, xend - s1->xstart_ - 1);
+      yend - s1->ystart_ - 1, xend - s1->xstart_ - 1);
 }
 
 void jas_matrix_bindsub(jas_matrix_t *mat0, jas_matrix_t *mat1, int r0, int c0,
   int r1, int c1)
 {
-	int i;
+    int i;
 
-	if (mat0->data_) {
+    if (mat0->data_) {
-		if (!(mat0->flags_ & JAS_MATRIX_REF)) {
+        if (!(mat0->flags_ & JAS_MATRIX_REF)) {
-			jas_free(mat0->data_);
+            jas_free(mat0->data_);
-		}
+        }
-		mat0->data_ = 0;
+        mat0->data_ = 0;
-		mat0->datasize_ = 0;
+        mat0->datasize_ = 0;
-	}
+    }
-	if (mat0->rows_) {
+    if (mat0->rows_) {
-		jas_free(mat0->rows_);
+        jas_free(mat0->rows_);
-		mat0->rows_ = 0;
+        mat0->rows_ = 0;
-	}
+    }
-	mat0->flags_ |= JAS_MATRIX_REF;
+    mat0->flags_ |= JAS_MATRIX_REF;
-	mat0->numrows_ = r1 - r0 + 1;
+    mat0->numrows_ = r1 - r0 + 1;
-	mat0->numcols_ = c1 - c0 + 1;
+    mat0->numcols_ = c1 - c0 + 1;
-	mat0->maxrows_ = mat0->numrows_;
+    mat0->maxrows_ = mat0->numrows_;
-	mat0->rows_ = jas_alloc2(mat0->maxrows_, sizeof(jas_seqent_t *));
+    mat0->rows_ = jas_alloc2(mat0->maxrows_, sizeof(jas_seqent_t *));
-	for (i = 0; i < mat0->numrows_; ++i) {
+    for (i = 0; i < mat0->numrows_; ++i) {
-		mat0->rows_[i] = mat1->rows_[r0 + i] + c0;
+        mat0->rows_[i] = mat1->rows_[r0 + i] + c0;
-	}
+    }
 
-	mat0->xstart_ = mat1->xstart_ + c0;
+    mat0->xstart_ = mat1->xstart_ + c0;
-	mat0->ystart_ = mat1->ystart_ + r0;
+    mat0->ystart_ = mat1->ystart_ + r0;
-	mat0->xend_ = mat0->xstart_ + mat0->numcols_;
+    mat0->xend_ = mat0->xstart_ + mat0->numcols_;
-	mat0->yend_ = mat0->ystart_ + mat0->numrows_;
+    mat0->yend_ = mat0->ystart_ + mat0->numrows_;
 }
 
 /******************************************************************************\
@@ -237,102 +237,102 @@ void jas_matrix_bindsub(jas_matrix_t *mat0, jas_matrix_t *mat1, int r0, int c0,
 
 int jas_matrix_cmp(jas_matrix_t *mat0, jas_matrix_t *mat1)
 {
-	int i;
+    int i;
-	int j;
+    int j;
 
-	if (mat0->numrows_ != mat1->numrows_ || mat0->numcols_ !=
+    if (mat0->numrows_ != mat1->numrows_ || mat0->numcols_ !=
-	  mat1->numcols_) {
+      mat1->numcols_) {
-		return 1;
+        return 1;
-	}
+    }
-	for (i = 0; i < mat0->numrows_; i++) {
+    for (i = 0; i < mat0->numrows_; i++) {
-		for (j = 0; j < mat0->numcols_; j++) {
+        for (j = 0; j < mat0->numcols_; j++) {
-			if (jas_matrix_get(mat0, i, j) != jas_matrix_get(mat1, i, j)) {
+            if (jas_matrix_get(mat0, i, j) != jas_matrix_get(mat1, i, j)) {
-				return 1;
+                return 1;
-			}
+            }
-		}
+        }
-	}
+    }
-	return 0;
+    return 0;
 }
 
 void jas_matrix_divpow2(jas_matrix_t *matrix, int n)
 {
-	int i;
+    int i;
-	int j;
+    int j;
-	jas_seqent_t *rowstart;
+    jas_seqent_t *rowstart;
-	int rowstep;
+    int rowstep;
-	jas_seqent_t *data;
+    jas_seqent_t *data;
 
-	rowstep = jas_matrix_rowstep(matrix);
+    rowstep = jas_matrix_rowstep(matrix);
-	for (i = matrix->numrows_, rowstart = matrix->rows_[0]; i > 0; --i,
+    for (i = matrix->numrows_, rowstart = matrix->rows_[0]; i > 0; --i,
-	  rowstart += rowstep) {
+      rowstart += rowstep) {
-		for (j = matrix->numcols_, data = rowstart; j > 0; --j,
+        for (j = matrix->numcols_, data = rowstart; j > 0; --j,
-		  ++data) {
+          ++data) {
-			*data = (*data >= 0) ? ((*data) >> n) :
+            *data = (*data >= 0) ? ((*data) >> n) :
-			  (-((-(*data)) >> n));
+              (-((-(*data)) >> n));
-		}
+        }
-	}
+    }
 }
 
 void jas_matrix_clip(jas_matrix_t *matrix, jas_seqent_t minval, jas_seqent_t maxval)
 {
-	int i;
+    int i;
-	int j;
+    int j;
-	jas_seqent_t v;
+    jas_seqent_t v;
-	jas_seqent_t *rowstart;
+    jas_seqent_t *rowstart;
-	jas_seqent_t *data;
+    jas_seqent_t *data;
-	int rowstep;
+    int rowstep;
 
-	rowstep = jas_matrix_rowstep(matrix);
+    rowstep = jas_matrix_rowstep(matrix);
-	for (i = matrix->numrows_, rowstart = matrix->rows_[0]; i > 0; --i,
+    for (i = matrix->numrows_, rowstart = matrix->rows_[0]; i > 0; --i,
-	  rowstart += rowstep) {
+      rowstart += rowstep) {
-		data = rowstart;
+        data = rowstart;
-		for (j = matrix->numcols_, data = rowstart; j > 0; --j,
+        for (j = matrix->numcols_, data = rowstart; j > 0; --j,
-		  ++data) {
+          ++data) {
-			v = *data;
+            v = *data;
-			if (v < minval) {
+            if (v < minval) {
-				*data = minval;
+                *data = minval;
-			} else if (v > maxval) {
+            } else if (v > maxval) {
-				*data = maxval;
+                *data = maxval;
-			}
+            }
-		}
+        }
-	}
+    }
 }
 
 void jas_matrix_asr(jas_matrix_t *matrix, int n)
 {
-	int i;
+    int i;
-	int j;
+    int j;
-	jas_seqent_t *rowstart;
+    jas_seqent_t *rowstart;
-	int rowstep;
+    int rowstep;
-	jas_seqent_t *data;
+    jas_seqent_t *data;
 
-	assert(n >= 0);
+    assert(n >= 0);
-	rowstep = jas_matrix_rowstep(matrix);
+    rowstep = jas_matrix_rowstep(matrix);
-	for (i = matrix->numrows_, rowstart = matrix->rows_[0]; i > 0; --i,
+    for (i = matrix->numrows_, rowstart = matrix->rows_[0]; i > 0; --i,
-	  rowstart += rowstep) {
+      rowstart += rowstep) {
-		for (j = matrix->numcols_, data = rowstart; j > 0; --j,
+        for (j = matrix->numcols_, data = rowstart; j > 0; --j,
-		  ++data) {
+          ++data) {
-			*data >>= n;
+            *data >>= n;
-		}
+        }
-	}
+    }
 }
 
 void jas_matrix_asl(jas_matrix_t *matrix, int n)
 {
-	int i;
+    int i;
-	int j;
+    int j;
-	jas_seqent_t *rowstart;
+    jas_seqent_t *rowstart;
-	int rowstep;
+    int rowstep;
-	jas_seqent_t *data;
+    jas_seqent_t *data;
 
-	rowstep = jas_matrix_rowstep(matrix);
+    rowstep = jas_matrix_rowstep(matrix);
-	for (i = matrix->numrows_, rowstart = matrix->rows_[0]; i > 0; --i,
+    for (i = matrix->numrows_, rowstart = matrix->rows_[0]; i > 0; --i,
-	  rowstart += rowstep) {
+      rowstart += rowstep) {
-		for (j = matrix->numcols_, data = rowstart; j > 0; --j,
+        for (j = matrix->numcols_, data = rowstart; j > 0; --j,
-		  ++data) {
+          ++data) {
-			*data <<= n;
+            *data <<= n;
-		}
+        }
-	}
+    }
 }
 
 /******************************************************************************\
@@ -341,114 +341,114 @@ void jas_matrix_asl(jas_matrix_t *matrix, int n)
 
 int jas_matrix_resize(jas_matrix_t *matrix, int numrows, int numcols)
 {
-	int size;
+    int size;
-	int i;
+    int i;
 
-	size = numrows * numcols;
+    size = numrows * numcols;
-	if (size > matrix->datasize_ || numrows > matrix->maxrows_) {
+    if (size > matrix->datasize_ || numrows > matrix->maxrows_) {
-		return -1;
+        return -1;
-	}
+    }
 
-	matrix->numrows_ = numrows;
+    matrix->numrows_ = numrows;
-	matrix->numcols_ = numcols;
+    matrix->numcols_ = numcols;
 
-	for (i = 0; i < numrows; ++i) {
+    for (i = 0; i < numrows; ++i) {
-		matrix->rows_[i] = &matrix->data_[numcols * i];
+        matrix->rows_[i] = &matrix->data_[numcols * i];
-	}
+    }
 
-	return 0;
+    return 0;
 }
 
 void jas_matrix_setall(jas_matrix_t *matrix, jas_seqent_t val)
 {
-	int i;
+    int i;
-	int j;
+    int j;
-	jas_seqent_t *rowstart;
+    jas_seqent_t *rowstart;
-	int rowstep;
+    int rowstep;
-	jas_seqent_t *data;
+    jas_seqent_t *data;
 
-	rowstep = jas_matrix_rowstep(matrix);
+    rowstep = jas_matrix_rowstep(matrix);
-	for (i = matrix->numrows_, rowstart = matrix->rows_[0]; i > 0; --i,
+    for (i = matrix->numrows_, rowstart = matrix->rows_[0]; i > 0; --i,
-	  rowstart += rowstep) {
+      rowstart += rowstep) {
-		for (j = matrix->numcols_, data = rowstart; j > 0; --j,
+        for (j = matrix->numcols_, data = rowstart; j > 0; --j,
-		  ++data) {
+          ++data) {
-			*data = val;
+            *data = val;
-		}
+        }
-	}
+    }
 }
 
 jas_matrix_t *jas_seq2d_input(FILE *in)
 {
-	jas_matrix_t *matrix;
+    jas_matrix_t *matrix;
-	int i;
+    int i;
-	int j;
+    int j;
-	long x;
+    long x;
-	int numrows;
+    int numrows;
-	int numcols;
+    int numcols;
-	int xoff;
+    int xoff;
-	int yoff;
+    int yoff;
 
-	if (fscanf(in, "%d %d", &xoff, &yoff) != 2)
+    if (fscanf(in, "%d %d", &xoff, &yoff) != 2)
-		return 0;
+        return 0;
-	if (fscanf(in, "%d %d", &numcols, &numrows) != 2)
+    if (fscanf(in, "%d %d", &numcols, &numrows) != 2)
-		return 0;
+        return 0;
-	if (!(matrix = jas_seq2d_create(xoff, yoff, xoff + numcols, yoff + numrows)))
+    if (!(matrix = jas_seq2d_create(xoff, yoff, xoff + numcols, yoff + numrows)))
-		return 0;
+        return 0;
 
-	if (jas_matrix_numrows(matrix) != numrows || jas_matrix_numcols(matrix) != numcols) {
+    if (jas_matrix_numrows(matrix) != numrows || jas_matrix_numcols(matrix) != numcols) {
-		abort();
+        abort();
-	}
+    }
 
-	/* Get matrix data. */
+    /* Get matrix data. */
-	for (i = 0; i < jas_matrix_numrows(matrix); i++) {
+    for (i = 0; i < jas_matrix_numrows(matrix); i++) {
-		for (j = 0; j < jas_matrix_numcols(matrix); j++) {
+        for (j = 0; j < jas_matrix_numcols(matrix); j++) {
-			if (fscanf(in, "%ld", &x) != 1) {
+            if (fscanf(in, "%ld", &x) != 1) {
-				jas_matrix_destroy(matrix);
+                jas_matrix_destroy(matrix);
-				return 0;
+                return 0;
-			}
+            }
-			jas_matrix_set(matrix, i, j, JAS_CAST(jas_seqent_t, x));
+            jas_matrix_set(matrix, i, j, JAS_CAST(jas_seqent_t, x));
-		}
+        }
-	}
+    }
 
-	return matrix;
+    return matrix;
 }
 
 int jas_seq2d_output(jas_matrix_t *matrix, FILE *out)
 {
 #define MAXLINELEN	80
-	int i;
+    int i;
-	int j;
+    int j;
-	jas_seqent_t x;
+    jas_seqent_t x;
-	char buf[MAXLINELEN + 1];
+    char buf[MAXLINELEN + 1];
-	char sbuf[MAXLINELEN + 1];
+    char sbuf[MAXLINELEN + 1];
-	int n;
+    int n;
 
-	fprintf(out, "%d %d\n", (int)jas_seq2d_xstart(matrix),
+    fprintf(out, "%d %d\n", (int)jas_seq2d_xstart(matrix),
-	  (int)jas_seq2d_ystart(matrix));
+      (int)jas_seq2d_ystart(matrix));
-	fprintf(out, "%d %d\n", (int)jas_matrix_numcols(matrix),
+    fprintf(out, "%d %d\n", (int)jas_matrix_numcols(matrix),
-	  (int)jas_matrix_numrows(matrix));
+      (int)jas_matrix_numrows(matrix));
 
-	buf[0] = '\0';
+    buf[0] = '\0';
-	for (i = 0; i < jas_matrix_numrows(matrix); ++i) {
+    for (i = 0; i < jas_matrix_numrows(matrix); ++i) {
-		for (j = 0; j < jas_matrix_numcols(matrix); ++j) {
+        for (j = 0; j < jas_matrix_numcols(matrix); ++j) {
-			x = jas_matrix_get(matrix, i, j);
+            x = jas_matrix_get(matrix, i, j);
-			sprintf(sbuf, "%s%4ld", (strlen(buf) > 0) ? " " : "",
+            sprintf(sbuf, "%s%4ld", (strlen(buf) > 0) ? " " : "",
-			  JAS_CAST(long, x));
+              JAS_CAST(long, x));
-			n = strlen(buf);
+            n = strlen(buf);
-			if (n + strlen(sbuf) > MAXLINELEN) {
+            if (n + strlen(sbuf) > MAXLINELEN) {
-				fputs(buf, out);
+                fputs(buf, out);
-				fputs("\n", out);
+                fputs("\n", out);
-				buf[0] = '\0';
+                buf[0] = '\0';
-			}
+            }
-			strcat(buf, sbuf);
+            strcat(buf, sbuf);
-			if (j == jas_matrix_numcols(matrix) - 1) {
+            if (j == jas_matrix_numcols(matrix) - 1) {
-				fputs(buf, out);
+                fputs(buf, out);
-				fputs("\n", out);
+                fputs("\n", out);
-				buf[0] = '\0';
+                buf[0] = '\0';
-			}
+            }
-		}
+        }
-	}
+    }
-	fputs(buf, out);
+    fputs(buf, out);
 
-	return 0;
+    return 0;
 }

3rdparty/libjasper/jas_string.c

@@ -6,15 +6,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,
@@ -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__
  */
 
@@ -85,12 +85,12 @@
 
 char *jas_strdup(const char *s)
 {
-	int n;
+    int n;
-	char *p;
+    char *p;
-	n = strlen(s) + 1;
+    n = strlen(s) + 1;
-	if (!(p = jas_malloc(n * sizeof(char)))) {
+    if (!(p = jas_malloc(n * sizeof(char)))) {
-		return 0;
+        return 0;
-	}
+    }
-	strcpy(p, s);
+    strcpy(p, s);
-	return p;
+    return p;
 }

3rdparty/libjasper/jas_tmr.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,51 +83,51 @@
 
 void jas_tmr_start(jas_tmr_t *tmr)
 {
-	if (gettimeofday(&tmr->start, 0)) {
+    if (gettimeofday(&tmr->start, 0)) {
-		abort();
+        abort();
-	}
+    }
 }
 
 void jas_tmr_stop(jas_tmr_t *tmr)
 {
-	if (gettimeofday(&tmr->stop, 0)) {
+    if (gettimeofday(&tmr->stop, 0)) {
-		abort();
+        abort();
-	}
+    }
 }
 
 double jas_tmr_get(jas_tmr_t *tmr)
 {
-	double t0;
+    double t0;
-	double t1;
+    double t1;
-	t0 = ((double) tmr->start.tv_sec) + ((double) tmr->start.tv_usec) / 1e6;
+    t0 = ((double) tmr->start.tv_sec) + ((double) tmr->start.tv_usec) / 1e6;
-	t1 = ((double) tmr->stop.tv_sec) + ((double) tmr->stop.tv_usec) / 1e6;
+    t1 = ((double) tmr->stop.tv_sec) + ((double) tmr->stop.tv_usec) / 1e6;
-	return t1 - t0;
+    return t1 - t0;
 }
 
 #elif defined(HAVE_GETRUSAGE)
 
 void jas_tmr_start(jas_tmr_t *tmr)
 {
-	if (getrusage(RUSAGE_SELF, &tmr->start) < 0) {
+    if (getrusage(RUSAGE_SELF, &tmr->start) < 0) {
-		abort();
+        abort();
-	}
+    }
 }
 
 void jas_tmr_stop(jas_tmr_t *tmr)
 {
-	if (getrusage(RUSAGE_SELF, &tmr->stop) < 0) {
+    if (getrusage(RUSAGE_SELF, &tmr->stop) < 0) {
-		abort();
+        abort();
-	}
+    }
 }
 
 double jas_tmr_get(jas_tmr_t *tmr)
 {
-	double t;
+    double t;
-	t = ((tmr->stop.ru_utime.tv_sec * 1e6 + tmr->stop.ru_utime.tv_usec) -
+    t = ((tmr->stop.ru_utime.tv_sec * 1e6 + tmr->stop.ru_utime.tv_usec) -
-	  (tmr->start.ru_utime.tv_sec * 1e6 + tmr->start.ru_utime.tv_usec)) / 1e6;
+      (tmr->start.ru_utime.tv_sec * 1e6 + tmr->start.ru_utime.tv_usec)) / 1e6;
-	t += ((tmr->stop.ru_stime.tv_sec * 1e6 + tmr->stop.ru_stime.tv_usec) -
+    t += ((tmr->stop.ru_stime.tv_sec * 1e6 + tmr->stop.ru_stime.tv_usec) -
-	  (tmr->start.ru_stime.tv_sec * 1e6 + tmr->start.ru_stime.tv_usec)) / 1e6;
+      (tmr->start.ru_stime.tv_sec * 1e6 + tmr->start.ru_stime.tv_usec)) / 1e6;
-	return t;
+    return t;
 }
 
 #else
@@ -142,7 +142,7 @@ void jas_tmr_stop(jas_tmr_t *tmr)
 
 double jas_tmr_get(jas_tmr_t *tmr)
 {
-	return 0.0;
+    return 0.0;
 }
 
 #endif

3rdparty/libjasper/jas_tvp.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__
  */
 
@@ -84,7 +84,7 @@
 
 /* Is the specified character valid for a tag name? */
 #define	JAS_TVP_ISTAG(x) \
-	(isalpha(x) || (x) == '_' || isdigit(x))
+    (isalpha(x) || (x) == '_' || isdigit(x))
 
 /******************************************************************************\
 * Code for creating and destroying a tag-value parser.
@@ -92,26 +92,26 @@
 
 jas_tvparser_t *jas_tvparser_create(const char *s)
 {
-	jas_tvparser_t *tvp;
+    jas_tvparser_t *tvp;
-	if (!(tvp = jas_malloc(sizeof(jas_tvparser_t)))) {
+    if (!(tvp = jas_malloc(sizeof(jas_tvparser_t)))) {
-		return 0;
+        return 0;
-	}
+    }
-	if (!(tvp->buf = jas_strdup(s))) {
+    if (!(tvp->buf = jas_strdup(s))) {
-		jas_tvparser_destroy(tvp);
+        jas_tvparser_destroy(tvp);
-		return 0;
+        return 0;
-	}
+    }
-	tvp->pos = tvp->buf;
+    tvp->pos = tvp->buf;
-	tvp->tag = 0;
+    tvp->tag = 0;
-	tvp->val = 0;
+    tvp->val = 0;
-	return tvp;
+    return tvp;
 }
 
 void jas_tvparser_destroy(jas_tvparser_t *tvp)
 {
-	if (tvp->buf) {
+    if (tvp->buf) {
-		jas_free(tvp->buf);
+        jas_free(tvp->buf);
-	}
+    }
-	jas_free(tvp);
+    jas_free(tvp);
 }
 
 /******************************************************************************\
@@ -121,73 +121,73 @@ void jas_tvparser_destroy(jas_tvparser_t *tvp)
 /* Get the next tag-value pair. */
 int jas_tvparser_next(jas_tvparser_t *tvp)
 {
-	char *p;
+    char *p;
-	char *tag;
+    char *tag;
-	char *val;
+    char *val;
 
-	/* Skip any leading whitespace. */
+    /* Skip any leading whitespace. */
-	p = tvp->pos;
+    p = tvp->pos;
-	while (*p != '\0' && isspace(*p)) {
+    while (*p != '\0' && isspace(*p)) {
-		++p;
+        ++p;
-	}
+    }
 
-	/* Has the end of the input data been reached? */
+    /* Has the end of the input data been reached? */
-	if (*p == '\0') {
+    if (*p == '\0') {
-		/* No more tags are present. */
+        /* No more tags are present. */
-		tvp->pos = p;
+        tvp->pos = p;
-		return 1;
+        return 1;
-	}
+    }
 
-	/* Does the tag name begin with a valid character? */
+    /* Does the tag name begin with a valid character? */
-	if (!JAS_TVP_ISTAG(*p)) {
+    if (!JAS_TVP_ISTAG(*p)) {
-		return -1;
+        return -1;
-	}
+    }
 
-	/* Remember where the tag name begins. */
+    /* Remember where the tag name begins. */
-	tag = p;
+    tag = p;
 
-	/* Find the end of the tag name. */
+    /* Find the end of the tag name. */
-	while (*p != '\0' && JAS_TVP_ISTAG(*p)) {
+    while (*p != '\0' && JAS_TVP_ISTAG(*p)) {
-		++p;
+        ++p;
-	}
+    }
 
-	/* Has the end of the input data been reached? */
+    /* Has the end of the input data been reached? */
-	if (*p == '\0') {
+    if (*p == '\0') {
-		/* The value field is empty. */
+        /* The value field is empty. */
-		tvp->tag = tag;
+        tvp->tag = tag;
-		tvp->val = "";
+        tvp->val = "";
-		tvp->pos = p;
+        tvp->pos = p;
-		return 0;
+        return 0;
-	}
+    }
 
-	/* Is a value field not present? */
+    /* Is a value field not present? */
-	if (*p != '=') {
+    if (*p != '=') {
-		if (*p != '\0' && !isspace(*p)) {
+        if (*p != '\0' && !isspace(*p)) {
-			return -1;
+            return -1;
-		}
+        }
-		*p++ = '\0';
+        *p++ = '\0';
-		tvp->tag = tag;
+        tvp->tag = tag;
-		tvp->val = "";
+        tvp->val = "";
-		tvp->pos = p;
+        tvp->pos = p;
-		return 0;
+        return 0;
-	}
+    }
 
-	*p++ = '\0';
+    *p++ = '\0';
 
-	val = p;
+    val = p;
-	while (*p != '\0' && !isspace(*p)) {
+    while (*p != '\0' && !isspace(*p)) {
-		++p;
+        ++p;
-	}
+    }
 
-	if (*p != '\0') {
+    if (*p != '\0') {
-		*p++ = '\0';
+        *p++ = '\0';
-	}
+    }
 
-	tvp->pos = p;
+    tvp->pos = p;
-	tvp->tag = tag;
+    tvp->tag = tag;
-	tvp->val = val;
+    tvp->val = val;
 
-	return 0;
+    return 0;
 }
 
 /******************************************************************************\
@@ -197,13 +197,13 @@ int jas_tvparser_next(jas_tvparser_t *tvp)
 /* Get the current tag. */
 char *jas_tvparser_gettag(jas_tvparser_t *tvp)
 {
-	return tvp->tag;
+    return tvp->tag;
 }
 
 /* Get the current value. */
 char *jas_tvparser_getval(jas_tvparser_t *tvp)
 {
-	return tvp->val;
+    return tvp->val;
 }
 
 /******************************************************************************\
@@ -213,15 +213,15 @@ char *jas_tvparser_getval(jas_tvparser_t *tvp)
 /* Lookup a tag by name. */
 jas_taginfo_t *jas_taginfos_lookup(jas_taginfo_t *taginfos, const char *name)
 {
-	jas_taginfo_t *taginfo;
+    jas_taginfo_t *taginfo;
-	taginfo = taginfos;
+    taginfo = taginfos;
-	while (taginfo->id >= 0) {
+    while (taginfo->id >= 0) {
-		if (!strcmp(taginfo->name, name)) {
+        if (!strcmp(taginfo->name, name)) {
-			return taginfo;
+            return taginfo;
-		}
+        }
-		++taginfo;
+        ++taginfo;
-	}
+    }
-	return 0;
+    return 0;
 }
 
 /* This function is simply for convenience. */
@@ -229,9 +229,9 @@ jas_taginfo_t *jas_taginfos_lookup(jas_taginfo_t *taginfos, const char *name)
   using this function.   This function never returns a null pointer.  */
 jas_taginfo_t *jas_taginfo_nonull(jas_taginfo_t *taginfo)
 {
-	static jas_taginfo_t invalidtaginfo = {
+    static jas_taginfo_t invalidtaginfo = {
-		-1, 0
+        -1, 0
-	};
+    };
-	
+
-	return taginfo ? taginfo : &invalidtaginfo;
+    return taginfo ? taginfo : &invalidtaginfo;
 }

3rdparty/libjasper/jas_version.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__
  */
 
@@ -63,5 +63,5 @@
 
 const char *jas_getversion()
 {
-	return JAS_VERSION;
+    return JAS_VERSION;
 }

3rdparty/libjasper/jasper/jas_cm.h

@@ -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__
  */
 
@@ -139,72 +139,72 @@ typedef double jas_cmreal_t;
 struct jas_cmpxform_s;
 
 typedef struct {
-	long *buf;
+    long *buf;
-	int prec;
+    int prec;
-	int sgnd;
+    int sgnd;
-	int width;
+    int width;
-	int height;
+    int height;
 } jas_cmcmptfmt_t;
 
 typedef struct {
-	int numcmpts;
+    int numcmpts;
-	jas_cmcmptfmt_t *cmptfmts;
+    jas_cmcmptfmt_t *cmptfmts;
 } jas_cmpixmap_t;
 
 typedef struct {
-	void (*destroy)(struct jas_cmpxform_s *pxform);
+    void (*destroy)(struct jas_cmpxform_s *pxform);
-	int (*apply)(struct jas_cmpxform_s *pxform, jas_cmreal_t *in, jas_cmreal_t *out, int cnt);
+    int (*apply)(struct jas_cmpxform_s *pxform, jas_cmreal_t *in, jas_cmreal_t *out, int cnt);
-	void (*dump)(struct jas_cmpxform_s *pxform);
+    void (*dump)(struct jas_cmpxform_s *pxform);
 } jas_cmpxformops_t;
 
 typedef struct {
-	jas_cmreal_t *data;
+    jas_cmreal_t *data;
-	int size;
+    int size;
 } jas_cmshapmatlut_t;
 
 typedef struct {
-	int mono;
+    int mono;
-	int order;
+    int order;
-	int useluts;
+    int useluts;
-	int usemat;
+    int usemat;
-	jas_cmshapmatlut_t luts[3];
+    jas_cmshapmatlut_t luts[3];
-	jas_cmreal_t mat[3][4];
+    jas_cmreal_t mat[3][4];
 } jas_cmshapmat_t;
 
 typedef struct {
-	int order;
+    int order;
 } jas_cmshaplut_t;
 
 typedef struct {
-	int inclrspc;
+    int inclrspc;
-	int outclrspc;
+    int outclrspc;
 } jas_cmclrspcconv_t;
 
 #define	jas_align_t	double
 
 typedef struct jas_cmpxform_s {
-	int refcnt;
+    int refcnt;
-	jas_cmpxformops_t *ops;
+    jas_cmpxformops_t *ops;
-	int numinchans;
+    int numinchans;
-	int numoutchans;
+    int numoutchans;
-	union {
+    union {
-		jas_align_t dummy;
+        jas_align_t dummy;
-		jas_cmshapmat_t shapmat;
+        jas_cmshapmat_t shapmat;
-		jas_cmshaplut_t shaplut;
+        jas_cmshaplut_t shaplut;
-		jas_cmclrspcconv_t clrspcconv;
+        jas_cmclrspcconv_t clrspcconv;
-	} data;
+    } data;
 } jas_cmpxform_t;
 
 typedef struct {
-	int numpxforms;
+    int numpxforms;
-	int maxpxforms;
+    int maxpxforms;
-	jas_cmpxform_t **pxforms;
+    jas_cmpxform_t **pxforms;
 } jas_cmpxformseq_t;
 
 typedef struct {
-	int numinchans;
+    int numinchans;
-	int numoutchans;
+    int numoutchans;
-	jas_cmpxformseq_t *pxformseq;
+    jas_cmpxformseq_t *pxformseq;
 } jas_cmxform_t;
 
 #define	JAS_CMPROF_TYPE_DEV	1
@@ -213,12 +213,12 @@ typedef struct {
 #define	JAS_CMPROF_NUMPXFORMSEQS	13
 
 typedef struct {
-	int clrspc;
+    int clrspc;
-	int numchans;
+    int numchans;
-	int refclrspc;
+    int refclrspc;
-	int numrefchans;
+    int numrefchans;
-	jas_iccprof_t *iccprof;
+    jas_iccprof_t *iccprof;
-	jas_cmpxformseq_t *pxformseqs[JAS_CMPROF_NUMPXFORMSEQS];
+    jas_cmpxformseq_t *pxformseqs[JAS_CMPROF_NUMPXFORMSEQS];
 } jas_cmprof_t;
 
 /* Create a profile. */

3rdparty/libjasper/jasper/jas_config2.h

@@ -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__
  */
 

3rdparty/libjasper/jasper/jas_debug.h

@@ -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__
  */
 
@@ -90,7 +90,7 @@ extern "C" {
   level is set sufficiently high. */
 #if defined(DEBUG)
 #define	JAS_DBGLOG(n, x) \
-	((jas_getdbglevel() >= (n)) ? (jas_eprintf x) : 0)
+    ((jas_getdbglevel() >= (n)) ? (jas_eprintf x) : 0)
 #else
 #define	JAS_DBGLOG(n, x)
 #endif

3rdparty/libjasper/jasper/jas_fix.h

@@ -6,15 +6,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,
@@ -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,15 +91,15 @@ extern "C" {
 
 /* The representation of the value zero. */
 #define	JAS_FIX_ZERO(fix_t, fracbits) \
-	JAS_CAST(fix_t, 0)
+    JAS_CAST(fix_t, 0)
 
 /* The representation of the value one. */
 #define	JAS_FIX_ONE(fix_t, fracbits) \
-	(JAS_CAST(fix_t, 1) << (fracbits))
+    (JAS_CAST(fix_t, 1) << (fracbits))
 
 /* The representation of the value one half. */
 #define	JAS_FIX_HALF(fix_t, fracbits) \
-	(JAS_CAST(fix_t, 1) << ((fracbits) - 1))
+    (JAS_CAST(fix_t, 1) << ((fracbits) - 1))
 
 /******************************************************************************\
 * Conversion operations.
@@ -107,19 +107,19 @@ extern "C" {
 
 /* Convert an int to a fixed-point number. */
 #define JAS_INTTOFIX(fix_t, fracbits, x) \
-	JAS_CAST(fix_t, (x) << (fracbits))
+    JAS_CAST(fix_t, (x) << (fracbits))
 
 /* Convert a fixed-point number to an int. */
 #define JAS_FIXTOINT(fix_t, fracbits, x) \
-	JAS_CAST(int, (x) >> (fracbits))
+    JAS_CAST(int, (x) >> (fracbits))
 
 /* Convert a fixed-point number to a double. */
 #define JAS_FIXTODBL(fix_t, fracbits, x) \
-	(JAS_CAST(double, x) / (JAS_CAST(fix_t, 1) << (fracbits)))
+    (JAS_CAST(double, x) / (JAS_CAST(fix_t, 1) << (fracbits)))
 
 /* Convert a double to a fixed-point number. */
 #define JAS_DBLTOFIX(fix_t, fracbits, x) \
-	JAS_CAST(fix_t, ((x) * JAS_CAST(double, JAS_CAST(fix_t, 1) << (fracbits))))
+    JAS_CAST(fix_t, ((x) * JAS_CAST(double, JAS_CAST(fix_t, 1) << (fracbits))))
 
 /******************************************************************************\
 * Basic arithmetic operations.
@@ -143,11 +143,11 @@ extern "C" {
 
 /* Calculate the sum of two fixed-point numbers with overflow checking. */
 #define	JAS_FIX_ADD_OFLOW(fix_t, fracbits, x, y) \
-	((x) >= 0) ? \
+    ((x) >= 0) ? \
-	  (((y) >= 0) ? ((x) + (y) >= 0 || JAS_FIX_OFLOW(), (x) + (y)) : \
+      (((y) >= 0) ? ((x) + (y) >= 0 || JAS_FIX_OFLOW(), (x) + (y)) : \
-	  ((x) + (y))) : \
+      ((x) + (y))) : \
-	  (((y) >= 0) ? ((x) + (y)) : ((x) + (y) < 0 || JAS_FIX_OFLOW(), \
+      (((y) >= 0) ? ((x) + (y)) : ((x) + (y) < 0 || JAS_FIX_OFLOW(), \
-	  (x) + (y)))
+      (x) + (y)))
 
 /* Calculate the product of two fixed-point numbers. */
 #if !defined(DEBUG_OVERFLOW)
@@ -159,17 +159,17 @@ extern "C" {
 /* Calculate the product of two fixed-point numbers without overflow
   checking. */
 #define	JAS_FIX_MUL_FAST(fix_t, fracbits, bigfix_t, x, y) \
-	JAS_CAST(fix_t, (JAS_CAST(bigfix_t, x) * JAS_CAST(bigfix_t, y)) >> \
+    JAS_CAST(fix_t, (JAS_CAST(bigfix_t, x) * JAS_CAST(bigfix_t, y)) >> \
-	  (fracbits))
+      (fracbits))
 
 /* Calculate the product of two fixed-point numbers with overflow
   checking. */
 #define JAS_FIX_MUL_OFLOW(fix_t, fracbits, bigfix_t, x, y) \
-	((JAS_CAST(bigfix_t, x) * JAS_CAST(bigfix_t, y) >> (fracbits)) == \
+    ((JAS_CAST(bigfix_t, x) * JAS_CAST(bigfix_t, y) >> (fracbits)) == \
-	  JAS_CAST(fix_t, (JAS_CAST(bigfix_t, x) * JAS_CAST(bigfix_t, y) >> \
+      JAS_CAST(fix_t, (JAS_CAST(bigfix_t, x) * JAS_CAST(bigfix_t, y) >> \
-	  (fracbits))) ? \
+      (fracbits))) ? \
-	  JAS_CAST(fix_t, (JAS_CAST(bigfix_t, x) * JAS_CAST(bigfix_t, y) >> \
+      JAS_CAST(fix_t, (JAS_CAST(bigfix_t, x) * JAS_CAST(bigfix_t, y) >> \
-	  (fracbits))) : JAS_FIX_OFLOW())
+      (fracbits))) : JAS_FIX_OFLOW())
 
 /* Calculate the product of a fixed-point number and an int. */
 #if !defined(DEBUG_OVERFLOW)
@@ -181,12 +181,12 @@ extern "C" {
 /* Calculate the product of a fixed-point number and an int without overflow
   checking. */
 #define	JAS_FIX_MULBYINT_FAST(fix_t, fracbits, x, y) \
-	JAS_CAST(fix_t, ((x) * (y)))
+    JAS_CAST(fix_t, ((x) * (y)))
 
 /* Calculate the product of a fixed-point number and an int with overflow
   checking. */
 #define	JAS_FIX_MULBYINT_OFLOW(fix_t, fracbits, x, y) \
-	JAS_FIX_MULBYINT_FAST(fix_t, fracbits, x, y)
+    JAS_FIX_MULBYINT_FAST(fix_t, fracbits, x, y)
 
 /* Calculate the quotient of two fixed-point numbers. */
 #if !defined(DEBUG_OVERFLOW)
@@ -198,12 +198,12 @@ extern "C" {
 /* Calculate the quotient of two fixed-point numbers without underflow
   checking. */
 #define	JAS_FIX_DIV_FAST(fix_t, fracbits, bigfix_t, x, y) \
-	JAS_CAST(fix_t, (JAS_CAST(bigfix_t, x) << (fracbits)) / (y))
+    JAS_CAST(fix_t, (JAS_CAST(bigfix_t, x) << (fracbits)) / (y))
 
 /* Calculate the quotient of two fixed-point numbers with underflow
   checking. */
 #define JAS_FIX_DIV_UFLOW(fix_t, fracbits, bigfix_t, x, y) \
-	JAS_FIX_DIV_FAST(fix_t, fracbits, bigfix_t, x, y)
+    JAS_FIX_DIV_FAST(fix_t, fracbits, bigfix_t, x, y)
 
 /* Negate a fixed-point number. */
 #if !defined(DEBUG_OVERFLOW)
@@ -214,13 +214,13 @@ extern "C" {
 
 /* Negate a fixed-point number without overflow checking. */
 #define	JAS_FIX_NEG_FAST(fix_t, fracbits, x) \
-	(-(x))
+    (-(x))
 
 /* Negate a fixed-point number with overflow checking. */
 /* Yes, overflow is actually possible for two's complement representations,
   although highly unlikely to occur. */
 #define	JAS_FIX_NEG_OFLOW(fix_t, fracbits, x) \
-	(((x) < 0) ? (-(x) > 0 || JAS_FIX_OFLOW(), -(x)) : (-(x)))
+    (((x) < 0) ? (-(x) > 0 || JAS_FIX_OFLOW(), -(x)) : (-(x)))
 
 /* Perform an arithmetic shift left of a fixed-point number. */
 #if !defined(DEBUG_OVERFLOW)
@@ -232,12 +232,12 @@ extern "C" {
 /* Perform an arithmetic shift left of a fixed-point number without overflow
   checking. */
 #define	JAS_FIX_ASL_FAST(fix_t, fracbits, x, n) \
-	((x) << (n))
+    ((x) << (n))
 
 /* Perform an arithmetic shift left of a fixed-point number with overflow
   checking. */
 #define	JAS_FIX_ASL_OFLOW(fix_t, fracbits, x, n) \
-	((((x) << (n)) >> (n)) == (x) || JAS_FIX_OFLOW(), (x) << (n))
+    ((((x) << (n)) >> (n)) == (x) || JAS_FIX_OFLOW(), (x) << (n))
 
 /* Perform an arithmetic shift right of a fixed-point number. */
 #if !defined(DEBUG_OVERFLOW)
@@ -249,12 +249,12 @@ extern "C" {
 /* Perform an arithmetic shift right of a fixed-point number without underflow
   checking. */
 #define	JAS_FIX_ASR_FAST(fix_t, fracbits, x, n) \
-	((x) >> (n))
+    ((x) >> (n))
 
 /* Perform an arithmetic shift right of a fixed-point number with underflow
   checking. */
 #define	JAS_FIX_ASR_UFLOW(fix_t, fracbits, x, n) \
-	JAS_FIX_ASR_FAST(fix_t, fracbits, x, n)
+    JAS_FIX_ASR_FAST(fix_t, fracbits, x, n)
 
 /******************************************************************************\
 * Other basic arithmetic operations.
@@ -262,19 +262,19 @@ extern "C" {
 
 /* Calculate the difference between two fixed-point numbers. */
 #define JAS_FIX_SUB(fix_t, fracbits, x, y) \
-	JAS_FIX_ADD(fix_t, fracbits, x, JAS_FIX_NEG(fix_t, fracbits, y))
+    JAS_FIX_ADD(fix_t, fracbits, x, JAS_FIX_NEG(fix_t, fracbits, y))
 
 /* Add one fixed-point number to another. */
 #define JAS_FIX_PLUSEQ(fix_t, fracbits, x, y) \
-	((x) = JAS_FIX_ADD(fix_t, fracbits, x, y))
+    ((x) = JAS_FIX_ADD(fix_t, fracbits, x, y))
 
 /* Subtract one fixed-point number from another. */
 #define JAS_FIX_MINUSEQ(fix_t, fracbits, x, y) \
-	((x) = JAS_FIX_SUB(fix_t, fracbits, x, y))
+    ((x) = JAS_FIX_SUB(fix_t, fracbits, x, y))
 
 /* Multiply one fixed-point number by another. */
 #define	JAS_FIX_MULEQ(fix_t, fracbits, bigfix_t, x, y) \
-	((x) = JAS_FIX_MUL(fix_t, fracbits, bigfix_t, x, y))
+    ((x) = JAS_FIX_MUL(fix_t, fracbits, bigfix_t, x, y))
 
 /******************************************************************************\
 * Miscellaneous operations.
@@ -282,15 +282,15 @@ extern "C" {
 
 /* Calculate the absolute value of a fixed-point number. */
 #define	JAS_FIX_ABS(fix_t, fracbits, x) \
-	(((x) >= 0) ? (x) : (JAS_FIX_NEG(fix_t, fracbits, x)))
+    (((x) >= 0) ? (x) : (JAS_FIX_NEG(fix_t, fracbits, x)))
 
 /* Is a fixed-point number an integer? */
 #define	JAS_FIX_ISINT(fix_t, fracbits, x) \
-	(JAS_FIX_FLOOR(fix_t, fracbits, x) == (x))
+    (JAS_FIX_FLOOR(fix_t, fracbits, x) == (x))
 
 /* Get the sign of a fixed-point number. */
 #define JAS_FIX_SGN(fix_t, fracbits, x) \
-	((x) >= 0 ? 1 : (-1))
+    ((x) >= 0 ? 1 : (-1))
 
 /******************************************************************************\
 * Relational operations.
@@ -298,23 +298,23 @@ extern "C" {
 
 /* Compare two fixed-point numbers. */
 #define JAS_FIX_CMP(fix_t, fracbits, x, y) \
-	((x) > (y) ? 1 : (((x) == (y)) ? 0 : (-1)))
+    ((x) > (y) ? 1 : (((x) == (y)) ? 0 : (-1)))
 
 /* Less than. */
 #define	JAS_FIX_LT(fix_t, fracbits, x, y) \
-	((x) < (y))
+    ((x) < (y))
 
 /* Less than or equal. */
 #define	JAS_FIX_LTE(fix_t, fracbits, x, y) \
-	((x) <= (y))
+    ((x) <= (y))
 
 /* Greater than. */
 #define	JAS_FIX_GT(fix_t, fracbits, x, y) \
-	((x) > (y))
+    ((x) > (y))
 
 /* Greater than or equal. */
 #define	JAS_FIX_GTE(fix_t, fracbits, x, y) \
-	((x) >= (y))
+    ((x) >= (y))
 
 /******************************************************************************\
 * Rounding functions.
@@ -322,21 +322,21 @@ extern "C" {
 
 /* Round a fixed-point number to the nearest integer. */
 #define	JAS_FIX_ROUND(fix_t, fracbits, x) \
-	(((x) < 0) ? JAS_FIX_FLOOR(fix_t, fracbits, JAS_FIX_ADD(fix_t, fracbits, \
+    (((x) < 0) ? JAS_FIX_FLOOR(fix_t, fracbits, JAS_FIX_ADD(fix_t, fracbits, \
-	  (x), JAS_FIX_HALF(fix_t, fracbits))) : \
+      (x), JAS_FIX_HALF(fix_t, fracbits))) : \
-	  JAS_FIX_NEG(fix_t, fracbits, JAS_FIX_FLOOR(fix_t, fracbits, \
+      JAS_FIX_NEG(fix_t, fracbits, JAS_FIX_FLOOR(fix_t, fracbits, \
-	  JAS_FIX_ADD(fix_t, fracbits, (-(x)), JAS_FIX_HALF(fix_t, fracbits)))))
+      JAS_FIX_ADD(fix_t, fracbits, (-(x)), JAS_FIX_HALF(fix_t, fracbits)))))
 
 /* Round a fixed-point number to the nearest integer in the direction of
   negative infinity (i.e., the floor function). */
 #define	JAS_FIX_FLOOR(fix_t, fracbits, x) \
-	((x) & (~((JAS_CAST(fix_t, 1) << (fracbits)) - 1)))
+    ((x) & (~((JAS_CAST(fix_t, 1) << (fracbits)) - 1)))
 
 /* Round a fixed-point number to the nearest integer in the direction
   of zero. */
 #define JAS_FIX_TRUNC(fix_t, fracbits, x) \
-	(((x) >= 0) ? JAS_FIX_FLOOR(fix_t, fracbits, x) : \
+    (((x) >= 0) ? JAS_FIX_FLOOR(fix_t, fracbits, x) : \
-	  JAS_FIX_CEIL(fix_t, fracbits, x))
+      JAS_FIX_CEIL(fix_t, fracbits, x))
 
 /******************************************************************************\
 * The below macros are for internal library use only.  Do not invoke them
@@ -345,11 +345,11 @@ extern "C" {
 
 /* Handle overflow. */
 #define	JAS_FIX_OFLOW() \
-	jas_eprintf("overflow error: file %s, line %d\n", __FILE__, __LINE__)
+    jas_eprintf("overflow error: file %s, line %d\n", __FILE__, __LINE__)
 
 /* Handle underflow. */
 #define	JAS_FIX_UFLOW() \
-	jas_eprintf("underflow error: file %s, line %d\n", __FILE__, __LINE__)
+    jas_eprintf("underflow error: file %s, line %d\n", __FILE__, __LINE__)
 
 #ifdef __cplusplus
 }

3rdparty/libjasper/jasper/jas_getopt.h

@@ -6,15 +6,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,
@@ -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__
  */
 
@@ -93,14 +93,14 @@ extern "C" {
 /* Command line option type. */
 typedef struct {
 
-	int id;
+    int id;
-	/* The unique identifier for this option. */
+    /* The unique identifier for this option. */
 
-	char *name;
+    char *name;
-	/* The name of this option. */
+    /* The name of this option. */
 
-	int flags;
+    int flags;
-	/* option flags. */
+    /* option flags. */
 
 } jas_opt_t;
 

3rdparty/libjasper/jasper/jas_icc.h

@@ -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__
  */
 
@@ -225,152 +225,152 @@ typedef jas_iccsig_t jas_iccattrname_t;
 
 /* Date/time type. */
 typedef struct {
-	jas_iccuint16_t year;
+    jas_iccuint16_t year;
-	jas_iccuint16_t month;
+    jas_iccuint16_t month;
-	jas_iccuint16_t day;
+    jas_iccuint16_t day;
-	jas_iccuint16_t hour;
+    jas_iccuint16_t hour;
-	jas_iccuint16_t min;
+    jas_iccuint16_t min;
-	jas_iccuint16_t sec;
+    jas_iccuint16_t sec;
 } jas_icctime_t;
 
 /* XYZ type. */
 typedef struct {
-	jas_iccs15fixed16_t x;
+    jas_iccs15fixed16_t x;
-	jas_iccs15fixed16_t y;
+    jas_iccs15fixed16_t y;
-	jas_iccs15fixed16_t z;
+    jas_iccs15fixed16_t z;
 } jas_iccxyz_t;
 
 /* Curve type. */
 typedef struct {
-	jas_iccuint32_t numents;
+    jas_iccuint32_t numents;
-	jas_iccuint16_t *ents;
+    jas_iccuint16_t *ents;
 } jas_icccurv_t;
 
 /* Text description type. */
 typedef struct {
-	jas_iccuint32_t asclen;
+    jas_iccuint32_t asclen;
-	char *ascdata; /* ASCII invariant description */
+    char *ascdata; /* ASCII invariant description */
-	jas_iccuint32_t uclangcode; /* Unicode language code */
+    jas_iccuint32_t uclangcode; /* Unicode language code */
-	jas_iccuint32_t uclen; /* Unicode localizable description count */
+    jas_iccuint32_t uclen; /* Unicode localizable description count */
-	uchar *ucdata; /* Unicode localizable description */
+    uchar *ucdata; /* Unicode localizable description */
-	jas_iccuint16_t sccode; /* ScriptCode code */
+    jas_iccuint16_t sccode; /* ScriptCode code */
-	jas_iccuint8_t maclen; /* Localizable Macintosh description count */
+    jas_iccuint8_t maclen; /* Localizable Macintosh description count */
-	uchar macdata[69]; /* Localizable Macintosh description */
+    uchar macdata[69]; /* Localizable Macintosh description */
 } jas_icctxtdesc_t;
 
 /* Text type. */
 typedef struct {
-	char *string;	/* ASCII character string */
+    char *string;	/* ASCII character string */
 } jas_icctxt_t;
 
 typedef struct {
-	jas_iccuint8_t numinchans;
+    jas_iccuint8_t numinchans;
-	jas_iccuint8_t numoutchans;
+    jas_iccuint8_t numoutchans;
-	jas_iccsint32_t e[3][3];
+    jas_iccsint32_t e[3][3];
-	jas_iccuint8_t clutlen;
+    jas_iccuint8_t clutlen;
-	jas_iccuint8_t *clut;
+    jas_iccuint8_t *clut;
-	jas_iccuint16_t numintabents;
+    jas_iccuint16_t numintabents;
-	jas_iccuint8_t **intabs;
+    jas_iccuint8_t **intabs;
-	jas_iccuint8_t *intabsbuf;
+    jas_iccuint8_t *intabsbuf;
-	jas_iccuint16_t numouttabents;
+    jas_iccuint16_t numouttabents;
-	jas_iccuint8_t **outtabs;
+    jas_iccuint8_t **outtabs;
-	jas_iccuint8_t *outtabsbuf;
+    jas_iccuint8_t *outtabsbuf;
 } jas_icclut8_t;
 
 typedef struct {
-	jas_iccuint8_t numinchans;
+    jas_iccuint8_t numinchans;
-	jas_iccuint8_t numoutchans;
+    jas_iccuint8_t numoutchans;
-	jas_iccsint32_t e[3][3];
+    jas_iccsint32_t e[3][3];
-	jas_iccuint8_t clutlen;
+    jas_iccuint8_t clutlen;
-	jas_iccuint16_t *clut;
+    jas_iccuint16_t *clut;
-	jas_iccuint16_t numintabents;
+    jas_iccuint16_t numintabents;
-	jas_iccuint16_t **intabs;
+    jas_iccuint16_t **intabs;
-	jas_iccuint16_t *intabsbuf;
+    jas_iccuint16_t *intabsbuf;
-	jas_iccuint16_t numouttabents;
+    jas_iccuint16_t numouttabents;
-	jas_iccuint16_t **outtabs;
+    jas_iccuint16_t **outtabs;
-	jas_iccuint16_t *outtabsbuf;
+    jas_iccuint16_t *outtabsbuf;
 } jas_icclut16_t;
 
 struct jas_iccattrval_s;
 
 typedef struct {
-	void (*destroy)(struct jas_iccattrval_s *);
+    void (*destroy)(struct jas_iccattrval_s *);
-	int (*copy)(struct jas_iccattrval_s *, struct jas_iccattrval_s *);
+    int (*copy)(struct jas_iccattrval_s *, struct jas_iccattrval_s *);
-	int (*input)(struct jas_iccattrval_s *, jas_stream_t *, int);
+    int (*input)(struct jas_iccattrval_s *, jas_stream_t *, int);
-	int (*output)(struct jas_iccattrval_s *, jas_stream_t *);
+    int (*output)(struct jas_iccattrval_s *, jas_stream_t *);
-	int (*getsize)(struct jas_iccattrval_s *);
+    int (*getsize)(struct jas_iccattrval_s *);
-	void (*dump)(struct jas_iccattrval_s *, FILE *);
+    void (*dump)(struct jas_iccattrval_s *, FILE *);
 } jas_iccattrvalops_t;
 
 /* Attribute value type (type and value information). */
 typedef struct jas_iccattrval_s {
-	int refcnt; /* reference count */
+    int refcnt; /* reference count */
-	jas_iccsig_t type; /* type */
+    jas_iccsig_t type; /* type */
-	jas_iccattrvalops_t *ops; /* type-dependent operations */
+    jas_iccattrvalops_t *ops; /* type-dependent operations */
-	union {
+    union {
-		jas_iccxyz_t xyz;
+        jas_iccxyz_t xyz;
-		jas_icccurv_t curv;
+        jas_icccurv_t curv;
-		jas_icctxtdesc_t txtdesc;
+        jas_icctxtdesc_t txtdesc;
-		jas_icctxt_t txt;
+        jas_icctxt_t txt;
-		jas_icclut8_t lut8;
+        jas_icclut8_t lut8;
-		jas_icclut16_t lut16;
+        jas_icclut16_t lut16;
-	} data; /* value */
+    } data; /* value */
 } jas_iccattrval_t;
 
 /* Header type. */
 typedef struct {
-	jas_iccuint32_t size; /* profile size */
+    jas_iccuint32_t size; /* profile size */
-	jas_iccsig_t cmmtype; /* CMM type signature */
+    jas_iccsig_t cmmtype; /* CMM type signature */
-	jas_iccuint32_t version; /* profile version */
+    jas_iccuint32_t version; /* profile version */
-	jas_iccsig_t clas; /* profile/device class signature */
+    jas_iccsig_t clas; /* profile/device class signature */
-	jas_iccsig_t colorspc; /* color space of data */
+    jas_iccsig_t colorspc; /* color space of data */
-	jas_iccsig_t refcolorspc; /* profile connection space */
+    jas_iccsig_t refcolorspc; /* profile connection space */
-	jas_icctime_t ctime; /* creation time */
+    jas_icctime_t ctime; /* creation time */
-	jas_iccsig_t magic; /* profile file signature */
+    jas_iccsig_t magic; /* profile file signature */
-	jas_iccsig_t platform; /* primary platform */
+    jas_iccsig_t platform; /* primary platform */
-	jas_iccuint32_t flags; /* profile flags */
+    jas_iccuint32_t flags; /* profile flags */
-	jas_iccsig_t maker; /* device manufacturer signature */
+    jas_iccsig_t maker; /* device manufacturer signature */
-	jas_iccsig_t model; /* device model signature */
+    jas_iccsig_t model; /* device model signature */
-	jas_iccuint64_t attr; /* device setup attributes */
+    jas_iccuint64_t attr; /* device setup attributes */
-	jas_iccsig_t intent; /* rendering intent */
+    jas_iccsig_t intent; /* rendering intent */
-	jas_iccxyz_t illum; /* illuminant */
+    jas_iccxyz_t illum; /* illuminant */
-	jas_iccsig_t creator; /* profile creator signature */
+    jas_iccsig_t creator; /* profile creator signature */
 } jas_icchdr_t;
 
 typedef struct {
-	jas_iccsig_t name;
+    jas_iccsig_t name;
-	jas_iccattrval_t *val;
+    jas_iccattrval_t *val;
 } jas_iccattr_t;
 
 typedef struct {
-	int numattrs;
+    int numattrs;
-	int maxattrs;
+    int maxattrs;
-	jas_iccattr_t *attrs;
+    jas_iccattr_t *attrs;
 } jas_iccattrtab_t;
 
 typedef struct jas_icctagtabent_s {
-	jas_iccuint32_t tag;
+    jas_iccuint32_t tag;
-	jas_iccuint32_t off;
+    jas_iccuint32_t off;
-	jas_iccuint32_t len;
+    jas_iccuint32_t len;
-	void *data;
+    void *data;
-	struct jas_icctagtabent_s *first;
+    struct jas_icctagtabent_s *first;
 } jas_icctagtabent_t;
 
 typedef struct {
-	jas_iccuint32_t numents;
+    jas_iccuint32_t numents;
-	jas_icctagtabent_t *ents;
+    jas_icctagtabent_t *ents;
 } jas_icctagtab_t;
 
 /* ICC profile type. */
 typedef struct {
-	jas_icchdr_t hdr;
+    jas_icchdr_t hdr;
-	jas_icctagtab_t tagtab;
+    jas_icctagtab_t tagtab;
-	jas_iccattrtab_t *attrtab;
+    jas_iccattrtab_t *attrtab;
 } jas_iccprof_t;
 
 typedef struct {
-	jas_iccuint32_t type;
+    jas_iccuint32_t type;
-	jas_iccattrvalops_t ops;
+    jas_iccattrvalops_t ops;
 } jas_iccattrvalinfo_t;
 
 jas_iccprof_t *jas_iccprof_load(jas_stream_t *in);

3rdparty/libjasper/jasper/jas_image.h

@@ -6,15 +6,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,
@@ -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__
  */
 
@@ -137,44 +137,44 @@ typedef int_fast16_t jas_image_smpltype_t;
 
 typedef struct {
 
-	jas_image_coord_t tlx_;
+    jas_image_coord_t tlx_;
-	/* The x-coordinate of the top-left corner of the component. */
+    /* The x-coordinate of the top-left corner of the component. */
 
-	jas_image_coord_t tly_;
+    jas_image_coord_t tly_;
-	/* The y-coordinate of the top-left corner of the component. */
+    /* The y-coordinate of the top-left corner of the component. */
 
-	jas_image_coord_t hstep_;
+    jas_image_coord_t hstep_;
-	/* The horizontal sampling period in units of the reference grid. */
+    /* The horizontal sampling period in units of the reference grid. */
 
-	jas_image_coord_t vstep_;
+    jas_image_coord_t vstep_;
-	/* The vertical sampling period in units of the reference grid. */
+    /* The vertical sampling period in units of the reference grid. */
 
-	jas_image_coord_t width_;
+    jas_image_coord_t width_;
-	/* The component width in samples. */
+    /* The component width in samples. */
 
-	jas_image_coord_t height_;
+    jas_image_coord_t height_;
-	/* The component height in samples. */
+    /* The component height in samples. */
 
 #ifdef FIX_ME
-	int smpltype_;
+    int smpltype_;
 #else
-	int prec_;
+    int prec_;
-	/* The precision of the sample data (i.e., the number of bits per
+    /* The precision of the sample data (i.e., the number of bits per
-	sample).  If the samples are signed values, this quantity
+    sample).  If the samples are signed values, this quantity
-	includes the sign bit. */
+    includes the sign bit. */
 
-	int sgnd_;
+    int sgnd_;
-	/* The signedness of the sample data. */
+    /* The signedness of the sample data. */
 #endif
 
-	jas_stream_t *stream_;
+    jas_stream_t *stream_;
-	/* The stream containing the component data. */
+    /* The stream containing the component data. */
 
-	int cps_;
+    int cps_;
-	/* The number of characters per sample in the stream. */
+    /* The number of characters per sample in the stream. */
 
-	jas_image_cmpttype_t type_;
+    jas_image_cmpttype_t type_;
-	/* The type of component (e.g., opacity, red, green, blue, luma). */
+    /* The type of component (e.g., opacity, red, green, blue, luma). */
 
 } jas_image_cmpt_t;
 
@@ -182,35 +182,35 @@ typedef struct {
 
 typedef struct {
 
-	jas_image_coord_t tlx_;
+    jas_image_coord_t tlx_;
-	/* The x-coordinate of the top-left corner of the image bounding box. */
+    /* The x-coordinate of the top-left corner of the image bounding box. */
 
-	jas_image_coord_t tly_;
+    jas_image_coord_t tly_;
-	/* The y-coordinate of the top-left corner of the image bounding box. */
+    /* The y-coordinate of the top-left corner of the image bounding box. */
 
-	jas_image_coord_t brx_;
+    jas_image_coord_t brx_;
-	/* The x-coordinate of the bottom-right corner of the image bounding
+    /* The x-coordinate of the bottom-right corner of the image bounding
-	  box (plus one). */
+      box (plus one). */
 
-	jas_image_coord_t bry_;
+    jas_image_coord_t bry_;
-	/* The y-coordinate of the bottom-right corner of the image bounding
+    /* The y-coordinate of the bottom-right corner of the image bounding
-	  box (plus one). */
+      box (plus one). */
 
-	int numcmpts_;
+    int numcmpts_;
-	/* The number of components. */
+    /* The number of components. */
 
-	int maxcmpts_;
+    int maxcmpts_;
-	/* The maximum number of components that this image can have (i.e., the
+    /* The maximum number of components that this image can have (i.e., the
-	  allocated size of the components array). */
+      allocated size of the components array). */
 
-	jas_image_cmpt_t **cmpts_;
+    jas_image_cmpt_t **cmpts_;
-	/* Per-component information. */
+    /* Per-component information. */
 
-	jas_clrspc_t clrspc_;
+    jas_clrspc_t clrspc_;
 
-	jas_cmprof_t *cmprof_;
+    jas_cmprof_t *cmprof_;
 
-	bool inmem_;
+    bool inmem_;
 
 } jas_image_t;
 
@@ -220,32 +220,32 @@ typedef struct {
 
 typedef struct {
 
-	jas_image_coord_t tlx;
+    jas_image_coord_t tlx;
-	/* The x-coordinate of the top-left corner of the component. */
+    /* The x-coordinate of the top-left corner of the component. */
 
-	jas_image_coord_t tly;
+    jas_image_coord_t tly;
-	/* The y-coordinate of the top-left corner of the component. */
+    /* The y-coordinate of the top-left corner of the component. */
 
-	jas_image_coord_t hstep;
+    jas_image_coord_t hstep;
-	/* The horizontal sampling period in units of the reference grid. */
+    /* The horizontal sampling period in units of the reference grid. */
 
-	jas_image_coord_t vstep;
+    jas_image_coord_t vstep;
-	/* The vertical sampling period in units of the reference grid. */
+    /* The vertical sampling period in units of the reference grid. */
 
-	jas_image_coord_t width;
+    jas_image_coord_t width;
-	/* The width of the component in samples. */
+    /* The width of the component in samples. */
 
-	jas_image_coord_t height;
+    jas_image_coord_t height;
-	/* The height of the component in samples. */
+    /* The height of the component in samples. */
 
 #ifdef FIX_ME
-	int smpltype;
+    int smpltype;
 #else
-	int prec;
+    int prec;
-	/* The precision of the component sample data. */
+    /* The precision of the component sample data. */
 
-	int sgnd;
+    int sgnd;
-	/* The signedness of the component sample data. */
+    /* The signedness of the component sample data. */
 #endif
 
 } jas_image_cmptparm_t;
@@ -261,14 +261,14 @@ typedef struct {
 
 typedef struct {
 
-	jas_image_t *(*decode)(jas_stream_t *in, char *opts);
+    jas_image_t *(*decode)(jas_stream_t *in, char *opts);
-	/* Decode image data from a stream. */
+    /* Decode image data from a stream. */
 
-	int (*encode)(jas_image_t *image, jas_stream_t *out, char *opts);
+    int (*encode)(jas_image_t *image, jas_stream_t *out, char *opts);
-	/* Encode image data to a stream. */
+    /* Encode image data to a stream. */
 
-	int (*validate)(jas_stream_t *in);
+    int (*validate)(jas_stream_t *in);
-	/* Determine if stream data is in a particular format. */
+    /* Determine if stream data is in a particular format. */
 
 } jas_image_fmtops_t;
 
@@ -276,20 +276,20 @@ typedef struct {
 
 typedef struct {
 
-	int id;
+    int id;
-	/* The ID for this format. */
+    /* The ID for this format. */
 
-	char *name;
+    char *name;
-	/* The name by which this format is identified. */
+    /* The name by which this format is identified. */
 
-	char *ext;
+    char *ext;
-	/* The file name extension associated with this format. */
+    /* The file name extension associated with this format. */
 
-	char *desc;
+    char *desc;
-	/* A brief description of the format. */
+    /* A brief description of the format. */
 
-	jas_image_fmtops_t ops;
+    jas_image_fmtops_t ops;
-	/* The operations for this format. */
+    /* The operations for this format. */
 
 } jas_image_fmtinfo_t;
 
@@ -312,92 +312,92 @@ void jas_image_destroy(jas_image_t *image);
 
 /* Get the width of the image in units of the image reference grid. */
 #define jas_image_width(image) \
-	((image)->brx_ - (image)->tlx_)
+    ((image)->brx_ - (image)->tlx_)
 
 /* Get the height of the image in units of the image reference grid. */
 #define	jas_image_height(image) \
-	((image)->bry_ - (image)->tly_)
+    ((image)->bry_ - (image)->tly_)
 
 /* Get the x-coordinate of the top-left corner of the image bounding box
   on the reference grid. */
 #define jas_image_tlx(image) \
-	((image)->tlx_)
+    ((image)->tlx_)
 
 /* Get the y-coordinate of the top-left corner of the image bounding box
   on the reference grid. */
 #define jas_image_tly(image) \
-	((image)->tly_)
+    ((image)->tly_)
 
 /* Get the x-coordinate of the bottom-right corner of the image bounding box
   on the reference grid (plus one). */
 #define jas_image_brx(image) \
-	((image)->brx_)
+    ((image)->brx_)
 
 /* Get the y-coordinate of the bottom-right corner of the image bounding box
   on the reference grid (plus one). */
 #define jas_image_bry(image) \
-	((image)->bry_)
+    ((image)->bry_)
 
 /* Get the number of image components. */
 #define	jas_image_numcmpts(image) \
-	((image)->numcmpts_)
+    ((image)->numcmpts_)
 
 /* Get the color model used by the image. */
 #define	jas_image_clrspc(image) \
-	((image)->clrspc_)
+    ((image)->clrspc_)
 
 /* Set the color model for an image. */
 #define jas_image_setclrspc(image, clrspc) \
-	((image)->clrspc_ = (clrspc))
+    ((image)->clrspc_ = (clrspc))
 
 #define jas_image_cmpttype(image, cmptno) \
-	((image)->cmpts_[(cmptno)]->type_)
+    ((image)->cmpts_[(cmptno)]->type_)
 #define jas_image_setcmpttype(image, cmptno, type) \
-	((image)->cmpts_[(cmptno)]->type_ = (type))
+    ((image)->cmpts_[(cmptno)]->type_ = (type))
 
 /* Get the width of a component. */
 #define	jas_image_cmptwidth(image, cmptno) \
-	((image)->cmpts_[cmptno]->width_)
+    ((image)->cmpts_[cmptno]->width_)
 
 /* Get the height of a component. */
 #define	jas_image_cmptheight(image, cmptno) \
-	((image)->cmpts_[cmptno]->height_)
+    ((image)->cmpts_[cmptno]->height_)
 
 /* Get the signedness of the sample data for a component. */
 #define	jas_image_cmptsgnd(image, cmptno) \
-	((image)->cmpts_[cmptno]->sgnd_)
+    ((image)->cmpts_[cmptno]->sgnd_)
 
 /* Get the precision of the sample data for a component. */
 #define	jas_image_cmptprec(image, cmptno) \
-	((image)->cmpts_[cmptno]->prec_)
+    ((image)->cmpts_[cmptno]->prec_)
 
 /* Get the horizontal subsampling factor for a component. */
 #define	jas_image_cmpthstep(image, cmptno) \
-	((image)->cmpts_[cmptno]->hstep_)
+    ((image)->cmpts_[cmptno]->hstep_)
 
 /* Get the vertical subsampling factor for a component. */
 #define	jas_image_cmptvstep(image, cmptno) \
-	((image)->cmpts_[cmptno]->vstep_)
+    ((image)->cmpts_[cmptno]->vstep_)
 
 /* Get the x-coordinate of the top-left corner of a component. */
 #define	jas_image_cmpttlx(image, cmptno) \
-	((image)->cmpts_[cmptno]->tlx_)
+    ((image)->cmpts_[cmptno]->tlx_)
 
 /* Get the y-coordinate of the top-left corner of a component. */
 #define	jas_image_cmpttly(image, cmptno) \
-	((image)->cmpts_[cmptno]->tly_)
+    ((image)->cmpts_[cmptno]->tly_)
 
 /* Get the x-coordinate of the bottom-right corner of a component
   (plus "one"). */
 #define	jas_image_cmptbrx(image, cmptno) \
-	((image)->cmpts_[cmptno]->tlx_ + (image)->cmpts_[cmptno]->width_ * \
+    ((image)->cmpts_[cmptno]->tlx_ + (image)->cmpts_[cmptno]->width_ * \
-	  (image)->cmpts_[cmptno]->hstep_)
+      (image)->cmpts_[cmptno]->hstep_)
 
 /* Get the y-coordinate of the bottom-right corner of a component
   (plus "one"). */
 #define	jas_image_cmptbry(image, cmptno) \
-	((image)->cmpts_[cmptno]->tly_ + (image)->cmpts_[cmptno]->height_ * \
+    ((image)->cmpts_[cmptno]->tly_ + (image)->cmpts_[cmptno]->height_ * \
-	  (image)->cmpts_[cmptno]->vstep_)
+      (image)->cmpts_[cmptno]->vstep_)
 
 /* Get the raw size of an image (i.e., the nominal size of the image without
   any compression. */
@@ -439,7 +439,7 @@ int jas_image_copycmpt(jas_image_t *dstimage, int dstcmptno,
 #define	JAS_IMAGE_CDT_SETPREC(dtype) ((dtype) & 0x7f)
 
 #define	jas_image_cmptdtype(image, cmptno) \
-	(JAS_IMAGE_CDT_SETSGND((image)->cmpts_[cmptno]->sgnd_) | JAS_IMAGE_CDT_SETPREC((image)->cmpts_[cmptno]->prec_))
+    (JAS_IMAGE_CDT_SETSGND((image)->cmpts_[cmptno]->sgnd_) | JAS_IMAGE_CDT_SETPREC((image)->cmpts_[cmptno]->prec_))
 
 int jas_image_depalettize(jas_image_t *image, int cmptno, int numlutents,
   int_fast32_t *lutents, int dtype, int newcmptno);

3rdparty/libjasper/jasper/jas_init.h

@@ -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__
  */
 

3rdparty/libjasper/jasper/jas_malloc.h

@@ -6,15 +6,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,
@@ -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__
  */
 

3rdparty/libjasper/jasper/jas_math.h

@@ -6,15 +6,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,
@@ -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__
  */
 
@@ -90,20 +90,20 @@ extern "C" {
 
 /* Compute the absolute value. */
 #define	JAS_ABS(x) \
-	(((x) >= 0) ? (x) : (-(x)))
+    (((x) >= 0) ? (x) : (-(x)))
 
 /* Compute the minimum of two values. */
 #define	JAS_MIN(x, y) \
-	(((x) < (y)) ? (x) : (y))
+    (((x) < (y)) ? (x) : (y))
 
 /* Compute the maximum of two values. */
 #define	JAS_MAX(x, y) \
-	(((x) > (y)) ? (x) : (y))
+    (((x) > (y)) ? (x) : (y))
 
 /* Compute the remainder from division (where division is defined such
   that the remainder is always nonnegative). */
 #define	JAS_MOD(x, y) \
-	(((x) < 0) ? (((-x) % (y)) ? ((y) - ((-(x)) % (y))) : (0)) : ((x) % (y)))
+    (((x) < 0) ? (((-x) % (y)) ? ((y) - ((-(x)) % (y))) : (0)) : ((x) % (y)))
 
 /* Compute the integer with the specified number of least significant bits
   set to one. */

3rdparty/libjasper/jasper/jas_seq.h

@@ -6,15 +6,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,
@@ -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__
  */
 
@@ -104,38 +104,38 @@ typedef int_fast32_t jas_matent_t;
 
 typedef struct {
 
-	/* Additional state information. */
+    /* Additional state information. */
-	int flags_;
+    int flags_;
 
-	/* The starting horizontal index. */
+    /* The starting horizontal index. */
-	int_fast32_t xstart_;
+    int_fast32_t xstart_;
 
-	/* The starting vertical index. */
+    /* The starting vertical index. */
-	int_fast32_t ystart_;
+    int_fast32_t ystart_;
 
-	/* The ending horizontal index. */
+    /* The ending horizontal index. */
-	int_fast32_t xend_;
+    int_fast32_t xend_;
 
-	/* The ending vertical index. */
+    /* The ending vertical index. */
-	int_fast32_t yend_;
+    int_fast32_t yend_;
 
-	/* The number of rows in the matrix. */
+    /* The number of rows in the matrix. */
-	int_fast32_t numrows_;
+    int_fast32_t numrows_;
 
-	/* The number of columns in the matrix. */
+    /* The number of columns in the matrix. */
-	int_fast32_t numcols_;
+    int_fast32_t numcols_;
 
-	/* Pointers to the start of each row. */
+    /* Pointers to the start of each row. */
-	jas_seqent_t **rows_;
+    jas_seqent_t **rows_;
 
-	/* The allocated size of the rows array. */
+    /* The allocated size of the rows array. */
-	int_fast32_t maxrows_;
+    int_fast32_t maxrows_;
 
-	/* The matrix data buffer. */
+    /* The matrix data buffer. */
-	jas_seqent_t *data_;
+    jas_seqent_t *data_;
 
-	/* The allocated size of the data array. */
+    /* The allocated size of the data array. */
-	int_fast32_t datasize_;
+    int_fast32_t datasize_;
 
 } jas_matrix_t;
 
@@ -148,39 +148,39 @@ typedef jas_matrix_t jas_seq_t;
 
 /* Get the number of rows. */
 #define jas_matrix_numrows(matrix) \
-	((matrix)->numrows_)
+    ((matrix)->numrows_)
 
 /* Get the number of columns. */
 #define jas_matrix_numcols(matrix) \
-	((matrix)->numcols_)
+    ((matrix)->numcols_)
 
 /* Get a matrix element. */
 #define jas_matrix_get(matrix, i, j) \
-	((matrix)->rows_[i][j])
+    ((matrix)->rows_[i][j])
 
 /* Set a matrix element. */
 #define jas_matrix_set(matrix, i, j, v) \
-	((matrix)->rows_[i][j] = (v))
+    ((matrix)->rows_[i][j] = (v))
 
 /* Get an element from a matrix that is known to be a row or column vector. */
 #define jas_matrix_getv(matrix, i) \
-	(((matrix)->numrows_ == 1) ? ((matrix)->rows_[0][i]) : \
+    (((matrix)->numrows_ == 1) ? ((matrix)->rows_[0][i]) : \
-	  ((matrix)->rows_[i][0]))
+      ((matrix)->rows_[i][0]))
 
 /* Set an element in a matrix that is known to be a row or column vector. */
 #define jas_matrix_setv(matrix, i, v) \
-	(((matrix)->numrows_ == 1) ? ((matrix)->rows_[0][i] = (v)) : \
+    (((matrix)->numrows_ == 1) ? ((matrix)->rows_[0][i] = (v)) : \
-	  ((matrix)->rows_[i][0] = (v)))
+      ((matrix)->rows_[i][0] = (v)))
 
 /* Get the address of an element in a matrix. */
 #define	jas_matrix_getref(matrix, i, j) \
-	(&(matrix)->rows_[i][j])
+    (&(matrix)->rows_[i][j])
 
 #define	jas_matrix_getvref(matrix, i) \
-	(((matrix)->numrows_ > 1) ? jas_matrix_getref(matrix, i, 0) : jas_matrix_getref(matrix, 0, i))
+    (((matrix)->numrows_ > 1) ? jas_matrix_getref(matrix, i, 0) : jas_matrix_getref(matrix, 0, i))
 
 #define jas_matrix_length(matrix) \
-	(max((matrix)->numrows_, (matrix)->numcols_))
+    (max((matrix)->numrows_, (matrix)->numcols_))
 
 /* Create a matrix with the specified dimensions. */
 jas_matrix_t *jas_matrix_create(int numrows, int numcols);
@@ -223,11 +223,11 @@ void jas_matrix_setall(jas_matrix_t *matrix, jas_seqent_t val);
 
 /* The spacing between rows of a matrix. */
 #define	jas_matrix_rowstep(matrix) \
-	(((matrix)->numrows_ > 1) ? ((matrix)->rows_[1] - (matrix)->rows_[0]) : (0))
+    (((matrix)->numrows_ > 1) ? ((matrix)->rows_[1] - (matrix)->rows_[0]) : (0))
 
 /* The spacing between columns of a matrix. */
 #define	jas_matrix_step(matrix) \
-	(((matrix)->numrows_ > 1) ? (jas_matrix_rowstep(matrix)) : (1))
+    (((matrix)->numrows_ > 1) ? (jas_matrix_rowstep(matrix)) : (1))
 
 /* Compare two matrices for equality. */
 int jas_matrix_cmp(jas_matrix_t *mat0, jas_matrix_t *mat1);
@@ -245,30 +245,30 @@ jas_seq2d_t *jas_seq2d_copy(jas_seq2d_t *x);
 jas_matrix_t *jas_seq2d_create(int xstart, int ystart, int xend, int yend);
 
 #define	jas_seq2d_destroy(s) \
-	jas_matrix_destroy(s)
+    jas_matrix_destroy(s)
 
 #define	jas_seq2d_xstart(s) \
-	((s)->xstart_)
+    ((s)->xstart_)
 #define	jas_seq2d_ystart(s) \
-	((s)->ystart_)
+    ((s)->ystart_)
 #define	jas_seq2d_xend(s) \
-	((s)->xend_)
+    ((s)->xend_)
 #define	jas_seq2d_yend(s) \
-	((s)->yend_)
+    ((s)->yend_)
 #define	jas_seq2d_getref(s, x, y) \
-	(jas_matrix_getref(s, (y) - (s)->ystart_, (x) - (s)->xstart_))
+    (jas_matrix_getref(s, (y) - (s)->ystart_, (x) - (s)->xstart_))
 #define	jas_seq2d_get(s, x, y) \
-	(jas_matrix_get(s, (y) - (s)->ystart_, (x) - (s)->xstart_))
+    (jas_matrix_get(s, (y) - (s)->ystart_, (x) - (s)->xstart_))
 #define	jas_seq2d_rowstep(s) \
-	jas_matrix_rowstep(s)
+    jas_matrix_rowstep(s)
 #define	jas_seq2d_width(s) \
-	((s)->xend_ - (s)->xstart_)
+    ((s)->xend_ - (s)->xstart_)
 #define	jas_seq2d_height(s) \
-	((s)->yend_ - (s)->ystart_)
+    ((s)->yend_ - (s)->ystart_)
 #define	jas_seq2d_setshift(s, x, y) \
-	((s)->xstart_ = (x), (s)->ystart_ = (y), \
+    ((s)->xstart_ = (x), (s)->ystart_ = (y), \
-	  (s)->xend_ = (s)->xstart_ + (s)->numcols_, \
+      (s)->xend_ = (s)->xstart_ + (s)->numcols_, \
-	  (s)->yend_ = (s)->ystart_ + (s)->numrows_)
+      (s)->yend_ = (s)->ystart_ + (s)->numrows_)
 
 void jas_seq2d_bindsub(jas_matrix_t *s, jas_matrix_t *s1, int xstart,
   int ystart, int xend, int yend);
@@ -278,21 +278,21 @@ void jas_seq2d_bindsub(jas_matrix_t *s, jas_matrix_t *s1, int xstart,
 \******************************************************************************/
 
 #define	jas_seq_create(start, end) \
-	(jas_seq2d_create(start, 0, end, 1))
+    (jas_seq2d_create(start, 0, end, 1))
 
 #define	jas_seq_destroy(seq) \
-	(jas_seq2d_destroy(seq))
+    (jas_seq2d_destroy(seq))
 
 #define jas_seq_set(seq, i, v) \
-	((seq)->rows_[0][(i) - (seq)->xstart_] = (v))
+    ((seq)->rows_[0][(i) - (seq)->xstart_] = (v))
 #define	jas_seq_getref(seq, i) \
-	(&(seq)->rows_[0][(i) - (seq)->xstart_])
+    (&(seq)->rows_[0][(i) - (seq)->xstart_])
 #define	jas_seq_get(seq, i) \
-	((seq)->rows_[0][(i) - (seq)->xstart_])
+    ((seq)->rows_[0][(i) - (seq)->xstart_])
 #define	jas_seq_start(seq) \
-	((seq)->xstart_)
+    ((seq)->xstart_)
 #define	jas_seq_end(seq) \
-	((seq)->xend_)
+    ((seq)->xend_)
 
 #ifdef __cplusplus
 }

3rdparty/libjasper/jasper/jas_stream.h

@@ -6,15 +6,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,
@@ -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__
  */
 
@@ -149,7 +149,7 @@ extern "C" {
 #define	JAS_STREAM_RWLIMIT	0x0004
 /* The error mask. */
 #define JAS_STREAM_ERRMASK \
-	(JAS_STREAM_EOF | JAS_STREAM_ERR | JAS_STREAM_RWLIMIT)
+    (JAS_STREAM_EOF | JAS_STREAM_ERR | JAS_STREAM_RWLIMIT)
 
 /*
  * Other miscellaneous constants.
@@ -179,17 +179,17 @@ typedef void jas_stream_obj_t;
 
 typedef struct {
 
-	/* Read characters from a file object. */
+    /* Read characters from a file object. */
-	int (*read_)(jas_stream_obj_t *obj, char *buf, int cnt);
+    int (*read_)(jas_stream_obj_t *obj, char *buf, int cnt);
 
-	/* Write characters to a file object. */
+    /* Write characters to a file object. */
-	int (*write_)(jas_stream_obj_t *obj, char *buf, int cnt);
+    int (*write_)(jas_stream_obj_t *obj, char *buf, int cnt);
 
-	/* Set the position for a file object. */
+    /* Set the position for a file object. */
-	long (*seek_)(jas_stream_obj_t *obj, long offset, int origin);
+    long (*seek_)(jas_stream_obj_t *obj, long offset, int origin);
 
-	/* Close a file object. */
+    /* Close a file object. */
-	int (*close_)(jas_stream_obj_t *obj);
+    int (*close_)(jas_stream_obj_t *obj);
 
 } jas_stream_ops_t;
 
@@ -199,46 +199,46 @@ typedef struct {
 
 typedef struct {
 
-	/* The mode in which the stream was opened. */
+    /* The mode in which the stream was opened. */
-	int openmode_;
+    int openmode_;
 
-	/* The buffering mode. */
+    /* The buffering mode. */
-	int bufmode_;
+    int bufmode_;
 
-	/* The stream status. */
+    /* The stream status. */
-	int flags_;
+    int flags_;
 
-	/* The start of the buffer area to use for reading/writing. */
+    /* The start of the buffer area to use for reading/writing. */
-	uchar *bufbase_;
+    uchar *bufbase_;
 
-	/* The start of the buffer area excluding the extra initial space for
+    /* The start of the buffer area excluding the extra initial space for
-	  character putback. */
+      character putback. */
-	uchar *bufstart_;
+    uchar *bufstart_;
 
-	/* The buffer size. */
+    /* The buffer size. */
-	int bufsize_;
+    int bufsize_;
 
-	/* The current position in the buffer. */
+    /* The current position in the buffer. */
-	uchar *ptr_;
+    uchar *ptr_;
 
-	/* The number of characters that must be read/written before
+    /* The number of characters that must be read/written before
-	the buffer needs to be filled/flushed. */
+    the buffer needs to be filled/flushed. */
-	int cnt_;
+    int cnt_;
 
-	/* A trivial buffer to be used for unbuffered operation. */
+    /* A trivial buffer to be used for unbuffered operation. */
-	uchar tinybuf_[JAS_STREAM_MAXPUTBACK + 1];
+    uchar tinybuf_[JAS_STREAM_MAXPUTBACK + 1];
 
-	/* The operations for the underlying stream file object. */
+    /* The operations for the underlying stream file object. */
-	jas_stream_ops_t *ops_;
+    jas_stream_ops_t *ops_;
 
-	/* The underlying stream file object. */
+    /* The underlying stream file object. */
-	jas_stream_obj_t *obj_;
+    jas_stream_obj_t *obj_;
 
-	/* The number of characters read/written. */
+    /* The number of characters read/written. */
-	long rwcnt_;
+    long rwcnt_;
 
-	/* The maximum number of characters that may be read/written. */
+    /* The maximum number of characters that may be read/written. */
-	long rwlimit_;
+    long rwlimit_;
 
 } jas_stream_t;
 
@@ -250,12 +250,12 @@ typedef struct {
  * File descriptor file object.
  */
 typedef struct {
-	int fd;
+    int fd;
-	int flags;
+    int flags;
 #if defined _WIN32 && !defined __MINGW__ && !defined __MINGW32__
-	char pathname[MAX_PATH + 1];
+    char pathname[MAX_PATH + 1];
 #else
-	char pathname[PATH_MAX + 1];
+    char pathname[PATH_MAX + 1];
 #endif
 } jas_stream_fileobj_t;
 
@@ -268,23 +268,23 @@ typedef struct {
 
 typedef struct {
 
-	/* The data associated with this file. */
+    /* The data associated with this file. */
-	uchar *buf_;
+    uchar *buf_;
 
-	/* The allocated size of the buffer for holding file data. */
+    /* The allocated size of the buffer for holding file data. */
-	int bufsize_;
+    int bufsize_;
 
-	/* The length of the file. */
+    /* The length of the file. */
-	int_fast32_t len_;
+    int_fast32_t len_;
 
-	/* The seek position. */
+    /* The seek position. */
-	int_fast32_t pos_;
+    int_fast32_t pos_;
 
-	/* Is the buffer growable? */
+    /* Is the buffer growable? */
-	int growable_;
+    int growable_;
 
-	/* Was the buffer allocated internally? */
+    /* Was the buffer allocated internally? */
-	int myalloc_;
+    int myalloc_;
 
 } jas_stream_memobj_t;
 
@@ -316,26 +316,26 @@ int jas_stream_close(jas_stream_t *stream);
 
 /* Get the EOF indicator for a stream. */
 #define jas_stream_eof(stream) \
-	(((stream)->flags_ & JAS_STREAM_EOF) != 0)
+    (((stream)->flags_ & JAS_STREAM_EOF) != 0)
 
 /* Get the error indicator for a stream. */
 #define jas_stream_error(stream) \
-	(((stream)->flags_ & JAS_STREAM_ERR) != 0)
+    (((stream)->flags_ & JAS_STREAM_ERR) != 0)
 
 /* Clear the error indicator for a stream. */
 #define jas_stream_clearerr(stream) \
-	((stream)->flags_ &= ~(JAS_STREAM_ERR | JAS_STREAM_EOF))
+    ((stream)->flags_ &= ~(JAS_STREAM_ERR | JAS_STREAM_EOF))
 
 /* Get the read/write limit for a stream. */
 #define	jas_stream_getrwlimit(stream) \
-	(((const jas_stream_t *)(stream))->rwlimit_)
+    (((const jas_stream_t *)(stream))->rwlimit_)
 
 /* Set the read/write limit for a stream. */
 int jas_stream_setrwlimit(jas_stream_t *stream, long rwlimit);
 
 /* Get the read/write count for a stream. */
 #define	jas_stream_getrwcount(stream) \
-	(((const jas_stream_t *)(stream))->rwcnt_)
+    (((const jas_stream_t *)(stream))->rwcnt_)
 
 /* Set the read/write count for a stream. */
 long jas_stream_setrwcount(jas_stream_t *stream, long rwcnt);
@@ -376,8 +376,8 @@ char *jas_stream_gets(jas_stream_t *stream, char *buf, int bufsize);
 /* Look at the next character to be read from a stream without actually
   removing it from the stream. */
 #define	jas_stream_peekc(stream) \
-	(((stream)->cnt_ <= 0) ? jas_stream_fillbuf(stream, 0) : \
+    (((stream)->cnt_ <= 0) ? jas_stream_fillbuf(stream, 0) : \
-	  ((int)(*(stream)->ptr_)))
+      ((int)(*(stream)->ptr_)))
 
 /* Put a character back on a stream. */
 int jas_stream_ungetc(jas_stream_t *stream, int c);
@@ -434,26 +434,26 @@ directly, you will die a horrible, miserable, and painful death! */
 
 /* Read a character from a stream. */
 #define jas_stream_getc_macro(stream) \
-	((!((stream)->flags_ & (JAS_STREAM_ERR | JAS_STREAM_EOF | \
+    ((!((stream)->flags_ & (JAS_STREAM_ERR | JAS_STREAM_EOF | \
-	  JAS_STREAM_RWLIMIT))) ? \
+      JAS_STREAM_RWLIMIT))) ? \
-	  (((stream)->rwlimit_ >= 0 && (stream)->rwcnt_ >= (stream)->rwlimit_) ? \
+      (((stream)->rwlimit_ >= 0 && (stream)->rwcnt_ >= (stream)->rwlimit_) ? \
-	  (stream->flags_ |= JAS_STREAM_RWLIMIT, EOF) : \
+      (stream->flags_ |= JAS_STREAM_RWLIMIT, EOF) : \
-	  jas_stream_getc2(stream)) : EOF)
+      jas_stream_getc2(stream)) : EOF)
 #define jas_stream_getc2(stream) \
-	((--(stream)->cnt_ < 0) ? jas_stream_fillbuf(stream, 1) : \
+    ((--(stream)->cnt_ < 0) ? jas_stream_fillbuf(stream, 1) : \
-	  (++(stream)->rwcnt_, (int)(*(stream)->ptr_++)))
+      (++(stream)->rwcnt_, (int)(*(stream)->ptr_++)))
 
 /* Write a character to a stream. */
 #define jas_stream_putc_macro(stream, c) \
-	((!((stream)->flags_ & (JAS_STREAM_ERR | JAS_STREAM_EOF | \
+    ((!((stream)->flags_ & (JAS_STREAM_ERR | JAS_STREAM_EOF | \
-	  JAS_STREAM_RWLIMIT))) ? \
+      JAS_STREAM_RWLIMIT))) ? \
-	  (((stream)->rwlimit_ >= 0 && (stream)->rwcnt_ >= (stream)->rwlimit_) ? \
+      (((stream)->rwlimit_ >= 0 && (stream)->rwcnt_ >= (stream)->rwlimit_) ? \
-	  (stream->flags_ |= JAS_STREAM_RWLIMIT, EOF) : \
+      (stream->flags_ |= JAS_STREAM_RWLIMIT, EOF) : \
-	  jas_stream_putc2(stream, c)) : EOF)
+      jas_stream_putc2(stream, c)) : EOF)
 #define jas_stream_putc2(stream, c) \
-	(((stream)->bufmode_ |= JAS_STREAM_WRBUF, --(stream)->cnt_ < 0) ? \
+    (((stream)->bufmode_ |= JAS_STREAM_WRBUF, --(stream)->cnt_ < 0) ? \
-	  jas_stream_flushbuf((stream), (uchar)(c)) : \
+      jas_stream_flushbuf((stream), (uchar)(c)) : \
-	  (++(stream)->rwcnt_, (int)(*(stream)->ptr_++ = (c))))
+      (++(stream)->rwcnt_, (int)(*(stream)->ptr_++ = (c))))
 
 /* These prototypes need to be here for the sake of the stream_getc and
 stream_putc macros. */

3rdparty/libjasper/jasper/jas_string.h

@@ -6,15 +6,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,
@@ -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__
  */
 

3rdparty/libjasper/jasper/jas_tmr.h

@@ -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__
  */
 
@@ -75,15 +75,15 @@ extern "C" {
 #if defined(HAVE_GETTIMEOFDAY)
 
 typedef struct {
-	struct timeval start;
+    struct timeval start;
-	struct timeval stop;
+    struct timeval stop;
 } jas_tmr_t;
 
 #elif defined(HAVE_GETRUSAGE)
 
 typedef struct {
-	struct rusage start;
+    struct rusage start;
-	struct rusage stop;
+    struct rusage stop;
 } jas_tmr_t;
 
 #else

3rdparty/libjasper/jasper/jas_tvp.h

@@ -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__
  */
 
@@ -86,11 +86,11 @@ extern "C" {
 
 typedef struct {
 
-	int id;
+    int id;
-	/* The ID for the tag. */
+    /* The ID for the tag. */
 
-	char *name;
+    char *name;
-	/* The name of the tag. */
+    /* The name of the tag. */
 
 } jas_taginfo_t;
 
@@ -98,17 +98,17 @@ typedef struct {
 
 typedef struct {
 
-	char *buf;
+    char *buf;
-	/* The parsing buffer. */
+    /* The parsing buffer. */
 
-	char *tag;
+    char *tag;
-	/* The current tag name. */
+    /* The current tag name. */
 
-	char *val;
+    char *val;
-	/* The current value. */
+    /* The current value. */
 
-	char *pos;
+    char *pos;
-	/* The current position in the parsing buffer. */
+    /* The current position in the parsing buffer. */
 
 } jas_tvparser_t;
 

3rdparty/libjasper/jasper/jas_types.h

@@ -6,15 +6,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,
@@ -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__
  */
 
@@ -215,7 +215,7 @@ typedef ulonglong uint_fast64_t;
   macro, type casts can be easily located in the source code with
   tools like "grep". */
 #define	JAS_CAST(t, e) \
-	((t) (e))
+    ((t) (e))
 
 #ifdef __cplusplus
 extern "C" {

3rdparty/libjasper/jasper/jas_version.h

@@ -6,15 +6,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,
@@ -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__
  */
 
@@ -85,24 +85,24 @@ extern "C" {
 #endif
 
 #define	JAS_COPYRIGHT \
-	"Copyright (c) 2001-2006 Michael David Adams.\n" \
+    "Copyright (c) 2001-2006 Michael David Adams.\n" \
-	"Copyright (c) 1999-2000 Image Power, Inc. and the University of\n" \
+    "Copyright (c) 1999-2000 Image Power, Inc. and the University of\n" \
-	"  British Columbia.\n" \
+    "  British Columbia.\n" \
-	"All rights reserved.\n"
+    "All rights reserved.\n"
 
 #define	JAS_NOTES \
-	"For more information about this software, please visit the following\n" \
+    "For more information about this software, please visit the following\n" \
-	"web sites/pages:\n" \
+    "web sites/pages:\n" \
-	"    http://www.ece.uvic.ca/~mdadams/jasper\n" \
+    "    http://www.ece.uvic.ca/~mdadams/jasper\n" \
-	"    http://www.jpeg.org/software\n" \
+    "    http://www.jpeg.org/software\n" \
-	"To be added to the (moderated) JasPer software announcements\n" \
+    "To be added to the (moderated) JasPer software announcements\n" \
-	"mailing list, send an email to:\n" \
+    "mailing list, send an email to:\n" \
-	"    jasper-announce-subscribe@yahoogroups.com\n" \
+    "    jasper-announce-subscribe@yahoogroups.com\n" \
-	"To be added to the (unmoderated) JasPer software discussion\n" \
+    "To be added to the (unmoderated) JasPer software discussion\n" \
-	"mailing list, send an email to:\n" \
+    "mailing list, send an email to:\n" \
-	"    jasper-discussion-subscribe@yahoogroups.com\n" \
+    "    jasper-discussion-subscribe@yahoogroups.com\n" \
-	"Please send any bug reports to:\n" \
+    "Please send any bug reports to:\n" \
-	"    mdadams@ieee.org\n"
+    "    mdadams@ieee.org\n"
 
 /******************************************************************************\
 * Functions.

3rdparty/libjasper/jasper/jasper.h

@@ -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__
  */
 

3rdparty/libjasper/jp2_cod.h

@@ -11,15 +11,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,
@@ -27,15 +27,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
@@ -62,7 +62,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__
  */
 
@@ -86,7 +86,7 @@
 \******************************************************************************/
 
 #define	JP2_SPTOBPC(s, p) \
-	((((p) - 1) & 0x7f) | (((s) & 1) << 7))
+    ((((p) - 1) & 0x7f) | (((s) & 1) << 7))
 
 /******************************************************************************\
 * Box class.
@@ -124,7 +124,7 @@
 #define	JP2_JP_LEN		12
 
 typedef struct {
-	uint_fast32_t magic;
+    uint_fast32_t magic;
 } jp2_jp_t;
 
 /* FTYP box data. */
@@ -135,10 +135,10 @@ typedef struct {
 #define	JP2_FTYP_COMPATCODE		JP2_FTYP_MAJVER
 
 typedef struct {
-	uint_fast32_t majver;
+    uint_fast32_t majver;
-	uint_fast32_t minver;
+    uint_fast32_t minver;
-	uint_fast32_t numcompatcodes;
+    uint_fast32_t numcompatcodes;
-	uint_fast32_t compatcodes[JP2_FTYP_MAXCOMPATCODES];
+    uint_fast32_t compatcodes[JP2_FTYP_MAXCOMPATCODES];
 } jp2_ftyp_t;
 
 /* IHDR box data. */
@@ -147,20 +147,20 @@ typedef struct {
 #define	JP2_IHDR_BPCNULL	255
 
 typedef struct {
-	uint_fast32_t width;
+    uint_fast32_t width;
-	uint_fast32_t height;
+    uint_fast32_t height;
-	uint_fast16_t numcmpts;
+    uint_fast16_t numcmpts;
-	uint_fast8_t bpc;
+    uint_fast8_t bpc;
-	uint_fast8_t comptype;
+    uint_fast8_t comptype;
-	uint_fast8_t csunk;
+    uint_fast8_t csunk;
-	uint_fast8_t ipr;
+    uint_fast8_t ipr;
 } jp2_ihdr_t;
 
 /* BPCC box data. */
 
 typedef struct {
-	uint_fast16_t numcmpts;
+    uint_fast16_t numcmpts;
-	uint_fast8_t *bpcs;
+    uint_fast8_t *bpcs;
 } jp2_bpcc_t;
 
 /* COLR box data. */
@@ -174,22 +174,22 @@ typedef struct {
 #define	JP2_COLR_SYCC	18
 
 typedef struct {
-	uint_fast8_t method;
+    uint_fast8_t method;
-	uint_fast8_t pri;
+    uint_fast8_t pri;
-	uint_fast8_t approx;
+    uint_fast8_t approx;
-	uint_fast32_t csid;
+    uint_fast32_t csid;
-	uint_fast8_t *iccp;
+    uint_fast8_t *iccp;
-	int iccplen;
+    int iccplen;
-	/* XXX - Someday we ought to add ICC profile data here. */
+    /* XXX - Someday we ought to add ICC profile data here. */
 } jp2_colr_t;
 
 /* PCLR box data. */
 
 typedef struct {
-	uint_fast16_t numlutents;
+    uint_fast16_t numlutents;
-	uint_fast8_t numchans;
+    uint_fast8_t numchans;
-	int_fast32_t *lutdata;
+    int_fast32_t *lutdata;
-	uint_fast8_t *bpc;
+    uint_fast8_t *bpc;
 } jp2_pclr_t;
 
 /* CDEF box per-channel data. */
@@ -211,33 +211,33 @@ typedef struct {
 #define	JP2_CDEF_ASOC_NONE	65535
 
 typedef struct {
-	uint_fast16_t channo;
+    uint_fast16_t channo;
-	uint_fast16_t type;
+    uint_fast16_t type;
-	uint_fast16_t assoc;
+    uint_fast16_t assoc;
 } jp2_cdefchan_t;
 
 /* CDEF box data. */
 
 typedef struct {
-	uint_fast16_t numchans;
+    uint_fast16_t numchans;
-	jp2_cdefchan_t *ents;
+    jp2_cdefchan_t *ents;
 } jp2_cdef_t;
 
 typedef struct {
-	uint_fast16_t cmptno;
+    uint_fast16_t cmptno;
-	uint_fast8_t map;
+    uint_fast8_t map;
-	uint_fast8_t pcol;
+    uint_fast8_t pcol;
 } jp2_cmapent_t;
 
 typedef struct {
-	uint_fast16_t numchans;
+    uint_fast16_t numchans;
-	jp2_cmapent_t *ents;
+    jp2_cmapent_t *ents;
 } jp2_cmap_t;
 
 typedef struct {
-	uint_fast32_t datalen;
+    uint_fast32_t datalen;
-	uint_fast8_t uuid[16];
+    uint_fast8_t uuid[16];
-	uint_fast8_t *data;
+    uint_fast8_t *data;
 } jp2_uuid_t;
 
 #define	JP2_CMAP_DIRECT		0
@@ -248,37 +248,37 @@ typedef struct {
 struct jp2_boxops_s;
 typedef struct {
 
-	struct jp2_boxops_s *ops;
+    struct jp2_boxops_s *ops;
-	struct jp2_boxinfo_s *info;
+    struct jp2_boxinfo_s *info;
 
-	uint_fast32_t type;
+    uint_fast32_t type;
 
-	/* The length of the box including the (variable-length) header. */
+    /* The length of the box including the (variable-length) header. */
-	uint_fast32_t len;
+    uint_fast32_t len;
 
-	/* The length of the box data. */
+    /* The length of the box data. */
-	uint_fast32_t datalen;
+    uint_fast32_t datalen;
 
-	union {
+    union {
-		jp2_jp_t jp;
+        jp2_jp_t jp;
-		jp2_ftyp_t ftyp;
+        jp2_ftyp_t ftyp;
-		jp2_ihdr_t ihdr;
+        jp2_ihdr_t ihdr;
-		jp2_bpcc_t bpcc;
+        jp2_bpcc_t bpcc;
-		jp2_colr_t colr;
+        jp2_colr_t colr;
-		jp2_pclr_t pclr;
+        jp2_pclr_t pclr;
-		jp2_cdef_t cdef;
+        jp2_cdef_t cdef;
-		jp2_cmap_t cmap;
+        jp2_cmap_t cmap;
-		jp2_uuid_t uuid;
+        jp2_uuid_t uuid;
-	} data;
+    } data;
 
 } jp2_box_t;
 
 typedef struct jp2_boxops_s {
-	void (*init)(jp2_box_t *box);
+    void (*init)(jp2_box_t *box);
-	void (*destroy)(jp2_box_t *box);
+    void (*destroy)(jp2_box_t *box);
-	int (*getdata)(jp2_box_t *box, jas_stream_t *in);
+    int (*getdata)(jp2_box_t *box, jas_stream_t *in);
-	int (*putdata)(jp2_box_t *box, jas_stream_t *out);
+    int (*putdata)(jp2_box_t *box, jas_stream_t *out);
-	void (*dumpdata)(jp2_box_t *box, FILE *out);
+    void (*dumpdata)(jp2_box_t *box, FILE *out);
 } jp2_boxops_t;
 
 /******************************************************************************\
@@ -286,10 +286,10 @@ typedef struct jp2_boxops_s {
 \******************************************************************************/
 
 typedef struct jp2_boxinfo_s {
-	int type;
+    int type;
-	char *name;
+    char *name;
-	int flags;
+    int flags;
-	jp2_boxops_t ops;
+    jp2_boxops_t ops;
 } jp2_boxinfo_t;
 
 /******************************************************************************\

3rdparty/libjasper/jp2_dec.c

@@ -6,15 +6,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,
@@ -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__
  */
 
@@ -95,509 +95,509 @@ static int jp2_getct(int colorspace, int type, int assoc);
 
 jas_image_t *jp2_decode(jas_stream_t *in, char *optstr)
 {
-	jp2_box_t *box;
+    jp2_box_t *box;
-	int found;
+    int found;
-	jas_image_t *image;
+    jas_image_t *image;
-	jp2_dec_t *dec;
+    jp2_dec_t *dec;
-	bool samedtype;
+    bool samedtype;
-	int dtype;
+    int dtype;
-	unsigned int i;
+    unsigned int i;
-	jp2_cmap_t *cmapd;
+    jp2_cmap_t *cmapd;
-	jp2_pclr_t *pclrd;
+    jp2_pclr_t *pclrd;
-	jp2_cdef_t *cdefd;
+    jp2_cdef_t *cdefd;
-	unsigned int channo;
+    unsigned int channo;
-	int newcmptno;
+    int newcmptno;
-	int_fast32_t *lutents;
+    int_fast32_t *lutents;
 #if 0
-	jp2_cdefchan_t *cdefent;
+    jp2_cdefchan_t *cdefent;
-	int cmptno;
+    int cmptno;
 #endif
-	jp2_cmapent_t *cmapent;
+    jp2_cmapent_t *cmapent;
-	jas_icchdr_t icchdr;
+    jas_icchdr_t icchdr;
-	jas_iccprof_t *iccprof;
+    jas_iccprof_t *iccprof;
 
-	dec = 0;
+    dec = 0;
-	box = 0;
+    box = 0;
-	image = 0;
+    image = 0;
 
-	if (!(dec = jp2_dec_create())) {
+    if (!(dec = jp2_dec_create())) {
-		goto error;
+        goto error;
-	}
+    }
 
-	/* Get the first box.  This should be a JP box. */
+    /* Get the first box.  This should be a JP box. */
-	if (!(box = jp2_box_get(in))) {
+    if (!(box = jp2_box_get(in))) {
-		jas_eprintf("error: cannot get box\n");
+        jas_eprintf("error: cannot get box\n");
-		goto error;
+        goto error;
-	}
+    }
-	if (box->type != JP2_BOX_JP) {
+    if (box->type != JP2_BOX_JP) {
-		jas_eprintf("error: expecting signature box\n");
+        jas_eprintf("error: expecting signature box\n");
-		goto error;
+        goto error;
-	}
+    }
-	if (box->data.jp.magic != JP2_JP_MAGIC) {
+    if (box->data.jp.magic != JP2_JP_MAGIC) {
-		jas_eprintf("incorrect magic number\n");
+        jas_eprintf("incorrect magic number\n");
-		goto error;
+        goto error;
-	}
+    }
-	jp2_box_destroy(box);
+    jp2_box_destroy(box);
-	box = 0;
+    box = 0;
 
-	/* Get the second box.  This should be a FTYP box. */
+    /* Get the second box.  This should be a FTYP box. */
-	if (!(box = jp2_box_get(in))) {
+    if (!(box = jp2_box_get(in))) {
-		goto error;
+        goto error;
-	}
+    }
-	if (box->type != JP2_BOX_FTYP) {
+    if (box->type != JP2_BOX_FTYP) {
-		jas_eprintf("expecting file type box\n");
+        jas_eprintf("expecting file type box\n");
-		goto error;
+        goto error;
-	}
+    }
-	jp2_box_destroy(box);
+    jp2_box_destroy(box);
-	box = 0;
+    box = 0;
 
-	/* Get more boxes... */
+    /* Get more boxes... */
-	found = 0;
+    found = 0;
-	while ((box = jp2_box_get(in))) {
+    while ((box = jp2_box_get(in))) {
-		if (jas_getdbglevel() >= 1) {
+        if (jas_getdbglevel() >= 1) {
-			jas_eprintf("box type %s\n", box->info->name);
+            jas_eprintf("box type %s\n", box->info->name);
-		}
+        }
-		switch (box->type) {
+        switch (box->type) {
-		case JP2_BOX_JP2C:
+        case JP2_BOX_JP2C:
-			found = 1;
+            found = 1;
-			break;
+            break;
-		case JP2_BOX_IHDR:
+        case JP2_BOX_IHDR:
-			if (!dec->ihdr) {
+            if (!dec->ihdr) {
-				dec->ihdr = box;
+                dec->ihdr = box;
-				box = 0;
+                box = 0;
-			}
+            }
-			break;
+            break;
-		case JP2_BOX_BPCC:
+        case JP2_BOX_BPCC:
-			if (!dec->bpcc) {
+            if (!dec->bpcc) {
-				dec->bpcc = box;
+                dec->bpcc = box;
-				box = 0;
+                box = 0;
-			}
+            }
-			break;
+            break;
-		case JP2_BOX_CDEF:
+        case JP2_BOX_CDEF:
-			if (!dec->cdef) {
+            if (!dec->cdef) {
-				dec->cdef = box;
+                dec->cdef = box;
-				box = 0;
+                box = 0;
-			}
+            }
-			break;
+            break;
-		case JP2_BOX_PCLR:
+        case JP2_BOX_PCLR:
-			if (!dec->pclr) {
+            if (!dec->pclr) {
-				dec->pclr = box;
+                dec->pclr = box;
-				box = 0;
+                box = 0;
-			}
+            }
-			break;
+            break;
-		case JP2_BOX_CMAP:
+        case JP2_BOX_CMAP:
-			if (!dec->cmap) {
+            if (!dec->cmap) {
-				dec->cmap = box;
+                dec->cmap = box;
-				box = 0;
+                box = 0;
-			}
+            }
-			break;
+            break;
-		case JP2_BOX_COLR:
+        case JP2_BOX_COLR:
-			if (!dec->colr) {
+            if (!dec->colr) {
-				dec->colr = box;
+                dec->colr = box;
-				box = 0;
+                box = 0;
-			}
+            }
-			break;
+            break;
-		}
+        }
-		if (box) {
+        if (box) {
-			jp2_box_destroy(box);
+            jp2_box_destroy(box);
-			box = 0;
+            box = 0;
-		}
+        }
-		if (found) {
+        if (found) {
-			break;
+            break;
-		}
+        }
-	}
+    }
 
-	if (!found) {
+    if (!found) {
-		jas_eprintf("error: no code stream found\n");
+        jas_eprintf("error: no code stream found\n");
-		goto error;
+        goto error;
-	}
+    }
 
-	if (!(dec->image = jpc_decode(in, optstr))) {
+    if (!(dec->image = jpc_decode(in, optstr))) {
-		jas_eprintf("error: cannot decode code stream\n");
+        jas_eprintf("error: cannot decode code stream\n");
-		goto error;
+        goto error;
-	}
+    }
 
-	/* An IHDR box must be present. */
+    /* An IHDR box must be present. */
-	if (!dec->ihdr) {
+    if (!dec->ihdr) {
-		jas_eprintf("error: missing IHDR box\n");
+        jas_eprintf("error: missing IHDR box\n");
-		goto error;
+        goto error;
-	}
+    }
 
-	/* Does the number of components indicated in the IHDR box match
+    /* Does the number of components indicated in the IHDR box match
-	  the value specified in the code stream? */
+      the value specified in the code stream? */
-	if (dec->ihdr->data.ihdr.numcmpts != JAS_CAST(uint, jas_image_numcmpts(dec->image))) {
+    if (dec->ihdr->data.ihdr.numcmpts != JAS_CAST(uint, jas_image_numcmpts(dec->image))) {
-		jas_eprintf("warning: number of components mismatch\n");
+        jas_eprintf("warning: number of components mismatch\n");
-	}
+    }
 
-	/* At least one component must be present. */
+    /* At least one component must be present. */
-	if (!jas_image_numcmpts(dec->image)) {
+    if (!jas_image_numcmpts(dec->image)) {
-		jas_eprintf("error: no components\n");
+        jas_eprintf("error: no components\n");
-		goto error;
+        goto error;
-	}
+    }
 
-	/* Determine if all components have the same data type. */
+    /* Determine if all components have the same data type. */
-	samedtype = true;
+    samedtype = true;
-	dtype = jas_image_cmptdtype(dec->image, 0);
+    dtype = jas_image_cmptdtype(dec->image, 0);
-	for (i = 1; i < JAS_CAST(uint, jas_image_numcmpts(dec->image)); ++i) {
+    for (i = 1; i < JAS_CAST(uint, jas_image_numcmpts(dec->image)); ++i) {
-		if (jas_image_cmptdtype(dec->image, i) != dtype) {
+        if (jas_image_cmptdtype(dec->image, i) != dtype) {
-			samedtype = false;
+            samedtype = false;
-			break;
+            break;
-		}
+        }
-	}
+    }
 
-	/* Is the component data type indicated in the IHDR box consistent
+    /* Is the component data type indicated in the IHDR box consistent
-	  with the data in the code stream? */
+      with the data in the code stream? */
-	if ((samedtype && dec->ihdr->data.ihdr.bpc != JP2_DTYPETOBPC(dtype)) ||
+    if ((samedtype && dec->ihdr->data.ihdr.bpc != JP2_DTYPETOBPC(dtype)) ||
-	  (!samedtype && dec->ihdr->data.ihdr.bpc != JP2_IHDR_BPCNULL)) {
+      (!samedtype && dec->ihdr->data.ihdr.bpc != JP2_IHDR_BPCNULL)) {
-		jas_eprintf("warning: component data type mismatch\n");
+        jas_eprintf("warning: component data type mismatch\n");
-	}
+    }
 
-	/* Is the compression type supported? */
+    /* Is the compression type supported? */
-	if (dec->ihdr->data.ihdr.comptype != JP2_IHDR_COMPTYPE) {
+    if (dec->ihdr->data.ihdr.comptype != JP2_IHDR_COMPTYPE) {
-		jas_eprintf("error: unsupported compression type\n");
+        jas_eprintf("error: unsupported compression type\n");
-		goto error;
+        goto error;
-	}
+    }
 
-	if (dec->bpcc) {
+    if (dec->bpcc) {
-		/* Is the number of components indicated in the BPCC box
+        /* Is the number of components indicated in the BPCC box
-		  consistent with the code stream data? */
+          consistent with the code stream data? */
-		if (dec->bpcc->data.bpcc.numcmpts != JAS_CAST(uint, jas_image_numcmpts(
+        if (dec->bpcc->data.bpcc.numcmpts != JAS_CAST(uint, jas_image_numcmpts(
-		  dec->image))) {
+          dec->image))) {
-			jas_eprintf("warning: number of components mismatch\n");
+            jas_eprintf("warning: number of components mismatch\n");
-		}
+        }
-		/* Is the component data type information indicated in the BPCC
+        /* Is the component data type information indicated in the BPCC
-		  box consistent with the code stream data? */
+          box consistent with the code stream data? */
-		if (!samedtype) {
+        if (!samedtype) {
-			for (i = 0; i < JAS_CAST(uint, jas_image_numcmpts(dec->image)); ++i) {
+            for (i = 0; i < JAS_CAST(uint, jas_image_numcmpts(dec->image)); ++i) {
-				if (jas_image_cmptdtype(dec->image, i) != JP2_BPCTODTYPE(dec->bpcc->data.bpcc.bpcs[i])) {
+                if (jas_image_cmptdtype(dec->image, i) != JP2_BPCTODTYPE(dec->bpcc->data.bpcc.bpcs[i])) {
-					jas_eprintf("warning: component data type mismatch\n");
+                    jas_eprintf("warning: component data type mismatch\n");
-				}
+                }
-			}
+            }
-		} else {
+        } else {
-			jas_eprintf("warning: superfluous BPCC box\n");
+            jas_eprintf("warning: superfluous BPCC box\n");
-		}
+        }
-	}
+    }
 
-	/* A COLR box must be present. */
+    /* A COLR box must be present. */
-	if (!dec->colr) {
+    if (!dec->colr) {
-		jas_eprintf("error: no COLR box\n");
+        jas_eprintf("error: no COLR box\n");
-		goto error;
+        goto error;
-	}
+    }
 
-	switch (dec->colr->data.colr.method) {
+    switch (dec->colr->data.colr.method) {
-	case JP2_COLR_ENUM:
+    case JP2_COLR_ENUM:
-		jas_image_setclrspc(dec->image, jp2_getcs(&dec->colr->data.colr));
+        jas_image_setclrspc(dec->image, jp2_getcs(&dec->colr->data.colr));
-		break;
+        break;
-	case JP2_COLR_ICC:
+    case JP2_COLR_ICC:
-		iccprof = jas_iccprof_createfrombuf(dec->colr->data.colr.iccp,
+        iccprof = jas_iccprof_createfrombuf(dec->colr->data.colr.iccp,
-		  dec->colr->data.colr.iccplen);
+          dec->colr->data.colr.iccplen);
-		assert(iccprof);
+        assert(iccprof);
-		jas_iccprof_gethdr(iccprof, &icchdr);
+        jas_iccprof_gethdr(iccprof, &icchdr);
-		jas_eprintf("ICC Profile CS %08x\n", icchdr.colorspc);
+        jas_eprintf("ICC Profile CS %08x\n", icchdr.colorspc);
-		jas_image_setclrspc(dec->image, fromiccpcs(icchdr.colorspc));
+        jas_image_setclrspc(dec->image, fromiccpcs(icchdr.colorspc));
-		dec->image->cmprof_ = jas_cmprof_createfromiccprof(iccprof);
+        dec->image->cmprof_ = jas_cmprof_createfromiccprof(iccprof);
-		assert(dec->image->cmprof_);
+        assert(dec->image->cmprof_);
-		jas_iccprof_destroy(iccprof);
+        jas_iccprof_destroy(iccprof);
-		break;
+        break;
-	}
+    }
 
-	/* If a CMAP box is present, a PCLR box must also be present. */
+    /* If a CMAP box is present, a PCLR box must also be present. */
-	if (dec->cmap && !dec->pclr) {
+    if (dec->cmap && !dec->pclr) {
-		jas_eprintf("warning: missing PCLR box or superfluous CMAP box\n");
+        jas_eprintf("warning: missing PCLR box or superfluous CMAP box\n");
-		jp2_box_destroy(dec->cmap);
+        jp2_box_destroy(dec->cmap);
-		dec->cmap = 0;
+        dec->cmap = 0;
-	}
+    }
 
-	/* If a CMAP box is not present, a PCLR box must not be present. */
+    /* If a CMAP box is not present, a PCLR box must not be present. */
-	if (!dec->cmap && dec->pclr) {
+    if (!dec->cmap && dec->pclr) {
-		jas_eprintf("warning: missing CMAP box or superfluous PCLR box\n");
+        jas_eprintf("warning: missing CMAP box or superfluous PCLR box\n");
-		jp2_box_destroy(dec->pclr);
+        jp2_box_destroy(dec->pclr);
-		dec->pclr = 0;
+        dec->pclr = 0;
-	}
+    }
 
-	/* Determine the number of channels (which is essentially the number
+    /* Determine the number of channels (which is essentially the number
-	  of components after any palette mappings have been applied). */
+      of components after any palette mappings have been applied). */
-	dec->numchans = dec->cmap ? dec->cmap->data.cmap.numchans : JAS_CAST(uint, jas_image_numcmpts(dec->image));
+    dec->numchans = dec->cmap ? dec->cmap->data.cmap.numchans : JAS_CAST(uint, jas_image_numcmpts(dec->image));
 
-	/* Perform a basic sanity check on the CMAP box if present. */
+    /* Perform a basic sanity check on the CMAP box if present. */
-	if (dec->cmap) {
+    if (dec->cmap) {
-		for (i = 0; i < dec->numchans; ++i) {
+        for (i = 0; i < dec->numchans; ++i) {
-			/* Is the component number reasonable? */
+            /* Is the component number reasonable? */
-			if (dec->cmap->data.cmap.ents[i].cmptno >= JAS_CAST(uint, jas_image_numcmpts(dec->image))) {
+            if (dec->cmap->data.cmap.ents[i].cmptno >= JAS_CAST(uint, jas_image_numcmpts(dec->image))) {
-				jas_eprintf("error: invalid component number in CMAP box\n");
+                jas_eprintf("error: invalid component number in CMAP box\n");
-				goto error;
+                goto error;
-			}
+            }
-			/* Is the LUT index reasonable? */
+            /* Is the LUT index reasonable? */
-			if (dec->cmap->data.cmap.ents[i].pcol >= dec->pclr->data.pclr.numchans) {
+            if (dec->cmap->data.cmap.ents[i].pcol >= dec->pclr->data.pclr.numchans) {
-				jas_eprintf("error: invalid CMAP LUT index\n");
+                jas_eprintf("error: invalid CMAP LUT index\n");
-				goto error;
+                goto error;
-			}
+            }
-		}
+        }
-	}
+    }
 
-	/* Allocate space for the channel-number to component-number LUT. */
+    /* Allocate space for the channel-number to component-number LUT. */
-	if (!(dec->chantocmptlut = jas_alloc2(dec->numchans, sizeof(uint_fast16_t)))) {
+    if (!(dec->chantocmptlut = jas_alloc2(dec->numchans, sizeof(uint_fast16_t)))) {
-		jas_eprintf("error: no memory\n");
+        jas_eprintf("error: no memory\n");
-		goto error;
+        goto error;
-	}
+    }
 
-	if (!dec->cmap) {
+    if (!dec->cmap) {
-		for (i = 0; i < dec->numchans; ++i) {
+        for (i = 0; i < dec->numchans; ++i) {
-			dec->chantocmptlut[i] = i;
+            dec->chantocmptlut[i] = i;
-		}
+        }
-	} else {
+    } else {
-		cmapd = &dec->cmap->data.cmap;
+        cmapd = &dec->cmap->data.cmap;
-		pclrd = &dec->pclr->data.pclr;
+        pclrd = &dec->pclr->data.pclr;
-		cdefd = &dec->cdef->data.cdef;
+        cdefd = &dec->cdef->data.cdef;
-		for (channo = 0; channo < cmapd->numchans; ++channo) {
+        for (channo = 0; channo < cmapd->numchans; ++channo) {
-			cmapent = &cmapd->ents[channo];
+            cmapent = &cmapd->ents[channo];
-			if (cmapent->map == JP2_CMAP_DIRECT) {
+            if (cmapent->map == JP2_CMAP_DIRECT) {
-				dec->chantocmptlut[channo] = channo;
+                dec->chantocmptlut[channo] = channo;
-			} else if (cmapent->map == JP2_CMAP_PALETTE) {
+            } else if (cmapent->map == JP2_CMAP_PALETTE) {
-				lutents = jas_alloc2(pclrd->numlutents, sizeof(int_fast32_t));
+                lutents = jas_alloc2(pclrd->numlutents, sizeof(int_fast32_t));
-				for (i = 0; i < pclrd->numlutents; ++i) {
+                for (i = 0; i < pclrd->numlutents; ++i) {
-					lutents[i] = pclrd->lutdata[cmapent->pcol + i * pclrd->numchans];
+                    lutents[i] = pclrd->lutdata[cmapent->pcol + i * pclrd->numchans];
-				}
+                }
-				newcmptno = jas_image_numcmpts(dec->image);
+                newcmptno = jas_image_numcmpts(dec->image);
-				jas_image_depalettize(dec->image, cmapent->cmptno, pclrd->numlutents, lutents, JP2_BPCTODTYPE(pclrd->bpc[cmapent->pcol]), newcmptno);
+                jas_image_depalettize(dec->image, cmapent->cmptno, pclrd->numlutents, lutents, JP2_BPCTODTYPE(pclrd->bpc[cmapent->pcol]), newcmptno);
-				dec->chantocmptlut[channo] = newcmptno;
+                dec->chantocmptlut[channo] = newcmptno;
-				jas_free(lutents);
+                jas_free(lutents);
 #if 0
-				if (dec->cdef) {
+                if (dec->cdef) {
-					cdefent = jp2_cdef_lookup(cdefd, channo);
+                    cdefent = jp2_cdef_lookup(cdefd, channo);
-					if (!cdefent) {
+                    if (!cdefent) {
-						abort();
+                        abort();
-					}
+                    }
-				jas_image_setcmpttype(dec->image, newcmptno, jp2_getct(jas_image_clrspc(dec->image), cdefent->type, cdefent->assoc));
+                jas_image_setcmpttype(dec->image, newcmptno, jp2_getct(jas_image_clrspc(dec->image), cdefent->type, cdefent->assoc));
-				} else {
+                } else {
-				jas_image_setcmpttype(dec->image, newcmptno, jp2_getct(jas_image_clrspc(dec->image), 0, channo + 1));
+                jas_image_setcmpttype(dec->image, newcmptno, jp2_getct(jas_image_clrspc(dec->image), 0, channo + 1));
-				}
+                }
 #endif
-			}
+            }
-		}
+        }
-	}
+    }
 
-	/* Mark all components as being of unknown type. */
+    /* Mark all components as being of unknown type. */
 
-	for (i = 0; i < JAS_CAST(uint, jas_image_numcmpts(dec->image)); ++i) {
+    for (i = 0; i < JAS_CAST(uint, jas_image_numcmpts(dec->image)); ++i) {
-		jas_image_setcmpttype(dec->image, i, JAS_IMAGE_CT_UNKNOWN);
+        jas_image_setcmpttype(dec->image, i, JAS_IMAGE_CT_UNKNOWN);
-	}
+    }
 
-	/* Determine the type of each component. */
+    /* Determine the type of each component. */
-	if (dec->cdef) {
+    if (dec->cdef) {
-		for (i = 0; i < dec->numchans; ++i) {
+        for (i = 0; i < dec->numchans; ++i) {
-			jas_image_setcmpttype(dec->image,
+            jas_image_setcmpttype(dec->image,
-			  dec->chantocmptlut[dec->cdef->data.cdef.ents[i].channo],
+              dec->chantocmptlut[dec->cdef->data.cdef.ents[i].channo],
-			  jp2_getct(jas_image_clrspc(dec->image),
+              jp2_getct(jas_image_clrspc(dec->image),
-			  dec->cdef->data.cdef.ents[i].type, dec->cdef->data.cdef.ents[i].assoc));
+              dec->cdef->data.cdef.ents[i].type, dec->cdef->data.cdef.ents[i].assoc));
-		}
+        }
-	} else {
+    } else {
-		for (i = 0; i < dec->numchans; ++i) {
+        for (i = 0; i < dec->numchans; ++i) {
-			jas_image_setcmpttype(dec->image, dec->chantocmptlut[i],
+            jas_image_setcmpttype(dec->image, dec->chantocmptlut[i],
-			  jp2_getct(jas_image_clrspc(dec->image), 0, i + 1));
+              jp2_getct(jas_image_clrspc(dec->image), 0, i + 1));
-		}
+        }
-	}
+    }
 
-	/* Delete any components that are not of interest. */
+    /* Delete any components that are not of interest. */
-	for (i = jas_image_numcmpts(dec->image); i > 0; --i) {
+    for (i = jas_image_numcmpts(dec->image); i > 0; --i) {
-		if (jas_image_cmpttype(dec->image, i - 1) == JAS_IMAGE_CT_UNKNOWN) {
+        if (jas_image_cmpttype(dec->image, i - 1) == JAS_IMAGE_CT_UNKNOWN) {
-			jas_image_delcmpt(dec->image, i - 1);
+            jas_image_delcmpt(dec->image, i - 1);
-		}
+        }
-	}
+    }
 
-	/* Ensure that some components survived. */
+    /* Ensure that some components survived. */
-	if (!jas_image_numcmpts(dec->image)) {
+    if (!jas_image_numcmpts(dec->image)) {
-		jas_eprintf("error: no components\n");
+        jas_eprintf("error: no components\n");
-		goto error;
+        goto error;
-	}
+    }
 #if 0
 jas_eprintf("no of components is %d\n", jas_image_numcmpts(dec->image));
 #endif
 
-	/* Prevent the image from being destroyed later. */
+    /* Prevent the image from being destroyed later. */
-	image = dec->image;
+    image = dec->image;
-	dec->image = 0;
+    dec->image = 0;
 
-	jp2_dec_destroy(dec);
+    jp2_dec_destroy(dec);
 
-	return image;
+    return image;
 
 error:
-	if (box) {
+    if (box) {
-		jp2_box_destroy(box);
+        jp2_box_destroy(box);
-	}
+    }
-	if (dec) {
+    if (dec) {
-		jp2_dec_destroy(dec);
+        jp2_dec_destroy(dec);
-	}
+    }
-	return 0;
+    return 0;
 }
 
 int jp2_validate(jas_stream_t *in)
 {
-	char buf[JP2_VALIDATELEN];
+    char buf[JP2_VALIDATELEN];
-	int i;
+    int i;
-	int n;
+    int n;
 #if 0
-	jas_stream_t *tmpstream;
+    jas_stream_t *tmpstream;
-	jp2_box_t *box;
+    jp2_box_t *box;
 #endif
 
-	assert(JAS_STREAM_MAXPUTBACK >= JP2_VALIDATELEN);
+    assert(JAS_STREAM_MAXPUTBACK >= JP2_VALIDATELEN);
 
-	/* Read the validation data (i.e., the data used for detecting
+    /* Read the validation data (i.e., the data used for detecting
-	  the format). */
+      the format). */
-	if ((n = jas_stream_read(in, buf, JP2_VALIDATELEN)) < 0) {
+    if ((n = jas_stream_read(in, buf, JP2_VALIDATELEN)) < 0) {
-		return -1;
+        return -1;
-	}
+    }
 
-	/* Put the validation data back onto the stream, so that the
+    /* Put the validation data back onto the stream, so that the
-	  stream position will not be changed. */
+      stream position will not be changed. */
-	for (i = n - 1; i >= 0; --i) {
+    for (i = n - 1; i >= 0; --i) {
-		if (jas_stream_ungetc(in, buf[i]) == EOF) {
+        if (jas_stream_ungetc(in, buf[i]) == EOF) {
-			return -1;
+            return -1;
-		}
+        }
-	}
+    }
 
-	/* Did we read enough data? */
+    /* Did we read enough data? */
-	if (n < JP2_VALIDATELEN) {
+    if (n < JP2_VALIDATELEN) {
-		return -1;
+        return -1;
-	}
+    }
 
-	/* Is the box type correct? */
+    /* Is the box type correct? */
-	if (((buf[4] << 24) | (buf[5] << 16) | (buf[6] << 8) | buf[7]) !=
+    if (((buf[4] << 24) | (buf[5] << 16) | (buf[6] << 8) | buf[7]) !=
-	  JP2_BOX_JP)
+      JP2_BOX_JP)
-	{
+    {
-		return -1;
+        return -1;
-	}
+    }
 
-	return 0;
+    return 0;
 }
 
 static jp2_dec_t *jp2_dec_create(void)
 {
-	jp2_dec_t *dec;
+    jp2_dec_t *dec;
 
-	if (!(dec = jas_malloc(sizeof(jp2_dec_t)))) {
+    if (!(dec = jas_malloc(sizeof(jp2_dec_t)))) {
-		return 0;
+        return 0;
-	}
+    }
-	dec->ihdr = 0;
+    dec->ihdr = 0;
-	dec->bpcc = 0;
+    dec->bpcc = 0;
-	dec->cdef = 0;
+    dec->cdef = 0;
-	dec->pclr = 0;
+    dec->pclr = 0;
-	dec->image = 0;
+    dec->image = 0;
-	dec->chantocmptlut = 0;
+    dec->chantocmptlut = 0;
-	dec->cmap = 0;
+    dec->cmap = 0;
-	dec->colr = 0;
+    dec->colr = 0;
-	return dec;
+    return dec;
 }
 
 static void jp2_dec_destroy(jp2_dec_t *dec)
 {
-	if (dec->ihdr) {
+    if (dec->ihdr) {
-		jp2_box_destroy(dec->ihdr);
+        jp2_box_destroy(dec->ihdr);
-	}
+    }
-	if (dec->bpcc) {
+    if (dec->bpcc) {
-		jp2_box_destroy(dec->bpcc);
+        jp2_box_destroy(dec->bpcc);
-	}
+    }
-	if (dec->cdef) {
+    if (dec->cdef) {
-		jp2_box_destroy(dec->cdef);
+        jp2_box_destroy(dec->cdef);
-	}
+    }
-	if (dec->pclr) {
+    if (dec->pclr) {
-		jp2_box_destroy(dec->pclr);
+        jp2_box_destroy(dec->pclr);
-	}
+    }
-	if (dec->image) {
+    if (dec->image) {
-		jas_image_destroy(dec->image);
+        jas_image_destroy(dec->image);
-	}
+    }
-	if (dec->cmap) {
+    if (dec->cmap) {
-		jp2_box_destroy(dec->cmap);
+        jp2_box_destroy(dec->cmap);
-	}
+    }
-	if (dec->colr) {
+    if (dec->colr) {
-		jp2_box_destroy(dec->colr);
+        jp2_box_destroy(dec->colr);
-	}
+    }
-	if (dec->chantocmptlut) {
+    if (dec->chantocmptlut) {
-		jas_free(dec->chantocmptlut);
+        jas_free(dec->chantocmptlut);
-	}
+    }
-	jas_free(dec);
+    jas_free(dec);
 }
 
 static int jp2_getct(int colorspace, int type, int assoc)
 {
-	if (type == 1 && assoc == 0) {
+    if (type == 1 && assoc == 0) {
-		return JAS_IMAGE_CT_OPACITY;
+        return JAS_IMAGE_CT_OPACITY;
-	}
+    }
-	if (type == 0 && assoc >= 1 && assoc <= 65534) {
+    if (type == 0 && assoc >= 1 && assoc <= 65534) {
-		switch (colorspace) {
+        switch (colorspace) {
-		case JAS_CLRSPC_FAM_RGB:
+        case JAS_CLRSPC_FAM_RGB:
-			switch (assoc) {
+            switch (assoc) {
-			case JP2_CDEF_RGB_R:
+            case JP2_CDEF_RGB_R:
-				return JAS_IMAGE_CT_COLOR(JAS_CLRSPC_CHANIND_RGB_R);
+                return JAS_IMAGE_CT_COLOR(JAS_CLRSPC_CHANIND_RGB_R);
-				break;
+                break;
-			case JP2_CDEF_RGB_G:
+            case JP2_CDEF_RGB_G:
-				return JAS_IMAGE_CT_COLOR(JAS_CLRSPC_CHANIND_RGB_G);
+                return JAS_IMAGE_CT_COLOR(JAS_CLRSPC_CHANIND_RGB_G);
-				break;
+                break;
-			case JP2_CDEF_RGB_B:
+            case JP2_CDEF_RGB_B:
-				return JAS_IMAGE_CT_COLOR(JAS_CLRSPC_CHANIND_RGB_B);
+                return JAS_IMAGE_CT_COLOR(JAS_CLRSPC_CHANIND_RGB_B);
-				break;
+                break;
-			}
+            }
-			break;
+            break;
-		case JAS_CLRSPC_FAM_YCBCR:
+        case JAS_CLRSPC_FAM_YCBCR:
-			switch (assoc) {
+            switch (assoc) {
-			case JP2_CDEF_YCBCR_Y:
+            case JP2_CDEF_YCBCR_Y:
-				return JAS_IMAGE_CT_COLOR(JAS_CLRSPC_CHANIND_YCBCR_Y);
+                return JAS_IMAGE_CT_COLOR(JAS_CLRSPC_CHANIND_YCBCR_Y);
-				break;
+                break;
-			case JP2_CDEF_YCBCR_CB:
+            case JP2_CDEF_YCBCR_CB:
-				return JAS_IMAGE_CT_COLOR(JAS_CLRSPC_CHANIND_YCBCR_CB);
+                return JAS_IMAGE_CT_COLOR(JAS_CLRSPC_CHANIND_YCBCR_CB);
-				break;
+                break;
-			case JP2_CDEF_YCBCR_CR:
+            case JP2_CDEF_YCBCR_CR:
-				return JAS_IMAGE_CT_COLOR(JAS_CLRSPC_CHANIND_YCBCR_CR);
+                return JAS_IMAGE_CT_COLOR(JAS_CLRSPC_CHANIND_YCBCR_CR);
-				break;
+                break;
-			}
+            }
-			break;
+            break;
-		case JAS_CLRSPC_FAM_GRAY:
+        case JAS_CLRSPC_FAM_GRAY:
-			switch (assoc) {
+            switch (assoc) {
-			case JP2_CDEF_GRAY_Y:
+            case JP2_CDEF_GRAY_Y:
-				return JAS_IMAGE_CT_COLOR(JAS_CLRSPC_CHANIND_GRAY_Y);
+                return JAS_IMAGE_CT_COLOR(JAS_CLRSPC_CHANIND_GRAY_Y);
-				break;
+                break;
-			}
+            }
-			break;
+            break;
-		default:
+        default:
-			return JAS_IMAGE_CT_COLOR(assoc - 1);
+            return JAS_IMAGE_CT_COLOR(assoc - 1);
-			break;
+            break;
-		}
+        }
-	}
+    }
-	return JAS_IMAGE_CT_UNKNOWN;
+    return JAS_IMAGE_CT_UNKNOWN;
 }
 
 static int jp2_getcs(jp2_colr_t *colr)
 {
-	if (colr->method == JP2_COLR_ENUM) {
+    if (colr->method == JP2_COLR_ENUM) {
-		switch (colr->csid) {
+        switch (colr->csid) {
-		case JP2_COLR_SRGB:
+        case JP2_COLR_SRGB:
-			return JAS_CLRSPC_SRGB;
+            return JAS_CLRSPC_SRGB;
-			break;
+            break;
-		case JP2_COLR_SYCC:
+        case JP2_COLR_SYCC:
-			return JAS_CLRSPC_SYCBCR;
+            return JAS_CLRSPC_SYCBCR;
-			break;
+            break;
-		case JP2_COLR_SGRAY:
+        case JP2_COLR_SGRAY:
-			return JAS_CLRSPC_SGRAY;
+            return JAS_CLRSPC_SGRAY;
-			break;
+            break;
-		}
+        }
-	}
+    }
-	return JAS_CLRSPC_UNKNOWN;
+    return JAS_CLRSPC_UNKNOWN;
 }
 
 static int fromiccpcs(int cs)
 {
-	switch (cs) {
+    switch (cs) {
-	case ICC_CS_RGB:
+    case ICC_CS_RGB:
-		return JAS_CLRSPC_GENRGB;
+        return JAS_CLRSPC_GENRGB;
-		break;
+        break;
-	case ICC_CS_YCBCR:
+    case ICC_CS_YCBCR:
-		return JAS_CLRSPC_GENYCBCR;
+        return JAS_CLRSPC_GENYCBCR;
-		break;
+        break;
-	case ICC_CS_GRAY:
+    case ICC_CS_GRAY:
-		return JAS_CLRSPC_GENGRAY;
+        return JAS_CLRSPC_GENGRAY;
-		break;
+        break;
-	}
+    }
-	return JAS_CLRSPC_UNKNOWN;
+    return JAS_CLRSPC_UNKNOWN;
 }

3rdparty/libjasper/jp2_dec.h

@@ -6,15 +6,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,
@@ -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__
  */
 
@@ -70,15 +70,15 @@
 
 typedef struct {
 
-	jp2_box_t *pclr;
+    jp2_box_t *pclr;
-	jp2_box_t *cdef;
+    jp2_box_t *cdef;
-	jp2_box_t *ihdr;
+    jp2_box_t *ihdr;
-	jp2_box_t *bpcc;
+    jp2_box_t *bpcc;
-	jp2_box_t *cmap;
+    jp2_box_t *cmap;
-	jp2_box_t *colr;
+    jp2_box_t *colr;
-	jas_image_t *image;
+    jas_image_t *image;
-	uint_fast16_t numchans;
+    uint_fast16_t numchans;
-	uint_fast16_t *chantocmptlut;
+    uint_fast16_t *chantocmptlut;
 
 } jp2_dec_t;
 

3rdparty/libjasper/jp2_enc.c

@@ -11,15 +11,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,
@@ -27,15 +27,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
@@ -62,7 +62,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__
  */
 
@@ -93,19 +93,19 @@ static int clrspctojp2(jas_clrspc_t clrspc);
 
 int jp2_write_header(jas_image_t *image, jas_stream_t *out)
 {
-	jp2_box_t *box;
+    jp2_box_t *box;
-	jp2_ftyp_t *ftyp;
+    jp2_ftyp_t *ftyp;
-	jp2_ihdr_t *ihdr;
+    jp2_ihdr_t *ihdr;
-	jas_stream_t *tmpstream;
+    jas_stream_t *tmpstream;
-	int allcmptssame;
+    int allcmptssame;
-	jp2_bpcc_t *bpcc;
+    jp2_bpcc_t *bpcc;
-	long len;
+    long len;
-	uint_fast16_t cmptno;
+    uint_fast16_t cmptno;
-	jp2_colr_t *colr;
+    jp2_colr_t *colr;
-	jp2_cdefchan_t *cdefchanent;
+    jp2_cdefchan_t *cdefchanent;
-	jp2_cdef_t *cdef;
+    jp2_cdef_t *cdef;
-	int i;
+    int i;
-	uint_fast32_t typeasoc;
+    uint_fast32_t typeasoc;
 jas_iccprof_t *iccprof;
 jas_stream_t *iccstream;
 int pos;
@@ -113,369 +113,369 @@ int needcdef;
 int prec;
 int sgnd;
 
-	box = 0;
+    box = 0;
-	tmpstream = 0;
+    tmpstream = 0;
 
-	allcmptssame = 1;
+    allcmptssame = 1;
-	sgnd = jas_image_cmptsgnd(image, 0);
+    sgnd = jas_image_cmptsgnd(image, 0);
-	prec = jas_image_cmptprec(image, 0);
+    prec = jas_image_cmptprec(image, 0);
-	for (i = 1; i < jas_image_numcmpts(image); ++i) {
+    for (i = 1; i < jas_image_numcmpts(image); ++i) {
-		if (jas_image_cmptsgnd(image, i) != sgnd ||
+        if (jas_image_cmptsgnd(image, i) != sgnd ||
-		  jas_image_cmptprec(image, i) != prec) {
+          jas_image_cmptprec(image, i) != prec) {
-			allcmptssame = 0;
+            allcmptssame = 0;
-			break;
+            break;
-		}
+        }
-	}
+    }
 
-	/* Output the signature box. */
+    /* Output the signature box. */
 
-	if (!(box = jp2_box_create(JP2_BOX_JP))) {
+    if (!(box = jp2_box_create(JP2_BOX_JP))) {
-		goto error;
+        goto error;
-	}
+    }
-	box->data.jp.magic = JP2_JP_MAGIC;
+    box->data.jp.magic = JP2_JP_MAGIC;
-	if (jp2_box_put(box, out)) {
+    if (jp2_box_put(box, out)) {
-		goto error;
+        goto error;
-	}
+    }
-	jp2_box_destroy(box);
+    jp2_box_destroy(box);
-	box = 0;
+    box = 0;
 
-	/* Output the file type box. */
+    /* Output the file type box. */
 
-	if (!(box = jp2_box_create(JP2_BOX_FTYP))) {
+    if (!(box = jp2_box_create(JP2_BOX_FTYP))) {
-		goto error;
+        goto error;
-	}
+    }
-	ftyp = &box->data.ftyp;
+    ftyp = &box->data.ftyp;
-	ftyp->majver = JP2_FTYP_MAJVER;
+    ftyp->majver = JP2_FTYP_MAJVER;
-	ftyp->minver = JP2_FTYP_MINVER;
+    ftyp->minver = JP2_FTYP_MINVER;
-	ftyp->numcompatcodes = 1;
+    ftyp->numcompatcodes = 1;
-	ftyp->compatcodes[0] = JP2_FTYP_COMPATCODE;
+    ftyp->compatcodes[0] = JP2_FTYP_COMPATCODE;
-	if (jp2_box_put(box, out)) {
+    if (jp2_box_put(box, out)) {
-		goto error;
+        goto error;
-	}
+    }
-	jp2_box_destroy(box);
+    jp2_box_destroy(box);
-	box = 0;
+    box = 0;
 
-	/*
+    /*
-	 * Generate the data portion of the JP2 header box.
+     * Generate the data portion of the JP2 header box.
-	 * We cannot simply output the header for this box
+     * We cannot simply output the header for this box
-	 * since we do not yet know the correct value for the length
+     * since we do not yet know the correct value for the length
-	 * field.
+     * field.
-	 */
+     */
 
-	if (!(tmpstream = jas_stream_memopen(0, 0))) {
+    if (!(tmpstream = jas_stream_memopen(0, 0))) {
-		goto error;
+        goto error;
-	}
+    }
 
-	/* Generate image header box. */
+    /* Generate image header box. */
 
-	if (!(box = jp2_box_create(JP2_BOX_IHDR))) {
+    if (!(box = jp2_box_create(JP2_BOX_IHDR))) {
-		goto error;
+        goto error;
-	}
+    }
-	ihdr = &box->data.ihdr;
+    ihdr = &box->data.ihdr;
-	ihdr->width = jas_image_width(image);
+    ihdr->width = jas_image_width(image);
-	ihdr->height = jas_image_height(image);
+    ihdr->height = jas_image_height(image);
-	ihdr->numcmpts = jas_image_numcmpts(image);
+    ihdr->numcmpts = jas_image_numcmpts(image);
-	ihdr->bpc = allcmptssame ? JP2_SPTOBPC(jas_image_cmptsgnd(image, 0),
+    ihdr->bpc = allcmptssame ? JP2_SPTOBPC(jas_image_cmptsgnd(image, 0),
-	  jas_image_cmptprec(image, 0)) : JP2_IHDR_BPCNULL;
+      jas_image_cmptprec(image, 0)) : JP2_IHDR_BPCNULL;
-	ihdr->comptype = JP2_IHDR_COMPTYPE;
+    ihdr->comptype = JP2_IHDR_COMPTYPE;
-	ihdr->csunk = 0;
+    ihdr->csunk = 0;
-	ihdr->ipr = 0;
+    ihdr->ipr = 0;
-	if (jp2_box_put(box, tmpstream)) {
+    if (jp2_box_put(box, tmpstream)) {
-		goto error;
+        goto error;
-	}
+    }
-	jp2_box_destroy(box);
+    jp2_box_destroy(box);
-	box = 0;
+    box = 0;
 
-	/* Generate bits per component box. */
+    /* Generate bits per component box. */
 
-	if (!allcmptssame) {
+    if (!allcmptssame) {
-		if (!(box = jp2_box_create(JP2_BOX_BPCC))) {
+        if (!(box = jp2_box_create(JP2_BOX_BPCC))) {
-			goto error;
+            goto error;
-		}
+        }
-		bpcc = &box->data.bpcc;
+        bpcc = &box->data.bpcc;
-		bpcc->numcmpts = jas_image_numcmpts(image);
+        bpcc->numcmpts = jas_image_numcmpts(image);
-		if (!(bpcc->bpcs = jas_alloc2(bpcc->numcmpts,
+        if (!(bpcc->bpcs = jas_alloc2(bpcc->numcmpts,
-		  sizeof(uint_fast8_t)))) {
+          sizeof(uint_fast8_t)))) {
-			goto error;
+            goto error;
-		}
+        }
-		for (cmptno = 0; cmptno < bpcc->numcmpts; ++cmptno) {
+        for (cmptno = 0; cmptno < bpcc->numcmpts; ++cmptno) {
-			bpcc->bpcs[cmptno] = JP2_SPTOBPC(jas_image_cmptsgnd(image,
+            bpcc->bpcs[cmptno] = JP2_SPTOBPC(jas_image_cmptsgnd(image,
-			  cmptno), jas_image_cmptprec(image, cmptno));
+              cmptno), jas_image_cmptprec(image, cmptno));
-		}
+        }
-		if (jp2_box_put(box, tmpstream)) {
+        if (jp2_box_put(box, tmpstream)) {
-			goto error;
+            goto error;
-		}
+        }
-		jp2_box_destroy(box);
+        jp2_box_destroy(box);
-		box = 0;
+        box = 0;
-	}
+    }
 
-	/* Generate color specification box. */
+    /* Generate color specification box. */
 
-	if (!(box = jp2_box_create(JP2_BOX_COLR))) {
+    if (!(box = jp2_box_create(JP2_BOX_COLR))) {
-		goto error;
+        goto error;
-	}
+    }
-	colr = &box->data.colr;
+    colr = &box->data.colr;
-	switch (jas_image_clrspc(image)) {
+    switch (jas_image_clrspc(image)) {
-	case JAS_CLRSPC_SRGB:
+    case JAS_CLRSPC_SRGB:
-	case JAS_CLRSPC_SYCBCR:
+    case JAS_CLRSPC_SYCBCR:
-	case JAS_CLRSPC_SGRAY:
+    case JAS_CLRSPC_SGRAY:
-		colr->method = JP2_COLR_ENUM;
+        colr->method = JP2_COLR_ENUM;
-		colr->csid = clrspctojp2(jas_image_clrspc(image));
+        colr->csid = clrspctojp2(jas_image_clrspc(image));
-		colr->pri = JP2_COLR_PRI;
+        colr->pri = JP2_COLR_PRI;
-		colr->approx = 0;
+        colr->approx = 0;
-		break;
+        break;
-	default:
+    default:
-		colr->method = JP2_COLR_ICC;
+        colr->method = JP2_COLR_ICC;
-		colr->pri = JP2_COLR_PRI;
+        colr->pri = JP2_COLR_PRI;
-		colr->approx = 0;
+        colr->approx = 0;
-		iccprof = jas_iccprof_createfromcmprof(jas_image_cmprof(image));
+        iccprof = jas_iccprof_createfromcmprof(jas_image_cmprof(image));
-		assert(iccprof);
+        assert(iccprof);
-		iccstream = jas_stream_memopen(0, 0);
+        iccstream = jas_stream_memopen(0, 0);
-		assert(iccstream);
+        assert(iccstream);
-		if (jas_iccprof_save(iccprof, iccstream))
+        if (jas_iccprof_save(iccprof, iccstream))
-			abort();
+            abort();
-		if ((pos = jas_stream_tell(iccstream)) < 0)
+        if ((pos = jas_stream_tell(iccstream)) < 0)
-			abort();
+            abort();
-		colr->iccplen = pos;
+        colr->iccplen = pos;
-		colr->iccp = jas_malloc(pos);
+        colr->iccp = jas_malloc(pos);
-		assert(colr->iccp);
+        assert(colr->iccp);
-		jas_stream_rewind(iccstream);
+        jas_stream_rewind(iccstream);
-		if (jas_stream_read(iccstream, colr->iccp, colr->iccplen) != colr->iccplen)
+        if (jas_stream_read(iccstream, colr->iccp, colr->iccplen) != colr->iccplen)
-			abort();
+            abort();
-		jas_stream_close(iccstream);
+        jas_stream_close(iccstream);
-		jas_iccprof_destroy(iccprof);
+        jas_iccprof_destroy(iccprof);
-		break;
+        break;
-	}
+    }
-	if (jp2_box_put(box, tmpstream)) {
+    if (jp2_box_put(box, tmpstream)) {
-		goto error;
+        goto error;
-	}
+    }
-	jp2_box_destroy(box);
+    jp2_box_destroy(box);
-	box = 0;
+    box = 0;
 
-	needcdef = 1;
+    needcdef = 1;
-	switch (jas_clrspc_fam(jas_image_clrspc(image))) {
+    switch (jas_clrspc_fam(jas_image_clrspc(image))) {
-	case JAS_CLRSPC_FAM_RGB:
+    case JAS_CLRSPC_FAM_RGB:
-		if (jas_image_cmpttype(image, 0) ==
+        if (jas_image_cmpttype(image, 0) ==
-		  JAS_IMAGE_CT_COLOR(JAS_CLRSPC_CHANIND_RGB_R) &&
+          JAS_IMAGE_CT_COLOR(JAS_CLRSPC_CHANIND_RGB_R) &&
-		  jas_image_cmpttype(image, 1) ==
+          jas_image_cmpttype(image, 1) ==
-		  JAS_IMAGE_CT_COLOR(JAS_CLRSPC_CHANIND_RGB_G) &&
+          JAS_IMAGE_CT_COLOR(JAS_CLRSPC_CHANIND_RGB_G) &&
-		  jas_image_cmpttype(image, 2) ==
+          jas_image_cmpttype(image, 2) ==
-		  JAS_IMAGE_CT_COLOR(JAS_CLRSPC_CHANIND_RGB_B))
+          JAS_IMAGE_CT_COLOR(JAS_CLRSPC_CHANIND_RGB_B))
-			needcdef = 0;
+            needcdef = 0;
-		break;
+        break;
-	case JAS_CLRSPC_FAM_YCBCR:
+    case JAS_CLRSPC_FAM_YCBCR:
-		if (jas_image_cmpttype(image, 0) ==
+        if (jas_image_cmpttype(image, 0) ==
-		  JAS_IMAGE_CT_COLOR(JAS_CLRSPC_CHANIND_YCBCR_Y) &&
+          JAS_IMAGE_CT_COLOR(JAS_CLRSPC_CHANIND_YCBCR_Y) &&
-		  jas_image_cmpttype(image, 1) ==
+          jas_image_cmpttype(image, 1) ==
-		  JAS_IMAGE_CT_COLOR(JAS_CLRSPC_CHANIND_YCBCR_CB) &&
+          JAS_IMAGE_CT_COLOR(JAS_CLRSPC_CHANIND_YCBCR_CB) &&
-		  jas_image_cmpttype(image, 2) ==
+          jas_image_cmpttype(image, 2) ==
-		  JAS_IMAGE_CT_COLOR(JAS_CLRSPC_CHANIND_YCBCR_CR))
+          JAS_IMAGE_CT_COLOR(JAS_CLRSPC_CHANIND_YCBCR_CR))
-			needcdef = 0;
+            needcdef = 0;
-		break;
+        break;
-	case JAS_CLRSPC_FAM_GRAY:
+    case JAS_CLRSPC_FAM_GRAY:
-		if (jas_image_cmpttype(image, 0) ==
+        if (jas_image_cmpttype(image, 0) ==
-		  JAS_IMAGE_CT_COLOR(JAS_IMAGE_CT_GRAY_Y))
+          JAS_IMAGE_CT_COLOR(JAS_IMAGE_CT_GRAY_Y))
-			needcdef = 0;
+            needcdef = 0;
-		break;
+        break;
-	default:
+    default:
-		abort();
+        abort();
-		break;
+        break;
-	}
+    }
 
-	if (needcdef) {
+    if (needcdef) {
-		if (!(box = jp2_box_create(JP2_BOX_CDEF))) {
+        if (!(box = jp2_box_create(JP2_BOX_CDEF))) {
-			goto error;
+            goto error;
-		}
+        }
-		cdef = &box->data.cdef;
+        cdef = &box->data.cdef;
-		cdef->numchans = jas_image_numcmpts(image);
+        cdef->numchans = jas_image_numcmpts(image);
-		cdef->ents = jas_alloc2(cdef->numchans, sizeof(jp2_cdefchan_t));
+        cdef->ents = jas_alloc2(cdef->numchans, sizeof(jp2_cdefchan_t));
-		for (i = 0; i < jas_image_numcmpts(image); ++i) {
+        for (i = 0; i < jas_image_numcmpts(image); ++i) {
-			cdefchanent = &cdef->ents[i];
+            cdefchanent = &cdef->ents[i];
-			cdefchanent->channo = i;
+            cdefchanent->channo = i;
-			typeasoc = jp2_gettypeasoc(jas_image_clrspc(image), jas_image_cmpttype(image, i));
+            typeasoc = jp2_gettypeasoc(jas_image_clrspc(image), jas_image_cmpttype(image, i));
-			cdefchanent->type = typeasoc >> 16;
+            cdefchanent->type = typeasoc >> 16;
-			cdefchanent->assoc = typeasoc & 0x7fff;
+            cdefchanent->assoc = typeasoc & 0x7fff;
-		}
+        }
-		if (jp2_box_put(box, tmpstream)) {
+        if (jp2_box_put(box, tmpstream)) {
-			goto error;
+            goto error;
-		}
+        }
-		jp2_box_destroy(box);
+        jp2_box_destroy(box);
-		box = 0;
+        box = 0;
-	}
+    }
 
-	/* Determine the total length of the JP2 header box. */
+    /* Determine the total length of the JP2 header box. */
 
-	len = jas_stream_tell(tmpstream);
+    len = jas_stream_tell(tmpstream);
-	jas_stream_rewind(tmpstream);
+    jas_stream_rewind(tmpstream);
 
-	/*
+    /*
-	 * Output the JP2 header box and all of the boxes which it contains.
+     * Output the JP2 header box and all of the boxes which it contains.
-	 */
+     */
 
-	if (!(box = jp2_box_create(JP2_BOX_JP2H))) {
+    if (!(box = jp2_box_create(JP2_BOX_JP2H))) {
-		goto error;
+        goto error;
-	}
+    }
-	box->len = len + JP2_BOX_HDRLEN(false);
+    box->len = len + JP2_BOX_HDRLEN(false);
-	if (jp2_box_put(box, out)) {
+    if (jp2_box_put(box, out)) {
-		goto error;
+        goto error;
-	}
+    }
-	jp2_box_destroy(box);
+    jp2_box_destroy(box);
-	box = 0;
+    box = 0;
 
-	if (jas_stream_copy(out, tmpstream, len)) {
+    if (jas_stream_copy(out, tmpstream, len)) {
-		goto error;
+        goto error;
-	}
+    }
 
-	jas_stream_close(tmpstream);
+    jas_stream_close(tmpstream);
-	tmpstream = 0;
+    tmpstream = 0;
 
-	return 0;
+    return 0;
-	abort();
+    abort();
 
 error:
 
-	if (box) {
+    if (box) {
-		jp2_box_destroy(box);
+        jp2_box_destroy(box);
-	}
+    }
-	if (tmpstream) {
+    if (tmpstream) {
-		jas_stream_close(tmpstream);
+        jas_stream_close(tmpstream);
-	}
+    }
-	return -1;
+    return -1;
 }
 
 int jp2_write_codestream(jas_image_t *image, jas_stream_t *out, char *optstr)
 {
-	jp2_box_t *box;
+    jp2_box_t *box;
-	char buf[4096];
+    char buf[4096];
-	uint_fast32_t overhead;
+    uint_fast32_t overhead;
 
-	/*
+    /*
-	 * Output the contiguous code stream box.
+     * Output the contiguous code stream box.
-	 */
+     */
 
-	if (!(box = jp2_box_create(JP2_BOX_JP2C))) {
+    if (!(box = jp2_box_create(JP2_BOX_JP2C))) {
-		goto error;
+        goto error;
-	}
+    }
-	box->len = 0;
+    box->len = 0;
-	if (jp2_box_put(box, out)) {
+    if (jp2_box_put(box, out)) {
-		goto error;
+        goto error;
-	}
+    }
-	jp2_box_destroy(box);
+    jp2_box_destroy(box);
-	box = 0;
+    box = 0;
 
-	/* Output the JPEG-2000 code stream. */
+    /* Output the JPEG-2000 code stream. */
 
-	overhead = jas_stream_getrwcount(out);
+    overhead = jas_stream_getrwcount(out);
-	sprintf(buf, "%s\n_jp2overhead=%lu\n", (optstr ? optstr : ""),
+    sprintf(buf, "%s\n_jp2overhead=%lu\n", (optstr ? optstr : ""),
-	  (unsigned long) overhead);
+      (unsigned long) overhead);
 
-	if (jpc_encode(image, out, buf)) {
+    if (jpc_encode(image, out, buf)) {
-		goto error;
+        goto error;
-	}
+    }
 
-	return 0;
+    return 0;
-	abort();
+    abort();
 
 error:
 
-	if (box) {
+    if (box) {
-		jp2_box_destroy(box);
+        jp2_box_destroy(box);
-	}
+    }
-	return -1;
+    return -1;
 }
 
 int jp2_encode(jas_image_t *image, jas_stream_t *out, char *optstr)
 {
-	if (jp2_write_header(image, out) < 0)
+    if (jp2_write_header(image, out) < 0)
-		return -1;
+        return -1;
-	if (jp2_write_codestream(image, out, optstr) < 0)
+    if (jp2_write_codestream(image, out, optstr) < 0)
-		return -1;
+        return -1;
 
-	return 0;
+    return 0;
 }
 
 int jp2_encode_uuid(jas_image_t *image, jas_stream_t *out,
-		    char *optstr, jp2_box_t *uuid)
+            char *optstr, jp2_box_t *uuid)
 {
-	if (jp2_write_header(image, out) < 0)
+    if (jp2_write_header(image, out) < 0)
-		return -1;
+        return -1;
-	if (uuid) {
+    if (uuid) {
-		if (jp2_box_put(uuid, out))
+        if (jp2_box_put(uuid, out))
-			return -1;
+            return -1;
-	}
+    }
-	if (jp2_write_codestream(image, out, optstr) < 0)
+    if (jp2_write_codestream(image, out, optstr) < 0)
-		return -1;
+        return -1;
 
-	return 0;
+    return 0;
 }
 
 static uint_fast32_t jp2_gettypeasoc(int colorspace, int ctype)
 {
-	int type;
+    int type;
-	int asoc;
+    int asoc;
 
-	if (ctype & JAS_IMAGE_CT_OPACITY) {
+    if (ctype & JAS_IMAGE_CT_OPACITY) {
-		type = JP2_CDEF_TYPE_OPACITY;
+        type = JP2_CDEF_TYPE_OPACITY;
-		asoc = JP2_CDEF_ASOC_ALL;
+        asoc = JP2_CDEF_ASOC_ALL;
-		goto done;
+        goto done;
-	}
+    }
 
-	type = JP2_CDEF_TYPE_UNSPEC;
+    type = JP2_CDEF_TYPE_UNSPEC;
-	asoc = JP2_CDEF_ASOC_NONE;
+    asoc = JP2_CDEF_ASOC_NONE;
-	switch (jas_clrspc_fam(colorspace)) {
+    switch (jas_clrspc_fam(colorspace)) {
-	case JAS_CLRSPC_FAM_RGB:
+    case JAS_CLRSPC_FAM_RGB:
-		switch (JAS_IMAGE_CT_COLOR(ctype)) {
+        switch (JAS_IMAGE_CT_COLOR(ctype)) {
-		case JAS_IMAGE_CT_RGB_R:
+        case JAS_IMAGE_CT_RGB_R:
-			type = JP2_CDEF_TYPE_COLOR;
+            type = JP2_CDEF_TYPE_COLOR;
-			asoc = JP2_CDEF_RGB_R;
+            asoc = JP2_CDEF_RGB_R;
-			break;
+            break;
-		case JAS_IMAGE_CT_RGB_G:
+        case JAS_IMAGE_CT_RGB_G:
-			type = JP2_CDEF_TYPE_COLOR;
+            type = JP2_CDEF_TYPE_COLOR;
-			asoc = JP2_CDEF_RGB_G;
+            asoc = JP2_CDEF_RGB_G;
-			break;
+            break;
-		case JAS_IMAGE_CT_RGB_B:
+        case JAS_IMAGE_CT_RGB_B:
-			type = JP2_CDEF_TYPE_COLOR;
+            type = JP2_CDEF_TYPE_COLOR;
-			asoc = JP2_CDEF_RGB_B;
+            asoc = JP2_CDEF_RGB_B;
-			break;
+            break;
-		}
+        }
-		break;
+        break;
-	case JAS_CLRSPC_FAM_YCBCR:
+    case JAS_CLRSPC_FAM_YCBCR:
-		switch (JAS_IMAGE_CT_COLOR(ctype)) {
+        switch (JAS_IMAGE_CT_COLOR(ctype)) {
-		case JAS_IMAGE_CT_YCBCR_Y:
+        case JAS_IMAGE_CT_YCBCR_Y:
-			type = JP2_CDEF_TYPE_COLOR;
+            type = JP2_CDEF_TYPE_COLOR;
-			asoc = JP2_CDEF_YCBCR_Y;
+            asoc = JP2_CDEF_YCBCR_Y;
-			break;
+            break;
-		case JAS_IMAGE_CT_YCBCR_CB:
+        case JAS_IMAGE_CT_YCBCR_CB:
-			type = JP2_CDEF_TYPE_COLOR;
+            type = JP2_CDEF_TYPE_COLOR;
-			asoc = JP2_CDEF_YCBCR_CB;
+            asoc = JP2_CDEF_YCBCR_CB;
-			break;
+            break;
-		case JAS_IMAGE_CT_YCBCR_CR:
+        case JAS_IMAGE_CT_YCBCR_CR:
-			type = JP2_CDEF_TYPE_COLOR;
+            type = JP2_CDEF_TYPE_COLOR;
-			asoc = JP2_CDEF_YCBCR_CR;
+            asoc = JP2_CDEF_YCBCR_CR;
-			break;
+            break;
-		}
+        }
-		break;
+        break;
-	case JAS_CLRSPC_FAM_GRAY:
+    case JAS_CLRSPC_FAM_GRAY:
-		type = JP2_CDEF_TYPE_COLOR;
+        type = JP2_CDEF_TYPE_COLOR;
-		asoc = JP2_CDEF_GRAY_Y;
+        asoc = JP2_CDEF_GRAY_Y;
-		break;
+        break;
-	}
+    }
 
 done:
-	return (type << 16) | asoc;
+    return (type << 16) | asoc;
 }
 
 static int clrspctojp2(jas_clrspc_t clrspc)
 {
-	switch (clrspc) {
+    switch (clrspc) {
-	case JAS_CLRSPC_SRGB:
+    case JAS_CLRSPC_SRGB:
-		return JP2_COLR_SRGB;
+        return JP2_COLR_SRGB;
-	case JAS_CLRSPC_SYCBCR:
+    case JAS_CLRSPC_SYCBCR:
-		return JP2_COLR_SYCC;
+        return JP2_COLR_SYCC;
-	case JAS_CLRSPC_SGRAY:
+    case JAS_CLRSPC_SGRAY:
-		return JP2_COLR_SGRAY;
+        return JP2_COLR_SGRAY;
-	default:
+    default:
-		abort();
+        abort();
-		break;
+        break;
-	}
+    }
 }

3rdparty/libjasper/jpc_bs.c

@@ -6,15 +6,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,
@@ -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__
  */
 
@@ -94,73 +94,73 @@ static jpc_bitstream_t *jpc_bitstream_alloc(void);
 /* Open a bit stream from a stream. */
 jpc_bitstream_t *jpc_bitstream_sopen(jas_stream_t *stream, char *mode)
 {
-	jpc_bitstream_t *bitstream;
+    jpc_bitstream_t *bitstream;
 
-	/* Ensure that the open mode is valid. */
+    /* Ensure that the open mode is valid. */
 #if 1
 /* This causes a string literal too long error (with c99 pedantic mode). */
-	assert(!strcmp(mode, "r") || !strcmp(mode, "w") || !strcmp(mode, "r+")
+    assert(!strcmp(mode, "r") || !strcmp(mode, "w") || !strcmp(mode, "r+")
-	  || !strcmp(mode, "w+"));
+      || !strcmp(mode, "w+"));
 #endif
 
-	if (!(bitstream = jpc_bitstream_alloc())) {
+    if (!(bitstream = jpc_bitstream_alloc())) {
-		return 0;
+        return 0;
-	}
+    }
 
-	/* By default, do not close the underlying (character) stream, upon
+    /* By default, do not close the underlying (character) stream, upon
-	  the close of the bit stream. */
+      the close of the bit stream. */
-	bitstream->flags_ = JPC_BITSTREAM_NOCLOSE;
+    bitstream->flags_ = JPC_BITSTREAM_NOCLOSE;
 
-	bitstream->stream_ = stream;
+    bitstream->stream_ = stream;
-	bitstream->openmode_ = (mode[0] == 'w') ? JPC_BITSTREAM_WRITE :
+    bitstream->openmode_ = (mode[0] == 'w') ? JPC_BITSTREAM_WRITE :
-	  JPC_BITSTREAM_READ;
+      JPC_BITSTREAM_READ;
 
-	/* Mark the data buffer as empty. */
+    /* Mark the data buffer as empty. */
-	bitstream->cnt_ = (bitstream->openmode_ == JPC_BITSTREAM_READ) ? 0 : 8;
+    bitstream->cnt_ = (bitstream->openmode_ == JPC_BITSTREAM_READ) ? 0 : 8;
-	bitstream->buf_ = 0;
+    bitstream->buf_ = 0;
 
-	return bitstream;
+    return bitstream;
 }
 
 /* Close a bit stream. */
 int jpc_bitstream_close(jpc_bitstream_t *bitstream)
 {
-	int ret = 0;
+    int ret = 0;
 
-	/* Align to the next byte boundary while considering the effects of
+    /* Align to the next byte boundary while considering the effects of
-	  bit stuffing. */
+      bit stuffing. */
-	if (jpc_bitstream_align(bitstream)) {
+    if (jpc_bitstream_align(bitstream)) {
-		ret = -1;
+        ret = -1;
-	}
+    }
 
-	/* If necessary, close the underlying (character) stream. */
+    /* If necessary, close the underlying (character) stream. */
-	if (!(bitstream->flags_ & JPC_BITSTREAM_NOCLOSE) && bitstream->stream_) {
+    if (!(bitstream->flags_ & JPC_BITSTREAM_NOCLOSE) && bitstream->stream_) {
-		if (jas_stream_close(bitstream->stream_)) {
+        if (jas_stream_close(bitstream->stream_)) {
-			ret = -1;
+            ret = -1;
-		}
+        }
-		bitstream->stream_ = 0;
+        bitstream->stream_ = 0;
-	}
+    }
 
-	jas_free(bitstream);
+    jas_free(bitstream);
-	return ret;
+    return ret;
 }
 
 /* Allocate a new bit stream. */
 static jpc_bitstream_t *jpc_bitstream_alloc()
 {
-	jpc_bitstream_t *bitstream;
+    jpc_bitstream_t *bitstream;
 
-	/* Allocate memory for the new bit stream object. */
+    /* Allocate memory for the new bit stream object. */
-	if (!(bitstream = jas_malloc(sizeof(jpc_bitstream_t)))) {
+    if (!(bitstream = jas_malloc(sizeof(jpc_bitstream_t)))) {
-		return 0;
+        return 0;
-	}
+    }
-	/* Initialize all of the data members. */
+    /* Initialize all of the data members. */
-	bitstream->stream_ = 0;
+    bitstream->stream_ = 0;
-	bitstream->cnt_ = 0;
+    bitstream->cnt_ = 0;
-	bitstream->flags_ = 0;
+    bitstream->flags_ = 0;
-	bitstream->openmode_ = 0;
+    bitstream->openmode_ = 0;
 
-	return bitstream;
+    return bitstream;
 }
 
 /******************************************************************************\
@@ -170,64 +170,64 @@ static jpc_bitstream_t *jpc_bitstream_alloc()
 /* Get a bit from a bit stream. */
 int jpc_bitstream_getbit_func(jpc_bitstream_t *bitstream)
 {
-	int ret;
+    int ret;
-	JAS_DBGLOG(1000, ("jpc_bitstream_getbit_func(%p)\n", bitstream));
+    JAS_DBGLOG(1000, ("jpc_bitstream_getbit_func(%p)\n", bitstream));
-	ret = jpc_bitstream_getbit_macro(bitstream);
+    ret = jpc_bitstream_getbit_macro(bitstream);
-	JAS_DBGLOG(1000, ("jpc_bitstream_getbit_func -> %d\n", ret));
+    JAS_DBGLOG(1000, ("jpc_bitstream_getbit_func -> %d\n", ret));
-	return ret;
+    return ret;
 }
 
 /* Put a bit to a bit stream. */
 int jpc_bitstream_putbit_func(jpc_bitstream_t *bitstream, int b)
 {
-	int ret;
+    int ret;
-	JAS_DBGLOG(1000, ("jpc_bitstream_putbit_func(%p, %d)\n", bitstream, b));
+    JAS_DBGLOG(1000, ("jpc_bitstream_putbit_func(%p, %d)\n", bitstream, b));
-	ret = jpc_bitstream_putbit_macro(bitstream, b);
+    ret = jpc_bitstream_putbit_macro(bitstream, b);
-	JAS_DBGLOG(1000, ("jpc_bitstream_putbit_func() -> %d\n", ret));
+    JAS_DBGLOG(1000, ("jpc_bitstream_putbit_func() -> %d\n", ret));
-	return ret;
+    return ret;
 }
 
 /* Get one or more bits from a bit stream. */
 long jpc_bitstream_getbits(jpc_bitstream_t *bitstream, int n)
 {
-	long v;
+    long v;
-	int u;
+    int u;
 
-	/* We can reliably get at most 31 bits since ISO/IEC 9899 only
+    /* We can reliably get at most 31 bits since ISO/IEC 9899 only
-	  guarantees that a long can represent values up to 2^31-1. */
+      guarantees that a long can represent values up to 2^31-1. */
-	assert(n >= 0 && n < 32);
+    assert(n >= 0 && n < 32);
 
-	/* Get the number of bits requested from the specified bit stream. */
+    /* Get the number of bits requested from the specified bit stream. */
-	v = 0;
+    v = 0;
-	while (--n >= 0) {
+    while (--n >= 0) {
-		if ((u = jpc_bitstream_getbit(bitstream)) < 0) {
+        if ((u = jpc_bitstream_getbit(bitstream)) < 0) {
-			return -1;
+            return -1;
-		}
+        }
-		v = (v << 1) | u;
+        v = (v << 1) | u;
-	}
+    }
-	return v;
+    return v;
 }
 
 /* Put one or more bits to a bit stream. */
 int jpc_bitstream_putbits(jpc_bitstream_t *bitstream, int n, long v)
 {
-	int m;
+    int m;
 
-	/* We can reliably put at most 31 bits since ISO/IEC 9899 only
+    /* We can reliably put at most 31 bits since ISO/IEC 9899 only
-	  guarantees that a long can represent values up to 2^31-1. */
+      guarantees that a long can represent values up to 2^31-1. */
-	assert(n >= 0 && n < 32);
+    assert(n >= 0 && n < 32);
-	/* Ensure that only the bits to be output are nonzero. */
+    /* Ensure that only the bits to be output are nonzero. */
-	assert(!(v & (~JAS_ONES(n))));
+    assert(!(v & (~JAS_ONES(n))));
 
-	/* Put the desired number of bits to the specified bit stream. */
+    /* Put the desired number of bits to the specified bit stream. */
-	m = n - 1;
+    m = n - 1;
-	while (--n >= 0) {
+    while (--n >= 0) {
-		if (jpc_bitstream_putbit(bitstream, (v >> m) & 1) == EOF) {
+        if (jpc_bitstream_putbit(bitstream, (v >> m) & 1) == EOF) {
-			return EOF;
+            return EOF;
-		}
+        }
-		v <<= 1;
+        v <<= 1;
-	}
+    }
-	return 0;
+    return 0;
 }
 
 /******************************************************************************\
@@ -237,30 +237,30 @@ int jpc_bitstream_putbits(jpc_bitstream_t *bitstream, int n, long v)
 /* Fill the buffer for a bit stream. */
 int jpc_bitstream_fillbuf(jpc_bitstream_t *bitstream)
 {
-	int c;
+    int c;
-	/* Note: The count has already been decremented by the caller. */
+    /* Note: The count has already been decremented by the caller. */
-	assert(bitstream->openmode_ & JPC_BITSTREAM_READ);
+    assert(bitstream->openmode_ & JPC_BITSTREAM_READ);
-	assert(bitstream->cnt_ <= 0);
+    assert(bitstream->cnt_ <= 0);
 
-	if (bitstream->flags_ & JPC_BITSTREAM_ERR) {
+    if (bitstream->flags_ & JPC_BITSTREAM_ERR) {
-		bitstream->cnt_ = 0;
+        bitstream->cnt_ = 0;
-		return -1;
+        return -1;
-	}
+    }
 
-	if (bitstream->flags_ & JPC_BITSTREAM_EOF) {
+    if (bitstream->flags_ & JPC_BITSTREAM_EOF) {
-		bitstream->buf_ = 0x7f;
+        bitstream->buf_ = 0x7f;
-		bitstream->cnt_ = 7;
+        bitstream->cnt_ = 7;
-		return 1;
+        return 1;
-	}
+    }
 
-	bitstream->buf_ = (bitstream->buf_ << 8) & 0xffff;
+    bitstream->buf_ = (bitstream->buf_ << 8) & 0xffff;
-	if ((c = jas_stream_getc((bitstream)->stream_)) == EOF) {
+    if ((c = jas_stream_getc((bitstream)->stream_)) == EOF) {
-		bitstream->flags_ |= JPC_BITSTREAM_EOF;
+        bitstream->flags_ |= JPC_BITSTREAM_EOF;
-		return 1;
+        return 1;
-	}
+    }
-	bitstream->cnt_ = (bitstream->buf_ == 0xff00) ? 6 : 7;
+    bitstream->cnt_ = (bitstream->buf_ == 0xff00) ? 6 : 7;
-	bitstream->buf_ |= c & ((1 << (bitstream->cnt_ + 1)) - 1);
+    bitstream->buf_ |= c & ((1 << (bitstream->cnt_ + 1)) - 1);
-	return (bitstream->buf_ >> bitstream->cnt_) & 1;
+    return (bitstream->buf_ >> bitstream->cnt_) & 1;
 }
 
 
@@ -272,169 +272,169 @@ int jpc_bitstream_fillbuf(jpc_bitstream_t *bitstream)
   the effects of bit stuffing)? */
 int jpc_bitstream_needalign(jpc_bitstream_t *bitstream)
 {
-	if (bitstream->openmode_ & JPC_BITSTREAM_READ) {
+    if (bitstream->openmode_ & JPC_BITSTREAM_READ) {
-		/* The bit stream is open for reading. */
+        /* The bit stream is open for reading. */
-		/* If there are any bits buffered for reading, or the
+        /* If there are any bits buffered for reading, or the
-		  previous byte forced a stuffed bit, alignment is
+          previous byte forced a stuffed bit, alignment is
-		  required. */
+          required. */
-		if ((bitstream->cnt_ < 8 && bitstream->cnt_ > 0) ||
+        if ((bitstream->cnt_ < 8 && bitstream->cnt_ > 0) ||
-		  ((bitstream->buf_ >> 8) & 0xff) == 0xff) {
+          ((bitstream->buf_ >> 8) & 0xff) == 0xff) {
-			return 1;
+            return 1;
-		}
+        }
-	} else if (bitstream->openmode_ & JPC_BITSTREAM_WRITE) {
+    } else if (bitstream->openmode_ & JPC_BITSTREAM_WRITE) {
-		/* The bit stream is open for writing. */
+        /* The bit stream is open for writing. */
-		/* If there are any bits buffered for writing, or the
+        /* If there are any bits buffered for writing, or the
-		  previous byte forced a stuffed bit, alignment is
+          previous byte forced a stuffed bit, alignment is
-		  required. */
+          required. */
-		if ((bitstream->cnt_ < 8 && bitstream->cnt_ >= 0) ||
+        if ((bitstream->cnt_ < 8 && bitstream->cnt_ >= 0) ||
-		  ((bitstream->buf_ >> 8) & 0xff) == 0xff) {
+          ((bitstream->buf_ >> 8) & 0xff) == 0xff) {
-			return 1;
+            return 1;
-		}
+        }
-	} else {
+    } else {
-		/* This should not happen.  Famous last words, eh? :-) */
+        /* This should not happen.  Famous last words, eh? :-) */
-		assert(0);
+        assert(0);
-		return -1;
+        return -1;
-	}
+    }
-	return 0;
+    return 0;
 }
 
 /* How many additional bytes would be output if we align the bit stream? */
 int jpc_bitstream_pending(jpc_bitstream_t *bitstream)
 {
-	if (bitstream->openmode_ & JPC_BITSTREAM_WRITE) {
+    if (bitstream->openmode_ & JPC_BITSTREAM_WRITE) {
-		/* The bit stream is being used for writing. */
+        /* The bit stream is being used for writing. */
 #if 1
-		/* XXX - Is this really correct?  Check someday... */
+        /* XXX - Is this really correct?  Check someday... */
-		if (bitstream->cnt_ < 8) {
+        if (bitstream->cnt_ < 8) {
-			return 1;
+            return 1;
-		}
+        }
 #else
-		if (bitstream->cnt_ < 8) {
+        if (bitstream->cnt_ < 8) {
-			if (((bitstream->buf_ >> 8) & 0xff) == 0xff) {
+            if (((bitstream->buf_ >> 8) & 0xff) == 0xff) {
-				return 2;
+                return 2;
-			}
+            }
-			return 1;
+            return 1;
-		}
+        }
 #endif
-		return 0;
+        return 0;
-	} else {
+    } else {
-		/* This operation should not be invoked on a bit stream that
+        /* This operation should not be invoked on a bit stream that
-		  is being used for reading. */
+          is being used for reading. */
-		return -1;
+        return -1;
-	}
+    }
 }
 
 /* Align the bit stream to a byte boundary. */
 int jpc_bitstream_align(jpc_bitstream_t *bitstream)
 {
-	int ret;
+    int ret;
-	if (bitstream->openmode_ & JPC_BITSTREAM_READ) {
+    if (bitstream->openmode_ & JPC_BITSTREAM_READ) {
-		ret = jpc_bitstream_inalign(bitstream, 0, 0);
+        ret = jpc_bitstream_inalign(bitstream, 0, 0);
-	} else if (bitstream->openmode_ & JPC_BITSTREAM_WRITE) {
+    } else if (bitstream->openmode_ & JPC_BITSTREAM_WRITE) {
-		ret = jpc_bitstream_outalign(bitstream, 0);
+        ret = jpc_bitstream_outalign(bitstream, 0);
-	} else {
+    } else {
-		abort();
+        abort();
-	}
+    }
-	return ret;
+    return ret;
 }
 
 /* Align a bit stream in the input case. */
 int jpc_bitstream_inalign(jpc_bitstream_t *bitstream, int fillmask,
   int filldata)
 {
-	int n;
+    int n;
-	int v;
+    int v;
-	int u;
+    int u;
-	int numfill;
+    int numfill;
-	int m;
+    int m;
 
-	numfill = 7;
+    numfill = 7;
-	m = 0;
+    m = 0;
-	v = 0;
+    v = 0;
-	if (bitstream->cnt_ > 0) {
+    if (bitstream->cnt_ > 0) {
-		n = bitstream->cnt_;
+        n = bitstream->cnt_;
-	} else if (!bitstream->cnt_) {
+    } else if (!bitstream->cnt_) {
-		n = ((bitstream->buf_ & 0xff) == 0xff) ? 7 : 0;
+        n = ((bitstream->buf_ & 0xff) == 0xff) ? 7 : 0;
-	} else {
+    } else {
-		n = 0;
+        n = 0;
-	}
+    }
-	if (n > 0) {
+    if (n > 0) {
-		if ((u = jpc_bitstream_getbits(bitstream, n)) < 0) {
+        if ((u = jpc_bitstream_getbits(bitstream, n)) < 0) {
-			return -1;
+            return -1;
-		}
+        }
-		m += n;
+        m += n;
-		v = (v << n) | u;
+        v = (v << n) | u;
-	}
+    }
-	if ((bitstream->buf_ & 0xff) == 0xff) {
+    if ((bitstream->buf_ & 0xff) == 0xff) {
-		if ((u = jpc_bitstream_getbits(bitstream, 7)) < 0) {
+        if ((u = jpc_bitstream_getbits(bitstream, 7)) < 0) {
-			return -1;
+            return -1;
-		}
+        }
-		v = (v << 7) | u;
+        v = (v << 7) | u;
-		m += 7;
+        m += 7;
-	}
+    }
-	if (m > numfill) {
+    if (m > numfill) {
-		v >>= m - numfill;
+        v >>= m - numfill;
-	} else {
+    } else {
-		filldata >>= numfill - m;
+        filldata >>= numfill - m;
-		fillmask >>= numfill - m;
+        fillmask >>= numfill - m;
-	}
+    }
-	if (((~(v ^ filldata)) & fillmask) != fillmask) {
+    if (((~(v ^ filldata)) & fillmask) != fillmask) {
-		/* The actual fill pattern does not match the expected one. */
+        /* The actual fill pattern does not match the expected one. */
-		return 1;
+        return 1;
-	}
+    }
 
-	return 0;
+    return 0;
 }
 
 /* Align a bit stream in the output case. */
 int jpc_bitstream_outalign(jpc_bitstream_t *bitstream, int filldata)
 {
-	int n;
+    int n;
-	int v;
+    int v;
 
-	/* Ensure that this bit stream is open for writing. */
+    /* Ensure that this bit stream is open for writing. */
-	assert(bitstream->openmode_ & JPC_BITSTREAM_WRITE);
+    assert(bitstream->openmode_ & JPC_BITSTREAM_WRITE);
 
-	/* Ensure that the first bit of fill data is zero. */
+    /* Ensure that the first bit of fill data is zero. */
-	/* Note: The first bit of fill data must be zero.  If this were not
+    /* Note: The first bit of fill data must be zero.  If this were not
-	  the case, the fill data itself could cause further bit stuffing to
+      the case, the fill data itself could cause further bit stuffing to
-	  be required (which would cause numerous complications). */
+      be required (which would cause numerous complications). */
-	assert(!(filldata & (~0x3f)));
+    assert(!(filldata & (~0x3f)));
 
-	if (!bitstream->cnt_) {
+    if (!bitstream->cnt_) {
-		if ((bitstream->buf_ & 0xff) == 0xff) {
+        if ((bitstream->buf_ & 0xff) == 0xff) {
-			n = 7;
+            n = 7;
-			v = filldata;
+            v = filldata;
-		} else {
+        } else {
-			n = 0;
+            n = 0;
-			v = 0;
+            v = 0;
-		}
+        }
-	} else if (bitstream->cnt_ > 0 && bitstream->cnt_ < 8) {
+    } else if (bitstream->cnt_ > 0 && bitstream->cnt_ < 8) {
-		n = bitstream->cnt_;
+        n = bitstream->cnt_;
-		v = filldata >> (7 - n);
+        v = filldata >> (7 - n);
-	} else {
+    } else {
-		n = 0;
+        n = 0;
-		v = 0;
+        v = 0;
-		return 0;
+        return 0;
-	}
+    }
 
-	/* Write the appropriate fill data to the bit stream. */
+    /* Write the appropriate fill data to the bit stream. */
-	if (n > 0) {
+    if (n > 0) {
-		if (jpc_bitstream_putbits(bitstream, n, v)) {
+        if (jpc_bitstream_putbits(bitstream, n, v)) {
-			return -1;
+            return -1;
-		}
+        }
-	}
+    }
-	if (bitstream->cnt_ < 8) {
+    if (bitstream->cnt_ < 8) {
-		assert(bitstream->cnt_ >= 0 && bitstream->cnt_ < 8);
+        assert(bitstream->cnt_ >= 0 && bitstream->cnt_ < 8);
-		assert((bitstream->buf_ & 0xff) != 0xff);
+        assert((bitstream->buf_ & 0xff) != 0xff);
-		/* Force the pending byte of output to be written to the
+        /* Force the pending byte of output to be written to the
-		  underlying (character) stream. */
+          underlying (character) stream. */
-		if (jas_stream_putc(bitstream->stream_, bitstream->buf_ & 0xff) == EOF) {
+        if (jas_stream_putc(bitstream->stream_, bitstream->buf_ & 0xff) == EOF) {
-			return -1;
+            return -1;
-		}
+        }
-		bitstream->cnt_ = 8;
+        bitstream->cnt_ = 8;
-		bitstream->buf_ = (bitstream->buf_ << 8) & 0xffff;
+        bitstream->buf_ = (bitstream->buf_ << 8) & 0xffff;
-	}
+    }
 
-	return 0;
+    return 0;
 }

3rdparty/libjasper/jpc_bs.h

@@ -6,15 +6,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,
@@ -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__
  */
 
@@ -111,20 +111,20 @@
 
 typedef struct {
 
-	/* Some miscellaneous flags. */
+    /* Some miscellaneous flags. */
-	int flags_;
+    int flags_;
 
-	/* The input/output buffer. */
+    /* The input/output buffer. */
-	uint_fast16_t buf_;
+    uint_fast16_t buf_;
 
-	/* The number of bits remaining in the byte being read/written. */
+    /* The number of bits remaining in the byte being read/written. */
-	int cnt_;
+    int cnt_;
 
-	/* The underlying stream associated with this bit stream. */
+    /* The underlying stream associated with this bit stream. */
-	jas_stream_t *stream_;
+    jas_stream_t *stream_;
 
-	/* The mode in which this bit stream was opened. */
+    /* The mode in which this bit stream was opened. */
-	int openmode_;
+    int openmode_;
 
 } jpc_bitstream_t;
 
@@ -145,19 +145,19 @@ int jpc_bitstream_close(jpc_bitstream_t *bitstream);
 /* Read a bit from a bit stream. */
 #if defined(DEBUG)
 #define	jpc_bitstream_getbit(bitstream) \
-	jpc_bitstream_getbit_func(bitstream)
+    jpc_bitstream_getbit_func(bitstream)
 #else
 #define jpc_bitstream_getbit(bitstream) \
-	jpc_bitstream_getbit_macro(bitstream)
+    jpc_bitstream_getbit_macro(bitstream)
 #endif
 
 /* Write a bit to a bit stream. */
 #if defined(DEBUG)
 #define	jpc_bitstream_putbit(bitstream, v) \
-	jpc_bitstream_putbit_func(bitstream, v)
+    jpc_bitstream_putbit_func(bitstream, v)
 #else
 #define	jpc_bitstream_putbit(bitstream, v) \
-	jpc_bitstream_putbit_macro(bitstream, v)
+    jpc_bitstream_putbit_macro(bitstream, v)
 #endif
 
 /* Read one or more bits from a bit stream. */
@@ -196,7 +196,7 @@ int jpc_bitstream_pending(jpc_bitstream_t *bitstream);
 
 /* Has EOF been encountered on a bit stream? */
 #define jpc_bitstream_eof(bitstream) \
-	((bitstream)->flags_ & JPC_BITSTREAM_EOF)
+    ((bitstream)->flags_ & JPC_BITSTREAM_EOF)
 
 /******************************************************************************\
 * Internals.
@@ -212,20 +212,20 @@ int jpc_bitstream_putbit_func(jpc_bitstream_t *bitstream, int v);
 int jpc_bitstream_fillbuf(jpc_bitstream_t *bitstream);
 
 #define	jpc_bitstream_getbit_macro(bitstream) \
-	(assert((bitstream)->openmode_ & JPC_BITSTREAM_READ), \
+    (assert((bitstream)->openmode_ & JPC_BITSTREAM_READ), \
-	  (--(bitstream)->cnt_ >= 0) ? \
+      (--(bitstream)->cnt_ >= 0) ? \
-	  ((int)(((bitstream)->buf_ >> (bitstream)->cnt_) & 1)) : \
+      ((int)(((bitstream)->buf_ >> (bitstream)->cnt_) & 1)) : \
-	  jpc_bitstream_fillbuf(bitstream))
+      jpc_bitstream_fillbuf(bitstream))
 
 #define jpc_bitstream_putbit_macro(bitstream, bit) \
-	(assert((bitstream)->openmode_ & JPC_BITSTREAM_WRITE), \
+    (assert((bitstream)->openmode_ & JPC_BITSTREAM_WRITE), \
-	  (--(bitstream)->cnt_ < 0) ? \
+      (--(bitstream)->cnt_ < 0) ? \
-	  ((bitstream)->buf_ = ((bitstream)->buf_ << 8) & 0xffff, \
+      ((bitstream)->buf_ = ((bitstream)->buf_ << 8) & 0xffff, \
-	  (bitstream)->cnt_ = ((bitstream)->buf_ == 0xff00) ? 6 : 7, \
+      (bitstream)->cnt_ = ((bitstream)->buf_ == 0xff00) ? 6 : 7, \
-	  (bitstream)->buf_ |= ((bit) & 1) << (bitstream)->cnt_, \
+      (bitstream)->buf_ |= ((bit) & 1) << (bitstream)->cnt_, \
-	  (jas_stream_putc((bitstream)->stream_, (bitstream)->buf_ >> 8) == EOF) \
+      (jas_stream_putc((bitstream)->stream_, (bitstream)->buf_ >> 8) == EOF) \
-	  ? (EOF) : ((bit) & 1)) : \
+      ? (EOF) : ((bit) & 1)) : \
-	  ((bitstream)->buf_ |= ((bit) & 1) << (bitstream)->cnt_, \
+      ((bitstream)->buf_ |= ((bit) & 1) << (bitstream)->cnt_, \
-	  (bit) & 1))
+      (bit) & 1))
 
 #endif

3rdparty/libjasper/jpc_cod.h

@@ -6,15 +6,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,
@@ -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__
  */
 

3rdparty/libjasper/jpc_cs.h

@@ -6,15 +6,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,
@@ -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__
  */
 
@@ -125,8 +125,8 @@
 
 typedef struct {
 
-	/* The number of components. */
+    /* The number of components. */
-	uint_fast16_t numcomps;
+    uint_fast16_t numcomps;
 
 } jpc_cstate_t;
 
@@ -136,18 +136,18 @@ typedef struct {
 
 typedef struct {
 
-	/* The tile number. */
+    /* The tile number. */
-	uint_fast16_t tileno;
+    uint_fast16_t tileno;
 
-	/* The combined length of the marker segment and its auxilary data
+    /* The combined length of the marker segment and its auxilary data
-	  (i.e., packet data). */
+      (i.e., packet data). */
-	uint_fast32_t len;
+    uint_fast32_t len;
 
-	/* The tile-part instance. */
+    /* The tile-part instance. */
-	uint_fast8_t partno;
+    uint_fast8_t partno;
 
-	/* The number of tile-parts. */
+    /* The number of tile-parts. */
-	uint_fast8_t numparts;
+    uint_fast8_t numparts;
 
 } jpc_sot_t;
 
@@ -159,19 +159,19 @@ typedef struct {
 
 typedef struct {
 
-	/* The precision of the samples. */
+    /* The precision of the samples. */
-	uint_fast8_t prec;
+    uint_fast8_t prec;
 
-	/* The signedness of the samples. */
+    /* The signedness of the samples. */
-	uint_fast8_t sgnd;
+    uint_fast8_t sgnd;
 
-	/* The horizontal separation of samples with respect to the reference
+    /* The horizontal separation of samples with respect to the reference
-	  grid. */
+      grid. */
-	uint_fast8_t hsamp;
+    uint_fast8_t hsamp;
 
-	/* The vertical separation of samples with respect to the reference
+    /* The vertical separation of samples with respect to the reference
-	  grid. */
+      grid. */
-	uint_fast8_t vsamp;
+    uint_fast8_t vsamp;
 
 } jpc_sizcomp_t;
 
@@ -179,42 +179,42 @@ typedef struct {
 
 typedef struct {
 
-	/* The code stream capabilities. */
+    /* The code stream capabilities. */
-	uint_fast16_t caps;
+    uint_fast16_t caps;
 
-	/* The width of the image in units of the reference grid. */
+    /* The width of the image in units of the reference grid. */
-	uint_fast32_t width;
+    uint_fast32_t width;
 
-	/* The height of the image in units of the reference grid. */
+    /* The height of the image in units of the reference grid. */
-	uint_fast32_t height;
+    uint_fast32_t height;
 
-	/* The horizontal offset from the origin of the reference grid to the
+    /* The horizontal offset from the origin of the reference grid to the
-	  left side of the image area. */
+      left side of the image area. */
-	uint_fast32_t xoff;
+    uint_fast32_t xoff;
 
-	/* The vertical offset from the origin of the reference grid to the
+    /* The vertical offset from the origin of the reference grid to the
-	  top side of the image area. */
+      top side of the image area. */
-	uint_fast32_t yoff;
+    uint_fast32_t yoff;
 
-	/* The nominal width of a tile in units of the reference grid. */
+    /* The nominal width of a tile in units of the reference grid. */
-	uint_fast32_t tilewidth;
+    uint_fast32_t tilewidth;
 
-	/* The nominal height of a tile in units of the reference grid. */
+    /* The nominal height of a tile in units of the reference grid. */
-	uint_fast32_t tileheight;
+    uint_fast32_t tileheight;
 
-	/* The horizontal offset from the origin of the reference grid to the
+    /* The horizontal offset from the origin of the reference grid to the
-	  left side of the first tile. */
+      left side of the first tile. */
-	uint_fast32_t tilexoff;
+    uint_fast32_t tilexoff;
 
-	/* The vertical offset from the origin of the reference grid to the
+    /* The vertical offset from the origin of the reference grid to the
-	  top side of the first tile. */
+      top side of the first tile. */
-	uint_fast32_t tileyoff;
+    uint_fast32_t tileyoff;
 
-	/* The number of components. */
+    /* The number of components. */
-	uint_fast16_t numcomps;
+    uint_fast16_t numcomps;
 
-	/* The per-component information. */
+    /* The per-component information. */
-	jpc_sizcomp_t *comps;
+    jpc_sizcomp_t *comps;
 
 } jpc_siz_t;
 
@@ -278,11 +278,11 @@ typedef struct {
 
 typedef struct {
 
-	/* The packet partition width. */
+    /* The packet partition width. */
-	uint_fast8_t parwidthval;
+    uint_fast8_t parwidthval;
 
-	/* The packet partition height. */
+    /* The packet partition height. */
-	uint_fast8_t parheightval;
+    uint_fast8_t parheightval;
 
 } jpc_coxrlvl_t;
 
@@ -290,29 +290,29 @@ typedef struct {
 
 typedef struct {
 
-	/* The coding style. */
+    /* The coding style. */
-	uint_fast8_t csty;
+    uint_fast8_t csty;
 
-	/* The number of decomposition levels. */
+    /* The number of decomposition levels. */
-	uint_fast8_t numdlvls;
+    uint_fast8_t numdlvls;
 
-	/* The nominal code block width specifier. */
+    /* The nominal code block width specifier. */
-	uint_fast8_t cblkwidthval;
+    uint_fast8_t cblkwidthval;
 
-	/* The nominal code block height specifier. */
+    /* The nominal code block height specifier. */
-	uint_fast8_t cblkheightval;
+    uint_fast8_t cblkheightval;
 
-	/* The style of coding passes. */
+    /* The style of coding passes. */
-	uint_fast8_t cblksty;
+    uint_fast8_t cblksty;
 
-	/* The QMFB employed. */
+    /* The QMFB employed. */
-	uint_fast8_t qmfbid;
+    uint_fast8_t qmfbid;
 
-	/* The number of resolution levels. */
+    /* The number of resolution levels. */
-	int numrlvls;
+    int numrlvls;
 
-	/* The per-resolution-level information. */
+    /* The per-resolution-level information. */
-	jpc_coxrlvl_t rlvls[JPC_MAXRLVLS];
+    jpc_coxrlvl_t rlvls[JPC_MAXRLVLS];
 
 } jpc_coxcp_t;
 
@@ -320,20 +320,20 @@ typedef struct {
 
 typedef struct {
 
-	/* The general coding style. */
+    /* The general coding style. */
-	uint_fast8_t csty;
+    uint_fast8_t csty;
 
-	/* The progression order. */
+    /* The progression order. */
-	uint_fast8_t prg;
+    uint_fast8_t prg;
 
-	/* The number of layers. */
+    /* The number of layers. */
-	uint_fast16_t numlyrs;
+    uint_fast16_t numlyrs;
 
-	/* The multicomponent transform. */
+    /* The multicomponent transform. */
-	uint_fast8_t mctrans;
+    uint_fast8_t mctrans;
 
-	/* Component-related parameters. */
+    /* Component-related parameters. */
-	jpc_coxcp_t compparms;
+    jpc_coxcp_t compparms;
 
 } jpc_cod_t;
 
@@ -341,11 +341,11 @@ typedef struct {
 
 typedef struct {
 
-	/* The component number. */
+    /* The component number. */
-	uint_fast16_t compno;
+    uint_fast16_t compno;
 
-	/* Component-related parameters. */
+    /* Component-related parameters. */
-	jpc_coxcp_t compparms;
+    jpc_coxcp_t compparms;
 
 } jpc_coc_t;
 
@@ -358,14 +358,14 @@ typedef struct {
 
 typedef struct {
 
-	/* The component to which the marker applies. */
+    /* The component to which the marker applies. */
-	uint_fast16_t compno;
+    uint_fast16_t compno;
 
-	/* The ROI style. */
+    /* The ROI style. */
-	uint_fast8_t roisty;
+    uint_fast8_t roisty;
 
-	/* The ROI shift value. */
+    /* The ROI shift value. */
-	uint_fast8_t roishift;
+    uint_fast8_t roishift;
 
 } jpc_rgn_t;
 
@@ -394,17 +394,17 @@ typedef struct {
 
 typedef struct {
 
-	/* The quantization style. */
+    /* The quantization style. */
-	uint_fast8_t qntsty;
+    uint_fast8_t qntsty;
 
-	/* The number of step sizes. */
+    /* The number of step sizes. */
-	int numstepsizes;
+    int numstepsizes;
 
-	/* The step sizes. */
+    /* The step sizes. */
-	uint_fast16_t *stepsizes;
+    uint_fast16_t *stepsizes;
 
-	/* The number of guard bits. */
+    /* The number of guard bits. */
-	uint_fast8_t numguard;
+    uint_fast8_t numguard;
 
 } jpc_qcxcp_t;
 
@@ -412,11 +412,11 @@ typedef struct {
 
 typedef struct {
 
-	/* The component associated with this marker segment. */
+    /* The component associated with this marker segment. */
-	uint_fast16_t compno;
+    uint_fast16_t compno;
 
-	/* The parameters. */
+    /* The parameters. */
-	jpc_qcxcp_t compparms;
+    jpc_qcxcp_t compparms;
 
 } jpc_qcc_t;
 
@@ -424,8 +424,8 @@ typedef struct {
 
 typedef struct {
 
-	/* The parameters. */
+    /* The parameters. */
-	jpc_qcxcp_t compparms;
+    jpc_qcxcp_t compparms;
 
 } jpc_qcd_t;
 
@@ -435,28 +435,28 @@ typedef struct {
 
 typedef struct {
 
-	/* The progression order. */
+    /* The progression order. */
-	uint_fast8_t prgord;
+    uint_fast8_t prgord;
 
-	/* The lower bound (inclusive) on the resolution level for the
+    /* The lower bound (inclusive) on the resolution level for the
-	  progression order volume. */
+      progression order volume. */
-	uint_fast8_t rlvlnostart;
+    uint_fast8_t rlvlnostart;
 
-	/* The upper bound (exclusive) on the resolution level for the
+    /* The upper bound (exclusive) on the resolution level for the
-	  progression order volume. */
+      progression order volume. */
-	uint_fast8_t rlvlnoend;
+    uint_fast8_t rlvlnoend;
 
-	/* The lower bound (inclusive) on the component for the progression
+    /* The lower bound (inclusive) on the component for the progression
-	  order volume. */
+      order volume. */
-	uint_fast16_t compnostart;
+    uint_fast16_t compnostart;
 
-	/* The upper bound (exclusive) on the component for the progression
+    /* The upper bound (exclusive) on the component for the progression
-	  order volume. */
+      order volume. */
-	uint_fast16_t compnoend;
+    uint_fast16_t compnoend;
 
-	/* The upper bound (exclusive) on the layer for the progression
+    /* The upper bound (exclusive) on the layer for the progression
-	  order volume. */
+      order volume. */
-	uint_fast16_t lyrnoend;
+    uint_fast16_t lyrnoend;
 
 } jpc_pocpchg_t;
 
@@ -467,11 +467,11 @@ typedef jpc_pocpchg_t jpc_pchg_t;
 
 typedef struct {
 
-	/* The number of progression order changes. */
+    /* The number of progression order changes. */
-	int numpchgs;
+    int numpchgs;
 
-	/* The per-progression-order-change information. */
+    /* The per-progression-order-change information. */
-	jpc_pocpchg_t *pchgs;
+    jpc_pocpchg_t *pchgs;
 
 } jpc_poc_t;
 
@@ -483,14 +483,14 @@ typedef struct {
 
 typedef struct {
 
-	/* The index. */
+    /* The index. */
-	uint_fast8_t ind;
+    uint_fast8_t ind;
 
-	/* The length. */
+    /* The length. */
-	uint_fast16_t len;
+    uint_fast16_t len;
 
-	/* The data. */
+    /* The data. */
-	uchar *data;
+    uchar *data;
 
 } jpc_ppm_t;
 
@@ -498,14 +498,14 @@ typedef struct {
 
 typedef struct {
 
-	/* The index. */
+    /* The index. */
-	uint_fast8_t ind;
+    uint_fast8_t ind;
 
-	/* The length. */
+    /* The length. */
-	uint_fast32_t len;
+    uint_fast32_t len;
 
-	/* The data. */
+    /* The data. */
-	unsigned char *data;
+    unsigned char *data;
 
 } jpc_ppt_t;
 
@@ -522,14 +522,14 @@ typedef struct {
 
 typedef struct {
 
-	/* The registration ID. */
+    /* The registration ID. */
-	uint_fast16_t regid;
+    uint_fast16_t regid;
 
-	/* The length of the data in bytes. */
+    /* The length of the data in bytes. */
-	uint_fast16_t len;
+    uint_fast16_t len;
 
-	/* The data. */
+    /* The data. */
-	uchar *data;
+    uchar *data;
 
 } jpc_com_t;
 
@@ -539,8 +539,8 @@ typedef struct {
 
 typedef struct {
 
-	/* The sequence number. */
+    /* The sequence number. */
-	uint_fast16_t seqno;
+    uint_fast16_t seqno;
 
 } jpc_sop_t;
 
@@ -552,21 +552,21 @@ typedef struct {
 
 typedef struct {
 
-	/* The horizontal offset. */
+    /* The horizontal offset. */
-	uint_fast16_t hoff;
+    uint_fast16_t hoff;
 
-	/* The vertical offset. */
+    /* The vertical offset. */
-	uint_fast16_t voff;
+    uint_fast16_t voff;
 
 } jpc_crgcomp_t;
 
 typedef struct {
 
-	/* The number of components. */
+    /* The number of components. */
-	int numcomps;
+    int numcomps;
 
-	/* Per component information. */
+    /* Per component information. */
-	jpc_crgcomp_t *comps;
+    jpc_crgcomp_t *comps;
 
 } jpc_crg_t;
 
@@ -576,11 +576,11 @@ typedef struct {
 
 typedef struct {
 
-	/* The data. */
+    /* The data. */
-	uchar *data;
+    uchar *data;
 
-	/* The length. */
+    /* The length. */
-	uint_fast16_t len;
+    uint_fast16_t len;
 
 } jpc_unk_t;
 
@@ -589,26 +589,26 @@ typedef struct {
 \**************************************/
 
 typedef union {
-	int soc;	/* unused */
+    int soc;	/* unused */
-	jpc_sot_t sot;
+    jpc_sot_t sot;
-	int sod;	/* unused */
+    int sod;	/* unused */
-	int eoc;	/* unused */
+    int eoc;	/* unused */
-	jpc_siz_t siz;
+    jpc_siz_t siz;
-	jpc_cod_t cod;
+    jpc_cod_t cod;
-	jpc_coc_t coc;
+    jpc_coc_t coc;
-	jpc_rgn_t rgn;
+    jpc_rgn_t rgn;
-	jpc_qcd_t qcd;
+    jpc_qcd_t qcd;
-	jpc_qcc_t qcc;
+    jpc_qcc_t qcc;
-	jpc_poc_t poc;
+    jpc_poc_t poc;
-	/* jpc_plm_t plm; */
+    /* jpc_plm_t plm; */
-	/* jpc_plt_t plt; */
+    /* jpc_plt_t plt; */
-	jpc_ppm_t ppm;
+    jpc_ppm_t ppm;
-	jpc_ppt_t ppt;
+    jpc_ppt_t ppt;
-	jpc_sop_t sop;
+    jpc_sop_t sop;
-	int eph;	/* unused */
+    int eph;	/* unused */
-	jpc_com_t com;
+    jpc_com_t com;
-	jpc_crg_t crg;
+    jpc_crg_t crg;
-	jpc_unk_t unk;
+    jpc_unk_t unk;
 } jpc_msparms_t;
 
 /**************************************\
@@ -667,20 +667,20 @@ struct jpc_msops_s;
 
 typedef struct {
 
-	/* The type of marker segment. */
+    /* The type of marker segment. */
-	uint_fast16_t id;
+    uint_fast16_t id;
 
-	/* The length of the marker segment. */
+    /* The length of the marker segment. */
-	uint_fast16_t len;
+    uint_fast16_t len;
 
-	/* The starting offset within the stream. */
+    /* The starting offset within the stream. */
-	uint_fast32_t off;
+    uint_fast32_t off;
 
-	/* The parameters of the marker segment. */
+    /* The parameters of the marker segment. */
-	jpc_msparms_t parms;
+    jpc_msparms_t parms;
 
-	/* The marker segment operations. */
+    /* The marker segment operations. */
-	struct jpc_msops_s *ops;
+    struct jpc_msops_s *ops;
 
 } jpc_ms_t;
 
@@ -688,17 +688,17 @@ typedef struct {
 
 typedef struct jpc_msops_s {
 
-	/* Destroy the marker segment parameters. */
+    /* Destroy the marker segment parameters. */
-	void (*destroyparms)(jpc_ms_t *ms);
+    void (*destroyparms)(jpc_ms_t *ms);
 
-	/* Get the marker segment parameters from a stream. */
+    /* Get the marker segment parameters from a stream. */
-	int (*getparms)(jpc_ms_t *ms, jpc_cstate_t *cstate, jas_stream_t *in);
+    int (*getparms)(jpc_ms_t *ms, jpc_cstate_t *cstate, jas_stream_t *in);
 
-	/* Put the marker segment parameters to a stream. */
+    /* Put the marker segment parameters to a stream. */
-	int (*putparms)(jpc_ms_t *ms, jpc_cstate_t *cstate, jas_stream_t *out);
+    int (*putparms)(jpc_ms_t *ms, jpc_cstate_t *cstate, jas_stream_t *out);
 
-	/* Dump the marker segment parameters (for debugging). */
+    /* Dump the marker segment parameters (for debugging). */
-	int (*dumpparms)(jpc_ms_t *ms, FILE *out);
+    int (*dumpparms)(jpc_ms_t *ms, FILE *out);
 
 } jpc_msops_t;
 
@@ -720,12 +720,12 @@ void jpc_ms_destroy(jpc_ms_t *ms);
 
 /* Does a marker segment have parameters? */
 #define	JPC_MS_HASPARMS(x) \
-	(!((x) == JPC_MS_SOC || (x) == JPC_MS_SOD || (x) == JPC_MS_EOC || \
+    (!((x) == JPC_MS_SOC || (x) == JPC_MS_SOD || (x) == JPC_MS_EOC || \
-	  (x) == JPC_MS_EPH || ((x) >= 0xff30 && (x) <= 0xff3f)))
+      (x) == JPC_MS_EPH || ((x) >= 0xff30 && (x) <= 0xff3f)))
 
 /* Get the marker segment type. */
 #define	jpc_ms_gettype(ms) \
-	((ms)->id)
+    ((ms)->id)
 
 /* Read a marker segment from a stream. */
 jpc_ms_t *jpc_getms(jas_stream_t *in, jpc_cstate_t *cstate);

3rdparty/libjasper/jpc_dec.h

@@ -6,15 +6,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,
@@ -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__
  */
 
@@ -92,14 +92,14 @@
 
 typedef struct {
 
-	/* The index for this entry. */
+    /* The index for this entry. */
-	uint_fast16_t ind;
+    uint_fast16_t ind;
 
-	/* The data length. */
+    /* The data length. */
-	uint_fast32_t len;
+    uint_fast32_t len;
 
-	/* The data. */
+    /* The data. */
-	uchar *data;
+    uchar *data;
 
 } jpc_ppxstabent_t;
 
@@ -107,15 +107,15 @@ typedef struct {
 
 typedef struct {
 
-	/* The number of entries. */
+    /* The number of entries. */
-	int numents;
+    int numents;
 
-	/* The maximum number of entries (i.e., the allocated size of the array
+    /* The maximum number of entries (i.e., the allocated size of the array
-	  below). */
+      below). */
-	int maxents;
+    int maxents;
 
-	/* The table entries. */
+    /* The table entries. */
-	jpc_ppxstabent_t **ents;
+    jpc_ppxstabent_t **ents;
 
 } jpc_ppxstab_t;
 
@@ -123,15 +123,15 @@ typedef struct {
 
 typedef struct {
 
-	/* The number of streams in this list. */
+    /* The number of streams in this list. */
-	int numstreams;
+    int numstreams;
 
-	/* The maximum number of streams that can be accomodated without
+    /* The maximum number of streams that can be accomodated without
-	  growing the streams array. */
+      growing the streams array. */
-	int maxstreams;
+    int maxstreams;
 
-	/* The streams. */
+    /* The streams. */
-	jas_stream_t **streams;
+    jas_stream_t **streams;
 
 } jpc_streamlist_t;
 
@@ -143,47 +143,47 @@ typedef struct {
 
 typedef struct {
 
-	/* How were various coding parameters set? */
+    /* How were various coding parameters set? */
-	int flags;
+    int flags;
 
-	/* Per-component coding style parameters (e.g., explicit precinct sizes) */
+    /* Per-component coding style parameters (e.g., explicit precinct sizes) */
-	uint_fast8_t csty;
+    uint_fast8_t csty;
 
-	/* The number of resolution levels. */
+    /* The number of resolution levels. */
-	uint_fast8_t numrlvls;
+    uint_fast8_t numrlvls;
 
-	/* The code block width exponent. */
+    /* The code block width exponent. */
-	uint_fast8_t cblkwidthexpn;
+    uint_fast8_t cblkwidthexpn;
 
-	/* The code block height exponent. */
+    /* The code block height exponent. */
-	uint_fast8_t cblkheightexpn;
+    uint_fast8_t cblkheightexpn;
 
-	/* The QMFB ID. */
+    /* The QMFB ID. */
-	uint_fast8_t qmfbid;
+    uint_fast8_t qmfbid;
 
-	/* The quantization style. */
+    /* The quantization style. */
-	uint_fast8_t qsty;
+    uint_fast8_t qsty;
 
-	/* The number of quantizer step sizes. */
+    /* The number of quantizer step sizes. */
-	uint_fast16_t numstepsizes;
+    uint_fast16_t numstepsizes;
 
-	/* The step sizes. */
+    /* The step sizes. */
-	uint_fast16_t stepsizes[3 * JPC_MAXRLVLS + 1];
+    uint_fast16_t stepsizes[3 * JPC_MAXRLVLS + 1];
 
-	/* The number of guard bits. */
+    /* The number of guard bits. */
-	uint_fast8_t numguardbits;
+    uint_fast8_t numguardbits;
 
-	/* The ROI shift value. */
+    /* The ROI shift value. */
-	uint_fast8_t roishift;
+    uint_fast8_t roishift;
 
-	/* The code block parameters. */
+    /* The code block parameters. */
-	uint_fast8_t cblkctx;
+    uint_fast8_t cblkctx;
 
-	/* The precinct width exponents. */
+    /* The precinct width exponents. */
-	uint_fast8_t prcwidthexpns[JPC_MAXRLVLS];
+    uint_fast8_t prcwidthexpns[JPC_MAXRLVLS];
 
-	/* The precinct height exponents. */
+    /* The precinct height exponents. */
-	uint_fast8_t prcheightexpns[JPC_MAXRLVLS];
+    uint_fast8_t prcheightexpns[JPC_MAXRLVLS];
 
 } jpc_dec_ccp_t;
 
@@ -191,29 +191,29 @@ typedef struct {
 
 typedef struct {
 
-	/* How were these coding parameters set? */
+    /* How were these coding parameters set? */
-	int flags;
+    int flags;
 
-	/* Progression change list. */
+    /* Progression change list. */
-	jpc_pchglist_t *pchglist;
+    jpc_pchglist_t *pchglist;
 
-	/* Progression order. */
+    /* Progression order. */
-	uint_fast8_t prgord;
+    uint_fast8_t prgord;
 
-	/* The number of layers. */
+    /* The number of layers. */
-	uint_fast16_t numlyrs;
+    uint_fast16_t numlyrs;
 
-	/* The MCT ID. */
+    /* The MCT ID. */
-	uint_fast8_t mctid;
+    uint_fast8_t mctid;
 
-	/* The coding style parameters (e.g., SOP, EPH). */
+    /* The coding style parameters (e.g., SOP, EPH). */
-	uint_fast8_t csty;
+    uint_fast8_t csty;
 
-	/* The number of components. */
+    /* The number of components. */
-	int numcomps;
+    int numcomps;
 
-	/* The per-component coding parameters. */
+    /* The per-component coding parameters. */
-	jpc_dec_ccp_t *ccps;
+    jpc_dec_ccp_t *ccps;
 
 } jpc_dec_cp_t;
 
@@ -225,38 +225,38 @@ typedef struct {
 
 typedef struct jpc_dec_seg_s {
 
-	/* The next segment in the list. */
+    /* The next segment in the list. */
-	struct jpc_dec_seg_s *next;
+    struct jpc_dec_seg_s *next;
 
-	/* The previous segment in the list. */
+    /* The previous segment in the list. */
-	struct jpc_dec_seg_s *prev;
+    struct jpc_dec_seg_s *prev;
 
-	/* The starting pass number for this segment. */
+    /* The starting pass number for this segment. */
-	int passno;
+    int passno;
 
-	/* The number of passes in this segment. */
+    /* The number of passes in this segment. */
-	int numpasses;
+    int numpasses;
 
-	/* The maximum number of passes in this segment. */
+    /* The maximum number of passes in this segment. */
-	int maxpasses;
+    int maxpasses;
 
-	/* The type of data in this segment (i.e., MQ or raw). */
+    /* The type of data in this segment (i.e., MQ or raw). */
-	int type;
+    int type;
 
-	/* A stream containing the data for this segment. */
+    /* A stream containing the data for this segment. */
-	jas_stream_t *stream;
+    jas_stream_t *stream;
 
-	/* The number of bytes destined for this segment from the packet
+    /* The number of bytes destined for this segment from the packet
-	  currently being decoded. */
+      currently being decoded. */
-	int cnt;
+    int cnt;
 
-	/* A flag indicating if this segment has been terminated. */
+    /* A flag indicating if this segment has been terminated. */
-	int complete;
+    int complete;
 
-	/* The layer number to which this segment belongs. */
+    /* The layer number to which this segment belongs. */
-	/* If the segment spans multiple layers, then the largest layer number
+    /* If the segment spans multiple layers, then the largest layer number
-	  spanned by the segment is used. */
+      spanned by the segment is used. */
-	int lyrno;
+    int lyrno;
 
 } jpc_dec_seg_t;
 
@@ -264,11 +264,11 @@ typedef struct jpc_dec_seg_s {
 
 typedef struct {
 
-	/* The first entry in the list. */
+    /* The first entry in the list. */
-	jpc_dec_seg_t *head;
+    jpc_dec_seg_t *head;
 
-	/* The last entry in the list. */
+    /* The last entry in the list. */
-	jpc_dec_seg_t *tail;
+    jpc_dec_seg_t *tail;
 
 } jpc_dec_seglist_t;
 
@@ -276,35 +276,35 @@ typedef struct {
 
 typedef struct {
 
-	/* The number of passes. */
+    /* The number of passes. */
-	int numpasses;
+    int numpasses;
 
-	/* A list of segments that still need to be decoded. */
+    /* A list of segments that still need to be decoded. */
-	jpc_dec_seglist_t segs;
+    jpc_dec_seglist_t segs;
 
-	/* The first incomplete/partial segment. */
+    /* The first incomplete/partial segment. */
-	jpc_dec_seg_t *curseg;
+    jpc_dec_seg_t *curseg;
 
-	/* The number of leading insignificant bit planes for this code block. */
+    /* The number of leading insignificant bit planes for this code block. */
-	int numimsbs;
+    int numimsbs;
 
-	/* The number of bits used to encode pass data lengths. */
+    /* The number of bits used to encode pass data lengths. */
-	int numlenbits;
+    int numlenbits;
 
-	/* The first pass number containing data for this code block. */
+    /* The first pass number containing data for this code block. */
-	int firstpassno;
+    int firstpassno;
 
-	/* The MQ decoder. */
+    /* The MQ decoder. */
-	jpc_mqdec_t *mqdec;
+    jpc_mqdec_t *mqdec;
 
-	/* The raw bit stream decoder. */
+    /* The raw bit stream decoder. */
-	jpc_bitstream_t *nulldec;
+    jpc_bitstream_t *nulldec;
 
-	/* The per-sample state information for this code block. */
+    /* The per-sample state information for this code block. */
-	jas_matrix_t *flags;
+    jas_matrix_t *flags;
 
-	/* The sample data associated with this code block. */
+    /* The sample data associated with this code block. */
-	jas_matrix_t *data;
+    jas_matrix_t *data;
 
 } jpc_dec_cblk_t;
 
@@ -312,39 +312,39 @@ typedef struct {
 
 typedef struct {
 
-	/* The x-coordinate of the top-left corner of the precinct. */
+    /* The x-coordinate of the top-left corner of the precinct. */
-	uint_fast32_t xstart;
+    uint_fast32_t xstart;
 
-	/* The y-coordinate of the top-left corner of the precinct. */
+    /* The y-coordinate of the top-left corner of the precinct. */
-	uint_fast32_t ystart;
+    uint_fast32_t ystart;
 
-	/* The x-coordinate of the bottom-right corner of the precinct
+    /* The x-coordinate of the bottom-right corner of the precinct
-	  (plus one). */
+      (plus one). */
-	uint_fast32_t xend;
+    uint_fast32_t xend;
 
-	/* The y-coordinate of the bottom-right corner of the precinct
+    /* The y-coordinate of the bottom-right corner of the precinct
-	  (plus one). */
+      (plus one). */
-	uint_fast32_t yend;
+    uint_fast32_t yend;
 
-	/* The number of code blocks spanning this precinct in the horizontal
+    /* The number of code blocks spanning this precinct in the horizontal
-	  direction. */
+      direction. */
-	int numhcblks;
+    int numhcblks;
 
-	/* The number of code blocks spanning this precinct in the vertical
+    /* The number of code blocks spanning this precinct in the vertical
-	  direction. */
+      direction. */
-	int numvcblks;
+    int numvcblks;
 
-	/* The total number of code blocks in this precinct. */
+    /* The total number of code blocks in this precinct. */
-	int numcblks;
+    int numcblks;
 
-	/* The per code block information. */
+    /* The per code block information. */
-	jpc_dec_cblk_t *cblks;
+    jpc_dec_cblk_t *cblks;
 
-	/* The inclusion tag tree. */
+    /* The inclusion tag tree. */
-	jpc_tagtree_t *incltagtree;
+    jpc_tagtree_t *incltagtree;
 
-	/* The insignificant MSBs tag tree. */
+    /* The insignificant MSBs tag tree. */
-	jpc_tagtree_t *numimsbstagtree;
+    jpc_tagtree_t *numimsbstagtree;
 
 } jpc_dec_prc_t;
 
@@ -352,29 +352,29 @@ typedef struct {
 
 typedef struct {
 
-	/* The per-code-block-group state information. */
+    /* The per-code-block-group state information. */
-	jpc_dec_prc_t *prcs;
+    jpc_dec_prc_t *prcs;
 
-	/* The sample data associated with this band. */
+    /* The sample data associated with this band. */
-	jas_matrix_t *data;
+    jas_matrix_t *data;
 
-	/* The orientation of this band (i.e., LL, LH, HL, or HH). */
+    /* The orientation of this band (i.e., LL, LH, HL, or HH). */
-	int orient;
+    int orient;
 
-	/* The encoded quantizer step size. */
+    /* The encoded quantizer step size. */
-	int stepsize;
+    int stepsize;
 
-	/* The absolute quantizer step size. */
+    /* The absolute quantizer step size. */
-	jpc_fix_t absstepsize;
+    jpc_fix_t absstepsize;
 
-	/* The number of bit planes for this band. */
+    /* The number of bit planes for this band. */
-	int numbps;
+    int numbps;
 
-	/* The analysis gain associated with this band. */
+    /* The analysis gain associated with this band. */
-	int analgain;
+    int analgain;
 
-	/* The ROI shift value for this band. */
+    /* The ROI shift value for this band. */
-	int roishift;
+    int roishift;
 
 } jpc_dec_band_t;
 
@@ -382,60 +382,60 @@ typedef struct {
 
 typedef struct {
 
-	/* The number of bands associated with this resolution level. */
+    /* The number of bands associated with this resolution level. */
-	int numbands;
+    int numbands;
 
-	/* The per-band information. */
+    /* The per-band information. */
-	jpc_dec_band_t *bands;
+    jpc_dec_band_t *bands;
 
-	/* The x-coordinate of the top-left corner of the tile-component
+    /* The x-coordinate of the top-left corner of the tile-component
-	  at this resolution. */
+      at this resolution. */
-	uint_fast32_t xstart;
+    uint_fast32_t xstart;
 
-	/* The y-coordinate of the top-left corner of the tile-component
+    /* The y-coordinate of the top-left corner of the tile-component
-	  at this resolution. */
+      at this resolution. */
-	uint_fast32_t ystart;
+    uint_fast32_t ystart;
 
-	/* The x-coordinate of the bottom-right corner of the tile-component
+    /* The x-coordinate of the bottom-right corner of the tile-component
-	  at this resolution (plus one). */
+      at this resolution (plus one). */
-	uint_fast32_t xend;
+    uint_fast32_t xend;
 
-	/* The y-coordinate of the bottom-right corner of the tile-component
+    /* The y-coordinate of the bottom-right corner of the tile-component
-	  at this resolution (plus one). */
+      at this resolution (plus one). */
-	uint_fast32_t yend;
+    uint_fast32_t yend;
 
-	/* The exponent value for the nominal precinct width measured
+    /* The exponent value for the nominal precinct width measured
-	  relative to the associated LL band. */
+      relative to the associated LL band. */
-	int prcwidthexpn;
+    int prcwidthexpn;
 
-	/* The exponent value for the nominal precinct height measured
+    /* The exponent value for the nominal precinct height measured
-	  relative to the associated LL band. */
+      relative to the associated LL band. */
-	int prcheightexpn;
+    int prcheightexpn;
 
-	/* The number of precincts in the horizontal direction. */
+    /* The number of precincts in the horizontal direction. */
-	int numhprcs;
+    int numhprcs;
 
-	/* The number of precincts in the vertical direction. */
+    /* The number of precincts in the vertical direction. */
-	int numvprcs;
+    int numvprcs;
 
-	/* The total number of precincts. */
+    /* The total number of precincts. */
-	int numprcs;
+    int numprcs;
 
-	/* The exponent value for the nominal code block group width.
+    /* The exponent value for the nominal code block group width.
-	  This quantity is associated with the next lower resolution level
+      This quantity is associated with the next lower resolution level
-	  (assuming that there is one). */
+      (assuming that there is one). */
-	int cbgwidthexpn;
+    int cbgwidthexpn;
 
-	/* The exponent value for the nominal code block group height
+    /* The exponent value for the nominal code block group height
-	  This quantity is associated with the next lower resolution level
+      This quantity is associated with the next lower resolution level
-	  (assuming that there is one). */
+      (assuming that there is one). */
-	int cbgheightexpn;
+    int cbgheightexpn;
 
-	/* The exponent value for the code block width. */
+    /* The exponent value for the code block width. */
-	uint_fast16_t cblkwidthexpn;
+    uint_fast16_t cblkwidthexpn;
 
-	/* The exponent value for the code block height. */
+    /* The exponent value for the code block height. */
-	uint_fast16_t cblkheightexpn;
+    uint_fast16_t cblkheightexpn;
 
 } jpc_dec_rlvl_t;
 
@@ -443,33 +443,33 @@ typedef struct {
 
 typedef struct {
 
-	/* The x-coordinate of the top-left corner of the tile-component
+    /* The x-coordinate of the top-left corner of the tile-component
-	  in the coordinate system of the tile-component. */
+      in the coordinate system of the tile-component. */
-	uint_fast32_t xstart;
+    uint_fast32_t xstart;
 
-	/* The y-coordinate of the top-left corner of the tile-component
+    /* The y-coordinate of the top-left corner of the tile-component
-	  in the coordinate system of the tile-component. */
+      in the coordinate system of the tile-component. */
-	uint_fast32_t ystart;
+    uint_fast32_t ystart;
 
-	/* The x-coordinate of the bottom-right corner of the tile-component
+    /* The x-coordinate of the bottom-right corner of the tile-component
-	  in the coordinate system of the tile-component (plus one). */
+      in the coordinate system of the tile-component (plus one). */
-	uint_fast32_t xend;
+    uint_fast32_t xend;
 
-	/* The y-coordinate of the bottom-right corner of the tile-component
+    /* The y-coordinate of the bottom-right corner of the tile-component
-	  in the coordinate system of the tile-component (plus one). */
+      in the coordinate system of the tile-component (plus one). */
-	uint_fast32_t yend;
+    uint_fast32_t yend;
 
-	/* The component data for the current tile. */
+    /* The component data for the current tile. */
-	jas_matrix_t *data;
+    jas_matrix_t *data;
 
-	/* The number of resolution levels. */
+    /* The number of resolution levels. */
-	int numrlvls;
+    int numrlvls;
 
-	/* The per resolution level information. */
+    /* The per resolution level information. */
-	jpc_dec_rlvl_t *rlvls;
+    jpc_dec_rlvl_t *rlvls;
 
-	/* The TSFB. */
+    /* The TSFB. */
-	jpc_tsfb_t *tsfb;
+    jpc_tsfb_t *tsfb;
 
 } jpc_dec_tcomp_t;
 
@@ -486,51 +486,51 @@ typedef struct {
 
 typedef struct {
 
-	/* The processing state for this tile. */
+    /* The processing state for this tile. */
-	int state;
+    int state;
 
-	/* The x-coordinate of the top-left corner of the tile on the reference
+    /* The x-coordinate of the top-left corner of the tile on the reference
-	  grid. */
+      grid. */
-	uint_fast32_t xstart;
+    uint_fast32_t xstart;
 
-	/* The y-coordinate of the top-left corner of the tile on the reference
+    /* The y-coordinate of the top-left corner of the tile on the reference
-	  grid. */
+      grid. */
-	uint_fast32_t ystart;
+    uint_fast32_t ystart;
 
-	/* The x-coordinate of the bottom-right corner of the tile on the
+    /* The x-coordinate of the bottom-right corner of the tile on the
-	  reference grid (plus one). */
+      reference grid (plus one). */
-	uint_fast32_t xend;
+    uint_fast32_t xend;
 
-	/* The y-coordinate of the bottom-right corner of the tile on the
+    /* The y-coordinate of the bottom-right corner of the tile on the
-	  reference grid (plus one). */
+      reference grid (plus one). */
-	uint_fast32_t yend;
+    uint_fast32_t yend;
 
-	/* The packed packet header data for this tile. */
+    /* The packed packet header data for this tile. */
-	jpc_ppxstab_t *pptstab;
+    jpc_ppxstab_t *pptstab;
 
-	/* A stream containing the packed packet header data for this tile. */
+    /* A stream containing the packed packet header data for this tile. */
-	jas_stream_t *pkthdrstream;
+    jas_stream_t *pkthdrstream;
 
-	/* The current position within the packed packet header stream. */
+    /* The current position within the packed packet header stream. */
-	long pkthdrstreampos;
+    long pkthdrstreampos;
 
-	/* The coding parameters for this tile. */
+    /* The coding parameters for this tile. */
-	jpc_dec_cp_t *cp;
+    jpc_dec_cp_t *cp;
 
-	/* The per tile-component information. */
+    /* The per tile-component information. */
-	jpc_dec_tcomp_t *tcomps;
+    jpc_dec_tcomp_t *tcomps;
 
-	/* The next expected tile-part number. */
+    /* The next expected tile-part number. */
-	int partno;
+    int partno;
 
-	/* The number of tile-parts. */
+    /* The number of tile-parts. */
-	int numparts;
+    int numparts;
 
-	/* The coding mode. */
+    /* The coding mode. */
-	int realmode;
+    int realmode;
 
-	/* The packet iterator for this tile. */
+    /* The packet iterator for this tile. */
-	jpc_pi_t *pi;
+    jpc_pi_t *pi;
 
 } jpc_dec_tile_t;
 
@@ -538,29 +538,29 @@ typedef struct {
 
 typedef struct {
 
-	/* The horizontal sampling period. */
+    /* The horizontal sampling period. */
-	uint_fast32_t hstep;
+    uint_fast32_t hstep;
 
-	/* The vertical sampling period. */
+    /* The vertical sampling period. */
-	uint_fast32_t vstep;
+    uint_fast32_t vstep;
 
-	/* The number of samples in the horizontal direction. */
+    /* The number of samples in the horizontal direction. */
-	uint_fast32_t width;
+    uint_fast32_t width;
 
-	/* The number of samples in the vertical direction. */
+    /* The number of samples in the vertical direction. */
-	uint_fast32_t height;
+    uint_fast32_t height;
 
-	/* The precision of the sample data. */
+    /* The precision of the sample data. */
-	uint_fast16_t prec;
+    uint_fast16_t prec;
 
-	/* The signedness of the sample data. */
+    /* The signedness of the sample data. */
-	bool sgnd;
+    bool sgnd;
 
-	/* The sample alignment horizontal offset. */
+    /* The sample alignment horizontal offset. */
-	uint_fast32_t hsubstep;
+    uint_fast32_t hsubstep;
-	
+
-	/* The sample alignment vertical offset. */
+    /* The sample alignment vertical offset. */
-	uint_fast32_t vsubstep;
+    uint_fast32_t vsubstep;
 
 } jpc_dec_cmpt_t;
 
@@ -568,96 +568,96 @@ typedef struct {
 
 typedef struct {
 
-	/* The decoded image. */
+    /* The decoded image. */
-	jas_image_t *image;
+    jas_image_t *image;
 
-	/* The x-coordinate of the top-left corner of the image area on
+    /* The x-coordinate of the top-left corner of the image area on
-	  the reference grid. */
+      the reference grid. */
-	uint_fast32_t xstart;
+    uint_fast32_t xstart;
 
-	/* The y-coordinate of the top-left corner of the image area on
+    /* The y-coordinate of the top-left corner of the image area on
-	  the reference grid. */
+      the reference grid. */
-	uint_fast32_t ystart;
+    uint_fast32_t ystart;
 
-	/* The x-coordinate of the bottom-right corner of the image area on
+    /* The x-coordinate of the bottom-right corner of the image area on
-	  the reference grid (plus one). */
+      the reference grid (plus one). */
-	uint_fast32_t xend;
+    uint_fast32_t xend;
 
-	/* The y-coordinate of the bottom-right corner of the image area on
+    /* The y-coordinate of the bottom-right corner of the image area on
-	  the reference grid (plus one). */
+      the reference grid (plus one). */
-	uint_fast32_t yend;
+    uint_fast32_t yend;
 
-	/* The nominal tile width in units of the image reference grid. */
+    /* The nominal tile width in units of the image reference grid. */
-	uint_fast32_t tilewidth;
+    uint_fast32_t tilewidth;
 
-	/* The nominal tile height in units of the image reference grid. */
+    /* The nominal tile height in units of the image reference grid. */
-	uint_fast32_t tileheight;
+    uint_fast32_t tileheight;
 
-	/* The horizontal offset from the origin of the reference grid to the
+    /* The horizontal offset from the origin of the reference grid to the
-	  left side of the first tile. */
+      left side of the first tile. */
-	uint_fast32_t tilexoff;
+    uint_fast32_t tilexoff;
 
-	/* The vertical offset from the origin of the reference grid to the
+    /* The vertical offset from the origin of the reference grid to the
-	  top side of the first tile. */
+      top side of the first tile. */
-	uint_fast32_t tileyoff;
+    uint_fast32_t tileyoff;
 
-	/* The number of tiles spanning the image area in the vertical
+    /* The number of tiles spanning the image area in the vertical
-	  direction. */
+      direction. */
-	int numhtiles;
+    int numhtiles;
 
-	/* The number of tiles spanning the image area in the horizontal
+    /* The number of tiles spanning the image area in the horizontal
-	  direction. */
+      direction. */
-	int numvtiles;
+    int numvtiles;
 
-	/* The total number of tiles. */
+    /* The total number of tiles. */
-	int numtiles;
+    int numtiles;
 
-	/* The per-tile information. */
+    /* The per-tile information. */
-	jpc_dec_tile_t *tiles;
+    jpc_dec_tile_t *tiles;
 
-	/* The tile currently being processed. */
+    /* The tile currently being processed. */
-	jpc_dec_tile_t *curtile;
+    jpc_dec_tile_t *curtile;
 
-	/* The number of components. */
+    /* The number of components. */
-	int numcomps;
+    int numcomps;
 
-	/* The stream containing the input JPEG-2000 code stream data. */
+    /* The stream containing the input JPEG-2000 code stream data. */
-	jas_stream_t *in;
+    jas_stream_t *in;
 
-	/* The default coding parameters for all tiles. */
+    /* The default coding parameters for all tiles. */
-	jpc_dec_cp_t *cp;
+    jpc_dec_cp_t *cp;
 
-	/* The maximum number of layers that may be decoded. */
+    /* The maximum number of layers that may be decoded. */
-	int maxlyrs;
+    int maxlyrs;
 
-	/* The maximum number of packets that may be decoded. */
+    /* The maximum number of packets that may be decoded. */
-	int maxpkts;
+    int maxpkts;
 
-	/* The number of packets decoded so far in the processing of the entire
+    /* The number of packets decoded so far in the processing of the entire
-	  code stream. */
+      code stream. */
-	int numpkts;
+    int numpkts;
 
-	/* The next expected PPM marker segment sequence number. */
+    /* The next expected PPM marker segment sequence number. */
-	int ppmseqno;
+    int ppmseqno;
 
-	/* The current state for code stream processing. */
+    /* The current state for code stream processing. */
-	int state;
+    int state;
 
-	/* The per-component information. */
+    /* The per-component information. */
-	jpc_dec_cmpt_t *cmpts;
+    jpc_dec_cmpt_t *cmpts;
 
-	/* The information from PPM marker segments. */
+    /* The information from PPM marker segments. */
-	jpc_ppxstab_t *ppmstab;
+    jpc_ppxstab_t *ppmstab;
 
-	/* A list of streams containing packet header data from PPM marker
+    /* A list of streams containing packet header data from PPM marker
-	  segments. */
+      segments. */
-	jpc_streamlist_t *pkthdrstreams;
+    jpc_streamlist_t *pkthdrstreams;
 
-	/* The expected ending offset for a tile-part. */
+    /* The expected ending offset for a tile-part. */
-	long curtileendoff;
+    long curtileendoff;
 
-	/* This is required by the tier-2 decoder. */
+    /* This is required by the tier-2 decoder. */
-	jpc_cstate_t *cstate;
+    jpc_cstate_t *cstate;
 
 } jpc_dec_t;
 
@@ -665,14 +665,14 @@ typedef struct {
 
 typedef struct {
 
-	/* The debug level for the decoder. */
+    /* The debug level for the decoder. */
-	int debug;
+    int debug;
 
-	/* The maximum number of layers to decode. */
+    /* The maximum number of layers to decode. */
-	int maxlyrs;
+    int maxlyrs;
 
-	/* The maximum number of packets to decode. */
+    /* The maximum number of packets to decode. */
-	int maxpkts;
+    int maxpkts;
 
 } jpc_dec_importopts_t;
 

3rdparty/libjasper/jpc_enc.h

@@ -6,15 +6,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,
@@ -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__
  */
 
@@ -100,29 +100,29 @@
 
 typedef struct {
 
-	/* The horizontal sampling period. */
+    /* The horizontal sampling period. */
-	uint_fast8_t sampgrdstepx;
+    uint_fast8_t sampgrdstepx;
 
-	/* The vertical sampling period. */
+    /* The vertical sampling period. */
-	uint_fast8_t sampgrdstepy;
+    uint_fast8_t sampgrdstepy;
 
-	/* The sample alignment horizontal offset. */
+    /* The sample alignment horizontal offset. */
-	uint_fast8_t sampgrdsubstepx;
+    uint_fast8_t sampgrdsubstepx;
 
-	/* The sample alignment vertical offset. */
+    /* The sample alignment vertical offset. */
-	uint_fast8_t sampgrdsubstepy;
+    uint_fast8_t sampgrdsubstepy;
 
-	/* The precision of the samples. */
+    /* The precision of the samples. */
-	uint_fast8_t prec;
+    uint_fast8_t prec;
 
-	/* The signedness of the samples. */
+    /* The signedness of the samples. */
-	bool sgnd;
+    bool sgnd;
 
-	/* The number of step sizes. */
+    /* The number of step sizes. */
-	uint_fast16_t numstepsizes;
+    uint_fast16_t numstepsizes;
 
-	/* The quantizer step sizes. */
+    /* The quantizer step sizes. */
-	uint_fast16_t stepsizes[JPC_MAXBANDS];
+    uint_fast16_t stepsizes[JPC_MAXBANDS];
 
 } jpc_enc_ccp_t;
 
@@ -130,24 +130,24 @@ typedef struct {
 
 typedef struct {
 
-	/* The coding mode. */
+    /* The coding mode. */
-	bool intmode;
+    bool intmode;
 
-	/* The coding style (i.e., SOP, EPH). */
+    /* The coding style (i.e., SOP, EPH). */
-	uint_fast8_t csty;
+    uint_fast8_t csty;
 
-	/* The progression order. */
+    /* The progression order. */
-	uint_fast8_t prg;
+    uint_fast8_t prg;
 
-	/* The multicomponent transform. */
+    /* The multicomponent transform. */
-	uint_fast8_t mctid;
+    uint_fast8_t mctid;
 
-	/* The number of layers. */
+    /* The number of layers. */
-	uint_fast16_t numlyrs;
+    uint_fast16_t numlyrs;
 
-	/* The normalized bit rates associated with the various
+    /* The normalized bit rates associated with the various
-	  intermediate layers. */
+      intermediate layers. */
-	jpc_fix_t *ilyrrates;
+    jpc_fix_t *ilyrrates;
 
 } jpc_enc_tcp_t;
 
@@ -155,33 +155,33 @@ typedef struct {
 
 typedef struct {
 
-	/* The coding style (i.e., explicit precinct sizes). */
+    /* The coding style (i.e., explicit precinct sizes). */
-	uint_fast8_t csty;
+    uint_fast8_t csty;
 
-	/* The maximum number of resolution levels allowed. */
+    /* The maximum number of resolution levels allowed. */
-	uint_fast8_t maxrlvls;
+    uint_fast8_t maxrlvls;
 
-	/* The exponent for the nominal code block width. */
+    /* The exponent for the nominal code block width. */
-	uint_fast16_t cblkwidthexpn;
+    uint_fast16_t cblkwidthexpn;
 
-	/* The exponent for the nominal code block height. */
+    /* The exponent for the nominal code block height. */
-	uint_fast16_t cblkheightexpn;
+    uint_fast16_t cblkheightexpn;
 
-	/* The code block style parameters (e.g., lazy, terminate all,
+    /* The code block style parameters (e.g., lazy, terminate all,
-	  segmentation symbols, causal, reset probability models). */
+      segmentation symbols, causal, reset probability models). */
-	uint_fast8_t cblksty;
+    uint_fast8_t cblksty;
 
-	/* The QMFB. */
+    /* The QMFB. */
-	uint_fast8_t qmfbid;
+    uint_fast8_t qmfbid;
 
-	/* The precinct width values. */
+    /* The precinct width values. */
-	uint_fast16_t prcwidthexpns[JPC_MAXRLVLS];
+    uint_fast16_t prcwidthexpns[JPC_MAXRLVLS];
 
-	/* The precinct height values. */
+    /* The precinct height values. */
-	uint_fast16_t prcheightexpns[JPC_MAXRLVLS];
+    uint_fast16_t prcheightexpns[JPC_MAXRLVLS];
 
-	/* The number of guard bits. */
+    /* The number of guard bits. */
-	uint_fast8_t numgbits;
+    uint_fast8_t numgbits;
 
 } jpc_enc_tccp_t;
 
@@ -189,67 +189,67 @@ typedef struct {
 
 typedef struct {
 
-	/* The debug level. */
+    /* The debug level. */
-	int debug;
+    int debug;
 
-	/* The horizontal offset from the origin of the reference grid to the
+    /* The horizontal offset from the origin of the reference grid to the
-	  left edge of the image area. */
+      left edge of the image area. */
-	uint_fast32_t imgareatlx;
+    uint_fast32_t imgareatlx;
 
-	/* The vertical offset from the origin of the reference grid to the
+    /* The vertical offset from the origin of the reference grid to the
-	  top edge of the image area. */
+      top edge of the image area. */
-	uint_fast32_t imgareatly;
+    uint_fast32_t imgareatly;
 
-	/* The horizontal offset from the origin of the reference grid to the
+    /* The horizontal offset from the origin of the reference grid to the
-	  right edge of the image area (plus one). */
+      right edge of the image area (plus one). */
-	uint_fast32_t refgrdwidth;
+    uint_fast32_t refgrdwidth;
 
-	/* The vertical offset from the origin of the reference grid to the
+    /* The vertical offset from the origin of the reference grid to the
-	  bottom edge of the image area (plus one). */
+      bottom edge of the image area (plus one). */
-	uint_fast32_t refgrdheight;
+    uint_fast32_t refgrdheight;
 
-	/* The horizontal offset from the origin of the tile grid to the
+    /* The horizontal offset from the origin of the tile grid to the
-	  origin of the reference grid. */
+      origin of the reference grid. */
-	uint_fast32_t tilegrdoffx;
+    uint_fast32_t tilegrdoffx;
 
-	/* The vertical offset from the origin of the tile grid to the
+    /* The vertical offset from the origin of the tile grid to the
-	  origin of the reference grid. */
+      origin of the reference grid. */
-	uint_fast32_t tilegrdoffy;
+    uint_fast32_t tilegrdoffy;
 
-	/* The nominal tile width in units of the image reference grid. */
+    /* The nominal tile width in units of the image reference grid. */
-	uint_fast32_t tilewidth;
+    uint_fast32_t tilewidth;
 
-	/* The nominal tile height in units of the image reference grid. */
+    /* The nominal tile height in units of the image reference grid. */
-	uint_fast32_t tileheight;
+    uint_fast32_t tileheight;
 
-	/* The number of tiles spanning the image area in the horizontal
+    /* The number of tiles spanning the image area in the horizontal
-	  direction. */
+      direction. */
-	uint_fast32_t numhtiles;
+    uint_fast32_t numhtiles;
 
-	/* The number of tiles spanning the image area in the vertical
+    /* The number of tiles spanning the image area in the vertical
-	  direction. */
+      direction. */
-	uint_fast32_t numvtiles;
+    uint_fast32_t numvtiles;
 
-	/* The number of tiles. */
+    /* The number of tiles. */
-	uint_fast32_t numtiles;
+    uint_fast32_t numtiles;
 
-	/* The number of components. */
+    /* The number of components. */
-	uint_fast16_t numcmpts;
+    uint_fast16_t numcmpts;
 
-	/* The per-component coding parameters. */
+    /* The per-component coding parameters. */
-	jpc_enc_ccp_t *ccps;
+    jpc_enc_ccp_t *ccps;
 
-	/* The per-tile coding parameters. */
+    /* The per-tile coding parameters. */
-	jpc_enc_tcp_t tcp;
+    jpc_enc_tcp_t tcp;
 
-	/* The per-tile-component coding parameters. */
+    /* The per-tile-component coding parameters. */
-	jpc_enc_tccp_t tccp;
+    jpc_enc_tccp_t tccp;
 
-	/* The target code stream length in bytes. */
+    /* The target code stream length in bytes. */
-	uint_fast32_t totalsize;
+    uint_fast32_t totalsize;
 
-	/* The raw (i.e., uncompressed) size of the image in bytes. */
+    /* The raw (i.e., uncompressed) size of the image in bytes. */
-	uint_fast32_t rawsize;
+    uint_fast32_t rawsize;
 
 } jpc_enc_cp_t;
 
@@ -261,35 +261,35 @@ typedef struct {
 
 typedef struct {
 
-	/* The starting offset for this pass. */
+    /* The starting offset for this pass. */
-	int start;
+    int start;
 
-	/* The ending offset for this pass. */
+    /* The ending offset for this pass. */
-	int end;
+    int end;
 
-	/* The type of data in this pass (i.e., MQ or raw). */
+    /* The type of data in this pass (i.e., MQ or raw). */
-	int type;
+    int type;
 
-	/* Flag indicating that this pass is terminated. */
+    /* Flag indicating that this pass is terminated. */
-	int term;
+    int term;
 
-	/* The entropy coder state after coding this pass. */
+    /* The entropy coder state after coding this pass. */
-	jpc_mqencstate_t mqencstate;
+    jpc_mqencstate_t mqencstate;
 
-	/* The layer to which this pass has been assigned. */
+    /* The layer to which this pass has been assigned. */
-	int lyrno;
+    int lyrno;
 
-	/* The R-D slope for this pass. */
+    /* The R-D slope for this pass. */
-	jpc_flt_t rdslope;
+    jpc_flt_t rdslope;
 
-	/* The weighted MSE reduction associated with this pass. */
+    /* The weighted MSE reduction associated with this pass. */
-	jpc_flt_t wmsedec;
+    jpc_flt_t wmsedec;
 
-	/* The cumulative weighted MSE reduction. */
+    /* The cumulative weighted MSE reduction. */
-	jpc_flt_t cumwmsedec;
+    jpc_flt_t cumwmsedec;
 
-	/* The normalized MSE reduction. */
+    /* The normalized MSE reduction. */
-	long nmsedec;
+    long nmsedec;
 
 } jpc_enc_pass_t;
 
@@ -297,53 +297,53 @@ typedef struct {
 
 typedef struct {
 
-	/* The number of passes. */
+    /* The number of passes. */
-	int numpasses;
+    int numpasses;
 
-	/* The per-pass information. */
+    /* The per-pass information. */
-	jpc_enc_pass_t *passes;
+    jpc_enc_pass_t *passes;
 
-	/* The number of passes encoded so far. */
+    /* The number of passes encoded so far. */
-	int numencpasses;
+    int numencpasses;
 
-	/* The number of insignificant MSBs. */
+    /* The number of insignificant MSBs. */
-	int numimsbs;
+    int numimsbs;
 
-	/* The number of bits used to encode pass data lengths. */
+    /* The number of bits used to encode pass data lengths. */
-	int numlenbits;
+    int numlenbits;
 
-	/* The byte stream for this code block. */
+    /* The byte stream for this code block. */
-	jas_stream_t *stream;
+    jas_stream_t *stream;
 
-	/* The entropy encoder. */
+    /* The entropy encoder. */
-	jpc_mqenc_t *mqenc;
+    jpc_mqenc_t *mqenc;
 
-	/* The data for this code block. */
+    /* The data for this code block. */
-	jas_matrix_t *data;
+    jas_matrix_t *data;
 
-	/* The state for this code block. */
+    /* The state for this code block. */
-	jas_matrix_t *flags;
+    jas_matrix_t *flags;
 
-	/* The number of bit planes required for this code block. */
+    /* The number of bit planes required for this code block. */
-	int numbps;
+    int numbps;
 
-	/* The next pass to be encoded. */
+    /* The next pass to be encoded. */
-	jpc_enc_pass_t *curpass;
+    jpc_enc_pass_t *curpass;
 
-	/* The per-code-block-group state information. */
+    /* The per-code-block-group state information. */
-	struct jpc_enc_prc_s *prc;
+    struct jpc_enc_prc_s *prc;
 
-	/* The saved current pass. */
+    /* The saved current pass. */
-	/* This is used by the rate control code. */
+    /* This is used by the rate control code. */
-	jpc_enc_pass_t *savedcurpass;
+    jpc_enc_pass_t *savedcurpass;
 
-	/* The saved length indicator size. */
+    /* The saved length indicator size. */
-	/* This is used by the rate control code. */
+    /* This is used by the rate control code. */
-	int savednumlenbits;
+    int savednumlenbits;
 
-	/* The saved number of encoded passes. */
+    /* The saved number of encoded passes. */
-	/* This is used by the rate control code. */
+    /* This is used by the rate control code. */
-	int savednumencpasses;
+    int savednumencpasses;
 
 } jpc_enc_cblk_t;
 
@@ -351,50 +351,50 @@ typedef struct {
 
 typedef struct jpc_enc_prc_s {
 
-	/* The x-coordinate of the top-left corner of the precinct. */
+    /* The x-coordinate of the top-left corner of the precinct. */
-	uint_fast32_t tlx;
+    uint_fast32_t tlx;
 
-	/* The y-coordinate of the top-left corner of the precinct. */
+    /* The y-coordinate of the top-left corner of the precinct. */
-	uint_fast32_t tly;
+    uint_fast32_t tly;
 
-	/* The x-coordinate of the bottom-right corner of the precinct
+    /* The x-coordinate of the bottom-right corner of the precinct
-	  (plus one). */
+      (plus one). */
-	uint_fast32_t brx;
+    uint_fast32_t brx;
 
-	/* The y-coordinate of the bottom-right corner of the precinct
+    /* The y-coordinate of the bottom-right corner of the precinct
-	  (plus one). */
+      (plus one). */
-	uint_fast32_t bry;
+    uint_fast32_t bry;
 
-	/* The number of code blocks spanning the precinct in the horizontal
+    /* The number of code blocks spanning the precinct in the horizontal
-	direction. */
+    direction. */
-	int numhcblks;
+    int numhcblks;
 
-	/* The number of code blocks spanning the precinct in the vertical
+    /* The number of code blocks spanning the precinct in the vertical
-	direction. */
+    direction. */
-	int numvcblks;
+    int numvcblks;
 
-	/* The total number of code blocks. */
+    /* The total number of code blocks. */
-	int numcblks;
+    int numcblks;
 
-	/* The per-code-block information. */
+    /* The per-code-block information. */
-	jpc_enc_cblk_t *cblks;
+    jpc_enc_cblk_t *cblks;
 
-	/* The inclusion tag tree. */
+    /* The inclusion tag tree. */
-	jpc_tagtree_t *incltree;
+    jpc_tagtree_t *incltree;
 
-	/* The insignifcant MSBs tag tree. */
+    /* The insignifcant MSBs tag tree. */
-	jpc_tagtree_t *nlibtree;
+    jpc_tagtree_t *nlibtree;
 
-	/* The per-band information. */
+    /* The per-band information. */
-	struct jpc_enc_band_s *band;
+    struct jpc_enc_band_s *band;
 
-	/* The saved inclusion tag tree. */
+    /* The saved inclusion tag tree. */
-	/* This is used by rate control. */
+    /* This is used by rate control. */
-	jpc_tagtree_t *savincltree;
+    jpc_tagtree_t *savincltree;
 
-	/* The saved leading-insignificant-bit-planes tag tree. */
+    /* The saved leading-insignificant-bit-planes tag tree. */
-	/* This is used by rate control. */
+    /* This is used by rate control. */
-	jpc_tagtree_t *savnlibtree;
+    jpc_tagtree_t *savnlibtree;
 
 } jpc_enc_prc_t;
 
@@ -402,33 +402,33 @@ typedef struct jpc_enc_prc_s {
 
 typedef struct jpc_enc_band_s {
 
-	/* The per precinct information. */
+    /* The per precinct information. */
-	jpc_enc_prc_t *prcs;
+    jpc_enc_prc_t *prcs;
 
-	/* The coefficient data for this band. */
+    /* The coefficient data for this band. */
-	jas_matrix_t *data;
+    jas_matrix_t *data;
 
-	/* The orientation of this band (i.e., LL, LH, HL, or HH). */
+    /* The orientation of this band (i.e., LL, LH, HL, or HH). */
-	int orient;
+    int orient;
 
-	/* The number of bit planes associated with this band. */
+    /* The number of bit planes associated with this band. */
-	int numbps;
+    int numbps;
 
-	/* The quantizer step size. */
+    /* The quantizer step size. */
-	jpc_fix_t absstepsize;
+    jpc_fix_t absstepsize;
 
-	/* The encoded quantizer step size. */
+    /* The encoded quantizer step size. */
-	int stepsize;
+    int stepsize;
 
-	/* The L2 norm of the synthesis basis functions associated with
+    /* The L2 norm of the synthesis basis functions associated with
-	  this band.  (The MCT is not considered in this value.) */
+      this band.  (The MCT is not considered in this value.) */
-	jpc_fix_t synweight;
+    jpc_fix_t synweight;
 
-	/* The analysis gain for this band. */
+    /* The analysis gain for this band. */
-	int analgain;
+    int analgain;
 
-	/* The per-resolution-level information. */
+    /* The per-resolution-level information. */
-	struct jpc_enc_rlvl_s *rlvl;
+    struct jpc_enc_rlvl_s *rlvl;
 
 } jpc_enc_band_t;
 
@@ -436,65 +436,65 @@ typedef struct jpc_enc_band_s {
 
 typedef struct jpc_enc_rlvl_s {
 
-	/* The x-coordinate of the top-left corner of the tile-component
+    /* The x-coordinate of the top-left corner of the tile-component
-	  at this resolution. */
+      at this resolution. */
-	uint_fast32_t tlx;
+    uint_fast32_t tlx;
 
-	/* The y-coordinate of the top-left corner of the tile-component
+    /* The y-coordinate of the top-left corner of the tile-component
-	  at this resolution. */
+      at this resolution. */
-	uint_fast32_t tly;
+    uint_fast32_t tly;
 
-	/* The x-coordinate of the bottom-right corner of the tile-component
+    /* The x-coordinate of the bottom-right corner of the tile-component
-	  at this resolution (plus one). */
+      at this resolution (plus one). */
-	uint_fast32_t brx;
+    uint_fast32_t brx;
 
-	/* The y-coordinate of the bottom-right corner of the tile-component
+    /* The y-coordinate of the bottom-right corner of the tile-component
-	  at this resolution (plus one). */
+      at this resolution (plus one). */
-	uint_fast32_t bry;
+    uint_fast32_t bry;
 
-	/* The exponent value for the nominal precinct width measured
+    /* The exponent value for the nominal precinct width measured
-	  relative to the associated LL band. */
+      relative to the associated LL band. */
-	int prcwidthexpn;
+    int prcwidthexpn;
 
-	/* The exponent value for the nominal precinct height measured
+    /* The exponent value for the nominal precinct height measured
-	  relative to the associated LL band. */
+      relative to the associated LL band. */
-	int prcheightexpn;
+    int prcheightexpn;
 
-	/* The number of precincts spanning the resolution level in the
+    /* The number of precincts spanning the resolution level in the
-	  horizontal direction. */
+      horizontal direction. */
-	int numhprcs;
+    int numhprcs;
 
-	/* The number of precincts spanning the resolution level in the
+    /* The number of precincts spanning the resolution level in the
-	  vertical direction. */
+      vertical direction. */
-	int numvprcs;
+    int numvprcs;
 
-	/* The total number of precincts. */
+    /* The total number of precincts. */
-	int numprcs;
+    int numprcs;
 
-	/* The exponent value for the nominal code block group width.
+    /* The exponent value for the nominal code block group width.
-	  This quantity is associated with the next lower resolution level
+      This quantity is associated with the next lower resolution level
-	  (assuming that there is one). */
+      (assuming that there is one). */
-	int cbgwidthexpn;
+    int cbgwidthexpn;
 
-	/* The exponent value for the nominal code block group height.
+    /* The exponent value for the nominal code block group height.
-	  This quantity is associated with the next lower resolution level
+      This quantity is associated with the next lower resolution level
-	  (assuming that there is one). */
+      (assuming that there is one). */
-	int cbgheightexpn;
+    int cbgheightexpn;
 
-	/* The exponent value for the code block width. */
+    /* The exponent value for the code block width. */
-	uint_fast16_t cblkwidthexpn;
+    uint_fast16_t cblkwidthexpn;
 
-	/* The exponent value for the code block height. */
+    /* The exponent value for the code block height. */
-	uint_fast16_t cblkheightexpn;
+    uint_fast16_t cblkheightexpn;
 
-	/* The number of bands associated with this resolution level. */
+    /* The number of bands associated with this resolution level. */
-	int numbands;
+    int numbands;
 
-	/* The per-band information. */
+    /* The per-band information. */
-	jpc_enc_band_t *bands;
+    jpc_enc_band_t *bands;
 
-	/* The parent tile-component. */
+    /* The parent tile-component. */
-	struct jpc_enc_tcmpt_s *tcmpt;
+    struct jpc_enc_tcmpt_s *tcmpt;
 
 } jpc_enc_rlvl_t;
 
@@ -502,53 +502,53 @@ typedef struct jpc_enc_rlvl_s {
 
 typedef struct jpc_enc_tcmpt_s {
 
-	/* The number of resolution levels. */
+    /* The number of resolution levels. */
-	int numrlvls;
+    int numrlvls;
 
-	/* The per-resolution-level information. */
+    /* The per-resolution-level information. */
-	jpc_enc_rlvl_t *rlvls;
+    jpc_enc_rlvl_t *rlvls;
 
-	/* The tile-component data. */
+    /* The tile-component data. */
-	jas_matrix_t *data;
+    jas_matrix_t *data;
 
-	/* The QMFB. */
+    /* The QMFB. */
-	int qmfbid;
+    int qmfbid;
 
-	/* The number of bands. */
+    /* The number of bands. */
-	int numbands;
+    int numbands;
 
-	/* The TSFB. */
+    /* The TSFB. */
-	jpc_tsfb_t *tsfb;
+    jpc_tsfb_t *tsfb;
 
-	/* The synthesis energy weight (for the MCT). */
+    /* The synthesis energy weight (for the MCT). */
-	jpc_fix_t synweight;
+    jpc_fix_t synweight;
 
-	/* The precinct width exponents. */
+    /* The precinct width exponents. */
-	int prcwidthexpns[JPC_MAXRLVLS];
+    int prcwidthexpns[JPC_MAXRLVLS];
 
-	/* The precinct height exponents. */
+    /* The precinct height exponents. */
-	int prcheightexpns[JPC_MAXRLVLS];
+    int prcheightexpns[JPC_MAXRLVLS];
 
-	/* The code block width exponent. */
+    /* The code block width exponent. */
-	int cblkwidthexpn;
+    int cblkwidthexpn;
 
-	/* The code block height exponent. */
+    /* The code block height exponent. */
-	int cblkheightexpn;
+    int cblkheightexpn;
 
-	/* Coding style (i.e., explicit precinct sizes). */
+    /* Coding style (i.e., explicit precinct sizes). */
-	int csty;
+    int csty;
 
-	/* Code block style. */
+    /* Code block style. */
-	int cblksty;
+    int cblksty;
 
-	/* The number of quantizer step sizes. */
+    /* The number of quantizer step sizes. */
-	int numstepsizes;
+    int numstepsizes;
 
-	/* The encoded quantizer step sizes. */
+    /* The encoded quantizer step sizes. */
-	uint_fast16_t stepsizes[JPC_MAXBANDS];
+    uint_fast16_t stepsizes[JPC_MAXBANDS];
 
-	/* The parent tile. */
+    /* The parent tile. */
-	struct jpc_enc_tile_s *tile;
+    struct jpc_enc_tile_s *tile;
 
 } jpc_enc_tcmpt_t;
 
@@ -556,55 +556,55 @@ typedef struct jpc_enc_tcmpt_s {
 
 typedef struct jpc_enc_tile_s {
 
-	/* The tile number. */
+    /* The tile number. */
-	uint_fast32_t tileno;
+    uint_fast32_t tileno;
 
-	/* The x-coordinate of the top-left corner of the tile measured with
+    /* The x-coordinate of the top-left corner of the tile measured with
-	  respect to the reference grid. */
+      respect to the reference grid. */
-	uint_fast32_t tlx;
+    uint_fast32_t tlx;
 
-	/* The y-coordinate of the top-left corner of the tile measured with
+    /* The y-coordinate of the top-left corner of the tile measured with
-	  respect to the reference grid. */
+      respect to the reference grid. */
-	uint_fast32_t tly;
+    uint_fast32_t tly;
 
-	/* The x-coordinate of the bottom-right corner of the tile measured
+    /* The x-coordinate of the bottom-right corner of the tile measured
-	  with respect to the reference grid (plus one). */
+      with respect to the reference grid (plus one). */
-	uint_fast32_t brx;
+    uint_fast32_t brx;
 
-	/* The y-coordinate of the bottom-right corner of the tile measured
+    /* The y-coordinate of the bottom-right corner of the tile measured
-	  with respect to the reference grid (plus one). */
+      with respect to the reference grid (plus one). */
-	uint_fast32_t bry;
+    uint_fast32_t bry;
 
-	/* The coding style. */
+    /* The coding style. */
-	uint_fast8_t csty;
+    uint_fast8_t csty;
 
-	/* The progression order. */
+    /* The progression order. */
-	uint_fast8_t prg;
+    uint_fast8_t prg;
 
-	/* The number of layers. */
+    /* The number of layers. */
-	int numlyrs;
+    int numlyrs;
 
-	/* The MCT to employ (if any). */
+    /* The MCT to employ (if any). */
-	uint_fast8_t mctid;
+    uint_fast8_t mctid;
 
-	/* The packet iterator (used to determine the order of packet
+    /* The packet iterator (used to determine the order of packet
-	  generation). */
+      generation). */
-	jpc_pi_t *pi;
+    jpc_pi_t *pi;
 
-	/* The coding mode (i.e., integer or real). */
+    /* The coding mode (i.e., integer or real). */
-	bool intmode;
+    bool intmode;
 
-	/* The number of bytes to allocate to the various layers. */
+    /* The number of bytes to allocate to the various layers. */
-	uint_fast32_t *lyrsizes;
+    uint_fast32_t *lyrsizes;
 
-	/* The number of tile-components. */
+    /* The number of tile-components. */
-	int numtcmpts;
+    int numtcmpts;
 
-	/* The per tile-component information. */
+    /* The per tile-component information. */
-	jpc_enc_tcmpt_t *tcmpts;
+    jpc_enc_tcmpt_t *tcmpts;
 
-	/* The raw (i.e., uncompressed) size of this tile. */
+    /* The raw (i.e., uncompressed) size of this tile. */
-	uint_fast32_t rawsize;
+    uint_fast32_t rawsize;
 
 } jpc_enc_tile_t;
 
@@ -612,34 +612,34 @@ typedef struct jpc_enc_tile_s {
 
 typedef struct jpc_enc_s {
 
-	/* The image being encoded. */
+    /* The image being encoded. */
-	jas_image_t *image;
+    jas_image_t *image;
 
-	/* The output stream. */
+    /* The output stream. */
-	jas_stream_t *out;
+    jas_stream_t *out;
 
-	/* The coding parameters. */
+    /* The coding parameters. */
-	jpc_enc_cp_t *cp;
+    jpc_enc_cp_t *cp;
 
-	/* The tile currently being processed. */
+    /* The tile currently being processed. */
-	jpc_enc_tile_t *curtile;
+    jpc_enc_tile_t *curtile;
 
-	/* The code stream state. */
+    /* The code stream state. */
-	jpc_cstate_t *cstate;
+    jpc_cstate_t *cstate;
 
-	/* The number of bytes output so far. */
+    /* The number of bytes output so far. */
-	uint_fast32_t len;
+    uint_fast32_t len;
 
-	/* The number of bytes available for the main body of the code stream. */
+    /* The number of bytes available for the main body of the code stream. */
-	/* This is used for rate allocation purposes. */
+    /* This is used for rate allocation purposes. */
-	uint_fast32_t mainbodysize;
+    uint_fast32_t mainbodysize;
 
-	/* The marker segment currently being processed. */
+    /* The marker segment currently being processed. */
-	/* This member is a convenience for making cleanup easier. */
+    /* This member is a convenience for making cleanup easier. */
-	jpc_ms_t *mrk;
+    jpc_ms_t *mrk;
 
-	/* The stream used to temporarily hold tile-part data. */
+    /* The stream used to temporarily hold tile-part data. */
-	jas_stream_t *tmpstream;
+    jas_stream_t *tmpstream;
 
 } jpc_enc_t;
 

3rdparty/libjasper/jpc_fix.h

@@ -6,15 +6,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,
@@ -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__
  */
 
@@ -113,11 +113,11 @@ typedef int_fast64_t jpc_fix_big_t;
 #define	jpc_fix_add(x, y)	JAS_FIX_ADD(jpc_fix_t, JPC_FIX_FRACBITS, x, y)
 #define	jpc_fix_sub(x, y)	JAS_FIX_SUB(jpc_fix_t, JPC_FIX_FRACBITS, x, y)
 #define	jpc_fix_mul(x, y) \
-	JAS_FIX_MUL(jpc_fix_t, JPC_FIX_FRACBITS, jpc_fix_big_t, x, y)
+    JAS_FIX_MUL(jpc_fix_t, JPC_FIX_FRACBITS, jpc_fix_big_t, x, y)
 #define	jpc_fix_mulbyint(x, y) \
-	JAS_FIX_MULBYINT(jpc_fix_t, JPC_FIX_FRACBITS, x, y)
+    JAS_FIX_MULBYINT(jpc_fix_t, JPC_FIX_FRACBITS, x, y)
 #define	jpc_fix_div(x, y) \
-	JAS_FIX_DIV(jpc_fix_t, JPC_FIX_FRACBITS, jpc_fix_big_t, x, y)
+    JAS_FIX_DIV(jpc_fix_t, JPC_FIX_FRACBITS, jpc_fix_big_t, x, y)
 #define	jpc_fix_neg(x)		JAS_FIX_NEG(jpc_fix_t, JPC_FIX_FRACBITS, x)
 #define	jpc_fix_asl(x, n)	JAS_FIX_ASL(jpc_fix_t, JPC_FIX_FRACBITS, x, n)
 #define	jpc_fix_asr(x, n)	JAS_FIX_ASR(jpc_fix_t, JPC_FIX_FRACBITS, x, n)
@@ -125,7 +125,7 @@ typedef int_fast64_t jpc_fix_big_t;
 #define jpc_fix_pluseq(x, y)	JAS_FIX_PLUSEQ(jpc_fix_t, JPC_FIX_FRACBITS, x, y)
 #define jpc_fix_minuseq(x, y)	JAS_FIX_MINUSEQ(jpc_fix_t, JPC_FIX_FRACBITS, x, y)
 #define	jpc_fix_muleq(x, y)	\
-	JAS_FIX_MULEQ(jpc_fix_t, JPC_FIX_FRACBITS, jpc_fix_big_t, x, y)
+    JAS_FIX_MULEQ(jpc_fix_t, JPC_FIX_FRACBITS, jpc_fix_big_t, x, y)
 
 #define	jpc_fix_abs(x)		JAS_FIX_ABS(jpc_fix_t, JPC_FIX_FRACBITS, x)
 #define	jpc_fix_isint(x)	JAS_FIX_ISINT(jpc_fix_t, JPC_FIX_FRACBITS, x)

3rdparty/libjasper/jpc_flt.h

@@ -6,15 +6,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,
@@ -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__
  */
 

3rdparty/libjasper/jpc_math.c

@@ -6,15 +6,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,
@@ -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__
  */
 
@@ -88,17 +88,17 @@
   integer. */
 int jpc_floorlog2(int x)
 {
-	int y;
+    int y;
 
-	/* The argument must be positive. */
+    /* The argument must be positive. */
-	assert(x > 0);
+    assert(x > 0);
 
-	y = 0;
+    y = 0;
-	while (x > 1) {
+    while (x > 1) {
-		x >>= 1;
+        x >>= 1;
-		++y;
+        ++y;
-	}
+    }
-	return y;
+    return y;
 }
 
 /* Calculate the bit position of the first leading one in a nonnegative
@@ -107,15 +107,15 @@ int jpc_floorlog2(int x)
   allowable range for x is slightly different. */
 int jpc_firstone(int x)
 {
-	int n;
+    int n;
 
-	/* The argument must be nonnegative. */
+    /* The argument must be nonnegative. */
-	assert(x >= 0);
+    assert(x >= 0);
 
-	n = -1;
+    n = -1;
-	while (x > 0) {
+    while (x > 0) {
-		x >>= 1;
+        x >>= 1;
-		++n;
+        ++n;
-	}
+    }
-	return n;
+    return n;
 }

3rdparty/libjasper/jpc_math.h

@@ -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__
  */
 

3rdparty/libjasper/jpc_mct.c

@@ -6,15 +6,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,
@@ -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__
  */
 
@@ -86,206 +86,206 @@
 
 void jpc_rct(jas_matrix_t *c0, jas_matrix_t *c1, jas_matrix_t *c2)
 {
-	int numrows;
+    int numrows;
-	int numcols;
+    int numcols;
-	int i;
+    int i;
-	int j;
+    int j;
-	jpc_fix_t *c0p;
+    jpc_fix_t *c0p;
-	jpc_fix_t *c1p;
+    jpc_fix_t *c1p;
-	jpc_fix_t *c2p;
+    jpc_fix_t *c2p;
 
-	numrows = jas_matrix_numrows(c0);
+    numrows = jas_matrix_numrows(c0);
-	numcols = jas_matrix_numcols(c0);
+    numcols = jas_matrix_numcols(c0);
 
-	/* All three matrices must have the same dimensions. */
+    /* All three matrices must have the same dimensions. */
-	assert(jas_matrix_numrows(c1) == numrows && jas_matrix_numcols(c1) == numcols
+    assert(jas_matrix_numrows(c1) == numrows && jas_matrix_numcols(c1) == numcols
-	  && jas_matrix_numrows(c2) == numrows && jas_matrix_numcols(c2) == numcols);
+      && jas_matrix_numrows(c2) == numrows && jas_matrix_numcols(c2) == numcols);
 
-	for (i = 0; i < numrows; i++) {
+    for (i = 0; i < numrows; i++) {
-		c0p = jas_matrix_getref(c0, i, 0);
+        c0p = jas_matrix_getref(c0, i, 0);
-		c1p = jas_matrix_getref(c1, i, 0);
+        c1p = jas_matrix_getref(c1, i, 0);
-		c2p = jas_matrix_getref(c2, i, 0);
+        c2p = jas_matrix_getref(c2, i, 0);
-		for (j = numcols; j > 0; --j) {
+        for (j = numcols; j > 0; --j) {
-			int r;
+            int r;
-			int g;
+            int g;
-			int b;
+            int b;
-			int y;
+            int y;
-			int u;
+            int u;
-			int v;
+            int v;
-			r = *c0p;
+            r = *c0p;
-			g = *c1p;
+            g = *c1p;
-			b = *c2p;
+            b = *c2p;
-			y = (r + (g << 1) + b) >> 2;
+            y = (r + (g << 1) + b) >> 2;
-			u = b - g;
+            u = b - g;
-			v = r - g;
+            v = r - g;
-			*c0p++ = y;
+            *c0p++ = y;
-			*c1p++ = u;
+            *c1p++ = u;
-			*c2p++ = v;
+            *c2p++ = v;
-		}
+        }
-	}
+    }
 }
 
 /* Compute the inverse RCT. */
 
 void jpc_irct(jas_matrix_t *c0, jas_matrix_t *c1, jas_matrix_t *c2)
 {
-	int numrows;
+    int numrows;
-	int numcols;
+    int numcols;
-	int i;
+    int i;
-	int j;
+    int j;
-	jpc_fix_t *c0p;
+    jpc_fix_t *c0p;
-	jpc_fix_t *c1p;
+    jpc_fix_t *c1p;
-	jpc_fix_t *c2p;
+    jpc_fix_t *c2p;
 
-	numrows = jas_matrix_numrows(c0);
+    numrows = jas_matrix_numrows(c0);
-	numcols = jas_matrix_numcols(c0);
+    numcols = jas_matrix_numcols(c0);
 
-	/* All three matrices must have the same dimensions. */
+    /* All three matrices must have the same dimensions. */
-	assert(jas_matrix_numrows(c1) == numrows && jas_matrix_numcols(c1) == numcols
+    assert(jas_matrix_numrows(c1) == numrows && jas_matrix_numcols(c1) == numcols
-	  && jas_matrix_numrows(c2) == numrows && jas_matrix_numcols(c2) == numcols);
+      && jas_matrix_numrows(c2) == numrows && jas_matrix_numcols(c2) == numcols);
 
-	for (i = 0; i < numrows; i++) {
+    for (i = 0; i < numrows; i++) {
-		c0p = jas_matrix_getref(c0, i, 0);
+        c0p = jas_matrix_getref(c0, i, 0);
-		c1p = jas_matrix_getref(c1, i, 0);
+        c1p = jas_matrix_getref(c1, i, 0);
-		c2p = jas_matrix_getref(c2, i, 0);
+        c2p = jas_matrix_getref(c2, i, 0);
-		for (j = numcols; j > 0; --j) {
+        for (j = numcols; j > 0; --j) {
-			int r;
+            int r;
-			int g;
+            int g;
-			int b;
+            int b;
-			int y;
+            int y;
-			int u;
+            int u;
-			int v;
+            int v;
-			y = *c0p;
+            y = *c0p;
-			u = *c1p;
+            u = *c1p;
-			v = *c2p;
+            v = *c2p;
-			g = y - ((u + v) >> 2);
+            g = y - ((u + v) >> 2);
-			r = v + g;
+            r = v + g;
-			b = u + g;
+            b = u + g;
-			*c0p++ = r;
+            *c0p++ = r;
-			*c1p++ = g;
+            *c1p++ = g;
-			*c2p++ = b;
+            *c2p++ = b;
-		}
+        }
-	}
+    }
 }
 
 void jpc_ict(jas_matrix_t *c0, jas_matrix_t *c1, jas_matrix_t *c2)
 {
-	int numrows;
+    int numrows;
-	int numcols;
+    int numcols;
-	int i;
+    int i;
-	int j;
+    int j;
-	jpc_fix_t r;
+    jpc_fix_t r;
-	jpc_fix_t g;
+    jpc_fix_t g;
-	jpc_fix_t b;
+    jpc_fix_t b;
-	jpc_fix_t y;
+    jpc_fix_t y;
-	jpc_fix_t u;
+    jpc_fix_t u;
-	jpc_fix_t v;
+    jpc_fix_t v;
-	jpc_fix_t *c0p;
+    jpc_fix_t *c0p;
-	jpc_fix_t *c1p;
+    jpc_fix_t *c1p;
-	jpc_fix_t *c2p;
+    jpc_fix_t *c2p;
 
-	numrows = jas_matrix_numrows(c0);
+    numrows = jas_matrix_numrows(c0);
-	assert(jas_matrix_numrows(c1) == numrows && jas_matrix_numrows(c2) == numrows);
+    assert(jas_matrix_numrows(c1) == numrows && jas_matrix_numrows(c2) == numrows);
-	numcols = jas_matrix_numcols(c0);
+    numcols = jas_matrix_numcols(c0);
-	assert(jas_matrix_numcols(c1) == numcols && jas_matrix_numcols(c2) == numcols);
+    assert(jas_matrix_numcols(c1) == numcols && jas_matrix_numcols(c2) == numcols);
-	for (i = 0; i < numrows; ++i) {
+    for (i = 0; i < numrows; ++i) {
-		c0p = jas_matrix_getref(c0, i, 0);
+        c0p = jas_matrix_getref(c0, i, 0);
-		c1p = jas_matrix_getref(c1, i, 0);
+        c1p = jas_matrix_getref(c1, i, 0);
-		c2p = jas_matrix_getref(c2, i, 0);
+        c2p = jas_matrix_getref(c2, i, 0);
-		for (j = numcols; j > 0; --j) {
+        for (j = numcols; j > 0; --j) {
-			r = *c0p;
+            r = *c0p;
-			g = *c1p;
+            g = *c1p;
-			b = *c2p;
+            b = *c2p;
-			y = jpc_fix_add3(jpc_fix_mul(jpc_dbltofix(0.299), r), jpc_fix_mul(jpc_dbltofix(0.587), g),
+            y = jpc_fix_add3(jpc_fix_mul(jpc_dbltofix(0.299), r), jpc_fix_mul(jpc_dbltofix(0.587), g),
-			  jpc_fix_mul(jpc_dbltofix(0.114), b));
+              jpc_fix_mul(jpc_dbltofix(0.114), b));
-			u = jpc_fix_add3(jpc_fix_mul(jpc_dbltofix(-0.16875), r), jpc_fix_mul(jpc_dbltofix(-0.33126), g),
+            u = jpc_fix_add3(jpc_fix_mul(jpc_dbltofix(-0.16875), r), jpc_fix_mul(jpc_dbltofix(-0.33126), g),
-			  jpc_fix_mul(jpc_dbltofix(0.5), b));
+              jpc_fix_mul(jpc_dbltofix(0.5), b));
-			v = jpc_fix_add3(jpc_fix_mul(jpc_dbltofix(0.5), r), jpc_fix_mul(jpc_dbltofix(-0.41869), g),
+            v = jpc_fix_add3(jpc_fix_mul(jpc_dbltofix(0.5), r), jpc_fix_mul(jpc_dbltofix(-0.41869), g),
-			  jpc_fix_mul(jpc_dbltofix(-0.08131), b));
+              jpc_fix_mul(jpc_dbltofix(-0.08131), b));
-			*c0p++ = y;
+            *c0p++ = y;
-			*c1p++ = u;
+            *c1p++ = u;
-			*c2p++ = v;
+            *c2p++ = v;
-		}
+        }
-	}
+    }
 }
 
 void jpc_iict(jas_matrix_t *c0, jas_matrix_t *c1, jas_matrix_t *c2)
 {
-	int numrows;
+    int numrows;
-	int numcols;
+    int numcols;
-	int i;
+    int i;
-	int j;
+    int j;
-	jpc_fix_t r;
+    jpc_fix_t r;
-	jpc_fix_t g;
+    jpc_fix_t g;
-	jpc_fix_t b;
+    jpc_fix_t b;
-	jpc_fix_t y;
+    jpc_fix_t y;
-	jpc_fix_t u;
+    jpc_fix_t u;
-	jpc_fix_t v;
+    jpc_fix_t v;
-	jpc_fix_t *c0p;
+    jpc_fix_t *c0p;
-	jpc_fix_t *c1p;
+    jpc_fix_t *c1p;
-	jpc_fix_t *c2p;
+    jpc_fix_t *c2p;
 
-	numrows = jas_matrix_numrows(c0);
+    numrows = jas_matrix_numrows(c0);
-	assert(jas_matrix_numrows(c1) == numrows && jas_matrix_numrows(c2) == numrows);
+    assert(jas_matrix_numrows(c1) == numrows && jas_matrix_numrows(c2) == numrows);
-	numcols = jas_matrix_numcols(c0);
+    numcols = jas_matrix_numcols(c0);
-	assert(jas_matrix_numcols(c1) == numcols && jas_matrix_numcols(c2) == numcols);
+    assert(jas_matrix_numcols(c1) == numcols && jas_matrix_numcols(c2) == numcols);
-	for (i = 0; i < numrows; ++i) {
+    for (i = 0; i < numrows; ++i) {
-		c0p = jas_matrix_getref(c0, i, 0);
+        c0p = jas_matrix_getref(c0, i, 0);
-		c1p = jas_matrix_getref(c1, i, 0);
+        c1p = jas_matrix_getref(c1, i, 0);
-		c2p = jas_matrix_getref(c2, i, 0);
+        c2p = jas_matrix_getref(c2, i, 0);
-		for (j = numcols; j > 0; --j) {
+        for (j = numcols; j > 0; --j) {
-			y = *c0p;
+            y = *c0p;
-			u = *c1p;
+            u = *c1p;
-			v = *c2p;
+            v = *c2p;
-			r = jpc_fix_add(y, jpc_fix_mul(jpc_dbltofix(1.402), v));
+            r = jpc_fix_add(y, jpc_fix_mul(jpc_dbltofix(1.402), v));
-			g = jpc_fix_add3(y, jpc_fix_mul(jpc_dbltofix(-0.34413), u),
+            g = jpc_fix_add3(y, jpc_fix_mul(jpc_dbltofix(-0.34413), u),
-			  jpc_fix_mul(jpc_dbltofix(-0.71414), v));
+              jpc_fix_mul(jpc_dbltofix(-0.71414), v));
-			b = jpc_fix_add(y, jpc_fix_mul(jpc_dbltofix(1.772), u));
+            b = jpc_fix_add(y, jpc_fix_mul(jpc_dbltofix(1.772), u));
-			*c0p++ = r;
+            *c0p++ = r;
-			*c1p++ = g;
+            *c1p++ = g;
-			*c2p++ = b;
+            *c2p++ = b;
-		}
+        }
-	}
+    }
 }
 
 jpc_fix_t jpc_mct_getsynweight(int mctid, int cmptno)
 {
-	jpc_fix_t synweight;
+    jpc_fix_t synweight;
 
-	synweight = JPC_FIX_ONE;
+    synweight = JPC_FIX_ONE;
-	switch (mctid) {
+    switch (mctid) {
-	case JPC_MCT_RCT:
+    case JPC_MCT_RCT:
-		switch (cmptno) {
+        switch (cmptno) {
-		case 0:
+        case 0:
-			synweight = jpc_dbltofix(sqrt(3.0));
+            synweight = jpc_dbltofix(sqrt(3.0));
-			break;
+            break;
-		case 1:
+        case 1:
-			synweight = jpc_dbltofix(sqrt(0.6875));
+            synweight = jpc_dbltofix(sqrt(0.6875));
-			break;
+            break;
-		case 2:
+        case 2:
-			synweight = jpc_dbltofix(sqrt(0.6875));
+            synweight = jpc_dbltofix(sqrt(0.6875));
-			break;
+            break;
-		}
+        }
-		break;
+        break;
-	case JPC_MCT_ICT:
+    case JPC_MCT_ICT:
-		switch (cmptno) {
+        switch (cmptno) {
-		case 0:
+        case 0:
-			synweight = jpc_dbltofix(sqrt(3.0000));
+            synweight = jpc_dbltofix(sqrt(3.0000));
-			break;
+            break;
-		case 1:
+        case 1:
-			synweight = jpc_dbltofix(sqrt(3.2584));
+            synweight = jpc_dbltofix(sqrt(3.2584));
-			break;
+            break;
-		case 2:
+        case 2:
-			synweight = jpc_dbltofix(sqrt(2.4755));
+            synweight = jpc_dbltofix(sqrt(2.4755));
-			break;
+            break;
-		}
+        }
-		break;
+        break;
 #if 0
-	default:
+    default:
-		synweight = JPC_FIX_ONE;
+        synweight = JPC_FIX_ONE;
-		break;
+        break;
 #endif
-	}
+    }
 
-	return synweight;
+    return synweight;
 }

3rdparty/libjasper/jpc_mct.h

@@ -6,15 +6,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,
@@ -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__
  */
 

3rdparty/libjasper/jpc_mqcod.c

@@ -6,15 +6,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,
@@ -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__
  */
 
@@ -82,98 +82,98 @@
 /* MQ coder per-state information. */
 
 jpc_mqstate_t jpc_mqstates[47 * 2] = {
-	{0x5601, 0, &jpc_mqstates[ 2], &jpc_mqstates[ 3]},
+    {0x5601, 0, &jpc_mqstates[ 2], &jpc_mqstates[ 3]},
-	{0x5601, 1, &jpc_mqstates[ 3], &jpc_mqstates[ 2]},
+    {0x5601, 1, &jpc_mqstates[ 3], &jpc_mqstates[ 2]},
-	{0x3401, 0, &jpc_mqstates[ 4], &jpc_mqstates[12]},
+    {0x3401, 0, &jpc_mqstates[ 4], &jpc_mqstates[12]},
-	{0x3401, 1, &jpc_mqstates[ 5], &jpc_mqstates[13]},
+    {0x3401, 1, &jpc_mqstates[ 5], &jpc_mqstates[13]},
-	{0x1801, 0, &jpc_mqstates[ 6], &jpc_mqstates[18]},
+    {0x1801, 0, &jpc_mqstates[ 6], &jpc_mqstates[18]},
-	{0x1801, 1, &jpc_mqstates[ 7], &jpc_mqstates[19]},
+    {0x1801, 1, &jpc_mqstates[ 7], &jpc_mqstates[19]},
-	{0x0ac1, 0, &jpc_mqstates[ 8], &jpc_mqstates[24]},
+    {0x0ac1, 0, &jpc_mqstates[ 8], &jpc_mqstates[24]},
-	{0x0ac1, 1, &jpc_mqstates[ 9], &jpc_mqstates[25]},
+    {0x0ac1, 1, &jpc_mqstates[ 9], &jpc_mqstates[25]},
-	{0x0521, 0, &jpc_mqstates[10], &jpc_mqstates[58]},
+    {0x0521, 0, &jpc_mqstates[10], &jpc_mqstates[58]},
-	{0x0521, 1, &jpc_mqstates[11], &jpc_mqstates[59]},
+    {0x0521, 1, &jpc_mqstates[11], &jpc_mqstates[59]},
-	{0x0221, 0, &jpc_mqstates[76], &jpc_mqstates[66]},
+    {0x0221, 0, &jpc_mqstates[76], &jpc_mqstates[66]},
-	{0x0221, 1, &jpc_mqstates[77], &jpc_mqstates[67]},
+    {0x0221, 1, &jpc_mqstates[77], &jpc_mqstates[67]},
-	{0x5601, 0, &jpc_mqstates[14], &jpc_mqstates[13]},
+    {0x5601, 0, &jpc_mqstates[14], &jpc_mqstates[13]},
-	{0x5601, 1, &jpc_mqstates[15], &jpc_mqstates[12]},
+    {0x5601, 1, &jpc_mqstates[15], &jpc_mqstates[12]},
-	{0x5401, 0, &jpc_mqstates[16], &jpc_mqstates[28]},
+    {0x5401, 0, &jpc_mqstates[16], &jpc_mqstates[28]},
-	{0x5401, 1, &jpc_mqstates[17], &jpc_mqstates[29]},
+    {0x5401, 1, &jpc_mqstates[17], &jpc_mqstates[29]},
-	{0x4801, 0, &jpc_mqstates[18], &jpc_mqstates[28]},
+    {0x4801, 0, &jpc_mqstates[18], &jpc_mqstates[28]},
-	{0x4801, 1, &jpc_mqstates[19], &jpc_mqstates[29]},
+    {0x4801, 1, &jpc_mqstates[19], &jpc_mqstates[29]},
-	{0x3801, 0, &jpc_mqstates[20], &jpc_mqstates[28]},
+    {0x3801, 0, &jpc_mqstates[20], &jpc_mqstates[28]},
-	{0x3801, 1, &jpc_mqstates[21], &jpc_mqstates[29]},
+    {0x3801, 1, &jpc_mqstates[21], &jpc_mqstates[29]},
-	{0x3001, 0, &jpc_mqstates[22], &jpc_mqstates[34]},
+    {0x3001, 0, &jpc_mqstates[22], &jpc_mqstates[34]},
-	{0x3001, 1, &jpc_mqstates[23], &jpc_mqstates[35]},
+    {0x3001, 1, &jpc_mqstates[23], &jpc_mqstates[35]},
-	{0x2401, 0, &jpc_mqstates[24], &jpc_mqstates[36]},
+    {0x2401, 0, &jpc_mqstates[24], &jpc_mqstates[36]},
-	{0x2401, 1, &jpc_mqstates[25], &jpc_mqstates[37]},
+    {0x2401, 1, &jpc_mqstates[25], &jpc_mqstates[37]},
-	{0x1c01, 0, &jpc_mqstates[26], &jpc_mqstates[40]},
+    {0x1c01, 0, &jpc_mqstates[26], &jpc_mqstates[40]},
-	{0x1c01, 1, &jpc_mqstates[27], &jpc_mqstates[41]},
+    {0x1c01, 1, &jpc_mqstates[27], &jpc_mqstates[41]},
-	{0x1601, 0, &jpc_mqstates[58], &jpc_mqstates[42]},
+    {0x1601, 0, &jpc_mqstates[58], &jpc_mqstates[42]},
-	{0x1601, 1, &jpc_mqstates[59], &jpc_mqstates[43]},
+    {0x1601, 1, &jpc_mqstates[59], &jpc_mqstates[43]},
-	{0x5601, 0, &jpc_mqstates[30], &jpc_mqstates[29]},
+    {0x5601, 0, &jpc_mqstates[30], &jpc_mqstates[29]},
-	{0x5601, 1, &jpc_mqstates[31], &jpc_mqstates[28]},
+    {0x5601, 1, &jpc_mqstates[31], &jpc_mqstates[28]},
-	{0x5401, 0, &jpc_mqstates[32], &jpc_mqstates[28]},
+    {0x5401, 0, &jpc_mqstates[32], &jpc_mqstates[28]},
-	{0x5401, 1, &jpc_mqstates[33], &jpc_mqstates[29]},
+    {0x5401, 1, &jpc_mqstates[33], &jpc_mqstates[29]},
-	{0x5101, 0, &jpc_mqstates[34], &jpc_mqstates[30]},
+    {0x5101, 0, &jpc_mqstates[34], &jpc_mqstates[30]},
-	{0x5101, 1, &jpc_mqstates[35], &jpc_mqstates[31]},
+    {0x5101, 1, &jpc_mqstates[35], &jpc_mqstates[31]},
-	{0x4801, 0, &jpc_mqstates[36], &jpc_mqstates[32]},
+    {0x4801, 0, &jpc_mqstates[36], &jpc_mqstates[32]},
-	{0x4801, 1, &jpc_mqstates[37], &jpc_mqstates[33]},
+    {0x4801, 1, &jpc_mqstates[37], &jpc_mqstates[33]},
-	{0x3801, 0, &jpc_mqstates[38], &jpc_mqstates[34]},
+    {0x3801, 0, &jpc_mqstates[38], &jpc_mqstates[34]},
-	{0x3801, 1, &jpc_mqstates[39], &jpc_mqstates[35]},
+    {0x3801, 1, &jpc_mqstates[39], &jpc_mqstates[35]},
-	{0x3401, 0, &jpc_mqstates[40], &jpc_mqstates[36]},
+    {0x3401, 0, &jpc_mqstates[40], &jpc_mqstates[36]},
-	{0x3401, 1, &jpc_mqstates[41], &jpc_mqstates[37]},
+    {0x3401, 1, &jpc_mqstates[41], &jpc_mqstates[37]},
-	{0x3001, 0, &jpc_mqstates[42], &jpc_mqstates[38]},
+    {0x3001, 0, &jpc_mqstates[42], &jpc_mqstates[38]},
-	{0x3001, 1, &jpc_mqstates[43], &jpc_mqstates[39]},
+    {0x3001, 1, &jpc_mqstates[43], &jpc_mqstates[39]},
-	{0x2801, 0, &jpc_mqstates[44], &jpc_mqstates[38]},
+    {0x2801, 0, &jpc_mqstates[44], &jpc_mqstates[38]},
-	{0x2801, 1, &jpc_mqstates[45], &jpc_mqstates[39]},
+    {0x2801, 1, &jpc_mqstates[45], &jpc_mqstates[39]},
-	{0x2401, 0, &jpc_mqstates[46], &jpc_mqstates[40]},
+    {0x2401, 0, &jpc_mqstates[46], &jpc_mqstates[40]},
-	{0x2401, 1, &jpc_mqstates[47], &jpc_mqstates[41]},
+    {0x2401, 1, &jpc_mqstates[47], &jpc_mqstates[41]},
-	{0x2201, 0, &jpc_mqstates[48], &jpc_mqstates[42]},
+    {0x2201, 0, &jpc_mqstates[48], &jpc_mqstates[42]},
-	{0x2201, 1, &jpc_mqstates[49], &jpc_mqstates[43]},
+    {0x2201, 1, &jpc_mqstates[49], &jpc_mqstates[43]},
-	{0x1c01, 0, &jpc_mqstates[50], &jpc_mqstates[44]},
+    {0x1c01, 0, &jpc_mqstates[50], &jpc_mqstates[44]},
-	{0x1c01, 1, &jpc_mqstates[51], &jpc_mqstates[45]},
+    {0x1c01, 1, &jpc_mqstates[51], &jpc_mqstates[45]},
-	{0x1801, 0, &jpc_mqstates[52], &jpc_mqstates[46]},
+    {0x1801, 0, &jpc_mqstates[52], &jpc_mqstates[46]},
-	{0x1801, 1, &jpc_mqstates[53], &jpc_mqstates[47]},
+    {0x1801, 1, &jpc_mqstates[53], &jpc_mqstates[47]},
-	{0x1601, 0, &jpc_mqstates[54], &jpc_mqstates[48]},
+    {0x1601, 0, &jpc_mqstates[54], &jpc_mqstates[48]},
-	{0x1601, 1, &jpc_mqstates[55], &jpc_mqstates[49]},
+    {0x1601, 1, &jpc_mqstates[55], &jpc_mqstates[49]},
-	{0x1401, 0, &jpc_mqstates[56], &jpc_mqstates[50]},
+    {0x1401, 0, &jpc_mqstates[56], &jpc_mqstates[50]},
-	{0x1401, 1, &jpc_mqstates[57], &jpc_mqstates[51]},
+    {0x1401, 1, &jpc_mqstates[57], &jpc_mqstates[51]},
-	{0x1201, 0, &jpc_mqstates[58], &jpc_mqstates[52]},
+    {0x1201, 0, &jpc_mqstates[58], &jpc_mqstates[52]},
-	{0x1201, 1, &jpc_mqstates[59], &jpc_mqstates[53]},
+    {0x1201, 1, &jpc_mqstates[59], &jpc_mqstates[53]},
-	{0x1101, 0, &jpc_mqstates[60], &jpc_mqstates[54]},
+    {0x1101, 0, &jpc_mqstates[60], &jpc_mqstates[54]},
-	{0x1101, 1, &jpc_mqstates[61], &jpc_mqstates[55]},
+    {0x1101, 1, &jpc_mqstates[61], &jpc_mqstates[55]},
-	{0x0ac1, 0, &jpc_mqstates[62], &jpc_mqstates[56]},
+    {0x0ac1, 0, &jpc_mqstates[62], &jpc_mqstates[56]},
-	{0x0ac1, 1, &jpc_mqstates[63], &jpc_mqstates[57]},
+    {0x0ac1, 1, &jpc_mqstates[63], &jpc_mqstates[57]},
-	{0x09c1, 0, &jpc_mqstates[64], &jpc_mqstates[58]},
+    {0x09c1, 0, &jpc_mqstates[64], &jpc_mqstates[58]},
-	{0x09c1, 1, &jpc_mqstates[65], &jpc_mqstates[59]},
+    {0x09c1, 1, &jpc_mqstates[65], &jpc_mqstates[59]},
-	{0x08a1, 0, &jpc_mqstates[66], &jpc_mqstates[60]},
+    {0x08a1, 0, &jpc_mqstates[66], &jpc_mqstates[60]},
-	{0x08a1, 1, &jpc_mqstates[67], &jpc_mqstates[61]},
+    {0x08a1, 1, &jpc_mqstates[67], &jpc_mqstates[61]},
-	{0x0521, 0, &jpc_mqstates[68], &jpc_mqstates[62]},
+    {0x0521, 0, &jpc_mqstates[68], &jpc_mqstates[62]},
-	{0x0521, 1, &jpc_mqstates[69], &jpc_mqstates[63]},
+    {0x0521, 1, &jpc_mqstates[69], &jpc_mqstates[63]},
-	{0x0441, 0, &jpc_mqstates[70], &jpc_mqstates[64]},
+    {0x0441, 0, &jpc_mqstates[70], &jpc_mqstates[64]},
-	{0x0441, 1, &jpc_mqstates[71], &jpc_mqstates[65]},
+    {0x0441, 1, &jpc_mqstates[71], &jpc_mqstates[65]},
-	{0x02a1, 0, &jpc_mqstates[72], &jpc_mqstates[66]},
+    {0x02a1, 0, &jpc_mqstates[72], &jpc_mqstates[66]},
-	{0x02a1, 1, &jpc_mqstates[73], &jpc_mqstates[67]},
+    {0x02a1, 1, &jpc_mqstates[73], &jpc_mqstates[67]},
-	{0x0221, 0, &jpc_mqstates[74], &jpc_mqstates[68]},
+    {0x0221, 0, &jpc_mqstates[74], &jpc_mqstates[68]},
-	{0x0221, 1, &jpc_mqstates[75], &jpc_mqstates[69]},
+    {0x0221, 1, &jpc_mqstates[75], &jpc_mqstates[69]},
-	{0x0141, 0, &jpc_mqstates[76], &jpc_mqstates[70]},
+    {0x0141, 0, &jpc_mqstates[76], &jpc_mqstates[70]},
-	{0x0141, 1, &jpc_mqstates[77], &jpc_mqstates[71]},
+    {0x0141, 1, &jpc_mqstates[77], &jpc_mqstates[71]},
-	{0x0111, 0, &jpc_mqstates[78], &jpc_mqstates[72]},
+    {0x0111, 0, &jpc_mqstates[78], &jpc_mqstates[72]},
-	{0x0111, 1, &jpc_mqstates[79], &jpc_mqstates[73]},
+    {0x0111, 1, &jpc_mqstates[79], &jpc_mqstates[73]},
-	{0x0085, 0, &jpc_mqstates[80], &jpc_mqstates[74]},
+    {0x0085, 0, &jpc_mqstates[80], &jpc_mqstates[74]},
-	{0x0085, 1, &jpc_mqstates[81], &jpc_mqstates[75]},
+    {0x0085, 1, &jpc_mqstates[81], &jpc_mqstates[75]},
-	{0x0049, 0, &jpc_mqstates[82], &jpc_mqstates[76]},
+    {0x0049, 0, &jpc_mqstates[82], &jpc_mqstates[76]},
-	{0x0049, 1, &jpc_mqstates[83], &jpc_mqstates[77]},
+    {0x0049, 1, &jpc_mqstates[83], &jpc_mqstates[77]},
-	{0x0025, 0, &jpc_mqstates[84], &jpc_mqstates[78]},
+    {0x0025, 0, &jpc_mqstates[84], &jpc_mqstates[78]},
-	{0x0025, 1, &jpc_mqstates[85], &jpc_mqstates[79]},
+    {0x0025, 1, &jpc_mqstates[85], &jpc_mqstates[79]},
-	{0x0015, 0, &jpc_mqstates[86], &jpc_mqstates[80]},
+    {0x0015, 0, &jpc_mqstates[86], &jpc_mqstates[80]},
-	{0x0015, 1, &jpc_mqstates[87], &jpc_mqstates[81]},
+    {0x0015, 1, &jpc_mqstates[87], &jpc_mqstates[81]},
-	{0x0009, 0, &jpc_mqstates[88], &jpc_mqstates[82]},
+    {0x0009, 0, &jpc_mqstates[88], &jpc_mqstates[82]},
-	{0x0009, 1, &jpc_mqstates[89], &jpc_mqstates[83]},
+    {0x0009, 1, &jpc_mqstates[89], &jpc_mqstates[83]},
-	{0x0005, 0, &jpc_mqstates[90], &jpc_mqstates[84]},
+    {0x0005, 0, &jpc_mqstates[90], &jpc_mqstates[84]},
-	{0x0005, 1, &jpc_mqstates[91], &jpc_mqstates[85]},
+    {0x0005, 1, &jpc_mqstates[91], &jpc_mqstates[85]},
-	{0x0001, 0, &jpc_mqstates[90], &jpc_mqstates[86]},
+    {0x0001, 0, &jpc_mqstates[90], &jpc_mqstates[86]},
-	{0x0001, 1, &jpc_mqstates[91], &jpc_mqstates[87]},
+    {0x0001, 1, &jpc_mqstates[91], &jpc_mqstates[87]},
-	{0x5601, 0, &jpc_mqstates[92], &jpc_mqstates[92]},
+    {0x5601, 0, &jpc_mqstates[92], &jpc_mqstates[92]},
-	{0x5601, 1, &jpc_mqstates[93], &jpc_mqstates[93]},
+    {0x5601, 1, &jpc_mqstates[93], &jpc_mqstates[93]},
 };

3rdparty/libjasper/jpc_mqcod.h

@@ -6,15 +6,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,
@@ -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__
  */
 
@@ -86,11 +86,11 @@
 
 typedef struct {
 
-	/* The most probable symbol (MPS). */
+    /* The most probable symbol (MPS). */
-	int mps;
+    int mps;
 
-	/* The state index. */
+    /* The state index. */
-	int_fast16_t ind;
+    int_fast16_t ind;
 
 } jpc_mqctx_t;
 
@@ -100,17 +100,17 @@ typedef struct {
 
 typedef struct jpc_mqstate_s {
 
-	/* The Qe value. */
+    /* The Qe value. */
-	uint_fast16_t qeval;
+    uint_fast16_t qeval;
 
-	/* The MPS. */
+    /* The MPS. */
-	int mps;
+    int mps;
 
-	/* The NMPS state. */
+    /* The NMPS state. */
-	struct jpc_mqstate_s *nmps;
+    struct jpc_mqstate_s *nmps;
 
-	/* The NLPS state. */
+    /* The NLPS state. */
-	struct jpc_mqstate_s *nlps;
+    struct jpc_mqstate_s *nlps;
 
 } jpc_mqstate_t;
 

3rdparty/libjasper/jpc_mqdec.c

@@ -6,15 +6,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,
@@ -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__
  */
 
@@ -88,7 +88,7 @@
 
 #if defined(DEBUG)
 #define	MQDEC_CALL(n, x) \
-	((jas_getdbglevel() >= (n)) ? ((void)(x)) : ((void)0))
+    ((jas_getdbglevel() >= (n)) ? ((void)(x)) : ((void)0))
 #else
 #define	MQDEC_CALL(n, x)
 #endif
@@ -106,49 +106,49 @@ static void jpc_mqdec_bytein(jpc_mqdec_t *mqdec);
 /* Create a MQ decoder. */
 jpc_mqdec_t *jpc_mqdec_create(int maxctxs, jas_stream_t *in)
 {
-	jpc_mqdec_t *mqdec;
+    jpc_mqdec_t *mqdec;
 
-	/* There must be at least one context. */
+    /* There must be at least one context. */
-	assert(maxctxs > 0);
+    assert(maxctxs > 0);
 
-	/* Allocate memory for the MQ decoder. */
+    /* Allocate memory for the MQ decoder. */
-	if (!(mqdec = jas_malloc(sizeof(jpc_mqdec_t)))) {
+    if (!(mqdec = jas_malloc(sizeof(jpc_mqdec_t)))) {
-		goto error;
+        goto error;
-	}
+    }
-	mqdec->in = in;
+    mqdec->in = in;
-	mqdec->maxctxs = maxctxs;
+    mqdec->maxctxs = maxctxs;
-	/* Allocate memory for the per-context state information. */
+    /* Allocate memory for the per-context state information. */
-	if (!(mqdec->ctxs = jas_alloc2(mqdec->maxctxs, sizeof(jpc_mqstate_t *)))) {
+    if (!(mqdec->ctxs = jas_alloc2(mqdec->maxctxs, sizeof(jpc_mqstate_t *)))) {
-		goto error;
+        goto error;
-	}
+    }
-	/* Set the current context to the first context. */
+    /* Set the current context to the first context. */
-	mqdec->curctx = mqdec->ctxs;
+    mqdec->curctx = mqdec->ctxs;
 
-	/* If an input stream has been associated with the MQ decoder,
+    /* If an input stream has been associated with the MQ decoder,
-	  initialize the decoder state from the stream. */
+      initialize the decoder state from the stream. */
-	if (mqdec->in) {
+    if (mqdec->in) {
-		jpc_mqdec_init(mqdec);
+        jpc_mqdec_init(mqdec);
-	}
+    }
-	/* Initialize the per-context state information. */
+    /* Initialize the per-context state information. */
-	jpc_mqdec_setctxs(mqdec, 0, 0);
+    jpc_mqdec_setctxs(mqdec, 0, 0);
 
-	return mqdec;
+    return mqdec;
 
 error:
-	/* Oops...  Something has gone wrong. */
+    /* Oops...  Something has gone wrong. */
-	if (mqdec) {
+    if (mqdec) {
-		jpc_mqdec_destroy(mqdec);
+        jpc_mqdec_destroy(mqdec);
-	}
+    }
-	return 0;
+    return 0;
 }
 
 /* Destroy a MQ decoder. */
 void jpc_mqdec_destroy(jpc_mqdec_t *mqdec)
 {
-	if (mqdec->ctxs) {
+    if (mqdec->ctxs) {
-		jas_free(mqdec->ctxs);
+        jas_free(mqdec->ctxs);
-	}
+    }
-	jas_free(mqdec);
+    jas_free(mqdec);
 }
 
 /******************************************************************************\
@@ -159,59 +159,59 @@ void jpc_mqdec_destroy(jpc_mqdec_t *mqdec)
 
 void jpc_mqdec_init(jpc_mqdec_t *mqdec)
 {
-	int c;
+    int c;
 
-	mqdec->eof = 0;
+    mqdec->eof = 0;
-	mqdec->creg = 0;
+    mqdec->creg = 0;
-	/* Get the next byte from the input stream. */
+    /* Get the next byte from the input stream. */
-	if ((c = jas_stream_getc(mqdec->in)) == EOF) {
+    if ((c = jas_stream_getc(mqdec->in)) == EOF) {
-		/* We have encountered an I/O error or EOF. */
+        /* We have encountered an I/O error or EOF. */
-		c = 0xff;
+        c = 0xff;
-		mqdec->eof = 1;
+        mqdec->eof = 1;
-	}
+    }
-	mqdec->inbuffer = c;
+    mqdec->inbuffer = c;
-	mqdec->creg += mqdec->inbuffer << 16;
+    mqdec->creg += mqdec->inbuffer << 16;
-	jpc_mqdec_bytein(mqdec);
+    jpc_mqdec_bytein(mqdec);
-	mqdec->creg <<= 7;
+    mqdec->creg <<= 7;
-	mqdec->ctreg -= 7;
+    mqdec->ctreg -= 7;
-	mqdec->areg = 0x8000;
+    mqdec->areg = 0x8000;
 }
 
 /* Set the input stream for a MQ decoder. */
 
 void jpc_mqdec_setinput(jpc_mqdec_t *mqdec, jas_stream_t *in)
 {
-	mqdec->in = in;
+    mqdec->in = in;
 }
 
 /* Initialize one or more contexts. */
 
 void jpc_mqdec_setctxs(jpc_mqdec_t *mqdec, int numctxs, jpc_mqctx_t *ctxs)
 {
-	jpc_mqstate_t **ctx;
+    jpc_mqstate_t **ctx;
-	int n;
+    int n;
 
-	ctx = mqdec->ctxs;
+    ctx = mqdec->ctxs;
-	n = JAS_MIN(mqdec->maxctxs, numctxs);
+    n = JAS_MIN(mqdec->maxctxs, numctxs);
-	while (--n >= 0) {
+    while (--n >= 0) {
-		*ctx = &jpc_mqstates[2 * ctxs->ind + ctxs->mps];
+        *ctx = &jpc_mqstates[2 * ctxs->ind + ctxs->mps];
-		++ctx;
+        ++ctx;
-		++ctxs;
+        ++ctxs;
-	}
+    }
-	n = mqdec->maxctxs - numctxs;
+    n = mqdec->maxctxs - numctxs;
-	while (--n >= 0) {
+    while (--n >= 0) {
-		*ctx = &jpc_mqstates[0];
+        *ctx = &jpc_mqstates[0];
-		++ctx;
+        ++ctx;
-	}
+    }
 }
 
 /* Initialize a context. */
 
 void jpc_mqdec_setctx(jpc_mqdec_t *mqdec, int ctxno, jpc_mqctx_t *ctx)
 {
-	jpc_mqstate_t **ctxi;
+    jpc_mqstate_t **ctxi;
-	ctxi = &mqdec->ctxs[ctxno];
+    ctxi = &mqdec->ctxs[ctxno];
-	*ctxi = &jpc_mqstates[2 * ctx->ind + ctx->mps];
+    *ctxi = &jpc_mqstates[2 * ctx->ind + ctx->mps];
 }
 
 /******************************************************************************\
@@ -222,36 +222,36 @@ void jpc_mqdec_setctx(jpc_mqdec_t *mqdec, int ctxno, jpc_mqctx_t *ctx)
 
 int jpc_mqdec_getbit_func(register jpc_mqdec_t *mqdec)
 {
-	int bit;
+    int bit;
-	JAS_DBGLOG(100, ("jpc_mqdec_getbit_func(%p)\n", mqdec));
+    JAS_DBGLOG(100, ("jpc_mqdec_getbit_func(%p)\n", mqdec));
-	MQDEC_CALL(100, jpc_mqdec_dump(mqdec, stderr));
+    MQDEC_CALL(100, jpc_mqdec_dump(mqdec, stderr));
-	bit = jpc_mqdec_getbit_macro(mqdec);
+    bit = jpc_mqdec_getbit_macro(mqdec);
-	MQDEC_CALL(100, jpc_mqdec_dump(mqdec, stderr));
+    MQDEC_CALL(100, jpc_mqdec_dump(mqdec, stderr));
-	JAS_DBGLOG(100, ("ctx = %d, decoded %d\n", mqdec->curctx -
+    JAS_DBGLOG(100, ("ctx = %d, decoded %d\n", mqdec->curctx -
-	  mqdec->ctxs, bit));
+      mqdec->ctxs, bit));
-	return bit;
+    return bit;
 }
 
 /* Apply MPS_EXCHANGE algorithm (with RENORMD). */
 int jpc_mqdec_mpsexchrenormd(register jpc_mqdec_t *mqdec)
 {
-	int ret;
+    int ret;
-	register jpc_mqstate_t *state = *mqdec->curctx;
+    register jpc_mqstate_t *state = *mqdec->curctx;
-	jpc_mqdec_mpsexchange(mqdec->areg, state->qeval, mqdec->curctx, ret);
+    jpc_mqdec_mpsexchange(mqdec->areg, state->qeval, mqdec->curctx, ret);
-	jpc_mqdec_renormd(mqdec->areg, mqdec->creg, mqdec->ctreg, mqdec->in,
+    jpc_mqdec_renormd(mqdec->areg, mqdec->creg, mqdec->ctreg, mqdec->in,
-	  mqdec->eof, mqdec->inbuffer);
+      mqdec->eof, mqdec->inbuffer);
-	return ret;
+    return ret;
 }
 
 /* Apply LPS_EXCHANGE algorithm (with RENORMD). */
 int jpc_mqdec_lpsexchrenormd(register jpc_mqdec_t *mqdec)
 {
-	int ret;
+    int ret;
-	register jpc_mqstate_t *state = *mqdec->curctx;
+    register jpc_mqstate_t *state = *mqdec->curctx;
-	jpc_mqdec_lpsexchange(mqdec->areg, state->qeval, mqdec->curctx, ret);
+    jpc_mqdec_lpsexchange(mqdec->areg, state->qeval, mqdec->curctx, ret);
-	jpc_mqdec_renormd(mqdec->areg, mqdec->creg, mqdec->ctreg, mqdec->in,
+    jpc_mqdec_renormd(mqdec->areg, mqdec->creg, mqdec->ctreg, mqdec->in,
-	  mqdec->eof, mqdec->inbuffer);
+      mqdec->eof, mqdec->inbuffer);
-	return ret;
+    return ret;
 }
 
 /******************************************************************************\
@@ -261,32 +261,32 @@ int jpc_mqdec_lpsexchrenormd(register jpc_mqdec_t *mqdec)
 /* Apply the BYTEIN algorithm. */
 static void jpc_mqdec_bytein(jpc_mqdec_t *mqdec)
 {
-	int c;
+    int c;
-	unsigned char prevbuf;
+    unsigned char prevbuf;
 
-	if (!mqdec->eof) {
+    if (!mqdec->eof) {
-		if ((c = jas_stream_getc(mqdec->in)) == EOF) {
+        if ((c = jas_stream_getc(mqdec->in)) == EOF) {
-			mqdec->eof = 1;
+            mqdec->eof = 1;
-			c = 0xff;
+            c = 0xff;
-		}
+        }
-		prevbuf = mqdec->inbuffer;
+        prevbuf = mqdec->inbuffer;
-		mqdec->inbuffer = c;
+        mqdec->inbuffer = c;
-		if (prevbuf == 0xff) {
+        if (prevbuf == 0xff) {
-			if (c > 0x8f) {
+            if (c > 0x8f) {
-				mqdec->creg += 0xff00;
+                mqdec->creg += 0xff00;
-				mqdec->ctreg = 8;
+                mqdec->ctreg = 8;
-			} else {
+            } else {
-				mqdec->creg += c << 9;
+                mqdec->creg += c << 9;
-				mqdec->ctreg = 7;
+                mqdec->ctreg = 7;
-			}
+            }
-		} else {
+        } else {
-			mqdec->creg += c << 8;
+            mqdec->creg += c << 8;
-			mqdec->ctreg = 8;
+            mqdec->ctreg = 8;
-		}
+        }
-	} else {
+    } else {
-		mqdec->creg += 0xff00;
+        mqdec->creg += 0xff00;
-		mqdec->ctreg = 8;
+        mqdec->ctreg = 8;
-	}
+    }
 }
 
 /******************************************************************************\
@@ -297,10 +297,10 @@ static void jpc_mqdec_bytein(jpc_mqdec_t *mqdec)
 
 void jpc_mqdec_dump(jpc_mqdec_t *mqdec, FILE *out)
 {
-	fprintf(out, "MQDEC A = %08lx, C = %08lx, CT=%08lx, ",
+    fprintf(out, "MQDEC A = %08lx, C = %08lx, CT=%08lx, ",
-	  (unsigned long) mqdec->areg, (unsigned long) mqdec->creg,
+      (unsigned long) mqdec->areg, (unsigned long) mqdec->creg,
-	  (unsigned long) mqdec->ctreg);
+      (unsigned long) mqdec->ctreg);
-	fprintf(out, "CTX = %d, ", (int)(mqdec->curctx - mqdec->ctxs));
+    fprintf(out, "CTX = %d, ", (int)(mqdec->curctx - mqdec->ctxs));
-	fprintf(out, "IND %d, MPS %d, QEVAL %x\n", (int)(*mqdec->curctx -
+    fprintf(out, "IND %d, MPS %d, QEVAL %x\n", (int)(*mqdec->curctx -
-	  jpc_mqstates), (int)(*mqdec->curctx)->mps, (int)(*mqdec->curctx)->qeval);
+      jpc_mqstates), (int)(*mqdec->curctx)->mps, (int)(*mqdec->curctx)->qeval);
 }

3rdparty/libjasper/jpc_mqdec.h

@@ -6,15 +6,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,
@@ -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__
  */
 
@@ -87,32 +87,32 @@
 
 typedef struct {
 
-	/* The C register. */
+    /* The C register. */
-	uint_fast32_t creg;
+    uint_fast32_t creg;
 
-	/* The A register. */
+    /* The A register. */
-	uint_fast32_t areg;
+    uint_fast32_t areg;
 
-	/* The CT register. */
+    /* The CT register. */
-	uint_fast32_t ctreg;
+    uint_fast32_t ctreg;
 
-	/* The current context. */
+    /* The current context. */
-	jpc_mqstate_t **curctx;
+    jpc_mqstate_t **curctx;
 
-	/* The per-context information. */
+    /* The per-context information. */
-	jpc_mqstate_t **ctxs;
+    jpc_mqstate_t **ctxs;
 
-	/* The maximum number of contexts. */
+    /* The maximum number of contexts. */
-	int maxctxs;
+    int maxctxs;
 
-	/* The stream from which to read data. */
+    /* The stream from which to read data. */
-	jas_stream_t *in;
+    jas_stream_t *in;
 
-	/* The last character read. */
+    /* The last character read. */
-	uchar inbuffer;
+    uchar inbuffer;
 
-	/* The EOF indicator. */
+    /* The EOF indicator. */
-	int eof;
+    int eof;
 
 } jpc_mqdec_t;
 
@@ -142,7 +142,7 @@ void jpc_mqdec_init(jpc_mqdec_t *dec);
 
 /* Set the current context for a MQ decoder. */
 #define	jpc_mqdec_setcurctx(dec, ctxno) \
-	((mqdec)->curctx = &(mqdec)->ctxs[ctxno]);
+    ((mqdec)->curctx = &(mqdec)->ctxs[ctxno]);
 
 /* Set the state information for a particular context of a MQ decoder. */
 void jpc_mqdec_setctx(jpc_mqdec_t *dec, int ctxno, jpc_mqctx_t *ctx);
@@ -157,19 +157,19 @@ void jpc_mqdec_setctxs(jpc_mqdec_t *dec, int numctxs, jpc_mqctx_t *ctxs);
 /* Decode a symbol. */
 #if !defined(DEBUG)
 #define	jpc_mqdec_getbit(dec) \
-	jpc_mqdec_getbit_macro(dec)
+    jpc_mqdec_getbit_macro(dec)
 #else
 #define	jpc_mqdec_getbit(dec) \
-	jpc_mqdec_getbit_func(dec)
+    jpc_mqdec_getbit_func(dec)
 #endif
 
 /* Decode a symbol (assuming an unskewed probability distribution). */
 #if !defined(DEBUG)
 #define	jpc_mqdec_getbitnoskew(dec) \
-	jpc_mqdec_getbit_macro(dec)
+    jpc_mqdec_getbit_macro(dec)
 #else
 #define	jpc_mqdec_getbitnoskew(dec) \
-	jpc_mqdec_getbit_func(dec)
+    jpc_mqdec_getbit_func(dec)
 #endif
 
 /******************************************************************************\
@@ -186,82 +186,82 @@ void jpc_mqdec_dump(jpc_mqdec_t *dec, FILE *out);
 \******************************************************************************/
 
 #define	jpc_mqdec_getbit_macro(dec) \
-	((((dec)->areg -= (*(dec)->curctx)->qeval), \
+    ((((dec)->areg -= (*(dec)->curctx)->qeval), \
-	  (dec)->creg >> 16 >= (*(dec)->curctx)->qeval) ? \
+      (dec)->creg >> 16 >= (*(dec)->curctx)->qeval) ? \
-	  ((((dec)->creg -= (*(dec)->curctx)->qeval << 16), \
+      ((((dec)->creg -= (*(dec)->curctx)->qeval << 16), \
-	  (dec)->areg & 0x8000) ?  (*(dec)->curctx)->mps : \
+      (dec)->areg & 0x8000) ?  (*(dec)->curctx)->mps : \
-	  jpc_mqdec_mpsexchrenormd(dec)) : \
+      jpc_mqdec_mpsexchrenormd(dec)) : \
-	  jpc_mqdec_lpsexchrenormd(dec))
+      jpc_mqdec_lpsexchrenormd(dec))
 
 #define	jpc_mqdec_mpsexchange(areg, delta, curctx, bit) \
 { \
-	if ((areg) < (delta)) { \
+    if ((areg) < (delta)) { \
-		register jpc_mqstate_t *state = *(curctx); \
+        register jpc_mqstate_t *state = *(curctx); \
-		/* LPS decoded. */ \
+        /* LPS decoded. */ \
-		(bit) = state->mps ^ 1; \
+        (bit) = state->mps ^ 1; \
-		*(curctx) = state->nlps; \
+        *(curctx) = state->nlps; \
-	} else { \
+    } else { \
-		register jpc_mqstate_t *state = *(curctx); \
+        register jpc_mqstate_t *state = *(curctx); \
-		/* MPS decoded. */ \
+        /* MPS decoded. */ \
-		(bit) = state->mps; \
+        (bit) = state->mps; \
-		*(curctx) = state->nmps; \
+        *(curctx) = state->nmps; \
-	} \
+    } \
 }
 
 #define	jpc_mqdec_lpsexchange(areg, delta, curctx, bit) \
 { \
-	if ((areg) >= (delta)) { \
+    if ((areg) >= (delta)) { \
-		register jpc_mqstate_t *state = *(curctx); \
+        register jpc_mqstate_t *state = *(curctx); \
-		(areg) = (delta); \
+        (areg) = (delta); \
-		(bit) = state->mps ^ 1; \
+        (bit) = state->mps ^ 1; \
-		*(curctx) = state->nlps; \
+        *(curctx) = state->nlps; \
-	} else { \
+    } else { \
-		register jpc_mqstate_t *state = *(curctx); \
+        register jpc_mqstate_t *state = *(curctx); \
-		(areg) = (delta); \
+        (areg) = (delta); \
-		(bit) = state->mps; \
+        (bit) = state->mps; \
-		*(curctx) = state->nmps; \
+        *(curctx) = state->nmps; \
-	} \
+    } \
 }
 
 #define	jpc_mqdec_renormd(areg, creg, ctreg, in, eof, inbuf) \
 { \
-	do { \
+    do { \
-		if (!(ctreg)) { \
+        if (!(ctreg)) { \
-			jpc_mqdec_bytein2(creg, ctreg, in, eof, inbuf); \
+            jpc_mqdec_bytein2(creg, ctreg, in, eof, inbuf); \
-		} \
+        } \
-		(areg) <<= 1; \
+        (areg) <<= 1; \
-		(creg) <<= 1; \
+        (creg) <<= 1; \
-		--(ctreg); \
+        --(ctreg); \
-	} while (!((areg) & 0x8000)); \
+    } while (!((areg) & 0x8000)); \
 }
 
 #define	jpc_mqdec_bytein2(creg, ctreg, in, eof, inbuf) \
 { \
-	int c; \
+    int c; \
-	unsigned char prevbuf; \
+    unsigned char prevbuf; \
-	if (!(eof)) { \
+    if (!(eof)) { \
-		if ((c = jas_stream_getc(in)) == EOF) { \
+        if ((c = jas_stream_getc(in)) == EOF) { \
-			(eof) = 1; \
+            (eof) = 1; \
-			c = 0xff; \
+            c = 0xff; \
-		} \
+        } \
-		prevbuf = (inbuf); \
+        prevbuf = (inbuf); \
-		(inbuf) = c; \
+        (inbuf) = c; \
-		if (prevbuf == 0xff) { \
+        if (prevbuf == 0xff) { \
-			if (c > 0x8f) { \
+            if (c > 0x8f) { \
-				(creg) += 0xff00; \
+                (creg) += 0xff00; \
-				(ctreg) = 8; \
+                (ctreg) = 8; \
-			} else { \
+            } else { \
-				(creg) += c << 9; \
+                (creg) += c << 9; \
-				(ctreg) = 7; \
+                (ctreg) = 7; \
-			} \
+            } \
-		} else { \
+        } else { \
-			(creg) += c << 8; \
+            (creg) += c << 8; \
-			(ctreg) = 8; \
+            (ctreg) = 8; \
-		} \
+        } \
-	} else { \
+    } else { \
-		(creg) += 0xff00; \
+        (creg) += 0xff00; \
-		(ctreg) = 8; \
+        (ctreg) = 8; \
-	} \
+    } \
 }
 
 int jpc_mqdec_getbit_func(jpc_mqdec_t *dec);

3rdparty/libjasper/jpc_mqenc.c

@@ -6,15 +6,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,
@@ -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__
  */
 
@@ -87,90 +87,90 @@
 
 #if defined(DEBUG)
 #define	JPC_MQENC_CALL(n, x) \
-	((jas_getdbglevel() >= (n)) ? ((void)(x)) : ((void)0))
+    ((jas_getdbglevel() >= (n)) ? ((void)(x)) : ((void)0))
 #else
 #define	JPC_MQENC_CALL(n, x)
 #endif
 
 #define	jpc_mqenc_codemps9(areg, creg, ctreg, curctx, enc) \
 { \
-	jpc_mqstate_t *state = *(curctx); \
+    jpc_mqstate_t *state = *(curctx); \
-	(areg) -= state->qeval; \
+    (areg) -= state->qeval; \
-	if (!((areg) & 0x8000)) { \
+    if (!((areg) & 0x8000)) { \
-		if ((areg) < state->qeval) { \
+        if ((areg) < state->qeval) { \
-			(areg) = state->qeval; \
+            (areg) = state->qeval; \
-		} else { \
+        } else { \
-			(creg) += state->qeval; \
+            (creg) += state->qeval; \
-		} \
+        } \
-		*(curctx) = state->nmps; \
+        *(curctx) = state->nmps; \
-		jpc_mqenc_renorme((areg), (creg), (ctreg), (enc)); \
+        jpc_mqenc_renorme((areg), (creg), (ctreg), (enc)); \
-	} else { \
+    } else { \
-		(creg) += state->qeval; \
+        (creg) += state->qeval; \
-	} \
+    } \
 }
 
 #define	jpc_mqenc_codelps2(areg, creg, ctreg, curctx, enc) \
 { \
-	jpc_mqstate_t *state = *(curctx); \
+    jpc_mqstate_t *state = *(curctx); \
-	(areg) -= state->qeval; \
+    (areg) -= state->qeval; \
-	if ((areg) < state->qeval) { \
+    if ((areg) < state->qeval) { \
-		(creg) += state->qeval; \
+        (creg) += state->qeval; \
-	} else { \
+    } else { \
-		(areg) = state->qeval; \
+        (areg) = state->qeval; \
-	} \
+    } \
-	*(curctx) = state->nlps; \
+    *(curctx) = state->nlps; \
-	jpc_mqenc_renorme((areg), (creg), (ctreg), (enc)); \
+    jpc_mqenc_renorme((areg), (creg), (ctreg), (enc)); \
 }
 
 #define	jpc_mqenc_renorme(areg, creg, ctreg, enc) \
 { \
-	do { \
+    do { \
-		(areg) <<= 1; \
+        (areg) <<= 1; \
-		(creg) <<= 1; \
+        (creg) <<= 1; \
-		if (!--(ctreg)) { \
+        if (!--(ctreg)) { \
-			jpc_mqenc_byteout((areg), (creg), (ctreg), (enc)); \
+            jpc_mqenc_byteout((areg), (creg), (ctreg), (enc)); \
-		} \
+        } \
-	} while (!((areg) & 0x8000)); \
+    } while (!((areg) & 0x8000)); \
 }
 
 #define	jpc_mqenc_byteout(areg, creg, ctreg, enc) \
 { \
-	if ((enc)->outbuf != 0xff) { \
+    if ((enc)->outbuf != 0xff) { \
-		if ((creg) & 0x8000000) { \
+        if ((creg) & 0x8000000) { \
-			if (++((enc)->outbuf) == 0xff) { \
+            if (++((enc)->outbuf) == 0xff) { \
-				(creg) &= 0x7ffffff; \
+                (creg) &= 0x7ffffff; \
-				jpc_mqenc_byteout2(enc); \
+                jpc_mqenc_byteout2(enc); \
-				enc->outbuf = ((creg) >> 20) & 0xff; \
+                enc->outbuf = ((creg) >> 20) & 0xff; \
-				(creg) &= 0xfffff; \
+                (creg) &= 0xfffff; \
-				(ctreg) = 7; \
+                (ctreg) = 7; \
-			} else { \
+            } else { \
-				jpc_mqenc_byteout2(enc); \
+                jpc_mqenc_byteout2(enc); \
-				enc->outbuf = ((creg) >> 19) & 0xff; \
+                enc->outbuf = ((creg) >> 19) & 0xff; \
-				(creg) &= 0x7ffff; \
+                (creg) &= 0x7ffff; \
-				(ctreg) = 8; \
+                (ctreg) = 8; \
-			} \
+            } \
-		} else { \
+        } else { \
-			jpc_mqenc_byteout2(enc); \
+            jpc_mqenc_byteout2(enc); \
-			(enc)->outbuf = ((creg) >> 19) & 0xff; \
+            (enc)->outbuf = ((creg) >> 19) & 0xff; \
-			(creg) &= 0x7ffff; \
+            (creg) &= 0x7ffff; \
-			(ctreg) = 8; \
+            (ctreg) = 8; \
-		} \
+        } \
-	} else { \
+    } else { \
-		jpc_mqenc_byteout2(enc); \
+        jpc_mqenc_byteout2(enc); \
-		(enc)->outbuf = ((creg) >> 20) & 0xff; \
+        (enc)->outbuf = ((creg) >> 20) & 0xff; \
-		(creg) &= 0xfffff; \
+        (creg) &= 0xfffff; \
-		(ctreg) = 7; \
+        (ctreg) = 7; \
-	} \
+    } \
 }
 
 #define	jpc_mqenc_byteout2(enc) \
 { \
-	if (enc->outbuf >= 0) { \
+    if (enc->outbuf >= 0) { \
-		if (jas_stream_putc(enc->out, (unsigned char)enc->outbuf) == EOF) { \
+        if (jas_stream_putc(enc->out, (unsigned char)enc->outbuf) == EOF) { \
-			enc->err |= 1; \
+            enc->err |= 1; \
-		} \
+        } \
-	} \
+    } \
-	enc->lastbyte = enc->outbuf; \
+    enc->lastbyte = enc->outbuf; \
 }
 
 /******************************************************************************\
@@ -187,45 +187,45 @@ static void jpc_mqenc_setbits(jpc_mqenc_t *mqenc);
 
 jpc_mqenc_t *jpc_mqenc_create(int maxctxs, jas_stream_t *out)
 {
-	jpc_mqenc_t *mqenc;
+    jpc_mqenc_t *mqenc;
 
-	/* Allocate memory for the MQ encoder. */
+    /* Allocate memory for the MQ encoder. */
-	if (!(mqenc = jas_malloc(sizeof(jpc_mqenc_t)))) {
+    if (!(mqenc = jas_malloc(sizeof(jpc_mqenc_t)))) {
-		goto error;
+        goto error;
-	}
+    }
-	mqenc->out = out;
+    mqenc->out = out;
-	mqenc->maxctxs = maxctxs;
+    mqenc->maxctxs = maxctxs;
 
-	/* Allocate memory for the per-context state information. */
+    /* Allocate memory for the per-context state information. */
-	if (!(mqenc->ctxs = jas_alloc2(mqenc->maxctxs, sizeof(jpc_mqstate_t *)))) {
+    if (!(mqenc->ctxs = jas_alloc2(mqenc->maxctxs, sizeof(jpc_mqstate_t *)))) {
-		goto error;
+        goto error;
-	}
+    }
 
-	/* Set the current context to the first one. */
+    /* Set the current context to the first one. */
-	mqenc->curctx = mqenc->ctxs;
+    mqenc->curctx = mqenc->ctxs;
 
-	jpc_mqenc_init(mqenc);
+    jpc_mqenc_init(mqenc);
 
-	/* Initialize the per-context state information to something sane. */
+    /* Initialize the per-context state information to something sane. */
-	jpc_mqenc_setctxs(mqenc, 0, 0);
+    jpc_mqenc_setctxs(mqenc, 0, 0);
 
-	return mqenc;
+    return mqenc;
 
 error:
-	if (mqenc) {
+    if (mqenc) {
-		jpc_mqenc_destroy(mqenc);
+        jpc_mqenc_destroy(mqenc);
-	}
+    }
-	return 0;
+    return 0;
 }
 
 /* Destroy a MQ encoder. */
 
 void jpc_mqenc_destroy(jpc_mqenc_t *mqenc)
 {
-	if (mqenc->ctxs) {
+    if (mqenc->ctxs) {
-		jas_free(mqenc->ctxs);
+        jas_free(mqenc->ctxs);
-	}
+    }
-	jas_free(mqenc);
+    jas_free(mqenc);
 }
 
 /******************************************************************************\
@@ -236,33 +236,33 @@ void jpc_mqenc_destroy(jpc_mqenc_t *mqenc)
 
 void jpc_mqenc_init(jpc_mqenc_t *mqenc)
 {
-	mqenc->areg = 0x8000;
+    mqenc->areg = 0x8000;
-	mqenc->outbuf = -1;
+    mqenc->outbuf = -1;
-	mqenc->creg = 0;
+    mqenc->creg = 0;
-	mqenc->ctreg = 12;
+    mqenc->ctreg = 12;
-	mqenc->lastbyte = -1;
+    mqenc->lastbyte = -1;
-	mqenc->err = 0;
+    mqenc->err = 0;
 }
 
 /* Initialize one or more contexts. */
 
 void jpc_mqenc_setctxs(jpc_mqenc_t *mqenc, int numctxs, jpc_mqctx_t *ctxs)
 {
-	jpc_mqstate_t **ctx;
+    jpc_mqstate_t **ctx;
-	int n;
+    int n;
 
-	ctx = mqenc->ctxs;
+    ctx = mqenc->ctxs;
-	n = JAS_MIN(mqenc->maxctxs, numctxs);
+    n = JAS_MIN(mqenc->maxctxs, numctxs);
-	while (--n >= 0) {
+    while (--n >= 0) {
-		*ctx = &jpc_mqstates[2 * ctxs->ind + ctxs->mps];
+        *ctx = &jpc_mqstates[2 * ctxs->ind + ctxs->mps];
-		++ctx;
+        ++ctx;
-		++ctxs;
+        ++ctxs;
-	}
+    }
-	n = mqenc->maxctxs - numctxs;
+    n = mqenc->maxctxs - numctxs;
-	while (--n >= 0) {
+    while (--n >= 0) {
-		*ctx = &jpc_mqstates[0];
+        *ctx = &jpc_mqstates[0];
-		++ctx;
+        ++ctx;
-	}
+    }
 
 }
 
@@ -270,10 +270,10 @@ void jpc_mqenc_setctxs(jpc_mqenc_t *mqenc, int numctxs, jpc_mqctx_t *ctxs)
 
 void jpc_mqenc_getstate(jpc_mqenc_t *mqenc, jpc_mqencstate_t *state)
 {
-	state->areg = mqenc->areg;
+    state->areg = mqenc->areg;
-	state->creg = mqenc->creg;
+    state->creg = mqenc->creg;
-	state->ctreg = mqenc->ctreg;
+    state->ctreg = mqenc->ctreg;
-	state->lastbyte = mqenc->lastbyte;
+    state->lastbyte = mqenc->lastbyte;
 }
 
 /******************************************************************************\
@@ -284,49 +284,49 @@ void jpc_mqenc_getstate(jpc_mqenc_t *mqenc, jpc_mqencstate_t *state)
 
 int jpc_mqenc_putbit_func(jpc_mqenc_t *mqenc, int bit)
 {
-	const jpc_mqstate_t *state;
+    const jpc_mqstate_t *state;
-	JAS_DBGLOG(100, ("jpc_mqenc_putbit(%p, %d)\n", mqenc, bit));
+    JAS_DBGLOG(100, ("jpc_mqenc_putbit(%p, %d)\n", mqenc, bit));
-	JPC_MQENC_CALL(100, jpc_mqenc_dump(mqenc, stderr));
+    JPC_MQENC_CALL(100, jpc_mqenc_dump(mqenc, stderr));
 
-	state = *(mqenc->curctx);
+    state = *(mqenc->curctx);
 
-	if (state->mps == bit) {
+    if (state->mps == bit) {
-		/* Apply the CODEMPS algorithm as defined in the standard. */
+        /* Apply the CODEMPS algorithm as defined in the standard. */
-		mqenc->areg -= state->qeval;
+        mqenc->areg -= state->qeval;
-		if (!(mqenc->areg & 0x8000)) {
+        if (!(mqenc->areg & 0x8000)) {
-			jpc_mqenc_codemps2(mqenc);
+            jpc_mqenc_codemps2(mqenc);
-		} else {
+        } else {
-			mqenc->creg += state->qeval;
+            mqenc->creg += state->qeval;
-		}
+        }
-	} else {
+    } else {
-		/* Apply the CODELPS algorithm as defined in the standard. */
+        /* Apply the CODELPS algorithm as defined in the standard. */
-		jpc_mqenc_codelps2(mqenc->areg, mqenc->creg, mqenc->ctreg, mqenc->curctx, mqenc);
+        jpc_mqenc_codelps2(mqenc->areg, mqenc->creg, mqenc->ctreg, mqenc->curctx, mqenc);
-	}
+    }
 
-	return jpc_mqenc_error(mqenc) ? (-1) : 0;
+    return jpc_mqenc_error(mqenc) ? (-1) : 0;
 }
 
 int jpc_mqenc_codemps2(jpc_mqenc_t *mqenc)
 {
-	/* Note: This function only performs part of the work associated with
+    /* Note: This function only performs part of the work associated with
-	the CODEMPS algorithm from the standard.  Some of the work is also
+    the CODEMPS algorithm from the standard.  Some of the work is also
-	performed by the caller. */
+    performed by the caller. */
 
-	jpc_mqstate_t *state = *(mqenc->curctx);
+    jpc_mqstate_t *state = *(mqenc->curctx);
-	if (mqenc->areg < state->qeval) {
+    if (mqenc->areg < state->qeval) {
-		mqenc->areg = state->qeval;
+        mqenc->areg = state->qeval;
-	} else {
+    } else {
-		mqenc->creg += state->qeval;
+        mqenc->creg += state->qeval;
-	}
+    }
-	*mqenc->curctx = state->nmps;
+    *mqenc->curctx = state->nmps;
-	jpc_mqenc_renorme(mqenc->areg, mqenc->creg, mqenc->ctreg, mqenc);
+    jpc_mqenc_renorme(mqenc->areg, mqenc->creg, mqenc->ctreg, mqenc);
-	return jpc_mqenc_error(mqenc) ? (-1) : 0;
+    return jpc_mqenc_error(mqenc) ? (-1) : 0;
 }
 
 int jpc_mqenc_codelps(jpc_mqenc_t *mqenc)
 {
-	jpc_mqenc_codelps2(mqenc->areg, mqenc->creg, mqenc->ctreg, mqenc->curctx, mqenc);
+    jpc_mqenc_codelps2(mqenc->areg, mqenc->creg, mqenc->ctreg, mqenc->curctx, mqenc);
-	return jpc_mqenc_error(mqenc) ? (-1) : 0;
+    return jpc_mqenc_error(mqenc) ? (-1) : 0;
 }
 
 /******************************************************************************\
@@ -337,56 +337,56 @@ int jpc_mqenc_codelps(jpc_mqenc_t *mqenc)
 
 int jpc_mqenc_flush(jpc_mqenc_t *mqenc, int termmode)
 {
-	int_fast16_t k;
+    int_fast16_t k;
 
-	switch (termmode) {
+    switch (termmode) {
-	case JPC_MQENC_PTERM:
+    case JPC_MQENC_PTERM:
-		k = 11 - mqenc->ctreg + 1;
+        k = 11 - mqenc->ctreg + 1;
-		while (k > 0) {
+        while (k > 0) {
-			mqenc->creg <<= mqenc->ctreg;
+            mqenc->creg <<= mqenc->ctreg;
-			mqenc->ctreg = 0;
+            mqenc->ctreg = 0;
-			jpc_mqenc_byteout(mqenc->areg, mqenc->creg, mqenc->ctreg,
+            jpc_mqenc_byteout(mqenc->areg, mqenc->creg, mqenc->ctreg,
-			  mqenc);
+              mqenc);
-			k -= mqenc->ctreg;
+            k -= mqenc->ctreg;
-		}
+        }
-		if (mqenc->outbuf != 0xff) {
+        if (mqenc->outbuf != 0xff) {
-			jpc_mqenc_byteout(mqenc->areg, mqenc->creg, mqenc->ctreg, mqenc);
+            jpc_mqenc_byteout(mqenc->areg, mqenc->creg, mqenc->ctreg, mqenc);
-		}
+        }
-		break;
+        break;
-	case JPC_MQENC_DEFTERM:
+    case JPC_MQENC_DEFTERM:
-		jpc_mqenc_setbits(mqenc);
+        jpc_mqenc_setbits(mqenc);
-		mqenc->creg <<= mqenc->ctreg;
+        mqenc->creg <<= mqenc->ctreg;
-		jpc_mqenc_byteout(mqenc->areg, mqenc->creg, mqenc->ctreg, mqenc);
+        jpc_mqenc_byteout(mqenc->areg, mqenc->creg, mqenc->ctreg, mqenc);
-		mqenc->creg <<= mqenc->ctreg;
+        mqenc->creg <<= mqenc->ctreg;
-		jpc_mqenc_byteout(mqenc->areg, mqenc->creg, mqenc->ctreg, mqenc);
+        jpc_mqenc_byteout(mqenc->areg, mqenc->creg, mqenc->ctreg, mqenc);
-		if (mqenc->outbuf != 0xff) {
+        if (mqenc->outbuf != 0xff) {
-			jpc_mqenc_byteout(mqenc->areg, mqenc->creg, mqenc->ctreg, mqenc);
+            jpc_mqenc_byteout(mqenc->areg, mqenc->creg, mqenc->ctreg, mqenc);
-		}
+        }
-		break;
+        break;
-	default:
+    default:
-		abort();
+        abort();
-		break;
+        break;
-	}
+    }
-	return 0;
+    return 0;
 }
 
 static void jpc_mqenc_setbits(jpc_mqenc_t *mqenc)
 {
-	uint_fast32_t tmp = mqenc->creg + mqenc->areg;
+    uint_fast32_t tmp = mqenc->creg + mqenc->areg;
-	mqenc->creg |= 0xffff;
+    mqenc->creg |= 0xffff;
-	if (mqenc->creg >= tmp) {
+    if (mqenc->creg >= tmp) {
-		mqenc->creg -= 0x8000;
+        mqenc->creg -= 0x8000;
-	}
+    }
 }
 
 /* Dump a MQ encoder to a stream for debugging. */
 
 int jpc_mqenc_dump(jpc_mqenc_t *mqenc, FILE *out)
 {
-	fprintf(out, "AREG = %08x, CREG = %08x, CTREG = %d\n",
+    fprintf(out, "AREG = %08x, CREG = %08x, CTREG = %d\n",
-	  (unsigned)mqenc->areg, (unsigned)mqenc->creg, (int)mqenc->ctreg);
+      (unsigned)mqenc->areg, (unsigned)mqenc->creg, (int)mqenc->ctreg);
-	fprintf(out, "IND = %02d, MPS = %d, QEVAL = %04x\n",
+    fprintf(out, "IND = %02d, MPS = %d, QEVAL = %04x\n",
-	  (int)(*mqenc->curctx - jpc_mqstates), (int)(*mqenc->curctx)->mps,
+      (int)(*mqenc->curctx - jpc_mqstates), (int)(*mqenc->curctx)->mps,
-	  (int)(*mqenc->curctx)->qeval);
+      (int)(*mqenc->curctx)->qeval);
-	return 0;
+    return 0;
 }

3rdparty/libjasper/jpc_mqenc.h

@@ -6,15 +6,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,
@@ -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__
  */
 
@@ -98,53 +98,53 @@
 
 typedef struct {
 
-	/* The C register. */
+    /* The C register. */
-	uint_fast32_t creg;
+    uint_fast32_t creg;
 
-	/* The A register. */
+    /* The A register. */
-	uint_fast32_t areg;
+    uint_fast32_t areg;
 
-	/* The CT register. */
+    /* The CT register. */
-	uint_fast32_t ctreg;
+    uint_fast32_t ctreg;
 
-	/* The maximum number of contexts. */
+    /* The maximum number of contexts. */
-	int maxctxs;
+    int maxctxs;
 
-	/* The per-context information. */
+    /* The per-context information. */
-	jpc_mqstate_t **ctxs;
+    jpc_mqstate_t **ctxs;
 
-	/* The current context. */
+    /* The current context. */
-	jpc_mqstate_t **curctx;
+    jpc_mqstate_t **curctx;
 
-	/* The stream for encoder output. */
+    /* The stream for encoder output. */
-	jas_stream_t *out;
+    jas_stream_t *out;
 
-	/* The byte buffer (i.e., the B variable in the standard). */
+    /* The byte buffer (i.e., the B variable in the standard). */
-	int_fast16_t outbuf;
+    int_fast16_t outbuf;
 
-	/* The last byte output. */
+    /* The last byte output. */
-	int_fast16_t lastbyte;
+    int_fast16_t lastbyte;
+
+    /* The error indicator. */
+    int err;
 
-	/* The error indicator. */
-	int err;
-	
 } jpc_mqenc_t;
 
 /* MQ arithmetic encoder state information. */
 
 typedef struct {
 
-	/* The A register. */
+    /* The A register. */
-	unsigned areg;
+    unsigned areg;
 
-	/* The C register. */
+    /* The C register. */
-	unsigned creg;
+    unsigned creg;
 
-	/* The CT register. */
+    /* The CT register. */
-	unsigned ctreg;
+    unsigned ctreg;
 
-	/* The last byte output by the encoder. */
+    /* The last byte output by the encoder. */
-	int lastbyte;
+    int lastbyte;
 
 } jpc_mqencstate_t;
 
@@ -185,7 +185,7 @@ void jpc_mqenc_setctxs(jpc_mqenc_t *enc, int numctxs, jpc_mqctx_t *ctxs);
 
 /* Get the error state of a MQ encoder. */
 #define	jpc_mqenc_error(enc) \
-	((enc)->err)
+    ((enc)->err)
 
 /* Get the current encoder state. */
 void jpc_mqenc_getstate(jpc_mqenc_t *enc, jpc_mqencstate_t *state);
@@ -217,11 +217,11 @@ int jpc_mqenc_dump(jpc_mqenc_t *mqenc, FILE *out);
 /* Note: This macro is included only to satisfy the needs of
   the mqenc_putbit macro. */
 #define	jpc_mqenc_putbit_macro(enc, bit) \
-	(((*((enc)->curctx))->mps == (bit)) ? \
+    (((*((enc)->curctx))->mps == (bit)) ? \
-	  (((enc)->areg -= (*(enc)->curctx)->qeval), \
+      (((enc)->areg -= (*(enc)->curctx)->qeval), \
-	  ((!((enc)->areg & 0x8000)) ? (jpc_mqenc_codemps2(enc)) : \
+      ((!((enc)->areg & 0x8000)) ? (jpc_mqenc_codemps2(enc)) : \
-	  ((enc)->creg += (*(enc)->curctx)->qeval))) : \
+      ((enc)->creg += (*(enc)->curctx)->qeval))) : \
-	  jpc_mqenc_codelps(enc))
+      jpc_mqenc_codelps(enc))
 
 /* Note: These function prototypes are included only to satisfy the
   needs of the mqenc_putbit_macro macro.  Do not call any of these

3rdparty/libjasper/jpc_qmfb.h

@@ -6,15 +6,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,
@@ -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__
  */
 
@@ -101,10 +101,10 @@ any particular platform.  Hopefully, it is not too unreasonable, however. */
 #endif
 
 typedef struct {
-	int (*analyze)(int *, int, int, int, int, int);
+    int (*analyze)(int *, int, int, int, int, int);
-	int (*synthesize)(int *, int, int, int, int, int);
+    int (*synthesize)(int *, int, int, int, int, int);
-	double *lpenergywts;
+    double *lpenergywts;
-	double *hpenergywts;
+    double *hpenergywts;
 } jpc_qmfb2d_t;
 
 extern jpc_qmfb2d_t jpc_ft_qmfb2d;

3rdparty/libjasper/jpc_t1cod.c

@@ -6,15 +6,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,
@@ -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__
  */
 
@@ -114,49 +114,49 @@ void jpc_initmqctxs(void);
 
 int JPC_PASSTYPE(int passno)
 {
-	int passtype;
+    int passtype;
-	switch (passno % 3) {
+    switch (passno % 3) {
-	case 0:
+    case 0:
-		passtype = JPC_CLNPASS;
+        passtype = JPC_CLNPASS;
-		break;
+        break;
-	case 1:
+    case 1:
-		passtype = JPC_SIGPASS;
+        passtype = JPC_SIGPASS;
-		break;
+        break;
-	case 2:
+    case 2:
-		passtype = JPC_REFPASS;
+        passtype = JPC_REFPASS;
-		break;
+        break;
-	default:
+    default:
-		passtype = -1;
+        passtype = -1;
-		assert(0);
+        assert(0);
-		break;
+        break;
-	}
+    }
-	return passtype;
+    return passtype;
 }
 
 int JPC_NOMINALGAIN(int qmfbid, int numlvls, int lvlno, int orient)
 {
-	/* Avoid compiler warnings about unused parameters. */
+    /* Avoid compiler warnings about unused parameters. */
-	numlvls = 0;
+    numlvls = 0;
 
 if (qmfbid == JPC_COX_INS) {
-	return 0;
+    return 0;
 }
-	assert(qmfbid == JPC_COX_RFT);
+    assert(qmfbid == JPC_COX_RFT);
-	if (lvlno == 0) {
+    if (lvlno == 0) {
-		assert(orient == JPC_TSFB_LL);
+        assert(orient == JPC_TSFB_LL);
-		return 0;
+        return 0;
-	} else {
+    } else {
-		switch (orient) {
+        switch (orient) {
-		case JPC_TSFB_LH:
+        case JPC_TSFB_LH:
-		case JPC_TSFB_HL:
+        case JPC_TSFB_HL:
-			return 1;
+            return 1;
-			break;
+            break;
-		case JPC_TSFB_HH:
+        case JPC_TSFB_HH:
-			return 2;
+            return 2;
-			break;
+            break;
-		}
+        }
-	}
+    }
-	abort();
+    abort();
 }
 
 /******************************************************************************\
@@ -165,66 +165,66 @@ if (qmfbid == JPC_COX_INS) {
 
 int JPC_SEGTYPE(int passno, int firstpassno, int bypass)
 {
-	int passtype;
+    int passtype;
-	if (bypass) {
+    if (bypass) {
-		passtype = JPC_PASSTYPE(passno);
+        passtype = JPC_PASSTYPE(passno);
-		if (passtype == JPC_CLNPASS) {
+        if (passtype == JPC_CLNPASS) {
-			return JPC_SEG_MQ;
+            return JPC_SEG_MQ;
-		}
+        }
-		return ((passno < firstpassno + 10) ? JPC_SEG_MQ : JPC_SEG_RAW);
+        return ((passno < firstpassno + 10) ? JPC_SEG_MQ : JPC_SEG_RAW);
-	} else {
+    } else {
-		return JPC_SEG_MQ;
+        return JPC_SEG_MQ;
-	}
+    }
 }
 
 int JPC_SEGPASSCNT(int passno, int firstpassno, int numpasses, int bypass, int termall)
 {
-	int ret;
+    int ret;
-	int passtype;
+    int passtype;
 
-	if (termall) {
+    if (termall) {
-		ret = 1;
+        ret = 1;
-	} else if (bypass) {
+    } else if (bypass) {
-		if (passno < firstpassno + 10) {
+        if (passno < firstpassno + 10) {
-			ret = 10 - (passno - firstpassno);
+            ret = 10 - (passno - firstpassno);
-		} else {
+        } else {
-			passtype = JPC_PASSTYPE(passno);
+            passtype = JPC_PASSTYPE(passno);
-			switch (passtype) {
+            switch (passtype) {
-			case JPC_SIGPASS:
+            case JPC_SIGPASS:
-				ret = 2;
+                ret = 2;
-				break;
+                break;
-			case JPC_REFPASS:
+            case JPC_REFPASS:
-				ret = 1;
+                ret = 1;
-				break;
+                break;
-			case JPC_CLNPASS:
+            case JPC_CLNPASS:
-				ret = 1;
+                ret = 1;
-				break;
+                break;
-			default:
+            default:
-				ret = -1;
+                ret = -1;
-				assert(0);
+                assert(0);
-				break;
+                break;
-			}
+            }
-		}
+        }
-	} else {
+    } else {
-		ret = JPC_PREC * 3 - 2;
+        ret = JPC_PREC * 3 - 2;
-	}
+    }
-	ret = JAS_MIN(ret, numpasses - passno);
+    ret = JAS_MIN(ret, numpasses - passno);
-	return ret;
+    return ret;
 }
 
 int JPC_ISTERMINATED(int passno, int firstpassno, int numpasses, int termall,
   int lazy)
 {
-	int ret;
+    int ret;
-	int n;
+    int n;
-	if (passno - firstpassno == numpasses - 1) {
+    if (passno - firstpassno == numpasses - 1) {
-		ret = 1;
+        ret = 1;
-	} else {
+    } else {
-		n = JPC_SEGPASSCNT(passno, firstpassno, numpasses, lazy, termall);
+        n = JPC_SEGPASSCNT(passno, firstpassno, numpasses, lazy, termall);
-		ret = (n <= 1) ? 1 : 0;
+        ret = (n <= 1) ? 1 : 0;
-	}
+    }
 
-	return ret;
+    return ret;
 }
 
 /******************************************************************************\
@@ -233,265 +233,265 @@ int JPC_ISTERMINATED(int passno, int firstpassno, int numpasses, int termall,
 
 void jpc_initluts()
 {
-	int i;
+    int i;
-	int orient;
+    int orient;
-	int refine;
+    int refine;
-	float u;
+    float u;
-	float v;
+    float v;
-	float t;
+    float t;
 
 /* XXX - hack */
 jpc_initmqctxs();
 
-	for (orient = 0; orient < 4; ++orient) {
+    for (orient = 0; orient < 4; ++orient) {
-		for (i = 0; i < 256; ++i) {
+        for (i = 0; i < 256; ++i) {
-			jpc_zcctxnolut[(orient << 8) | i] = jpc_getzcctxno(i, orient);
+            jpc_zcctxnolut[(orient << 8) | i] = jpc_getzcctxno(i, orient);
-		}
+        }
-	}
+    }
 
-	for (i = 0; i < 256; ++i) {
+    for (i = 0; i < 256; ++i) {
-		jpc_spblut[i] = jpc_getspb(i << 4);
+        jpc_spblut[i] = jpc_getspb(i << 4);
-	}
+    }
 
-	for (i = 0; i < 256; ++i) {
+    for (i = 0; i < 256; ++i) {
-		jpc_scctxnolut[i] = jpc_getscctxno(i << 4);
+        jpc_scctxnolut[i] = jpc_getscctxno(i << 4);
-	}
+    }
 
-	for (refine = 0; refine < 2; ++refine) {
+    for (refine = 0; refine < 2; ++refine) {
-		for (i = 0; i < 2048; ++i) {
+        for (i = 0; i < 2048; ++i) {
-			jpc_magctxnolut[(refine << 11) + i] = jpc_getmagctxno((refine ? JPC_REFINE : 0) | i);
+            jpc_magctxnolut[(refine << 11) + i] = jpc_getmagctxno((refine ? JPC_REFINE : 0) | i);
-		}
+        }
-	}
+    }
 
-	for (i = 0; i < (1 << JPC_NMSEDEC_BITS); ++i) {
+    for (i = 0; i < (1 << JPC_NMSEDEC_BITS); ++i) {
-		t = i * jpc_pow2i(-JPC_NMSEDEC_FRACBITS);
+        t = i * jpc_pow2i(-JPC_NMSEDEC_FRACBITS);
-		u = t;
+        u = t;
-		v = t - 1.5;
+        v = t - 1.5;
-		jpc_signmsedec[i] = jpc_dbltofix(floor((u * u - v * v) * jpc_pow2i(JPC_NMSEDEC_FRACBITS) + 0.5) / jpc_pow2i(JPC_NMSEDEC_FRACBITS));
+        jpc_signmsedec[i] = jpc_dbltofix(floor((u * u - v * v) * jpc_pow2i(JPC_NMSEDEC_FRACBITS) + 0.5) / jpc_pow2i(JPC_NMSEDEC_FRACBITS));
 /* XXX - this calc is not correct */
-		jpc_signmsedec0[i] = jpc_dbltofix(floor((u * u) * jpc_pow2i(JPC_NMSEDEC_FRACBITS) + 0.5) / jpc_pow2i(JPC_NMSEDEC_FRACBITS));
+        jpc_signmsedec0[i] = jpc_dbltofix(floor((u * u) * jpc_pow2i(JPC_NMSEDEC_FRACBITS) + 0.5) / jpc_pow2i(JPC_NMSEDEC_FRACBITS));
-		u = t - 1.0;
+        u = t - 1.0;
-		if (i & (1 << (JPC_NMSEDEC_BITS - 1))) {
+        if (i & (1 << (JPC_NMSEDEC_BITS - 1))) {
-			v = t - 1.5;
+            v = t - 1.5;
-		} else {
+        } else {
-			v = t - 0.5;
+            v = t - 0.5;
-		}
+        }
-		jpc_refnmsedec[i] = jpc_dbltofix(floor((u * u - v * v) * jpc_pow2i(JPC_NMSEDEC_FRACBITS) + 0.5) / jpc_pow2i(JPC_NMSEDEC_FRACBITS));
+        jpc_refnmsedec[i] = jpc_dbltofix(floor((u * u - v * v) * jpc_pow2i(JPC_NMSEDEC_FRACBITS) + 0.5) / jpc_pow2i(JPC_NMSEDEC_FRACBITS));
 /* XXX - this calc is not correct */
-		jpc_refnmsedec0[i] = jpc_dbltofix(floor((u * u) * jpc_pow2i(JPC_NMSEDEC_FRACBITS) + 0.5) / jpc_pow2i(JPC_NMSEDEC_FRACBITS));
+        jpc_refnmsedec0[i] = jpc_dbltofix(floor((u * u) * jpc_pow2i(JPC_NMSEDEC_FRACBITS) + 0.5) / jpc_pow2i(JPC_NMSEDEC_FRACBITS));
-	}
+    }
 }
 
 jpc_fix_t jpc_getsignmsedec_func(jpc_fix_t x, int bitpos)
 {
-	jpc_fix_t y;
+    jpc_fix_t y;
-	assert(!(x & (~JAS_ONES(bitpos + 1))));
+    assert(!(x & (~JAS_ONES(bitpos + 1))));
-	y = jpc_getsignmsedec_macro(x, bitpos);
+    y = jpc_getsignmsedec_macro(x, bitpos);
-	return y;
+    return y;
 }
 
 int jpc_getzcctxno(int f, int orient)
 {
-	int h;
+    int h;
-	int v;
+    int v;
-	int d;
+    int d;
-	int n;
+    int n;
-	int t;
+    int t;
-	int hv;
+    int hv;
 
-	/* Avoid compiler warning. */
+    /* Avoid compiler warning. */
-	n = 0;
+    n = 0;
 
-	h = ((f & JPC_WSIG) != 0) + ((f & JPC_ESIG) != 0);
+    h = ((f & JPC_WSIG) != 0) + ((f & JPC_ESIG) != 0);
-	v = ((f & JPC_NSIG) != 0) + ((f & JPC_SSIG) != 0);
+    v = ((f & JPC_NSIG) != 0) + ((f & JPC_SSIG) != 0);
-	d = ((f & JPC_NWSIG) != 0) + ((f & JPC_NESIG) != 0) + ((f & JPC_SESIG) != 0) + ((f & JPC_SWSIG) != 0);
+    d = ((f & JPC_NWSIG) != 0) + ((f & JPC_NESIG) != 0) + ((f & JPC_SESIG) != 0) + ((f & JPC_SWSIG) != 0);
-	switch (orient) {
+    switch (orient) {
-	case JPC_TSFB_HL:
+    case JPC_TSFB_HL:
-		t = h;
+        t = h;
-		h = v;
+        h = v;
-		v = t;
+        v = t;
-	case JPC_TSFB_LL:
+    case JPC_TSFB_LL:
-	case JPC_TSFB_LH:
+    case JPC_TSFB_LH:
-		if (!h) {
+        if (!h) {
-			if (!v) {
+            if (!v) {
-				if (!d) {
+                if (!d) {
-					n = 0;
+                    n = 0;
-				} else if (d == 1) {
+                } else if (d == 1) {
-					n = 1;
+                    n = 1;
-				} else {
+                } else {
-					n = 2;
+                    n = 2;
-				}
+                }
-			} else if (v == 1) {
+            } else if (v == 1) {
-				n = 3;
+                n = 3;
-			} else {
+            } else {
-				n = 4;
+                n = 4;
-			}
+            }
-		} else if (h == 1) {
+        } else if (h == 1) {
-			if (!v) {
+            if (!v) {
-				if (!d) {
+                if (!d) {
-					n = 5;
+                    n = 5;
-				} else {
+                } else {
-					n = 6;
+                    n = 6;
-				}
+                }
-			} else {
+            } else {
-				n = 7;
+                n = 7;
-			}
+            }
-		} else {
+        } else {
-			n = 8;
+            n = 8;
-		}
+        }
-		break;
+        break;
-	case JPC_TSFB_HH:
+    case JPC_TSFB_HH:
-		hv = h + v;
+        hv = h + v;
-		if (!d) {
+        if (!d) {
-			if (!hv) {
+            if (!hv) {
-				n = 0;
+                n = 0;
-			} else if (hv == 1) {
+            } else if (hv == 1) {
-				n = 1;
+                n = 1;
-			} else {
+            } else {
-				n = 2;
+                n = 2;
-			}
+            }
-		} else if (d == 1) {
+        } else if (d == 1) {
-			if (!hv) {
+            if (!hv) {
-				n = 3;
+                n = 3;
-			} else if (hv == 1) {
+            } else if (hv == 1) {
-				n = 4;
+                n = 4;
-			} else {
+            } else {
-				n = 5;
+                n = 5;
-			}
+            }
-		} else if (d == 2) {
+        } else if (d == 2) {
-			if (!hv) {
+            if (!hv) {
-				n = 6;
+                n = 6;
-			} else {
+            } else {
-				n = 7;
+                n = 7;
-			}
+            }
-		} else {
+        } else {
-			n = 8;
+            n = 8;
-		}
+        }
-		break;
+        break;
-	}
+    }
-	assert(n < JPC_NUMZCCTXS);
+    assert(n < JPC_NUMZCCTXS);
-	return JPC_ZCCTXNO + n;
+    return JPC_ZCCTXNO + n;
 }
 
 int jpc_getspb(int f)
 {
-	int hc;
+    int hc;
-	int vc;
+    int vc;
-	int n;
+    int n;
 
-	hc = JAS_MIN(((f & (JPC_ESIG | JPC_ESGN)) == JPC_ESIG) + ((f & (JPC_WSIG | JPC_WSGN)) == JPC_WSIG), 1) -
+    hc = JAS_MIN(((f & (JPC_ESIG | JPC_ESGN)) == JPC_ESIG) + ((f & (JPC_WSIG | JPC_WSGN)) == JPC_WSIG), 1) -
-	  JAS_MIN(((f & (JPC_ESIG | JPC_ESGN)) == (JPC_ESIG | JPC_ESGN)) + ((f & (JPC_WSIG | JPC_WSGN)) == (JPC_WSIG | JPC_WSGN)), 1);
+      JAS_MIN(((f & (JPC_ESIG | JPC_ESGN)) == (JPC_ESIG | JPC_ESGN)) + ((f & (JPC_WSIG | JPC_WSGN)) == (JPC_WSIG | JPC_WSGN)), 1);
-	vc = JAS_MIN(((f & (JPC_NSIG | JPC_NSGN)) == JPC_NSIG) + ((f & (JPC_SSIG | JPC_SSGN)) == JPC_SSIG), 1) -
+    vc = JAS_MIN(((f & (JPC_NSIG | JPC_NSGN)) == JPC_NSIG) + ((f & (JPC_SSIG | JPC_SSGN)) == JPC_SSIG), 1) -
-	  JAS_MIN(((f & (JPC_NSIG | JPC_NSGN)) == (JPC_NSIG | JPC_NSGN)) + ((f & (JPC_SSIG | JPC_SSGN)) == (JPC_SSIG | JPC_SSGN)), 1);
+      JAS_MIN(((f & (JPC_NSIG | JPC_NSGN)) == (JPC_NSIG | JPC_NSGN)) + ((f & (JPC_SSIG | JPC_SSGN)) == (JPC_SSIG | JPC_SSGN)), 1);
-	if (!hc && !vc) {
+    if (!hc && !vc) {
-		n = 0;
+        n = 0;
-	} else {
+    } else {
-		n = (!(hc > 0 || (!hc && vc > 0)));
+        n = (!(hc > 0 || (!hc && vc > 0)));
-	}
+    }
-	return n;
+    return n;
 }
 
 int jpc_getscctxno(int f)
 {
-	int hc;
+    int hc;
-	int vc;
+    int vc;
-	int n;
+    int n;
 
-	/* Avoid compiler warning. */
+    /* Avoid compiler warning. */
-	n = 0;
+    n = 0;
 
-	hc = JAS_MIN(((f & (JPC_ESIG | JPC_ESGN)) == JPC_ESIG) + ((f & (JPC_WSIG | JPC_WSGN)) == JPC_WSIG),
+    hc = JAS_MIN(((f & (JPC_ESIG | JPC_ESGN)) == JPC_ESIG) + ((f & (JPC_WSIG | JPC_WSGN)) == JPC_WSIG),
-	  1) - JAS_MIN(((f & (JPC_ESIG | JPC_ESGN)) == (JPC_ESIG | JPC_ESGN)) +
+      1) - JAS_MIN(((f & (JPC_ESIG | JPC_ESGN)) == (JPC_ESIG | JPC_ESGN)) +
-	  ((f & (JPC_WSIG | JPC_WSGN)) == (JPC_WSIG | JPC_WSGN)), 1);
+      ((f & (JPC_WSIG | JPC_WSGN)) == (JPC_WSIG | JPC_WSGN)), 1);
-	vc = JAS_MIN(((f & (JPC_NSIG | JPC_NSGN)) == JPC_NSIG) + ((f & (JPC_SSIG | JPC_SSGN)) == JPC_SSIG),
+    vc = JAS_MIN(((f & (JPC_NSIG | JPC_NSGN)) == JPC_NSIG) + ((f & (JPC_SSIG | JPC_SSGN)) == JPC_SSIG),
-	  1) - JAS_MIN(((f & (JPC_NSIG | JPC_NSGN)) == (JPC_NSIG | JPC_NSGN)) +
+      1) - JAS_MIN(((f & (JPC_NSIG | JPC_NSGN)) == (JPC_NSIG | JPC_NSGN)) +
-	  ((f & (JPC_SSIG | JPC_SSGN)) == (JPC_SSIG | JPC_SSGN)), 1);
+      ((f & (JPC_SSIG | JPC_SSGN)) == (JPC_SSIG | JPC_SSGN)), 1);
-	assert(hc >= -1 && hc <= 1 && vc >= -1 && vc <= 1);
+    assert(hc >= -1 && hc <= 1 && vc >= -1 && vc <= 1);
-	if (hc < 0) {
+    if (hc < 0) {
-		hc = -hc;
+        hc = -hc;
-		vc = -vc;
+        vc = -vc;
-	}
+    }
-	if (!hc) {
+    if (!hc) {
-		if (vc == -1) {
+        if (vc == -1) {
-			n = 1;
+            n = 1;
-		} else if (!vc) {
+        } else if (!vc) {
-			n = 0;
+            n = 0;
-		} else {
+        } else {
-			n = 1;
+            n = 1;
-		}
+        }
-	} else if (hc == 1) {
+    } else if (hc == 1) {
-		if (vc == -1) {
+        if (vc == -1) {
-			n = 2;
+            n = 2;
-		} else if (!vc) {
+        } else if (!vc) {
-			n = 3;
+            n = 3;
-		} else {
+        } else {
-			n = 4;
+            n = 4;
-		}
+        }
-	}
+    }
-	assert(n < JPC_NUMSCCTXS);
+    assert(n < JPC_NUMSCCTXS);
-	return JPC_SCCTXNO + n;
+    return JPC_SCCTXNO + n;
 }
 
 int jpc_getmagctxno(int f)
 {
-	int n;
+    int n;
 
-	if (!(f & JPC_REFINE)) {
+    if (!(f & JPC_REFINE)) {
-		n = (f & (JPC_OTHSIGMSK)) ? 1 : 0;
+        n = (f & (JPC_OTHSIGMSK)) ? 1 : 0;
-	} else {
+    } else {
-		n = 2;
+        n = 2;
-	}
+    }
 
-	assert(n < JPC_NUMMAGCTXS);
+    assert(n < JPC_NUMMAGCTXS);
-	return JPC_MAGCTXNO + n;
+    return JPC_MAGCTXNO + n;
 }
 
 void jpc_initctxs(jpc_mqctx_t *ctxs)
 {
-	jpc_mqctx_t *ctx;
+    jpc_mqctx_t *ctx;
-	int i;
+    int i;
 
-	ctx = ctxs;
+    ctx = ctxs;
-	for (i = 0; i < JPC_NUMCTXS; ++i) {
+    for (i = 0; i < JPC_NUMCTXS; ++i) {
-		ctx->mps = 0;
+        ctx->mps = 0;
-		switch (i) {
+        switch (i) {
-		case JPC_UCTXNO:
+        case JPC_UCTXNO:
-			ctx->ind = 46;
+            ctx->ind = 46;
-			break;
+            break;
-		case JPC_ZCCTXNO:
+        case JPC_ZCCTXNO:
-			ctx->ind = 4;
+            ctx->ind = 4;
-			break;
+            break;
-		case JPC_AGGCTXNO:
+        case JPC_AGGCTXNO:
-			ctx->ind = 3;
+            ctx->ind = 3;
-			break;
+            break;
-		default:
+        default:
-			ctx->ind = 0;
+            ctx->ind = 0;
-			break;
+            break;
-		}
+        }
-		++ctx;
+        ++ctx;
-	}
+    }
 }
 
 void jpc_initmqctxs()
 {
-	jpc_initctxs(jpc_mqctxs);
+    jpc_initctxs(jpc_mqctxs);
 }
 
 /* Calculate the real quantity exp2(n), where x is an integer. */
 double jpc_pow2i(int n)
 {
-	double x;
+    double x;
-	double a;
+    double a;
 
-	x = 1.0;
+    x = 1.0;
-	if (n < 0) {
+    if (n < 0) {
-		a = 0.5;
+        a = 0.5;
-		n = -n;
+        n = -n;
-	} else {
+    } else {
-		a = 2.0;
+        a = 2.0;
-	}
+    }
-	while (--n >= 0) {
+    while (--n >= 0) {
-		x *= a;
+        x *= a;
-	}
+    }
-	return x;
+    return x;
 }

3rdparty/libjasper/jpc_t1cod.h

@@ -6,15 +6,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,
@@ -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__
  */
 
@@ -127,7 +127,7 @@
 #define	JPC_WSIG	0x0080
 /* The significance mask for 8-connected neighbours. */
 #define	JPC_OTHSIGMSK \
-	(JPC_NSIG | JPC_NESIG | JPC_ESIG | JPC_SESIG | JPC_SSIG | JPC_SWSIG | JPC_WSIG | JPC_NWSIG)
+    (JPC_NSIG | JPC_NESIG | JPC_ESIG | JPC_SESIG | JPC_SSIG | JPC_SWSIG | JPC_WSIG | JPC_NWSIG)
 /* The significance mask for 4-connected neighbours. */
 #define	JPC_PRIMSIGMSK	(JPC_NSIG | JPC_ESIG | JPC_SSIG | JPC_WSIG)
 
@@ -201,75 +201,75 @@ void jpc_initctxs(jpc_mqctx_t *ctxs);
 /* Get the zero coding context. */
 int jpc_getzcctxno(int f, int orient);
 #define	JPC_GETZCCTXNO(f, orient) \
-	(jpc_zcctxnolut[((orient) << 8) | ((f) & JPC_OTHSIGMSK)])
+    (jpc_zcctxnolut[((orient) << 8) | ((f) & JPC_OTHSIGMSK)])
 
 /* Get the sign prediction bit. */
 int jpc_getspb(int f);
 #define	JPC_GETSPB(f) \
-	(jpc_spblut[((f) & (JPC_PRIMSIGMSK | JPC_SGNMSK)) >> 4])
+    (jpc_spblut[((f) & (JPC_PRIMSIGMSK | JPC_SGNMSK)) >> 4])
 
 /* Get the sign coding context. */
 int jpc_getscctxno(int f);
 #define	JPC_GETSCCTXNO(f) \
-	(jpc_scctxnolut[((f) & (JPC_PRIMSIGMSK | JPC_SGNMSK)) >> 4])
+    (jpc_scctxnolut[((f) & (JPC_PRIMSIGMSK | JPC_SGNMSK)) >> 4])
 
 /* Get the magnitude context. */
 int jpc_getmagctxno(int f);
 #define	JPC_GETMAGCTXNO(f) \
-	(jpc_magctxnolut[((f) & JPC_OTHSIGMSK) | ((((f) & JPC_REFINE) != 0) << 11)])
+    (jpc_magctxnolut[((f) & JPC_OTHSIGMSK) | ((((f) & JPC_REFINE) != 0) << 11)])
 
 /* Get the normalized MSE reduction for significance passes. */
 #define	JPC_GETSIGNMSEDEC(x, bitpos)	jpc_getsignmsedec_macro(x, bitpos)
 jpc_fix_t jpc_getsignmsedec_func(jpc_fix_t x, int bitpos);
 #define	jpc_getsignmsedec_macro(x, bitpos) \
-	((bitpos > JPC_NMSEDEC_FRACBITS) ? jpc_signmsedec[JPC_ASR(x, bitpos - JPC_NMSEDEC_FRACBITS) & JAS_ONES(JPC_NMSEDEC_BITS)] : \
+    ((bitpos > JPC_NMSEDEC_FRACBITS) ? jpc_signmsedec[JPC_ASR(x, bitpos - JPC_NMSEDEC_FRACBITS) & JAS_ONES(JPC_NMSEDEC_BITS)] : \
-	  (jpc_signmsedec0[JPC_ASR(x, bitpos - JPC_NMSEDEC_FRACBITS) & JAS_ONES(JPC_NMSEDEC_BITS)]))
+      (jpc_signmsedec0[JPC_ASR(x, bitpos - JPC_NMSEDEC_FRACBITS) & JAS_ONES(JPC_NMSEDEC_BITS)]))
 
 /* Get the normalized MSE reduction for refinement passes. */
 #define	JPC_GETREFNMSEDEC(x, bitpos)	jpc_getrefnmsedec_macro(x, bitpos)
 jpc_fix_t jpc_refsignmsedec_func(jpc_fix_t x, int bitpos);
 #define	jpc_getrefnmsedec_macro(x, bitpos) \
-	((bitpos > JPC_NMSEDEC_FRACBITS) ? jpc_refnmsedec[JPC_ASR(x, bitpos - JPC_NMSEDEC_FRACBITS) & JAS_ONES(JPC_NMSEDEC_BITS)] : \
+    ((bitpos > JPC_NMSEDEC_FRACBITS) ? jpc_refnmsedec[JPC_ASR(x, bitpos - JPC_NMSEDEC_FRACBITS) & JAS_ONES(JPC_NMSEDEC_BITS)] : \
-	  (jpc_refnmsedec0[JPC_ASR(x, bitpos - JPC_NMSEDEC_FRACBITS) & JAS_ONES(JPC_NMSEDEC_BITS)]))
+      (jpc_refnmsedec0[JPC_ASR(x, bitpos - JPC_NMSEDEC_FRACBITS) & JAS_ONES(JPC_NMSEDEC_BITS)]))
 
 /* Arithmetic shift right (with ability to shift left also). */
 #define	JPC_ASR(x, n) \
-	(((n) >= 0) ? ((x) >> (n)) : ((x) << (-(n))))
+    (((n) >= 0) ? ((x) >> (n)) : ((x) << (-(n))))
 
 /* Update the per-sample state information. */
 #define	JPC_UPDATEFLAGS4(fp, rowstep, s, vcausalflag) \
 { \
-	register jpc_fix_t *np = (fp) - (rowstep); \
+    register jpc_fix_t *np = (fp) - (rowstep); \
-	register jpc_fix_t *sp = (fp) + (rowstep); \
+    register jpc_fix_t *sp = (fp) + (rowstep); \
-	if ((vcausalflag)) { \
+    if ((vcausalflag)) { \
-		sp[-1] |= JPC_NESIG; \
+        sp[-1] |= JPC_NESIG; \
-		sp[1] |= JPC_NWSIG; \
+        sp[1] |= JPC_NWSIG; \
-		if (s) { \
+        if (s) { \
-			*sp |= JPC_NSIG | JPC_NSGN; \
+            *sp |= JPC_NSIG | JPC_NSGN; \
-			(fp)[-1] |= JPC_ESIG | JPC_ESGN; \
+            (fp)[-1] |= JPC_ESIG | JPC_ESGN; \
-			(fp)[1] |= JPC_WSIG | JPC_WSGN; \
+            (fp)[1] |= JPC_WSIG | JPC_WSGN; \
-		} else { \
+        } else { \
-			*sp |= JPC_NSIG; \
+            *sp |= JPC_NSIG; \
-			(fp)[-1] |= JPC_ESIG; \
+            (fp)[-1] |= JPC_ESIG; \
-			(fp)[1] |= JPC_WSIG; \
+            (fp)[1] |= JPC_WSIG; \
-		} \
+        } \
-	} else { \
+    } else { \
-		np[-1] |= JPC_SESIG; \
+        np[-1] |= JPC_SESIG; \
-		np[1] |= JPC_SWSIG; \
+        np[1] |= JPC_SWSIG; \
-		sp[-1] |= JPC_NESIG; \
+        sp[-1] |= JPC_NESIG; \
-		sp[1] |= JPC_NWSIG; \
+        sp[1] |= JPC_NWSIG; \
-		if (s) { \
+        if (s) { \
-			*np |= JPC_SSIG | JPC_SSGN; \
+            *np |= JPC_SSIG | JPC_SSGN; \
-			*sp |= JPC_NSIG | JPC_NSGN; \
+            *sp |= JPC_NSIG | JPC_NSGN; \
-			(fp)[-1] |= JPC_ESIG | JPC_ESGN; \
+            (fp)[-1] |= JPC_ESIG | JPC_ESGN; \
-			(fp)[1] |= JPC_WSIG | JPC_WSGN; \
+            (fp)[1] |= JPC_WSIG | JPC_WSGN; \
-		} else { \
+        } else { \
-			*np |= JPC_SSIG; \
+            *np |= JPC_SSIG; \
-			*sp |= JPC_NSIG; \
+            *sp |= JPC_NSIG; \
-			(fp)[-1] |= JPC_ESIG; \
+            (fp)[-1] |= JPC_ESIG; \
-			(fp)[1] |= JPC_WSIG; \
+            (fp)[1] |= JPC_WSIG; \
-		} \
+        } \
-	} \
+    } \
 }
 
 /* Initialize the lookup tables used by the codec. */

3rdparty/libjasper/jpc_t1dec.h

@@ -6,15 +6,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,
@@ -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__
  */
 

3rdparty/libjasper/jpc_t1enc.h

@@ -6,15 +6,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,
@@ -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__
  */
 

3rdparty/libjasper/jpc_t2cod.h

@@ -6,15 +6,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,
@@ -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__
  */
 
@@ -84,15 +84,15 @@
 
 typedef struct {
 
-	/* The number of progression changes. */
+    /* The number of progression changes. */
-	int numpchgs;
+    int numpchgs;
 
-	/* The maximum number of progression changes that can be accomodated
+    /* The maximum number of progression changes that can be accomodated
-	  without growing the progression change array. */
+      without growing the progression change array. */
-	int maxpchgs;
+    int maxpchgs;
 
-	/* The progression changes. */
+    /* The progression changes. */
-	jpc_pchg_t **pchgs;
+    jpc_pchg_t **pchgs;
 
 } jpc_pchglist_t;
 
@@ -100,21 +100,21 @@ typedef struct {
 
 typedef struct {
 
-	/* The number of precincts. */
+    /* The number of precincts. */
-	int numprcs;
+    int numprcs;
 
-	/* The last layer processed for each precinct. */
+    /* The last layer processed for each precinct. */
-	int *prclyrnos;
+    int *prclyrnos;
 
-	/* The precinct width exponent. */
+    /* The precinct width exponent. */
-	int prcwidthexpn;
+    int prcwidthexpn;
 
-	/* The precinct height exponent. */
+    /* The precinct height exponent. */
-	int prcheightexpn;
+    int prcheightexpn;
 
-	/* The number of precincts spanning the resolution level in the horizontal
+    /* The number of precincts spanning the resolution level in the horizontal
-	  direction. */
+      direction. */
-	int numhprcs;
+    int numhprcs;
 
 } jpc_pirlvl_t;
 
@@ -122,17 +122,17 @@ typedef struct {
 
 typedef struct {
 
-	/* The number of resolution levels. */
+    /* The number of resolution levels. */
-	int numrlvls;
+    int numrlvls;
 
-	/* The per-resolution-level information. */
+    /* The per-resolution-level information. */
-	jpc_pirlvl_t *pirlvls;
+    jpc_pirlvl_t *pirlvls;
 
-	/* The horizontal sampling period. */
+    /* The horizontal sampling period. */
-	int hsamp;
+    int hsamp;
 
-	/* The vertical sampling period. */
+    /* The vertical sampling period. */
-	int vsamp;
+    int vsamp;
 
 } jpc_picomp_t;
 
@@ -140,84 +140,84 @@ typedef struct {
 
 typedef struct {
 
-	/* The number of layers. */
+    /* The number of layers. */
-	int numlyrs;
+    int numlyrs;
 
-	/* The number of resolution levels. */
+    /* The number of resolution levels. */
-	int maxrlvls;
+    int maxrlvls;
 
-	/* The number of components. */
+    /* The number of components. */
-	int numcomps;
+    int numcomps;
 
-	/* The per-component information. */
+    /* The per-component information. */
-	jpc_picomp_t *picomps;
+    jpc_picomp_t *picomps;
 
-	/* The current component. */
+    /* The current component. */
-	jpc_picomp_t *picomp;
+    jpc_picomp_t *picomp;
 
-	/* The current resolution level. */
+    /* The current resolution level. */
-	jpc_pirlvl_t *pirlvl;
+    jpc_pirlvl_t *pirlvl;
 
-	/* The number of the current component. */
+    /* The number of the current component. */
-	int compno;
+    int compno;
 
-	/* The number of the current resolution level. */
+    /* The number of the current resolution level. */
-	int rlvlno;
+    int rlvlno;
 
-	/* The number of the current precinct. */
+    /* The number of the current precinct. */
-	int prcno;
+    int prcno;
 
-	/* The number of the current layer. */
+    /* The number of the current layer. */
-	int lyrno;
+    int lyrno;
 
-	/* The x-coordinate of the current position. */
+    /* The x-coordinate of the current position. */
-	int x;
+    int x;
 
-	/* The y-coordinate of the current position. */
+    /* The y-coordinate of the current position. */
-	int y;
+    int y;
 
-	/* The horizontal step size. */
+    /* The horizontal step size. */
-	int xstep;
+    int xstep;
 
-	/* The vertical step size. */
+    /* The vertical step size. */
-	int ystep;
+    int ystep;
 
-	/* The x-coordinate of the top-left corner of the tile on the reference
+    /* The x-coordinate of the top-left corner of the tile on the reference
-	  grid. */
+      grid. */
-	int xstart;
+    int xstart;
 
-	/* The y-coordinate of the top-left corner of the tile on the reference
+    /* The y-coordinate of the top-left corner of the tile on the reference
-	  grid. */
+      grid. */
-	int ystart;
+    int ystart;
 
-	/* The x-coordinate of the bottom-right corner of the tile on the
+    /* The x-coordinate of the bottom-right corner of the tile on the
-	  reference grid (plus one). */
+      reference grid (plus one). */
-	int xend;
+    int xend;
 
-	/* The y-coordinate of the bottom-right corner of the tile on the
+    /* The y-coordinate of the bottom-right corner of the tile on the
-	  reference grid (plus one). */
+      reference grid (plus one). */
-	int yend;
+    int yend;
 
-	/* The current progression change. */
+    /* The current progression change. */
-	jpc_pchg_t *pchg;
+    jpc_pchg_t *pchg;
 
-	/* The progression change list. */
+    /* The progression change list. */
-	jpc_pchglist_t *pchglist;
+    jpc_pchglist_t *pchglist;
 
-	/* The progression to use in the absense of explicit specification. */
+    /* The progression to use in the absense of explicit specification. */
-	jpc_pchg_t defaultpchg;
+    jpc_pchg_t defaultpchg;
 
-	/* The current progression change number. */
+    /* The current progression change number. */
-	int pchgno;
+    int pchgno;
 
-	/* Is this the first time in the current progression volume? */
+    /* Is this the first time in the current progression volume? */
-	bool prgvolfirst;
+    bool prgvolfirst;
 
-	/* Is the current iterator value valid? */
+    /* Is the current iterator value valid? */
-	bool valid;
+    bool valid;
 
-	/* The current packet number. */
+    /* The current packet number. */
-	int pktno;
+    int pktno;
 
 } jpc_pi_t;
 

3rdparty/libjasper/jpc_t2dec.c

@@ -6,15 +6,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,
@@ -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__
  */
 
@@ -106,309 +106,309 @@ static int jpc_dec_decodepkt(jpc_dec_t *dec, jas_stream_t *pkthdrstream, jas_str
 
 static int jpc_getcommacode(jpc_bitstream_t *in)
 {
-	int n;
+    int n;
-	int v;
+    int v;
 
-	n = 0;
+    n = 0;
-	for (;;) {
+    for (;;) {
-		if ((v = jpc_bitstream_getbit(in)) < 0) {
+        if ((v = jpc_bitstream_getbit(in)) < 0) {
-			return -1;
+            return -1;
-		}
+        }
-		if (jpc_bitstream_eof(in)) {
+        if (jpc_bitstream_eof(in)) {
-			return -1;
+            return -1;
-		}
+        }
-		if (!v) {
+        if (!v) {
-			break;
+            break;
-		}
+        }
-		++n;
+        ++n;
-	}
+    }
 
-	return n;
+    return n;
 }
 
 static int jpc_getnumnewpasses(jpc_bitstream_t *in)
 {
-	int n;
+    int n;
 
-	if ((n = jpc_bitstream_getbit(in)) > 0) {
+    if ((n = jpc_bitstream_getbit(in)) > 0) {
-		if ((n = jpc_bitstream_getbit(in)) > 0) {
+        if ((n = jpc_bitstream_getbit(in)) > 0) {
-			if ((n = jpc_bitstream_getbits(in, 2)) == 3) {
+            if ((n = jpc_bitstream_getbits(in, 2)) == 3) {
-				if ((n = jpc_bitstream_getbits(in, 5)) == 31) {
+                if ((n = jpc_bitstream_getbits(in, 5)) == 31) {
-					if ((n = jpc_bitstream_getbits(in, 7)) >= 0) {
+                    if ((n = jpc_bitstream_getbits(in, 7)) >= 0) {
-						n += 36 + 1;
+                        n += 36 + 1;
-					}
+                    }
-				} else if (n >= 0) {
+                } else if (n >= 0) {
-					n += 5 + 1;
+                    n += 5 + 1;
-				}
+                }
-			} else if (n >= 0) {
+            } else if (n >= 0) {
-				n += 2 + 1;
+                n += 2 + 1;
-			}
+            }
-		} else if (!n) {
+        } else if (!n) {
-			n += 2;
+            n += 2;
-		}
+        }
-	} else if (!n) {
+    } else if (!n) {
-		++n;
+        ++n;
-	}
+    }
 
-	return n;
+    return n;
 }
 
 static int jpc_dec_decodepkt(jpc_dec_t *dec, jas_stream_t *pkthdrstream, jas_stream_t *in, int compno, int rlvlno,
   int prcno, int lyrno)
 {
-	jpc_bitstream_t *inb;
+    jpc_bitstream_t *inb;
-	jpc_dec_tcomp_t *tcomp;
+    jpc_dec_tcomp_t *tcomp;
-	jpc_dec_rlvl_t *rlvl;
+    jpc_dec_rlvl_t *rlvl;
-	jpc_dec_band_t *band;
+    jpc_dec_band_t *band;
-	jpc_dec_cblk_t *cblk;
+    jpc_dec_cblk_t *cblk;
-	int n;
+    int n;
-	int m;
+    int m;
-	int i;
+    int i;
-	jpc_tagtreenode_t *leaf;
+    jpc_tagtreenode_t *leaf;
-	int included;
+    int included;
-	int ret;
+    int ret;
-	int numnewpasses;
+    int numnewpasses;
-	jpc_dec_seg_t *seg;
+    jpc_dec_seg_t *seg;
-	int len;
+    int len;
-	int present;
+    int present;
-	int savenumnewpasses;
+    int savenumnewpasses;
-	int mycounter;
+    int mycounter;
-	jpc_ms_t *ms;
+    jpc_ms_t *ms;
-	jpc_dec_tile_t *tile;
+    jpc_dec_tile_t *tile;
-	jpc_dec_ccp_t *ccp;
+    jpc_dec_ccp_t *ccp;
-	jpc_dec_cp_t *cp;
+    jpc_dec_cp_t *cp;
-	int bandno;
+    int bandno;
-	jpc_dec_prc_t *prc;
+    jpc_dec_prc_t *prc;
-	int usedcblkcnt;
+    int usedcblkcnt;
-	int cblkno;
+    int cblkno;
-	uint_fast32_t bodylen;
+    uint_fast32_t bodylen;
-	bool discard;
+    bool discard;
-	int passno;
+    int passno;
-	int maxpasses;
+    int maxpasses;
-	int hdrlen;
+    int hdrlen;
-	int hdroffstart;
+    int hdroffstart;
-	int hdroffend;
+    int hdroffend;
 
-	/* Avoid compiler warning about possible use of uninitialized
+    /* Avoid compiler warning about possible use of uninitialized
-	  variable. */
+      variable. */
-	bodylen = 0;
+    bodylen = 0;
 
-	discard = (lyrno >= dec->maxlyrs);
+    discard = (lyrno >= dec->maxlyrs);
 
-	tile = dec->curtile;
+    tile = dec->curtile;
-	cp = tile->cp;
+    cp = tile->cp;
-	ccp = &cp->ccps[compno];
+    ccp = &cp->ccps[compno];
 
-	/*
+    /*
-	 * Decode the packet header.
+     * Decode the packet header.
-	 */
+     */
 
-	/* Decode the SOP marker segment if present. */
+    /* Decode the SOP marker segment if present. */
-	if (cp->csty & JPC_COD_SOP) {
+    if (cp->csty & JPC_COD_SOP) {
-		if (jpc_dec_lookahead(in) == JPC_MS_SOP) {
+        if (jpc_dec_lookahead(in) == JPC_MS_SOP) {
-			if (!(ms = jpc_getms(in, dec->cstate))) {
+            if (!(ms = jpc_getms(in, dec->cstate))) {
-				return -1;
+                return -1;
-			}
+            }
-			if (jpc_ms_gettype(ms) != JPC_MS_SOP) {
+            if (jpc_ms_gettype(ms) != JPC_MS_SOP) {
-				jpc_ms_destroy(ms);
+                jpc_ms_destroy(ms);
-				jas_eprintf("missing SOP marker segment\n");
+                jas_eprintf("missing SOP marker segment\n");
-				return -1;
+                return -1;
-			}
+            }
-			jpc_ms_destroy(ms);
+            jpc_ms_destroy(ms);
-		}
+        }
-	}
+    }
 
 hdroffstart = jas_stream_getrwcount(pkthdrstream);
 
-	if (!(inb = jpc_bitstream_sopen(pkthdrstream, "r"))) {
+    if (!(inb = jpc_bitstream_sopen(pkthdrstream, "r"))) {
-		return -1;
+        return -1;
-	}
+    }
 
-	if ((present = jpc_bitstream_getbit(inb)) < 0) {
+    if ((present = jpc_bitstream_getbit(inb)) < 0) {
-		return 1;
+        return 1;
-	}
+    }
-	JAS_DBGLOG(10, ("\n", present));
+    JAS_DBGLOG(10, ("\n", present));
-	JAS_DBGLOG(10, ("present=%d ", present));
+    JAS_DBGLOG(10, ("present=%d ", present));
 
-	/* Is the packet non-empty? */
+    /* Is the packet non-empty? */
-	if (present) {
+    if (present) {
-		/* The packet is non-empty. */
+        /* The packet is non-empty. */
-		tcomp = &tile->tcomps[compno];
+        tcomp = &tile->tcomps[compno];
-		rlvl = &tcomp->rlvls[rlvlno];
+        rlvl = &tcomp->rlvls[rlvlno];
-		bodylen = 0;
+        bodylen = 0;
-		for (bandno = 0, band = rlvl->bands; bandno < rlvl->numbands;
+        for (bandno = 0, band = rlvl->bands; bandno < rlvl->numbands;
-		  ++bandno, ++band) {
+          ++bandno, ++band) {
-			if (!band->data) {
+            if (!band->data) {
-				continue;
+                continue;
-			}
+            }
-			prc = &band->prcs[prcno];
+            prc = &band->prcs[prcno];
-			if (!prc->cblks) {
+            if (!prc->cblks) {
-				continue;
+                continue;
-			}
+            }
-			usedcblkcnt = 0;
+            usedcblkcnt = 0;
-			for (cblkno = 0, cblk = prc->cblks; cblkno < prc->numcblks;
+            for (cblkno = 0, cblk = prc->cblks; cblkno < prc->numcblks;
-			  ++cblkno, ++cblk) {
+              ++cblkno, ++cblk) {
-				++usedcblkcnt;
+                ++usedcblkcnt;
-				if (!cblk->numpasses) {
+                if (!cblk->numpasses) {
-					leaf = jpc_tagtree_getleaf(prc->incltagtree, usedcblkcnt - 1);
+                    leaf = jpc_tagtree_getleaf(prc->incltagtree, usedcblkcnt - 1);
-					if ((included = jpc_tagtree_decode(prc->incltagtree, leaf, lyrno + 1, inb)) < 0) {
+                    if ((included = jpc_tagtree_decode(prc->incltagtree, leaf, lyrno + 1, inb)) < 0) {
-						return -1;
+                        return -1;
-					}
+                    }
-				} else {
+                } else {
-					if ((included = jpc_bitstream_getbit(inb)) < 0) {
+                    if ((included = jpc_bitstream_getbit(inb)) < 0) {
-						return -1;
+                        return -1;
-					}
+                    }
-				}
+                }
-				JAS_DBGLOG(10, ("\n"));
+                JAS_DBGLOG(10, ("\n"));
-				JAS_DBGLOG(10, ("included=%d ", included));
+                JAS_DBGLOG(10, ("included=%d ", included));
-				if (!included) {
+                if (!included) {
-					continue;
+                    continue;
-				}
+                }
-				if (!cblk->numpasses) {
+                if (!cblk->numpasses) {
-					i = 1;
+                    i = 1;
-					leaf = jpc_tagtree_getleaf(prc->numimsbstagtree, usedcblkcnt - 1);
+                    leaf = jpc_tagtree_getleaf(prc->numimsbstagtree, usedcblkcnt - 1);
-					for (;;) {
+                    for (;;) {
-						if ((ret = jpc_tagtree_decode(prc->numimsbstagtree, leaf, i, inb)) < 0) {
+                        if ((ret = jpc_tagtree_decode(prc->numimsbstagtree, leaf, i, inb)) < 0) {
-							return -1;
+                            return -1;
-						}
+                        }
-						if (ret) {
+                        if (ret) {
-							break;
+                            break;
-						}
+                        }
-						++i;
+                        ++i;
-					}
+                    }
-					cblk->numimsbs = i - 1;
+                    cblk->numimsbs = i - 1;
-					cblk->firstpassno = cblk->numimsbs * 3;
+                    cblk->firstpassno = cblk->numimsbs * 3;
-				}
+                }
-				if ((numnewpasses = jpc_getnumnewpasses(inb)) < 0) {
+                if ((numnewpasses = jpc_getnumnewpasses(inb)) < 0) {
-					return -1;
+                    return -1;
-				}
+                }
-				JAS_DBGLOG(10, ("numnewpasses=%d ", numnewpasses));
+                JAS_DBGLOG(10, ("numnewpasses=%d ", numnewpasses));
-				seg = cblk->curseg;
+                seg = cblk->curseg;
-				savenumnewpasses = numnewpasses;
+                savenumnewpasses = numnewpasses;
-				mycounter = 0;
+                mycounter = 0;
-				if (numnewpasses > 0) {
+                if (numnewpasses > 0) {
-					if ((m = jpc_getcommacode(inb)) < 0) {
+                    if ((m = jpc_getcommacode(inb)) < 0) {
-						return -1;
+                        return -1;
-					}
+                    }
-					cblk->numlenbits += m;
+                    cblk->numlenbits += m;
-					JAS_DBGLOG(10, ("increment=%d ", m));
+                    JAS_DBGLOG(10, ("increment=%d ", m));
-					while (numnewpasses > 0) {
+                    while (numnewpasses > 0) {
-						passno = cblk->firstpassno + cblk->numpasses + mycounter;
+                        passno = cblk->firstpassno + cblk->numpasses + mycounter;
-	/* XXX - the maxpasses is not set precisely but this doesn't matter... */
+    /* XXX - the maxpasses is not set precisely but this doesn't matter... */
-						maxpasses = JPC_SEGPASSCNT(passno, cblk->firstpassno, 10000, (ccp->cblkctx & JPC_COX_LAZY) != 0, (ccp->cblkctx & JPC_COX_TERMALL) != 0);
+                        maxpasses = JPC_SEGPASSCNT(passno, cblk->firstpassno, 10000, (ccp->cblkctx & JPC_COX_LAZY) != 0, (ccp->cblkctx & JPC_COX_TERMALL) != 0);
-						if (!discard && !seg) {
+                        if (!discard && !seg) {
-							if (!(seg = jpc_seg_alloc())) {
+                            if (!(seg = jpc_seg_alloc())) {
-								return -1;
+                                return -1;
-							}
+                            }
-							jpc_seglist_insert(&cblk->segs, cblk->segs.tail, seg);
+                            jpc_seglist_insert(&cblk->segs, cblk->segs.tail, seg);
-							if (!cblk->curseg) {
+                            if (!cblk->curseg) {
-								cblk->curseg = seg;
+                                cblk->curseg = seg;
-							}
+                            }
-							seg->passno = passno;
+                            seg->passno = passno;
-							seg->type = JPC_SEGTYPE(seg->passno, cblk->firstpassno, (ccp->cblkctx & JPC_COX_LAZY) != 0);
+                            seg->type = JPC_SEGTYPE(seg->passno, cblk->firstpassno, (ccp->cblkctx & JPC_COX_LAZY) != 0);
-							seg->maxpasses = maxpasses;
+                            seg->maxpasses = maxpasses;
-						}
+                        }
-						n = JAS_MIN(numnewpasses, maxpasses);
+                        n = JAS_MIN(numnewpasses, maxpasses);
-						mycounter += n;
+                        mycounter += n;
-						numnewpasses -= n;
+                        numnewpasses -= n;
-						if ((len = jpc_bitstream_getbits(inb, cblk->numlenbits + jpc_floorlog2(n))) < 0) {
+                        if ((len = jpc_bitstream_getbits(inb, cblk->numlenbits + jpc_floorlog2(n))) < 0) {
-							return -1;
+                            return -1;
-						}
+                        }
-						JAS_DBGLOG(10, ("len=%d ", len));
+                        JAS_DBGLOG(10, ("len=%d ", len));
-						if (!discard) {
+                        if (!discard) {
-							seg->lyrno = lyrno;
+                            seg->lyrno = lyrno;
-							seg->numpasses += n;
+                            seg->numpasses += n;
-							seg->cnt = len;
+                            seg->cnt = len;
-							seg = seg->next;
+                            seg = seg->next;
-						}
+                        }
-						bodylen += len;
+                        bodylen += len;
-					}
+                    }
-				}
+                }
-				cblk->numpasses += savenumnewpasses;
+                cblk->numpasses += savenumnewpasses;
-			}
+            }
-		}
+        }
 
-		jpc_bitstream_inalign(inb, 0, 0);
+        jpc_bitstream_inalign(inb, 0, 0);
 
-	} else {
+    } else {
-		if (jpc_bitstream_inalign(inb, 0x7f, 0)) {
+        if (jpc_bitstream_inalign(inb, 0x7f, 0)) {
-			jas_eprintf("alignment failed\n");
+            jas_eprintf("alignment failed\n");
-			return -1;
+            return -1;
-		}
+        }
-	}
+    }
-	jpc_bitstream_close(inb);
+    jpc_bitstream_close(inb);
 
-	hdroffend = jas_stream_getrwcount(pkthdrstream);
+    hdroffend = jas_stream_getrwcount(pkthdrstream);
-	hdrlen = hdroffend - hdroffstart;
+    hdrlen = hdroffend - hdroffstart;
-	if (jas_getdbglevel() >= 5) {
+    if (jas_getdbglevel() >= 5) {
-		jas_eprintf("hdrlen=%lu bodylen=%lu \n", (unsigned long) hdrlen,
+        jas_eprintf("hdrlen=%lu bodylen=%lu \n", (unsigned long) hdrlen,
-		  (unsigned long) bodylen);
+          (unsigned long) bodylen);
-	}
+    }
 
-	if (cp->csty & JPC_COD_EPH) {
+    if (cp->csty & JPC_COD_EPH) {
-		if (jpc_dec_lookahead(pkthdrstream) == JPC_MS_EPH) {
+        if (jpc_dec_lookahead(pkthdrstream) == JPC_MS_EPH) {
-			if (!(ms = jpc_getms(pkthdrstream, dec->cstate))) {
+            if (!(ms = jpc_getms(pkthdrstream, dec->cstate))) {
-				jas_eprintf("cannot get (EPH) marker segment\n");
+                jas_eprintf("cannot get (EPH) marker segment\n");
-				return -1;
+                return -1;
-			}
+            }
-			if (jpc_ms_gettype(ms) != JPC_MS_EPH) {
+            if (jpc_ms_gettype(ms) != JPC_MS_EPH) {
-				jpc_ms_destroy(ms);
+                jpc_ms_destroy(ms);
-				jas_eprintf("missing EPH marker segment\n");
+                jas_eprintf("missing EPH marker segment\n");
-				return -1;
+                return -1;
-			}
+            }
-			jpc_ms_destroy(ms);
+            jpc_ms_destroy(ms);
-		}
+        }
-	}
+    }
 
-	/* decode the packet body. */
+    /* decode the packet body. */
 
-	if (jas_getdbglevel() >= 1) {
+    if (jas_getdbglevel() >= 1) {
-		jas_eprintf("packet body offset=%06ld\n", (long) jas_stream_getrwcount(in));
+        jas_eprintf("packet body offset=%06ld\n", (long) jas_stream_getrwcount(in));
-	}
+    }
 
-	if (!discard) {
+    if (!discard) {
-		tcomp = &tile->tcomps[compno];
+        tcomp = &tile->tcomps[compno];
-		rlvl = &tcomp->rlvls[rlvlno];
+        rlvl = &tcomp->rlvls[rlvlno];
-		for (bandno = 0, band = rlvl->bands; bandno < rlvl->numbands;
+        for (bandno = 0, band = rlvl->bands; bandno < rlvl->numbands;
-		  ++bandno, ++band) {
+          ++bandno, ++band) {
-			if (!band->data) {
+            if (!band->data) {
-				continue;
+                continue;
-			}
+            }
-			prc = &band->prcs[prcno];
+            prc = &band->prcs[prcno];
-			if (!prc->cblks) {
+            if (!prc->cblks) {
-				continue;
+                continue;
-			}
+            }
-			for (cblkno = 0, cblk = prc->cblks; cblkno < prc->numcblks;
+            for (cblkno = 0, cblk = prc->cblks; cblkno < prc->numcblks;
-			  ++cblkno, ++cblk) {
+              ++cblkno, ++cblk) {
-				seg = cblk->curseg;
+                seg = cblk->curseg;
-				while (seg) {
+                while (seg) {
-					if (!seg->stream) {
+                    if (!seg->stream) {
-						if (!(seg->stream = jas_stream_memopen(0, 0))) {
+                        if (!(seg->stream = jas_stream_memopen(0, 0))) {
-							return -1;
+                            return -1;
-						}
+                        }
-					}
+                    }
 #if 0
 jas_eprintf("lyrno=%02d, compno=%02d, lvlno=%02d, prcno=%02d, bandno=%02d, cblkno=%02d, passno=%02d numpasses=%02d cnt=%d numbps=%d, numimsbs=%d\n", lyrno, compno, rlvlno, prcno, band - rlvl->bands, cblk - prc->cblks, seg->passno, seg->numpasses, seg->cnt, band->numbps, cblk->numimsbs);
 #endif
-					if (seg->cnt > 0) {
+                    if (seg->cnt > 0) {
-						if (jpc_getdata(in, seg->stream, seg->cnt) < 0) {
+                        if (jpc_getdata(in, seg->stream, seg->cnt) < 0) {
-							return -1;
+                            return -1;
-						}
+                        }
-						seg->cnt = 0;
+                        seg->cnt = 0;
-					}
+                    }
-					if (seg->numpasses >= seg->maxpasses) {
+                    if (seg->numpasses >= seg->maxpasses) {
-						cblk->curseg = seg->next;
+                        cblk->curseg = seg->next;
-					}
+                    }
-					seg = seg->next;
+                    seg = seg->next;
-				}
+                }
-			}
+            }
-		}
+        }
-	} else {
+    } else {
-		if (jas_stream_gobble(in, bodylen) != JAS_CAST(int, bodylen)) {
+        if (jas_stream_gobble(in, bodylen) != JAS_CAST(int, bodylen)) {
-			return -1;
+            return -1;
-		}
+        }
-	}
+    }
-	return 0;
+    return 0;
 }
 
 /********************************************************************************************/
@@ -416,166 +416,166 @@ jas_eprintf("lyrno=%02d, compno=%02d, lvlno=%02d, prcno=%02d, bandno=%02d, cblkn
 
 int jpc_dec_decodepkts(jpc_dec_t *dec, jas_stream_t *pkthdrstream, jas_stream_t *in)
 {
-	jpc_dec_tile_t *tile;
+    jpc_dec_tile_t *tile;
-	jpc_pi_t *pi;
+    jpc_pi_t *pi;
-	int ret;
+    int ret;
 
-	tile = dec->curtile;
+    tile = dec->curtile;
-	pi = tile->pi;
+    pi = tile->pi;
-	for (;;) {
+    for (;;) {
 if (!tile->pkthdrstream || jas_stream_peekc(tile->pkthdrstream) == EOF) {
-		switch (jpc_dec_lookahead(in)) {
+        switch (jpc_dec_lookahead(in)) {
-		case JPC_MS_EOC:
+        case JPC_MS_EOC:
-		case JPC_MS_SOT:
+        case JPC_MS_SOT:
-			return 0;
+            return 0;
-			break;
+            break;
-		case JPC_MS_SOP:
+        case JPC_MS_SOP:
-		case JPC_MS_EPH:
+        case JPC_MS_EPH:
-		case 0:
+        case 0:
-			break;
+            break;
-		default:
+        default:
-			return -1;
+            return -1;
-			break;
+            break;
-		}
+        }
 }
-		if ((ret = jpc_pi_next(pi))) {
+        if ((ret = jpc_pi_next(pi))) {
-			return ret;
+            return ret;
-		}
+        }
 if (dec->maxpkts >= 0 && dec->numpkts >= dec->maxpkts) {
-	jas_eprintf("warning: stopping decode prematurely as requested\n");
+    jas_eprintf("warning: stopping decode prematurely as requested\n");
-	return 0;
+    return 0;
 }
-		if (jas_getdbglevel() >= 1) {
+        if (jas_getdbglevel() >= 1) {
-			jas_eprintf("packet offset=%08ld prg=%d cmptno=%02d "
+            jas_eprintf("packet offset=%08ld prg=%d cmptno=%02d "
-			  "rlvlno=%02d prcno=%03d lyrno=%02d\n", (long)
+              "rlvlno=%02d prcno=%03d lyrno=%02d\n", (long)
-			  jas_stream_getrwcount(in), jpc_pi_prg(pi), jpc_pi_cmptno(pi),
+              jas_stream_getrwcount(in), jpc_pi_prg(pi), jpc_pi_cmptno(pi),
-			  jpc_pi_rlvlno(pi), jpc_pi_prcno(pi), jpc_pi_lyrno(pi));
+              jpc_pi_rlvlno(pi), jpc_pi_prcno(pi), jpc_pi_lyrno(pi));
-		}
+        }
-		if (jpc_dec_decodepkt(dec, pkthdrstream, in, jpc_pi_cmptno(pi), jpc_pi_rlvlno(pi),
+        if (jpc_dec_decodepkt(dec, pkthdrstream, in, jpc_pi_cmptno(pi), jpc_pi_rlvlno(pi),
-		  jpc_pi_prcno(pi), jpc_pi_lyrno(pi))) {
+          jpc_pi_prcno(pi), jpc_pi_lyrno(pi))) {
-			return -1;
+            return -1;
-		}
+        }
 ++dec->numpkts;
-	}
+    }
 
-	return 0;
+    return 0;
 }
 
 jpc_pi_t *jpc_dec_pi_create(jpc_dec_t *dec, jpc_dec_tile_t *tile)
 {
-	jpc_pi_t *pi;
+    jpc_pi_t *pi;
-	int compno;
+    int compno;
-	jpc_picomp_t *picomp;
+    jpc_picomp_t *picomp;
-	jpc_pirlvl_t *pirlvl;
+    jpc_pirlvl_t *pirlvl;
-	jpc_dec_tcomp_t *tcomp;
+    jpc_dec_tcomp_t *tcomp;
-	int rlvlno;
+    int rlvlno;
-	jpc_dec_rlvl_t *rlvl;
+    jpc_dec_rlvl_t *rlvl;
-	int prcno;
+    int prcno;
-	int *prclyrno;
+    int *prclyrno;
-	jpc_dec_cmpt_t *cmpt;
+    jpc_dec_cmpt_t *cmpt;
 
-	if (!(pi = jpc_pi_create0())) {
+    if (!(pi = jpc_pi_create0())) {
-		return 0;
+        return 0;
-	}
+    }
-	pi->numcomps = dec->numcomps;
+    pi->numcomps = dec->numcomps;
-	if (!(pi->picomps = jas_alloc2(pi->numcomps, sizeof(jpc_picomp_t)))) {
+    if (!(pi->picomps = jas_alloc2(pi->numcomps, sizeof(jpc_picomp_t)))) {
-		jpc_pi_destroy(pi);
+        jpc_pi_destroy(pi);
-		return 0;
+        return 0;
-	}
+    }
-	for (compno = 0, picomp = pi->picomps; compno < pi->numcomps; ++compno,
+    for (compno = 0, picomp = pi->picomps; compno < pi->numcomps; ++compno,
-	  ++picomp) {
+      ++picomp) {
-		picomp->pirlvls = 0;
+        picomp->pirlvls = 0;
-	}
+    }
 
-	for (compno = 0, tcomp = tile->tcomps, picomp = pi->picomps;
+    for (compno = 0, tcomp = tile->tcomps, picomp = pi->picomps;
-	  compno < pi->numcomps; ++compno, ++tcomp, ++picomp) {
+      compno < pi->numcomps; ++compno, ++tcomp, ++picomp) {
-		picomp->numrlvls = tcomp->numrlvls;
+        picomp->numrlvls = tcomp->numrlvls;
-		if (!(picomp->pirlvls = jas_alloc2(picomp->numrlvls,
+        if (!(picomp->pirlvls = jas_alloc2(picomp->numrlvls,
-		  sizeof(jpc_pirlvl_t)))) {
+          sizeof(jpc_pirlvl_t)))) {
-			jpc_pi_destroy(pi);
+            jpc_pi_destroy(pi);
-			return 0;
+            return 0;
-		}
+        }
-		for (rlvlno = 0, pirlvl = picomp->pirlvls; rlvlno <
+        for (rlvlno = 0, pirlvl = picomp->pirlvls; rlvlno <
-		  picomp->numrlvls; ++rlvlno, ++pirlvl) {
+          picomp->numrlvls; ++rlvlno, ++pirlvl) {
-			pirlvl->prclyrnos = 0;
+            pirlvl->prclyrnos = 0;
-		}
+        }
-		for (rlvlno = 0, pirlvl = picomp->pirlvls, rlvl = tcomp->rlvls;
+        for (rlvlno = 0, pirlvl = picomp->pirlvls, rlvl = tcomp->rlvls;
-		  rlvlno < picomp->numrlvls; ++rlvlno, ++pirlvl, ++rlvl) {
+          rlvlno < picomp->numrlvls; ++rlvlno, ++pirlvl, ++rlvl) {
 /* XXX sizeof(long) should be sizeof different type */
-			pirlvl->numprcs = rlvl->numprcs;
+            pirlvl->numprcs = rlvl->numprcs;
-			if (!(pirlvl->prclyrnos = jas_alloc2(pirlvl->numprcs,
+            if (!(pirlvl->prclyrnos = jas_alloc2(pirlvl->numprcs,
-			  sizeof(long)))) {
+              sizeof(long)))) {
-				jpc_pi_destroy(pi);
+                jpc_pi_destroy(pi);
-				return 0;
+                return 0;
-			}
+            }
-		}
+        }
-	}
+    }
 
-	pi->maxrlvls = 0;
+    pi->maxrlvls = 0;
-	for (compno = 0, tcomp = tile->tcomps, picomp = pi->picomps, cmpt =
+    for (compno = 0, tcomp = tile->tcomps, picomp = pi->picomps, cmpt =
-	  dec->cmpts; compno < pi->numcomps; ++compno, ++tcomp, ++picomp,
+      dec->cmpts; compno < pi->numcomps; ++compno, ++tcomp, ++picomp,
-	  ++cmpt) {
+      ++cmpt) {
-		picomp->hsamp = cmpt->hstep;
+        picomp->hsamp = cmpt->hstep;
-		picomp->vsamp = cmpt->vstep;
+        picomp->vsamp = cmpt->vstep;
-		for (rlvlno = 0, pirlvl = picomp->pirlvls, rlvl = tcomp->rlvls;
+        for (rlvlno = 0, pirlvl = picomp->pirlvls, rlvl = tcomp->rlvls;
-		  rlvlno < picomp->numrlvls; ++rlvlno, ++pirlvl, ++rlvl) {
+          rlvlno < picomp->numrlvls; ++rlvlno, ++pirlvl, ++rlvl) {
-			pirlvl->prcwidthexpn = rlvl->prcwidthexpn;
+            pirlvl->prcwidthexpn = rlvl->prcwidthexpn;
-			pirlvl->prcheightexpn = rlvl->prcheightexpn;
+            pirlvl->prcheightexpn = rlvl->prcheightexpn;
-			for (prcno = 0, prclyrno = pirlvl->prclyrnos;
+            for (prcno = 0, prclyrno = pirlvl->prclyrnos;
-			  prcno < pirlvl->numprcs; ++prcno, ++prclyrno) {
+              prcno < pirlvl->numprcs; ++prcno, ++prclyrno) {
-				*prclyrno = 0;
+                *prclyrno = 0;
-			}
+            }
-			pirlvl->numhprcs = rlvl->numhprcs;
+            pirlvl->numhprcs = rlvl->numhprcs;
-		}
+        }
-		if (pi->maxrlvls < tcomp->numrlvls) {
+        if (pi->maxrlvls < tcomp->numrlvls) {
-			pi->maxrlvls = tcomp->numrlvls;
+            pi->maxrlvls = tcomp->numrlvls;
-		}
+        }
-	}
+    }
 
-	pi->numlyrs = tile->cp->numlyrs;
+    pi->numlyrs = tile->cp->numlyrs;
-	pi->xstart = tile->xstart;
+    pi->xstart = tile->xstart;
-	pi->ystart = tile->ystart;
+    pi->ystart = tile->ystart;
-	pi->xend = tile->xend;
+    pi->xend = tile->xend;
-	pi->yend = tile->yend;
+    pi->yend = tile->yend;
 
-	pi->picomp = 0;
+    pi->picomp = 0;
-	pi->pirlvl = 0;
+    pi->pirlvl = 0;
-	pi->x = 0;
+    pi->x = 0;
-	pi->y = 0;
+    pi->y = 0;
-	pi->compno = 0;
+    pi->compno = 0;
-	pi->rlvlno = 0;
+    pi->rlvlno = 0;
-	pi->prcno = 0;
+    pi->prcno = 0;
-	pi->lyrno = 0;
+    pi->lyrno = 0;
-	pi->xstep = 0;
+    pi->xstep = 0;
-	pi->ystep = 0;
+    pi->ystep = 0;
 
-	pi->pchgno = -1;
+    pi->pchgno = -1;
 
-	pi->defaultpchg.prgord = tile->cp->prgord;
+    pi->defaultpchg.prgord = tile->cp->prgord;
-	pi->defaultpchg.compnostart = 0;
+    pi->defaultpchg.compnostart = 0;
-	pi->defaultpchg.compnoend = pi->numcomps;
+    pi->defaultpchg.compnoend = pi->numcomps;
-	pi->defaultpchg.rlvlnostart = 0;
+    pi->defaultpchg.rlvlnostart = 0;
-	pi->defaultpchg.rlvlnoend = pi->maxrlvls;
+    pi->defaultpchg.rlvlnoend = pi->maxrlvls;
-	pi->defaultpchg.lyrnoend = pi->numlyrs;
+    pi->defaultpchg.lyrnoend = pi->numlyrs;
-	pi->pchg = 0;
+    pi->pchg = 0;
 
-	pi->valid = 0;
+    pi->valid = 0;
 
-	return pi;
+    return pi;
 }
 
 long jpc_dec_lookahead(jas_stream_t *in)
 {
-	uint_fast16_t x;
+    uint_fast16_t x;
-	if (jpc_getuint16(in, &x)) {
+    if (jpc_getuint16(in, &x)) {
-		return -1;
+        return -1;
-	}
+    }
-	if (jas_stream_ungetc(in, x & 0xff) == EOF ||
+    if (jas_stream_ungetc(in, x & 0xff) == EOF ||
-	  jas_stream_ungetc(in, x >> 8) == EOF) {
+      jas_stream_ungetc(in, x >> 8) == EOF) {
-		return -1;
+        return -1;
-	}
+    }
-	if (x >= JPC_MS_INMIN /*&& x <= JPC_MS_INMAX*/) {
+    if (x >= JPC_MS_INMIN /*&& x <= JPC_MS_INMAX*/) {
-		return x;
+        return x;
-	}
+    }
-	return 0;
+    return 0;
 }

3rdparty/libjasper/jpc_t2dec.h

@@ -6,15 +6,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,
@@ -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__
  */
 

3rdparty/libjasper/jpc_t2enc.h

@@ -6,15 +6,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,
@@ -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__
  */
 

3rdparty/libjasper/jpc_tagtree.c

@@ -6,15 +6,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,
@@ -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__
  */
 
@@ -94,99 +94,99 @@ static jpc_tagtree_t *jpc_tagtree_alloc(void);
 
 jpc_tagtree_t *jpc_tagtree_create(int numleafsh, int numleafsv)
 {
-	int nplh[JPC_TAGTREE_MAXDEPTH];
+    int nplh[JPC_TAGTREE_MAXDEPTH];
-	int nplv[JPC_TAGTREE_MAXDEPTH];
+    int nplv[JPC_TAGTREE_MAXDEPTH];
-	jpc_tagtreenode_t *node;
+    jpc_tagtreenode_t *node;
-	jpc_tagtreenode_t *parentnode;
+    jpc_tagtreenode_t *parentnode;
-	jpc_tagtreenode_t *parentnode0;
+    jpc_tagtreenode_t *parentnode0;
-	jpc_tagtree_t *tree;
+    jpc_tagtree_t *tree;
-	int i;
+    int i;
-	int j;
+    int j;
-	int k;
+    int k;
-	int numlvls;
+    int numlvls;
-	int n;
+    int n;
 
-	assert(numleafsh > 0 && numleafsv > 0);
+    assert(numleafsh > 0 && numleafsv > 0);
 
-	if (!(tree = jpc_tagtree_alloc())) {
+    if (!(tree = jpc_tagtree_alloc())) {
-		return 0;
+        return 0;
-	}
+    }
-	tree->numleafsh_ = numleafsh;
+    tree->numleafsh_ = numleafsh;
-	tree->numleafsv_ = numleafsv;
+    tree->numleafsv_ = numleafsv;
 
-	numlvls = 0;
+    numlvls = 0;
-	nplh[0] = numleafsh;
+    nplh[0] = numleafsh;
-	nplv[0] = numleafsv;
+    nplv[0] = numleafsv;
-	do {
+    do {
-		n = nplh[numlvls] * nplv[numlvls];
+        n = nplh[numlvls] * nplv[numlvls];
-		nplh[numlvls + 1] = (nplh[numlvls] + 1) / 2;
+        nplh[numlvls + 1] = (nplh[numlvls] + 1) / 2;
-		nplv[numlvls + 1] = (nplv[numlvls] + 1) / 2;
+        nplv[numlvls + 1] = (nplv[numlvls] + 1) / 2;
-		tree->numnodes_ += n;
+        tree->numnodes_ += n;
-		++numlvls;
+        ++numlvls;
-	} while (n > 1);
+    } while (n > 1);
 
-	if (!(tree->nodes_ = jas_alloc2(tree->numnodes_, sizeof(jpc_tagtreenode_t)))) {
+    if (!(tree->nodes_ = jas_alloc2(tree->numnodes_, sizeof(jpc_tagtreenode_t)))) {
-		return 0;
+        return 0;
-	}
+    }
 
-	/* Initialize the parent links for all nodes in the tree. */
+    /* Initialize the parent links for all nodes in the tree. */
 
-	node = tree->nodes_;
+    node = tree->nodes_;
-	parentnode = &tree->nodes_[tree->numleafsh_ * tree->numleafsv_];
+    parentnode = &tree->nodes_[tree->numleafsh_ * tree->numleafsv_];
-	parentnode0 = parentnode;
+    parentnode0 = parentnode;
 
-	for (i = 0; i < numlvls - 1; ++i) {
+    for (i = 0; i < numlvls - 1; ++i) {
-		for (j = 0; j < nplv[i]; ++j) {
+        for (j = 0; j < nplv[i]; ++j) {
-			k = nplh[i];
+            k = nplh[i];
-			while (--k >= 0) {
+            while (--k >= 0) {
-				node->parent_ = parentnode;
+                node->parent_ = parentnode;
-				++node;
+                ++node;
-				if (--k >= 0) {
+                if (--k >= 0) {
-					node->parent_ = parentnode;
+                    node->parent_ = parentnode;
-					++node;
+                    ++node;
-				}
+                }
-				++parentnode;
+                ++parentnode;
-			}
+            }
-			if ((j & 1) || j == nplv[i] - 1) {
+            if ((j & 1) || j == nplv[i] - 1) {
-				parentnode0 = parentnode;
+                parentnode0 = parentnode;
-			} else {
+            } else {
-				parentnode = parentnode0;
+                parentnode = parentnode0;
-				parentnode0 += nplh[i];
+                parentnode0 += nplh[i];
-			}
+            }
-		}
+        }
-	}
+    }
-	node->parent_ = 0;
+    node->parent_ = 0;
 
-	/* Initialize the data values to something sane. */
+    /* Initialize the data values to something sane. */
 
-	jpc_tagtree_reset(tree);
+    jpc_tagtree_reset(tree);
 
-	return tree;
+    return tree;
 }
 
 /* Destroy a tag tree. */
 
 void jpc_tagtree_destroy(jpc_tagtree_t *tree)
 {
-	if (tree->nodes_) {
+    if (tree->nodes_) {
-		jas_free(tree->nodes_);
+        jas_free(tree->nodes_);
-	}
+    }
-	jas_free(tree);
+    jas_free(tree);
 }
 
 static jpc_tagtree_t *jpc_tagtree_alloc()
 {
-	jpc_tagtree_t *tree;
+    jpc_tagtree_t *tree;
 
-	if (!(tree = jas_malloc(sizeof(jpc_tagtree_t)))) {
+    if (!(tree = jas_malloc(sizeof(jpc_tagtree_t)))) {
-		return 0;
+        return 0;
-	}
+    }
-	tree->numleafsh_ = 0;
+    tree->numleafsh_ = 0;
-	tree->numleafsv_ = 0;
+    tree->numleafsv_ = 0;
-	tree->numnodes_ = 0;
+    tree->numnodes_ = 0;
-	tree->nodes_ = 0;
+    tree->nodes_ = 0;
 
-	return tree;
+    return tree;
 }
 
 /******************************************************************************\
@@ -197,42 +197,42 @@ static jpc_tagtree_t *jpc_tagtree_alloc()
 
 void jpc_tagtree_copy(jpc_tagtree_t *dsttree, jpc_tagtree_t *srctree)
 {
-	int n;
+    int n;
-	jpc_tagtreenode_t *srcnode;
+    jpc_tagtreenode_t *srcnode;
-	jpc_tagtreenode_t *dstnode;
+    jpc_tagtreenode_t *dstnode;
 
-	/* The two tag trees must have similar sizes. */
+    /* The two tag trees must have similar sizes. */
-	assert(srctree->numleafsh_ == dsttree->numleafsh_ &&
+    assert(srctree->numleafsh_ == dsttree->numleafsh_ &&
-	  srctree->numleafsv_ == dsttree->numleafsv_);
+      srctree->numleafsv_ == dsttree->numleafsv_);
 
-	n = srctree->numnodes_;
+    n = srctree->numnodes_;
-	srcnode = srctree->nodes_;
+    srcnode = srctree->nodes_;
-	dstnode = dsttree->nodes_;
+    dstnode = dsttree->nodes_;
-	while (--n >= 0) {
+    while (--n >= 0) {
-		dstnode->value_ = srcnode->value_;
+        dstnode->value_ = srcnode->value_;
-		dstnode->low_ = srcnode->low_;
+        dstnode->low_ = srcnode->low_;
-		dstnode->known_ = srcnode->known_;
+        dstnode->known_ = srcnode->known_;
-		++dstnode;
+        ++dstnode;
-		++srcnode;
+        ++srcnode;
-	}
+    }
 }
 
 /* Reset all of the state information associated with a tag tree. */
 
 void jpc_tagtree_reset(jpc_tagtree_t *tree)
 {
-	int n;
+    int n;
-	jpc_tagtreenode_t *node;
+    jpc_tagtreenode_t *node;
 
-	n = tree->numnodes_;
+    n = tree->numnodes_;
-	node = tree->nodes_;
+    node = tree->nodes_;
 
-	while (--n >= 0) {
+    while (--n >= 0) {
-		node->value_ = INT_MAX;
+        node->value_ = INT_MAX;
-		node->low_ = 0;
+        node->low_ = 0;
-		node->known_ = 0;
+        node->known_ = 0;
-		++node;
+        ++node;
-	}
+    }
 }
 
 /* Set the value associated with the specified leaf node, updating
@@ -241,25 +241,25 @@ the other nodes as necessary. */
 void jpc_tagtree_setvalue(jpc_tagtree_t *tree, jpc_tagtreenode_t *leaf,
   int value)
 {
-	jpc_tagtreenode_t *node;
+    jpc_tagtreenode_t *node;
 
-	/* Avoid compiler warnings about unused parameters. */
+    /* Avoid compiler warnings about unused parameters. */
-	tree = 0;
+    tree = 0;
 
-	assert(value >= 0);
+    assert(value >= 0);
 
-	node = leaf;
+    node = leaf;
-	while (node && node->value_ > value) {
+    while (node && node->value_ > value) {
-		node->value_ = value;
+        node->value_ = value;
-		node = node->parent_;
+        node = node->parent_;
-	}
+    }
 }
 
 /* Get a particular leaf node. */
 
 jpc_tagtreenode_t *jpc_tagtree_getleaf(jpc_tagtree_t *tree, int n)
 {
-	return &tree->nodes_[n];
+    return &tree->nodes_[n];
 }
 
 /* Invoke the tag tree encoding procedure. */
@@ -267,58 +267,58 @@ jpc_tagtreenode_t *jpc_tagtree_getleaf(jpc_tagtree_t *tree, int n)
 int jpc_tagtree_encode(jpc_tagtree_t *tree, jpc_tagtreenode_t *leaf,
   int threshold, jpc_bitstream_t *out)
 {
-	jpc_tagtreenode_t *stk[JPC_TAGTREE_MAXDEPTH - 1];
+    jpc_tagtreenode_t *stk[JPC_TAGTREE_MAXDEPTH - 1];
-	jpc_tagtreenode_t **stkptr;
+    jpc_tagtreenode_t **stkptr;
-	jpc_tagtreenode_t *node;
+    jpc_tagtreenode_t *node;
-	int low;
+    int low;
 
-	/* Avoid compiler warnings about unused parameters. */
+    /* Avoid compiler warnings about unused parameters. */
-	tree = 0;
+    tree = 0;
 
-	assert(leaf);
+    assert(leaf);
-	assert(threshold >= 0);
+    assert(threshold >= 0);
 
-	/* Traverse to the root of the tree, recording the path taken. */
+    /* Traverse to the root of the tree, recording the path taken. */
-	stkptr = stk;
+    stkptr = stk;
-	node = leaf;
+    node = leaf;
-	while (node->parent_) {
+    while (node->parent_) {
-		*stkptr++ = node;
+        *stkptr++ = node;
-		node = node->parent_;
+        node = node->parent_;
-	}
+    }
 
-	low = 0;
+    low = 0;
-	for (;;) {
+    for (;;) {
-		if (low > node->low_) {
+        if (low > node->low_) {
-			/* Deferred propagation of the lower bound downward in
+            /* Deferred propagation of the lower bound downward in
-			  the tree. */
+              the tree. */
-			node->low_ = low;
+            node->low_ = low;
-		} else {
+        } else {
-			low = node->low_;
+            low = node->low_;
-		}
+        }
 
-		while (low < threshold) {
+        while (low < threshold) {
-			if (low >= node->value_) {
+            if (low >= node->value_) {
-				if (!node->known_) {
+                if (!node->known_) {
-					if (jpc_bitstream_putbit(out, 1) == EOF) {
+                    if (jpc_bitstream_putbit(out, 1) == EOF) {
-						return -1;
+                        return -1;
-					}
+                    }
-					node->known_ = 1;
+                    node->known_ = 1;
-				}
+                }
-				break;
+                break;
-			}
+            }
-			if (jpc_bitstream_putbit(out, 0) == EOF) {
+            if (jpc_bitstream_putbit(out, 0) == EOF) {
-				return -1;
+                return -1;
-			}
+            }
-			++low;
+            ++low;
-		}
+        }
-		node->low_ = low;
+        node->low_ = low;
-		if (stkptr == stk) {
+        if (stkptr == stk) {
-			break;
+            break;
-		}
+        }
-		node = *--stkptr;
+        node = *--stkptr;
 
-	}
+    }
-	return (leaf->low_ < threshold) ? 1 : 0;
+    return (leaf->low_ < threshold) ? 1 : 0;
 
 }
 
@@ -327,50 +327,50 @@ int jpc_tagtree_encode(jpc_tagtree_t *tree, jpc_tagtreenode_t *leaf,
 int jpc_tagtree_decode(jpc_tagtree_t *tree, jpc_tagtreenode_t *leaf,
   int threshold, jpc_bitstream_t *in)
 {
-	jpc_tagtreenode_t *stk[JPC_TAGTREE_MAXDEPTH - 1];
+    jpc_tagtreenode_t *stk[JPC_TAGTREE_MAXDEPTH - 1];
-	jpc_tagtreenode_t **stkptr;
+    jpc_tagtreenode_t **stkptr;
-	jpc_tagtreenode_t *node;
+    jpc_tagtreenode_t *node;
-	int low;
+    int low;
-	int ret;
+    int ret;
 
-	/* Avoid compiler warnings about unused parameters. */
+    /* Avoid compiler warnings about unused parameters. */
-	tree = 0;
+    tree = 0;
 
-	assert(threshold >= 0);
+    assert(threshold >= 0);
 
-	/* Traverse to the root of the tree, recording the path taken. */
+    /* Traverse to the root of the tree, recording the path taken. */
-	stkptr = stk;
+    stkptr = stk;
-	node = leaf;
+    node = leaf;
-	while (node->parent_) {
+    while (node->parent_) {
-		*stkptr++ = node;
+        *stkptr++ = node;
-		node = node->parent_;
+        node = node->parent_;
-	}
+    }
 
-	low = 0;
+    low = 0;
-	for (;;) {
+    for (;;) {
-		if (low > node->low_) {
+        if (low > node->low_) {
-			node->low_ = low;
+            node->low_ = low;
-		} else {
+        } else {
-			low = node->low_;
+            low = node->low_;
-		}
+        }
-		while (low < threshold && low < node->value_) {
+        while (low < threshold && low < node->value_) {
-			if ((ret = jpc_bitstream_getbit(in)) < 0) {
+            if ((ret = jpc_bitstream_getbit(in)) < 0) {
-				return -1;
+                return -1;
-			}
+            }
-			if (ret) {
+            if (ret) {
-				node->value_ = low;
+                node->value_ = low;
-			} else {
+            } else {
-				++low;
+                ++low;
-			}
+            }
-		}
+        }
-		node->low_ = low;
+        node->low_ = low;
-		if (stkptr == stk) {
+        if (stkptr == stk) {
-			break;
+            break;
-		}
+        }
-		node = *--stkptr;
+        node = *--stkptr;
-	}
+    }
 
-	return (node->value_ < threshold) ? 1 : 0;
+    return (node->value_ < threshold) ? 1 : 0;
 }
 
 /******************************************************************************\
@@ -379,15 +379,15 @@ int jpc_tagtree_decode(jpc_tagtree_t *tree, jpc_tagtreenode_t *leaf,
 
 void jpc_tagtree_dump(jpc_tagtree_t *tree, FILE *out)
 {
-	jpc_tagtreenode_t *node;
+    jpc_tagtreenode_t *node;
-	int n;
+    int n;
 
-	node = tree->nodes_;
+    node = tree->nodes_;
-	n = tree->numnodes_;
+    n = tree->numnodes_;
-	while (--n >= 0) {
+    while (--n >= 0) {
-		fprintf(out, "node %p, parent %p, value %d, lower %d, known %d\n",
+        fprintf(out, "node %p, parent %p, value %d, lower %d, known %d\n",
-		  (void *) node, (void *) node->parent_, node->value_, node->low_,
+          (void *) node, (void *) node->parent_, node->value_, node->low_,
-		  node->known_);
+          node->known_);
-		++node;
+        ++node;
-	}
+    }
 }

3rdparty/libjasper/jpc_tagtree.h

@@ -6,15 +6,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,
@@ -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__
  */
 
@@ -96,17 +96,17 @@
 
 typedef struct jpc_tagtreenode_ {
 
-	/* The parent of this node. */
+    /* The parent of this node. */
-	struct jpc_tagtreenode_ *parent_;
+    struct jpc_tagtreenode_ *parent_;
 
-	/* The value associated with this node. */
+    /* The value associated with this node. */
-	int value_;
+    int value_;
 
-	/* The lower bound on the value associated with this node. */
+    /* The lower bound on the value associated with this node. */
-	int low_;
+    int low_;
 
-	/* A flag indicating if the value is known exactly. */
+    /* A flag indicating if the value is known exactly. */
-	int known_;
+    int known_;
 
 } jpc_tagtreenode_t;
 
@@ -116,17 +116,17 @@ typedef struct jpc_tagtreenode_ {
 
 typedef struct {
 
-	/* The number of leaves in the horizontal direction. */
+    /* The number of leaves in the horizontal direction. */
-	int numleafsh_;
+    int numleafsh_;
 
-	/* The number of leaves in the vertical direction. */
+    /* The number of leaves in the vertical direction. */
-	int numleafsv_;
+    int numleafsv_;
 
-	/* The total number of nodes in the tree. */
+    /* The total number of nodes in the tree. */
-	int numnodes_;
+    int numnodes_;
 
-	/* The nodes. */
+    /* The nodes. */
-	jpc_tagtreenode_t *nodes_;
+    jpc_tagtreenode_t *nodes_;
 
 } jpc_tagtree_t;
 

3rdparty/libjasper/jpc_tsfb.c

@@ -6,15 +6,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,
@@ -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__
  */
 
@@ -92,197 +92,197 @@ void jpc_tsfb_getbands2(jpc_tsfb_t *tsfb, int locxstart, int locystart,
 
 jpc_tsfb_t *jpc_cod_gettsfb(int qmfbid, int numlvls)
 {
-	jpc_tsfb_t *tsfb;
+    jpc_tsfb_t *tsfb;
 
-	if (!(tsfb = malloc(sizeof(jpc_tsfb_t))))
+    if (!(tsfb = malloc(sizeof(jpc_tsfb_t))))
-		return 0;
+        return 0;
 
-	if (numlvls > 0) {
+    if (numlvls > 0) {
-		switch (qmfbid) {
+        switch (qmfbid) {
-		case JPC_COX_INS:
+        case JPC_COX_INS:
-			tsfb->qmfb = &jpc_ns_qmfb2d;
+            tsfb->qmfb = &jpc_ns_qmfb2d;
-			break;
+            break;
-		default:
+        default:
-		case JPC_COX_RFT:
+        case JPC_COX_RFT:
-			tsfb->qmfb = &jpc_ft_qmfb2d;
+            tsfb->qmfb = &jpc_ft_qmfb2d;
-			break;
+            break;
-		}
+        }
-	} else {
+    } else {
-		tsfb->qmfb = 0;
+        tsfb->qmfb = 0;
-	}
+    }
-	tsfb->numlvls = numlvls;
+    tsfb->numlvls = numlvls;
-	return tsfb;
+    return tsfb;
 }
 
 void jpc_tsfb_destroy(jpc_tsfb_t *tsfb)
 {
-	free(tsfb);
+    free(tsfb);
 }
 
 int jpc_tsfb_analyze(jpc_tsfb_t *tsfb, jas_seq2d_t *a)
 {
-	return (tsfb->numlvls > 0) ? jpc_tsfb_analyze2(tsfb, jas_seq2d_getref(a,
+    return (tsfb->numlvls > 0) ? jpc_tsfb_analyze2(tsfb, jas_seq2d_getref(a,
-	  jas_seq2d_xstart(a), jas_seq2d_ystart(a)), jas_seq2d_xstart(a),
+      jas_seq2d_xstart(a), jas_seq2d_ystart(a)), jas_seq2d_xstart(a),
-	  jas_seq2d_ystart(a), jas_seq2d_width(a),
+      jas_seq2d_ystart(a), jas_seq2d_width(a),
-	  jas_seq2d_height(a), jas_seq2d_rowstep(a), tsfb->numlvls - 1) : 0;
+      jas_seq2d_height(a), jas_seq2d_rowstep(a), tsfb->numlvls - 1) : 0;
 }
 
 int jpc_tsfb_analyze2(jpc_tsfb_t *tsfb, int *a, int xstart, int ystart,
   int width, int height, int stride, int numlvls)
 {
-	if (width > 0 && height > 0) {
+    if (width > 0 && height > 0) {
-		if ((*tsfb->qmfb->analyze)(a, xstart, ystart, width, height, stride))
+        if ((*tsfb->qmfb->analyze)(a, xstart, ystart, width, height, stride))
-			return -1;
+            return -1;
-		if (numlvls > 0) {
+        if (numlvls > 0) {
-			if (jpc_tsfb_analyze2(tsfb, a, JPC_CEILDIVPOW2(xstart,
+            if (jpc_tsfb_analyze2(tsfb, a, JPC_CEILDIVPOW2(xstart,
-			  1), JPC_CEILDIVPOW2(ystart, 1), JPC_CEILDIVPOW2(
+              1), JPC_CEILDIVPOW2(ystart, 1), JPC_CEILDIVPOW2(
-			  xstart + width, 1) - JPC_CEILDIVPOW2(xstart, 1),
+              xstart + width, 1) - JPC_CEILDIVPOW2(xstart, 1),
-			  JPC_CEILDIVPOW2(ystart + height, 1) -
+              JPC_CEILDIVPOW2(ystart + height, 1) -
-			  JPC_CEILDIVPOW2(ystart, 1), stride, numlvls - 1)) {
+              JPC_CEILDIVPOW2(ystart, 1), stride, numlvls - 1)) {
-				return -1;
+                return -1;
-			}
+            }
-		}
+        }
-	}
+    }
-	return 0;
+    return 0;
 }
 
 int jpc_tsfb_synthesize(jpc_tsfb_t *tsfb, jas_seq2d_t *a)
 {
-	return (tsfb->numlvls > 0) ? jpc_tsfb_synthesize2(tsfb,
+    return (tsfb->numlvls > 0) ? jpc_tsfb_synthesize2(tsfb,
-	  jas_seq2d_getref(a, jas_seq2d_xstart(a), jas_seq2d_ystart(a)),
+      jas_seq2d_getref(a, jas_seq2d_xstart(a), jas_seq2d_ystart(a)),
-	  jas_seq2d_xstart(a), jas_seq2d_ystart(a), jas_seq2d_width(a),
+      jas_seq2d_xstart(a), jas_seq2d_ystart(a), jas_seq2d_width(a),
-	  jas_seq2d_height(a), jas_seq2d_rowstep(a), tsfb->numlvls - 1) : 0;
+      jas_seq2d_height(a), jas_seq2d_rowstep(a), tsfb->numlvls - 1) : 0;
 }
 
 int jpc_tsfb_synthesize2(jpc_tsfb_t *tsfb, int *a, int xstart, int ystart,
   int width, int height, int stride, int numlvls)
 {
-	if (numlvls > 0) {
+    if (numlvls > 0) {
-		if (jpc_tsfb_synthesize2(tsfb, a, JPC_CEILDIVPOW2(xstart, 1),
+        if (jpc_tsfb_synthesize2(tsfb, a, JPC_CEILDIVPOW2(xstart, 1),
-		  JPC_CEILDIVPOW2(ystart, 1), JPC_CEILDIVPOW2(xstart + width,
+          JPC_CEILDIVPOW2(ystart, 1), JPC_CEILDIVPOW2(xstart + width,
-		  1) - JPC_CEILDIVPOW2(xstart, 1), JPC_CEILDIVPOW2(ystart +
+          1) - JPC_CEILDIVPOW2(xstart, 1), JPC_CEILDIVPOW2(ystart +
-		  height, 1) - JPC_CEILDIVPOW2(ystart, 1), stride, numlvls -
+          height, 1) - JPC_CEILDIVPOW2(ystart, 1), stride, numlvls -
-		  1)) {
+          1)) {
-			return -1;
+            return -1;
-		}
+        }
-	}
+    }
-	if (width > 0 && height > 0) {
+    if (width > 0 && height > 0) {
-		if ((*tsfb->qmfb->synthesize)(a, xstart, ystart, width, height, stride)) {
+        if ((*tsfb->qmfb->synthesize)(a, xstart, ystart, width, height, stride)) {
-			return -1;
+            return -1;
-		}
+        }
-	}
+    }
-	return 0;
+    return 0;
 }
 
 int jpc_tsfb_getbands(jpc_tsfb_t *tsfb, uint_fast32_t xstart,
   uint_fast32_t ystart, uint_fast32_t xend, uint_fast32_t yend,
   jpc_tsfb_band_t *bands)
 {
-	jpc_tsfb_band_t *band;
+    jpc_tsfb_band_t *band;
 
-	band = bands;
+    band = bands;
-	if (tsfb->numlvls > 0) {
+    if (tsfb->numlvls > 0) {
-		jpc_tsfb_getbands2(tsfb, xstart, ystart, xstart, ystart, xend, yend,
+        jpc_tsfb_getbands2(tsfb, xstart, ystart, xstart, ystart, xend, yend,
-		  &band, tsfb->numlvls);
+          &band, tsfb->numlvls);
-	} else {
+    } else {
 
-		band->xstart = xstart;
+        band->xstart = xstart;
-		band->ystart = ystart;
+        band->ystart = ystart;
-		band->xend = xend;
+        band->xend = xend;
-		band->yend = yend;
+        band->yend = yend;
-		band->locxstart = xstart;
+        band->locxstart = xstart;
-		band->locystart = ystart;
+        band->locystart = ystart;
-		band->locxend = band->locxstart + band->xend - band->xstart;
+        band->locxend = band->locxstart + band->xend - band->xstart;
-		band->locyend = band->locystart + band->yend - band->ystart;
+        band->locyend = band->locystart + band->yend - band->ystart;
-		band->orient = JPC_TSFB_LL;
+        band->orient = JPC_TSFB_LL;
-		band->synenergywt = JPC_FIX_ONE;
+        band->synenergywt = JPC_FIX_ONE;
-		++band;
+        ++band;
-	}
+    }
-	return band - bands;
+    return band - bands;
 }
 
 void jpc_tsfb_getbands2(jpc_tsfb_t *tsfb, int locxstart, int locystart,
   int xstart, int ystart, int xend, int yend, jpc_tsfb_band_t **bands,
   int numlvls)
 {
-	int newxstart;
+    int newxstart;
-	int newystart;
+    int newystart;
-	int newxend;
+    int newxend;
-	int newyend;
+    int newyend;
-	jpc_tsfb_band_t *band;
+    jpc_tsfb_band_t *band;
 
-	newxstart = JPC_CEILDIVPOW2(xstart, 1);
+    newxstart = JPC_CEILDIVPOW2(xstart, 1);
-	newystart = JPC_CEILDIVPOW2(ystart, 1);
+    newystart = JPC_CEILDIVPOW2(ystart, 1);
-	newxend = JPC_CEILDIVPOW2(xend, 1);
+    newxend = JPC_CEILDIVPOW2(xend, 1);
-	newyend = JPC_CEILDIVPOW2(yend, 1);
+    newyend = JPC_CEILDIVPOW2(yend, 1);
 
-	if (numlvls > 0) {
+    if (numlvls > 0) {
 
-		jpc_tsfb_getbands2(tsfb, locxstart, locystart, newxstart, newystart,
+        jpc_tsfb_getbands2(tsfb, locxstart, locystart, newxstart, newystart,
-		  newxend, newyend, bands, numlvls - 1);
+          newxend, newyend, bands, numlvls - 1);
 
-		band = *bands;
+        band = *bands;
-		band->xstart = JPC_FLOORDIVPOW2(xstart, 1);
+        band->xstart = JPC_FLOORDIVPOW2(xstart, 1);
-		band->ystart = newystart;
+        band->ystart = newystart;
-		band->xend = JPC_FLOORDIVPOW2(xend, 1);
+        band->xend = JPC_FLOORDIVPOW2(xend, 1);
-		band->yend = newyend;
+        band->yend = newyend;
-		band->locxstart = locxstart + newxend - newxstart;
+        band->locxstart = locxstart + newxend - newxstart;
-		band->locystart = locystart;
+        band->locystart = locystart;
-		band->locxend = band->locxstart + band->xend - band->xstart;
+        band->locxend = band->locxstart + band->xend - band->xstart;
-		band->locyend = band->locystart + band->yend - band->ystart;
+        band->locyend = band->locystart + band->yend - band->ystart;
-		band->orient = JPC_TSFB_HL;
+        band->orient = JPC_TSFB_HL;
-		band->synenergywt = jpc_dbltofix(tsfb->qmfb->hpenergywts[
+        band->synenergywt = jpc_dbltofix(tsfb->qmfb->hpenergywts[
-		  tsfb->numlvls - numlvls] * tsfb->qmfb->lpenergywts[
+          tsfb->numlvls - numlvls] * tsfb->qmfb->lpenergywts[
-		  tsfb->numlvls - numlvls]);
+          tsfb->numlvls - numlvls]);
-		++(*bands);
+        ++(*bands);
 
-		band = *bands;
+        band = *bands;
-		band->xstart = newxstart;
+        band->xstart = newxstart;
-		band->ystart = JPC_FLOORDIVPOW2(ystart, 1);
+        band->ystart = JPC_FLOORDIVPOW2(ystart, 1);
-		band->xend = newxend;
+        band->xend = newxend;
-		band->yend = JPC_FLOORDIVPOW2(yend, 1);
+        band->yend = JPC_FLOORDIVPOW2(yend, 1);
-		band->locxstart = locxstart;
+        band->locxstart = locxstart;
-		band->locystart = locystart + newyend - newystart;
+        band->locystart = locystart + newyend - newystart;
-		band->locxend = band->locxstart + band->xend - band->xstart;
+        band->locxend = band->locxstart + band->xend - band->xstart;
-		band->locyend = band->locystart + band->yend - band->ystart;
+        band->locyend = band->locystart + band->yend - band->ystart;
-		band->orient = JPC_TSFB_LH;
+        band->orient = JPC_TSFB_LH;
-		band->synenergywt = jpc_dbltofix(tsfb->qmfb->lpenergywts[
+        band->synenergywt = jpc_dbltofix(tsfb->qmfb->lpenergywts[
-		  tsfb->numlvls - numlvls] * tsfb->qmfb->hpenergywts[
+          tsfb->numlvls - numlvls] * tsfb->qmfb->hpenergywts[
-		  tsfb->numlvls - numlvls]);
+          tsfb->numlvls - numlvls]);
-		++(*bands);
+        ++(*bands);
 
-		band = *bands;
+        band = *bands;
-		band->xstart = JPC_FLOORDIVPOW2(xstart, 1);
+        band->xstart = JPC_FLOORDIVPOW2(xstart, 1);
-		band->ystart = JPC_FLOORDIVPOW2(ystart, 1);
+        band->ystart = JPC_FLOORDIVPOW2(ystart, 1);
-		band->xend = JPC_FLOORDIVPOW2(xend, 1);
+        band->xend = JPC_FLOORDIVPOW2(xend, 1);
-		band->yend = JPC_FLOORDIVPOW2(yend, 1);
+        band->yend = JPC_FLOORDIVPOW2(yend, 1);
-		band->locxstart = locxstart + newxend - newxstart;
+        band->locxstart = locxstart + newxend - newxstart;
-		band->locystart = locystart + newyend - newystart;
+        band->locystart = locystart + newyend - newystart;
-		band->locxend = band->locxstart + band->xend - band->xstart;
+        band->locxend = band->locxstart + band->xend - band->xstart;
-		band->locyend = band->locystart + band->yend - band->ystart;
+        band->locyend = band->locystart + band->yend - band->ystart;
-		band->orient = JPC_TSFB_HH;
+        band->orient = JPC_TSFB_HH;
-		band->synenergywt = jpc_dbltofix(tsfb->qmfb->hpenergywts[
+        band->synenergywt = jpc_dbltofix(tsfb->qmfb->hpenergywts[
-		  tsfb->numlvls - numlvls] * tsfb->qmfb->hpenergywts[
+          tsfb->numlvls - numlvls] * tsfb->qmfb->hpenergywts[
-		  tsfb->numlvls - numlvls]);
+          tsfb->numlvls - numlvls]);
-		++(*bands);
+        ++(*bands);
 
-	} else {
+    } else {
 
-		band = *bands;
+        band = *bands;
-		band->xstart = xstart;
+        band->xstart = xstart;
-		band->ystart = ystart;
+        band->ystart = ystart;
-		band->xend = xend;
+        band->xend = xend;
-		band->yend = yend;
+        band->yend = yend;
-		band->locxstart = locxstart;
+        band->locxstart = locxstart;
-		band->locystart = locystart;
+        band->locystart = locystart;
-		band->locxend = band->locxstart + band->xend - band->xstart;
+        band->locxend = band->locxstart + band->xend - band->xstart;
-		band->locyend = band->locystart + band->yend - band->ystart;
+        band->locyend = band->locystart + band->yend - band->ystart;
-		band->orient = JPC_TSFB_LL;
+        band->orient = JPC_TSFB_LL;
-		band->synenergywt = jpc_dbltofix(tsfb->qmfb->lpenergywts[
+        band->synenergywt = jpc_dbltofix(tsfb->qmfb->lpenergywts[
-		  tsfb->numlvls - numlvls - 1] * tsfb->qmfb->lpenergywts[
+          tsfb->numlvls - numlvls - 1] * tsfb->qmfb->lpenergywts[
-		  tsfb->numlvls - numlvls - 1]);
+          tsfb->numlvls - numlvls - 1]);
-		++(*bands);
+        ++(*bands);
 
-	}
+    }
 
 }

3rdparty/libjasper/jpc_tsfb.h

@@ -6,15 +6,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,
@@ -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__
  */
 
@@ -97,21 +97,21 @@
 \******************************************************************************/
 
 typedef struct {
-	int xstart;
+    int xstart;
-	int ystart;
+    int ystart;
-	int xend;
+    int xend;
-	int yend;
+    int yend;
-	int orient;
+    int orient;
-	int locxstart;
+    int locxstart;
-	int locystart;
+    int locystart;
-	int locxend;
+    int locxend;
-	int locyend;
+    int locyend;
-	jpc_fix_t synenergywt;
+    jpc_fix_t synenergywt;
 } jpc_tsfb_band_t;
 
 typedef struct {
-	int numlvls;
+    int numlvls;
-	jpc_qmfb2d_t *qmfb;
+    jpc_qmfb2d_t *qmfb;
 } jpc_tsfb_t;
 
 /******************************************************************************\

3rdparty/libjasper/jpc_util.c

@@ -6,15 +6,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,
@@ -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__
  */
 
@@ -90,105 +90,105 @@
 
 int jpc_atoaf(char *s, int *numvalues, double **values)
 {
-	static char delim[] = ", \t\n";
+    static char delim[] = ", \t\n";
-	char buf[4096];
+    char buf[4096];
-	int n;
+    int n;
-	double *vs;
+    double *vs;
-	char *cp;
+    char *cp;
 
-	strncpy(buf, s, sizeof(buf));
+    strncpy(buf, s, sizeof(buf));
-	buf[sizeof(buf) - 1] = '\0';
+    buf[sizeof(buf) - 1] = '\0';
-	n = 0;
+    n = 0;
-	if ((cp = strtok(buf, delim))) {
+    if ((cp = strtok(buf, delim))) {
-		++n;
+        ++n;
-		while ((cp = strtok(0, delim))) {
+        while ((cp = strtok(0, delim))) {
-			if (cp != '\0') {
+            if (cp != '\0') {
-				++n;
+                ++n;
-			}
+            }
-		}
+        }
-	}
+    }
 
-	if (n) {
+    if (n) {
-		if (!(vs = jas_alloc2(n, sizeof(double)))) {
+        if (!(vs = jas_alloc2(n, sizeof(double)))) {
-			return -1;
+            return -1;
-		}
+        }
 
-		strncpy(buf, s, sizeof(buf));
+        strncpy(buf, s, sizeof(buf));
-		buf[sizeof(buf) - 1] = '\0';
+        buf[sizeof(buf) - 1] = '\0';
-		n = 0;
+        n = 0;
-		if ((cp = strtok(buf, delim))) {
+        if ((cp = strtok(buf, delim))) {
-			vs[n] = atof(cp);
+            vs[n] = atof(cp);
-			++n;
+            ++n;
-			while ((cp = strtok(0, delim))) {
+            while ((cp = strtok(0, delim))) {
-				if (cp != '\0') {
+                if (cp != '\0') {
-					vs[n] = atof(cp);
+                    vs[n] = atof(cp);
-					++n;
+                    ++n;
-				}
+                }
-			}
+            }
-		}
+        }
-	} else {
+    } else {
-		vs = 0;
+        vs = 0;
-	}
+    }
 
-	*numvalues = n;
+    *numvalues = n;
-	*values = vs;
+    *values = vs;
 
-	return 0;
+    return 0;
 }
 
 jas_seq_t *jpc_seq_upsample(jas_seq_t *x, int m)
 {
-	jas_seq_t *z;
+    jas_seq_t *z;
-	int i;
+    int i;
 
-	if (!(z = jas_seq_create(jas_seq_start(x) * m, (jas_seq_end(x) - 1) * m + 1)))
+    if (!(z = jas_seq_create(jas_seq_start(x) * m, (jas_seq_end(x) - 1) * m + 1)))
-		return 0;
+        return 0;
-	for (i = jas_seq_start(z); i < jas_seq_end(z); i++) {
+    for (i = jas_seq_start(z); i < jas_seq_end(z); i++) {
-		*jas_seq_getref(z, i) = (!JAS_MOD(i, m)) ? jas_seq_get(x, i / m) :
+        *jas_seq_getref(z, i) = (!JAS_MOD(i, m)) ? jas_seq_get(x, i / m) :
-		  jpc_inttofix(0);
+          jpc_inttofix(0);
-	}
+    }
 
-	return z;
+    return z;
 }
 
 jpc_fix_t jpc_seq_norm(jas_seq_t *x)
 {
-	jpc_fix_t s;
+    jpc_fix_t s;
-	int i;
+    int i;
 
-	s = jpc_inttofix(0);
+    s = jpc_inttofix(0);
-	for (i = jas_seq_start(x); i < jas_seq_end(x); i++) {
+    for (i = jas_seq_start(x); i < jas_seq_end(x); i++) {
-		s = jpc_fix_add(s, jpc_fix_mul(jas_seq_get(x, i), jas_seq_get(x, i)));
+        s = jpc_fix_add(s, jpc_fix_mul(jas_seq_get(x, i), jas_seq_get(x, i)));
-	}
+    }
 
-	return jpc_dbltofix(sqrt(jpc_fixtodbl(s)));
+    return jpc_dbltofix(sqrt(jpc_fixtodbl(s)));
 }
 
 jas_seq_t *jpc_seq_conv(jas_seq_t *x, jas_seq_t *y)
 {
-	int i;
+    int i;
-	int j;
+    int j;
-	int k;
+    int k;
-	jas_seq_t *z;
+    jas_seq_t *z;
-	jpc_fix_t s;
+    jpc_fix_t s;
-	jpc_fix_t v;
+    jpc_fix_t v;
 
-	z = jas_seq_create(jas_seq_start(x) + jas_seq_start(y),
+    z = jas_seq_create(jas_seq_start(x) + jas_seq_start(y),
-	  jas_seq_end(x) + jas_seq_end(y) - 1);
+      jas_seq_end(x) + jas_seq_end(y) - 1);
-	assert(z);
+    assert(z);
-	for (i = jas_seq_start(z); i < jas_seq_end(z); i++) {
+    for (i = jas_seq_start(z); i < jas_seq_end(z); i++) {
-		s = jpc_inttofix(0);
+        s = jpc_inttofix(0);
-		for (j = jas_seq_start(y); j < jas_seq_end(y); j++) {
+        for (j = jas_seq_start(y); j < jas_seq_end(y); j++) {
-			k = i - j;
+            k = i - j;
-			if (k < jas_seq_start(x) || k >= jas_seq_end(x)) {
+            if (k < jas_seq_start(x) || k >= jas_seq_end(x)) {
-				v = JPC_FIX_ZERO;
+                v = JPC_FIX_ZERO;
-			} else {
+            } else {
-				v = jas_seq_get(x, k);
+                v = jas_seq_get(x, k);
-			}
+            }
-			s = jpc_fix_add(s, jpc_fix_mul(jas_seq_get(y, j), v));
+            s = jpc_fix_add(s, jpc_fix_mul(jas_seq_get(y, j), v));
-		}
+        }
-		*jas_seq_getref(z, i) = s;
+        *jas_seq_getref(z, i) = s;
-	}
+    }
 
-	return z;
+    return z;
 }

3rdparty/libjasper/jpc_util.h

@@ -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__
  */
 

3rdparty/libjpeg/jcapimin.c

@@ -36,8 +36,8 @@ jpeg_CreateCompress (j_compress_ptr cinfo, int version, size_t structsize)
   if (version != JPEG_LIB_VERSION)
     ERREXIT2(cinfo, JERR_BAD_LIB_VERSION, JPEG_LIB_VERSION, version);
   if (structsize != SIZEOF(struct jpeg_compress_struct))
-    ERREXIT2(cinfo, JERR_BAD_STRUCT_SIZE, 
+    ERREXIT2(cinfo, JERR_BAD_STRUCT_SIZE,
-	     (int) SIZEOF(struct jpeg_compress_struct), (int) structsize);
+         (int) SIZEOF(struct jpeg_compress_struct), (int) structsize);
 
   /* For debugging purposes, we zero the whole master structure.
    * But the application has already set the err pointer, and may have set
@@ -161,15 +161,15 @@ jpeg_finish_compress (j_compress_ptr cinfo)
     (*cinfo->master->prepare_for_pass) (cinfo);
     for (iMCU_row = 0; iMCU_row < cinfo->total_iMCU_rows; iMCU_row++) {
       if (cinfo->progress != NULL) {
-	cinfo->progress->pass_counter = (long) iMCU_row;
+    cinfo->progress->pass_counter = (long) iMCU_row;
-	cinfo->progress->pass_limit = (long) cinfo->total_iMCU_rows;
+    cinfo->progress->pass_limit = (long) cinfo->total_iMCU_rows;
-	(*cinfo->progress->progress_monitor) ((j_common_ptr) cinfo);
+    (*cinfo->progress->progress_monitor) ((j_common_ptr) cinfo);
       }
       /* We bypass the main controller and invoke coef controller directly;
        * all work is being done from the coefficient buffer.
        */
       if (! (*cinfo->coef->compress_data) (cinfo, (JSAMPIMAGE) NULL))
-	ERREXIT(cinfo, JERR_CANT_SUSPEND);
+    ERREXIT(cinfo, JERR_CANT_SUSPEND);
     }
     (*cinfo->master->finish_pass) (cinfo);
   }
@@ -190,7 +190,7 @@ jpeg_finish_compress (j_compress_ptr cinfo)
 
 GLOBAL(void)
 jpeg_write_marker (j_compress_ptr cinfo, int marker,
-		   const JOCTET *dataptr, unsigned int datalen)
+           const JOCTET *dataptr, unsigned int datalen)
 {
   JMETHOD(void, write_marker_byte, (j_compress_ptr info, int val));
 

3rdparty/libjpeg/jcapistd.c

@@ -75,7 +75,7 @@ jpeg_start_compress (j_compress_ptr cinfo, boolean write_all_tables)
 
 GLOBAL(JDIMENSION)
 jpeg_write_scanlines (j_compress_ptr cinfo, JSAMPARRAY scanlines,
-		      JDIMENSION num_lines)
+              JDIMENSION num_lines)
 {
   JDIMENSION row_ctr, rows_left;
 
@@ -118,7 +118,7 @@ jpeg_write_scanlines (j_compress_ptr cinfo, JSAMPARRAY scanlines,
 
 GLOBAL(JDIMENSION)
 jpeg_write_raw_data (j_compress_ptr cinfo, JSAMPIMAGE data,
-		     JDIMENSION num_lines)
+             JDIMENSION num_lines)
 {
   JDIMENSION lines_per_iMCU_row;
 

3rdparty/libjpeg/jccoefct.c

@@ -154,7 +154,7 @@ compress_data (j_compress_ptr cinfo, JSAMPIMAGE input_buf)
   for (yoffset = coef->MCU_vert_offset; yoffset < coef->MCU_rows_per_iMCU_row;
        yoffset++) {
     for (MCU_col_num = coef->mcu_ctr; MCU_col_num <= last_MCU_col;
-	 MCU_col_num++) {
+     MCU_col_num++) {
       /* Determine where data comes from in input_buf and do the DCT thing.
        * Each call on forward_DCT processes a horizontal row of DCT blocks
        * as wide as an MCU; we rely on having allocated the MCU_buffer[] blocks
@@ -166,46 +166,46 @@ compress_data (j_compress_ptr cinfo, JSAMPIMAGE input_buf)
        */
       blkn = 0;
       for (ci = 0; ci < cinfo->comps_in_scan; ci++) {
-	compptr = cinfo->cur_comp_info[ci];
+    compptr = cinfo->cur_comp_info[ci];
-	blockcnt = (MCU_col_num < last_MCU_col) ? compptr->MCU_width
+    blockcnt = (MCU_col_num < last_MCU_col) ? compptr->MCU_width
-						: compptr->last_col_width;
+                        : compptr->last_col_width;
-	xpos = MCU_col_num * compptr->MCU_sample_width;
+    xpos = MCU_col_num * compptr->MCU_sample_width;
-	ypos = yoffset * DCTSIZE; /* ypos == (yoffset+yindex) * DCTSIZE */
+    ypos = yoffset * DCTSIZE; /* ypos == (yoffset+yindex) * DCTSIZE */
-	for (yindex = 0; yindex < compptr->MCU_height; yindex++) {
+    for (yindex = 0; yindex < compptr->MCU_height; yindex++) {
-	  if (coef->iMCU_row_num < last_iMCU_row ||
+      if (coef->iMCU_row_num < last_iMCU_row ||
-	      yoffset+yindex < compptr->last_row_height) {
+          yoffset+yindex < compptr->last_row_height) {
-	    (*cinfo->fdct->forward_DCT) (cinfo, compptr,
+        (*cinfo->fdct->forward_DCT) (cinfo, compptr,
-					 input_buf[compptr->component_index],
+                     input_buf[compptr->component_index],
-					 coef->MCU_buffer[blkn],
+                     coef->MCU_buffer[blkn],
-					 ypos, xpos, (JDIMENSION) blockcnt);
+                     ypos, xpos, (JDIMENSION) blockcnt);
-	    if (blockcnt < compptr->MCU_width) {
+        if (blockcnt < compptr->MCU_width) {
-	      /* Create some dummy blocks at the right edge of the image. */
+          /* Create some dummy blocks at the right edge of the image. */
-	      jzero_far((void FAR *) coef->MCU_buffer[blkn + blockcnt],
+          jzero_far((void FAR *) coef->MCU_buffer[blkn + blockcnt],
-			(compptr->MCU_width - blockcnt) * SIZEOF(JBLOCK));
+            (compptr->MCU_width - blockcnt) * SIZEOF(JBLOCK));
-	      for (bi = blockcnt; bi < compptr->MCU_width; bi++) {
+          for (bi = blockcnt; bi < compptr->MCU_width; bi++) {
-		coef->MCU_buffer[blkn+bi][0][0] = coef->MCU_buffer[blkn+bi-1][0][0];
+        coef->MCU_buffer[blkn+bi][0][0] = coef->MCU_buffer[blkn+bi-1][0][0];
-	      }
+          }
-	    }
+        }
-	  } else {
+      } else {
-	    /* Create a row of dummy blocks at the bottom of the image. */
+        /* Create a row of dummy blocks at the bottom of the image. */
-	    jzero_far((void FAR *) coef->MCU_buffer[blkn],
+        jzero_far((void FAR *) coef->MCU_buffer[blkn],
-		      compptr->MCU_width * SIZEOF(JBLOCK));
+              compptr->MCU_width * SIZEOF(JBLOCK));
-	    for (bi = 0; bi < compptr->MCU_width; bi++) {
+        for (bi = 0; bi < compptr->MCU_width; bi++) {
-	      coef->MCU_buffer[blkn+bi][0][0] = coef->MCU_buffer[blkn-1][0][0];
+          coef->MCU_buffer[blkn+bi][0][0] = coef->MCU_buffer[blkn-1][0][0];
-	    }
+        }
-	  }
+      }
-	  blkn += compptr->MCU_width;
+      blkn += compptr->MCU_width;
-	  ypos += DCTSIZE;
+      ypos += DCTSIZE;
-	}
+    }
       }
       /* Try to write the MCU.  In event of a suspension failure, we will
        * re-DCT the MCU on restart (a bit inefficient, could be fixed...)
        */
       if (! (*cinfo->entropy->encode_mcu) (cinfo, coef->MCU_buffer)) {
-	/* Suspension forced; update state counters and exit */
+    /* Suspension forced; update state counters and exit */
-	coef->MCU_vert_offset = yoffset;
+    coef->MCU_vert_offset = yoffset;
-	coef->mcu_ctr = MCU_col_num;
+    coef->mcu_ctr = MCU_col_num;
-	return FALSE;
+    return FALSE;
       }
     }
     /* Completed an MCU row, but perhaps not an iMCU row */
@@ -280,17 +280,17 @@ compress_first_pass (j_compress_ptr cinfo, JSAMPIMAGE input_buf)
     for (block_row = 0; block_row < block_rows; block_row++) {
       thisblockrow = buffer[block_row];
       (*cinfo->fdct->forward_DCT) (cinfo, compptr,
-				   input_buf[ci], thisblockrow,
+                   input_buf[ci], thisblockrow,
-				   (JDIMENSION) (block_row * DCTSIZE),
+                   (JDIMENSION) (block_row * DCTSIZE),
-				   (JDIMENSION) 0, blocks_across);
+                   (JDIMENSION) 0, blocks_across);
       if (ndummy > 0) {
-	/* Create dummy blocks at the right edge of the image. */
+    /* Create dummy blocks at the right edge of the image. */
-	thisblockrow += blocks_across; /* => first dummy block */
+    thisblockrow += blocks_across; /* => first dummy block */
-	jzero_far((void FAR *) thisblockrow, ndummy * SIZEOF(JBLOCK));
+    jzero_far((void FAR *) thisblockrow, ndummy * SIZEOF(JBLOCK));
-	lastDC = thisblockrow[-1][0];
+    lastDC = thisblockrow[-1][0];
-	for (bi = 0; bi < ndummy; bi++) {
+    for (bi = 0; bi < ndummy; bi++) {
-	  thisblockrow[bi][0] = lastDC;
+      thisblockrow[bi][0] = lastDC;
-	}
+    }
       }
     }
     /* If at end of image, create dummy block rows as needed.
@@ -302,19 +302,19 @@ compress_first_pass (j_compress_ptr cinfo, JSAMPIMAGE input_buf)
       blocks_across += ndummy;	/* include lower right corner */
       MCUs_across = blocks_across / h_samp_factor;
       for (block_row = block_rows; block_row < compptr->v_samp_factor;
-	   block_row++) {
+       block_row++) {
-	thisblockrow = buffer[block_row];
+    thisblockrow = buffer[block_row];
-	lastblockrow = buffer[block_row-1];
+    lastblockrow = buffer[block_row-1];
-	jzero_far((void FAR *) thisblockrow,
+    jzero_far((void FAR *) thisblockrow,
-		  (size_t) (blocks_across * SIZEOF(JBLOCK)));
+          (size_t) (blocks_across * SIZEOF(JBLOCK)));
-	for (MCUindex = 0; MCUindex < MCUs_across; MCUindex++) {
+    for (MCUindex = 0; MCUindex < MCUs_across; MCUindex++) {
-	  lastDC = lastblockrow[h_samp_factor-1][0];
+      lastDC = lastblockrow[h_samp_factor-1][0];
-	  for (bi = 0; bi < h_samp_factor; bi++) {
+      for (bi = 0; bi < h_samp_factor; bi++) {
-	    thisblockrow[bi][0] = lastDC;
+        thisblockrow[bi][0] = lastDC;
-	  }
+      }
-	  thisblockrow += h_samp_factor; /* advance to next MCU in row */
+      thisblockrow += h_samp_factor; /* advance to next MCU in row */
-	  lastblockrow += h_samp_factor;
+      lastblockrow += h_samp_factor;
-	}
+    }
       }
     }
   }
@@ -364,25 +364,25 @@ compress_output (j_compress_ptr cinfo, JSAMPIMAGE input_buf)
   for (yoffset = coef->MCU_vert_offset; yoffset < coef->MCU_rows_per_iMCU_row;
        yoffset++) {
     for (MCU_col_num = coef->mcu_ctr; MCU_col_num < cinfo->MCUs_per_row;
-	 MCU_col_num++) {
+     MCU_col_num++) {
       /* Construct list of pointers to DCT blocks belonging to this MCU */
       blkn = 0;			/* index of current DCT block within MCU */
       for (ci = 0; ci < cinfo->comps_in_scan; ci++) {
-	compptr = cinfo->cur_comp_info[ci];
+    compptr = cinfo->cur_comp_info[ci];
-	start_col = MCU_col_num * compptr->MCU_width;
+    start_col = MCU_col_num * compptr->MCU_width;
-	for (yindex = 0; yindex < compptr->MCU_height; yindex++) {
+    for (yindex = 0; yindex < compptr->MCU_height; yindex++) {
-	  buffer_ptr = buffer[ci][yindex+yoffset] + start_col;
+      buffer_ptr = buffer[ci][yindex+yoffset] + start_col;
-	  for (xindex = 0; xindex < compptr->MCU_width; xindex++) {
+      for (xindex = 0; xindex < compptr->MCU_width; xindex++) {
-	    coef->MCU_buffer[blkn++] = buffer_ptr++;
+        coef->MCU_buffer[blkn++] = buffer_ptr++;
-	  }
+      }
-	}
+    }
       }
       /* Try to write the MCU. */
       if (! (*cinfo->entropy->encode_mcu) (cinfo, coef->MCU_buffer)) {
-	/* Suspension forced; update state counters and exit */
+    /* Suspension forced; update state counters and exit */
-	coef->MCU_vert_offset = yoffset;
+    coef->MCU_vert_offset = yoffset;
-	coef->mcu_ctr = MCU_col_num;
+    coef->mcu_ctr = MCU_col_num;
-	return FALSE;
+    return FALSE;
       }
     }
     /* Completed an MCU row, but perhaps not an iMCU row */
@@ -408,7 +408,7 @@ jinit_c_coef_controller (j_compress_ptr cinfo, boolean need_full_buffer)
 
   coef = (my_coef_ptr)
     (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
-				SIZEOF(my_coef_controller));
+                SIZEOF(my_coef_controller));
   cinfo->coef = (struct jpeg_c_coef_controller *) coef;
   coef->pub.start_pass = start_pass_coef;
 
@@ -421,14 +421,14 @@ jinit_c_coef_controller (j_compress_ptr cinfo, boolean need_full_buffer)
     jpeg_component_info *compptr;
 
     for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
-	 ci++, compptr++) {
+     ci++, compptr++) {
       coef->whole_image[ci] = (*cinfo->mem->request_virt_barray)
-	((j_common_ptr) cinfo, JPOOL_IMAGE, FALSE,
+    ((j_common_ptr) cinfo, JPOOL_IMAGE, FALSE,
-	 (JDIMENSION) jround_up((long) compptr->width_in_blocks,
+     (JDIMENSION) jround_up((long) compptr->width_in_blocks,
-				(long) compptr->h_samp_factor),
+                (long) compptr->h_samp_factor),
-	 (JDIMENSION) jround_up((long) compptr->height_in_blocks,
+     (JDIMENSION) jround_up((long) compptr->height_in_blocks,
-				(long) compptr->v_samp_factor),
+                (long) compptr->v_samp_factor),
-	 (JDIMENSION) compptr->v_samp_factor);
+     (JDIMENSION) compptr->v_samp_factor);
     }
 #else
     ERREXIT(cinfo, JERR_BAD_BUFFER_MODE);
@@ -440,7 +440,7 @@ jinit_c_coef_controller (j_compress_ptr cinfo, boolean need_full_buffer)
 
     buffer = (JBLOCKROW)
       (*cinfo->mem->alloc_large) ((j_common_ptr) cinfo, JPOOL_IMAGE,
-				  C_MAX_BLOCKS_IN_MCU * SIZEOF(JBLOCK));
+                  C_MAX_BLOCKS_IN_MCU * SIZEOF(JBLOCK));
     for (i = 0; i < C_MAX_BLOCKS_IN_MCU; i++) {
       coef->MCU_buffer[i] = buffer + i;
     }

3rdparty/libjpeg/jccolor.c

@@ -92,7 +92,7 @@ rgb_ycc_start (j_compress_ptr cinfo)
   /* Allocate and fill in the conversion tables. */
   cconvert->rgb_ycc_tab = rgb_ycc_tab = (INT32 *)
     (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
-				(TABLE_SIZE * SIZEOF(INT32)));
+                (TABLE_SIZE * SIZEOF(INT32)));
 
   for (i = 0; i <= MAXJSAMPLE; i++) {
     rgb_ycc_tab[i+R_Y_OFF] = FIX(0.29900) * i;
@@ -128,8 +128,8 @@ rgb_ycc_start (j_compress_ptr cinfo)
 
 METHODDEF(void)
 rgb_ycc_convert (j_compress_ptr cinfo,
-		 JSAMPARRAY input_buf, JSAMPIMAGE output_buf,
+         JSAMPARRAY input_buf, JSAMPIMAGE output_buf,
-		 JDIMENSION output_row, int num_rows)
+         JDIMENSION output_row, int num_rows)
 {
   my_cconvert_ptr cconvert = (my_cconvert_ptr) cinfo->cconvert;
   register int r, g, b;
@@ -157,16 +157,16 @@ rgb_ycc_convert (j_compress_ptr cinfo,
        */
       /* Y */
       outptr0[col] = (JSAMPLE)
-		((ctab[r+R_Y_OFF] + ctab[g+G_Y_OFF] + ctab[b+B_Y_OFF])
+        ((ctab[r+R_Y_OFF] + ctab[g+G_Y_OFF] + ctab[b+B_Y_OFF])
-		 >> SCALEBITS);
+         >> SCALEBITS);
       /* Cb */
       outptr1[col] = (JSAMPLE)
-		((ctab[r+R_CB_OFF] + ctab[g+G_CB_OFF] + ctab[b+B_CB_OFF])
+        ((ctab[r+R_CB_OFF] + ctab[g+G_CB_OFF] + ctab[b+B_CB_OFF])
-		 >> SCALEBITS);
+         >> SCALEBITS);
       /* Cr */
       outptr2[col] = (JSAMPLE)
-		((ctab[r+R_CR_OFF] + ctab[g+G_CR_OFF] + ctab[b+B_CR_OFF])
+        ((ctab[r+R_CR_OFF] + ctab[g+G_CR_OFF] + ctab[b+B_CR_OFF])
-		 >> SCALEBITS);
+         >> SCALEBITS);
     }
   }
 }
@@ -184,8 +184,8 @@ rgb_ycc_convert (j_compress_ptr cinfo,
 
 METHODDEF(void)
 rgb_gray_convert (j_compress_ptr cinfo,
-		  JSAMPARRAY input_buf, JSAMPIMAGE output_buf,
+          JSAMPARRAY input_buf, JSAMPIMAGE output_buf,
-		  JDIMENSION output_row, int num_rows)
+          JDIMENSION output_row, int num_rows)
 {
   my_cconvert_ptr cconvert = (my_cconvert_ptr) cinfo->cconvert;
   register int r, g, b;
@@ -206,8 +206,8 @@ rgb_gray_convert (j_compress_ptr cinfo,
       inptr += RGB_PIXELSIZE;
       /* Y */
       outptr[col] = (JSAMPLE)
-		((ctab[r+R_Y_OFF] + ctab[g+G_Y_OFF] + ctab[b+B_Y_OFF])
+        ((ctab[r+R_Y_OFF] + ctab[g+G_Y_OFF] + ctab[b+B_Y_OFF])
-		 >> SCALEBITS);
+         >> SCALEBITS);
     }
   }
 }
@@ -223,8 +223,8 @@ rgb_gray_convert (j_compress_ptr cinfo,
 
 METHODDEF(void)
 cmyk_ycck_convert (j_compress_ptr cinfo,
-		   JSAMPARRAY input_buf, JSAMPIMAGE output_buf,
+           JSAMPARRAY input_buf, JSAMPIMAGE output_buf,
-		   JDIMENSION output_row, int num_rows)
+           JDIMENSION output_row, int num_rows)
 {
   my_cconvert_ptr cconvert = (my_cconvert_ptr) cinfo->cconvert;
   register int r, g, b;
@@ -255,16 +255,16 @@ cmyk_ycck_convert (j_compress_ptr cinfo,
        */
       /* Y */
       outptr0[col] = (JSAMPLE)
-		((ctab[r+R_Y_OFF] + ctab[g+G_Y_OFF] + ctab[b+B_Y_OFF])
+        ((ctab[r+R_Y_OFF] + ctab[g+G_Y_OFF] + ctab[b+B_Y_OFF])
-		 >> SCALEBITS);
+         >> SCALEBITS);
       /* Cb */
       outptr1[col] = (JSAMPLE)
-		((ctab[r+R_CB_OFF] + ctab[g+G_CB_OFF] + ctab[b+B_CB_OFF])
+        ((ctab[r+R_CB_OFF] + ctab[g+G_CB_OFF] + ctab[b+B_CB_OFF])
-		 >> SCALEBITS);
+         >> SCALEBITS);
       /* Cr */
       outptr2[col] = (JSAMPLE)
-		((ctab[r+R_CR_OFF] + ctab[g+G_CR_OFF] + ctab[b+B_CR_OFF])
+        ((ctab[r+R_CR_OFF] + ctab[g+G_CR_OFF] + ctab[b+B_CR_OFF])
-		 >> SCALEBITS);
+         >> SCALEBITS);
     }
   }
 }
@@ -278,8 +278,8 @@ cmyk_ycck_convert (j_compress_ptr cinfo,
 
 METHODDEF(void)
 grayscale_convert (j_compress_ptr cinfo,
-		   JSAMPARRAY input_buf, JSAMPIMAGE output_buf,
+           JSAMPARRAY input_buf, JSAMPIMAGE output_buf,
-		   JDIMENSION output_row, int num_rows)
+           JDIMENSION output_row, int num_rows)
 {
   register JSAMPROW inptr;
   register JSAMPROW outptr;
@@ -307,8 +307,8 @@ grayscale_convert (j_compress_ptr cinfo,
 
 METHODDEF(void)
 null_convert (j_compress_ptr cinfo,
-	      JSAMPARRAY input_buf, JSAMPIMAGE output_buf,
+          JSAMPARRAY input_buf, JSAMPIMAGE output_buf,
-	      JDIMENSION output_row, int num_rows)
+          JDIMENSION output_row, int num_rows)
 {
   register JSAMPROW inptr;
   register JSAMPROW outptr;
@@ -323,8 +323,8 @@ null_convert (j_compress_ptr cinfo,
       inptr = *input_buf;
       outptr = output_buf[ci][output_row];
       for (col = 0; col < num_cols; col++) {
-	outptr[col] = inptr[ci]; /* don't need GETJSAMPLE() here */
+    outptr[col] = inptr[ci]; /* don't need GETJSAMPLE() here */
-	inptr += nc;
+    inptr += nc;
       }
     }
     input_buf++;
@@ -355,7 +355,7 @@ jinit_color_converter (j_compress_ptr cinfo)
 
   cconvert = (my_cconvert_ptr)
     (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
-				SIZEOF(my_color_converter));
+                SIZEOF(my_color_converter));
   cinfo->cconvert = (struct jpeg_color_converter *) cconvert;
   /* set start_pass to null method until we find out differently */
   cconvert->pub.start_pass = null_method;
@@ -451,7 +451,7 @@ jinit_color_converter (j_compress_ptr cinfo)
 
   default:			/* allow null conversion of JCS_UNKNOWN */
     if (cinfo->jpeg_color_space != cinfo->in_color_space ||
-	cinfo->num_components != cinfo->input_components)
+    cinfo->num_components != cinfo->input_components)
       ERREXIT(cinfo, JERR_CONVERSION_NOTIMPL);
     cconvert->pub.color_convert = null_convert;
     break;

3rdparty/libjpeg/jcdctmgr.c

@@ -64,7 +64,7 @@ start_pass_fdctmgr (j_compress_ptr cinfo)
     qtblno = compptr->quant_tbl_no;
     /* Make sure specified quantization table is present */
     if (qtblno < 0 || qtblno >= NUM_QUANT_TBLS ||
-	cinfo->quant_tbl_ptrs[qtblno] == NULL)
+    cinfo->quant_tbl_ptrs[qtblno] == NULL)
       ERREXIT1(cinfo, JERR_NO_QUANT_TABLE, qtblno);
     qtbl = cinfo->quant_tbl_ptrs[qtblno];
     /* Compute divisors for this quant table */
@@ -76,87 +76,87 @@ start_pass_fdctmgr (j_compress_ptr cinfo)
        * coefficients multiplied by 8 (to counteract scaling).
        */
       if (fdct->divisors[qtblno] == NULL) {
-	fdct->divisors[qtblno] = (DCTELEM *)
+    fdct->divisors[qtblno] = (DCTELEM *)
-	  (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+      (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
-				      DCTSIZE2 * SIZEOF(DCTELEM));
+                      DCTSIZE2 * SIZEOF(DCTELEM));
       }
       dtbl = fdct->divisors[qtblno];
       for (i = 0; i < DCTSIZE2; i++) {
-	dtbl[i] = ((DCTELEM) qtbl->quantval[i]) << 3;
+    dtbl[i] = ((DCTELEM) qtbl->quantval[i]) << 3;
       }
       break;
 #endif
 #ifdef DCT_IFAST_SUPPORTED
     case JDCT_IFAST:
       {
-	/* For AA&N IDCT method, divisors are equal to quantization
+    /* For AA&N IDCT method, divisors are equal to quantization
-	 * coefficients scaled by scalefactor[row]*scalefactor[col], where
+     * coefficients scaled by scalefactor[row]*scalefactor[col], where
-	 *   scalefactor[0] = 1
+     *   scalefactor[0] = 1
-	 *   scalefactor[k] = cos(k*PI/16) * sqrt(2)    for k=1..7
+     *   scalefactor[k] = cos(k*PI/16) * sqrt(2)    for k=1..7
-	 * We apply a further scale factor of 8.
+     * We apply a further scale factor of 8.
-	 */
+     */
 #define CONST_BITS 14
-	static const INT16 aanscales[DCTSIZE2] = {
+    static const INT16 aanscales[DCTSIZE2] = {
-	  /* precomputed values scaled up by 14 bits */
+      /* precomputed values scaled up by 14 bits */
-	  16384, 22725, 21407, 19266, 16384, 12873,  8867,  4520,
+      16384, 22725, 21407, 19266, 16384, 12873,  8867,  4520,
-	  22725, 31521, 29692, 26722, 22725, 17855, 12299,  6270,
+      22725, 31521, 29692, 26722, 22725, 17855, 12299,  6270,
-	  21407, 29692, 27969, 25172, 21407, 16819, 11585,  5906,
+      21407, 29692, 27969, 25172, 21407, 16819, 11585,  5906,
-	  19266, 26722, 25172, 22654, 19266, 15137, 10426,  5315,
+      19266, 26722, 25172, 22654, 19266, 15137, 10426,  5315,
-	  16384, 22725, 21407, 19266, 16384, 12873,  8867,  4520,
+      16384, 22725, 21407, 19266, 16384, 12873,  8867,  4520,
-	  12873, 17855, 16819, 15137, 12873, 10114,  6967,  3552,
+      12873, 17855, 16819, 15137, 12873, 10114,  6967,  3552,
-	   8867, 12299, 11585, 10426,  8867,  6967,  4799,  2446,
+       8867, 12299, 11585, 10426,  8867,  6967,  4799,  2446,
-	   4520,  6270,  5906,  5315,  4520,  3552,  2446,  1247
+       4520,  6270,  5906,  5315,  4520,  3552,  2446,  1247
-	};
+    };
-	SHIFT_TEMPS
+    SHIFT_TEMPS
 
-	if (fdct->divisors[qtblno] == NULL) {
+    if (fdct->divisors[qtblno] == NULL) {
-	  fdct->divisors[qtblno] = (DCTELEM *)
+      fdct->divisors[qtblno] = (DCTELEM *)
-	    (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+        (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
-					DCTSIZE2 * SIZEOF(DCTELEM));
+                    DCTSIZE2 * SIZEOF(DCTELEM));
-	}
+    }
-	dtbl = fdct->divisors[qtblno];
+    dtbl = fdct->divisors[qtblno];
-	for (i = 0; i < DCTSIZE2; i++) {
+    for (i = 0; i < DCTSIZE2; i++) {
-	  dtbl[i] = (DCTELEM)
+      dtbl[i] = (DCTELEM)
-	    DESCALE(MULTIPLY16V16((INT32) qtbl->quantval[i],
+        DESCALE(MULTIPLY16V16((INT32) qtbl->quantval[i],
-				  (INT32) aanscales[i]),
+                  (INT32) aanscales[i]),
-		    CONST_BITS-3);
+            CONST_BITS-3);
-	}
+    }
       }
       break;
 #endif
 #ifdef DCT_FLOAT_SUPPORTED
     case JDCT_FLOAT:
       {
-	/* For float AA&N IDCT method, divisors are equal to quantization
+    /* For float AA&N IDCT method, divisors are equal to quantization
-	 * coefficients scaled by scalefactor[row]*scalefactor[col], where
+     * coefficients scaled by scalefactor[row]*scalefactor[col], where
-	 *   scalefactor[0] = 1
+     *   scalefactor[0] = 1
-	 *   scalefactor[k] = cos(k*PI/16) * sqrt(2)    for k=1..7
+     *   scalefactor[k] = cos(k*PI/16) * sqrt(2)    for k=1..7
-	 * We apply a further scale factor of 8.
+     * We apply a further scale factor of 8.
-	 * What's actually stored is 1/divisor so that the inner loop can
+     * What's actually stored is 1/divisor so that the inner loop can
-	 * use a multiplication rather than a division.
+     * use a multiplication rather than a division.
-	 */
+     */
-	FAST_FLOAT * fdtbl;
+    FAST_FLOAT * fdtbl;
-	int row, col;
+    int row, col;
-	static const double aanscalefactor[DCTSIZE] = {
+    static const double aanscalefactor[DCTSIZE] = {
-	  1.0, 1.387039845, 1.306562965, 1.175875602,
+      1.0, 1.387039845, 1.306562965, 1.175875602,
-	  1.0, 0.785694958, 0.541196100, 0.275899379
+      1.0, 0.785694958, 0.541196100, 0.275899379
-	};
+    };
 
-	if (fdct->float_divisors[qtblno] == NULL) {
+    if (fdct->float_divisors[qtblno] == NULL) {
-	  fdct->float_divisors[qtblno] = (FAST_FLOAT *)
+      fdct->float_divisors[qtblno] = (FAST_FLOAT *)
-	    (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+        (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
-					DCTSIZE2 * SIZEOF(FAST_FLOAT));
+                    DCTSIZE2 * SIZEOF(FAST_FLOAT));
-	}
+    }
-	fdtbl = fdct->float_divisors[qtblno];
+    fdtbl = fdct->float_divisors[qtblno];
-	i = 0;
+    i = 0;
-	for (row = 0; row < DCTSIZE; row++) {
+    for (row = 0; row < DCTSIZE; row++) {
-	  for (col = 0; col < DCTSIZE; col++) {
+      for (col = 0; col < DCTSIZE; col++) {
-	    fdtbl[i] = (FAST_FLOAT)
+        fdtbl[i] = (FAST_FLOAT)
-	      (1.0 / (((double) qtbl->quantval[i] *
+          (1.0 / (((double) qtbl->quantval[i] *
-		       aanscalefactor[row] * aanscalefactor[col] * 8.0)));
+               aanscalefactor[row] * aanscalefactor[col] * 8.0)));
-	    i++;
+        i++;
-	  }
+      }
-	}
+    }
       }
       break;
 #endif
@@ -178,9 +178,9 @@ start_pass_fdctmgr (j_compress_ptr cinfo)
 
 METHODDEF(void)
 forward_DCT (j_compress_ptr cinfo, jpeg_component_info * compptr,
-	     JSAMPARRAY sample_data, JBLOCKROW coef_blocks,
+         JSAMPARRAY sample_data, JBLOCKROW coef_blocks,
-	     JDIMENSION start_row, JDIMENSION start_col,
+         JDIMENSION start_row, JDIMENSION start_col,
-	     JDIMENSION num_blocks)
+         JDIMENSION num_blocks)
 /* This version is used for integer DCT implementations. */
 {
   /* This routine is heavily used, so it's worth coding it tightly. */
@@ -200,22 +200,22 @@ forward_DCT (j_compress_ptr cinfo, jpeg_component_info * compptr,
 
       workspaceptr = workspace;
       for (elemr = 0; elemr < DCTSIZE; elemr++) {
-	elemptr = sample_data[elemr] + start_col;
+    elemptr = sample_data[elemr] + start_col;
 #if DCTSIZE == 8		/* unroll the inner loop */
-	*workspaceptr++ = GETJSAMPLE(*elemptr++) - CENTERJSAMPLE;
+    *workspaceptr++ = GETJSAMPLE(*elemptr++) - CENTERJSAMPLE;
-	*workspaceptr++ = GETJSAMPLE(*elemptr++) - CENTERJSAMPLE;
+    *workspaceptr++ = GETJSAMPLE(*elemptr++) - CENTERJSAMPLE;
-	*workspaceptr++ = GETJSAMPLE(*elemptr++) - CENTERJSAMPLE;
+    *workspaceptr++ = GETJSAMPLE(*elemptr++) - CENTERJSAMPLE;
-	*workspaceptr++ = GETJSAMPLE(*elemptr++) - CENTERJSAMPLE;
+    *workspaceptr++ = GETJSAMPLE(*elemptr++) - CENTERJSAMPLE;
-	*workspaceptr++ = GETJSAMPLE(*elemptr++) - CENTERJSAMPLE;
+    *workspaceptr++ = GETJSAMPLE(*elemptr++) - CENTERJSAMPLE;
-	*workspaceptr++ = GETJSAMPLE(*elemptr++) - CENTERJSAMPLE;
+    *workspaceptr++ = GETJSAMPLE(*elemptr++) - CENTERJSAMPLE;
-	*workspaceptr++ = GETJSAMPLE(*elemptr++) - CENTERJSAMPLE;
+    *workspaceptr++ = GETJSAMPLE(*elemptr++) - CENTERJSAMPLE;
-	*workspaceptr++ = GETJSAMPLE(*elemptr++) - CENTERJSAMPLE;
+    *workspaceptr++ = GETJSAMPLE(*elemptr++) - CENTERJSAMPLE;
 #else
-	{ register int elemc;
+    { register int elemc;
-	  for (elemc = DCTSIZE; elemc > 0; elemc--) {
+      for (elemc = DCTSIZE; elemc > 0; elemc--) {
-	    *workspaceptr++ = GETJSAMPLE(*elemptr++) - CENTERJSAMPLE;
+        *workspaceptr++ = GETJSAMPLE(*elemptr++) - CENTERJSAMPLE;
-	  }
+      }
-	}
+    }
 #endif
       }
     }
@@ -229,35 +229,35 @@ forward_DCT (j_compress_ptr cinfo, jpeg_component_info * compptr,
       register JCOEFPTR output_ptr = coef_blocks[bi];
 
       for (i = 0; i < DCTSIZE2; i++) {
-	qval = divisors[i];
+    qval = divisors[i];
-	temp = workspace[i];
+    temp = workspace[i];
-	/* Divide the coefficient value by qval, ensuring proper rounding.
+    /* Divide the coefficient value by qval, ensuring proper rounding.
-	 * Since C does not specify the direction of rounding for negative
+     * Since C does not specify the direction of rounding for negative
-	 * quotients, we have to force the dividend positive for portability.
+     * quotients, we have to force the dividend positive for portability.
-	 *
+     *
-	 * In most files, at least half of the output values will be zero
+     * In most files, at least half of the output values will be zero
-	 * (at default quantization settings, more like three-quarters...)
+     * (at default quantization settings, more like three-quarters...)
-	 * so we should ensure that this case is fast.  On many machines,
+     * so we should ensure that this case is fast.  On many machines,
-	 * a comparison is enough cheaper than a divide to make a special test
+     * a comparison is enough cheaper than a divide to make a special test
-	 * a win.  Since both inputs will be nonnegative, we need only test
+     * a win.  Since both inputs will be nonnegative, we need only test
-	 * for a < b to discover whether a/b is 0.
+     * for a < b to discover whether a/b is 0.
-	 * If your machine's division is fast enough, define FAST_DIVIDE.
+     * If your machine's division is fast enough, define FAST_DIVIDE.
-	 */
+     */
 #ifdef FAST_DIVIDE
 #define DIVIDE_BY(a,b)	a /= b
 #else
 #define DIVIDE_BY(a,b)	if (a >= b) a /= b; else a = 0
 #endif
-	if (temp < 0) {
+    if (temp < 0) {
-	  temp = -temp;
+      temp = -temp;
-	  temp += qval>>1;	/* for rounding */
+      temp += qval>>1;	/* for rounding */
-	  DIVIDE_BY(temp, qval);
+      DIVIDE_BY(temp, qval);
-	  temp = -temp;
+      temp = -temp;
-	} else {
+    } else {
-	  temp += qval>>1;	/* for rounding */
+      temp += qval>>1;	/* for rounding */
-	  DIVIDE_BY(temp, qval);
+      DIVIDE_BY(temp, qval);
-	}
+    }
-	output_ptr[i] = (JCOEF) temp;
+    output_ptr[i] = (JCOEF) temp;
       }
     }
   }
@@ -268,9 +268,9 @@ forward_DCT (j_compress_ptr cinfo, jpeg_component_info * compptr,
 
 METHODDEF(void)
 forward_DCT_float (j_compress_ptr cinfo, jpeg_component_info * compptr,
-		   JSAMPARRAY sample_data, JBLOCKROW coef_blocks,
+           JSAMPARRAY sample_data, JBLOCKROW coef_blocks,
-		   JDIMENSION start_row, JDIMENSION start_col,
+           JDIMENSION start_row, JDIMENSION start_col,
-		   JDIMENSION num_blocks)
+           JDIMENSION num_blocks)
 /* This version is used for floating-point DCT implementations. */
 {
   /* This routine is heavily used, so it's worth coding it tightly. */
@@ -290,23 +290,23 @@ forward_DCT_float (j_compress_ptr cinfo, jpeg_component_info * compptr,
 
       workspaceptr = workspace;
       for (elemr = 0; elemr < DCTSIZE; elemr++) {
-	elemptr = sample_data[elemr] + start_col;
+    elemptr = sample_data[elemr] + start_col;
 #if DCTSIZE == 8		/* unroll the inner loop */
-	*workspaceptr++ = (FAST_FLOAT)(GETJSAMPLE(*elemptr++) - CENTERJSAMPLE);
+    *workspaceptr++ = (FAST_FLOAT)(GETJSAMPLE(*elemptr++) - CENTERJSAMPLE);
-	*workspaceptr++ = (FAST_FLOAT)(GETJSAMPLE(*elemptr++) - CENTERJSAMPLE);
+    *workspaceptr++ = (FAST_FLOAT)(GETJSAMPLE(*elemptr++) - CENTERJSAMPLE);
-	*workspaceptr++ = (FAST_FLOAT)(GETJSAMPLE(*elemptr++) - CENTERJSAMPLE);
+    *workspaceptr++ = (FAST_FLOAT)(GETJSAMPLE(*elemptr++) - CENTERJSAMPLE);
-	*workspaceptr++ = (FAST_FLOAT)(GETJSAMPLE(*elemptr++) - CENTERJSAMPLE);
+    *workspaceptr++ = (FAST_FLOAT)(GETJSAMPLE(*elemptr++) - CENTERJSAMPLE);
-	*workspaceptr++ = (FAST_FLOAT)(GETJSAMPLE(*elemptr++) - CENTERJSAMPLE);
+    *workspaceptr++ = (FAST_FLOAT)(GETJSAMPLE(*elemptr++) - CENTERJSAMPLE);
-	*workspaceptr++ = (FAST_FLOAT)(GETJSAMPLE(*elemptr++) - CENTERJSAMPLE);
+    *workspaceptr++ = (FAST_FLOAT)(GETJSAMPLE(*elemptr++) - CENTERJSAMPLE);
-	*workspaceptr++ = (FAST_FLOAT)(GETJSAMPLE(*elemptr++) - CENTERJSAMPLE);
+    *workspaceptr++ = (FAST_FLOAT)(GETJSAMPLE(*elemptr++) - CENTERJSAMPLE);
-	*workspaceptr++ = (FAST_FLOAT)(GETJSAMPLE(*elemptr++) - CENTERJSAMPLE);
+    *workspaceptr++ = (FAST_FLOAT)(GETJSAMPLE(*elemptr++) - CENTERJSAMPLE);
 #else
-	{ register int elemc;
+    { register int elemc;
-	  for (elemc = DCTSIZE; elemc > 0; elemc--) {
+      for (elemc = DCTSIZE; elemc > 0; elemc--) {
-	    *workspaceptr++ = (FAST_FLOAT)
+        *workspaceptr++ = (FAST_FLOAT)
-	      (GETJSAMPLE(*elemptr++) - CENTERJSAMPLE);
+          (GETJSAMPLE(*elemptr++) - CENTERJSAMPLE);
-	  }
+      }
-	}
+    }
 #endif
       }
     }
@@ -320,15 +320,15 @@ forward_DCT_float (j_compress_ptr cinfo, jpeg_component_info * compptr,
       register JCOEFPTR output_ptr = coef_blocks[bi];
 
       for (i = 0; i < DCTSIZE2; i++) {
-	/* Apply the quantization and scaling factor */
+    /* Apply the quantization and scaling factor */
-	temp = workspace[i] * divisors[i];
+    temp = workspace[i] * divisors[i];
-	/* Round to nearest integer.
+    /* Round to nearest integer.
-	 * Since C does not specify the direction of rounding for negative
+     * Since C does not specify the direction of rounding for negative
-	 * quotients, we have to force the dividend positive for portability.
+     * quotients, we have to force the dividend positive for portability.
-	 * The maximum coefficient size is +-16K (for 12-bit data), so this
+     * The maximum coefficient size is +-16K (for 12-bit data), so this
-	 * code should work for either 16-bit or 32-bit ints.
+     * code should work for either 16-bit or 32-bit ints.
-	 */
+     */
-	output_ptr[i] = (JCOEF) ((int) (temp + (FAST_FLOAT) 16384.5) - 16384);
+    output_ptr[i] = (JCOEF) ((int) (temp + (FAST_FLOAT) 16384.5) - 16384);
       }
     }
   }
@@ -349,7 +349,7 @@ jinit_forward_dct (j_compress_ptr cinfo)
 
   fdct = (my_fdct_ptr)
     (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
-				SIZEOF(my_fdct_controller));
+                SIZEOF(my_fdct_controller));
   cinfo->fdct = (struct jpeg_forward_dct *) fdct;
   fdct->pub.start_pass = start_pass_fdctmgr;
 

3rdparty/libjpeg/jchuff.c

@@ -42,12 +42,12 @@ typedef struct {
 #else
 #if MAX_COMPS_IN_SCAN == 4
 #define ASSIGN_STATE(dest,src)  \
-	((dest).put_buffer = (src).put_buffer, \
+    ((dest).put_buffer = (src).put_buffer, \
-	 (dest).put_bits = (src).put_bits, \
+     (dest).put_bits = (src).put_bits, \
-	 (dest).last_dc_val[0] = (src).last_dc_val[0], \
+     (dest).last_dc_val[0] = (src).last_dc_val[0], \
-	 (dest).last_dc_val[1] = (src).last_dc_val[1], \
+     (dest).last_dc_val[1] = (src).last_dc_val[1], \
-	 (dest).last_dc_val[2] = (src).last_dc_val[2], \
+     (dest).last_dc_val[2] = (src).last_dc_val[2], \
-	 (dest).last_dc_val[3] = (src).last_dc_val[3])
+     (dest).last_dc_val[3] = (src).last_dc_val[3])
 #endif
 #endif
 
@@ -87,11 +87,11 @@ typedef struct {
 
 /* Forward declarations */
 METHODDEF(boolean) encode_mcu_huff JPP((j_compress_ptr cinfo,
-					JBLOCKROW *MCU_data));
+                    JBLOCKROW *MCU_data));
 METHODDEF(void) finish_pass_huff JPP((j_compress_ptr cinfo));
 #ifdef ENTROPY_OPT_SUPPORTED
 METHODDEF(boolean) encode_mcu_gather JPP((j_compress_ptr cinfo,
-					  JBLOCKROW *MCU_data));
+                      JBLOCKROW *MCU_data));
 METHODDEF(void) finish_pass_gather JPP((j_compress_ptr cinfo));
 #endif
 
@@ -130,29 +130,29 @@ start_pass_huff (j_compress_ptr cinfo, boolean gather_statistics)
       /* Check for invalid table indexes */
       /* (make_c_derived_tbl does this in the other path) */
       if (dctbl < 0 || dctbl >= NUM_HUFF_TBLS)
-	ERREXIT1(cinfo, JERR_NO_HUFF_TABLE, dctbl);
+    ERREXIT1(cinfo, JERR_NO_HUFF_TABLE, dctbl);
       if (actbl < 0 || actbl >= NUM_HUFF_TBLS)
-	ERREXIT1(cinfo, JERR_NO_HUFF_TABLE, actbl);
+    ERREXIT1(cinfo, JERR_NO_HUFF_TABLE, actbl);
       /* Allocate and zero the statistics tables */
       /* Note that jpeg_gen_optimal_table expects 257 entries in each table! */
       if (entropy->dc_count_ptrs[dctbl] == NULL)
-	entropy->dc_count_ptrs[dctbl] = (long *)
+    entropy->dc_count_ptrs[dctbl] = (long *)
-	  (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+      (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
-				      257 * SIZEOF(long));
+                      257 * SIZEOF(long));
       MEMZERO(entropy->dc_count_ptrs[dctbl], 257 * SIZEOF(long));
       if (entropy->ac_count_ptrs[actbl] == NULL)
-	entropy->ac_count_ptrs[actbl] = (long *)
+    entropy->ac_count_ptrs[actbl] = (long *)
-	  (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+      (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
-				      257 * SIZEOF(long));
+                      257 * SIZEOF(long));
       MEMZERO(entropy->ac_count_ptrs[actbl], 257 * SIZEOF(long));
 #endif
     } else {
       /* Compute derived values for Huffman tables */
       /* We may do this more than once for a table, but it's not expensive */
       jpeg_make_c_derived_tbl(cinfo, TRUE, dctbl,
-			      & entropy->dc_derived_tbls[dctbl]);
+                  & entropy->dc_derived_tbls[dctbl]);
       jpeg_make_c_derived_tbl(cinfo, FALSE, actbl,
-			      & entropy->ac_derived_tbls[actbl]);
+                  & entropy->ac_derived_tbls[actbl]);
     }
     /* Initialize DC predictions to 0 */
     entropy->saved.last_dc_val[ci] = 0;
@@ -177,7 +177,7 @@ start_pass_huff (j_compress_ptr cinfo, boolean gather_statistics)
 
 GLOBAL(void)
 jpeg_make_c_derived_tbl (j_compress_ptr cinfo, boolean isDC, int tblno,
-			 c_derived_tbl ** pdtbl)
+             c_derived_tbl ** pdtbl)
 {
   JHUFF_TBL *htbl;
   c_derived_tbl *dtbl;
@@ -202,9 +202,9 @@ jpeg_make_c_derived_tbl (j_compress_ptr cinfo, boolean isDC, int tblno,
   if (*pdtbl == NULL)
     *pdtbl = (c_derived_tbl *)
       (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
-				  SIZEOF(c_derived_tbl));
+                  SIZEOF(c_derived_tbl));
   dtbl = *pdtbl;
-  
+
   /* Figure C.1: make table of Huffman code length for each symbol */
 
   p = 0;
@@ -217,7 +217,7 @@ jpeg_make_c_derived_tbl (j_compress_ptr cinfo, boolean isDC, int tblno,
   }
   huffsize[p] = 0;
   lastp = p;
-  
+
   /* Figure C.2: generate the codes themselves */
   /* We also validate that the counts represent a legal Huffman code tree. */
 
@@ -237,7 +237,7 @@ jpeg_make_c_derived_tbl (j_compress_ptr cinfo, boolean isDC, int tblno,
     code <<= 1;
     si++;
   }
-  
+
   /* Figure C.3: generate encoding tables */
   /* These are code and size indexed by symbol value */
 
@@ -268,10 +268,10 @@ jpeg_make_c_derived_tbl (j_compress_ptr cinfo, boolean isDC, int tblno,
 
 /* Emit a byte, taking 'action' if must suspend. */
 #define emit_byte(state,val,action)  \
-	{ *(state)->next_output_byte++ = (JOCTET) (val);  \
+    { *(state)->next_output_byte++ = (JOCTET) (val);  \
-	  if (--(state)->free_in_buffer == 0)  \
+      if (--(state)->free_in_buffer == 0)  \
-	    if (! dump_buffer(state))  \
+        if (! dump_buffer(state))  \
-	      { action; } }
+          { action; } }
 
 
 LOCAL(boolean)
@@ -311,16 +311,16 @@ emit_bits (working_state * state, unsigned int code, int size)
     ERREXIT(state->cinfo, JERR_HUFF_MISSING_CODE);
 
   put_buffer &= (((INT32) 1)<<size) - 1; /* mask off any extra bits in code */
-  
+
   put_bits += size;		/* new number of bits in buffer */
-  
+
   put_buffer <<= 24 - put_bits; /* align incoming bits */
 
   put_buffer |= state->cur.put_buffer; /* and merge with old buffer contents */
-  
+
   while (put_bits >= 8) {
     int c = (int) ((put_buffer >> 16) & 0xFF);
-    
+
     emit_byte(state, c, return FALSE);
     if (c == 0xFF) {		/* need to stuff a zero byte? */
       emit_byte(state, 0, return FALSE);
@@ -351,14 +351,14 @@ flush_bits (working_state * state)
 
 LOCAL(boolean)
 encode_one_block (working_state * state, JCOEFPTR block, int last_dc_val,
-		  c_derived_tbl *dctbl, c_derived_tbl *actbl)
+          c_derived_tbl *dctbl, c_derived_tbl *actbl)
 {
   register int temp, temp2;
   register int nbits;
   register int k, r, i;
-  
+
   /* Encode the DC coefficient difference per section F.1.2.1 */
-  
+
   temp = temp2 = block[0] - last_dc_val;
 
   if (temp < 0) {
@@ -367,7 +367,7 @@ encode_one_block (working_state * state, JCOEFPTR block, int last_dc_val,
     /* This code assumes we are on a two's complement machine */
     temp2--;
   }
-  
+
   /* Find the number of bits needed for the magnitude of the coefficient */
   nbits = 0;
   while (temp) {
@@ -379,7 +379,7 @@ encode_one_block (working_state * state, JCOEFPTR block, int last_dc_val,
    */
   if (nbits > MAX_COEF_BITS+1)
     ERREXIT(state->cinfo, JERR_BAD_DCT_COEF);
-  
+
   /* Emit the Huffman-coded symbol for the number of bits */
   if (! emit_bits(state, dctbl->ehufco[nbits], dctbl->ehufsi[nbits]))
     return FALSE;
@@ -391,45 +391,45 @@ encode_one_block (working_state * state, JCOEFPTR block, int last_dc_val,
       return FALSE;
 
   /* Encode the AC coefficients per section F.1.2.2 */
-  
+
   r = 0;			/* r = run length of zeros */
-  
+
   for (k = 1; k < DCTSIZE2; k++) {
     if ((temp = block[jpeg_natural_order[k]]) == 0) {
       r++;
     } else {
       /* if run length > 15, must emit special run-length-16 codes (0xF0) */
       while (r > 15) {
-	if (! emit_bits(state, actbl->ehufco[0xF0], actbl->ehufsi[0xF0]))
+    if (! emit_bits(state, actbl->ehufco[0xF0], actbl->ehufsi[0xF0]))
-	  return FALSE;
+      return FALSE;
-	r -= 16;
+    r -= 16;
       }
 
       temp2 = temp;
       if (temp < 0) {
-	temp = -temp;		/* temp is abs value of input */
+    temp = -temp;		/* temp is abs value of input */
-	/* This code assumes we are on a two's complement machine */
+    /* This code assumes we are on a two's complement machine */
-	temp2--;
+    temp2--;
       }
-      
+
       /* Find the number of bits needed for the magnitude of the coefficient */
       nbits = 1;		/* there must be at least one 1 bit */
       while ((temp >>= 1))
-	nbits++;
+    nbits++;
       /* Check for out-of-range coefficient values */
       if (nbits > MAX_COEF_BITS)
-	ERREXIT(state->cinfo, JERR_BAD_DCT_COEF);
+    ERREXIT(state->cinfo, JERR_BAD_DCT_COEF);
-      
+
       /* Emit Huffman symbol for run length / number of bits */
       i = (r << 4) + nbits;
       if (! emit_bits(state, actbl->ehufco[i], actbl->ehufsi[i]))
-	return FALSE;
+    return FALSE;
 
       /* Emit that number of bits of the value, if positive, */
       /* or the complement of its magnitude, if negative. */
       if (! emit_bits(state, (unsigned int) temp2, nbits))
-	return FALSE;
+    return FALSE;
-      
+
       r = 0;
     }
   }
@@ -490,7 +490,7 @@ encode_mcu_huff (j_compress_ptr cinfo, JBLOCKROW *MCU_data)
   if (cinfo->restart_interval) {
     if (entropy->restarts_to_go == 0)
       if (! emit_restart(&state, entropy->next_restart_num))
-	return FALSE;
+    return FALSE;
   }
 
   /* Encode the MCU data blocks */
@@ -498,9 +498,9 @@ encode_mcu_huff (j_compress_ptr cinfo, JBLOCKROW *MCU_data)
     ci = cinfo->MCU_membership[blkn];
     compptr = cinfo->cur_comp_info[ci];
     if (! encode_one_block(&state,
-			   MCU_data[blkn][0], state.cur.last_dc_val[ci],
+               MCU_data[blkn][0], state.cur.last_dc_val[ci],
-			   entropy->dc_derived_tbls[compptr->dc_tbl_no],
+               entropy->dc_derived_tbls[compptr->dc_tbl_no],
-			   entropy->ac_derived_tbls[compptr->ac_tbl_no]))
+               entropy->ac_derived_tbls[compptr->ac_tbl_no]))
       return FALSE;
     /* Update last_dc_val */
     state.cur.last_dc_val[ci] = MCU_data[blkn][0][0];
@@ -570,18 +570,18 @@ finish_pass_huff (j_compress_ptr cinfo)
 
 LOCAL(void)
 htest_one_block (j_compress_ptr cinfo, JCOEFPTR block, int last_dc_val,
-		 long dc_counts[], long ac_counts[])
+         long dc_counts[], long ac_counts[])
 {
   register int temp;
   register int nbits;
   register int k, r;
-  
+
   /* Encode the DC coefficient difference per section F.1.2.1 */
-  
+
   temp = block[0] - last_dc_val;
   if (temp < 0)
     temp = -temp;
-  
+
   /* Find the number of bits needed for the magnitude of the coefficient */
   nbits = 0;
   while (temp) {
@@ -596,36 +596,36 @@ htest_one_block (j_compress_ptr cinfo, JCOEFPTR block, int last_dc_val,
 
   /* Count the Huffman symbol for the number of bits */
   dc_counts[nbits]++;
-  
+
   /* Encode the AC coefficients per section F.1.2.2 */
-  
+
   r = 0;			/* r = run length of zeros */
-  
+
   for (k = 1; k < DCTSIZE2; k++) {
     if ((temp = block[jpeg_natural_order[k]]) == 0) {
       r++;
     } else {
       /* if run length > 15, must emit special run-length-16 codes (0xF0) */
       while (r > 15) {
-	ac_counts[0xF0]++;
+    ac_counts[0xF0]++;
-	r -= 16;
+    r -= 16;
       }
-      
+
       /* Find the number of bits needed for the magnitude of the coefficient */
       if (temp < 0)
-	temp = -temp;
+    temp = -temp;
-      
+
       /* Find the number of bits needed for the magnitude of the coefficient */
       nbits = 1;		/* there must be at least one 1 bit */
       while ((temp >>= 1))
-	nbits++;
+    nbits++;
       /* Check for out-of-range coefficient values */
       if (nbits > MAX_COEF_BITS)
-	ERREXIT(cinfo, JERR_BAD_DCT_COEF);
+    ERREXIT(cinfo, JERR_BAD_DCT_COEF);
-      
+
       /* Count Huffman symbol for run length / number of bits */
       ac_counts[(r << 4) + nbits]++;
-      
+
       r = 0;
     }
   }
@@ -653,7 +653,7 @@ encode_mcu_gather (j_compress_ptr cinfo, JBLOCKROW *MCU_data)
     if (entropy->restarts_to_go == 0) {
       /* Re-initialize DC predictions to 0 */
       for (ci = 0; ci < cinfo->comps_in_scan; ci++)
-	entropy->saved.last_dc_val[ci] = 0;
+    entropy->saved.last_dc_val[ci] = 0;
       /* Update restart state */
       entropy->restarts_to_go = cinfo->restart_interval;
     }
@@ -664,8 +664,8 @@ encode_mcu_gather (j_compress_ptr cinfo, JBLOCKROW *MCU_data)
     ci = cinfo->MCU_membership[blkn];
     compptr = cinfo->cur_comp_info[ci];
     htest_one_block(cinfo, MCU_data[blkn][0], entropy->saved.last_dc_val[ci],
-		    entropy->dc_count_ptrs[compptr->dc_tbl_no],
+            entropy->dc_count_ptrs[compptr->dc_tbl_no],
-		    entropy->ac_count_ptrs[compptr->ac_tbl_no]);
+            entropy->ac_count_ptrs[compptr->ac_tbl_no]);
     entropy->saved.last_dc_val[ci] = MCU_data[blkn][0][0];
   }
 
@@ -718,7 +718,7 @@ jpeg_gen_optimal_table (j_compress_ptr cinfo, JHUFF_TBL * htbl, long freq[])
   MEMZERO(codesize, SIZEOF(codesize));
   for (i = 0; i < 257; i++)
     others[i] = -1;		/* init links to empty */
-  
+
   freq[256] = 1;		/* make sure 256 has a nonzero count */
   /* Including the pseudo-symbol 256 in the Huffman procedure guarantees
    * that no real symbol is given code-value of all ones, because 256
@@ -734,8 +734,8 @@ jpeg_gen_optimal_table (j_compress_ptr cinfo, JHUFF_TBL * htbl, long freq[])
     v = 1000000000L;
     for (i = 0; i <= 256; i++) {
       if (freq[i] && freq[i] <= v) {
-	v = freq[i];
+    v = freq[i];
-	c1 = i;
+    c1 = i;
       }
     }
 
@@ -745,15 +745,15 @@ jpeg_gen_optimal_table (j_compress_ptr cinfo, JHUFF_TBL * htbl, long freq[])
     v = 1000000000L;
     for (i = 0; i <= 256; i++) {
       if (freq[i] && freq[i] <= v && i != c1) {
-	v = freq[i];
+    v = freq[i];
-	c2 = i;
+    c2 = i;
       }
     }
 
     /* Done if we've merged everything into one frequency */
     if (c2 < 0)
       break;
-    
+
     /* Else merge the two counts/trees */
     freq[c1] += freq[c2];
     freq[c2] = 0;
@@ -764,9 +764,9 @@ jpeg_gen_optimal_table (j_compress_ptr cinfo, JHUFF_TBL * htbl, long freq[])
       c1 = others[c1];
       codesize[c1]++;
     }
-    
+
     others[c1] = c2;		/* chain c2 onto c1's tree branch */
-    
+
     /* Increment the codesize of everything in c2's tree branch */
     codesize[c2]++;
     while (others[c2] >= 0) {
@@ -781,7 +781,7 @@ jpeg_gen_optimal_table (j_compress_ptr cinfo, JHUFF_TBL * htbl, long freq[])
       /* The JPEG standard seems to think that this can't happen, */
       /* but I'm paranoid... */
       if (codesize[i] > MAX_CLEN)
-	ERREXIT(cinfo, JERR_HUFF_CLEN_OVERFLOW);
+    ERREXIT(cinfo, JERR_HUFF_CLEN_OVERFLOW);
 
       bits[codesize[i]]++;
     }
@@ -797,13 +797,13 @@ jpeg_gen_optimal_table (j_compress_ptr cinfo, JHUFF_TBL * htbl, long freq[])
    * shortest nonzero BITS entry is converted into a prefix for two code words
    * one bit longer.
    */
-  
+
   for (i = MAX_CLEN; i > 16; i--) {
     while (bits[i] > 0) {
       j = i - 2;		/* find length of new prefix to be used */
       while (bits[j] == 0)
-	j--;
+    j--;
-      
+
       bits[i] -= 2;		/* remove two symbols */
       bits[i-1]++;		/* one goes in this length */
       bits[j+1] += 2;		/* two new symbols in this length */
@@ -815,10 +815,10 @@ jpeg_gen_optimal_table (j_compress_ptr cinfo, JHUFF_TBL * htbl, long freq[])
   while (bits[i] == 0)		/* find largest codelength still in use */
     i--;
   bits[i]--;
-  
+
   /* Return final symbol counts (only for lengths 0..16) */
   MEMCOPY(htbl->bits, bits, SIZEOF(htbl->bits));
-  
+
   /* Return a list of the symbols sorted by code length */
   /* It's not real clear to me why we don't need to consider the codelength
    * changes made above, but the JPEG spec seems to think this works.
@@ -827,8 +827,8 @@ jpeg_gen_optimal_table (j_compress_ptr cinfo, JHUFF_TBL * htbl, long freq[])
   for (i = 1; i <= MAX_CLEN; i++) {
     for (j = 0; j <= 255; j++) {
       if (codesize[j] == i) {
-	htbl->huffval[p] = (UINT8) j;
+    htbl->huffval[p] = (UINT8) j;
-	p++;
+    p++;
       }
     }
   }
@@ -865,14 +865,14 @@ finish_pass_gather (j_compress_ptr cinfo)
     if (! did_dc[dctbl]) {
       htblptr = & cinfo->dc_huff_tbl_ptrs[dctbl];
       if (*htblptr == NULL)
-	*htblptr = jpeg_alloc_huff_table((j_common_ptr) cinfo);
+    *htblptr = jpeg_alloc_huff_table((j_common_ptr) cinfo);
       jpeg_gen_optimal_table(cinfo, *htblptr, entropy->dc_count_ptrs[dctbl]);
       did_dc[dctbl] = TRUE;
     }
     if (! did_ac[actbl]) {
       htblptr = & cinfo->ac_huff_tbl_ptrs[actbl];
       if (*htblptr == NULL)
-	*htblptr = jpeg_alloc_huff_table((j_common_ptr) cinfo);
+    *htblptr = jpeg_alloc_huff_table((j_common_ptr) cinfo);
       jpeg_gen_optimal_table(cinfo, *htblptr, entropy->ac_count_ptrs[actbl]);
       did_ac[actbl] = TRUE;
     }
@@ -895,7 +895,7 @@ jinit_huff_encoder (j_compress_ptr cinfo)
 
   entropy = (huff_entropy_ptr)
     (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
-				SIZEOF(huff_entropy_encoder));
+                SIZEOF(huff_entropy_encoder));
   cinfo->entropy = (struct jpeg_entropy_encoder *) entropy;
   entropy->pub.start_pass = start_pass_huff;
 

3rdparty/libjpeg/jchuff.h

@@ -39,9 +39,9 @@ typedef struct {
 
 /* Expand a Huffman table definition into the derived format */
 EXTERN(void) jpeg_make_c_derived_tbl
-	JPP((j_compress_ptr cinfo, boolean isDC, int tblno,
+    JPP((j_compress_ptr cinfo, boolean isDC, int tblno,
-	     c_derived_tbl ** pdtbl));
+         c_derived_tbl ** pdtbl));
 
 /* Generate an optimal table definition given the specified counts */
 EXTERN(void) jpeg_gen_optimal_table
-	JPP((j_compress_ptr cinfo, JHUFF_TBL * htbl, long freq[]));
+    JPP((j_compress_ptr cinfo, JHUFF_TBL * htbl, long freq[]));

3rdparty/libjpeg/jcinit.c

@@ -56,7 +56,7 @@ jinit_compress_master (j_compress_ptr cinfo)
 
   /* Need a full-image coefficient buffer in any multi-pass mode. */
   jinit_c_coef_controller(cinfo,
-		(boolean) (cinfo->num_scans > 1 || cinfo->optimize_coding));
+        (boolean) (cinfo->num_scans > 1 || cinfo->optimize_coding));
   jinit_c_main_controller(cinfo, FALSE /* never need full buffer here */);
 
   jinit_marker_writer(cinfo);

3rdparty/libjpeg/jcmainct.c

@@ -52,12 +52,12 @@ typedef my_main_controller * my_main_ptr;
 
 /* Forward declarations */
 METHODDEF(void) process_data_simple_main
-	JPP((j_compress_ptr cinfo, JSAMPARRAY input_buf,
+    JPP((j_compress_ptr cinfo, JSAMPARRAY input_buf,
-	     JDIMENSION *in_row_ctr, JDIMENSION in_rows_avail));
+         JDIMENSION *in_row_ctr, JDIMENSION in_rows_avail));
 #ifdef FULL_MAIN_BUFFER_SUPPORTED
 METHODDEF(void) process_data_buffer_main
-	JPP((j_compress_ptr cinfo, JSAMPARRAY input_buf,
+    JPP((j_compress_ptr cinfo, JSAMPARRAY input_buf,
-	     JDIMENSION *in_row_ctr, JDIMENSION in_rows_avail));
+         JDIMENSION *in_row_ctr, JDIMENSION in_rows_avail));
 #endif
 
 
@@ -111,8 +111,8 @@ start_pass_main (j_compress_ptr cinfo, J_BUF_MODE pass_mode)
 
 METHODDEF(void)
 process_data_simple_main (j_compress_ptr cinfo,
-			  JSAMPARRAY input_buf, JDIMENSION *in_row_ctr,
+              JSAMPARRAY input_buf, JDIMENSION *in_row_ctr,
-			  JDIMENSION in_rows_avail)
+              JDIMENSION in_rows_avail)
 {
   my_main_ptr main_ptr = (my_main_ptr) cinfo->main;
 
@@ -120,9 +120,9 @@ process_data_simple_main (j_compress_ptr cinfo,
     /* Read input data if we haven't filled the main_ptr buffer yet */
     if (main_ptr->rowgroup_ctr < DCTSIZE)
       (*cinfo->prep->pre_process_data) (cinfo,
-					input_buf, in_row_ctr, in_rows_avail,
+                    input_buf, in_row_ctr, in_rows_avail,
-					main_ptr->buffer, &main_ptr->rowgroup_ctr,
+                    main_ptr->buffer, &main_ptr->rowgroup_ctr,
-					(JDIMENSION) DCTSIZE);
+                    (JDIMENSION) DCTSIZE);
 
     /* If we don't have a full iMCU row buffered, return to application for
      * more data.  Note that preprocessor will always pad to fill the iMCU row
@@ -140,8 +140,8 @@ process_data_simple_main (j_compress_ptr cinfo,
        * think we were done.
        */
       if (! main_ptr->suspended) {
-	(*in_row_ctr)--;
+    (*in_row_ctr)--;
-	main_ptr->suspended = TRUE;
+    main_ptr->suspended = TRUE;
       }
       return;
     }
@@ -167,8 +167,8 @@ process_data_simple_main (j_compress_ptr cinfo,
 
 METHODDEF(void)
 process_data_buffer_main (j_compress_ptr cinfo,
-			  JSAMPARRAY input_buf, JDIMENSION *in_row_ctr,
+              JSAMPARRAY input_buf, JDIMENSION *in_row_ctr,
-			  JDIMENSION in_rows_avail)
+              JDIMENSION in_rows_avail)
 {
   my_main_ptr main_ptr = (my_main_ptr) cinfo->main;
   int ci;
@@ -179,16 +179,16 @@ process_data_buffer_main (j_compress_ptr cinfo,
     /* Realign the virtual buffers if at the start of an iMCU row. */
     if (main_ptr->rowgroup_ctr == 0) {
       for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
-	   ci++, compptr++) {
+       ci++, compptr++) {
-	main_ptr->buffer[ci] = (*cinfo->mem->access_virt_sarray)
+    main_ptr->buffer[ci] = (*cinfo->mem->access_virt_sarray)
-	  ((j_common_ptr) cinfo, main_ptr->whole_image[ci],
+      ((j_common_ptr) cinfo, main_ptr->whole_image[ci],
-	   main_ptr->cur_iMCU_row * (compptr->v_samp_factor * DCTSIZE),
+       main_ptr->cur_iMCU_row * (compptr->v_samp_factor * DCTSIZE),
-	   (JDIMENSION) (compptr->v_samp_factor * DCTSIZE), writing);
+       (JDIMENSION) (compptr->v_samp_factor * DCTSIZE), writing);
       }
       /* In a read pass, pretend we just read some source data. */
       if (! writing) {
-	*in_row_ctr += cinfo->max_v_samp_factor * DCTSIZE;
+    *in_row_ctr += cinfo->max_v_samp_factor * DCTSIZE;
-	main_ptr->rowgroup_ctr = DCTSIZE;
+    main_ptr->rowgroup_ctr = DCTSIZE;
       }
     }
 
@@ -196,35 +196,35 @@ process_data_buffer_main (j_compress_ptr cinfo,
     /* Note: preprocessor will pad if necessary to fill the last iMCU row. */
     if (writing) {
       (*cinfo->prep->pre_process_data) (cinfo,
-					input_buf, in_row_ctr, in_rows_avail,
+                    input_buf, in_row_ctr, in_rows_avail,
-					main_ptr->buffer, &main_ptr->rowgroup_ctr,
+                    main_ptr->buffer, &main_ptr->rowgroup_ctr,
-					(JDIMENSION) DCTSIZE);
+                    (JDIMENSION) DCTSIZE);
       /* Return to application if we need more data to fill the iMCU row. */
       if (main_ptr->rowgroup_ctr < DCTSIZE)
-	return;
+    return;
     }
 
     /* Emit data, unless this is a sink-only pass. */
     if (main_ptr->pass_mode != JBUF_SAVE_SOURCE) {
       if (! (*cinfo->coef->compress_data) (cinfo, main_ptr->buffer)) {
-	/* If compressor did not consume the whole row, then we must need to
+    /* If compressor did not consume the whole row, then we must need to
-	 * suspend processing and return to the application.  In this situation
+     * suspend processing and return to the application.  In this situation
-	 * we pretend we didn't yet consume the last input row; otherwise, if
+     * we pretend we didn't yet consume the last input row; otherwise, if
-	 * it happened to be the last row of the image, the application would
+     * it happened to be the last row of the image, the application would
-	 * think we were done.
+     * think we were done.
-	 */
+     */
-	if (! main_ptr->suspended) {
+    if (! main_ptr->suspended) {
-	  (*in_row_ctr)--;
+      (*in_row_ctr)--;
-	  main_ptr->suspended = TRUE;
+      main_ptr->suspended = TRUE;
-	}
+    }
-	return;
+    return;
       }
       /* We did finish the row.  Undo our little suspension hack if a previous
        * call suspended; then mark the main_ptr buffer empty.
        */
       if (main_ptr->suspended) {
-	(*in_row_ctr)++;
+    (*in_row_ctr)++;
-	main_ptr->suspended = FALSE;
+    main_ptr->suspended = FALSE;
       }
     }
 
@@ -250,7 +250,7 @@ jinit_c_main_controller (j_compress_ptr cinfo, boolean need_full_buffer)
 
   main_ptr = (my_main_ptr)
     (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
-				SIZEOF(my_main_controller));
+                SIZEOF(my_main_controller));
   cinfo->main = (struct jpeg_c_main_controller *) main_ptr;
   main_ptr->pub.start_pass = start_pass_main;
 
@@ -266,13 +266,13 @@ jinit_c_main_controller (j_compress_ptr cinfo, boolean need_full_buffer)
     /* Allocate a full-image virtual array for each component */
     /* Note we pad the bottom to a multiple of the iMCU height */
     for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
-	 ci++, compptr++) {
+     ci++, compptr++) {
       main_ptr->whole_image[ci] = (*cinfo->mem->request_virt_sarray)
-	((j_common_ptr) cinfo, JPOOL_IMAGE, FALSE,
+    ((j_common_ptr) cinfo, JPOOL_IMAGE, FALSE,
-	 compptr->width_in_blocks * DCTSIZE,
+     compptr->width_in_blocks * DCTSIZE,
-	 (JDIMENSION) jround_up((long) compptr->height_in_blocks,
+     (JDIMENSION) jround_up((long) compptr->height_in_blocks,
-				(long) compptr->v_samp_factor) * DCTSIZE,
+                (long) compptr->v_samp_factor) * DCTSIZE,
-	 (JDIMENSION) (compptr->v_samp_factor * DCTSIZE));
+     (JDIMENSION) (compptr->v_samp_factor * DCTSIZE));
     }
 #else
     ERREXIT(cinfo, JERR_BAD_BUFFER_MODE);
@@ -283,11 +283,11 @@ jinit_c_main_controller (j_compress_ptr cinfo, boolean need_full_buffer)
 #endif
     /* Allocate a strip buffer for each component */
     for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
-	 ci++, compptr++) {
+     ci++, compptr++) {
       main_ptr->buffer[ci] = (*cinfo->mem->alloc_sarray)
-	((j_common_ptr) cinfo, JPOOL_IMAGE,
+    ((j_common_ptr) cinfo, JPOOL_IMAGE,
-	 compptr->width_in_blocks * DCTSIZE,
+     compptr->width_in_blocks * DCTSIZE,
-	 (JDIMENSION) (compptr->v_samp_factor * DCTSIZE));
+     (JDIMENSION) (compptr->v_samp_factor * DCTSIZE));
     }
   }
 }