Changelog

This documentation is for Bink 1 and Bink 2 (which are licensed separately).

The minor versions are released in sync, so, for example, 2.1a (Bink 2) and 1.990a (Bink 1) are released at the same time.

This documentation was generated for Bink versions "2.5p/1.100p".

• Updated the Bink Unity plugin to support Unity 5.2+ (the binary interface changed).

• Added new Bink Unreal Engine 4 integration! Just drops in (no source changes normally needed). Built-in GPU decoding, async seeking and more. Supports UE 4.3 and up. Platforms: Win, Mac, Linux. GL, D3D11, and D3D12 support.
• Updated the Bink Japanese and Korean documentation.
• Added ARM 64 Android target.
• Fixed bug where the Bink player wasn't using keyframes during seeking.

• Fixed a few bugs with ancient Bink 1 old audio format files.

• Added new updated Japanese docs.
• Mac builds now use SSE 3 as their minimum architecture.
• The RAD tools no longer pre-read all of the images in a still-image sequence. We now assume all of the images are the same size as the first. This starts the compression much more quickly.
• Reorganized the order that input files are read - if there is a weird file that used to load and now doesn't, drop me a line.
• Change the minimum frame size calculations for Bink 2 - gives smaller output with videos that have little to no movement.

• Fixed a bug in the Binkplayer where it wouldn't use key frames after the current play cursor.

• Fixed a bug in the Analyze window for videos with more than 64K frames.
• The RAD Video Tools now run in high DPI mode (on high DPI monitors of course).
• Added support for importing 24-bit wave files.
• Fixed the iOS distribution to contain up-to-date Metal support.
• Made the Xbox build not set the BLD_INFO to avoid compiler warnings.
• Updated the PS4 sample for SDK 2.5 and 3.0.
• Froze the WinRT 8.0 and 8.1 builds at current version (new versions will be Win10 only).
• Add Miles output support to the Android builds.
• Switched the Windows 10 universal builds back to standard Win32 threads.
• Worked around occasional deadlock in BinkStartAsyncThread on PS4 2.5 or 3.0 SDK.
• Set affinity on Xbox One to the first 6 cores (running on the 7th core, even occasionally, can stall decompression).
• Now build the iOS build with embedded bitcode which is now the Apple recommended sweet action (also updated to Xcode 7.2).

• Simpler version scheme for Bink 1.

• Bink 1 file-format update: use full colorspace by default.
• Bink 1 file-format update: constant frame alpha is stored better smaller.
• Bink 1 file-format update: optional string data now supported.
• Bink 1 and 2 can now specify a custom colorspace in the file itself - more to come with this later.
• Added GPU-assistance for Windows 10 Universal and RT targets.
• All new software blitters - higher quality and available for all platforms. We continue to recommend not using software blitters and to use the GPU for color conversion, though.
• Dropped all the scaling compression options (2x height, 2x height interlaced, etc). No modern app should need these old school modes.
• Dropped the SPU version of the Bink decoder (which cleans up the codebase considerably). You can still download the old Bink 1 SPU decoder if necessary.
• Dropped the Nintendo 3DS as a current platform (also cleans up the codebase). You can still download the old Bink 1 3DS SDK if necessary.
• Removed all the weird buffer formats that no one uses anymore (BINKSURFACE24, BINKSURFACEYUVU, etc).
• Removed all the DirectDraw based options in the Bink player for Windows (just use DIBSections now).
• Added Linux 64-bit Bink Player to distribution.
• Moved to native Linux 32-bit builds (vs hybrid MSVC build).
• Fixed some window sizing and restoring problems for the RAD Video Tools on Windows 10 (update to Windows 10 1511 for sizing fix).
• Updated to Xcode 7.1 for tvOS, MacOS x64, and iOS.

• Fixed a bug when streaming Bink files smaller than 128KB.

• Fixed a bug on 64-bit MacOS when using memory allocation callbacks.

• Fixed a bug where files of a certain size would deadlock witth BINKPRELOADALL.

• Small changes to the Apple Metal integration to allow Metal GPU compute shaders to be used once the hardware gets fast enough (which is not now).
• Added an Apple tvOS platform.

• Fixed a bug where the IO buffer size was set to zero if the IO thread hadn't run in a while.

• Switched to the upcoming Telemetry 3 lib.

• Added Bink for Unity now supports Mac and GNU/Linux (in addition to Windows).

• Various small Unity fixes.
• Windows 10 Universal libraries now link with mincore.lib (instead of kernel32.lib) - should run on more Windows Universal platforms.
• Added Bink shared library target for GNU/Linux.
• Added Bink FAT shared library target for Mac.
• Worked around the powf_finite symbol on newer Linux GCC versions, should link with older glibc versions now.
• Worked around some multiple symbol definition warnings for older Linux GCC versions.
• Worked around ancient GCC linkers failing on long C++ symbols.

• Unity update: Unity 5.x compatibility, 64-bit Unity, Bink 1 compatibility, errors to Debug.Log.

• On Linux, we now use clock_gettime with CLOCK_MONOTONIC to avoid problems with timing if the system time is changed during video playback.

• Added all new Unity integration for Windows! Supports GL, D3D9, D3D11, GPU-assist, rendertargets, multichannel audio, and is fully multithreaded (up to 4 core decoding). Supports Bink 1 or Bink 2.

• With BinkGPU on GL, we now use persistent buffers if available - this gives a large reduction in CPU driver time on some GPUs.
• Added D3D 12 BinkGPU implementation on Windows.
• Added D3D 12 Binktextures and BinkGPU implementation on Xbox One.
• Added feature to stream Bink into memory and then play out of the memory once fully loaded. Use a size larger than the Bink file size to BinkSetIOSize to trigger this mode.
• Made the BinkGPU GL implementation use a dummy alpha texture instead of relying on driver consistency when sampling from unbound textures.

• Added new Windows Universal target (WinRT and WinPhone). WinRT and WinPhone targets merged.

• Added D3D 12 Binktextures API implementation. See BinkTexturesD3D12.cpp for details, D3D12 isn't as hands off as the other Binktexture platforms.
• Added support for Xaudio 2.8 (in addition to the old Xaudio 2.7 version).
• Added a user pointer parameter to Create_Bink_textures functions (which is passed back to you from any internal allocators).
• Made the GL Binktextures implementation use a dummy alpha texture instead of relying on driver consistency when sampling from unbound textures.
• Fixed a bug in the D3D9 Binktextures implementation when using triple buffering.
• New C# plugin library.

• Merge BinkTextures API with the GPU assisted API - now, if you use BinkTextures, you can switch to GPU assisted decoding just by linking with a different source file!

• BinkTexture API streamlined and simplified - switching is easy, should take less than 15 minutes. The Bink docs have a checklist on updating to the new API.
• BinkTextures now allows you to have multiple providers linked in and use them dynamically (like GL and D3D11 in the same EXE, or, more commonly, D3D11 and D3D11-GPU-assisted).
• Added new Apple Metal support for iOS - MUCH faster video than OpenGL, easily play 4K video on new iPads!
• Examples all streamlined and simplified - especially Linux and MacOS.
• BinkTextures source files renamed to be consistent across platforms.
• You can tell Bink to use triple buffering in the framebuffers, so you get automatic triple buffering just by changing a constant in BinkOpen. Nice on all zero-copy texture platforms (consoles, Metal).
• Fixed a bug where you couldn't control the volume on OpenAL.
• Removed the ancient BinkBuffers 2D API - just easier to use SetDIBits directly now-a-days.
• Fixed a tricky bug in the FFT code on Linux and Mac where the CPU detection code caused an internal overwrite.

• Fixed crash when flooding filling non-divisible by 16 alpha plane sizes.

• Fixed crash when flooding filling a completely empty alpha plane.
• Fixed a problem where the Bink player wasn't showing the scroll bar.
• Fixed a problem when Bink would incorrectly warn about movie-wide constant alpha.
• Fixed a problem where a constant alpha plane could be cleared incorrectly.
• Fixed a problem where decompression of a constant alpha plane with a height divisible by 16 (not 32) could crash.

• Big new version! Lots of compression improvements, mostly for alpha and near-lossless videos. This version includes a format change, so you need to update the tools and your SDK at the same time.

• We now recommend you use normal alpha video (non-premultiplied) when compressing with Bink, since this gives us the smoothest signal for compressing. Normal alpha is the default output format for video packages, so this should be easy. You usually want to use the 'filter-as-premultiplied-and-convert-back-to-non-premultiplied' option when compressing - this gives the best compression quality.
• When using the 'filter-as-premultiplied-and-convert-back-to-non-premultiplied' option, Bink now back fills the zero alpha areas with smooth, easy-to-compress color blocks.
• The Bink player now displays the alpha plane with a checker-board background so you can see it post-alpha (it assumes non-premultiplied). Press 'b' to change the brightness of the alpha plane.
• Areas of the video that have areas of all alpha zero values are weighted to zero in the compressor - this gives huge improvements to almost all alpha videos. You can turn off this weighting if you are storing non-alpha data in the alpha plane.
• Frames with constant alpha are stored in a much more efficient form. Effectively, there is no cost for frames that have all constant alpha values (good for videos that fade in the alpha to a max of 255, for example).
• Bink audio decompression is now about 3 times faster (huge SIMD optimizations in our iDCT code). Bink audio was already fast and now it's crazy fast (not that much slower than crappy ADPCM).
• Deblocking is applied slightly differently - gives better quality with fewer artifacts and is faster.
• Videos with lots of flat color (cartoons and sprites for example) can be compressed much smaller.
• Various improvements to the general Bink compressor.
• Old versions of Bink would use bandwidth attempting to microscopically improve near-lossless blocks. Now, Bink is better about using bandwidth for more important improvements.

• Fixed a bug in the GL and DX11 examples where they weren't calling BinkRegisterFrameBuffers (which has the odd effect of drawing every other frame).

• Fixed a bug where the DX11 code tried to update the alpha texture, even if it was not initialized.

• Added an iOS ARM 64-bit target and 64-bit simulator target.

• Updated the BinkTextures.h API - it is now completely cross platform compatible and much, much simpler (almost no platform ifdefs). Updating should be easy - it's usually a matter of removing parameters that were previously unused.
• You can now use multiple BinkTexture platforms in one application (like D3D9 and GL, for example).
• Made a few alignment changes in Bink.h - you must make sure your Bink.h matches your library version.
• Fixed an export problem with the BinkSetOSFileCallbacks function.
• On PS4, made the background threads use round robin scheduling.

• Added a new simplified way to redirect Bink's IO functions without having to completely replace the IO system. See the new BinkSetOSFileCallbacks API.

• Made gamma setting during compression not cost any extra CPU.
• Fixed the Linux 32-bit function export settings (bug from 2.4h).
• Fixed an iOS link error (bug from 2.4h).
• Fixed an Android link error (bug from 2.4h).
• Fixed a file open crash on Android (bug from 2.4h).
• When running on Xaudio2 on Windows, we close and reopen the Xaudio device if you call BinkSoundUseXAudio2 with a zero multiple times. This way you can have Bink reopen the audio device after a headphone is removed (but only if all the Binks are closed first).

• Fixed a rare crash bug on PS4 in the atomics library.

• Switched to the new simplified radtypes.h library (from rrcore.h).
• Android now attempts to open the file first with fopen and then the asset manager, so you can leave videos unpackaged.
• You can now turn on and off RAD Video Tools version checks with the versioncheck.exe tool.

• Fixed a bug in the Bink 2 YUV converter, where there would be a discoloration on the top lines of the chroma planes if the video height wasn't a multiple of 8.

• Fixed a bug on non-x86 platforms where when decompressing alpha we would prefetch beyond the edge of the alpha plane by 16 scanlines.
• On Windows, when using DirectSound, if no application window is found, use the desktop hwnd.

• Fixed a bug in the YUV converter, where the bottom line of the video would be overwritten by second to bottom line if the video height wasn't a multiple of 8.

• New BinkTextures implementations - more consistent and better cross platform compatibility.
• New BinkTextures update functions. You now call Start_Bink_texture_update when you are about to start decompressing (before BinkDoFrame or BinkDoFrameAsync). And once decompression is done (either after BinkDoFrame or BinkDoFrameAsyncWait returns), you call Finish_Bink_texture_update. Start replaces Wait_for_Bink_textures and Lock_Bink_textures, and Finish replaces Unlock.
• New BinkTextures draw function - you now just specify two device coordinates (0 to 1 based), so the size is consistent across different screens, and you no longer use a weird zoom parameter. Much simpler.
• Switched to pre-compiled shaders on most platforms. Our shader source is listed in the comments, so you can always continue to compile them at run-time if you prefer.
• Dropped DX10 support.

• Fixed a sporadic compressor crash/hang that could happen within preview frames of the end of the file.

• Made a Windows OpenGL pixel shader example (use gltextures.cpp on Windows).
• Don't query the sound system on a resume, if the video is already resumed.

• On Xbox 360, PS3 and Wii, fixed cache-clearing an extra 8 scanlines of texture data on videos that had a divisible by 16 or less height (height%32 == 1 to 16). This could crash on a dcbst instruction depending on how your texture memory was mapped.

• Added Telemetry support to Bink Orbis.
• Added hack workaround for Bink 2 GPU on AMD 5800 cards for DX11.
• Fixed a crash when BinkGetPlatformInfo-ing the sound submission thread on PS4 when no Binks had an open sound track.
• Fixed a bug when playing a Bink 2 movie on the GPU that has alpha, but you chose not to decompress the alpha.
• On the iOS simulator, fixed a link error with Bink 2.
• Made Bink 1 always blit the entire frame with DIBSections (prevents worse than usual tearing issues on slow scrolling videos in Aero mode on Windows).
• Multithreaded the resizing of videos during compression - compression can be many times faster if you are resizing.
• On Android x86, used a dummy silence sound buffer to prevent clicks and to avoid terrible performance if the sound started skipping.

• Warn if any of the files in a list file or series of images have missing alpha and you tried to compress with an alpha plane.

• On Xbox One, build with March XDK.

• Fixed bug when compressing movies smaller than 128 pixels high (compressor and decompressor fix).

• Made loading series of still PNGs, JPGs, and TIFs much faster (especially over a network).
• Fixed a bug where 64-bit Windows was sometimes showing as 32-bit in the System Info window.
• Added a WinRT 8.1 target (no, you can't just use the 8.0 DLLs, sigh).
• When using OpenAL on Linux, use the per-thread set current context functions (should integrate with game OpenAL use now).
• Fixed some symbols names on the Bink 2 Linux 32-bit library that was preventing it from linking into static libs.

• Bink 2 now has GPU video decoding! This is generally two to three times faster than CPU-only decoding alone! BinkGPU uses the CPU to decode the bitstream, and compute shaders on the GPU for everything else! Available for Windows DirectX 11, Linux GL 4.3, Sony PS4 and Microsoft Xbox One. Bink 2 is now even faster!

• Switched to PS4 SDK 1.5.

• Switched to GCC 4.8 on Linux 64.
• Fixed a bug where SSSE3 instructions were being generated on Linux (in places they shouldn't have been).
• On PS4, moved the default for the sound and IO threads to core 4 and bumped the sound thread priority (should help with UE3).
• Added a way to query the sound submission thread pointer on PS4 using BinkGetPlatformInfo and the BINKPLATFORMSUBMITTHREADS enum.
• Moved to the QFE 11 XDK on Xbox One.

• New video format - we've had a lot of fixes in the last month and we wanted to round them all up into a new format, so you know you are using the best stuff. We expect this version to be around a while - everyone should recompress.

• Bink now stores the version of the compressor that compressed the video in the video itself (can view it in RAD Info).
• Using the command line, you can now store a string in the Bink header (for copyrights or other metadata).
• Improved motion compensation near the edges of the video.
• Fixed a bug with videos that very specific widths (736, for example).
• Fixed a bug when decompressing a slices video with one core.

• Fixed deblocking artifact if you decompressed a video with fewer cores than slices that you compressed with. So, for example, if you compress with 2 slices and use 1 core to decode, then you should update (and re-encode).

• Removed the software blitters for Bink 2 Android.
• Lowered the default variance adaptive quantization (VAQ) level (this will slightly improve most videos).
• Added an option to control the VAQ level in the Bink 2 compressor (including turning it off completely).
• Allow use of '+' on numeric command line switches for easier setting of option flags (you can now use '/v512+8192' instead of '/v8704').

• Fixed a nasty overwrite bug in 2.3a, everyone should update and recompress! Valgrind-64 rules, btw!

• Removed the software blitters for Bink 2 iOS.
• Fixed a link error with Bink Android x86.

• Big new version: new file format, new features, new platforms!

• Bink now allows you to use 3-way, 4-way and 8-way multicore slicing at compression time. This means you can create videos that scale across more cores. So now, with 8-way slicing, you can get 4K video decompression down to 4ms on a PC! Also, with 3-way slicing, Xbox 360 and Wii-U get much faster too.
• Note that the Bink 2.3 compressor can still create Bink 2.2 compatible files - just set the slice count to '2 (Bink 2.2 format)'.
• Added new edge detection on the deblocker - videos with edges that align right onto 8x8 blocks will look much better.
• New Bink decompression API to use many cores for decompression.
• On Xbox One, added support for Direct3D monolithic mode.
• On Xbox One, fixed a bug in the Xaudio initialization.
• On PS4, fix a bug where the IO and sound thread priorities were too low.
• On PS4, fixed a synch issue if you paused and resumed over and over.
• Updated to most recent Xbox One and PS4 SDKs.
• Updated the GL texture code for faster texture uploading (especially on Android).
• Updated the Windows threaded example code to use many cores (instead of just two).
• Fixed a crash on Android when a file doesn't exist in the asset manager.
• Fixed a rare crash (divide by zero) from the IO thread if you were near the end of the video.
• Added iOS support for Bink 2 - requires a Neon device (iPhone 4+ or iPad).
• Added Windows 8 phone support.
• Added 64-bit Mac OS libraries for both Bink 1 and Bink 2.
• Fixed a sound synch bug on PSP2.
• Rewrote the RAD System Info display in the RAD Video Tools (64-bit compatible now).

• Added Wii-U support for Bink 2 - play 30 Hz 1080p or 60 Hz 720p video! We didn't think this would be possible - the little non-SIMD CPU that could!

• Added PSP2 (Playstation VITA) support for Bink 2 - play 60 Hz videos at native 960x544 resolution!
• Added Wii support for Bink 2 - play 30 Hz 640x480 video. Another Broadway platform we didn't initally think could handle Bink 2 - great CPU core!
• Added Bink 2 support for Android! Requires Neon - play beautiful 720p video at low, low data rates!
• Added x86 Android library support - man, the x86 Android phones are crazy fast. Supports both Bink 1 and Bink 2.
• Fixed the frame flipping logic in the PSP 2 example code - can flip faster now, shouldn't affect your games.
• Fixed a linking problem on Wii-U and Durango for Bink 1.
• Fixed a header file problem on Android.

• Added Windows RT (Windows Store Apps) support for Bink 2 and Bink 1. Includes x86, x64, and ARM DLLs. x86 and x64 are as lighting fast as regular Windows, and ARM can play 720p 30 Hz video comfortably.

• Allow you to set the engine and mix objects for OpenSL on Android (for Android platforms that let you only open one SL context).
• Fixed a crash bug on the Bink 2 alpha software blitters.
• On Xbox One, create the Xaudio object with XAUDIO2_DO_NOT_USE_SHAPE (takes less hardware resources).
• On Xbox One, set 8 channel output so that multichannel mixing works properly.
• On PS4, made the audio when pausing and resuming less latent.
• Use new threading primitives on Windows, Xenon, Xbox One and Windows RT.
• Slightly better motion-comp on the edges of movies that are non-divisible by 32 in the width or height.

• Fixed a crash on some divisible by 16 (rather than 32) videos.

• Made the PS3 textures always use a multiple of 128 for the pitch.
• Updated to SDK TWL5.5 on the Nintendo DSi.
• Fixed a non-determinism bug in the encoder.

• Added an 'Auto' mode for the datarate in the compressors - this will choose a reasonable data rate for your input video's resolution and frame rate.

• Added a position scroll bar to the Bink Player.
• Fixed a bug in the software blitters that would crash if your Bink 2 file was 16 to 23 pixels off of divisible by 32 in the width.
• Made the File Info button properly recognize Bink 2.2 files.
• Several improvements in the Bink 2 encoder - improved compression speed by about 10%.
• New mo-vec samplers that don't overread when filtering.

• Huge new 2.2 version - we probably should have called it 3.0. All Bink 2 users should upgrade and recompress.

• All new codec (new file format) - massive quality and speed improvements.
• Use *half* the data rate as Bink 2.1! 720p at 600K, 1080p at 1200K! Experiment with low-rates - we are commonly surprised at how low we can take some videos now. Smaller is also faster to decode!
• Encoder is twice as fast as 2.1. It is now almost 3 times faster than Bink 1, and will encode 720p at 60 fps with 16 cores.
• New perceptual based variable quantizer - quality is vastly improved at all data rates, but especially low rates.
• Uses any dimension of video (padding done internally) - 3D support code all updated to support padded widths and heights.
• Improvements to colorspace converters (where some videos would be a little blue). Make sure you update your shader constants too.
• Huge decoder speedups! 1.5x to 2x faster playing the same 2.1 videos. Faster still if you compress the videos at a lower rate with 2.2 (which will look the same). 720p videos are under 1 millisecond per frame now on x86.
• SSE3 and SSSE3 optimizations.
• PS3 version is much, much faster and smaller (GCC inliner kept under control).
• Deblocking is much faster, and you can turn it off completely for even more speed.
• Updated to latest Xenon, PS3, Wii-U, PS4 and Xbox One SDKs.
• Support for Telemetry 2.
• Linux 64-bit build now includes software blitters for the Bink 2 colorspace.
• Added PS4 and Xbox One docs.
• Turned off UPX EXE compression, since drunk interns seem to write McAffee's virus detector (pro-tip: decompress before detection... ahh, nevermind, look just take the banana out of your nose).

• Massive Bink 2 compressor speed improvement - 20x faster, now usually faster than Bink 1.

• Big improvements in compression quality - up to 20% in some cases.
• Full dual core decoding implemented - twice as fast as previous Bink.
• Fixed problem in new colorspace software blitters (reddish tint).
• Fixed a crash with 32x32 videos.
• Added new colorspace support for GL platforms.
• Print colorspace info in File info window.
• Changed the BinkTextures.h API on DX10, DX11, and OpenGL to better match what the graphics APIs are actually doing. To change, remove BINKNOFRAMEBUFFERS from BinkOpen, pass in the width and height of the movie to Create_Bink_textures, remove the call to Lock_Bink_textures, rename the call to Unlock_Bink_textures to Update_Bink_textures, and remove the call to BinkRegisterFrameBuffers.
• Added video width and height parameters on Create_Bink_textures in the BinkTexture.h API, so that we can handle non-divisible by 16 videos on the graphics APIS that allow it.
• Updated the DX9 Exam3DpsThr.cpp example to show how to handle a device reset (and added two function to the BinkTextures.h API for DX9.

• Fixed crash in Bink 2 when compressing alpha videos.

• Bink 2 now uses full Y colorspace (0-255) - gradients look a *lot* better. You must recompress to get the new colorspace. All of the Bink texture code has changed to support two colorspaces.
• Added SSE2 software blitters for the full Y colorspace.
• Added support for handling iOS Siri audio interruption.
• Updated to new beta system SDK for secret platform 2 - lots of GPU optimization.
• Fixed a memory overwrite bug in the DX10 and DX11 BinkTexture cpp files.
• Fixed a problem where an SSE 3 instruction was accidentally used (Bink 2 requires SSE2 only).
• Fix where batching a bunch of files into Bink 2 used the old Bink 1 extension.

• Public release of Bink 2! Six times quality, 2x to 3x faster!

• Note, Bink 2 compressor only supplied with Bink 2 SDK for now.
• Bink 1 still available for non-SIMD platforms (Wii, 3DS, etc).
• Added another secret platform.

• On Linux, switch to OpenAL for sound output.

• Made the DX10 texturing support code more driver-optimizable - roughly twice as fast on most GPUs.
• Added DX11 texturing support.
• Made the OpenGL texturing support code run on Android.
• Updated to later system SDK on a secret platform.
• Fixed a bug in the example old fixed function Windows GL source, where the second frame was skipped.
• Made the Bink IO system use Telemetry timespans instead of time sections.
• Fixed a bug where the alpha plane could get corrupted on extremely small frames.

• Fixed a nasty rare deadlock on BinkClose on non-priority-inheriting platforms (notably PS3, Xbox, Wii and Wii-U).

• Fixed a regression problem with Wii-U audio not playing.
• Added an ARMv7s library to the fat iOS Bink library.
• Added the async functions to Android.

• Added a new secret platform (contact us for details).

• Added Linux 64-bit as a new platform.
• Added a gltextures.cpp GLSL pixel shader blitter file for Mac, iOS, and Linux.
• On Mac, now handle headphones being removed during playback.
• Updated to latest Telemetry.
• Fixed a bug on PS Vita, where the sound on the first frame could be lost, leading to sync issues.
• Switched distributions to 7zip.

• On Wii-U, switched to Nintendo 2.07.03 patch 3.

• BinkWait keeps waiting if there is still IO to be performed (instead of doing it in BinkDoFrame).
• For Wii-U, added a bunch of I/O guidelines - short version is that BinkOpen, BinkGoto and BinkClose should be called on a background thread.
• For Wii-U, create a file command block for each IO, so that you can open multiple Binks at once without complications. This means a small source change for the BinkSetWiiUFileClient call.
• For Wii-U, clear out the callback fields in the audio voices to work around a system bug.
• For Wii-U, added a way to poll the BinkControlBackgroundIO call, so that you don't block on the silly IO system.
• For Wii-U, flush the Bink texture buffers during decompression.
• Made most platforms default to not loading up the IO buffer (since most are threaded now anyway).
• Switched to the Android 4.6 toolchain.

• Cleaned up the multiple definitions problem on Linux, and fixed some stuff to allow the static library to be linked into a shared object.

• Fixed a problem where the center channel volume could leak into the DRC output on Wii-U.
• Switched to the 2.07.03 SDK on Wii-U.
• Fixed a bug with certain PNGs that overwrote the JPEG decode tables in the RAD Video Tools.
• Smaller libs on Xenon is due to not including D3D stuff from xtl.h - they will be the same size linked.

• Android is now a supported platform!

• Added a new secret platform (contact us for details).
• On the Wii-U, switched to using the FS API (since FSA has been deprecated). You'll have to update your code, since this call now takes two parameters.
• On Wii and Wii-U, allocate the stack space for the async threads from the BinkSetMemory callback.

• Fixed a subtle bug on iOS where the background threads were sleeping too little - big performance increase on single core Apple devices.

• Switched to Wii-U SDK 2.04.
• Fixed on DRC output on Wii-U.

• Added 5.1 and DRC Wii-U sound support.

• On Wii-U, precompiled shaders are now built for 2.03 and up (and moved to Wii-U 2.03 SDK).
• Added multi-channel out using CoreAudio on MacOS.
• On the 3DS, moved to the 2.4.2 system SDK.
• Added code in the 3DS example to show how to use an Autostack.
• Fixed a bug in the 3DS code where the vertex buffer was being used twice (create a race condition).
• On the 3DS, fixed a rare crash in the sound system when looping a movie.
• On Xenon, synchronize the Xaudio buffer starts to fix cross audio track slipping on resume.
• Improved the colorspace converters used when compressing.

• Added Wii-U support!

• Added some docs about using BINKFROMMEMORY with local memory when using the SPU on PS3 (there is a speed hit, but only about 30% and you save the system memory).
• Fixed a problem on PS Vita where thread resources hung around.

• Fixed a bug on Windows and Xenon where if you started a Bink async thread and immediately closed it, you could deadlock.

• Added markup to support the upcoming Telemetry version that supports SPU.
• Worked around a bug in Xaudio, where it would crash if there were no audio devices on the system.
• Fixed a threading issue in the yuv converter, where the final 8 lines on an all black frame could turn greenish.

• Fixed a bug where multiple sounds tracks could get out of sync after a BinkGoto.

• On PS Vita, updated to SDK 1.0 (example code tweaks).
• Updated the Wii examples to not use GX_CA_ONE.
• Range check the spu/thread indexes on the async functions.
• Fixed some 3DS sound skipping issues with certain sound playback rates.
• Fixed a bug in the still image library where some PNG files would blow up the JPEG decoder.
• Removed all TLS stuff for PS3 (and just use a hash map) - too many corner cases with the PS3 TLS implementation.

• Fixed a bug on iOS where the background threads weren't sleeping properly - all iOS users should update.

• On 3DS, updated to SDK 2.4.

• Fixed a bug where the IO thread inherited the stack size of the calling thread, which could lead to rare and hard to reproduce crashes - everyone with 1.99h should update.

• On Wii, fixed a nasty deadlock when ejecting at the end of a file (thanks to two dedicated testers!).

• Added some early outs in the IO system, when an IO error occurs.
• On Xbox, switched to June XDK.
• On PS3, switched to 360 SDK.
• On iOS, fixed blitting pitch issue for odd-width Bink videos.

• Added background decoding on Sony NGP (can use multiple cores).

• On the Wii, updated the example texturing code to more easily integrate with Iggy.
• On PS3, fixed an SPU deadlock if your IO was running way behind.
• Made shutdown slightly faster if an IO was in progress.
• Fixed a bug in BinkGoto when the destination frame was within 750 ms of the previous key frame and the currently displayed frame.
• Fixed a bug on the Wii, if when opening a file on a non-divisible-by-32 file offset.

• Added Sony NGP support!

• Added background thread decompression for Wii (lets you decompress in the retrace wait or across multiple frames).
• Fixed background thread decompression on Mac.
• Videos without sound will now only catch up to a maximum of 4 frames (before resyncing). This prevents playback from zooming forward if you stop calling Bink for a while. You should still call BinkPause if you are doing this intentionally.

• Added iOS as an official platform (had been shipping as beta for a long time).

• The iOS library is now a fat library that contains simulator, ARM 6 and ARM 7 versions.
• Moved our 3DS support out of secret mode.
• Fixed a crash on the 3DS where if another system was pumping the DSP sound chip, you could deadlock. Now, in BinkSoundUse3DS, you call tell Bink to service the DSP or not.
• Fixed an issue where the 3DS wouldn't play sound depending on your thread priorities.
• Switched to light-weight semaphores on 3DS, since there are only 8 real semaphores system-wide.
• Added the blend op in the DX10 pixel shader code.
• On the PS3, insure that all audio tracks are decoded before starting mixing (fixes a problem where occasionally a set of audio track would be started out of phase).

• On the Xbox, switched to the Feb 2011 XDK for an Xaudio flags change.

• Fixed a bug in the compressor when setting a hint value on the very final frame.
• Fixed the MacOS X player so that it can play compiled Bink EXE files again.
• On the 3DS, moved the sound servicing thread back into Bink (from the user-side code).

• Added support for negative frame numbers in the Bink compressor - they are offsets from the end of the file. So, a start frame of -1 means start on the very last frame.

• On the 3DS, remove an unintentional call to NN_LOG (which isn't in the release libs).
• On Windows, increment the maximum number of queued async frame decompressions to 32 (for Intel's 100's of videos demo).
• On the Xbox, when under super-heavy system load, avoid the XDK warning message if you incremented a semaphore past it's max.
• On the 3DS, reset the vertices pointers on every call to draw the textures.
• On the PS3, dynamically allocate TLS variables so that the Bink library can be used in a PRX.
• On the PS3, use a bigger priority delta for the background threads.
• On the Wii, allocate the stack memory for the background threads from the user memory callback.
• On the Xbox, switched to the November XDK.
• On the 3DS, switched to the 1.0 SDK.

• Fixed a bug on Windows machines with more than 32 cores.

• Updated Bink on NDS to use the same IO layer as all the other platforms.
• Fixed a bug on the NDS where the first bit of sound would be muted.
• Fixed a problem in the example program for a secret platform.
• On the PS3, if you don't use threaded IO and you are decoding on the SPU, then we make sure the disc IO is complete before starting the SPU task.

• Fixed a crash when playing a movie directly from memory that had no sound.

• Updated to the latest iOS SDK for the Apple devices.
• Added volume control to Bink for iOS.
• Updated to the least SDK on a secret platform and fixed a sound skipping problem caused by this update.
• Updated to the Xbox November 2010 XDK.

• Added XAudio 2 support on Windows and enabled it in the RAD Video Tools - now there is an easy way to test your multichannel Binks on Windows 7.

• Made the Bink player window resizable during playback. Playback also now continues during window drags.
• Made the Bink player default to playing when it isn't the focus.
• Fixed a bug where semaphore handles could leak depending on how the Bink IO and sound threads shut down.
• On Nintendo 3DS, fixed a thread handle leak.
• Clear the sound buffer when using BinkGoto to jump back to frame 1.
• Fixed a few rare volume issues on Xbox 360.
• Switched to VC2008 and built with stack frame enabled on Windows (for better release-mode debugging).

• Added a new support for Nintendo 3DS.

• On the Wii, added support for the latest IO and sound systems (which are thread based). Threads are awkward on the Wii, but now that we have a good wrapper, we can share all of the fancy IO features from other platforms.
• Added code to the Wii examples to show how to handle critical IO errors during Bink playback.
• On the PS3, don't call cellAudioPortStop when audio drops out, since we've had reports of it deadlocking when the system is under severe load.
• On the Xbox 360, fixed a problem when you didn't set all of the speaker volumes for a track (that is, if you just set the volumes for a subset of speaker outputs).
• Fixed a bug where audio would be delayed, if you used BinkGoto to jump directly to a key frame.
• Fixed a bug on MacOS, where the initial file offset when using BINKFILEOFFSET wasn't queried correctly.
• Moved to the PS3 350 system software.
• Moved to the Xbox September 2010 system software.

• Updated the Mac platform to the latest Bink. Dropped all pre-MacOS X versions of the library.

• Released a new version of the Bink Mac player that supports the latest versions of MacOS.
• Updated the Linux platform to the latest Bink.
• Fixed a rare deadlock in BinkGoto.

• Fixed the new 64-bit file offset stuff for Xbox 360.

• Fixed a rare deadlock in the global libAudio mixer on the PS3.
• When possible, made the BinkGoto IO happen on the background thread.
• Fixed some sound systems not restarting after a BinkSetSoundOnOff.
• Fixed a problem with multiple sounds tracks on the SPUs.

• The Bink encoder has been massively tweaked using Telemetry - up to twice as fast on many core machines (4+ cores).

• Decoder IO system completely rewritten. IO is now done later in pipeline (more opportunity for background IO). And even under starvation conditions, IO happens on the async thread. Better yet, when playing multiple Binks at a time, all IO is co-operatively scheduled. Again, all these optimizations performed using Telemetry.
• Telemetry integration in the Bink compressor, Bink player, and Bink SDK. More information soon.
• Multichannel output functions overhauled - the new BinkSetSpeakerVolumes function is cross-platform compatible and replaces the old mix bin functions. Cleaned up Xaudio2, PS3 libAudio, and Miles multichannel output.
• Added built-in support for PNGs files with alpha - you no longer have to install QuickTime still image support.
• Bink now allows developers to control whether the background IO and sound threads are closed in BinkClose automatically or not. If you choose not to free them in BinkClose, then free them with BinkFreeGlobals.
• Removed the non-MacOS-X Mac, Xbox 1, and GameCube build targets.
• Added new BinkGetPlatformInfo function to obtain internal Bink information (like thread handles).
• Standard Bink IO source simplified for easier modification (several chunks of functionality moved back into library).
• Ported the async decompression features to more platforms (PSP, Mac, Linux).
• Fixed a problem where the Bink tools would warn to check for updates each time you ran them on 64-bit Windows.
• Added Altivec byteswappers to the PS3 and Xbox360 build (minor speed win).
• Added the new BinkSetFileOffset function to allow you to set the Bink video position within the file to load (also now 64-bit offset compatible).
• Exported the BinkFlipEndian32 function to do fast endian-swapping on big-endian platforms.
• Added a BinkOpenWithOptions function that allows you to specify all of the optional settings at open time (so it is multithread safe).

• Fixed a rare clicking bug with stereo audio tracks.

• Fixed an alignment crash when looping movies with unusual frame rates.
• Fixed a bug when trying to play non-present audio tracks that were specified out of order between two good audio tracks.
• Fixed some header file dependencies for the new generic x86 build.
• On the PS3, added code to detect if --strip-mode-normal was not specified to spu_elf-to-ppu_obj.

• Fixed an obscure crash bug in audio decoder when using a replacement memory allocator.

• Reduced the memory use on each audio track down even further - saves another 8 KB per audio track.
• Optimized the SPU DMA audio table copy by 10 KB per audio track.
• Bink encoder now uses the same table driven FFT routines at the decoder.
• Shrunk the FFT table memory - saved about 8K in library code space.
• When possible, use the output buffer for the FFT workspace buffer - this is better for the CPU cache which speeds up audio decompression, especially on slower platforms like NDS and Wii.
• Aggregate-allocate all the audio memory, so instead of two allocations per track, there is a single big allocation for all of the tracks.
• On Windows, set the thread affinity on the async threads to reduce playback variability.
• Added a new generic x86 build - it can run on any 32-bit x86 platform (Linux, MacOS, smartphones or whatever).

• Playing multitrack audio now takes about 10 KB less per track.

• On the consoles, made the FFT audio routines use pre-built tables to avoid the calls to the math libraries.
• Updated Bink to link with Miles 8 (the new Miles is awesome, btw).
• Moved the Bink logo into another file, so that GCC would be convinced to dead-strip it (when not used).
• Added a hint in the docs to use --strip-mode=normal on PS3 when embedding your SPU images in a PPU object file.
• On the Xbox, switched to the new February XDK (which comes with a new compiler).

• On PS3, we switched back to use cellSpursEventFlagWait (you should insure that exitIfNoWork is set to false in cellSpursAttributeInitialize or cellSpursInitialize).

• On the PS3, upgraded to SDK 310.
• On Windows, fixed a bug when scheduling async decompression of more than 64 background frames.
• On Windows, turn off audio rate adjusting for data rates that are exactly 44100 or 48000 or when you are running on a single CPU. This fixes some skipping problems on older machines.
• On Windows, added a timer option that forces use of timeGetTime instead of QueryPerformanceCounter - to enable it, set the environment variable RAD_USE_TGT to 1 (can be useful as a workaround on old AMD boxes).
• Fixed a rare divide overflow in BinkGetSummary.

• Fixed a bug in the PS3 GCM texture example - if your mapped memory allocator doesn't align to 128-byte addresses, then you need this apply this change.

• Fixed a regression where small Bink files still streamed (even though they could fit in the IO buffer).
• Made it safe to call Bink from multiple threads using different HBINK handles without using a mutex.
• Made it possible to change sound providers after you have set one (if there are no Bink files open).
• Added a BinkSetWillLoop function that tells Bink that you want to loop the video during playback - this lets Bink seek back to the beginning of the file to hide the disc seek hitch when you loop around.

• Added support for the Nintendo DSi.

• Rewrote the IO system on the DS and DSi - it saves up to 25% of the CPU. Everyone should upgrade.
• Sped up the SPU based PS3 decompression for SPURS (uses less SPU and PPU cpu while waiting).
• Changed the DX9 support on Windows to always use system textures with dirty rectangle updating - this gets better render overlap.
• Added Bink texture support code for DX10 on Windows.
• Added Korean documentation.
• Optimized the initial file loading on all platforms - we now do fewer start up IOs.
• Dropped Xaudio 1 support on Xbox 360.
• Added some alignment constraints to speed up file IO on various platforms.
• Fixed a bug where dirty rectangles weren't being returned correctly.
• Fixed a rare deadlock on Vista (when a user unplugged USB speakers or headphones during playback).
• Made the Windows 64-bit player use the 32-bit registry, so that it finds all the 32-bit settings.

• Built with March Xbox XDK - fixes a sound crash when using an older Bink on the March XDK.

• Built with the 250 Sony SDK.
• Built with the Wii SdK 3.2 (patch 3).

• Fixed a rare bug that would cause the background IO thread to use 100% of the CPU when IO was suspended. If you are loading data while streaming a video, this will greatly help your performance (especially on PS3 which doesn't have a spare core to hide the problem).

• Switch the MacOS X version of the Bink library to use Unix paths (no more FSSpecs).
• Fixed the screen vertices on Windows, Xbox and Xenon, so that videos will play properly with bi-linear turned off.
• Changed the Wii texture code to draw in 32x32 pixel chunks - this almost doubles (!) the texturing speed (better texture cache usage), and it fixes the previous problem of artifacts when scaling a texture (which means the Wii texturing precision problem was in triangle setup and not the texture iterators as I previously suspected). Note that this fix is in WiiTextures.c, which is sample code that you generally integrate into your game, so make sure you merge these changes!
• Cleaned up the 3D window resizing code in the Windows examples.
• Added error reporting to the SPU setup code, so you can call BinkGetError to better see what went wrong.
• Fixed a crash when using BinkMix to remove a track that wasn't present in the input file.

• Worked around yet another code-gen bug on the Xbox 360 (which led to noisy audio).

• Fixed a bug in the new BinkDoFramePlane function.

• Switched to the November Xbox 360 XDK (with hotfix).
• Fixed a bug on Windows where the video could play too fast for the first few seconds after a loop.
• Fixed a linker issue on Win64, where MSS64.DLL wasn't being delay loaded properly.
• Added SIMD optimizations in the Bink audio decoder for PSP.
• Switched the latest GCC and to the GCC linker on PSP.
• Switched to CodeWarrior 1.0 on Wii.

• Added SIMD versions of the Bink audio decoder for MMX, SSE, SSE2, PS3 VMX, Xbox 360 VMX, and Sony PS2. The Bink audio decoder is already really fast (usually less than a few percent on most platforms), but it's now faster still.

• Added the new BinkDoFramePlane function which lets you decompress specific planes of a video frame (like just the alpha, or just the Y).
• Added support for Miles 7.2d and up.
• Fixed two bugs in the Nintendo Wii GPU color conversion sample code. The first bug would draw your movies too bright (blacks would be slightly gray). The second bug selected three indirect stages instead of two, so game state could be incorrectly inherited. These bugs were fixed in wiitextures.c which is supplied in source form, so be sure to update the copy in your game.
• Fixed a bug in the Wii audio code where very long movies (around 8 minutes) would start to fall out of sync.
• Fixed sync problems for all Windows sound providers (DirectSound, waveOut, and Miles) where newer sound chipsets (most motherboard sound chips) that have a natural sample rate of 48000, will play non-48K audio (like 44100 Hz) at the incorrect rate (like 44130 Hz). This slight clock difference slowly leads to sync problems in longer movies. We now measure the sound rate and slowly compensate the video to match. It's amazing that in 2008 we are still having these problems.
• On the Nintendo DS, added the embedded middleware notices.
• On the PS3, added vectorized sound mixing in the hand-off to libaudio. This is one of the few tasks done on the PPU and it only uses about 1%, but, in any case, it is now about 3.5 times faster.
• Switched the PS2 example code to use GPU color conversion. This uses about half the dynamic memory during playback and doubles the amount of CPU that Bink can use for decompression. This means you can now playback much higher quality Bink movies on PS2. Since this technique is so much better, we removed the software blitters to save another 32K in code space. You can still use the old Bink library, if you don't want to update to the new technique (but there's no reason not to switch).
• Fixed a bug on the Xbox 360 and Win32, where if you were playing two videos simultaneously on one background hardware thread, only one video would be advanced.
• Fixed a bug in the DirectSound code, where long thread delays during playback would play the previous contents of the audio buffer (leading to looping audio), instead of silence.
• Fixed a bug on the Xbox 360 where you could get an XAudio 2 assert if you changed the master volume of a mono track.
• Updated the analysis window with more modern data rate target graphs.
• Added Smacker 4.2d to the RAD Video Tools.

• Made the RAD Video Tools use registry for settings, so that the 64-bit player can see the 32-bit settings.

• On the PS3, fixed a bug in the GCM example code where the SPU decompression would fail on movies that had a non-divisible-by-32 width.
• Shrunk the stack sizes on the PS3.
• Fixed a bug playing ancient Bink files on single CPU machines.

• Added support for XAudio 2 on the Xbox 360.

• On the PS3, set an error when using an aligned structure for BinkRegisterFrameBuffers (instead of just crashing).

• On the Wii and GameCube, fixed a rare problem with IO buffer alignment if you did a BinkGoto exactly while the final IO of the file was in still progress (thanks Mattias!)

• Fixed a bug in the Xbox 360 mixbin code, where volume would behave oddly.

• Fixed a bug in the PS3 SPU code when playing multiple audio tracks (5.1 or 7.1 audio).

• Fixed a silly bug in the PS3 example code where the example would crash if it couldn't find the Bink SPU elf.
• Fixed a bug in the Windows Miles integration code where stereo audio tracks might not play in the rear speakers correctly.
• Always allocate two video buffers, even if the file contains all key frames. This allows us to properly use async decompression on these file (async requires two buffers).
• Fixed a distribution problem where the latest Win64 Bink player wasn't being included in the RAD Video Tools.
• If you request alpha channel support, and the input movie doesn't have an alpha channel - we just turn off alpha in the Bink file (rather than encode an all-zero alpha plane). Also added an option to override the `no alpha channel present` warning.
• When running on Win64, the RAD Video Tools now calls the 64-bit player automatically.

• On the Nintendo DS, fixed a bug with videos that had very little data changing from frame to frame.

• Updated the documentation of BinkStartAsyncThread for SPURS tasks.
• Built the PS3 version with system software 210.

• Added pre-written SPURS task and RAW support libraries for the PS3 SPU asynchronous decompressor.

• On SPURS, allow the audio codec to be swapped out to make more room when decompressing 1080p movies.
• Wrote SIMD SPU audio decoder routines (which lowered the audio decompression time on the SPU by 25%).
• Preload a little more data on the SPU routines to get better overlap (which allowed me to shrink the overall memory footprint a bit).
• Switched a bunch of temporary buffers to the stack with alloca on Windows, Xbox 360, PS3 and SPU. This usually lets us load higher resolution movies in tight memory situations.
• Return from BinkNextFrame and BinkGoto if there is an asynchronous decompression already in progress.
• Fixed an IO buffer problem on the Wii, that would cause very small Binks to fail to load.
• In the RAD Video Tools, try using our built-in file readers for TIFF and JPEG before trying QuickTime - this is much faster.
• Improved the Xbox 360 mix bin support code, so that you can modify the speaker mix during playback.
• Switched to the November Xbox 360 SDK.
• Fixed a bug where ancient Bink files (created before January 2000) would play incorrectly on multi-CPU boxes.
• Fixed a filename length overrun when creating Bink files in very deep file paths.

• The big asynchronous decompression release! Bink now supports built-in background decompression on Windows, Xbox 360 and Sony PS3 (using SPUs). All of this is done super cleanly, it requires very few code changes, and you don't have to do any direct multi-threaded coding at all.

• Added SPU decompression support on the PS3 - Bink now takes no PPU time at all! You can play up to ten 1280x720 on the six SPUs at the same time, or up to 36 640x480 movies simultaneously! The PS3 is really fast when you can harness the SPUs.
• Added support for background decompression on Windows. All games should use threaded decompression now - it is faster even on single core CPUs (because the blitting takes place concurrently with decompression). The standalone Bink Player has also been threaded.
• Dropped the requirement to do a Sync_Bink_textures on Xbox 360, PS3, and Wii. We now do the cache flush ourselves in the codec (which is faster).
• Added some clean-up code to the Draw_Bink_textures function on Wii, so that the GX API isn't left in such a weird state.
• Added a FrameChangePercent field to the Bink structure, so you don't have to calculate it with the BinkGetRects function.
• Added some optimizations on Xbox 360, PS3 and Windows 64. Cartoon style videos are up to 15% faster.
• Added support for background decompression on the Xbox 360.
• Fixed the sound sync on PSP after resuming from a paused state.
• In creating the SPU version, cut the library code/static data size by about 20K on all platforms.
• Put more runtime temporary data on the stack - this saved about 26K of data previously allocated in BinkOpen.
• No longer allocate the delta mask plane unless you call BinkGetRects or BinkCopyToBuffer - otherwise we save another 8K or so.
• Added the total video time in the file info window.
• Show the video name in the Bink Player window.
• Added support for Miles 7.1b.
• Switched to the August Xbox 360 SDK.

• Fixed a problem in the Bink file header validation where partially compressed Bink files would be seen as corrupted. This meant you couldn't preview Bink files while they were still compressing in the front-end tool.

• Added more bulletproofing to the audio frame reader to handle additional corrupted input Bink files.
• Switched to the 1.90 PS3 SDK, and built with GCC 4.11. The new GCC is terrific - it sped up decompression on the PS3 by 10%!
• In the Bink compression tool, added an option to apply the alpha pre-multiplication before compressing. Pre-multiplied alpha gives better quality, it filters better, and it's faster - everyone should use it. Also, added an option to use pre-multiplied alpha during filtering (like resizing) and then convert back before compression.
• Updated the examples on all of the platforms to allow you to specify whether you used pre-multiplied alpha.
• Updated the PS3 GCM example to included a simple manager for mapped memory.
• On Xbox 360 and PS3, rewrote the pixel shaders to be more efficient (although the GPUs are so fast on these platforms that it doesn't matter much).
• On Windows, rewrote the 2.0 pixel shaders to be more efficient, and added an optional pixel shader 1.1 path to run on older DX8-class hardware.
• On Wii, changed the example code to take into account as much information about the Wii texture iterators as is public to minimize resampling errors when scaling a Bink video texture. It's always best to try to play the movies at 1 to 1, though, since it seems impossible to remove all possible scaled sampling errors.
• On Wii, fixed the pause feature so that it resumes the audio tracks immediately. Previously, it could take up to 700 ms for the audio to begin when you paused and then resumed audio.
• Fixed a problem in the front-end tools, where filenames in a list file had to be less than 128 characters long.

• Wrote new optimizations for Xbox 360 and PS3 that give around a 5% speed improvement.

• Fixed an overflow bug where Bink movies around the 400 MB range might be preloaded rather than streamed.
• Fixed a bug on the PS3 where a small amount of audio could be dropped at the beginning of playback if the system was under load.
• Added more bulletproofing when reading the Bink header.
• Fixed a bug on Wii and GameCube where very small files (and preloaded files) using a file offset wouldn't open.
• Added new documentation describing best practices for handling critical errors on each of our platforms.
• Made 8-bit audio tracks play on Wii, PS2, PS3, and PSP. Note that you should normally use 16-bit audio, since 8-bit input is simply scaled up to 16-bit anyway.
• Compiled the Nintendo DS SDK to allow it to be called from 32-bit or 16-bit code.
• Fixed a bug where the Windows Bink player wouldn't clear the bottom of the playback window, if the window was scaled.
• Made the File Info button show up to 256 tracks in a Bink file (it previously only showed 8).

• Fixed a bug on Windows that caused a crash on machines that have SSE, but not SSE2 (older Athlons mostly).

• Added a delay in the PSP audio shutdown to make sure the sound buffer has spun down.

• Bulletproofed the video and audio decoders against bad input file data - Bink can play right through any data corruptions now.

• Changed the frame skipping logic to handle playback at incorrect fixed frame rates more smoothly. Playing an NTSC movie on PAL device will be much nicer now, for example.
• Worked around three, count 'em, three code generation bugs with VC 2005 that were causing the RAD Video Tools to exit.
• Increased a few of the internal buffer sizes to handle super long filenames.

• Changed the default video blitter on Windows to DIBSection. DirectDraw is becoming less reliable and modern machines are more than fast enough to use DIBs.

• Fixed a very rare compression issue when compressing with alpha planes (which also improves alpha quality).
• A bunch of changes under the hood of the Bink audio compressor.
• Bink decompression could previously only open 8 tracks per Bink due to a stupid bug - you can now open 32 per movie.
• Added restrict to many of the internal decoder pointers so that RISC compilers can do a bit better optimizing.
• Added an option for pure mono out on the Wii.
• Fixed the Bink version info so that it shows up on Vista correctly.
• Added internal SSE versions of memcpy, memmove and memset on Win32.
• Put a few of the small global allocations into a fixed pool to avoid fragmentation or remnant allocations (especially for PS3).
• Updated to the PS3 1.60 SDK.
• Updated to the Xbox 360 April SDK.
• Updated to the Visual Studio 2005 on Windows.
• Updated to the Wii 2.4 patch 3 SDK.
• Renamed a few of the fft math routines to avoid conflicting with other middleware.
• Fixed a few of the example programs for the PS3 for SDK 1.60.
• Forced the first Bink frame to always be a key frame (avoids surprises if you use the compression hint window incorrectly).

• On the PS3, added GCM library example code - now you can get Bink running with a GCM based game almost immediately.

• Change the PS3 library to free the background threads when you call BinkFreeGlobals instead of when you close the last Bink file. This lets you run Bink on other threads without having to worry so much about thread shutdown deadlocks.
• Made the PS3 examples using cellFs directory functions to avoid a memory leak in the C runtime library directory functions.
• Rebuilt the library for version 2.4 of the Wii system libraries. If you are using 2.4, then you must upgrade to this version.
• Added some docs about handling the home button on the PSP.
• Fixed the DX9 pixel shader example code for Windows so that it sets the vertex declaration each frame instead of at setup time.
• Made the tools handle the maximum length Windows file names.
• Changed the way Bink handles small delays (60 to 400 ms) during playback - avoids a very rare pathological case where Bink would keep skipping frames, thinking it was lagging behind the audio.

• Fixed a very rare bug in the threaded IO provider that is used on Windows, Xbox 360, and PS3. If you are using one of these platforms, you must update.

• Fixed a problem where a mono sound track couldn't be spacialized to the back right speaker on Xbox 360. Stereo tracks worked fine.
• Fixed a problem in the simple Win32 3D example where the second frame was always skipped.
• Fixed a bug on PS3 and PSP where file IO errors weren't being detected properly, leading to a crash on media eject - updating is required.
• Updated the PS3 library and examples to the 096.002 SDK.
• Updated to the Xbox 360 September XDK build.

• Fixed a silly bug where the batch editor window wasn't popping up.

• Fixed a bug in the optional VRAM allocator in the PSP SDK (not sure if anyone actually uses this).
• Fixed a bug in the 360 SDK where pausing and resuming a Bink would put the audio tracks slightly out of phase.
• Made file IO a little more efficient on files with a data rate less than 128KBps.
• Fixed an IO problem when reading from the very end of a file that had a data rate of less than 128KBps.

• Added a new video texturing example for the Wii that uses the GPU to do color conversion (for video texturing).

• Updated the GameCube SDK to also use GPU based color conversion and removed the old software blitters (which saves a bunch of runtime memory).
• Fixed a problem where the JPEG library would infinite loop if it attempted to open some types of PNG files.
• Fixed a regression bug in the 16-bit blitters on the NDS.
• Removed the CRT library from the Bink tools and DLL on Win32 - saves about 60K in the player and DLL.
• Updated the Japanese Bink SDK manual to the latest version of the docs.

• Added a Nintendo Wii version of Bink!

• Fixed a bug when importing resized TGAs with an alpha channel.
• Changed the Windows, Mac, Xbox, 360, PS3 and PSP IO functions to stay on aligned file offsets when reading. This can make the data reading faster, since the OS doesn't have to break up each IO into multiple chunks (especially good for the Xbox and Xbox 360).

• Fixed a crash in the Bink compressor when compressing a file with an alpha channel to very low data rates.

• Fixed a bug where the X and Y offsets were being ignored when importing a file with an alpha channel.
• Fixed a rare, nasty crash in several of the RAD Video Tools when memory returned from the system was oddly aligned.
• Added PSP support for the system simple audio library (and made the example use it).
• Fixed a thread handle leak on PSP.
• Fixed the global audio buffer memory being leaked on PSP.

• Added a Sony PSP version of Bink! The PSP SDK is available immediately.

• Fixed a mutex locking bug on the PS3 that would lock if you played two movies in a row on a background thread.

• Added a Sony Playstation 3 version of Bink! The PS3 SDK is available immediately.

• Changed a D3D setup flag in the Windows 3D examples that was preventing ATI 1900 cards from rendering.
• Updated a few of the Xbox and Xbox 360 examples to play lumpy data rate movies more smoothly.
• Added details in the Bink docs about the Bink cross platform pixel shader blitting API (supplied in BinkTextures.h). This API automates pixel shader blitting on Windows, Sony PS3, Xbox, and Xbox 360.

• Added a Mac Intel version of Bink. The MacIntel SDK is available immediately, and a Bink player for Mac Intel machines can be downloaded from our website.

• Added a Win64 version of the Bink player. You can even compile to Win64 video EXEs. On Win64, playback is about 15% faster than the 32-bit version of Bink. A beta Win64 SDK is also available. Thanks to AMD for their kind support of this porting effort!

• Added new DirectX 9 pixel shader example code for Win32 and Win64. Pixel shaders are the fastest and highest quality method to display Bink videos. If you are using Bink in a 3D game on Windows, you should definitely update and use the new pixel shader example code.
• Fixed some stuttering when closing and re-opening the cover of a Nintendo DS. You must call BinkSetSoundOnOff around the close and re-open.
• Fixed the 5.1 speaker channel settings on Xbox 360 for newer versions of the XDK.
• Sped up the loading of single image series from a network drive (sometimes massively).
• Fixed a crash when using an offset to crop a series of single images that had alpha.
• Cleaned up and simplified the Windows 3D texture examples.

• Fixed a problem in the dirty rectangle calculations when the height wasn't divisible by 16.

• Added the latest version of Smacker Player in the RAD Video Tools.

• Compressor uses a slightly different error metric to help really low data rate Binks (like for NDS).

• Fixed a bug when converting QuickTime files that have internal scale factors (very rare).
• Changed the TGA detection code to avoid matching some QuickTime movie files.
• We now free a global 30K static audio buffer on the NDS when all Bink files are closed (saves 30K when Binks aren't in use).
• Worked around a deadlock problem on some DirectSound drivers when pausing or stopping a DirectSound buffer.
• Set the alpha bit on in the 5551 format on Nintendo (since they do only have alpha blitters).
• Fix a bug on some sound formats where a looping Bink file would play as static every other loop.
• Switched to the new RAD_IOP from Miles (you can now control the hardware audio directly, if you want to replace Multistream.
• Fixed a problem where specifying a sound track in a Bink file to convert to an AVI or wave file was converting the wrong track.
• Made the 3D example code on Windows and Xbox use the discard flag if all of the pixels are going to be updated (for speeding up full frame copies). This lets the D3D render a frame ahead on full frame updates.

• Fixed a channel assignment bug with stereo tracks on the Xbox 360.

• Built with latest Xbox 360 system software.

• Worked around a bug in QueryPerformance Counter on the Xbox 360.

• Don't try to check the sound format of still images which cause DirectShow to occasionally crash on importing.

• Built with final version of Xbox 360 system software.

• Added support for Miles 7 on Windows (you can now do 5.1 on Windows)! The Miles example shows how to do 5.1 with just a few code changes.
• Worked around an Xbox 360 deadlock problem when playing audio with the system audio player while a Bink is playing.
• Fixed the mix bin volume calculation on Xbox and Xbox 360, where the linear to loudness scale was being applied twice.
• Fixed a crash in BinkOpen if you ran out of memory on a little allocation that followed a larger allocation.
• Fixed a crash in the BinkGetRealTime function when run on a 1 fps movie.
• Fixed BinkShouldSkip on Bink files that don't have an audio track.
• Moved the minimum read size on Xbox and Xbox 360 up to 128K since most movies are use HD data rates.
• Fixed importing of QuickTime files that are wider than 4096 pixels.
• Fixed a crash when using a pixel offset on a still image that had an alpha plane.
• Fixed importing of still image files that are wider than 4096 pixels.
• Detect dual-core Athlons.
• Fixed the Smacker player not playing off another drive letter.

• Added support for the beta Xbox 360 hardware (June XDK).

• Fixed 8-bit audio playback on Nintendo DS - we still recommend using 16-bit audio, though.

• Added Nintendo DS support! Play Bink movies in your NDS games as easily as any other Bink platform.

• Added a new function called BinkControlCPUFeatures to turn on and off various features on different platforms.
• Fixed some pixel center bugs in the DX sample code that bilinear blending usually hid.
• Totally rewrote the entire YcRcB to RGB color conversion system. All new infrastructure, all new assembly blitters. This means almost 30% of Bink was replaced in this version.
• All new x86 blitters for MMX and non-MMX: almost twice as fast, less buggy, no more corner cases, and saved almost 200K in the Bink DLL!
• Added dithering to the 16-bit RGB color conversion blitters. 16-bit looks almost as good as 32-bit now.
• Added a new 8-bit palettized output mode. Also added a BinkGetPalette function to retrieve the global Bink palette.
• Moved a few more source files and data tables into Bink sections, so you save another 64K or so, when you unload the Bink section on Xbox.
• Changed a few of the examples to use BinkShouldSkip, so that they avoid locking a texture completely, if we are just going to skip the frame anyway.

• Added all the changes for the new Nintendo DS version.

• In the Bink player, when using the full-screen stretch parameters (/w-1 /h-1), we now maintain the aspect ratio, so the video doesn't stretch oddly.
• Fixed a bug where if you paused a Bink movie before the first frame, then Bink would think it was way behind in playback and keep struggling to catch up.
• Bumped to the March XDK for the Xbox 360.
• Fixed a bug in the Redmon next-gen console version where setting the volume could cause an assert in XAudio.
• Updated to CodeWarrior 9.4 on MacOS.

• Added new Bink for Xbox support code that allows the use of hardware pixel shaders for the YcRcB color conversion. This doubles the playback speed on an Xbox *and* uses 900 KB less memory *and* is much higher quality! Using this feature, you can now play 1280x720 HDTV movies on the Xbox!! This is such the `right thing to do` on an Xbox that it is now the default playback method - if you have old Bink for Xbox code, you should definitely update it.

• Added new Bink for Xbox examples for both normal video and alpha video pixel shader playback.
• Added a few tweaks to the Xbox 360 support.
• Fixed a silly typo that caused the pause key in the Bink player not to pause the movie.
• Made a tweak to the QuickTime audio importer. This should fix the -108 error when loading of QT audio tracks (which happens on a lot of camera movies).
• Added a option on the Linux player to not play audio. This avoids a crash in SDL on some Linux machines.
• For sound input files with a .QT or .MOV file extension, we now always try QuickTime first. This prevents broken DirectShow filters (say for MPEG splitting) from preventing QT files from converting (when they really should be read with QT anyway). We did this for video files previously, now we do it for sound too.

• Added support for this one unreleased next-gen console from a company over in Redmond (Xbox 360).

• Added BinkGetFrameBuffersInfo and BinkRegisterFrameBuffers functions. These functions allow you to allocate the Y, cR, and cB color buffers that Bink uses internally. This allows you to do a lot of cool things, like allocating the frame buffers as 8-bit luminance textures on Xbox, and then using a pixel shader to do the YcRcB to RGB conversion so that there is no blitting overhead at all (example of this coming soon)! This also allows you to share the same frame buffer memory for multiple Bink files and save memory (as long as you don't play them all at once).
• Added a BinkControlBackgroundIO function that allows you to suspend and resume the background IO that Bink performs. This makes it really easy to load other game data while a Bink is playing - you just suspend Bink when the Bink buffer is mostly full and resume it when it is mostly empty. Great for playing a movie while your game loads level data.
• Added a BinkShouldSkip function that allows you to query whether a frame or blit should be skipped. This allows you to avoid calling BinkCopyToBuffer completely to check whether you are falling behind, so you don't have to lock a texture or DDraw surface just to find out you should have skipped anyway. It's also useful when using the BinkRegisterFrameBuffers function with textures, since you will never call BinkCopyToBuffer.
• Made an adjustment to the audio encoder that makes deep bassy tones compress much better.
• Fixed a goofy bug in the 32-bit still image importer that would cause the right-most pixels to display garbage.
• Fixed a bug in the 16-bit YUV tables that caused unaligned 16-bit blits to be slightly dim.
• For input files with a .QT or .MOV file extension, we now always try QuickTime first. This prevents broken DirectShow filters (say for MJPEG files) from preventing QT files from converting (when they really should be read with QT anyway).

• Fixed a problem where the DirectShow importing code could lock up on the final frame.

• Fixed a problem importing some QuickTime sound files.
• Added a warning for long filenames with QuickTime.
• Fixed a problem with flic output when the final frame palette was different than the first palette.

• Fixed a problem on the PS2 where the system libraries occasionally fail to report a disk error. We now use an IO timeout, so after 400 ms, we will fail the read.

• Added a warning when QuickTime doesn't have all of the components available to decompress an audio track.

• DirectShow was trying to load JPEG files (presumably with the M-JPEG codec) - changed to use our internal JPEG decoder (which is way faster).

• DirectShow was trying to load GIF files - changed to use our internal GIF decoder (which is way faster) unless it is a multiframe GIF.
• Fixed a lock up with DirectShow files that don't specify an image pitch.
• Fixed a crash with DirectShow files that had a time duration of zero (which makes no sense, but whatever).

• Added a DirectShow video and audio importer - this allows us to import a bunch of new file types! We can now import AVIs larger than 2GB, MPEG 1 videos (including the audio track), MPEG 2 videos (if you have a decoder installed), WMV videos (Windows Media), ASF files, MPEG-4 video files, DV video files, MJPEG videos, and tons of compressed audio formats (MP3 and WMA in particular). Many file types that were previously decoded with QuickTime (which is really slow) are now handled by DirectShow.

• Added support for LZW-compressed GIF and TIF files (patent expired).
• Added AMD 64, AMD Opteron, SSE3, Hyperthreading, EM64T and Windows 2003 Server detection to the System Info button.
• Switched to building radutil.dll with VS 2003 which has slightly faster code generation.
• Fixed a bug when reading 48-bit TIFF files (which we only compress as 24-bit files).
• Fixed a bug in the File Info button where the fractional part of the frame rate was reported incorrectly.
• Bink now tries to refill the IO buffer when it falls under 75% of the highest one second's worth of data rate of the file. In previous versions, Bink tried to refill the IO buffer when it fell under 75% of the total IO buffer size. This change allows you to now optionally use large IO buffers without having to worry causing occasional long delays to refill it.
• You can now use the BINKNOFILLIOBUF flag in BinkCopyToBuffer to tell Bink not to refill the IO buffer when it falls under 75% of the data rate. This is useful if you are holding a system lock and you always need BinkCopyToBuffer to complete as quickly as possible.
• Bumped the Xbox stack size up to 32K.

• Fixed a bug where the the audio track would lose sync with the video if you paused and resumed the audio over and over (problem was most noticeable on Xbox and Windows).

• Fixed a bug on the Mac and GameCube where an uncommon block type was not being byte-swapped as it was loaded.

• Fixed a bug in the YUV lookup tables on the Mac, GameCube and non-MMX PC where the RGB pixels were too dim (which was most noticable when clamped pixels showed up as too bright).
• Fixed a bug in BinkGetRealTime when called on the very first frame.
• Made the input YUV converter more accurate (during compression).

• Fixed a crash in the Bink compressor on XP Service Pack 2 (SP2).

• Added some additional file I/O error checking in BinkOpen.
• Fixed a bug in the Bink for Linux where the background IO thread was taking way too much CPU.
• Fixed a bug on the Nintendo GameCube in the 64-bit divider routine that would cause sound to skip.
• Fixed a bug on the GameCube where async IO were not being cancelled when the cover was opened during BinkOpen.
• Fixed a lock up on Windows when you started playing a movie with a USB headset, but then removed it during playback.
• Moved the Bink decoder DLL base address to avoid conflicts with some XP SP2 DLLs.
• Optimized the 64-bit divider on the MacOS platforms.
• Upgraded to CodeWarrior 9.3 on MacOS.
• Fixed the Japanese documentation to show the Japanese index.

• Added a Japanese version of the Bink SDK documentation.

• Fixed a crash in BinkSoundUseDirectSound that only happened if you called it while a Bink video was still playing.

• Added a new PS2 video texturing example - check out `ExamPtex.c`.

• Fixed the PS2 docs and the examples to use a max volume of 0x7fff for the PCM channel volumes.
• Made the PS2 back buffer example DMA uploading code a little cleaner and more general purpose.
• Made the PS2 RAD_IOPStartup and RAD_IOPShutdown calls do reference counting (so you can call RAD_IOPStartup multiple times).

• Bink for Sony Playstation 2 is now available! Massively optimized to run on the PS/2, Bink now lets you use the same videos and API that you use on your other platforms! Thanks to Michael Abrash and Mike Sartain for all their hard optimization work.

• Many of the optimizations for the PS2 benefit the other platforms. Bink for the Xbox is 15% faster, for example. Bink for the GameCube is 20% faster.
• Made some build changes to fix problems when running on MacOS 10.3.
• Fixed a bug in the Linux system where playing two Binks at once would reset the system sound format.
• Removed the mono and 2X blitters from the GameCube library to make it smaller (and because you can use the graphics hardware to do these effects faster anyway).

• Added some power management code to the Bink screen saver feature.

• Added support for using Bink screen savers as input (so you can recompress them, convert to AVI or wave format, or whatever).
• Made the screen saver code never change the display resolution when in preview mode (now only changes when the screen saver officially activates).

• Bink Video EXE files can now be used as screen savers! When you make the EXE, you can choose to create a EXE or a SCR. After creating the SCR file, you simply copy it into your main Windows directory and it will be added to the list of available screen savers.

• Made the Bink player and examples use high resolution scheduling which makes most playback rates much smoother.
• Fixed a crash where turning on playback statistics on very slow movies (one frame per second or slower) would crash.
• Updated the list file processor so that it can handle series of filenames that aren't zero left-aligned (now it can handle `file8, file9, file10` and `file08, file09, file10`). To use this feature, you must highlight the longest file name (file10 in previous example).
• Fixed the DOS Smacker player so it could be compiled as an EXE.

• Fixed a bug with non-divisible by 8 widths in the 5551 surface blitter.

• Fixed a bug with non-divisible by 16 heights in the delta (non-copy all) blitter.
• Fixed a sporadic bug that could cause DirectSound not to play on NT4.

• Fixed a bug in the RAD Video Tools heap that was cause the RAD Batch window not to pop up.

• Added a Bink for GNU/Linux SDK - should work on most of the modern distributions.

• Added a Bink for GNU/Linux command line video player (uses SDL_mixer for output).
• Added an option in the Windows player to view the alpha plane of a movie.
• Renamed the memory callback function, RADSetMemory to BinkSetMemory (so that you can use Bink and Smacker in the same project.
• Added a BinkDX9SurfaceType function for DX9 games.
• Fixed a problem where a skipped frame would cause BinkGetRects to always return zero rects if you called it before BinkCopyToBufferRect.
• If you pass in inverted numbers for a series of still images for the command line tools, Bink will process them in reverse order.
• Added a few checks so that we don't detect some weird TGAs as JPEGs.

• Fixed a bug where the Bink player for Mac couldn't highlight pre-compiled EXE video files.

• Fixed a bug on the Mac in the BINKSURFACE32R and BINKSURFACE32RA YUV to RGB pixel converters where a non-divisible by 4 right edge would draw with the wrong colors.
• Fixed a bug in the Mac Classic versions of the library and player where RemoveTimeTask couldn't be found on pre-9.0 MacOS.
• Added Mach-O format Carbon dynamic libraries for building Project Builder or CodeWarrior Mach-O applications without thunking.
• Brought Bink Mac up to the latest PC source base (now uses Perforce and command line building just like the PC, so it will always stay in sync).

• Bink playback is now much smoother on medium to low-end machines running Win 9x, due to working around a multi-threaded bug in the system function, timeGetTime, that was eating up to 30% of the CPU!

• Now properly handle the window being minimized when using DirectDraw primary surface blitting in the Bink player.
• Fixed an edge bug when using BinkCopyToBufferRect with a non-divisible-by-4 width or height and a non-zero left or top offset.

• Fixed the Smack and SmackMix tools when using old format Bink audio tracks.

• We more support more dialects of TGA import files. This means we resort to QuickTime less often (which is good because QuickTime is slooow).
• Fixed an debug assert in the Xbox SDK when setting very quiet (or silent) mix bin volume levels.
• Fixed a crash when using waveOut audio output and the `play as fast as possible` frame rate option.

• Allowed the Smack and SmackMix tools to create old format Bink audio tracks.

• Increased the Bink I/O block size from 8K to 16K (since Bink videos are slowly using higher data rates).
• Fixed a setting in the Bink SDK help where the navigation tab would disappear when the focus was lost. One stupid downside is that WinHelp remembers what the setting used to be, so if you have no nagivation tab at all, then choose `Options... Show Tabs` on the menu bar.

• Fixed the accidental exclusion of the RADSetMemory function header file from the Bink SDKs.

• Made the Bink Player only ask to check for updates if it is in the same directory as the RAD Video Tools. This means that the free Bink Player can be distributed without popping up update requests.
• We now poll the DirectSound buffer positions much less frequently to handle sound drivers that report these positions slowly.
• We added a non-LTCG version of Bink for Xbox, so that `Edit and Continue` can be used again.

• Fixed a problem where our JPEG reader was detecting motion-JPEG QuickTime movies as a single frame JPEG. This had the effect of making motion-JPEG movies only appear to be one frame, so only the first frame of the movie was ever converted. We now force the use of QuickTime when the JPEG file is over 1.5 MB in size, or when the extension is .QT or .MOV.

• Fixed a bug when using the old Bink audio codec where stereo sound files would get converted to mono during compression. Note that there was no problem if you were using the new Bink audio codec (which you should be anyway).
• Fixed a bug when compiling a Smacker for DOS or Win16 video executable.
• Did the big switch over to Perforce source code control.

• Added MusyX audio output support for the GameCube SDK. This caused a few API changes on the GameCube (even for non-MusyX games) because we no longer automatically assume you are using AX. So, you must now call BinkSoundUseAX or BinkSoundUseMusyX before the first call to BinkOpen, or you won't get any sound. Also, RADSetAudioMemory has been removed (because only AX used it) - instead, you now pass in the ARAM callbacks to the BinkSoundUseAX function.

• Updated all of the GameCude examples to let them be built AX or MusyX.

• Made the lower Bink audio compression levels less lossy (the levels less than 4).

• Changed the GameCube I/O code to check the global DVD status (vs. the file status) so that errors are still reported even if other async I/O intervenes.
• Worked around buggy Windows XP sound drivers that report bogus playback positions (which was causing occasional skips).
• Switched to using QuickTime to load PNGs when compressing alpha planes.

• Fixed a problem on the GameCube where stereo audio playback was overly noisy.

• Fixed a few subtle timing issues to allow seamless audio looping.

• Added batch functionality to the RAD Video Tools! Now you can highlight a group of input files and process them all one by one.

• The RAD Video Tools now has built-in support for TGA and TIFF alpha planes (previously QuickTime was used for alpha input). Our built-in support is almost 20 times faster than QuickTime, so compressing large numbers of still images is now much, much faster!
• Fixed a bug in the DirectSound support where changing the volume could be ignored.
• Bumped up the default compression data rate to 400 kps.
• Added a warning when you ask to compress an alpha plane and the input file has no alpha plane.
• Switched to .NET for building the tools (a little faster compiled code, but the debugger is frustrating).
• Changed the sound support so that we only reset the sound system every 2 minutes of video (less popping at loop points). We also do the reset on the first frame (previously we did it on the last frame which occasionally popped).
• Moved the end of file logic in the Xbox and GameCube example source to fix a problem where playback could stop one frame early.
• Show 2 decimal places when displaying frame rates in the RAD Video Tools.
• We now free the 2x height doubled YUV scanline buffers in BinkClose (vs. shutdown in previous versions). This only saves about 1500 bytes, but it helps with fragmentation.
• Changed the GameCube SDK to account for the slightly faster rate that the NGC DSP really runs at. Fixes sync problems with longer movies on the GameCube.
• Changed the Xbox and PC SDK to allocate the sound sample buffer on the stack - saves 16K of global memory.
• Now build the Xbox library using VC7's link time code generation. This will generate both faster and smaller code. The file size of the library is large because the linker does the compilation - the link size in bytes will be 10K to 50K smaller.

• Updated the sound code for the Miles Sound System to work with Miles 6.5.

• Updated the sound code for DirectSound to be loudness based (vs. amplitude based).
• Updated the Nintendo GameCube examples to work with Patch 3.

• Fixed a no-volume problem when using the latest GameCube audio libraries.

• Made BinkOpen use async reads on the GameCube to avoid lock ups when opening the door at the wrong time.

• Re-enabled the BinkDX8SurfaceType function on the Xbox.

• Fixed the GameCube not playing some soundtracks.

• Fixed two ugly bugs on the GameCube when closing a Bink file.
• Fixed an periodic clicking on the GameCube with some audio sample rates.
• Fixed the little glitch of audio when playing 8-bit data on the GameCube.

• Fixed a crash when compressing some audio files.

• Fixed a bug when compressing or mixing using the old Bink audio compressor.

• Fixed a debug message that displayed while compressing.

• Fixed a few linker errors on GameCube when using CodeWarrior.

• Worked around a compiler bug that could cause the Bink compressor to crash on some input files.

• Added the BinkCopyToBufferRect function to the Bink SDK. This function allows you to partially copy a Bink frame to another buffer. You can draw with tiled Direct3D textures much faster with this function.

• Updated the DX8 and DX7 example programs to use the BinkCopyToBufferRect function.
• Changed the RAD 3D wrapper API slightly on PC to handle direct locking of tiled textures. You now need to call Lock_RAD_3D_image in a loop to obtain each buffer pointer to copy into. See ExamAlph.c for the updated example.
• Released a new Carbon version of the Mac player (compatible with MacOS X and 9)!
• Fixed a false positive condition when writing out an AVI that could cause the 'Windows has crashed' message to appear when everything was fine.
• Updated the Mac version to the latest codebase.
• Fixed an offset bug on the Mac in BinkBufferLock when running on certain multi-monitor configurations.
• Switched to an all new internal task sharing model on the Mac - replaces all the cooperative thread stuff with timers and critical sections. Much better IO and sound performance (fixes the MacOS X multi-CPU sound skips).
• On MacOS X, switched to using normal IO on a background thread instead of async IO.
• Fixed a few bugs on the GameCube when playing videos with no sound.
• Fixed the mixer to accept lossy levels greater than 100 (to specify the old Bink encoder format).
• Fixed the delay when using BinkGoto on a video without sound.

• Added an all new Bink audio encoder! Sounds much better and can compress up to half the old data rate!

• Added crash protection around all calls to Windows or QuickTime - we should now withstand crashes in buggy 3rd party codecs. The specific frame that was being decompressed will be blank, but the rest of the movie should survive.
• Added several new Xbox SDK examples showing overlay and back buffer support. Overlays are really cool - they are definitely the best way to play most videos on the Xbox.
• Added YUY2 blitting support to the Xbox SDK - this allows the Xbox hardware to do the YUV to RGB conversion (which is usually much faster). Most of the examples now use YUY2 as the default texture format.
• Added support for 3D Studio Max's RLA file format. This format supports RGB, alpha, Z-depth info, UV-coordinates, and normals - all per pixel! This lets you do some amazing post-process stuff with video that you'd swear couldn't be pre-rendered. We'll put up some demos of this soon!
• Added lots of new configuration detection to the System Info button in the RAD Video Tools (Duron, P4, Celeron, Itanium, Me, 2000, XP, video card, audio card, memory, and disk space).
• Detect larger than 2 GB AVI files and warn the user that they are not supported by the Windows reader.

• Released the all new Nintendo GameCube support! The platforms keep coming!

• Fixed a stupid memory leak in BinkOpen - everyone using 1.2i should upgrade.
• Rewrote BinkGoto completely - you can now jump directly to a frame and the sound will begin immediately (vs. the old 750 millisecond silence delay).
• Added new Direct3D 8 example texture support code. Includes support for dynamic and non-power of 2 textures (both of which can improve playback dramatically).

• Detected when DirectDraw can't lock the primary surface and switch to DIBSections. This fixes the problem with blank video windows on XP or when NetMeeting was running.

• Fixed a rare deadlock problem when a movie would loop (or when you called BinkSetSoundOnOff).
• Fixed a data overrun that could cause pauses when playing a movie that had no sound.
• Made BinkGoto start the audio from the `gone-to` frame instead of whatever filled up the sound buffer first.
• Fixed BinkGoto to not unpause the movie if it was previously paused.
• Removed Windows.h from the Bink header file (for faster compilation).

• Made the default mix bins on the Xbox to be all speakers (instead of the normal Xbox default of just the front-left and front-right speakers).

• Switched to the November Xbox SDK which required slightly changing the BinkSetMixBins and BinkSetMixBinVolumes functions.

• Fixed a silly regression bug where videos without audio would play with the wrong frame rate.

• Bink can now play multiple sound tracks at once. This means that the BinkSetSoundTrack function now takes an array of track IDs to play instead of a single value. Also, the BINKNOSOUND constant has been removed - to play without any sound, pass a zero for the track count in BinkSetSoundTrack.

• Added example code in ExamXbox.cpp that shows how to play 5.1 audio on an Xbox.
• Added the BinkSetMixBinVolumes function to adjust the mix bin volumes individually on the Xbox.
• BinkSetVolume, BinkSetPan, BinkSetMixBins functions all now take a track ID to control which sound track is changed.
• Worked around a DirectSound bug on the Xbox where the audio tracks sometimes wouldn't start. If we notice the sound positions aren't updating, we restart the audio track.

• Fixed a bug in the Miles sound module where sound wouldn't restart after a skip.

• Worked around a nasty bug in the Xbox system software where the machine can occasionally get in a state where QueryPerformanceCounter actually runs backwards.

• Fixed a bug where Bink wouldn't play the audio track of very short videos (the entire video had to be less than 250 milliseconds long).

• Put all of Bink in separate sections, so that it can be loaded and unloaded on an Xbox. Use the new BinkUnload and BinkUnloadConverters to manage Bink's sections.

• Set the headroom on the Bink DirectSound buffer to zero (the default is too quiet on the Xbox).
• Added a new BinkSetMixBins function to allow the management of Xbox mix bin destination buffers.

• Huge quality improvements on videos with color gradiants, washes, or fades as a result of cleaning up noise contamination all the way through the Bink pixel pipeline. In some cases, equivalent quality can be obtained at 1/4 the bandwidth! If you need highest possible quality, we recommend recompressing all your Bink videos. The only downside is that video compression time is longer when using super-high data rates (which you may not need any more). These improvements aren't hype - the quality difference is amazing in most cases!

• Added a new denoising video filter (which is now rarely necessary with the new quality improvements).
• Fixed a front-end problem in the video converter where half-toning was being applied if you selected `half-tone always` in the 256-color section.

• Worked around an Xbox DirectSound bug that caused movies to skip or slip out of synch at the start of a movie.

• Fixed a bug that caused Bink's DirectSound code to take lock the DirectSound buffer too frequently.
• Bink for Xbox now allocates it's sound buffer from the RAD memory allocation functions.
• Bink's threads now use 12K of stack space instead of the executable default. This can save a fair amount of memory on the Xbox.
• Added a workaround in the Bink timer code for buggy motherboards that advance the QueryPerformanceCounter incorrectly under heavy loads.

• Added new QuickTime importing code to support the video track of MPEG and Flash movies. QuickTime doesn't support audio exporting from either of these file types yet, unfortunately.

• Added new QuickTime importing code to support AVIs that Windows can't open (like DV formatted AVIs).
• Switched to the July version of the Xbox SDK.

• Fixed bug when opening a Bink file with multi-threaded I/O turned off. This caused several of the tools to lock up when processing Bink files as input files.

• Added new audio encoder that provides much higher quality sound on deep tones (may still have to use 0 lossy level on some files, though).

• Rewritten DirectSound layer - much more tolerant of CPU starvation. Also worked around buggy SBLive drivers that would cause periodic skipping under Windows 2000.
• All new threading model - instead of one thread per open Bink, there are simply two global threads for all open Bink files. Also fixed a few very rare thread deadlocks on multi-CPU machines (typically exhibited after more than 12 hours of looped playback).
• Built with new beta versions of the Xbox system software - fixes crash in BinkOpen on beta 1 and 2 Xbox hardware.
• Fixed compression of unusual AVIs where the video stream format doesn't match the file format (usually seen in Debabilizer AVI files).
• Fixed a bug compressing unusual QuickTime movies where the audio started at a non-zero offset.
• Improved the Bink I/O system to give better playback when playing files that are very close to the data rate limit of the playback device.
• Added a new BinkDX8SurfaceType function that returns the type of a DirectX 8 surface.

• First release of the Bink SDK for Xbox! Use Bink files on the Xbox!

• Fixed a several precision issues in the front-end tools that caused a variety of odd problems when working with very long video files.
• Updated the 3D example files to support scaling the video while blitting.
• Fixed a thread deadlock when running under Windows 98 and another background application was pounding on the DirectSound device.
• Fixed a bug on the Mac when using the BINKSURFACE32A surface type.

• All Bink example files have been rewritten - much cleaner and easier to understand.

• The example programs for performing alpha on OpenGL or Direct3D have been merged into one file (ExamAlph.C). The example now uses a simple wrapper API to both OpenGL (GLRAD3D.C) and Direct3D (D3DRAD3D.CPP).
• Added a Carbon version of the Bink library for MacOS X.
• Made the Bink Mac player show double-clicked or dropped files from the Finder.
• Fixed a few bugs in the video resizer - should look better when using small resize ratios (like resizing a 320x240 video to 352x256, for example).
• Fixed a bug in the video smoother where small artifacts could appear.
• Allow more video files to be added to a single compiled executable.
• Fixed a bug where bi-linear filtering was forced on when compressing an alpha plane.
• When adding three or more files to a list file, the files are sorted as they are placed into the list.
• List files now store complete pathnames internally, so you can copy them to other locations and the list file will still work.

• Fixed a silly bug in the still image importer where the frame range was used incorrectly.

• Fixed a bug in Smacker's lossless mode where it wasn't lossless if the input file had a very high data rate.

• Fixed a bug when using a list file containing a series of still images with local start and end frame offsets.
• Fixed a display bug in file information window where large file sizes could be displayed as negative numbers.
• Switched to the new RAD make tool - very cool.

• Added video resizing! You can now shrink or zooming during compression or conversion. We use bi-cubic interpolation for extremely high quality scaling.

• Added a bunch of digital video filters for use during compression and conversion - contrast, smoothing, brightness, clamp to black, gamma correction, and video de-interlacing are all now available!
• Fixed a subtle bug in the QuickTime importer where the first frame was sometimes duplicated.
• Added new 256-color small and large icons for Bink and Smacker.
• Added a workaround to a SBLive driver bug that was causing waveOut mode not to work under Win98.
• Fixed some thread contention problems that were causing audio decompression to take a bit more CPU than necessary.
• Fixed the non-client area not being redrawn in the players after a window resize under Win2K.
• Changed a few variable names in RAD.H to avoid conflicts with AMD's 3DNow header file.
• Fixed a bug where a list file containing files with different original frame rates would wrap around if an adjusted frame rate was used on the list file.

• Made the player periodically ask to check for updates (since many users just double-click in Explorer and never run the tools).

• Fixed a stupid bug where Bink videos without sound would play as fast possible.

• Sped up the decompressor by 12% on Mac and 5% on PC.

• Fixed a audio problem on the Mac where audio playback was noisy.
• An error is now shown when the audio track of a locked QuickTime file is opened (rather than just converting silence).
• When executing an internal video utility and the control key is held down, we now put the command onto the clipboard (this makes it easy to copy the command line into a batch file).
• An hourglass is displayed when reading long series of image files.
• Fixed a bug where the wrong window style was used in the Bink player.
• Fixed a goofy bug where BinkSetSoundOnOff only allowed zero or one (vs. zero or non-zero).

• Fixed a subtle aliasing error when using the 'adjust to frame rate' option with non-integral multiples.

• Fixed a bug where the alpha plane of an imported Bink file was ignored.
• Fixed a bug where the alpha plane of a TGA file was ignored if you imported the file as one of a series of still images.
• Switched to a new EXE compressor (UPX) under Win32 that gets better compression and that should be more widely compatible.

• Switched to the real FFT instead of the complex FFT which can double audio decompression performance on some CPUs!

• Made the RAD Video Tools must better at detecting series of numbered files.

• Compiled EXE Bink and Smacker files can now be used by most of the tools - you can convert them into AVIs, recompress them, remix audio from them, click on advanced play to change the built-in playback settings, etc.

• You can now use the Bink and Smacker sound mixers to remove an audio track - just use '-' for the sound filename to mix.
• The Mac player can now play PC EXE compiled videos - just highlight EXE file and hit Play!
• Video playback is now centered by default on the Mac.
• The background screen is cleared to black by default on the Mac.
• Added options to not clear the background screen and to hide the mouse during playback on the Mac.
• The Smacker player can now hide the mouse cursor during playback.
• Fixed crash when encountering a file IO error (such as the CD being ejected during playback) on both PC and Mac.
• Fixed an offset bug when using negative X offsets in the RAD graphics file importer when outputting true-color files.
• Added the new RADSetMemory function that allows you to replace Bink's or Smacker's memory allocation and freeing routines on both PC and Mac.

• Switched to a faster FFT routine (speeds up audio decompression).

• Fixed BinkCopyToBuffer to return a 1, if the blit was skipped.
• Exported the BinkSetIO function correctly.
• Fixed a wrap around bug when converting long wave files with the Bink converter.

• Fixed some surface byte ordering issues on MacOS - BINKSURFACE32 is now the correct format for the MacOS desktop.

• Fixed a millisecond overflow problem on MacOS.
• Buffer more sound data on MacOS - should give smoother playback.
• Use less aggressive frame skipping on both PC and Mac.
• Fixed a bug in the Bink IO speed simulator.
• Fixed a crash when importing a Smacker file with Bink audio.
• Added waveOut support to Bink - it can now run completely without DirectX.

• First version of Bink for Mac! The full Bink SDK and player is now available for MacOS!

• Fixed a bug when pausing a video before a single frame had been decompressed.

• Added three new display color depth options to the Bink player - `at least high-color` (tries 16-bit, then 32-bit, and then 24-bit), `try true-color` (tries 32-bit, then 24-bit, and then 16-bit), and `true-color only` (tries 32-bit, and then tries 24-bit).

• Checks the actual bit depth set after a call to ChangeDisplaySettings to work around a bug in the NVidia drivers.
• Bink player doesn't decompress sound that is going to be skipped when playing in `as fast as possible` mode.
• Fixed a bug in the 5551 merged alpha blitters.
• Added two Bink alpha plane playback examples - DXALPHA.CPP for Direct3D and GLALPHA.C for OpenGL.
• First version of Smacker 4.0 for the Mac! PowerPC and 68K are both supported (you should avoid using Bink audio in Smacker files that will be played on 68K machines, though).
• Fixed a bug in the Smacker encoder where files compressed with Bink audio tracks would be aligned incorrectly. This led to too slow Smacker files on the PC and unplayable files on the Mac. You have to recompress the Smacker file to fix the problem, though.
• Renamed the SmackTimerRead function to RADTimerRead and switched to using QueryPerformanceCounter (from timeGetTime) on Win32 - should make movies play a little more smoothly on Windows NT and 2000.
• Fixed a bug in the SmackGetRects function where an extra bogus rectangle would be returned on a frame where a palette change occurred, but no pixels changed.
• In the Smacker player and SDK, broke out the time spent in the audio and video decoders into separate values.
• Fixed a bug in the Smacker player that cause an extra millisecond of sleep for every frame.
• Fixed a bug where the Bink encoder wouldn't read the alpha channel out of an input Bink file.
• Fixed a crash in the Mac SmackBuffer API when a NULL rectangle was passing to SmackBufferBlit.
• You can now override settings on the command line with a remove switch. For example, if you run `BinkPlay test /L`, you can tell Bink to ignore the loop switch with `BinkPlay test /L /-L`. The `slash-minus-L` tells Bink to skip the earlier L switch. This is mostly useful for overriding the switches that are compiled into a self-playing Bink or Smacker file.

• Under NT, sped up mixing time dramatically by flushing the file less often.

• Fixed a problem where a user-specified DirectSound object could cause audio not to play.
• Fixed a bug in the Smacker mixer where forcing a frame rate would cause the audio to be mixed incorrectly.

• Added multi-CPU support to the Bink compressor! Compression scales close to linearly with multiple CPUs - twice as fast for two CPUs, four times as fast for four CPUs, etc.

• Added reversed order blitters (BINKSURFACE24R and BINKSURFACE32R). These are convenient under OpenGL where the reversed byte path is more optimized.
• Added merging alpha blitters (BINKSURFACE32A, BINKSURFACE32RA, and BINKSURFACE4444). These are used with Bink files that are compressed with an alpha plane to get the merged formats commonly used by the 3D APIs.
• Added the new online documentation system (with the system that Casey created for Granny).
• Fixed a bug in the BinkBuffer API where the YUV formats were never tried if the DIBSection blitter failed.

• Made the Bink compressor up to 25% faster with better video quality.

• Made the core Bink decompressor about 12% faster on all CPUs.
• Made the decompressor another 5% faster if you recompress your Bink files.
• When compressing with alpha, we now use QuickTime to load the files first (which lets us read the alpha planes out of most files - including TGAs).
• Fixed a few bugs in the alpha plane compressor and decompressor.
• Switched to a new internal frame format as a precursor to multi-CPU (SMP) decompression.
• Merged the Bink for PC and Mac into one code base (for the upcoming Mac release).
• Fixed a crash in the Bink DLL when shutting down under NT 4.
• Made the Bink and Smacker players for Win32 take longer lists of filenames (up to 50 files can now be compiled into an EXE).

• Worked around a Windows buffer limit that was causing doubled-clicked files in the RAD Video Tools not to play.

• Fixed a potential crash when decompressing alpha plane data.

• Fixed a bug in the QuickTime sound importer - there should be no more glitches with compressed MOV soundtracks, MP3 files or other compressed wave files.

• Fixed the Bink converter using the wrong value when displaying percent complete during a sound file conversion.
• Fixed some YUV conversion problems when using non-zero offsets to the BinkCopyToBuffer function.
• Sped up mono 2x blitting on non-MMX CPUs.
• Fixed a bug where DirectDraw was still required even when using DIBSections.
• Fixed a bug in the standalone player where the DirectSound object was deadlocking when being released under NT 4 at shutdown time.
• Fixed some bugs in the measuring of total read time (and added reporting of idle reading time and background thread reading time in both the summary and the real time statistics).
• Fixed a bug when simulating a device speed where the device speed was overestimated.
• Made the list file button handle lists as large as Windows itself can handle.
• Made the list file button much faster when used with huge lists of files.
• Made the file info button display the true color depth of an AVI file (8, 16, 24, or 32 instead of always 8 or 24).

• Sped up mono blitting on non-MMX CPUs.

• Fixed a bug in the YUY2 and UYVY 2X stretchers.

• Added 2x height, 2x width, and 2x width and height stretching software blitters - up to four times faster than Windows.

• Added scaling compression support for 2x height, 2x width, and 2x width and height.
• Fixed the Bink colorspace conversion to match YUV hardware exactly (Bink videos should look identical whether displayed with the hardware or our optimized software blitters now). This also had the nice side effect of making videos with lots of reddish hues compress better.
• Added much faster blitter support for non-aligned destination memory addresses.
• Made the Bink compressor display more information when loading lists and runs of files.
• Fixed a bug in the Smacker player for DOS when playing new Smacker 4.0 files.
• Fixed a bug in the Smacker player for DOS when playing an audio track compressed with the Bink audio codec.
• Fixed edge support for mono and 2x blitters.
• Fixed a bug in both the Bink and Smacker compressors, where the start sound offset would be wrong if you adjusted the output frame rate.
• Fixed a bug where the Bink player would wait the first frame's time before beginning playback.
• Fixed a bug in the Bink player where the final frame wasn't displayed long enough.

• Bink compression is now twice as fast! Compress your movies in half the time.

• Bink player now shares the CPU much more nicely.
• Added video smoothing and contrast control to the Bink compressor (usually makes a huge difference in video quality).
• Smacker has been upgraded to version 4.0 and has been fully integrated.
• New Smacker 4.0 compression - double the quality of your Smacker movies!
• Smacker 4.0 now includes optional Bink audio compression. You can now use Bink's perceptually-lossless 8 to 1 audio compressor.
• Smacker 4.0 player now shares the CPU much more nicely.
• Smacker 4.0 player now correctly shows the logo if the movie was paused.
• Smacker 4.0 DOS player now uses Miles 6.0 (smaller compiled DOS EXEs).
• Smacker 4.0 uses the Bink bandwidth allocation routines to intelligently reallocate bandwidth to the frames that need it most.
• Added a SmackGetKeyFrame function to the Smacker 4.0 SDK.
• The analyze window now tags key frames in Bink and Smacker 4 files.
• Added an always-on-top option to both the Bink and Smacker players.
• The Bink compressor can now compress to grayscale-only Bink files.
• Added an option for the Bink compressor to compress the alpha plane of the input file (only Bink SDK users can access the alpha plane currently).
• Made window alignment dependent on pixel size (rather than always 4) in Bink.
• Made the compressors, converter, and mixers front-ends more consistent.
• Bink video window isn't cleared to black before playback begins.
• Fixed a nasty bug in the masking YUV blitter that would cause some unusual frames not to be completely copied (leaving little artifacts behind).
• Fixed a crash when looping short Bink movies.
• Fixed a bug in the Bink converter when converting RAW sound files into wave files.
• Fixed a bug in Bink where the first frame would be skipped after a go to or a loop around (which also fixed a weird problem when Smacking a Bink file).

• Added new YUV to RGB blitters specifically for video memory - up to 100% faster when converting directly into video memory.

• Fixed a memory leak in BinkClose.
• Fixed a bug when playing multiple files when using the fill-screen-to-black option.

• Added a grayscale blitting mode (much faster - useful on slow machines).

• Further tweaked the frame skipping logic for slower machines.
• Made the DIBSection blitter chosen before the overlay and off-screen surfaces (should be more compatible).

• Made sound synchronization much more accurate after a frame skip or a pause - we should recover from frame skips on low end machines much cleaner now.

• Fixed a problem with videos stopping with the SDK when using Miles.

• Further optimized the 24-bit and 32-bit non-MMX blitting routines.

• Fixed the background of the Bink Tools dialog boxes under NT.
• Fixed a bug with compiled EXE Bink files not playing under NT.

• Added DIB Section support for non-DirectX blitting.

• Changed DirectDraw off-screen system blitter to check the DirectDraw scale flags to see if it supported stretching.
• Added new non-MMX 16-bit, 24-bit, and 32-bit blitters that are all much faster on Pentium Pros.
• Added additional optimized data alignment paths in the 16-bit non-MMX blitters.
• Fixed a bug in the sound mixer where key frame markers would be lost.
• Fixed a bug in the compressor where the hint file frame numbers were off by one.
• Added a switch (/C) to hide the Windows mouse cursor inside the Bink window.

• Fixed a stupid, but pesky audio mixing bug where the `mix at what frame` setting could be ignored.

• Fixed a sporadic crash when compressing file with more than 50000 frames.
• Fixed a bug where the left edge of the desktop could peek through when using the `clear screen to black` setting.
• Fixed a bug in the SDK when BinkCopyToBuffer wouldn't work inside when the Bink file was paused.

• Added a new P5-scheduled version of the 24-bit RGB blitter.

• Fixed bug when canceling a Bink compression, but keeping the existing frames.
• Fixed a bug when skipping into a Bink file inside a list file.

• Fixed a goofy bug in the Bink player that causes video EXE files not to use the embedded options.

• Added Compile to EXE support for both Bink and Smacker files.

• Adjusted the Bink data rate algorithms to minimize periodic data spikes and data drop outs. It's usually worthwhile to recompress your videos.
• Added peak data rate control in the Bink compressor - this allows you to keep the peak rates under control when applying bandwidth reallocation.
• You can now highlight and play multiple files at once (both in quick mode and advanced).
• Added a View button to the Bink and Smacker mixers.
• The players now also adjust the sound playback rate when playing back at a forced frame rate. This keeps the audio in sync on forced frame rates.
• Added new optimized MMX 24-bit and 32-bit blitters - up to 50% faster blitting in these modes.
• Added a periodic reminder to check for a new Bink version.

• Add detection for the AMD Athlon processor (which is pretty awesome, by the way).

• Fixed a stupid bug when playing Bink or Smacker files from the front-end that had spaces in the filename.
• Fixed a bug when pressing Escape while the video was paused.

• Made the front-end always call the Bink and Smacker players directly.

• Fixed the Bink player credits window with playing in 320x200 or 320x240 mode.
• Fixed a crash in the player when trying to play a non-Smacker file.

• Fixed a DirectDraw related bug where the video frames would never be displayed if full screen mode was requested.

• Split out video decompression time and audio decompression time in the runtime and summary info.

• Added separate `Advanced play` windows for Bink and Smacker.

• Added a button to check for the latest version of the RAD Video Tools.
• Added the Video Analysis window to the Bink Tools.
• Fixed looping so that the movie would remain in sync.
• Added the BinkSetSoundOnOff command to the SDK.
• Added the Smacker Player and Smacker Mixer to the front-end (just the compressor to go).
• Wrote and implemented the new Bink help system.
• Much faster (up to twice as fast) 16-bit RGB blitting on MMX machines.
• Fixed a bug where the background I/O task would consume too much CPU time when the movie was done streaming (or close to done streaming).
• Added the BinkBufferSetDDPrimary function call to the SDK to allow BinkBuffers to be used with full-screen DirectDraw applications.
• Fixed an end-of-movie sound glitch when using DirectSound.

• Added the Bink converter which replaces the Graphics and Sound Processor in Smacker.

• The Bink converter can now convert video *and* audio at the same time - allowing direct conversions from Bink or QuickTime into AVIs.
• Fixed a threading crash if rapidly opening and closing Bink files.
• Fixed the importing of 16-bit BMP files.
• Added importing and exporting of PNG files.
• Fixed monotonous multiple prompting for series of files when creating a list when a run of files are selected.

• Added a frame rate adjustment feature. Unlike the existing frame rate changer, this feature will add or remove frames to maintain your specified frame rate. So, if you have a 15 fps animation and you adjust it to 30 fps, then every frame will be copied twice.

• Added decoding of Bink audio tracks to the utilities (you can now Bink or Smack a Bink file). This allows you to archive your videos in much, much less space than uncompressed AVIs (just use a really high data rate for archival purposes, say 2000000).

• Fixed an overwrite bug when compressing small resolution videos.

• Added the Bink SDK manual and cleaned up a few problems in the SDK.

• Fixed a bug when playing under NT close to the max data rate of the device.

• Fixed a nasty overflow in the data rate parameters which could cause the data rate to grow linearly during a compression. If the data rate of your movies seems too high, then you probably ran into this bug.

• Smoothed playback somewhat for movies that are playing very close to the maximum data rate of the playback device.

• Added much better background IO routines - can approach 100% background IO even on Windows 95/98.

• Made audio decompression much faster.
• Added better frame skipping techniques.
• Improved Bink compression speed somewhat.
• Added a new redistributable Bink player (with no RAD credits) for licensing.

• Added a list file editor.

• Fixed a bug when Binking a wave file.
• Can detect pretty much any type of CPU now (used the Scitech code).

• Rebuilt the Bink installation program to include the mixer.

• The first version of Bink for general testing is released (Bink Release Candidate 1)!

• File format changed from earlier betas, this came with an almost 2x quality improvement however - especially on low-bandwidth materials.
• Codec technology is completely finished - tools still need minor polishing, including the integration of Smacker.
• This version of Bink requires DirectX to be installed.

Bink 2.5p/1.100p E-mail bink3@radgametools.com for technical support. Copyright © 1994-2016 by RAD Game Tools, Inc. All Rights Reserved.