tests: Two new tests have been added for the new feature
`process_all_frames`.

When using this context, all the frames must be processed and there must
not be any frame loss. In order to test this, the framerate is forced to be
50fps, and afterwards the timestamp of the frames is overlapped. That way,
the expected overlapped strings are: "00:00:00.000", "00:00:00.020",
"00:00:00.040" and so on.

Due to a dependency on the speed of the computer where this is run, the
first match must not be at any specific time. Otherwise, it can be
missed and therefore, fail. Instead, the milliseconds are checked, and
afterwards, the timestamps will report whether the matches were
consecutive.
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.
# herelive 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.