stbt: add a method `process_all_frames` available for the tests

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, the `queue` element from the pipeline needs the
next attributes to be modified:

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

In order to restore the previous values of these attributes, these methods
have been added:

1) Display::save_config()
2) Display::restore_last_saved_config()

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.
# this line runs in normal (frame-dropping) mode.
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-run: detect_match and detect_motion now return the timestamp of the
frame processed

Previously, there was no guarantee that the timestamp returned was the one
of the frame processed.
run-tests.sh: Added unit tests for process_all_frames().

Added three new unit tests to check integrity of `process_all_frames`. All
of them use a source with a timestamp overlapped on its frames, and set
its frame rate to 50fps.

1) test_match_timed_frame: waits for the specific match of a frame that
has a particular timestamp.

2) test_live_stream_caught_up_after_process_all_frames: while processing
all frames, it changes the videotestsrc pattern, waits for a specific match
with a timestamp and when it catches up with the live stream, it waits for
a match for that pattern.

3) test_match_consecutive_timed_frames_in_leaky_mode: tries to wait for
three matches corresponding to three consecutive frames, and expects it to
fail.