DISTRHO
/
JUCE
mirror of https://github.com/DISTRHO/JUCE
1
0
Fork 0
Code Releases 1 Activity
Browse Source

Added locking to NamedPipe. Added extra checking to Image::clear. Other minor tidying-up.

tags/2021-05-28
Julian Storer 15 years ago
parent
a879d03c08
commit
dca61e54a4
15 changed files with 827 additions and 1196 deletions
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. +337
    -525
      juce_amalgamated.cpp
  2. +74
    -71
      juce_amalgamated.h
  3. +5
    -5
      src/core/juce_Atomic.h
  4. +8
    -8
      src/core/juce_ByteOrder.h
  5. +78
    -88
      src/core/juce_Time.cpp
  6. +21
    -21
      src/core/juce_Time.h
  7. +160
    -326
      src/cryptography/juce_BlowFish.cpp
  8. +4
    -4
      src/cryptography/juce_BlowFish.h
  9. +28
    -26
      src/gui/graphics/imaging/juce_Image.cpp
  10. +20
    -20
      src/gui/graphics/imaging/juce_Image.h
  11. +15
    -18
      src/gui/graphics/imaging/juce_ImageCache.cpp
  12. +15
    -12
      src/gui/graphics/imaging/juce_ImageCache.h
  13. +2
    -0
      src/io/files/juce_NamedPipe.h
  14. +29
    -30
      src/io/streams/juce_InputStream.cpp
  15. +31
    -42
      src/native/windows/juce_win32_Files.cpp

+ 337
- 525
juce_amalgamated.cpp
File diff suppressed because it is too large
View File


+ 74
- 71
juce_amalgamated.h View File

@@ -923,10 +923,10 @@ inline uint64 ByteOrder::swap (uint64 value)
inline uint16 ByteOrder::swapIfLittleEndian (const uint16 v) { return swap (v); } inline uint16 ByteOrder::swapIfLittleEndian (const uint16 v) { return swap (v); }
inline uint32 ByteOrder::swapIfLittleEndian (const uint32 v) { return swap (v); } inline uint32 ByteOrder::swapIfLittleEndian (const uint32 v) { return swap (v); }
inline uint64 ByteOrder::swapIfLittleEndian (const uint64 v) { return swap (v); } inline uint64 ByteOrder::swapIfLittleEndian (const uint64 v) { return swap (v); }
inline uint32 ByteOrder::littleEndianInt (const char* const bytes) { return *(uint32*) bytes; }
inline uint16 ByteOrder::littleEndianShort (const char* const bytes) { return *(uint16*) bytes; }
inline uint32 ByteOrder::bigEndianInt (const char* const bytes) { return swap (*(uint32*) bytes); }
inline uint16 ByteOrder::bigEndianShort (const char* const bytes) { return swap (*(uint16*) bytes); }
inline uint32 ByteOrder::littleEndianInt (const char* const bytes) { return *reinterpret_cast <const uint32*> (bytes); }
inline uint16 ByteOrder::littleEndianShort (const char* const bytes) { return *reinterpret_cast <const uint16*> (bytes); }
inline uint32 ByteOrder::bigEndianInt (const char* const bytes) { return swap (*reinterpret_cast <const uint32*> (bytes)); }
inline uint16 ByteOrder::bigEndianShort (const char* const bytes) { return swap (*reinterpret_cast <const uint16*> (bytes)); }
inline bool ByteOrder::isBigEndian() { return false; } inline bool ByteOrder::isBigEndian() { return false; }
#else #else
inline uint16 ByteOrder::swapIfBigEndian (const uint16 v) { return swap (v); } inline uint16 ByteOrder::swapIfBigEndian (const uint16 v) { return swap (v); }
@@ -935,10 +935,10 @@ inline uint64 ByteOrder::swap (uint64 value)
inline uint16 ByteOrder::swapIfLittleEndian (const uint16 v) { return v; } inline uint16 ByteOrder::swapIfLittleEndian (const uint16 v) { return v; }
inline uint32 ByteOrder::swapIfLittleEndian (const uint32 v) { return v; } inline uint32 ByteOrder::swapIfLittleEndian (const uint32 v) { return v; }
inline uint64 ByteOrder::swapIfLittleEndian (const uint64 v) { return v; } inline uint64 ByteOrder::swapIfLittleEndian (const uint64 v) { return v; }
inline uint32 ByteOrder::littleEndianInt (const char* const bytes) { return swap (*(uint32*) bytes); }
inline uint16 ByteOrder::littleEndianShort (const char* const bytes) { return swap (*(uint16*) bytes); }
inline uint32 ByteOrder::bigEndianInt (const char* const bytes) { return *(uint32*) bytes; }
inline uint16 ByteOrder::bigEndianShort (const char* const bytes) { return *(uint16*) bytes; }
inline uint32 ByteOrder::littleEndianInt (const char* const bytes) { return swap (*reinterpret_cast <const uint32*> (bytes)); }
inline uint16 ByteOrder::littleEndianShort (const char* const bytes) { return swap (*reinterpret_cast <const uint16*> (bytes)); }
inline uint32 ByteOrder::bigEndianInt (const char* const bytes) { return *reinterpret_cast <const uint32*> (bytes); }
inline uint16 ByteOrder::bigEndianShort (const char* const bytes) { return *reinterpret_cast <const uint16*> (bytes); }
inline bool ByteOrder::isBigEndian() { return true; } inline bool ByteOrder::isBigEndian() { return true; }
#endif #endif


@@ -3076,11 +3076,11 @@ public:


#if (JUCE_MAC || JUCE_IPHONE) // Mac and iPhone... #if (JUCE_MAC || JUCE_IPHONE) // Mac and iPhone...


inline void Atomic::increment (int32& variable) { OSAtomicIncrement32 ((int32_t*) &variable); }
inline int32 Atomic::incrementAndReturn (int32& variable) { return OSAtomicIncrement32 ((int32_t*) &variable); }
inline void Atomic::decrement (int32& variable) { OSAtomicDecrement32 ((int32_t*) &variable); }
inline int32 Atomic::decrementAndReturn (int32& variable) { return OSAtomicDecrement32 ((int32_t*) &variable); }
inline int32 Atomic::compareAndExchange (int32& destination, int32 newValue, int32 oldValue)
inline void Atomic::increment (int32& variable) { OSAtomicIncrement32 ((int32_t*) &variable); }
inline int32 Atomic::incrementAndReturn (int32& variable) { return OSAtomicIncrement32 ((int32_t*) &variable); }
inline void Atomic::decrement (int32& variable) { OSAtomicDecrement32 ((int32_t*) &variable); }
inline int32 Atomic::decrementAndReturn (int32& variable) { return OSAtomicDecrement32 ((int32_t*) &variable); }
inline int32 Atomic::compareAndExchange (int32& destination, int32 newValue, int32 oldValue)
{ return OSAtomicCompareAndSwap32Barrier (oldValue, newValue, (int32_t*) &destination); } { return OSAtomicCompareAndSwap32Barrier (oldValue, newValue, (int32_t*) &destination); }
inline void* Atomic::swapPointers (void* volatile* value1, void* value2) inline void* Atomic::swapPointers (void* volatile* value1, void* value2)
{ {
@@ -4112,16 +4112,16 @@ public:


Time (const Time& other) throw(); Time (const Time& other) throw();


Time (const int64 millisecondsSinceEpoch) throw();
Time (int64 millisecondsSinceEpoch) throw();


Time (const int year,
const int month,
const int day,
const int hours,
const int minutes,
const int seconds = 0,
const int milliseconds = 0,
const bool useLocalTime = true) throw();
Time (int year,
int month,
int day,
int hours,
int minutes,
int seconds = 0,
int milliseconds = 0,
bool useLocalTime = true) throw();


~Time() throw(); ~Time() throw();


@@ -4135,13 +4135,13 @@ public:


int getMonth() const throw(); int getMonth() const throw();


const String getMonthName (const bool threeLetterVersion) const throw();
const String getMonthName (bool threeLetterVersion) const throw();


int getDayOfMonth() const throw(); int getDayOfMonth() const throw();


int getDayOfWeek() const throw(); int getDayOfWeek() const throw();


const String getWeekdayName (const bool threeLetterVersion) const throw();
const String getWeekdayName (bool threeLetterVersion) const throw();


int getHours() const throw(); int getHours() const throw();


@@ -4159,12 +4159,12 @@ public:


const String getTimeZone() const throw(); const String getTimeZone() const throw();


const String toString (const bool includeDate,
const bool includeTime,
const bool includeSeconds = true,
const bool use24HourClock = false) const throw();
const String toString (bool includeDate,
bool includeTime,
bool includeSeconds = true,
bool use24HourClock = false) const throw();


const String formatted (const tchar* const format) const throw();
const String formatted (const juce_wchar* format) const throw();


const Time operator+ (const RelativeTime& delta) const throw() { return Time (millisSinceEpoch + delta.inMilliseconds()); } const Time operator+ (const RelativeTime& delta) const throw() { return Time (millisSinceEpoch + delta.inMilliseconds()); }


@@ -4187,10 +4187,10 @@ public:
bool setSystemTimeToThisTime() const throw(); bool setSystemTimeToThisTime() const throw();


static const String getWeekdayName (int dayNumber, static const String getWeekdayName (int dayNumber,
const bool threeLetterVersion) throw();
bool threeLetterVersion) throw();


static const String getMonthName (int monthNumber, static const String getMonthName (int monthNumber,
const bool threeLetterVersion) throw();
bool threeLetterVersion) throw();


// Static methods for getting system timers directly.. // Static methods for getting system timers directly..


@@ -4200,7 +4200,7 @@ public:


static double getMillisecondCounterHiRes() throw(); static double getMillisecondCounterHiRes() throw();


static void waitForMillisecondCounter (const uint32 targetTime) throw();
static void waitForMillisecondCounter (uint32 targetTime) throw();


static uint32 getApproximateMillisecondCounter() throw(); static uint32 getApproximateMillisecondCounter() throw();


@@ -4210,9 +4210,9 @@ public:


static int64 getHighResolutionTicksPerSecond() throw(); static int64 getHighResolutionTicksPerSecond() throw();


static double highResolutionTicksToSeconds (const int64 ticks) throw();
static double highResolutionTicksToSeconds (int64 ticks) throw();


static int64 secondsToHighResolutionTicks (const double seconds) throw();
static int64 secondsToHighResolutionTicks (double seconds) throw();


private: private:


@@ -7429,7 +7429,7 @@ class JUCE_API BlowFish
{ {
public: public:


BlowFish (const uint8* keyData, int keyBytes);
BlowFish (const void* keyData, int keyBytes);


BlowFish (const BlowFish& other); BlowFish (const BlowFish& other);


@@ -7437,9 +7437,9 @@ public:


~BlowFish(); ~BlowFish();


void encrypt (uint32& data1, uint32& data2) const;
void encrypt (uint32& data1, uint32& data2) const throw();


void decrypt (uint32& data1, uint32& data2) const;
void decrypt (uint32& data1, uint32& data2) const throw();


juce_UseDebuggingNewOperator juce_UseDebuggingNewOperator


@@ -7447,7 +7447,7 @@ private:
uint32 p[18]; uint32 p[18];
HeapBlock <uint32> s[4]; HeapBlock <uint32> s[4];


uint32 F (uint32 x) const;
uint32 F (uint32 x) const throw();
}; };


#endif // __JUCE_BLOWFISH_JUCEHEADER__ #endif // __JUCE_BLOWFISH_JUCEHEADER__
@@ -7799,6 +7799,7 @@ public:
private: private:
void* internal; void* internal;
String currentPipeName; String currentPipeName;
CriticalSection lock;


NamedPipe (const NamedPipe&); NamedPipe (const NamedPipe&);
NamedPipe& operator= (const NamedPipe&); NamedPipe& operator= (const NamedPipe&);
@@ -22125,19 +22126,19 @@ public:
SingleChannel /**<< each pixel is a 1-byte alpha channel value. */ SingleChannel /**<< each pixel is a 1-byte alpha channel value. */
}; };


Image (const PixelFormat format,
const int imageWidth,
const int imageHeight,
const bool clearImage);
Image (PixelFormat format,
int imageWidth,
int imageHeight,
bool clearImage);


Image (const Image& other); Image (const Image& other);


virtual ~Image(); virtual ~Image();


static Image* createNativeImage (const PixelFormat format,
const int imageWidth,
const int imageHeight,
const bool clearImage);
static Image* createNativeImage (PixelFormat format,
int imageWidth,
int imageHeight,
bool clearImage);


int getWidth() const throw() { return imageWidth; } int getWidth() const throw() { return imageWidth; }


@@ -22158,30 +22159,30 @@ public:


virtual Image* createCopy (int newWidth = -1, virtual Image* createCopy (int newWidth = -1,
int newHeight = -1, int newHeight = -1,
const Graphics::ResamplingQuality quality = Graphics::mediumResamplingQuality) const;
Graphics::ResamplingQuality quality = Graphics::mediumResamplingQuality) const;


virtual Image* createCopyOfAlphaChannel() const; virtual Image* createCopyOfAlphaChannel() const;


virtual const Colour getPixelAt (const int x, const int y) const;
virtual const Colour getPixelAt (int x, int y) const;


virtual void setPixelAt (const int x, const int y, const Colour& colour);
virtual void setPixelAt (int x, int y, const Colour& colour);


virtual void multiplyAlphaAt (const int x, const int y, const float multiplier);
virtual void multiplyAlphaAt (int x, int y, float multiplier);


virtual void multiplyAllAlphas (const float amountToMultiplyBy);
virtual void multiplyAllAlphas (float amountToMultiplyBy);


virtual void desaturate(); virtual void desaturate();


class BitmapData class BitmapData
{ {
public: public:
BitmapData (Image& image, int x, int y, int w, int h, const bool needsToBeWritable);
BitmapData (Image& image, int x, int y, int w, int h, bool needsToBeWritable);
BitmapData (const Image& image, int x, int y, int w, int h); BitmapData (const Image& image, int x, int y, int w, int h);
~BitmapData(); ~BitmapData();


inline uint8* getLinePointer (const int y) const { return data + y * lineStride; }
inline uint8* getLinePointer (int y) const { return data + y * lineStride; }


inline uint8* getPixelPointer (const int x, const int y) const { return data + y * lineStride + x * pixelStride; }
inline uint8* getPixelPointer (int x, int y) const { return data + y * lineStride + x * pixelStride; }


uint8* data; uint8* data;
int lineStride, pixelStride, width, height; int lineStride, pixelStride, width, height;
@@ -22199,7 +22200,7 @@ public:
int width, int height); int width, int height);


void createSolidAreaMask (RectangleList& result, void createSolidAreaMask (RectangleList& result,
const float alphaThreshold = 0.5f) const;
float alphaThreshold = 0.5f) const;


juce_UseDebuggingNewOperator juce_UseDebuggingNewOperator


@@ -22210,9 +22211,9 @@ protected:
const PixelFormat format; const PixelFormat format;
const int imageWidth, imageHeight; const int imageWidth, imageHeight;


Image (const PixelFormat format,
const int imageWidth,
const int imageHeight);
Image (PixelFormat format,
int imageWidth,
int imageHeight);


int pixelStride, lineStride; int pixelStride, lineStride;
HeapBlock <uint8> imageDataAllocated; HeapBlock <uint8> imageDataAllocated;
@@ -28241,8 +28242,6 @@ private:
#ifndef __JUCE_IMAGECACHE_JUCEHEADER__ #ifndef __JUCE_IMAGECACHE_JUCEHEADER__
#define __JUCE_IMAGECACHE_JUCEHEADER__ #define __JUCE_IMAGECACHE_JUCEHEADER__


struct ImageCacheItem;

class JUCE_API ImageCache : private DeletedAtShutdown, class JUCE_API ImageCache : private DeletedAtShutdown,
private Timer private Timer
{ {
@@ -28250,30 +28249,34 @@ public:


static Image* getFromFile (const File& file); static Image* getFromFile (const File& file);


static Image* getFromMemory (const void* imageData,
const int dataSize);
static Image* getFromMemory (const void* imageData, int dataSize);


static void release (Image* const imageToRelease);
static void release (Image* imageToRelease);


static void releaseOrDelete (Image* const imageToRelease);
static void releaseOrDelete (Image* imageToRelease);


static bool isImageInCache (Image* const imageToLookFor);
static bool isImageInCache (Image* imageToLookFor);


static void incReferenceCount (Image* const image);
static void incReferenceCount (Image* image);


static Image* getFromHashCode (const int64 hashCode);
static Image* getFromHashCode (int64 hashCode);


static void addImageToCache (Image* const image,
const int64 hashCode);
static void addImageToCache (Image* image, int64 hashCode);


static void setCacheTimeout (const int millisecs);
static void setCacheTimeout (int millisecs);


juce_UseDebuggingNewOperator juce_UseDebuggingNewOperator


private: private:


CriticalSection lock; CriticalSection lock;
OwnedArray <ImageCacheItem> images;
struct Item;
friend class ScopedPointer<Item>;
friend class OwnedArray<Item>;
OwnedArray<Item> images;

static ImageCache* instance;
static int cacheTimeout;


ImageCache(); ImageCache();
ImageCache (const ImageCache&); ImageCache (const ImageCache&);


+ 5
- 5
src/core/juce_Atomic.h View File

@@ -59,11 +59,11 @@ public:
//============================================================================== //==============================================================================
#if (JUCE_MAC || JUCE_IPHONE) // Mac and iPhone... #if (JUCE_MAC || JUCE_IPHONE) // Mac and iPhone...
inline void Atomic::increment (int32& variable) { OSAtomicIncrement32 ((int32_t*) &variable); }
inline int32 Atomic::incrementAndReturn (int32& variable) { return OSAtomicIncrement32 ((int32_t*) &variable); }
inline void Atomic::decrement (int32& variable) { OSAtomicDecrement32 ((int32_t*) &variable); }
inline int32 Atomic::decrementAndReturn (int32& variable) { return OSAtomicDecrement32 ((int32_t*) &variable); }
inline int32 Atomic::compareAndExchange (int32& destination, int32 newValue, int32 oldValue)
inline void Atomic::increment (int32& variable) { OSAtomicIncrement32 ((int32_t*) &variable); }
inline int32 Atomic::incrementAndReturn (int32& variable) { return OSAtomicIncrement32 ((int32_t*) &variable); }
inline void Atomic::decrement (int32& variable) { OSAtomicDecrement32 ((int32_t*) &variable); }
inline int32 Atomic::decrementAndReturn (int32& variable) { return OSAtomicDecrement32 ((int32_t*) &variable); }
inline int32 Atomic::compareAndExchange (int32& destination, int32 newValue, int32 oldValue)
{ return OSAtomicCompareAndSwap32Barrier (oldValue, newValue, (int32_t*) &destination); } { return OSAtomicCompareAndSwap32Barrier (oldValue, newValue, (int32_t*) &destination); }
inline void* Atomic::swapPointers (void* volatile* value1, void* value2) inline void* Atomic::swapPointers (void* volatile* value1, void* value2)
{ {


+ 8
- 8
src/core/juce_ByteOrder.h View File

@@ -146,10 +146,10 @@ inline uint64 ByteOrder::swap (uint64 value)
inline uint16 ByteOrder::swapIfLittleEndian (const uint16 v) { return swap (v); } inline uint16 ByteOrder::swapIfLittleEndian (const uint16 v) { return swap (v); }
inline uint32 ByteOrder::swapIfLittleEndian (const uint32 v) { return swap (v); } inline uint32 ByteOrder::swapIfLittleEndian (const uint32 v) { return swap (v); }
inline uint64 ByteOrder::swapIfLittleEndian (const uint64 v) { return swap (v); } inline uint64 ByteOrder::swapIfLittleEndian (const uint64 v) { return swap (v); }
inline uint32 ByteOrder::littleEndianInt (const char* const bytes) { return *(uint32*) bytes; }
inline uint16 ByteOrder::littleEndianShort (const char* const bytes) { return *(uint16*) bytes; }
inline uint32 ByteOrder::bigEndianInt (const char* const bytes) { return swap (*(uint32*) bytes); }
inline uint16 ByteOrder::bigEndianShort (const char* const bytes) { return swap (*(uint16*) bytes); }
inline uint32 ByteOrder::littleEndianInt (const char* const bytes) { return *reinterpret_cast <const uint32*> (bytes); }
inline uint16 ByteOrder::littleEndianShort (const char* const bytes) { return *reinterpret_cast <const uint16*> (bytes); }
inline uint32 ByteOrder::bigEndianInt (const char* const bytes) { return swap (*reinterpret_cast <const uint32*> (bytes)); }
inline uint16 ByteOrder::bigEndianShort (const char* const bytes) { return swap (*reinterpret_cast <const uint16*> (bytes)); }
inline bool ByteOrder::isBigEndian() { return false; } inline bool ByteOrder::isBigEndian() { return false; }
#else #else
inline uint16 ByteOrder::swapIfBigEndian (const uint16 v) { return swap (v); } inline uint16 ByteOrder::swapIfBigEndian (const uint16 v) { return swap (v); }
@@ -158,10 +158,10 @@ inline uint64 ByteOrder::swap (uint64 value)
inline uint16 ByteOrder::swapIfLittleEndian (const uint16 v) { return v; } inline uint16 ByteOrder::swapIfLittleEndian (const uint16 v) { return v; }
inline uint32 ByteOrder::swapIfLittleEndian (const uint32 v) { return v; } inline uint32 ByteOrder::swapIfLittleEndian (const uint32 v) { return v; }
inline uint64 ByteOrder::swapIfLittleEndian (const uint64 v) { return v; } inline uint64 ByteOrder::swapIfLittleEndian (const uint64 v) { return v; }
inline uint32 ByteOrder::littleEndianInt (const char* const bytes) { return swap (*(uint32*) bytes); }
inline uint16 ByteOrder::littleEndianShort (const char* const bytes) { return swap (*(uint16*) bytes); }
inline uint32 ByteOrder::bigEndianInt (const char* const bytes) { return *(uint32*) bytes; }
inline uint16 ByteOrder::bigEndianShort (const char* const bytes) { return *(uint16*) bytes; }
inline uint32 ByteOrder::littleEndianInt (const char* const bytes) { return swap (*reinterpret_cast <const uint32*> (bytes)); }
inline uint16 ByteOrder::littleEndianShort (const char* const bytes) { return swap (*reinterpret_cast <const uint16*> (bytes)); }
inline uint32 ByteOrder::bigEndianInt (const char* const bytes) { return *reinterpret_cast <const uint32*> (bytes); }
inline uint16 ByteOrder::bigEndianShort (const char* const bytes) { return *reinterpret_cast <const uint16*> (bytes); }
inline bool ByteOrder::isBigEndian() { return true; } inline bool ByteOrder::isBigEndian() { return true; }
#endif #endif


+ 78
- 88
src/core/juce_Time.cpp View File

@@ -55,55 +55,69 @@ BEGIN_JUCE_NAMESPACE
#endif #endif
//============================================================================== //==============================================================================
static void millisToLocal (const int64 millis, struct tm& result) throw()
namespace TimeHelpers
{ {
const int64 seconds = millis / 1000;
if (seconds < literal64bit (86400) || seconds >= literal64bit (2145916800))
{
// use extended maths for dates beyond 1970 to 2037..
const int timeZoneAdjustment = 31536000 - (int) (Time (1971, 0, 1, 0, 0).toMilliseconds() / 1000);
const int64 jdm = seconds + timeZoneAdjustment + literal64bit (210866803200);
const int days = (int) (jdm / literal64bit (86400));
const int a = 32044 + days;
const int b = (4 * a + 3) / 146097;
const int c = a - (b * 146097) / 4;
const int d = (4 * c + 3) / 1461;
const int e = c - (d * 1461) / 4;
const int m = (5 * e + 2) / 153;
result.tm_mday = e - (153 * m + 2) / 5 + 1;
result.tm_mon = m + 2 - 12 * (m / 10);
result.tm_year = b * 100 + d - 6700 + (m / 10);
result.tm_wday = (days + 1) % 7;
result.tm_yday = -1;
int t = (int) (jdm % literal64bit (86400));
result.tm_hour = t / 3600;
t %= 3600;
result.tm_min = t / 60;
result.tm_sec = t % 60;
result.tm_isdst = -1;
}
else
static struct tm millisToLocal (const int64 millis) throw()
{ {
time_t now = (time_t) (seconds);
struct tm result;
const int64 seconds = millis / 1000;
#if JUCE_WINDOWS
#ifdef USE_NEW_SECURE_TIME_FNS
if (now >= 0 && now <= 0x793406fff)
localtime_s (&result, &now);
if (seconds < literal64bit (86400) || seconds >= literal64bit (2145916800))
{
// use extended maths for dates beyond 1970 to 2037..
const int timeZoneAdjustment = 31536000 - (int) (Time (1971, 0, 1, 0, 0).toMilliseconds() / 1000);
const int64 jdm = seconds + timeZoneAdjustment + literal64bit (210866803200);
const int days = (int) (jdm / literal64bit (86400));
const int a = 32044 + days;
const int b = (4 * a + 3) / 146097;
const int c = a - (b * 146097) / 4;
const int d = (4 * c + 3) / 1461;
const int e = c - (d * 1461) / 4;
const int m = (5 * e + 2) / 153;
result.tm_mday = e - (153 * m + 2) / 5 + 1;
result.tm_mon = m + 2 - 12 * (m / 10);
result.tm_year = b * 100 + d - 6700 + (m / 10);
result.tm_wday = (days + 1) % 7;
result.tm_yday = -1;
int t = (int) (jdm % literal64bit (86400));
result.tm_hour = t / 3600;
t %= 3600;
result.tm_min = t / 60;
result.tm_sec = t % 60;
result.tm_isdst = -1;
}
else else
zeromem (&result, sizeof (result));
#else
result = *localtime (&now);
#endif
#else
// more thread-safe
localtime_r (&now, &result);
#endif
{
time_t now = static_cast <time_t> (seconds);
#if JUCE_WINDOWS
#ifdef USE_NEW_SECURE_TIME_FNS
if (now >= 0 && now <= 0x793406fff)
localtime_s (&result, &now);
else
zeromem (&result, sizeof (result));
#else
result = *localtime (&now);
#endif
#else
// more thread-safe
localtime_r (&now, &result);
#endif
}
return result;
} }
static int extendedModulo (const int64 value, const int modulo) throw()
{
return (int) (value >= 0 ? (value % modulo)
: (value - ((value / modulo) + 1) * modulo));
}
static uint32 lastMSCounterValue = 0;
} }
//============================================================================== //==============================================================================
@@ -219,23 +233,22 @@ int64 Time::currentTimeMillis() throw()
//============================================================================== //==============================================================================
uint32 juce_millisecondsSinceStartup() throw(); uint32 juce_millisecondsSinceStartup() throw();
static uint32 lastMSCounterValue = 0;
uint32 Time::getMillisecondCounter() throw() uint32 Time::getMillisecondCounter() throw()
{ {
const uint32 now = juce_millisecondsSinceStartup(); const uint32 now = juce_millisecondsSinceStartup();
if (now < lastMSCounterValue)
if (now < TimeHelpers::lastMSCounterValue)
{ {
// in multi-threaded apps this might be called concurrently, so // in multi-threaded apps this might be called concurrently, so
// make sure that our last counter value only increases and doesn't // make sure that our last counter value only increases and doesn't
// go backwards.. // go backwards..
if (now < lastMSCounterValue - 1000)
lastMSCounterValue = now;
if (now < TimeHelpers::lastMSCounterValue - 1000)
TimeHelpers::lastMSCounterValue = now;
} }
else else
{ {
lastMSCounterValue = now;
TimeHelpers::lastMSCounterValue = now;
} }
return now; return now;
@@ -243,8 +256,8 @@ uint32 Time::getMillisecondCounter() throw()
uint32 Time::getApproximateMillisecondCounter() throw() uint32 Time::getApproximateMillisecondCounter() throw()
{ {
jassert (lastMSCounterValue != 0);
return lastMSCounterValue;
jassert (TimeHelpers::lastMSCounterValue != 0);
return TimeHelpers::lastMSCounterValue;
} }
void Time::waitForMillisecondCounter (const uint32 targetTime) throw() void Time::waitForMillisecondCounter (const uint32 targetTime) throw()
@@ -328,16 +341,15 @@ const String Time::toString (const bool includeDate,
return result.trimEnd(); return result.trimEnd();
} }
const String Time::formatted (const tchar* const format) const throw()
const String Time::formatted (const juce_wchar* const format) const throw()
{ {
String buffer; String buffer;
int bufferSize = 128; int bufferSize = 128;
buffer.preallocateStorage (bufferSize); buffer.preallocateStorage (bufferSize);
struct tm t;
millisToLocal (millisSinceEpoch, t);
struct tm t (TimeHelpers::millisToLocal (millisSinceEpoch));
while (CharacterFunctions::ftime ((tchar*) (const tchar*) buffer, bufferSize, format, &t) <= 0)
while (CharacterFunctions::ftime (static_cast <juce_wchar*> (buffer), bufferSize, format, &t) <= 0)
{ {
bufferSize += 128; bufferSize += 128;
buffer.preallocateStorage (bufferSize); buffer.preallocateStorage (bufferSize);
@@ -349,37 +361,27 @@ const String Time::formatted (const tchar* const format) const throw()
//============================================================================== //==============================================================================
int Time::getYear() const throw() int Time::getYear() const throw()
{ {
struct tm t;
millisToLocal (millisSinceEpoch, t);
return t.tm_year + 1900;
return TimeHelpers::millisToLocal (millisSinceEpoch).tm_year + 1900;
} }
int Time::getMonth() const throw() int Time::getMonth() const throw()
{ {
struct tm t;
millisToLocal (millisSinceEpoch, t);
return t.tm_mon;
return TimeHelpers::millisToLocal (millisSinceEpoch).tm_mon;
} }
int Time::getDayOfMonth() const throw() int Time::getDayOfMonth() const throw()
{ {
struct tm t;
millisToLocal (millisSinceEpoch, t);
return t.tm_mday;
return TimeHelpers::millisToLocal (millisSinceEpoch).tm_mday;
} }
int Time::getDayOfWeek() const throw() int Time::getDayOfWeek() const throw()
{ {
struct tm t;
millisToLocal (millisSinceEpoch, t);
return t.tm_wday;
return TimeHelpers::millisToLocal (millisSinceEpoch).tm_wday;
} }
int Time::getHours() const throw() int Time::getHours() const throw()
{ {
struct tm t;
millisToLocal (millisSinceEpoch, t);
return t.tm_hour;
return TimeHelpers::millisToLocal (millisSinceEpoch).tm_hour;
} }
int Time::getHoursInAmPmFormat() const throw() int Time::getHoursInAmPmFormat() const throw()
@@ -399,34 +401,24 @@ bool Time::isAfternoon() const throw()
return getHours() >= 12; return getHours() >= 12;
} }
static int extendedModulo (const int64 value, const int modulo) throw()
{
return (int) (value >= 0 ? (value % modulo)
: (value - ((value / modulo) + 1) * modulo));
}
int Time::getMinutes() const throw() int Time::getMinutes() const throw()
{ {
struct tm t;
millisToLocal (millisSinceEpoch, t);
return t.tm_min;
return TimeHelpers::millisToLocal (millisSinceEpoch).tm_min;
} }
int Time::getSeconds() const throw() int Time::getSeconds() const throw()
{ {
return extendedModulo (millisSinceEpoch / 1000, 60);
return TimeHelpers::extendedModulo (millisSinceEpoch / 1000, 60);
} }
int Time::getMilliseconds() const throw() int Time::getMilliseconds() const throw()
{ {
return extendedModulo (millisSinceEpoch, 1000);
return TimeHelpers::extendedModulo (millisSinceEpoch, 1000);
} }
bool Time::isDaylightSavingTime() const throw() bool Time::isDaylightSavingTime() const throw()
{ {
struct tm t;
millisToLocal (millisSinceEpoch, t);
return t.tm_isdst != 0;
return TimeHelpers::millisToLocal (millisSinceEpoch).tm_isdst != 0;
} }
const String Time::getTimeZone() const throw() const String Time::getTimeZone() const throw()
@@ -483,8 +475,7 @@ const String Time::getWeekdayName (const bool threeLetterVersion) const throw()
return getWeekdayName (getDayOfWeek(), threeLetterVersion); return getWeekdayName (getDayOfWeek(), threeLetterVersion);
} }
const String Time::getMonthName (int monthNumber,
const bool threeLetterVersion) throw()
const String Time::getMonthName (int monthNumber, const bool threeLetterVersion) throw()
{ {
const char* const shortMonthNames[] = { "Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec" }; const char* const shortMonthNames[] = { "Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec" };
const char* const longMonthNames[] = { "January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November", "December" }; const char* const longMonthNames[] = { "January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November", "December" };
@@ -495,8 +486,7 @@ const String Time::getMonthName (int monthNumber,
: longMonthNames [monthNumber]); : longMonthNames [monthNumber]);
} }
const String Time::getWeekdayName (int day,
const bool threeLetterVersion) throw()
const String Time::getWeekdayName (int day, const bool threeLetterVersion) throw()
{ {
const char* const shortDayNames[] = { "Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat" }; const char* const shortDayNames[] = { "Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat" };
const char* const longDayNames[] = { "Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday" }; const char* const longDayNames[] = { "Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday" };


+ 21
- 21
src/core/juce_Time.h View File

@@ -64,7 +64,7 @@ public:
'epoch' (midnight Jan 1st 1970). 'epoch' (midnight Jan 1st 1970).
@see getCurrentTime, currentTimeMillis @see getCurrentTime, currentTimeMillis
*/ */
Time (const int64 millisecondsSinceEpoch) throw();
Time (int64 millisecondsSinceEpoch) throw();
/** Creates a time from a set of date components. /** Creates a time from a set of date components.
@@ -80,14 +80,14 @@ public:
@param useLocalTime if true, encode using the current machine's local time; if @param useLocalTime if true, encode using the current machine's local time; if
false, it will always work in GMT. false, it will always work in GMT.
*/ */
Time (const int year,
const int month,
const int day,
const int hours,
const int minutes,
const int seconds = 0,
const int milliseconds = 0,
const bool useLocalTime = true) throw();
Time (int year,
int month,
int day,
int hours,
int minutes,
int seconds = 0,
int milliseconds = 0,
bool useLocalTime = true) throw();
/** Destructor. */ /** Destructor. */
~Time() throw(); ~Time() throw();
@@ -129,7 +129,7 @@ public:
it'll return the long form, e.g. "January" it'll return the long form, e.g. "January"
@see getMonth @see getMonth
*/ */
const String getMonthName (const bool threeLetterVersion) const throw();
const String getMonthName (bool threeLetterVersion) const throw();
/** Returns the day of the month. /** Returns the day of the month.
@@ -148,7 +148,7 @@ public:
@param threeLetterVersion if true, it'll return a 3-letter abbreviation, e.g. "Tue"; if @param threeLetterVersion if true, it'll return a 3-letter abbreviation, e.g. "Tue"; if
false, it'll return the full version, e.g. "Tuesday". false, it'll return the full version, e.g. "Tuesday".
*/ */
const String getWeekdayName (const bool threeLetterVersion) const throw();
const String getWeekdayName (bool threeLetterVersion) const throw();
/** Returns the number of hours since midnight. /** Returns the number of hours since midnight.
@@ -209,10 +209,10 @@ public:
hour notation. hour notation.
@see formatted @see formatted
*/ */
const String toString (const bool includeDate,
const bool includeTime,
const bool includeSeconds = true,
const bool use24HourClock = false) const throw();
const String toString (bool includeDate,
bool includeTime,
bool includeSeconds = true,
bool use24HourClock = false) const throw();
/** Converts this date/time to a string with a user-defined format. /** Converts this date/time to a string with a user-defined format.
@@ -245,7 +245,7 @@ public:
@see toString @see toString
*/ */
const String formatted (const tchar* const format) const throw();
const String formatted (const juce_wchar* format) const throw();
//============================================================================== //==============================================================================
/** Adds a RelativeTime to this time and returns the result. */ /** Adds a RelativeTime to this time and returns the result. */
@@ -291,7 +291,7 @@ public:
false, it'll return the full version, e.g. "Tuesday". false, it'll return the full version, e.g. "Tuesday".
*/ */
static const String getWeekdayName (int dayNumber, static const String getWeekdayName (int dayNumber,
const bool threeLetterVersion) throw();
bool threeLetterVersion) throw();
/** Returns the name of one of the months. /** Returns the name of one of the months.
@@ -300,7 +300,7 @@ public:
it'll return the long form, e.g. "January" it'll return the long form, e.g. "January"
*/ */
static const String getMonthName (int monthNumber, static const String getMonthName (int monthNumber,
const bool threeLetterVersion) throw();
bool threeLetterVersion) throw();
//============================================================================== //==============================================================================
// Static methods for getting system timers directly.. // Static methods for getting system timers directly..
@@ -336,7 +336,7 @@ public:
This will make the thread sleep as efficiently as it can while it's waiting. This will make the thread sleep as efficiently as it can while it's waiting.
*/ */
static void waitForMillisecondCounter (const uint32 targetTime) throw();
static void waitForMillisecondCounter (uint32 targetTime) throw();
/** Less-accurate but faster version of getMillisecondCounter(). /** Less-accurate but faster version of getMillisecondCounter().
@@ -374,14 +374,14 @@ public:
@see getHighResolutionTicks, getHighResolutionTicksPerSecond, @see getHighResolutionTicks, getHighResolutionTicksPerSecond,
secondsToHighResolutionTicks secondsToHighResolutionTicks
*/ */
static double highResolutionTicksToSeconds (const int64 ticks) throw();
static double highResolutionTicksToSeconds (int64 ticks) throw();
/** Converts a number seconds into high-resolution ticks. /** Converts a number seconds into high-resolution ticks.
@see getHighResolutionTicks, getHighResolutionTicksPerSecond, @see getHighResolutionTicks, getHighResolutionTicksPerSecond,
highResolutionTicksToSeconds highResolutionTicksToSeconds
*/ */
static int64 secondsToHighResolutionTicks (const double seconds) throw();
static int64 secondsToHighResolutionTicks (double seconds) throw();
private: private:


+ 160
- 326
src/cryptography/juce_BlowFish.cpp View File

@@ -27,301 +27,170 @@
BEGIN_JUCE_NAMESPACE BEGIN_JUCE_NAMESPACE
#include "juce_BlowFish.h" #include "juce_BlowFish.h"
//============================================================================== //==============================================================================
static const uint32 initialPValues [18] =
{
0x243f6a88, 0x85a308d3, 0x13198a2e, 0x03707344,
0xa4093822, 0x299f31d0, 0x082efa98, 0xec4e6c89,
0x452821e6, 0x38d01377, 0xbe5466cf, 0x34e90c6c,
0xc0ac29b7, 0xc97c50dd, 0x3f84d5b5, 0xb5470917,
0x9216d5d9, 0x8979fb1b
};
static const uint32 initialSValues [4 * 256] =
BlowFish::BlowFish (const void* const keyData, const int keyBytes)
{ {
0xd1310ba6, 0x98dfb5ac, 0x2ffd72db, 0xd01adfb7,
0xb8e1afed, 0x6a267e96, 0xba7c9045, 0xf12c7f99,
0x24a19947, 0xb3916cf7, 0x0801f2e2, 0x858efc16,
0x636920d8, 0x71574e69, 0xa458fea3, 0xf4933d7e,
0x0d95748f, 0x728eb658, 0x718bcd58, 0x82154aee,
0x7b54a41d, 0xc25a59b5, 0x9c30d539, 0x2af26013,
0xc5d1b023, 0x286085f0, 0xca417918, 0xb8db38ef,
0x8e79dcb0, 0x603a180e, 0x6c9e0e8b, 0xb01e8a3e,
0xd71577c1, 0xbd314b27, 0x78af2fda, 0x55605c60,
0xe65525f3, 0xaa55ab94, 0x57489862, 0x63e81440,
0x55ca396a, 0x2aab10b6, 0xb4cc5c34, 0x1141e8ce,
0xa15486af, 0x7c72e993, 0xb3ee1411, 0x636fbc2a,
0x2ba9c55d, 0x741831f6, 0xce5c3e16, 0x9b87931e,
0xafd6ba33, 0x6c24cf5c, 0x7a325381, 0x28958677,
0x3b8f4898, 0x6b4bb9af, 0xc4bfe81b, 0x66282193,
0x61d809cc, 0xfb21a991, 0x487cac60, 0x5dec8032,
0xef845d5d, 0xe98575b1, 0xdc262302, 0xeb651b88,
0x23893e81, 0xd396acc5, 0x0f6d6ff3, 0x83f44239,
0x2e0b4482, 0xa4842004, 0x69c8f04a, 0x9e1f9b5e,
0x21c66842, 0xf6e96c9a, 0x670c9c61, 0xabd388f0,
0x6a51a0d2, 0xd8542f68, 0x960fa728, 0xab5133a3,
0x6eef0b6c, 0x137a3be4, 0xba3bf050, 0x7efb2a98,
0xa1f1651d, 0x39af0176, 0x66ca593e, 0x82430e88,
0x8cee8619, 0x456f9fb4, 0x7d84a5c3, 0x3b8b5ebe,
0xe06f75d8, 0x85c12073, 0x401a449f, 0x56c16aa6,
0x4ed3aa62, 0x363f7706, 0x1bfedf72, 0x429b023d,
0x37d0d724, 0xd00a1248, 0xdb0fead3, 0x49f1c09b,
0x075372c9, 0x80991b7b, 0x25d479d8, 0xf6e8def7,
0xe3fe501a, 0xb6794c3b, 0x976ce0bd, 0x04c006ba,
0xc1a94fb6, 0x409f60c4, 0x5e5c9ec2, 0x196a2463,
0x68fb6faf, 0x3e6c53b5, 0x1339b2eb, 0x3b52ec6f,
0x6dfc511f, 0x9b30952c, 0xcc814544, 0xaf5ebd09,
0xbee3d004, 0xde334afd, 0x660f2807, 0x192e4bb3,
0xc0cba857, 0x45c8740f, 0xd20b5f39, 0xb9d3fbdb,
0x5579c0bd, 0x1a60320a, 0xd6a100c6, 0x402c7279,
0x679f25fe, 0xfb1fa3cc, 0x8ea5e9f8, 0xdb3222f8,
0x3c7516df, 0xfd616b15, 0x2f501ec8, 0xad0552ab,
0x323db5fa, 0xfd238760, 0x53317b48, 0x3e00df82,
0x9e5c57bb, 0xca6f8ca0, 0x1a87562e, 0xdf1769db,
0xd542a8f6, 0x287effc3, 0xac6732c6, 0x8c4f5573,
0x695b27b0, 0xbbca58c8, 0xe1ffa35d, 0xb8f011a0,
0x10fa3d98, 0xfd2183b8, 0x4afcb56c, 0x2dd1d35b,
0x9a53e479, 0xb6f84565, 0xd28e49bc, 0x4bfb9790,
0xe1ddf2da, 0xa4cb7e33, 0x62fb1341, 0xcee4c6e8,
0xef20cada, 0x36774c01, 0xd07e9efe, 0x2bf11fb4,
0x95dbda4d, 0xae909198, 0xeaad8e71, 0x6b93d5a0,
0xd08ed1d0, 0xafc725e0, 0x8e3c5b2f, 0x8e7594b7,
0x8ff6e2fb, 0xf2122b64, 0x8888b812, 0x900df01c,
0x4fad5ea0, 0x688fc31c, 0xd1cff191, 0xb3a8c1ad,
0x2f2f2218, 0xbe0e1777, 0xea752dfe, 0x8b021fa1,
0xe5a0cc0f, 0xb56f74e8, 0x18acf3d6, 0xce89e299,
0xb4a84fe0, 0xfd13e0b7, 0x7cc43b81, 0xd2ada8d9,
0x165fa266, 0x80957705, 0x93cc7314, 0x211a1477,
0xe6ad2065, 0x77b5fa86, 0xc75442f5, 0xfb9d35cf,
0xebcdaf0c, 0x7b3e89a0, 0xd6411bd3, 0xae1e7e49,
0x00250e2d, 0x2071b35e, 0x226800bb, 0x57b8e0af,
0x2464369b, 0xf009b91e, 0x5563911d, 0x59dfa6aa,
0x78c14389, 0xd95a537f, 0x207d5ba2, 0x02e5b9c5,
0x83260376, 0x6295cfa9, 0x11c81968, 0x4e734a41,
0xb3472dca, 0x7b14a94a, 0x1b510052, 0x9a532915,
0xd60f573f, 0xbc9bc6e4, 0x2b60a476, 0x81e67400,
0x08ba6fb5, 0x571be91f, 0xf296ec6b, 0x2a0dd915,
0xb6636521, 0xe7b9f9b6, 0xff34052e, 0xc5855664,
0x53b02d5d, 0xa99f8fa1, 0x08ba4799, 0x6e85076a,
0x4b7a70e9, 0xb5b32944, 0xdb75092e, 0xc4192623,
0xad6ea6b0, 0x49a7df7d, 0x9cee60b8, 0x8fedb266,
0xecaa8c71, 0x699a17ff, 0x5664526c, 0xc2b19ee1,
0x193602a5, 0x75094c29, 0xa0591340, 0xe4183a3e,
0x3f54989a, 0x5b429d65, 0x6b8fe4d6, 0x99f73fd6,
0xa1d29c07, 0xefe830f5, 0x4d2d38e6, 0xf0255dc1,
0x4cdd2086, 0x8470eb26, 0x6382e9c6, 0x021ecc5e,
0x09686b3f, 0x3ebaefc9, 0x3c971814, 0x6b6a70a1,
0x687f3584, 0x52a0e286, 0xb79c5305, 0xaa500737,
0x3e07841c, 0x7fdeae5c, 0x8e7d44ec, 0x5716f2b8,
0xb03ada37, 0xf0500c0d, 0xf01c1f04, 0x0200b3ff,
0xae0cf51a, 0x3cb574b2, 0x25837a58, 0xdc0921bd,
0xd19113f9, 0x7ca92ff6, 0x94324773, 0x22f54701,
0x3ae5e581, 0x37c2dadc, 0xc8b57634, 0x9af3dda7,
0xa9446146, 0x0fd0030e, 0xecc8c73e, 0xa4751e41,
0xe238cd99, 0x3bea0e2f, 0x3280bba1, 0x183eb331,
0x4e548b38, 0x4f6db908, 0x6f420d03, 0xf60a04bf,
0x2cb81290, 0x24977c79, 0x5679b072, 0xbcaf89af,
0xde9a771f, 0xd9930810, 0xb38bae12, 0xdccf3f2e,
0x5512721f, 0x2e6b7124, 0x501adde6, 0x9f84cd87,
0x7a584718, 0x7408da17, 0xbc9f9abc, 0xe94b7d8c,
0xec7aec3a, 0xdb851dfa, 0x63094366, 0xc464c3d2,
0xef1c1847, 0x3215d908, 0xdd433b37, 0x24c2ba16,
0x12a14d43, 0x2a65c451, 0x50940002, 0x133ae4dd,
0x71dff89e, 0x10314e55, 0x81ac77d6, 0x5f11199b,
0x043556f1, 0xd7a3c76b, 0x3c11183b, 0x5924a509,
0xf28fe6ed, 0x97f1fbfa, 0x9ebabf2c, 0x1e153c6e,
0x86e34570, 0xeae96fb1, 0x860e5e0a, 0x5a3e2ab3,
0x771fe71c, 0x4e3d06fa, 0x2965dcb9, 0x99e71d0f,
0x803e89d6, 0x5266c825, 0x2e4cc978, 0x9c10b36a,
0xc6150eba, 0x94e2ea78, 0xa5fc3c53, 0x1e0a2df4,
0xf2f74ea7, 0x361d2b3d, 0x1939260f, 0x19c27960,
0x5223a708, 0xf71312b6, 0xebadfe6e, 0xeac31f66,
0xe3bc4595, 0xa67bc883, 0xb17f37d1, 0x018cff28,
0xc332ddef, 0xbe6c5aa5, 0x65582185, 0x68ab9802,
0xeecea50f, 0xdb2f953b, 0x2aef7dad, 0x5b6e2f84,
0x1521b628, 0x29076170, 0xecdd4775, 0x619f1510,
0x13cca830, 0xeb61bd96, 0x0334fe1e, 0xaa0363cf,
0xb5735c90, 0x4c70a239, 0xd59e9e0b, 0xcbaade14,
0xeecc86bc, 0x60622ca7, 0x9cab5cab, 0xb2f3846e,
0x648b1eaf, 0x19bdf0ca, 0xa02369b9, 0x655abb50,
0x40685a32, 0x3c2ab4b3, 0x319ee9d5, 0xc021b8f7,
0x9b540b19, 0x875fa099, 0x95f7997e, 0x623d7da8,
0xf837889a, 0x97e32d77, 0x11ed935f, 0x16681281,
0x0e358829, 0xc7e61fd6, 0x96dedfa1, 0x7858ba99,
0x57f584a5, 0x1b227263, 0x9b83c3ff, 0x1ac24696,
0xcdb30aeb, 0x532e3054, 0x8fd948e4, 0x6dbc3128,
0x58ebf2ef, 0x34c6ffea, 0xfe28ed61, 0xee7c3c73,
0x5d4a14d9, 0xe864b7e3, 0x42105d14, 0x203e13e0,
0x45eee2b6, 0xa3aaabea, 0xdb6c4f15, 0xfacb4fd0,
0xc742f442, 0xef6abbb5, 0x654f3b1d, 0x41cd2105,
0xd81e799e, 0x86854dc7, 0xe44b476a, 0x3d816250,
0xcf62a1f2, 0x5b8d2646, 0xfc8883a0, 0xc1c7b6a3,
0x7f1524c3, 0x69cb7492, 0x47848a0b, 0x5692b285,
0x095bbf00, 0xad19489d, 0x1462b174, 0x23820e00,
0x58428d2a, 0x0c55f5ea, 0x1dadf43e, 0x233f7061,
0x3372f092, 0x8d937e41, 0xd65fecf1, 0x6c223bdb,
0x7cde3759, 0xcbee7460, 0x4085f2a7, 0xce77326e,
0xa6078084, 0x19f8509e, 0xe8efd855, 0x61d99735,
0xa969a7aa, 0xc50c06c2, 0x5a04abfc, 0x800bcadc,
0x9e447a2e, 0xc3453484, 0xfdd56705, 0x0e1e9ec9,
0xdb73dbd3, 0x105588cd, 0x675fda79, 0xe3674340,
0xc5c43465, 0x713e38d8, 0x3d28f89e, 0xf16dff20,
0x153e21e7, 0x8fb03d4a, 0xe6e39f2b, 0xdb83adf7,
0xe93d5a68, 0x948140f7, 0xf64c261c, 0x94692934,
0x411520f7, 0x7602d4f7, 0xbcf46b2e, 0xd4a20068,
0xd4082471, 0x3320f46a, 0x43b7d4b7, 0x500061af,
0x1e39f62e, 0x97244546, 0x14214f74, 0xbf8b8840,
0x4d95fc1d, 0x96b591af, 0x70f4ddd3, 0x66a02f45,
0xbfbc09ec, 0x03bd9785, 0x7fac6dd0, 0x31cb8504,
0x96eb27b3, 0x55fd3941, 0xda2547e6, 0xabca0a9a,
0x28507825, 0x530429f4, 0x0a2c86da, 0xe9b66dfb,
0x68dc1462, 0xd7486900, 0x680ec0a4, 0x27a18dee,
0x4f3ffea2, 0xe887ad8c, 0xb58ce006, 0x7af4d6b6,
0xaace1e7c, 0xd3375fec, 0xce78a399, 0x406b2a42,
0x20fe9e35, 0xd9f385b9, 0xee39d7ab, 0x3b124e8b,
0x1dc9faf7, 0x4b6d1856, 0x26a36631, 0xeae397b2,
0x3a6efa74, 0xdd5b4332, 0x6841e7f7, 0xca7820fb,
0xfb0af54e, 0xd8feb397, 0x454056ac, 0xba489527,
0x55533a3a, 0x20838d87, 0xfe6ba9b7, 0xd096954b,
0x55a867bc, 0xa1159a58, 0xcca92963, 0x99e1db33,
0xa62a4a56, 0x3f3125f9, 0x5ef47e1c, 0x9029317c,
0xfdf8e802, 0x04272f70, 0x80bb155c, 0x05282ce3,
0x95c11548, 0xe4c66d22, 0x48c1133f, 0xc70f86dc,
0x07f9c9ee, 0x41041f0f, 0x404779a4, 0x5d886e17,
0x325f51eb, 0xd59bc0d1, 0xf2bcc18f, 0x41113564,
0x257b7834, 0x602a9c60, 0xdff8e8a3, 0x1f636c1b,
0x0e12b4c2, 0x02e1329e, 0xaf664fd1, 0xcad18115,
0x6b2395e0, 0x333e92e1, 0x3b240b62, 0xeebeb922,
0x85b2a20e, 0xe6ba0d99, 0xde720c8c, 0x2da2f728,
0xd0127845, 0x95b794fd, 0x647d0862, 0xe7ccf5f0,
0x5449a36f, 0x877d48fa, 0xc39dfd27, 0xf33e8d1e,
0x0a476341, 0x992eff74, 0x3a6f6eab, 0xf4f8fd37,
0xa812dc60, 0xa1ebddf8, 0x991be14c, 0xdb6e6b0d,
0xc67b5510, 0x6d672c37, 0x2765d43b, 0xdcd0e804,
0xf1290dc7, 0xcc00ffa3, 0xb5390f92, 0x690fed0b,
0x667b9ffb, 0xcedb7d9c, 0xa091cf0b, 0xd9155ea3,
0xbb132f88, 0x515bad24, 0x7b9479bf, 0x763bd6eb,
0x37392eb3, 0xcc115979, 0x8026e297, 0xf42e312d,
0x6842ada7, 0xc66a2b3b, 0x12754ccc, 0x782ef11c,
0x6a124237, 0xb79251e7, 0x06a1bbe6, 0x4bfb6350,
0x1a6b1018, 0x11caedfa, 0x3d25bdd8, 0xe2e1c3c9,
0x44421659, 0x0a121386, 0xd90cec6e, 0xd5abea2a,
0x64af674e, 0xda86a85f, 0xbebfe988, 0x64e4c3fe,
0x9dbc8057, 0xf0f7c086, 0x60787bf8, 0x6003604d,
0xd1fd8346, 0xf6381fb0, 0x7745ae04, 0xd736fccc,
0x83426b33, 0xf01eab71, 0xb0804187, 0x3c005e5f,
0x77a057be, 0xbde8ae24, 0x55464299, 0xbf582e61,
0x4e58f48f, 0xf2ddfda2, 0xf474ef38, 0x8789bdc2,
0x5366f9c3, 0xc8b38e74, 0xb475f255, 0x46fcd9b9,
0x7aeb2661, 0x8b1ddf84, 0x846a0e79, 0x915f95e2,
0x466e598e, 0x20b45770, 0x8cd55591, 0xc902de4c,
0xb90bace1, 0xbb8205d0, 0x11a86248, 0x7574a99e,
0xb77f19b6, 0xe0a9dc09, 0x662d09a1, 0xc4324633,
0xe85a1f02, 0x09f0be8c, 0x4a99a025, 0x1d6efe10,
0x1ab93d1d, 0x0ba5a4df, 0xa186f20f, 0x2868f169,
0xdcb7da83, 0x573906fe, 0xa1e2ce9b, 0x4fcd7f52,
0x50115e01, 0xa70683fa, 0xa002b5c4, 0x0de6d027,
0x9af88c27, 0x773f8641, 0xc3604c06, 0x61a806b5,
0xf0177a28, 0xc0f586e0, 0x006058aa, 0x30dc7d62,
0x11e69ed7, 0x2338ea63, 0x53c2dd94, 0xc2c21634,
0xbbcbee56, 0x90bcb6de, 0xebfc7da1, 0xce591d76,
0x6f05e409, 0x4b7c0188, 0x39720a3d, 0x7c927c24,
0x86e3725f, 0x724d9db9, 0x1ac15bb4, 0xd39eb8fc,
0xed545578, 0x08fca5b5, 0xd83d7cd3, 0x4dad0fc4,
0x1e50ef5e, 0xb161e6f8, 0xa28514d9, 0x6c51133c,
0x6fd5c7e7, 0x56e14ec4, 0x362abfce, 0xddc6c837,
0xd79a3234, 0x92638212, 0x670efa8e, 0x406000e0,
0x3a39ce37, 0xd3faf5cf, 0xabc27737, 0x5ac52d1b,
0x5cb0679e, 0x4fa33742, 0xd3822740, 0x99bc9bbe,
0xd5118e9d, 0xbf0f7315, 0xd62d1c7e, 0xc700c47b,
0xb78c1b6b, 0x21a19045, 0xb26eb1be, 0x6a366eb4,
0x5748ab2f, 0xbc946e79, 0xc6a376d2, 0x6549c2c8,
0x530ff8ee, 0x468dde7d, 0xd5730a1d, 0x4cd04dc6,
0x2939bbdb, 0xa9ba4650, 0xac9526e8, 0xbe5ee304,
0xa1fad5f0, 0x6a2d519a, 0x63ef8ce2, 0x9a86ee22,
0xc089c2b8, 0x43242ef6, 0xa51e03aa, 0x9cf2d0a4,
0x83c061ba, 0x9be96a4d, 0x8fe51550, 0xba645bd6,
0x2826a2f9, 0xa73a3ae1, 0x4ba99586, 0xef5562e9,
0xc72fefd3, 0xf752f7da, 0x3f046f69, 0x77fa0a59,
0x80e4a915, 0x87b08601, 0x9b09e6ad, 0x3b3ee593,
0xe990fd5a, 0x9e34d797, 0x2cf0b7d9, 0x022b8b51,
0x96d5ac3a, 0x017da67d, 0xd1cf3ed6, 0x7c7d2d28,
0x1f9f25cf, 0xadf2b89b, 0x5ad6b472, 0x5a88f54c,
0xe029ac71, 0xe019a5e6, 0x47b0acfd, 0xed93fa9b,
0xe8d3c48d, 0x283b57cc, 0xf8d56629, 0x79132e28,
0x785f0191, 0xed756055, 0xf7960e44, 0xe3d35e8c,
0x15056dd4, 0x88f46dba, 0x03a16125, 0x0564f0bd,
0xc3eb9e15, 0x3c9057a2, 0x97271aec, 0xa93a072a,
0x1b3f6d9b, 0x1e6321f5, 0xf59c66fb, 0x26dcf319,
0x7533d928, 0xb155fdf5, 0x03563482, 0x8aba3cbb,
0x28517711, 0xc20ad9f8, 0xabcc5167, 0xccad925f,
0x4de81751, 0x3830dc8e, 0x379d5862, 0x9320f991,
0xea7a90c2, 0xfb3e7bce, 0x5121ce64, 0x774fbe32,
0xa8b6e37e, 0xc3293d46, 0x48de5369, 0x6413e680,
0xa2ae0810, 0xdd6db224, 0x69852dfd, 0x09072166,
0xb39a460a, 0x6445c0dd, 0x586cdecf, 0x1c20c8ae,
0x5bbef7dd, 0x1b588d40, 0xccd2017f, 0x6bb4e3bb,
0xdda26a7e, 0x3a59ff45, 0x3e350a44, 0xbcb4cdd5,
0x72eacea8, 0xfa6484bb, 0x8d6612ae, 0xbf3c6f47,
0xd29be463, 0x542f5d9e, 0xaec2771b, 0xf64e6370,
0x740e0d8d, 0xe75b1357, 0xf8721671, 0xaf537d5d,
0x4040cb08, 0x4eb4e2cc, 0x34d2466a, 0x0115af84,
0xe1b00428, 0x95983a1d, 0x06b89fb4, 0xce6ea048,
0x6f3f3b82, 0x3520ab82, 0x011a1d4b, 0x277227f8,
0x611560b1, 0xe7933fdc, 0xbb3a792b, 0x344525bd,
0xa08839e1, 0x51ce794b, 0x2f32c9b7, 0xa01fbac9,
0xe01cc87e, 0xbcc7d1f6, 0xcf0111c3, 0xa1e8aac7,
0x1a908749, 0xd44fbd9a, 0xd0dadecb, 0xd50ada38,
0x0339c32a, 0xc6913667, 0x8df9317c, 0xe0b12b4f,
0xf79e59b7, 0x43f5bb3a, 0xf2d519ff, 0x27d9459c,
0xbf97222c, 0x15e6fc2a, 0x0f91fc71, 0x9b941525,
0xfae59361, 0xceb69ceb, 0xc2a86459, 0x12baa8d1,
0xb6c1075e, 0xe3056a0c, 0x10d25065, 0xcb03a442,
0xe0ec6e0e, 0x1698db3b, 0x4c98a0be, 0x3278e964,
0x9f1f9532, 0xe0d392df, 0xd3a0342b, 0x8971f21e,
0x1b0a7441, 0x4ba3348c, 0xc5be7120, 0xc37632d8,
0xdf359f8d, 0x9b992f2e, 0xe60b6f47, 0x0fe3f11d,
0xe54cda54, 0x1edad891, 0xce6279cf, 0xcd3e7e6f,
0x1618b166, 0xfd2c1d05, 0x848fd2c5, 0xf6fb2299,
0xf523f357, 0xa6327623, 0x93a83531, 0x56cccd02,
0xacf08162, 0x5a75ebb5, 0x6e163697, 0x88d273cc,
0xde966292, 0x81b949d0, 0x4c50901b, 0x71c65614,
0xe6c6c7bd, 0x327a140a, 0x45e1d006, 0xc3f27b9a,
0xc9aa53fd, 0x62a80f00, 0xbb25bfe2, 0x35bdd2f6,
0x71126905, 0xb2040222, 0xb6cbcf7c, 0xcd769c2b,
0x53113ec0, 0x1640e3d3, 0x38abbd60, 0x2547adf0,
0xba38209c, 0xf746ce76, 0x77afa1c5, 0x20756060,
0x85cbfe4e, 0x8ae88dd8, 0x7aaaf9b0, 0x4cf9aa7e,
0x1948c25c, 0x02fb8a8c, 0x01c36ae4, 0xd6ebe1f9,
0x90d4f869, 0xa65cdea0, 0x3f09252d, 0xc208e69f,
0xb74e6132, 0xce77e25b, 0x578fdfe3, 0x3ac372e6
};
jassert (keyData != 0);
jassert (keyBytes > 0);
static const uint32 initialPValues [18] =
{
0x243f6a88, 0x85a308d3, 0x13198a2e, 0x03707344, 0xa4093822, 0x299f31d0, 0x082efa98, 0xec4e6c89,
0x452821e6, 0x38d01377, 0xbe5466cf, 0x34e90c6c, 0xc0ac29b7, 0xc97c50dd, 0x3f84d5b5, 0xb5470917,
0x9216d5d9, 0x8979fb1b
};
static const uint32 initialSValues [4 * 256] =
{
0xd1310ba6, 0x98dfb5ac, 0x2ffd72db, 0xd01adfb7, 0xb8e1afed, 0x6a267e96, 0xba7c9045, 0xf12c7f99,
0x24a19947, 0xb3916cf7, 0x0801f2e2, 0x858efc16, 0x636920d8, 0x71574e69, 0xa458fea3, 0xf4933d7e,
0x0d95748f, 0x728eb658, 0x718bcd58, 0x82154aee, 0x7b54a41d, 0xc25a59b5, 0x9c30d539, 0x2af26013,
0xc5d1b023, 0x286085f0, 0xca417918, 0xb8db38ef, 0x8e79dcb0, 0x603a180e, 0x6c9e0e8b, 0xb01e8a3e,
0xd71577c1, 0xbd314b27, 0x78af2fda, 0x55605c60, 0xe65525f3, 0xaa55ab94, 0x57489862, 0x63e81440,
0x55ca396a, 0x2aab10b6, 0xb4cc5c34, 0x1141e8ce, 0xa15486af, 0x7c72e993, 0xb3ee1411, 0x636fbc2a,
0x2ba9c55d, 0x741831f6, 0xce5c3e16, 0x9b87931e, 0xafd6ba33, 0x6c24cf5c, 0x7a325381, 0x28958677,
0x3b8f4898, 0x6b4bb9af, 0xc4bfe81b, 0x66282193, 0x61d809cc, 0xfb21a991, 0x487cac60, 0x5dec8032,
0xef845d5d, 0xe98575b1, 0xdc262302, 0xeb651b88, 0x23893e81, 0xd396acc5, 0x0f6d6ff3, 0x83f44239,
0x2e0b4482, 0xa4842004, 0x69c8f04a, 0x9e1f9b5e, 0x21c66842, 0xf6e96c9a, 0x670c9c61, 0xabd388f0,
0x6a51a0d2, 0xd8542f68, 0x960fa728, 0xab5133a3, 0x6eef0b6c, 0x137a3be4, 0xba3bf050, 0x7efb2a98,
0xa1f1651d, 0x39af0176, 0x66ca593e, 0x82430e88, 0x8cee8619, 0x456f9fb4, 0x7d84a5c3, 0x3b8b5ebe,
0xe06f75d8, 0x85c12073, 0x401a449f, 0x56c16aa6, 0x4ed3aa62, 0x363f7706, 0x1bfedf72, 0x429b023d,
0x37d0d724, 0xd00a1248, 0xdb0fead3, 0x49f1c09b, 0x075372c9, 0x80991b7b, 0x25d479d8, 0xf6e8def7,
0xe3fe501a, 0xb6794c3b, 0x976ce0bd, 0x04c006ba, 0xc1a94fb6, 0x409f60c4, 0x5e5c9ec2, 0x196a2463,
0x68fb6faf, 0x3e6c53b5, 0x1339b2eb, 0x3b52ec6f, 0x6dfc511f, 0x9b30952c, 0xcc814544, 0xaf5ebd09,
0xbee3d004, 0xde334afd, 0x660f2807, 0x192e4bb3, 0xc0cba857, 0x45c8740f, 0xd20b5f39, 0xb9d3fbdb,
0x5579c0bd, 0x1a60320a, 0xd6a100c6, 0x402c7279, 0x679f25fe, 0xfb1fa3cc, 0x8ea5e9f8, 0xdb3222f8,
0x3c7516df, 0xfd616b15, 0x2f501ec8, 0xad0552ab, 0x323db5fa, 0xfd238760, 0x53317b48, 0x3e00df82,
0x9e5c57bb, 0xca6f8ca0, 0x1a87562e, 0xdf1769db, 0xd542a8f6, 0x287effc3, 0xac6732c6, 0x8c4f5573,
0x695b27b0, 0xbbca58c8, 0xe1ffa35d, 0xb8f011a0, 0x10fa3d98, 0xfd2183b8, 0x4afcb56c, 0x2dd1d35b,
0x9a53e479, 0xb6f84565, 0xd28e49bc, 0x4bfb9790, 0xe1ddf2da, 0xa4cb7e33, 0x62fb1341, 0xcee4c6e8,
0xef20cada, 0x36774c01, 0xd07e9efe, 0x2bf11fb4, 0x95dbda4d, 0xae909198, 0xeaad8e71, 0x6b93d5a0,
0xd08ed1d0, 0xafc725e0, 0x8e3c5b2f, 0x8e7594b7, 0x8ff6e2fb, 0xf2122b64, 0x8888b812, 0x900df01c,
0x4fad5ea0, 0x688fc31c, 0xd1cff191, 0xb3a8c1ad, 0x2f2f2218, 0xbe0e1777, 0xea752dfe, 0x8b021fa1,
0xe5a0cc0f, 0xb56f74e8, 0x18acf3d6, 0xce89e299, 0xb4a84fe0, 0xfd13e0b7, 0x7cc43b81, 0xd2ada8d9,
0x165fa266, 0x80957705, 0x93cc7314, 0x211a1477, 0xe6ad2065, 0x77b5fa86, 0xc75442f5, 0xfb9d35cf,
0xebcdaf0c, 0x7b3e89a0, 0xd6411bd3, 0xae1e7e49, 0x00250e2d, 0x2071b35e, 0x226800bb, 0x57b8e0af,
0x2464369b, 0xf009b91e, 0x5563911d, 0x59dfa6aa, 0x78c14389, 0xd95a537f, 0x207d5ba2, 0x02e5b9c5,
0x83260376, 0x6295cfa9, 0x11c81968, 0x4e734a41, 0xb3472dca, 0x7b14a94a, 0x1b510052, 0x9a532915,
0xd60f573f, 0xbc9bc6e4, 0x2b60a476, 0x81e67400, 0x08ba6fb5, 0x571be91f, 0xf296ec6b, 0x2a0dd915,
0xb6636521, 0xe7b9f9b6, 0xff34052e, 0xc5855664, 0x53b02d5d, 0xa99f8fa1, 0x08ba4799, 0x6e85076a,
0x4b7a70e9, 0xb5b32944, 0xdb75092e, 0xc4192623, 0xad6ea6b0, 0x49a7df7d, 0x9cee60b8, 0x8fedb266,
0xecaa8c71, 0x699a17ff, 0x5664526c, 0xc2b19ee1, 0x193602a5, 0x75094c29, 0xa0591340, 0xe4183a3e,
0x3f54989a, 0x5b429d65, 0x6b8fe4d6, 0x99f73fd6, 0xa1d29c07, 0xefe830f5, 0x4d2d38e6, 0xf0255dc1,
0x4cdd2086, 0x8470eb26, 0x6382e9c6, 0x021ecc5e, 0x09686b3f, 0x3ebaefc9, 0x3c971814, 0x6b6a70a1,
0x687f3584, 0x52a0e286, 0xb79c5305, 0xaa500737, 0x3e07841c, 0x7fdeae5c, 0x8e7d44ec, 0x5716f2b8,
0xb03ada37, 0xf0500c0d, 0xf01c1f04, 0x0200b3ff, 0xae0cf51a, 0x3cb574b2, 0x25837a58, 0xdc0921bd,
0xd19113f9, 0x7ca92ff6, 0x94324773, 0x22f54701, 0x3ae5e581, 0x37c2dadc, 0xc8b57634, 0x9af3dda7,
0xa9446146, 0x0fd0030e, 0xecc8c73e, 0xa4751e41, 0xe238cd99, 0x3bea0e2f, 0x3280bba1, 0x183eb331,
0x4e548b38, 0x4f6db908, 0x6f420d03, 0xf60a04bf, 0x2cb81290, 0x24977c79, 0x5679b072, 0xbcaf89af,
0xde9a771f, 0xd9930810, 0xb38bae12, 0xdccf3f2e, 0x5512721f, 0x2e6b7124, 0x501adde6, 0x9f84cd87,
0x7a584718, 0x7408da17, 0xbc9f9abc, 0xe94b7d8c, 0xec7aec3a, 0xdb851dfa, 0x63094366, 0xc464c3d2,
0xef1c1847, 0x3215d908, 0xdd433b37, 0x24c2ba16, 0x12a14d43, 0x2a65c451, 0x50940002, 0x133ae4dd,
0x71dff89e, 0x10314e55, 0x81ac77d6, 0x5f11199b, 0x043556f1, 0xd7a3c76b, 0x3c11183b, 0x5924a509,
0xf28fe6ed, 0x97f1fbfa, 0x9ebabf2c, 0x1e153c6e, 0x86e34570, 0xeae96fb1, 0x860e5e0a, 0x5a3e2ab3,
0x771fe71c, 0x4e3d06fa, 0x2965dcb9, 0x99e71d0f, 0x803e89d6, 0x5266c825, 0x2e4cc978, 0x9c10b36a,
0xc6150eba, 0x94e2ea78, 0xa5fc3c53, 0x1e0a2df4, 0xf2f74ea7, 0x361d2b3d, 0x1939260f, 0x19c27960,
0x5223a708, 0xf71312b6, 0xebadfe6e, 0xeac31f66, 0xe3bc4595, 0xa67bc883, 0xb17f37d1, 0x018cff28,
0xc332ddef, 0xbe6c5aa5, 0x65582185, 0x68ab9802, 0xeecea50f, 0xdb2f953b, 0x2aef7dad, 0x5b6e2f84,
0x1521b628, 0x29076170, 0xecdd4775, 0x619f1510, 0x13cca830, 0xeb61bd96, 0x0334fe1e, 0xaa0363cf,
0xb5735c90, 0x4c70a239, 0xd59e9e0b, 0xcbaade14, 0xeecc86bc, 0x60622ca7, 0x9cab5cab, 0xb2f3846e,
0x648b1eaf, 0x19bdf0ca, 0xa02369b9, 0x655abb50, 0x40685a32, 0x3c2ab4b3, 0x319ee9d5, 0xc021b8f7,
0x9b540b19, 0x875fa099, 0x95f7997e, 0x623d7da8, 0xf837889a, 0x97e32d77, 0x11ed935f, 0x16681281,
0x0e358829, 0xc7e61fd6, 0x96dedfa1, 0x7858ba99, 0x57f584a5, 0x1b227263, 0x9b83c3ff, 0x1ac24696,
0xcdb30aeb, 0x532e3054, 0x8fd948e4, 0x6dbc3128, 0x58ebf2ef, 0x34c6ffea, 0xfe28ed61, 0xee7c3c73,
0x5d4a14d9, 0xe864b7e3, 0x42105d14, 0x203e13e0, 0x45eee2b6, 0xa3aaabea, 0xdb6c4f15, 0xfacb4fd0,
0xc742f442, 0xef6abbb5, 0x654f3b1d, 0x41cd2105, 0xd81e799e, 0x86854dc7, 0xe44b476a, 0x3d816250,
0xcf62a1f2, 0x5b8d2646, 0xfc8883a0, 0xc1c7b6a3, 0x7f1524c3, 0x69cb7492, 0x47848a0b, 0x5692b285,
0x095bbf00, 0xad19489d, 0x1462b174, 0x23820e00, 0x58428d2a, 0x0c55f5ea, 0x1dadf43e, 0x233f7061,
0x3372f092, 0x8d937e41, 0xd65fecf1, 0x6c223bdb, 0x7cde3759, 0xcbee7460, 0x4085f2a7, 0xce77326e,
0xa6078084, 0x19f8509e, 0xe8efd855, 0x61d99735, 0xa969a7aa, 0xc50c06c2, 0x5a04abfc, 0x800bcadc,
0x9e447a2e, 0xc3453484, 0xfdd56705, 0x0e1e9ec9, 0xdb73dbd3, 0x105588cd, 0x675fda79, 0xe3674340,
0xc5c43465, 0x713e38d8, 0x3d28f89e, 0xf16dff20, 0x153e21e7, 0x8fb03d4a, 0xe6e39f2b, 0xdb83adf7,
0xe93d5a68, 0x948140f7, 0xf64c261c, 0x94692934, 0x411520f7, 0x7602d4f7, 0xbcf46b2e, 0xd4a20068,
0xd4082471, 0x3320f46a, 0x43b7d4b7, 0x500061af, 0x1e39f62e, 0x97244546, 0x14214f74, 0xbf8b8840,
0x4d95fc1d, 0x96b591af, 0x70f4ddd3, 0x66a02f45, 0xbfbc09ec, 0x03bd9785, 0x7fac6dd0, 0x31cb8504,
0x96eb27b3, 0x55fd3941, 0xda2547e6, 0xabca0a9a, 0x28507825, 0x530429f4, 0x0a2c86da, 0xe9b66dfb,
0x68dc1462, 0xd7486900, 0x680ec0a4, 0x27a18dee, 0x4f3ffea2, 0xe887ad8c, 0xb58ce006, 0x7af4d6b6,
0xaace1e7c, 0xd3375fec, 0xce78a399, 0x406b2a42, 0x20fe9e35, 0xd9f385b9, 0xee39d7ab, 0x3b124e8b,
0x1dc9faf7, 0x4b6d1856, 0x26a36631, 0xeae397b2, 0x3a6efa74, 0xdd5b4332, 0x6841e7f7, 0xca7820fb,
0xfb0af54e, 0xd8feb397, 0x454056ac, 0xba489527, 0x55533a3a, 0x20838d87, 0xfe6ba9b7, 0xd096954b,
0x55a867bc, 0xa1159a58, 0xcca92963, 0x99e1db33, 0xa62a4a56, 0x3f3125f9, 0x5ef47e1c, 0x9029317c,
0xfdf8e802, 0x04272f70, 0x80bb155c, 0x05282ce3, 0x95c11548, 0xe4c66d22, 0x48c1133f, 0xc70f86dc,
0x07f9c9ee, 0x41041f0f, 0x404779a4, 0x5d886e17, 0x325f51eb, 0xd59bc0d1, 0xf2bcc18f, 0x41113564,
0x257b7834, 0x602a9c60, 0xdff8e8a3, 0x1f636c1b, 0x0e12b4c2, 0x02e1329e, 0xaf664fd1, 0xcad18115,
0x6b2395e0, 0x333e92e1, 0x3b240b62, 0xeebeb922, 0x85b2a20e, 0xe6ba0d99, 0xde720c8c, 0x2da2f728,
0xd0127845, 0x95b794fd, 0x647d0862, 0xe7ccf5f0, 0x5449a36f, 0x877d48fa, 0xc39dfd27, 0xf33e8d1e,
0x0a476341, 0x992eff74, 0x3a6f6eab, 0xf4f8fd37, 0xa812dc60, 0xa1ebddf8, 0x991be14c, 0xdb6e6b0d,
0xc67b5510, 0x6d672c37, 0x2765d43b, 0xdcd0e804, 0xf1290dc7, 0xcc00ffa3, 0xb5390f92, 0x690fed0b,
0x667b9ffb, 0xcedb7d9c, 0xa091cf0b, 0xd9155ea3, 0xbb132f88, 0x515bad24, 0x7b9479bf, 0x763bd6eb,
0x37392eb3, 0xcc115979, 0x8026e297, 0xf42e312d, 0x6842ada7, 0xc66a2b3b, 0x12754ccc, 0x782ef11c,
0x6a124237, 0xb79251e7, 0x06a1bbe6, 0x4bfb6350, 0x1a6b1018, 0x11caedfa, 0x3d25bdd8, 0xe2e1c3c9,
0x44421659, 0x0a121386, 0xd90cec6e, 0xd5abea2a, 0x64af674e, 0xda86a85f, 0xbebfe988, 0x64e4c3fe,
0x9dbc8057, 0xf0f7c086, 0x60787bf8, 0x6003604d, 0xd1fd8346, 0xf6381fb0, 0x7745ae04, 0xd736fccc,
0x83426b33, 0xf01eab71, 0xb0804187, 0x3c005e5f, 0x77a057be, 0xbde8ae24, 0x55464299, 0xbf582e61,
0x4e58f48f, 0xf2ddfda2, 0xf474ef38, 0x8789bdc2, 0x5366f9c3, 0xc8b38e74, 0xb475f255, 0x46fcd9b9,
0x7aeb2661, 0x8b1ddf84, 0x846a0e79, 0x915f95e2, 0x466e598e, 0x20b45770, 0x8cd55591, 0xc902de4c,
0xb90bace1, 0xbb8205d0, 0x11a86248, 0x7574a99e, 0xb77f19b6, 0xe0a9dc09, 0x662d09a1, 0xc4324633,
0xe85a1f02, 0x09f0be8c, 0x4a99a025, 0x1d6efe10, 0x1ab93d1d, 0x0ba5a4df, 0xa186f20f, 0x2868f169,
0xdcb7da83, 0x573906fe, 0xa1e2ce9b, 0x4fcd7f52, 0x50115e01, 0xa70683fa, 0xa002b5c4, 0x0de6d027,
0x9af88c27, 0x773f8641, 0xc3604c06, 0x61a806b5, 0xf0177a28, 0xc0f586e0, 0x006058aa, 0x30dc7d62,
0x11e69ed7, 0x2338ea63, 0x53c2dd94, 0xc2c21634, 0xbbcbee56, 0x90bcb6de, 0xebfc7da1, 0xce591d76,
0x6f05e409, 0x4b7c0188, 0x39720a3d, 0x7c927c24, 0x86e3725f, 0x724d9db9, 0x1ac15bb4, 0xd39eb8fc,
0xed545578, 0x08fca5b5, 0xd83d7cd3, 0x4dad0fc4, 0x1e50ef5e, 0xb161e6f8, 0xa28514d9, 0x6c51133c,
0x6fd5c7e7, 0x56e14ec4, 0x362abfce, 0xddc6c837, 0xd79a3234, 0x92638212, 0x670efa8e, 0x406000e0,
0x3a39ce37, 0xd3faf5cf, 0xabc27737, 0x5ac52d1b, 0x5cb0679e, 0x4fa33742, 0xd3822740, 0x99bc9bbe,
0xd5118e9d, 0xbf0f7315, 0xd62d1c7e, 0xc700c47b, 0xb78c1b6b, 0x21a19045, 0xb26eb1be, 0x6a366eb4,
0x5748ab2f, 0xbc946e79, 0xc6a376d2, 0x6549c2c8, 0x530ff8ee, 0x468dde7d, 0xd5730a1d, 0x4cd04dc6,
0x2939bbdb, 0xa9ba4650, 0xac9526e8, 0xbe5ee304, 0xa1fad5f0, 0x6a2d519a, 0x63ef8ce2, 0x9a86ee22,
0xc089c2b8, 0x43242ef6, 0xa51e03aa, 0x9cf2d0a4, 0x83c061ba, 0x9be96a4d, 0x8fe51550, 0xba645bd6,
0x2826a2f9, 0xa73a3ae1, 0x4ba99586, 0xef5562e9, 0xc72fefd3, 0xf752f7da, 0x3f046f69, 0x77fa0a59,
0x80e4a915, 0x87b08601, 0x9b09e6ad, 0x3b3ee593, 0xe990fd5a, 0x9e34d797, 0x2cf0b7d9, 0x022b8b51,
0x96d5ac3a, 0x017da67d, 0xd1cf3ed6, 0x7c7d2d28, 0x1f9f25cf, 0xadf2b89b, 0x5ad6b472, 0x5a88f54c,
0xe029ac71, 0xe019a5e6, 0x47b0acfd, 0xed93fa9b, 0xe8d3c48d, 0x283b57cc, 0xf8d56629, 0x79132e28,
0x785f0191, 0xed756055, 0xf7960e44, 0xe3d35e8c, 0x15056dd4, 0x88f46dba, 0x03a16125, 0x0564f0bd,
0xc3eb9e15, 0x3c9057a2, 0x97271aec, 0xa93a072a, 0x1b3f6d9b, 0x1e6321f5, 0xf59c66fb, 0x26dcf319,
0x7533d928, 0xb155fdf5, 0x03563482, 0x8aba3cbb, 0x28517711, 0xc20ad9f8, 0xabcc5167, 0xccad925f,
0x4de81751, 0x3830dc8e, 0x379d5862, 0x9320f991, 0xea7a90c2, 0xfb3e7bce, 0x5121ce64, 0x774fbe32,
0xa8b6e37e, 0xc3293d46, 0x48de5369, 0x6413e680, 0xa2ae0810, 0xdd6db224, 0x69852dfd, 0x09072166,
0xb39a460a, 0x6445c0dd, 0x586cdecf, 0x1c20c8ae, 0x5bbef7dd, 0x1b588d40, 0xccd2017f, 0x6bb4e3bb,
0xdda26a7e, 0x3a59ff45, 0x3e350a44, 0xbcb4cdd5, 0x72eacea8, 0xfa6484bb, 0x8d6612ae, 0xbf3c6f47,
0xd29be463, 0x542f5d9e, 0xaec2771b, 0xf64e6370, 0x740e0d8d, 0xe75b1357, 0xf8721671, 0xaf537d5d,
0x4040cb08, 0x4eb4e2cc, 0x34d2466a, 0x0115af84, 0xe1b00428, 0x95983a1d, 0x06b89fb4, 0xce6ea048,
0x6f3f3b82, 0x3520ab82, 0x011a1d4b, 0x277227f8, 0x611560b1, 0xe7933fdc, 0xbb3a792b, 0x344525bd,
0xa08839e1, 0x51ce794b, 0x2f32c9b7, 0xa01fbac9, 0xe01cc87e, 0xbcc7d1f6, 0xcf0111c3, 0xa1e8aac7,
0x1a908749, 0xd44fbd9a, 0xd0dadecb, 0xd50ada38, 0x0339c32a, 0xc6913667, 0x8df9317c, 0xe0b12b4f,
0xf79e59b7, 0x43f5bb3a, 0xf2d519ff, 0x27d9459c, 0xbf97222c, 0x15e6fc2a, 0x0f91fc71, 0x9b941525,
0xfae59361, 0xceb69ceb, 0xc2a86459, 0x12baa8d1, 0xb6c1075e, 0xe3056a0c, 0x10d25065, 0xcb03a442,
0xe0ec6e0e, 0x1698db3b, 0x4c98a0be, 0x3278e964, 0x9f1f9532, 0xe0d392df, 0xd3a0342b, 0x8971f21e,
0x1b0a7441, 0x4ba3348c, 0xc5be7120, 0xc37632d8, 0xdf359f8d, 0x9b992f2e, 0xe60b6f47, 0x0fe3f11d,
0xe54cda54, 0x1edad891, 0xce6279cf, 0xcd3e7e6f, 0x1618b166, 0xfd2c1d05, 0x848fd2c5, 0xf6fb2299,
0xf523f357, 0xa6327623, 0x93a83531, 0x56cccd02, 0xacf08162, 0x5a75ebb5, 0x6e163697, 0x88d273cc,
0xde966292, 0x81b949d0, 0x4c50901b, 0x71c65614, 0xe6c6c7bd, 0x327a140a, 0x45e1d006, 0xc3f27b9a,
0xc9aa53fd, 0x62a80f00, 0xbb25bfe2, 0x35bdd2f6, 0x71126905, 0xb2040222, 0xb6cbcf7c, 0xcd769c2b,
0x53113ec0, 0x1640e3d3, 0x38abbd60, 0x2547adf0, 0xba38209c, 0xf746ce76, 0x77afa1c5, 0x20756060,
0x85cbfe4e, 0x8ae88dd8, 0x7aaaf9b0, 0x4cf9aa7e, 0x1948c25c, 0x02fb8a8c, 0x01c36ae4, 0xd6ebe1f9,
0x90d4f869, 0xa65cdea0, 0x3f09252d, 0xc208e69f, 0xb74e6132, 0xce77e25b, 0x578fdfe3, 0x3ac372e6
};
//==============================================================================
BlowFish::BlowFish (const uint8* keyData, int keyBytes)
{
memcpy (p, initialPValues, sizeof (p)); memcpy (p, initialPValues, sizeof (p));
int i, j;
int i, j = 0;
for (i = 4; --i >= 0;) for (i = 4; --i >= 0;)
{ {
s[i].malloc (256); s[i].malloc (256);
memcpy (s[i], initialSValues + i * 256, 256 * sizeof (uint32)); memcpy (s[i], initialSValues + i * 256, 256 * sizeof (uint32));
} }
j = 0;
for (i = 0; i < 18; ++i) for (i = 0; i < 18; ++i)
{ {
uint32 d = 0; uint32 d = 0;
for (int k = 0; k < 4; ++k) for (int k = 0; k < 4; ++k)
{ {
d = (d << 8) | keyData[j];
d = (d << 8) | static_cast <const uint8*> (keyData)[j];
if (++j >= keyBytes) if (++j >= keyBytes)
j = 0; j = 0;
@@ -374,78 +243,43 @@ BlowFish::~BlowFish()
{ {
} }
uint32 BlowFish::F (uint32 x) const
uint32 BlowFish::F (const uint32 x) const throw()
{ {
uint16 a, b, c, d;
uint32 y;
d = (uint16) (x & 0xff);
x >>= 8;
c = (uint16) (x & 0xff);
x >>= 8;
b = (uint16) (x & 0xff);
x >>= 8;
a = (uint16) (x & 0xff);
y = s[0][a] + s[1][b];
y = y ^ s[2][c];
y = y + s[3][d];
return y;
return ((s[0][(x >> 24) & 0xff] + s[1][(x >> 16) & 0xff])
^ s[2][(x >> 8) & 0xff]) + s[3][x & 0xff];
} }
void BlowFish::encrypt (uint32& data1,
uint32& data2) const
void BlowFish::encrypt (uint32& data1, uint32& data2) const throw()
{ {
uint32 l = data1; uint32 l = data1;
uint32 r = data2; uint32 r = data2;
for (int i = 0; i < 16; ++i) for (int i = 0; i < 16; ++i)
{ {
l = l ^ p[i];
r = F (l) ^ r;
const uint32 temp = l;
l = r;
r = temp;
l ^= p[i];
r ^= F(l);
swapVariables (l, r);
} }
const uint32 temp = l;
l = r;
r = temp;
r = r ^ p[16];
l = l ^ p[17];
data1 = l;
data2 = r;
data1 = r ^ p[17];
data2 = l ^ p[16];
} }
void BlowFish::decrypt (uint32& data1,
uint32& data2) const
void BlowFish::decrypt (uint32& data1, uint32& data2) const throw()
{ {
uint32 l = data1; uint32 l = data1;
uint32 r = data2; uint32 r = data2;
for (int i = 17; i > 1; --i) for (int i = 17; i > 1; --i)
{ {
l =l ^ p[i];
r = F (l) ^ r;
const uint32 temp = l;
l = r;
r = temp;
l ^= p[i];
r ^= F(l);
swapVariables (l, r);
} }
const uint32 temp = l;
l = r;
r = temp;
r = r ^ p[1];
l = l ^ p[0];
data1 = l;
data2 = r;
data1 = r ^ p[0];
data2 = l ^ p[1];
} }
END_JUCE_NAMESPACE END_JUCE_NAMESPACE

+ 4
- 4
src/cryptography/juce_BlowFish.h View File

@@ -42,7 +42,7 @@ public:
The key data can be up to 72 bytes long. The key data can be up to 72 bytes long.
*/ */
BlowFish (const uint8* keyData, int keyBytes);
BlowFish (const void* keyData, int keyBytes);
/** Creates a copy of another blowfish object. */ /** Creates a copy of another blowfish object. */
BlowFish (const BlowFish& other); BlowFish (const BlowFish& other);
@@ -55,10 +55,10 @@ public:
//============================================================================== //==============================================================================
/** Encrypts a pair of 32-bit integers. */ /** Encrypts a pair of 32-bit integers. */
void encrypt (uint32& data1, uint32& data2) const;
void encrypt (uint32& data1, uint32& data2) const throw();
/** Decrypts a pair of 32-bit integers. */ /** Decrypts a pair of 32-bit integers. */
void decrypt (uint32& data1, uint32& data2) const;
void decrypt (uint32& data1, uint32& data2) const throw();
//============================================================================== //==============================================================================
@@ -68,7 +68,7 @@ private:
uint32 p[18]; uint32 p[18];
HeapBlock <uint32> s[4]; HeapBlock <uint32> s[4];
uint32 F (uint32 x) const;
uint32 F (uint32 x) const throw();
}; };


+ 28
- 26
src/gui/graphics/imaging/juce_Image.cpp View File

@@ -139,41 +139,43 @@ void Image::setPixelData (int x, int y, int w, int h,
} }
//============================================================================== //==============================================================================
void Image::clear (int dx, int dy, int dw, int dh,
const Colour& colourToClearTo)
void Image::clear (int dx, int dy, int dw, int dh, const Colour& colourToClearTo)
{ {
const PixelARGB col (colourToClearTo.getPixelARGB());
const BitmapData destData (*this, dx, dy, dw, dh, true);
uint8* dest = destData.data;
while (--dh >= 0)
if (Rectangle<int>::intersectRectangles (dx, dy, dw, dh, 0, 0, imageWidth, imageHeight))
{ {
uint8* line = dest;
dest += destData.lineStride;
const PixelARGB col (colourToClearTo.getPixelARGB());
if (isARGB())
const BitmapData destData (*this, dx, dy, dw, dh, true);
uint8* dest = destData.data;
while (--dh >= 0)
{ {
for (int x = dw; --x >= 0;)
uint8* line = dest;
dest += destData.lineStride;
if (isARGB())
{ {
((PixelARGB*) line)->set (col);
line += destData.pixelStride;
for (int x = dw; --x >= 0;)
{
((PixelARGB*) line)->set (col);
line += destData.pixelStride;
}
} }
}
else if (isRGB())
{
for (int x = dw; --x >= 0;)
else if (isRGB())
{ {
((PixelRGB*) line)->set (col);
line += destData.pixelStride;
for (int x = dw; --x >= 0;)
{
((PixelRGB*) line)->set (col);
line += destData.pixelStride;
}
} }
}
else
{
for (int x = dw; --x >= 0;)
else
{ {
*line = col.getAlpha();
line += destData.pixelStride;
for (int x = dw; --x >= 0;)
{
*line = col.getAlpha();
line += destData.pixelStride;
}
} }
} }
} }


+ 20
- 20
src/gui/graphics/imaging/juce_Image.h View File

@@ -77,10 +77,10 @@ public:
black. If false, the image may contain random data, and the black. If false, the image may contain random data, and the
user will have to deal with this user will have to deal with this
*/ */
Image (const PixelFormat format,
const int imageWidth,
const int imageHeight,
const bool clearImage);
Image (PixelFormat format,
int imageWidth,
int imageHeight,
bool clearImage);
/** Creates a copy of another image. /** Creates a copy of another image.
@@ -97,10 +97,10 @@ public:
On some platforms this will just return a normal software-based image. On some platforms this will just return a normal software-based image.
*/ */
static Image* createNativeImage (const PixelFormat format,
const int imageWidth,
const int imageHeight,
const bool clearImage);
static Image* createNativeImage (PixelFormat format,
int imageWidth,
int imageHeight,
bool clearImage);
//============================================================================== //==============================================================================
/** Returns the image's width (in pixels). */ /** Returns the image's width (in pixels). */
@@ -144,7 +144,7 @@ public:
*/ */
virtual Image* createCopy (int newWidth = -1, virtual Image* createCopy (int newWidth = -1,
int newHeight = -1, int newHeight = -1,
const Graphics::ResamplingQuality quality = Graphics::mediumResamplingQuality) const;
Graphics::ResamplingQuality quality = Graphics::mediumResamplingQuality) const;
/** Returns a new single-channel image which is a copy of the alpha-channel of this image. /** Returns a new single-channel image which is a copy of the alpha-channel of this image.
*/ */
@@ -160,7 +160,7 @@ public:
@see getAlphaAt, setPixelAt, blendPixelAt @see getAlphaAt, setPixelAt, blendPixelAt
*/ */
virtual const Colour getPixelAt (const int x, const int y) const;
virtual const Colour getPixelAt (int x, int y) const;
/** Sets the colour of one of the image's pixels. /** Sets the colour of one of the image's pixels.
@@ -175,7 +175,7 @@ public:
@see blendPixelAt @see blendPixelAt
*/ */
virtual void setPixelAt (const int x, const int y, const Colour& colour);
virtual void setPixelAt (int x, int y, const Colour& colour);
/** Changes the opacity of a pixel. /** Changes the opacity of a pixel.
@@ -187,7 +187,7 @@ public:
@see getAlphaAt, setPixelAt @see getAlphaAt, setPixelAt
*/ */
virtual void multiplyAlphaAt (const int x, const int y, const float multiplier);
virtual void multiplyAlphaAt (int x, int y, float multiplier);
/** Changes the overall opacity of the image. /** Changes the overall opacity of the image.
@@ -197,7 +197,7 @@ public:
If the image doesn't have an alpha channel, this won't have any effect. If the image doesn't have an alpha channel, this won't have any effect.
*/ */
virtual void multiplyAllAlphas (const float amountToMultiplyBy);
virtual void multiplyAllAlphas (float amountToMultiplyBy);
/** Changes all the colours to be shades of grey, based on their current luminosity. /** Changes all the colours to be shades of grey, based on their current luminosity.
*/ */
@@ -223,7 +223,7 @@ public:
class BitmapData class BitmapData
{ {
public: public:
BitmapData (Image& image, int x, int y, int w, int h, const bool needsToBeWritable);
BitmapData (Image& image, int x, int y, int w, int h, bool needsToBeWritable);
BitmapData (const Image& image, int x, int y, int w, int h); BitmapData (const Image& image, int x, int y, int w, int h);
~BitmapData(); ~BitmapData();
@@ -231,13 +231,13 @@ public:
The co-ordinate you provide here isn't checked, so it's the caller's responsibility to make The co-ordinate you provide here isn't checked, so it's the caller's responsibility to make
sure it's not out-of-range. sure it's not out-of-range.
*/ */
inline uint8* getLinePointer (const int y) const { return data + y * lineStride; }
inline uint8* getLinePointer (int y) const { return data + y * lineStride; }
/** Returns a pointer to a pixel in the image. /** Returns a pointer to a pixel in the image.
The co-ordinates you give here are not checked, so it's the caller's responsibility to make sure they're The co-ordinates you give here are not checked, so it's the caller's responsibility to make sure they're
not out-of-range. not out-of-range.
*/ */
inline uint8* getPixelPointer (const int x, const int y) const { return data + y * lineStride + x * pixelStride; }
inline uint8* getPixelPointer (int x, int y) const { return data + y * lineStride + x * pixelStride; }
uint8* data; uint8* data;
int lineStride, pixelStride, width, height; int lineStride, pixelStride, width, height;
@@ -269,7 +269,7 @@ public:
above this level will be considered opaque above this level will be considered opaque
*/ */
void createSolidAreaMask (RectangleList& result, void createSolidAreaMask (RectangleList& result,
const float alphaThreshold = 0.5f) const;
float alphaThreshold = 0.5f) const;
//============================================================================== //==============================================================================
juce_UseDebuggingNewOperator juce_UseDebuggingNewOperator
@@ -286,9 +286,9 @@ protected:
const int imageWidth, imageHeight; const int imageWidth, imageHeight;
/** Used internally so that subclasses can call a constructor that doesn't allocate memory */ /** Used internally so that subclasses can call a constructor that doesn't allocate memory */
Image (const PixelFormat format,
const int imageWidth,
const int imageHeight);
Image (PixelFormat format,
int imageWidth,
int imageHeight);
int pixelStride, lineStride; int pixelStride, lineStride;
HeapBlock <uint8> imageDataAllocated; HeapBlock <uint8> imageDataAllocated;


+ 15
- 18
src/gui/graphics/imaging/juce_ImageCache.cpp View File

@@ -33,7 +33,7 @@ BEGIN_JUCE_NAMESPACE
//============================================================================== //==============================================================================
struct ImageCacheItem
struct ImageCache::Item
{ {
ScopedPointer <Image> image; ScopedPointer <Image> image;
int64 hashCode; int64 hashCode;
@@ -43,11 +43,11 @@ struct ImageCacheItem
juce_UseDebuggingNewOperator juce_UseDebuggingNewOperator
}; };
//==============================================================================
static ImageCache* instance = 0;
static int cacheTimeout = 5000;
ImageCache* ImageCache::instance = 0;
int ImageCache::cacheTimeout = 5000;
//==============================================================================
ImageCache::ImageCache() ImageCache::ImageCache()
{ {
} }
@@ -66,7 +66,7 @@ Image* ImageCache::getFromHashCode (const int64 hashCode)
for (int i = instance->images.size(); --i >= 0;) for (int i = instance->images.size(); --i >= 0;)
{ {
ImageCacheItem* const ci = instance->images.getUnchecked(i);
Item* const ci = instance->images.getUnchecked(i);
if (ci->hashCode == hashCode) if (ci->hashCode == hashCode)
{ {
@@ -79,15 +79,14 @@ Image* ImageCache::getFromHashCode (const int64 hashCode)
return 0; return 0;
} }
void ImageCache::addImageToCache (Image* const image,
const int64 hashCode)
void ImageCache::addImageToCache (Image* const image, const int64 hashCode)
{ {
if (image != 0) if (image != 0)
{ {
if (instance == 0) if (instance == 0)
instance = new ImageCache(); instance = new ImageCache();
ImageCacheItem* const newC = new ImageCacheItem();
Item* const newC = new Item();
newC->hashCode = hashCode; newC->hashCode = hashCode;
newC->image = image; newC->image = image;
newC->refCount = 1; newC->refCount = 1;
@@ -106,9 +105,9 @@ void ImageCache::release (Image* const imageToRelease)
for (int i = instance->images.size(); --i >= 0;) for (int i = instance->images.size(); --i >= 0;)
{ {
ImageCacheItem* const ci = instance->images.getUnchecked(i);
Item* const ci = instance->images.getUnchecked(i);
if ((Image*) ci->image == imageToRelease)
if (static_cast <Image*> (ci->image) == imageToRelease)
{ {
if (--(ci->refCount) == 0) if (--(ci->refCount) == 0)
ci->releaseTime = Time::getApproximateMillisecondCounter(); ci->releaseTime = Time::getApproximateMillisecondCounter();
@@ -137,7 +136,7 @@ bool ImageCache::isImageInCache (Image* const imageToLookFor)
const ScopedLock sl (instance->lock); const ScopedLock sl (instance->lock);
for (int i = instance->images.size(); --i >= 0;) for (int i = instance->images.size(); --i >= 0;)
if ((Image*) instance->images.getUnchecked(i)->image == imageToLookFor)
if (static_cast <Image*> (instance->images.getUnchecked(i)->image) == imageToLookFor)
return true; return true;
} }
@@ -152,9 +151,9 @@ void ImageCache::incReferenceCount (Image* const image)
for (int i = instance->images.size(); --i >= 0;) for (int i = instance->images.size(); --i >= 0;)
{ {
ImageCacheItem* const ci = (ImageCacheItem*) instance->images.getUnchecked(i);
Item* const ci = instance->images.getUnchecked(i);
if ((Image*) ci->image == image)
if (static_cast <Image*> (ci->image) == image)
{ {
ci->refCount++; ci->refCount++;
return; return;
@@ -168,13 +167,13 @@ void ImageCache::incReferenceCount (Image* const image)
void ImageCache::timerCallback() void ImageCache::timerCallback()
{ {
int numberStillNeedingReleasing = 0; int numberStillNeedingReleasing = 0;
const unsigned int now = Time::getApproximateMillisecondCounter();
const uint32 now = Time::getApproximateMillisecondCounter();
const ScopedLock sl (lock); const ScopedLock sl (lock);
for (int i = images.size(); --i >= 0;) for (int i = images.size(); --i >= 0;)
{ {
ImageCacheItem* const ci = images.getUnchecked(i);
Item* const ci = images.getUnchecked(i);
if (ci->refCount <= 0) if (ci->refCount <= 0)
{ {
@@ -208,11 +207,9 @@ Image* ImageCache::getFromFile (const File& file)
return image; return image;
} }
Image* ImageCache::getFromMemory (const void* imageData,
const int dataSize)
Image* ImageCache::getFromMemory (const void* imageData, const int dataSize)
{ {
const int64 hashCode = (int64) (pointer_sized_int) imageData; const int64 hashCode = (int64) (pointer_sized_int) imageData;
Image* image = getFromHashCode (hashCode); Image* image = getFromHashCode (hashCode);
if (image == 0) if (image == 0)


+ 15
- 12
src/gui/graphics/imaging/juce_ImageCache.h View File

@@ -31,7 +31,6 @@
#include "../../../events/juce_Timer.h" #include "../../../events/juce_Timer.h"
#include "../../../utilities/juce_DeletedAtShutdown.h" #include "../../../utilities/juce_DeletedAtShutdown.h"
#include "../../../containers/juce_VoidArray.h" #include "../../../containers/juce_VoidArray.h"
struct ImageCacheItem;
//============================================================================== //==============================================================================
@@ -89,8 +88,7 @@ public:
@returns the image, or null if it there was an error loading it @returns the image, or null if it there was an error loading it
@see release, getFromMemory, getFromCache, ImageFileFormat::loadFrom @see release, getFromMemory, getFromCache, ImageFileFormat::loadFrom
*/ */
static Image* getFromMemory (const void* imageData,
const int dataSize);
static Image* getFromMemory (const void* imageData, int dataSize);
/** Releases an image that was previously created by the ImageCache. /** Releases an image that was previously created by the ImageCache.
@@ -100,26 +98,26 @@ public:
@see getFromFile, getFromMemory @see getFromFile, getFromMemory
*/ */
static void release (Image* const imageToRelease);
static void release (Image* imageToRelease);
/** Releases an image if it's in the cache, or deletes it if it isn't cached. /** Releases an image if it's in the cache, or deletes it if it isn't cached.
This is a handy function to use if you want to delete an image but are afraid that This is a handy function to use if you want to delete an image but are afraid that
it might be cached. it might be cached.
*/ */
static void releaseOrDelete (Image* const imageToRelease);
static void releaseOrDelete (Image* imageToRelease);
/** Checks whether an image is in the cache or not. /** Checks whether an image is in the cache or not.
@returns true if the image is currently in the cache @returns true if the image is currently in the cache
*/ */
static bool isImageInCache (Image* const imageToLookFor);
static bool isImageInCache (Image* imageToLookFor);
/** Increments the reference-count for a cached image. /** Increments the reference-count for a cached image.
If the image isn't in the cache, this method won't do anything. If the image isn't in the cache, this method won't do anything.
*/ */
static void incReferenceCount (Image* const image);
static void incReferenceCount (Image* image);
//============================================================================== //==============================================================================
/** Checks the cache for an image with a particular hashcode. /** Checks the cache for an image with a particular hashcode.
@@ -134,7 +132,7 @@ public:
image by addImageToCache() image by addImageToCache()
@see addImageToCache @see addImageToCache
*/ */
static Image* getFromHashCode (const int64 hashCode);
static Image* getFromHashCode (int64 hashCode);
/** Adds an image to the cache with a user-defined hash-code. /** Adds an image to the cache with a user-defined hash-code.
@@ -148,14 +146,13 @@ public:
@param hashCode the hash-code to associate with it @param hashCode the hash-code to associate with it
@see getFromHashCode @see getFromHashCode
*/ */
static void addImageToCache (Image* const image,
const int64 hashCode);
static void addImageToCache (Image* image, int64 hashCode);
/** Changes the amount of time before an unused image will be removed from the cache. /** Changes the amount of time before an unused image will be removed from the cache.
By default this is about 5 seconds. By default this is about 5 seconds.
*/ */
static void setCacheTimeout (const int millisecs);
static void setCacheTimeout (int millisecs);
//============================================================================== //==============================================================================
juce_UseDebuggingNewOperator juce_UseDebuggingNewOperator
@@ -163,7 +160,13 @@ public:
private: private:
//============================================================================== //==============================================================================
CriticalSection lock; CriticalSection lock;
OwnedArray <ImageCacheItem> images;
struct Item;
friend class ScopedPointer<Item>;
friend class OwnedArray<Item>;
OwnedArray<Item> images;
static ImageCache* instance;
static int cacheTimeout;
ImageCache(); ImageCache();
ImageCache (const ImageCache&); ImageCache (const ImageCache&);


+ 2
- 0
src/io/files/juce_NamedPipe.h View File

@@ -27,6 +27,7 @@
#define __JUCE_NAMEDPIPE_JUCEHEADER__ #define __JUCE_NAMEDPIPE_JUCEHEADER__
#include "../streams/juce_OutputStream.h" #include "../streams/juce_OutputStream.h"
#include "../../threads/juce_CriticalSection.h"
//============================================================================== //==============================================================================
@@ -104,6 +105,7 @@ public:
private: private:
void* internal; void* internal;
String currentPipeName; String currentPipeName;
CriticalSection lock;
NamedPipe (const NamedPipe&); NamedPipe (const NamedPipe&);
NamedPipe& operator= (const NamedPipe&); NamedPipe& operator= (const NamedPipe&);


+ 29
- 30
src/io/streams/juce_InputStream.cpp View File

@@ -46,42 +46,42 @@ bool InputStream::readBool()
short InputStream::readShort() short InputStream::readShort()
{ {
char temp [2];
char temp[2];
if (read (temp, 2) == 2) if (read (temp, 2) == 2)
return (short) ByteOrder::littleEndianShort (temp); return (short) ByteOrder::littleEndianShort (temp);
else
return 0;
return 0;
} }
short InputStream::readShortBigEndian() short InputStream::readShortBigEndian()
{ {
char temp [2];
char temp[2];
if (read (temp, 2) == 2) if (read (temp, 2) == 2)
return (short) ByteOrder::bigEndianShort (temp); return (short) ByteOrder::bigEndianShort (temp);
else
return 0;
return 0;
} }
int InputStream::readInt() int InputStream::readInt()
{ {
char temp [4];
char temp[4];
if (read (temp, 4) == 4) if (read (temp, 4) == 4)
return (int) ByteOrder::littleEndianInt (temp); return (int) ByteOrder::littleEndianInt (temp);
else
return 0;
return 0;
} }
int InputStream::readIntBigEndian() int InputStream::readIntBigEndian()
{ {
char temp [4];
char temp[4];
if (read (temp, 4) == 4) if (read (temp, 4) == 4)
return (int) ByteOrder::bigEndianInt (temp); return (int) ByteOrder::bigEndianInt (temp);
else
return 0;
return 0;
} }
int InputStream::readCompressedInt() int InputStream::readCompressedInt()
@@ -108,22 +108,22 @@ int InputStream::readCompressedInt()
int64 InputStream::readInt64() int64 InputStream::readInt64()
{ {
char temp [8];
char temp[8];
if (read (temp, 8) == 8) if (read (temp, 8) == 8)
return (int64) ByteOrder::swapIfBigEndian (*(uint64*) temp);
else
return 0;
return (int64) ByteOrder::swapIfBigEndian (*reinterpret_cast <uint64*> (temp));
return 0;
} }
int64 InputStream::readInt64BigEndian() int64 InputStream::readInt64BigEndian()
{ {
char temp [8];
char temp[8];
if (read (temp, 8) == 8) if (read (temp, 8) == 8)
return (int64) ByteOrder::swapIfLittleEndian (*(uint64*) temp);
else
return 0;
return (int64) ByteOrder::swapIfLittleEndian (*reinterpret_cast <uint64*> (temp));
return 0;
} }
float InputStream::readFloat() float InputStream::readFloat()
@@ -157,7 +157,7 @@ double InputStream::readDoubleBigEndian()
const String InputStream::readString() const String InputStream::readString()
{ {
MemoryBlock buffer (256); MemoryBlock buffer (256);
char* data = (char*) buffer.getData();
char* data = static_cast<char*> (buffer.getData());
size_t i = 0; size_t i = 0;
while ((data[i] = readByte()) != 0) while ((data[i] = readByte()) != 0)
@@ -165,7 +165,7 @@ const String InputStream::readString()
if (++i >= buffer.getSize()) if (++i >= buffer.getSize())
{ {
buffer.setSize (buffer.getSize() + 512); buffer.setSize (buffer.getSize() + 512);
data = (char*) buffer.getData();
data = static_cast<char*> (buffer.getData());
} }
} }
@@ -175,7 +175,7 @@ const String InputStream::readString()
const String InputStream::readNextLine() const String InputStream::readNextLine()
{ {
MemoryBlock buffer (256); MemoryBlock buffer (256);
char* data = (char*) buffer.getData();
char* data = static_cast<char*> (buffer.getData());
size_t i = 0; size_t i = 0;
while ((data[i] = readByte()) != 0) while ((data[i] = readByte()) != 0)
@@ -196,15 +196,14 @@ const String InputStream::readNextLine()
if (++i >= buffer.getSize()) if (++i >= buffer.getSize())
{ {
buffer.setSize (buffer.getSize() + 512); buffer.setSize (buffer.getSize() + 512);
data = (char*) buffer.getData();
data = static_cast<char*> (buffer.getData());
} }
} }
return String::fromUTF8 (data, (int) i); return String::fromUTF8 (data, (int) i);
} }
int InputStream::readIntoMemoryBlock (MemoryBlock& block,
int numBytes)
int InputStream::readIntoMemoryBlock (MemoryBlock& block, int numBytes)
{ {
const int64 totalLength = getTotalLength(); const int64 totalLength = getTotalLength();
@@ -228,7 +227,7 @@ int InputStream::readIntoMemoryBlock (MemoryBlock& block,
{ {
// know how many bytes we want, so we can resize the block first.. // know how many bytes we want, so we can resize the block first..
block.setSize (originalBlockSize + numBytes, false); block.setSize (originalBlockSize + numBytes, false);
totalBytesRead = read (((char*) block.getData()) + originalBlockSize, numBytes);
totalBytesRead = read (static_cast<char*> (block.getData()) + originalBlockSize, numBytes);
} }
else else
{ {
@@ -239,7 +238,7 @@ int InputStream::readIntoMemoryBlock (MemoryBlock& block,
{ {
block.ensureSize (originalBlockSize + totalBytesRead + chunkSize, false); block.ensureSize (originalBlockSize + totalBytesRead + chunkSize, false);
const int bytesJustIn = read (((char*) block.getData())
const int bytesJustIn = read (static_cast<char*> (block.getData())
+ originalBlockSize + originalBlockSize
+ totalBytesRead, + totalBytesRead,
chunkSize); chunkSize);
@@ -261,7 +260,7 @@ const String InputStream::readEntireStreamAsString()
MemoryBlock mb; MemoryBlock mb;
const int size = readIntoMemoryBlock (mb); const int size = readIntoMemoryBlock (mb);
return String::createStringFromData ((const char*) mb.getData(), size);
return String::createStringFromData (static_cast<const char*> (mb.getData()), size);
} }
//============================================================================== //==============================================================================
@@ -270,7 +269,7 @@ void InputStream::skipNextBytes (int64 numBytesToSkip)
if (numBytesToSkip > 0) if (numBytesToSkip > 0)
{ {
const int skipBufferSize = (int) jmin (numBytesToSkip, (int64) 16384); const int skipBufferSize = (int) jmin (numBytesToSkip, (int64) 16384);
HeapBlock <char> temp (skipBufferSize);
HeapBlock<char> temp (skipBufferSize);
while (numBytesToSkip > 0 && ! isExhausted()) while (numBytesToSkip > 0 && ! isExhausted())
numBytesToSkip -= read (temp, (int) jmin (numBytesToSkip, (int64) skipBufferSize)); numBytesToSkip -= read (temp, (int) jmin (numBytesToSkip, (int64) skipBufferSize));


+ 31
- 42
src/native/windows/juce_win32_Files.cpp View File

@@ -681,24 +681,26 @@ void File::revealToUser() const
} }
//============================================================================== //==============================================================================
struct NamedPipeInternal
class NamedPipeInternal
{ {
HANDLE pipeH;
HANDLE cancelEvent;
bool connected, createdPipe;
NamedPipeInternal()
public:
NamedPipeInternal (const String& file, const bool isPipe_)
: pipeH (0), : pipeH (0),
cancelEvent (0), cancelEvent (0),
connected (false), connected (false),
createdPipe (false)
isPipe (isPipe_)
{ {
cancelEvent = CreateEvent (0, FALSE, FALSE, 0); cancelEvent = CreateEvent (0, FALSE, FALSE, 0);
pipeH = isPipe ? CreateNamedPipe (file, PIPE_ACCESS_DUPLEX | FILE_FLAG_OVERLAPPED, 0,
PIPE_UNLIMITED_INSTANCES, 4096, 4096, 0, 0)
: CreateFile (file, GENERIC_READ | GENERIC_WRITE, 0, 0,
OPEN_EXISTING, FILE_FLAG_OVERLAPPED, 0);
} }
~NamedPipeInternal() ~NamedPipeInternal()
{ {
disconnect();
disconnectPipe();
if (pipeH != 0) if (pipeH != 0)
CloseHandle (pipeH); CloseHandle (pipeH);
@@ -708,7 +710,7 @@ struct NamedPipeInternal
bool connect (const int timeOutMs) bool connect (const int timeOutMs)
{ {
if (! createdPipe)
if (! isPipe)
return true; return true;
if (! connected) if (! connected)
@@ -746,7 +748,7 @@ struct NamedPipeInternal
return connected; return connected;
} }
void disconnect()
void disconnectPipe()
{ {
if (connected) if (connected)
{ {
@@ -754,12 +756,18 @@ struct NamedPipeInternal
connected = false; connected = false;
} }
} }
HANDLE pipeH;
HANDLE cancelEvent;
bool connected, isPipe;
}; };
void NamedPipe::close() void NamedPipe::close()
{ {
NamedPipeInternal* const intern = (NamedPipeInternal*) internal;
delete intern;
cancelPendingReads();
const ScopedLock sl (lock);
delete static_cast<NamedPipeInternal*> (internal);
internal = 0; internal = 0;
} }
@@ -767,43 +775,26 @@ bool NamedPipe::openInternal (const String& pipeName, const bool createPipe)
{ {
close(); close();
NamedPipeInternal* const intern = new NamedPipeInternal();
String file ("\\\\.\\pipe\\");
file += pipeName;
intern->createdPipe = createPipe;
if (createPipe)
{
intern->pipeH = CreateNamedPipe (file, PIPE_ACCESS_DUPLEX | FILE_FLAG_OVERLAPPED, 0,
PIPE_UNLIMITED_INSTANCES,
4096, 4096, 0, NULL);
}
else
{
intern->pipeH = CreateFile (file, GENERIC_READ | GENERIC_WRITE, 0, 0, OPEN_EXISTING,
FILE_FLAG_OVERLAPPED, 0);
}
ScopedPointer<NamedPipeInternal> intern (new NamedPipeInternal ("\\\\.\\pipe\\" + pipeName, createPipe));
if (intern->pipeH != INVALID_HANDLE_VALUE) if (intern->pipeH != INVALID_HANDLE_VALUE)
{ {
internal = intern;
internal = intern.release();
return true; return true;
} }
delete intern;
return false; return false;
} }
int NamedPipe::read (void* destBuffer, int maxBytesToRead, int timeOutMilliseconds) int NamedPipe::read (void* destBuffer, int maxBytesToRead, int timeOutMilliseconds)
{ {
const ScopedLock sl (lock);
int bytesRead = -1; int bytesRead = -1;
bool waitAgain = true; bool waitAgain = true;
while (waitAgain && internal != 0) while (waitAgain && internal != 0)
{ {
NamedPipeInternal* const intern = (NamedPipeInternal*) internal;
NamedPipeInternal* const intern = static_cast<NamedPipeInternal*> (internal);
waitAgain = false; waitAgain = false;
if (! intern->connect (timeOutMilliseconds)) if (! intern->connect (timeOutMilliseconds))
@@ -839,9 +830,9 @@ int NamedPipe::read (void* destBuffer, int maxBytesToRead, int timeOutMillisecon
{ {
bytesRead = (int) numRead; bytesRead = (int) numRead;
} }
else if (GetLastError() == ERROR_BROKEN_PIPE && intern->createdPipe)
else if (GetLastError() == ERROR_BROKEN_PIPE && intern->isPipe)
{ {
intern->disconnect();
intern->disconnectPipe();
waitAgain = true; waitAgain = true;
} }
} }
@@ -860,7 +851,7 @@ int NamedPipe::read (void* destBuffer, int maxBytesToRead, int timeOutMillisecon
int NamedPipe::write (const void* sourceBuffer, int numBytesToWrite, int timeOutMilliseconds) int NamedPipe::write (const void* sourceBuffer, int numBytesToWrite, int timeOutMilliseconds)
{ {
int bytesWritten = -1; int bytesWritten = -1;
NamedPipeInternal* const intern = (NamedPipeInternal*) internal;
NamedPipeInternal* const intern = static_cast<NamedPipeInternal*> (internal);
if (intern != 0 && intern->connect (timeOutMilliseconds)) if (intern != 0 && intern->connect (timeOutMilliseconds))
{ {
@@ -897,9 +888,9 @@ int NamedPipe::write (const void* sourceBuffer, int numBytesToWrite, int timeOut
{ {
bytesWritten = (int) numWritten; bytesWritten = (int) numWritten;
} }
else if (GetLastError() == ERROR_BROKEN_PIPE && intern->createdPipe)
else if (GetLastError() == ERROR_BROKEN_PIPE && intern->isPipe)
{ {
intern->disconnect();
intern->disconnectPipe();
} }
} }
@@ -911,10 +902,8 @@ int NamedPipe::write (const void* sourceBuffer, int numBytesToWrite, int timeOut
void NamedPipe::cancelPendingReads() void NamedPipe::cancelPendingReads()
{ {
NamedPipeInternal* const intern = (NamedPipeInternal*) internal;
if (intern != 0)
SetEvent (intern->cancelEvent);
if (internal != 0)
SetEvent (static_cast<NamedPipeInternal*> (internal)->cancelEvent);
} }


Write Preview
Loading…
Cancel
Save