1HEADmaster

1 files changed, 802 insertions, 0 deletions

diff --git a/common/quicktime_win32/Endian.h b/common/quicktime_win32/Endian.h
new file mode 100644
index 0000000..4a6aee8
--- /dev/null
+++ b/common/quicktime_win32/Endian.h
@@ -0,0 +1,802 @@
+/*
+     File:       Endian.h
+ 
+     Contains:   Endian swapping utilties
+ 
+     Version:    QuickTime 7.3
+ 
+     Copyright:  (c) 2007 (c) 1997-2001 by Apple Computer, Inc., all rights reserved
+ 
+     Bugs?:      For bug reports, consult the following page on
+                 the World Wide Web:
+ 
+                     http://developer.apple.com/bugreporter/
+ 
+*/
+#ifndef __ENDIAN__
+#define __ENDIAN__
+
+#ifndef __CONDITIONALMACROS__
+#include <ConditionalMacros.h>
+#endif
+
+#ifndef __MACTYPES__
+#include <MacTypes.h>
+#endif
+
+
+
+
+#if PRAGMA_ONCE
+#pragma once
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#if PRAGMA_IMPORT
+#pragma import on
+#endif
+
+#if PRAGMA_STRUCT_ALIGN
+    #pragma options align=mac68k
+#elif PRAGMA_STRUCT_PACKPUSH
+    #pragma pack(push, 2)
+#elif PRAGMA_STRUCT_PACK
+    #pragma pack(2)
+#endif
+
+/*
+    This file provides Endian Flipping routines for dealing with converting data
+    between Big-Endian and Little-Endian machines.  These routines are useful
+    when writing code to compile for both Big and Little Endian machines and  
+    which must handle other endian number formats, such as reading or writing 
+    to a file or network packet.
+    
+    These routines are named as follows:
+    
+        Endian<U><W>_<S>to<D>
+
+    where
+        <U> is whether the integer is signed ('S') or unsigned ('U')
+        <W> is integer bit width: 16, 32, or 64 
+        <S> is the source endian format: 'B' for big, 'L' for little, or 'N' for native
+        <D> is the destination endian format: 'B' for big, 'L' for little, or 'N' for native
+    
+    For example, to convert a Big Endian 32-bit unsigned integer to the current native format use:
+        
+        long i = EndianU32_BtoN(data);
+        
+    This file is set up so that the function macro to nothing when the target runtime already
+    is the desired format (e.g. on Big Endian machines, EndianU32_BtoN() macros away).
+            
+    If long long's are not supported, you cannot get 64-bit quantities as a single value.
+    The macros are not defined in that case.
+    
+    
+    
+                                <<< W A R N I N G >>>
+    
+    It is very important not to put any autoincrements inside the macros.  This 
+    will produce erroneous results because each time the address is accessed in the macro, 
+    the increment occurs.
+    
+ */
+/*
+   Note: These functions are currently not implemented in any library
+         and are only listed here as function prototypes to document the macros
+*/
+#if CALL_NOT_IN_CARBON
+/*
+ *  EndianS16_BtoN()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   not available
+ *    CarbonLib:        not available
+ *    Mac OS X:         not available
+ */
+EXTERN_API_C( SInt16 )
+EndianS16_BtoN(SInt16 value);
+
+
+/*
+ *  EndianS16_NtoB()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   not available
+ *    CarbonLib:        not available
+ *    Mac OS X:         not available
+ */
+EXTERN_API_C( SInt16 )
+EndianS16_NtoB(SInt16 value);
+
+
+/*
+ *  EndianS16_LtoN()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   not available
+ *    CarbonLib:        not available
+ *    Mac OS X:         not available
+ */
+EXTERN_API_C( SInt16 )
+EndianS16_LtoN(SInt16 value);
+
+
+/*
+ *  EndianS16_NtoL()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   not available
+ *    CarbonLib:        not available
+ *    Mac OS X:         not available
+ */
+EXTERN_API_C( SInt16 )
+EndianS16_NtoL(SInt16 value);
+
+
+/*
+ *  EndianS16_LtoB()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   not available
+ *    CarbonLib:        not available
+ *    Mac OS X:         not available
+ */
+EXTERN_API_C( SInt16 )
+EndianS16_LtoB(SInt16 value);
+
+
+/*
+ *  EndianS16_BtoL()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   not available
+ *    CarbonLib:        not available
+ *    Mac OS X:         not available
+ */
+EXTERN_API_C( SInt16 )
+EndianS16_BtoL(SInt16 value);
+
+
+/*
+ *  EndianU16_BtoN()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   not available
+ *    CarbonLib:        not available
+ *    Mac OS X:         not available
+ */
+EXTERN_API_C( UInt16 )
+EndianU16_BtoN(UInt16 value);
+
+
+/*
+ *  EndianU16_NtoB()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   not available
+ *    CarbonLib:        not available
+ *    Mac OS X:         not available
+ */
+EXTERN_API_C( UInt16 )
+EndianU16_NtoB(UInt16 value);
+
+
+/*
+ *  EndianU16_LtoN()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   not available
+ *    CarbonLib:        not available
+ *    Mac OS X:         not available
+ */
+EXTERN_API_C( UInt16 )
+EndianU16_LtoN(UInt16 value);
+
+
+/*
+ *  EndianU16_NtoL()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   not available
+ *    CarbonLib:        not available
+ *    Mac OS X:         not available
+ */
+EXTERN_API_C( UInt16 )
+EndianU16_NtoL(UInt16 value);
+
+
+/*
+ *  EndianU16_LtoB()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   not available
+ *    CarbonLib:        not available
+ *    Mac OS X:         not available
+ */
+EXTERN_API_C( UInt16 )
+EndianU16_LtoB(UInt16 value);
+
+
+/*
+ *  EndianU16_BtoL()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   not available
+ *    CarbonLib:        not available
+ *    Mac OS X:         not available
+ */
+EXTERN_API_C( UInt16 )
+EndianU16_BtoL(UInt16 value);
+
+
+/*
+ *  EndianS32_BtoN()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   not available
+ *    CarbonLib:        not available
+ *    Mac OS X:         not available
+ */
+EXTERN_API_C( SInt32 )
+EndianS32_BtoN(SInt32 value);
+
+
+/*
+ *  EndianS32_NtoB()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   not available
+ *    CarbonLib:        not available
+ *    Mac OS X:         not available
+ */
+EXTERN_API_C( SInt32 )
+EndianS32_NtoB(SInt32 value);
+
+
+/*
+ *  EndianS32_LtoN()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   not available
+ *    CarbonLib:        not available
+ *    Mac OS X:         not available
+ */
+EXTERN_API_C( SInt32 )
+EndianS32_LtoN(SInt32 value);
+
+
+/*
+ *  EndianS32_NtoL()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   not available
+ *    CarbonLib:        not available
+ *    Mac OS X:         not available
+ */
+EXTERN_API_C( SInt32 )
+EndianS32_NtoL(SInt32 value);
+
+
+/*
+ *  EndianS32_LtoB()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   not available
+ *    CarbonLib:        not available
+ *    Mac OS X:         not available
+ */
+EXTERN_API_C( SInt32 )
+EndianS32_LtoB(SInt32 value);
+
+
+/*
+ *  EndianS32_BtoL()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   not available
+ *    CarbonLib:        not available
+ *    Mac OS X:         not available
+ */
+EXTERN_API_C( SInt32 )
+EndianS32_BtoL(SInt32 value);
+
+
+/*
+ *  EndianU32_BtoN()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   not available
+ *    CarbonLib:        not available
+ *    Mac OS X:         not available
+ */
+EXTERN_API_C( UInt32 )
+EndianU32_BtoN(UInt32 value);
+
+
+/*
+ *  EndianU32_NtoB()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   not available
+ *    CarbonLib:        not available
+ *    Mac OS X:         not available
+ */
+EXTERN_API_C( UInt32 )
+EndianU32_NtoB(UInt32 value);
+
+
+/*
+ *  EndianU32_LtoN()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   not available
+ *    CarbonLib:        not available
+ *    Mac OS X:         not available
+ */
+EXTERN_API_C( UInt32 )
+EndianU32_LtoN(UInt32 value);
+
+
+/*
+ *  EndianU32_NtoL()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   not available
+ *    CarbonLib:        not available
+ *    Mac OS X:         not available
+ */
+EXTERN_API_C( UInt32 )
+EndianU32_NtoL(UInt32 value);
+
+
+/*
+ *  EndianU32_LtoB()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   not available
+ *    CarbonLib:        not available
+ *    Mac OS X:         not available
+ */
+EXTERN_API_C( UInt32 )
+EndianU32_LtoB(UInt32 value);
+
+
+/*
+ *  EndianU32_BtoL()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   not available
+ *    CarbonLib:        not available
+ *    Mac OS X:         not available
+ */
+EXTERN_API_C( UInt32 )
+EndianU32_BtoL(UInt32 value);
+
+
+#endif  /* CALL_NOT_IN_CARBON */
+
+#if !TYPE_LONGLONG
+/*
+   Note: If these Int64 functions ever were implemented in a library,
+         we would need two libraries, one for compilers that
+         support long long and one for other compilers.
+*/
+#if CALL_NOT_IN_CARBON
+/*
+ *  EndianS64_BtoN()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   not available
+ *    CarbonLib:        not available
+ *    Mac OS X:         not available
+ */
+EXTERN_API_C( SInt64 )
+EndianS64_BtoN(SInt64 value);
+
+
+/*
+ *  EndianS64_NtoB()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   not available
+ *    CarbonLib:        not available
+ *    Mac OS X:         not available
+ */
+EXTERN_API_C( SInt64 )
+EndianS64_NtoB(SInt64 value);
+
+
+/*
+ *  EndianS64_LtoN()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   not available
+ *    CarbonLib:        not available
+ *    Mac OS X:         not available
+ */
+EXTERN_API_C( SInt64 )
+EndianS64_LtoN(SInt64 value);
+
+
+/*
+ *  EndianS64_NtoL()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   not available
+ *    CarbonLib:        not available
+ *    Mac OS X:         not available
+ */
+EXTERN_API_C( SInt64 )
+EndianS64_NtoL(SInt64 value);
+
+
+/*
+ *  EndianS64_LtoB()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   not available
+ *    CarbonLib:        not available
+ *    Mac OS X:         not available
+ */
+EXTERN_API_C( SInt64 )
+EndianS64_LtoB(SInt64 value);
+
+
+/*
+ *  EndianS64_BtoL()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   not available
+ *    CarbonLib:        not available
+ *    Mac OS X:         not available
+ */
+EXTERN_API_C( SInt64 )
+EndianS64_BtoL(SInt64 value);
+
+
+/*
+ *  EndianU64_BtoN()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   not available
+ *    CarbonLib:        not available
+ *    Mac OS X:         not available
+ */
+EXTERN_API_C( UInt64 )
+EndianU64_BtoN(UInt64 value);
+
+
+/*
+ *  EndianU64_NtoB()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   not available
+ *    CarbonLib:        not available
+ *    Mac OS X:         not available
+ */
+EXTERN_API_C( UInt64 )
+EndianU64_NtoB(UInt64 value);
+
+
+/*
+ *  EndianU64_LtoN()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   not available
+ *    CarbonLib:        not available
+ *    Mac OS X:         not available
+ */
+EXTERN_API_C( UInt64 )
+EndianU64_LtoN(UInt64 value);
+
+
+/*
+ *  EndianU64_NtoL()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   not available
+ *    CarbonLib:        not available
+ *    Mac OS X:         not available
+ */
+EXTERN_API_C( UInt64 )
+EndianU64_NtoL(UInt64 value);
+
+
+/*
+ *  EndianU64_LtoB()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   not available
+ *    CarbonLib:        not available
+ *    Mac OS X:         not available
+ */
+EXTERN_API_C( UInt64 )
+EndianU64_LtoB(UInt64 value);
+
+
+/*
+ *  EndianU64_BtoL()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   not available
+ *    CarbonLib:        not available
+ *    Mac OS X:         not available
+ */
+EXTERN_API_C( UInt64 )
+EndianU64_BtoL(UInt64 value);
+
+
+#endif  /* CALL_NOT_IN_CARBON */
+
+#endif  /* !TYPE_LONGLONG */
+
+/*
+   These types are used for structures that contain data that is
+   always in BigEndian format.  This extra typing prevents little
+   endian code from directly changing the data, thus saving much
+   time in the debugger.
+*/
+
+#if TARGET_RT_LITTLE_ENDIAN
+struct BigEndianLong {
+  long                bigEndianValue;
+};
+typedef struct BigEndianLong            BigEndianLong;
+struct BigEndianUnsignedLong {
+  unsigned long       bigEndianValue;
+};
+typedef struct BigEndianUnsignedLong    BigEndianUnsignedLong;
+struct BigEndianShort {
+  short               bigEndianValue;
+};
+typedef struct BigEndianShort           BigEndianShort;
+struct BigEndianUnsignedShort {
+  unsigned short      bigEndianValue;
+};
+typedef struct BigEndianUnsignedShort   BigEndianUnsignedShort;
+struct BigEndianFixed {
+  Fixed               bigEndianValue;
+};
+typedef struct BigEndianFixed           BigEndianFixed;
+struct BigEndianUnsignedFixed {
+  UnsignedFixed       bigEndianValue;
+};
+typedef struct BigEndianUnsignedFixed   BigEndianUnsignedFixed;
+struct BigEndianOSType {
+  OSType              bigEndianValue;
+};
+typedef struct BigEndianOSType          BigEndianOSType;
+#else
+
+typedef long                            BigEndianLong;
+typedef unsigned long                   BigEndianUnsignedLong;
+typedef short                           BigEndianShort;
+typedef unsigned short                  BigEndianUnsignedShort;
+typedef Fixed                           BigEndianFixed;
+typedef UnsignedFixed                   BigEndianUnsignedFixed;
+typedef OSType                          BigEndianOSType;
+#endif  /* TARGET_RT_LITTLE_ENDIAN */
+
+
+/*
+    Macro away no-op functions
+*/
+#if TARGET_RT_BIG_ENDIAN
+ #define EndianS16_BtoN(value)               (value)
+    #define EndianS16_NtoB(value)               (value)
+    #define EndianU16_BtoN(value)               (value)
+    #define EndianU16_NtoB(value)               (value)
+    #define EndianS32_BtoN(value)               (value)
+    #define EndianS32_NtoB(value)               (value)
+    #define EndianU32_BtoN(value)               (value)
+    #define EndianU32_NtoB(value)               (value)
+    #define EndianS64_BtoN(value)               (value)
+    #define EndianS64_NtoB(value)               (value)
+    #define EndianU64_BtoN(value)               (value)
+    #define EndianU64_NtoB(value)               (value)
+#else
+  #define EndianS16_LtoN(value)               (value)
+    #define EndianS16_NtoL(value)               (value)
+    #define EndianU16_LtoN(value)               (value)
+    #define EndianU16_NtoL(value)               (value)
+    #define EndianS32_LtoN(value)               (value)
+    #define EndianS32_NtoL(value)               (value)
+    #define EndianU32_LtoN(value)               (value)
+    #define EndianU32_NtoL(value)               (value)
+    #define EndianS64_LtoN(value)               (value)
+    #define EndianS64_NtoL(value)               (value)
+    #define EndianU64_LtoN(value)               (value)
+    #define EndianU64_NtoL(value)               (value)
+#endif
+
+
+
+/*
+    Map native to actual
+*/
+#if TARGET_RT_BIG_ENDIAN
+   #define EndianS16_LtoN(value)               EndianS16_LtoB(value)
+  #define EndianS16_NtoL(value)               EndianS16_BtoL(value)
+  #define EndianU16_LtoN(value)               EndianU16_LtoB(value)
+  #define EndianU16_NtoL(value)               EndianU16_BtoL(value)
+  #define EndianS32_LtoN(value)               EndianS32_LtoB(value)
+  #define EndianS32_NtoL(value)               EndianS32_BtoL(value)
+  #define EndianU32_LtoN(value)               EndianU32_LtoB(value)
+  #define EndianU32_NtoL(value)               EndianU32_BtoL(value)
+  #define EndianS64_LtoN(value)               EndianS64_LtoB(value)
+  #define EndianS64_NtoL(value)               EndianS64_BtoL(value)
+  #define EndianU64_LtoN(value)               EndianU64_LtoB(value)
+  #define EndianU64_NtoL(value)               EndianU64_BtoL(value)
+#else
+    #define EndianS16_BtoN(value)               EndianS16_BtoL(value)
+  #define EndianS16_NtoB(value)               EndianS16_LtoB(value)
+  #define EndianU16_BtoN(value)               EndianU16_BtoL(value)
+  #define EndianU16_NtoB(value)               EndianU16_LtoB(value)
+  #define EndianS32_BtoN(value)               EndianS32_BtoL(value)
+  #define EndianS32_NtoB(value)               EndianS32_LtoB(value)
+  #define EndianU32_BtoN(value)               EndianU32_BtoL(value)
+  #define EndianU32_NtoB(value)               EndianU32_LtoB(value)
+  #define EndianS64_BtoN(value)               EndianS64_BtoL(value)
+  #define EndianS64_NtoB(value)               EndianS64_LtoB(value)
+  #define EndianU64_BtoN(value)               EndianU64_BtoL(value)
+  #define EndianU64_NtoB(value)               EndianU64_LtoB(value)
+#endif
+
+
+
+/*
+    Implement �LtoB and �BtoL
+*/
+#define EndianS16_LtoB(value)              ((SInt16)Endian16_Swap(value))
+#define EndianS16_BtoL(value)                ((SInt16)Endian16_Swap(value))
+#define EndianU16_LtoB(value)                ((UInt16)Endian16_Swap(value))
+#define EndianU16_BtoL(value)                ((UInt16)Endian16_Swap(value))
+#define EndianS32_LtoB(value)                ((SInt32)Endian32_Swap(value))
+#define EndianS32_BtoL(value)                ((SInt32)Endian32_Swap(value))
+#define EndianU32_LtoB(value)                ((UInt32)Endian32_Swap(value))
+#define EndianU32_BtoL(value)                ((UInt32)Endian32_Swap(value))
+#define EndianS64_LtoB(value)                ((SInt64)Endian64_Swap((UInt64)value))
+#define EndianS64_BtoL(value)                ((SInt64)Endian64_Swap((UInt64)value))
+#define EndianU64_LtoB(value)                ((UInt64)Endian64_Swap(value))
+#define EndianU64_BtoL(value)                ((UInt64)Endian64_Swap(value))
+
+
+
+/*
+    Implement low level *_Swap functions.
+    
+        extern UInt16 Endian16_Swap(UInt16 value);
+        extern UInt32 Endian32_Swap(UInt32 value);
+        extern UInt64 Endian64_Swap(UInt64 value);
+        
+    Note: Depending on the processor, you might want to implement
+          these as function calls instead of macros.
+    
+*/
+#if CALL_NOT_IN_CARBON
+/*
+ *  Endian16_Swap()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   not available
+ *    CarbonLib:        not available
+ *    Mac OS X:         not available
+ */
+#if TARGET_OS_MAC && TARGET_CPU_68K && !TARGET_RT_MAC_CFM
+#pragma parameter __D0 Endian16_Swap(__D0)
+#endif
+EXTERN_API( UInt16 )
+Endian16_Swap(UInt16 value)                                   ONEWORDINLINE(0xE158);
+
+
+/*
+ *  Endian32_Swap()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   not available
+ *    CarbonLib:        not available
+ *    Mac OS X:         not available
+ */
+#if TARGET_OS_MAC && TARGET_CPU_68K && !TARGET_RT_MAC_CFM
+#pragma parameter __D0 Endian32_Swap(__D0)
+#endif
+EXTERN_API( UInt32 )
+Endian32_Swap(UInt32 value)                                   THREEWORDINLINE(0xE158, 0x4840, 0xE158);
+
+
+#endif  /* CALL_NOT_IN_CARBON */
+
+/* override with macros */
+#define Endian16_Swap(value)                 \
+        (((((UInt16)value)<<8) & 0xFF00)   | \
+         ((((UInt16)value)>>8) & 0x00FF))
+
+#define Endian32_Swap(value)                     \
+        (((((UInt32)value)<<24) & 0xFF000000)  | \
+         ((((UInt32)value)<< 8) & 0x00FF0000)  | \
+         ((((UInt32)value)>> 8) & 0x0000FF00)  | \
+         ((((UInt32)value)>>24) & 0x000000FF))
+
+#if TYPE_LONGLONG
+    #if TARGET_OS_WIN32
+        /* the inline macros crash MSDEV's optimizer on Windows. */
+        extern UInt64 Endian64_Swap(UInt64 value);
+    #elif defined(__MWERKS__) && (__MWERKS__ < 0x1800)
+        /* older Metrowerks compilers errored on LL suffix */
+        #define Endian64_Swap(value)                             \
+                (((((UInt64)value)<<56) & 0xFF00000000000000)  | \
+                 ((((UInt64)value)<<40) & 0x00FF000000000000)  | \
+                 ((((UInt64)value)<<24) & 0x0000FF0000000000)  | \
+                 ((((UInt64)value)<< 8) & 0x000000FF00000000)  | \
+                 ((((UInt64)value)>> 8) & 0x00000000FF000000)  | \
+                 ((((UInt64)value)>>24) & 0x0000000000FF0000)  | \
+                 ((((UInt64)value)>>40) & 0x000000000000FF00)  | \
+                 ((((UInt64)value)>>56) & 0x00000000000000FF))
+    #else
+        #define Endian64_Swap(value)                                \
+                (((((UInt64)value)<<56) & 0xFF00000000000000ULL)  | \
+                 ((((UInt64)value)<<40) & 0x00FF000000000000ULL)  | \
+                 ((((UInt64)value)<<24) & 0x0000FF0000000000ULL)  | \
+                 ((((UInt64)value)<< 8) & 0x000000FF00000000ULL)  | \
+                 ((((UInt64)value)>> 8) & 0x00000000FF000000ULL)  | \
+                 ((((UInt64)value)>>24) & 0x0000000000FF0000ULL)  | \
+                 ((((UInt64)value)>>40) & 0x000000000000FF00ULL)  | \
+                 ((((UInt64)value)>>56) & 0x00000000000000FFULL))
+    #endif
+#else
+/* 
+    Note: When using compilers that don't support "long long",
+          Endian64_Swap must be implemented as glue. 
+*/
+#ifdef __cplusplus
+    inline static UInt64 Endian64_Swap(UInt64 value)
+    {
+        UInt64 temp;
+        ((UnsignedWide*)&temp)->lo = Endian32_Swap(((UnsignedWide*)&value)->hi);
+        ((UnsignedWide*)&temp)->hi = Endian32_Swap(((UnsignedWide*)&value)->lo);
+        return temp;
+    }
+#else
+#if CALL_NOT_IN_CARBON
+/*
+ *  Endian64_Swap()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   not available
+ *    CarbonLib:        not available
+ *    Mac OS X:         not available
+ */
+EXTERN_API_C( UInt64 )
+Endian64_Swap(UInt64 value);
+
+
+#endif  /* CALL_NOT_IN_CARBON */
+
+#endif
+#endif  /* TYPE_LONGLONG */
+
+
+
+#if PRAGMA_STRUCT_ALIGN
+    #pragma options align=reset
+#elif PRAGMA_STRUCT_PACKPUSH
+    #pragma pack(pop)
+#elif PRAGMA_STRUCT_PACK
+    #pragma pack()
+#endif
+
+#ifdef PRAGMA_IMPORT_OFF
+#pragma import off
+#elif PRAGMA_IMPORT
+#pragma import reset
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* __ENDIAN__ */
+