CHANGES
OIIO_RESTRICT macro for restricted pointers.

Use on function declarations like this:

    void add1 (float* OIIO_RESTRICT A, const float* OIIO_RESTRICT B)
    {
        A[0] = B[0] + 1.0f;
        A[1] = B[1] + 1.0f;
    }

This means "A and B will never point to the same memory in a way that
could create a data dependency". Without this, it could be that B[1] is
the same memory as A[0], which means that the first line MUST execute
prior to the second in order to be correct, whereas if it knew A and B
would point to distinct memory (or at least would never interfere), the
compiler could be more creative with optimizations because those lines
could be rearranged or run in parallel.

Use with extreme caution!
Basic SIMD support in the form of float4, int4, and mask4 classes
that take advantage of SSE if available.

This is a first stab at it, and will be augmented in the future
with additional functionality, additional architectures (AVX and Neon
come to mind), etc. But this is enough to get started.
make/CMake support for SIMD building modes (e.g. 'make USE_SIMD=sse4.1')
ImageBuf and ImageCache: pad buffers by an extra SIMD width so that SIMD
reads don't overstep the allocation sizes.
SIMD instruction speedups for texture lookups

This is a big overhaul of the internals of TextureSystem to make as much
as possible use SSE (and in future updates, other SIMD instruction
sets).  We're seeing 30-60% reduction in time of the texture lookups
themselves, depending on the SSE compatibility level, number of channels
looked up, whether texture derivatives are requested, etc.  Call it
close to a 2x speedup in general. But of course, how much this will
translate into speedup of an app using TextureSystem will depend a lot
on the original percentage of the runtime of the app that was spent
doing the texture math.

This is a first stab, there is more to return to in the future. For
example, we have only SSE-optimized texture(), but really not
texture3d() or environment(). There's probably even more we can squeeze
out of texture() if we try.
Overhaul TextureSystem API -- eliminate nchannels and deriv fields from
TextureOpt, in favor of passing them explicitly to the various texture
API functions. This is all in support of the SIMD internals changes.
Enhance handling > 4 chans by saving and restoring options.firstchannel.
Bump SPI minimal SSE level to 4.1 on spinux, 4.2 on OSX
Bump version with SIMD
Merge pull request #948 from lgritz/lg-simd

TextureSystem speedups via SIMD instructions
CHANGES
Fix compile break for no-SSE case
SIMD fixes for some compilers

This is just a guess, but it looks like maybe some people's compilers
are having trouble with the implicit conversion of int4 to _m128i. In
several places, I relied on the conversion, so this just changes those
spots to be explicit about it.
Big reorg of fmath.h.

* Some things (like understanding the endianness of the platform) have
  moved to platform.h.

* The stuff particular to supplying things that should be in math.h
  or stdint.h, but aren't on some platforms, has all been moved to
  a new header, missing_math.h.

* Tons of safe_blah (clamped input range) and fast_blah (approximate but
  must faster) have been added, copied from a recent addition to
  Open Shading Language (OSL).

* Moved a whole bunch of stuff around the file to give it some kind of
  sane overall organization.
Use fast_math in aniso texture calculations for speedup.
Improvements to fast_math functions

 * Improved approximation for erf
 * Add approximate ierf (inverse erf)
 * Improve range reduction for fast_sin/cos/tan when SSE4.1 or higher is enabled
 * Add some more comments on fast_sinpi
Add maketx option to sharpen as we create MIP levels.

The idea is that production sometimes thinks the filtered textures look
a little too blurry and washed out (even though we know that they're
filtered almost exactly right). So with this, we optionally do a
sharpening step (via unsharp_mask) as we create MIP levels. This gooses
the high-frequency detail just a bit.  Example command line:

  maketx input.exr -sharpen 0.5 -filter unsharp-median -o texture.exr

Play with the sharpening amount (I like somewhere between 0.25 and 0.5)
and with whether you use the unsharp-median or (by leaving out the
-filter or setting it to an ordinary name like "lanczos3") whether you
use the usual Gaussian-based unsharp mask

This is all experimental! Use at your own risk.
Fix typo in recent maketx change
CHANGES