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.

Silly code that pre-incremented a value while also assigning
it to the same value.

Skip decode refresh scheduling if the abort flag is
set when the timer fails to start.  This avoids extraneous
refresh scheduling when tearing down the decoders.

When compiling under mingw it was using the w32-pthreads
instead of the shared mingw pthread library.

Since sws_getCachedContext possibly logs a message every
time it is used (depending on the input), use our own caching
logic to minimize log spam.

Using LOG_ERROR here isn't really necessary, it just means that there's
no blackmagic support.

Fix a bug where when a source first starts up its async cache, it
unintentionally resets its cache, which means that the first few frames
would be lost.

The name 'Monitor' is a bit inconsistent with what it's called by the
operating system.

If the settings are reset to defaults or if the settings are just bad,
the video would get stuck on the last frame that was displayed, which
feels a bit awkward.  Best to make it stop video output entirely rather
than get stuck on the last video frame.

Having devices not active by default may cause confusion for some users.