The FocusList subclass of QListWidget emits a GotFocus signal when it
gets focus -- used for the filters window to know when a specific filter
list gets focus.

This is used to allow the user to temporarily disable sources/filters.

For each item in the list box, it displays a visibility checkbox (with
eye icon) that the user can click to disable/re-enable sources or
filters.

I did not end up using the Qt::ItemIsUserCheckable flag with the list
items for a few reasons:

- We could not style the checkbox indicator without qss screwing up
  other parts of the list widget style on certain operating systems

- We could not get the icon to properly invert on active selection like
  the text does on mac/linux, which made it look strange

- Clicking the checkbox too fast would cause it to signal a double-click
  on the icon, opening the properties for a source in the source list

This checkbox gives an 'eye' icon that indicates whether something is
visible or not.  The color of the icon is influenced by the current
style's foreground color.

Replace header include with forward to reduce needless header includes
and thus reduce compile time.

This allows knowing when the graphics viewport itself changes in size
(in case the window with the graphics viewport does not change size)

If a filter is an async filter move above/below other async filters,
and similarly for effect filters move above/below other effect filters.

Async filters and effect filters are really two different classes of
filters, so it's important that audio filters be marked as async.

Filtering the video before it's output to the texture means that it
happens after all the processing on the timestamps and such of the video
data.  This way, the video filter does not have to worry about what's
currently buffered, and it won't affect timing.

These are basically just capabilities of a source, that and too much
text on one line.

Gets the output flags by its source type.

obs_get_source_defaults was missing the definition for the function.

When OBS is shutting down, if for some reason the filter is destroyed
before the parent source is destroyed, it would try to remove itself
from the source, but it would decrement the reference and try to destroy
itself again while already in the process of destroying itself.

So, the solution was simply to make sure that if it's removing itself
from the source that it doesn't decrement its own reference.

If the filter's binary was recently removed, the data will be invalid,
so make sure that it properly handles that situation by skipping the
filter.

The "last" filter that's rendered is technically at filter index 0, so
enumeration needs to be from the last index in the list to the first
index in the list.

Refactors the function a bit to ensure that the filter mutex is locked
when changing the filter order.

Signals when the filter order has been changed for a source.

The 'idx' variable is the incorrect variable to be using here, the
variable that was supposed to be used was 'i'.

Technically, the "last" filter rendered is the filter at index 0, so
inserting a new filter at that point makes the most sense.

When rendering a filter to a texture, the target is empty and unused, so
there's no reason for blending to be on when rendering the filter to a
render target.

obs_source_process_filter tried to do everything in a single function,
but the problem is that effect parameters would not properly be
accounted for due to the way it internally draws, therefore it was
necessary to split the functions in to two, you first call
obs_source_process_filter_begin, then you set your effect parameters,
then you finally call obs_source_process_filter_end.  This ensures that
when the filter is drawn, that the effect parameters are set.

When the filter chain finally reaches the source and the last filter in
the chain is set to not render directly (meaning it has to render to
texture), it would not render the source with any effect due to the fact
that it expects a filter to be present.

Adds a source callback function that is used when a filter is removed
from a source.  This ensures that any data that might be associated with
that source can be cleaned up if necessary.

This allows a filter to skip its step and move on to the next target in
the chain without affecting performance.

This fixes a bug where the previous contents of a filter's render target
texture might become visible if using alpha.

There are a few more conditions which need to be checked to ensure
whether we can actually bypass or not; in this particular case we are
using the YUV texture shaders, plus the image can also be flipped, so we
can't really use the bypass optimization in those situations.

These functions are primarily for use with filters, filters need to be
able to get the width/height of a target source without it necessarily
getting the post-filtered dimensions.

Previously I had it set so that it would set the async_width and
async_height variables to 0,0 if a null frame occurs, but the problem
with this is that it was inadvertently cause the frame cache to clear
when it starts receiving textures again because it detects it as a size
change.

So instead of changing async_width and async_height to 0 when a null
frame occurs, change it so that if the source is set to an inactive
state, make obs_source_get_width/_get_height return 0 for their
dimensions instead.

When a frame is processed by a filter, it comes directly from the
source's video frame cache.  However, if a filter is using or processing
those frames for whatever reason, there would be no guarantee that the
frames would persist during processing, and frames could eventually be
deallocated unexpected, for example when the resolution or format
changes.

So the solution is to implement simple reference counting for the frames
so that the frames will exist until they have been released by any
source or filter that's using them.

Clears source video when the media stream ends.

A null frame send to the frame callback signals
the end of media being played.  Null frames are not
sent for looped media

This is in preparation of an API change that will send null
frames to signal the end of the media being played.