* When we need to cache a texture or buffer locally then before this
commit we'd transfer the whole resource, and re-transfer it every time
the event changed even if the contents haven't changed.
* Instead now we track the previous contents on both sides, and just
send a list of deltas to apply.
* On android reading pixel-by-pixel out of the mapped memory is
*incredibly* slow - taking up to 1.5s for a fullscreen depth texture.
It's faster to copy to a temporary array, and this shouldn't have a
huge effect on other platforms.
* Previously each read and write would 1:1 become a send or recv call.
* Now we buffer writes and send in batch (or when a chunk finishes),
and every time we read we try to non-blocking read more data to fill
the buffer, to allow batching reads where possible without blocking
on data that will never come.
* This makes API-agnostic processing over strucutred data a *little*
easier. At least it's possible to differentiate initialisation from
frame capture chunks.
* For a few primary cases, we check to see if the API call failed (or is
looking like it will fail, in the case of vulkan) and bail out. This
will cause the capture to fail to load.
* In each function, we check that serialisation succeeded before going
on to actually call into the API. If something went wrong, then we
bail out and fail to load the capture.
* Previously once we started loading a capture we'd blindly continue
until we loaded it (and then it's assumed to be successful), or we
crash.
* Now errors can be reported during serialisation and bubbled up to
abort the file load process. The next steps are to add error checking
in each function serialise before doing any replay calls to the API
with potentially corrupt data, and on top of that catching API-only
errors when the serialisation is (seemingly) fine, and propagating
those in a reasonable way.
* We also harden the serialisation a bit so that if it reads an
obviously invalid byte length for a buffer or array count, it won't
continue. It's still not perfect as the sizes could still be large and
invalid but within range, but it should catch the worst cases.
* This prevents leaking for cases where new widgets are created (and
the small chance a widget pointer could be re-used and cause serious
problems), and multiple-registration errors for global shortcuts.
* We need to inherit to chain these two, as otherwise when the tree view
delegate calls sizeHint() it passes to the tree widget delegate, but
then has no way to return back to the tree view for the overridden
initStyleOption.
* If there was a built-in way to chain delegates like styles (which
solve this problem by calling back to baseStyle when going from one
function to another), or better yet a way to avoid the base
QStyledItemDelegate initStyleOption from completely trampling all over
the option passed in to any function, this wouldn't be necessary.
* This doesn't make any difference really locally, but when using a
remote host for replay, it means the main viewport will update before
the thumbnails wait for those textures to transfer.
* Reported by Coverity Scan. In all cases, should not be a problem, but
with an upcast happening anyway we might as well ensure calculation
happens at a higher precision.
* Reported by Coverity Scan - most of these are not an issue and a
couple of them are coverity getting really confused (like seeing a
pointer being assigned to NULL and a count to 0, then a few lines
later declaring that a loop 0..count will dereference the pointer).
* However it's harmless in all cases to add a bit of robustness to keep
the analysis happy.
* This is a leftover from before the interface was hoisted out, and most
windows were still calling directly to CaptureContext instead of via
the public ICaptureContext interface
baldurk