[3D] Support switching to 3D resolutions

Include matching 3D flags (SBS/TAB) in the score of a resolution to switch to, to enable switching to 3d modes.
Also remove the old code that treated 3D modes differently when assigning a score.

I've also added a small weight to higher multiples of the desired framerate, so if display supports 30, 60 and 120Hz
and the video is 30fps then 30 will now be chosen rather than 120. This reduces the overhead of rendering the gui.
[confluence] Use animated gif as a cheaper working spinner
[rbp/omxplayer] Do we need discontinuity handling?

So far I've not seen what this is needed for and it does cause problems for some files.
[rbp/omxplayer] Cosmetics
h264_parser: Initialize the h264dsp context in the parser as well

Each AVStream struct for an H.264 elementary stream actually has two
copies of the H264DSPContext struct (and in fact all the other members
of H264Context as well):

((H264Context *) ((AVStream *)st)->codec->priv_data)->h264dsp
((H264Context *) ((AVStream *)st)->parser->priv_data)->h264dsp

but only the first of these was actually being initialised. This
prevented the addition of platform-specific implementations of
parser-related functions.

Signed-off-by: Martin Storsjö <martin@martin.st>
h264dsp: Factorize code into a new function, h264_find_start_code_candidate

This performs the start code search which was previously part of
h264_find_frame_end() - the most CPU intensive part of the function.

By itself, this results in a performance regression:
              Before          After
              Mean   StdDev   Mean   StdDev  Change
Overall time  2925.6 26.2     3068.5 31.7    -4.7%

but this can more than be made up for by platform-optimised
implementations of the function.

Signed-off-by: Martin Storsjö <martin@martin.st>
arm: Add assembly version of h264_find_start_code_candidate

               Before          After
               Mean   StdDev   Mean   StdDev  Change
This function   508.8 23.4      185.4  9.0    +174.4%
Overall        3068.5 31.7     2752.1 29.4     +11.5%

In combination with the preceding patch:
                Before          After
                Mean   StdDev   Mean   StdDev  Change
Overall         2925.6 26.2     2752.1 29.4     +6.3%

Signed-off-by: Martin Storsjö <martin@martin.st>
[ffmpeg] Backport of h264_find_start_code_candidate optimisation
Revert "[rbp/omxplayer] Avoid audio codec when in passthrough modes"

This reverts commit 9d6e3524ec14401961f64376f01eaca596ae39da.
Speedup for opening music song library

Previously, this repeatedly parsed the same URL string over and over again
for every song, each time the list of songs was opened.

Benchmarks for CMusicDatabase::GetSongsByWhere() on a Raspberry Pi with a
library of 4115 songs:

Before patch: 14.5 seconds
After patch:   4.0 seconds
Faster sorting of CFileItemLists, step 1

CFileItemLists are sorted by first construcing a SortItems object that refers
back to each CFileItem by index, sorting the SortItems object, then rebuilding
CSortItemList::m_items (a vector of pointers to CFileItems) by examination of
the sorted version of the SortItems object.

It might be more sensible, long-term, to sort m_items directly, but in the
meantime, there are a couple of simple ways to make sorting with SortItems
sufficiently efficient that it's not a problem any more.

Previously, SortItems was a vector of SortItem objects, held by value; each
SortItem was a std::map (implemented as a red-black tree) which ended up
being constructed and destructed as each element of SortItems was moved.
This patch changes SortItems to be a vector of pointers to SortItems instead.

Benchmarks for CFileItemList::Sort() on a Raspberry Pi with a library of
600 movies:
Before patch: 4.6 seconds
After patch:  1.1 seconds
Faster sorting of CFileItemLists, step 2

Each time a CFileItemList is sorted, multiple SortItem objects are
constructed and destructed. Each object is a std::map ,implemented as a
red-black tree with one node for each attribute (Field) upon which the
CFileItemList could conceivably have been sorted, even though for any given
SortBy, very few attributes are actually examined by SortUtils::Sort(). Worse
still, many of those nodes involve creating an associated fresh copy of a
string, with all the associated heap thrashing that entails.

This patch changes the various ToSortable methods to limit the number of
items in each SortItem's std::map to those actually required for performing
the chosen sort.

Benchmarks for CFileItemList::Sort() on a Raspberry Pi with a library of
600 movies:
Before patch: 1.1 seconds
After patch:  0.36 seconds
[rbp/omxplayer] Only apply boost centre to multichannel audio
[rbp/omxplayer] Avoid losing volume changes when amplification is disabled
Faster substring comparisons

There were nearly 200 places in the code where testing for a substring was
being performed using a construct of the form
  CStdString::Left(len).Equals("string")
or the related CStdString methods Mid or Right. These are bad for performance
because they involve allocating a heap block for the duration of the
expression evaluation, for the purpose of holding the substring, and then
freeing it again.

Aware that CStdString is being phased out (PR #3225), I have replaced these
where possible with calls to std::string::compare - this amounted to cases
where comparison was against a string literal containing no alphabetic
characters. In theory, calls of CStdString::Equals with the optional bUseCase
parameter set true would have been other candidates for this, but there were
none (at least not in conjunction with Left(), Mid() or Right()).

The remaining cases need to be case-insenitive comparisons, for
compatibility's sake. std::string doesn't have case-insensitive comparisons,
so I have added a couple of extra methods to StringUtils:

* SubstringEqualsNoCase(), similar to the existing EqualsNoCase() but
  specifying an offset and length into the first string.

* ToLowerSubstringEquals(), used in by far the most common case, where the
  second string was a string literal. This uses a C string parameter to avoid
  having to construct a std::string in order to call it. It also assumes that
  the string literal is already in lower case, to halve the number of
  tolower() calls needed. This was already true of the majority of string
  literals, and I have changed the remainder to match.

I noted that StringUtils::EqualsNoCase would benefit from being reimplemented
in a similar way to SubstringEqualsNoCase to avoid unnecessary heap
operations, but that is not part of this commit.

The majority of the changes here were achieved using a sophisticated search
and replace, which will hopefully minimise any bugs introduced in the
conversion.

This patch is expected to have wide-reaching performance benefits. One
benchmark (that can't pretend to exercise all ~200 improvements) is the time
to open the songs library: on a Raspberry Pi, this patch improves this time
- specificaly, in CGUIMediaWindow::Update - from 11.7 to 10.4 seconds (that's
a 13% speedup) with a library of 4100 songs. (The standard deviation on those
measurements is 0.1 seconds).
Merge branch 'newclock3' of https://github.com/popcornmix/xbmc into miappa_xbmc