We use polymorphic exception objects, so catching by value invokes
the copy constructor and stuff that we don't really want.

Bit shifting gives an approximate, but not properly accurate value
when upconverting. Do a proper calculation.

We won't always be on the primary monitor, so check which color space
we're actually using right now. For offscreen stuff we assume a standard
sRGB color space.

This will allow us to use better formats that preserve the entire
alpha channel.

Some platforms draw directly to the screen, which means that updates
will flicker if we draw multiple layers. Prevent this by first
composing the update on a hidden surface.

This will allow us to render more things than just the framebuffer.

Some platforms impose a significant delay per frame, so we need
to separate that from the time spent shuffling pixels.

The complex logic waiting for events didn't result in any added
performance, so use the simpler approach.

This is based on comparing CPU time with elapsed time, which means
that the tests can be heavily influenced by other load on the test
machine.

We need more callbacks for correct operation of multi-threaded
rect decoding.

Done in preparation for multi-core decoding. Keeps the complexity
out of the other classes. This also moves ownership of the
framebuffer in to CConnection. It's the CConnection object that is
aware of the threads and how to synchronise with them. Therefore
the ownership of the framebuffer must also be there to make sure
it isn't deleted whilst threads are working.

Time spent executing in the kernel is as much of a performance problem
as time spent in userspace. Make sure both numbers are included.

It doesn't really make sense anymore given that settings might come
from the GUI or configuration and not only the command line.

Either by casting, or switching to a more appropriate type
for the variable.

This prevents unhandled exceptions if the file isn't found.

For 16-bit and 8-bit datasets, you can now run encperf with an argument of
-translate=0 to benchmark just the encoder without converting the datasets to
24-bit.  This allows the output of encperf to be directly compared with that
of the TurboVNC Benchmark Tools.

GCC lets this slide, but other compilers (clang) complain about using % rather
than %% to print a literal % character.

Explicitly add the compression level to the list of encodings so it's obvious
how to override it.

Report encoded and raw-equivalent bytes as well as compression ratio (I like
to have these statistics so I can compute overall compression ratios for
groups of datasets in a spreadsheet.)

Code formatting tweaks to improve readability & make the code consistent with
the rest of TigerVNC

We want to have other tests related to pixel conversion, so avoid
possible naming conflicts.

There is nothing using these classes anymore, so remove the clutter.

This is a lot easier and cheaper than having to set up a complete
PixelTransformer object.

Gets rid of a loooot of code and complexity.

Colour map clients are still supported through an
automatically generated map, but we lose the ability to
develop a client or server that uses colour maps
internally.

Add a tests directory where we can put tests programs that can
be useful during testing. Start with a speed test for the pixel
conversion routines.