stbt: new public method `process_all_frames` implemented.

The `queue` element in the pipeline operates in "leaky" mode, which means
that, in order to keep up with live TV, the pipeline will drop out frames
when its buffer is filled.

The new method `process_all_frames` will force the pipeline to process all
the frames. Warning: code to be run while this is active shouldn't be too
long because an awful lot of memory will be consumed in order to keep all
the incoming frames.

In order to get this done, both the `appsink` and `queue` elements in the
pipeline need to be non-leaky:

1) queue.leaky = 0 ("Not Leaky")
2) queue.max_size_buffers = 0 ("disable")
3) queue.max_size_time = 0 ("disable")
4) queue.max_size_bytes = 0 ("disable")

Besides, the Queue object used to store the last frame is reused, created
with unlimited number of elements (max_size = 0)

When entering this context, no frame must be droppedd, so the bit of code
that drops an old frame must no be run. In order to achieve this in a
readable way, a new `operation_mode` attribute is used.

When leaving the context `process_all_frames`, restart_bin_source() is used
for catching up with the live stream. However, restart_source_bin()
detects many underruns and, therefore, raises the next error:
    "Video loss. Too many underruns."

In order to avoid this, process_all_frames() now deactivates the
underrun_timeout during the process, and it is necessary to make sure that
underrun_timeout exists before trying to start it.

Example usage code:

with stbt.process_all_frames():
    # do your measurements here.
# here, live stream is caught up with
# and frame-dropping (leaky) mode is back to normal
stbt-run: New public method `get_live_stream_timestamp`

This method enables to get the timestamp of the last frame queued for
processing.

This can be used to get an approximation of the current time expressed
in terms of the stream timestamp.

When the pipeline has just ben restarted, it may happen that gstreamer
can't get the last frame because it doesn't exist, so the optional
parameter `retry` can be used to force this method to continue checking
until it successfully retrieves a valid frame.
stbt.py: Fixed error launched by get_live_stream_timestamp()

The element that was being assigned the name `upstream_screenshot` was
instroduced erronously because a `queue` gstreamer element does not have
a "last-buffer" property. This is fixed by introducing an "appsink"
element.
stbt.py: make sure the upstream_screenshot drops old frames.
stbt.py: new function get_frame_timestamp() added

`stbt.get_frame()` returns the last processed frame, but not its timestamp.
Now that `process_all_frames()` has been added so as to take precise
measurements, there needs to be a way of retrieving this timestamp, as well
as the timestamp from the live stream (already implemented).

This way, a usage exmaple would be:

with stbt.process_all_frames():
    t0 = stbt.get_live_stream_timestamp(retry=True)
    stbt.press('MENU')
    stbt.wait_for_match('menu.png')
    t1 = stbt.get_frame_timestamp()
print 'Time spent in launching the menu:', float(t1 - t2) / (10 ** 9)
stbt.py: reduce memory used when queue is non-leaky

By allocating the queue after the ffmpgecolorspace element, we reduce the
memory consumed when it is non-leaky, that is in a `process_all_frames`
context.

To reduce this even more, I've tried to substitute this queue with a queue2
element. However, what queue2 does is store the buffers in disk AS WELL AS
keep them in memory. Therefore, that doesn't help.