/// <summary>
/// Called if exception occurred during computation.
/// </summary>
protected override void OnFailure(Exception e)
{
_producerListener.OnProducerFinishWithFailure(
_requestId,
_producerName,
e,
_producerListener.RequiresExtraMap(_requestId) ? GetExtraMapOnFailure(e) : null);
_consumer.OnFailure(e);
}
/// <summary>
/// Performs the decode synchronously.
/// </summary>
private async Task DoDecode(EncodedImage encodedImage, bool isLast)
{
if (IsFinished() || !EncodedImage.IsValid(encodedImage))
{
return;
}
try
{
long queueTime = _jobScheduler.GetQueuedTime();
int length = isLast ?
encodedImage.Size : GetIntermediateImageEndOffset(encodedImage);
if (length == 0)
{
return;
}
IQualityInfo quality = isLast ? ImmutableQualityInfo.FULL_QUALITY : GetQualityInfo();
_producerListener.OnProducerStart(_producerContext.Id, PRODUCER_NAME);
CloseableImage image = null;
try
{
image = await _parent._imageDecoder
.DecodeImageAsync(encodedImage, length, quality, _imageDecodeOptions)
.ConfigureAwait(false);
}
catch (Exception e)
{
_producerListener.OnProducerFinishWithFailure(
_producerContext.Id,
PRODUCER_NAME,
e,
GetExtraMap(image, queueTime, quality, isLast));
HandleError(e);
return;
}
_producerListener.OnProducerFinishWithSuccess(
_producerContext.Id,
PRODUCER_NAME,
GetExtraMap(image, queueTime, quality, isLast));
HandleResult(image, isLast);
}
finally
{
EncodedImage.CloseSafely(encodedImage);
}
}
private void DoPostprocessing(
CloseableReference <CloseableImage> sourceImageRef,
bool isLast)
{
Preconditions.CheckArgument(CloseableReference <CloseableImage> .IsValid(sourceImageRef));
if (!ShouldPostprocess(sourceImageRef.Get()))
{
MaybeNotifyOnNewResult(sourceImageRef, isLast);
return;
}
_listener.OnProducerStart(_requestId, NAME);
CloseableReference <CloseableImage> destImageRef = null;
try
{
try
{
destImageRef = PostprocessInternal(sourceImageRef.Get());
}
catch (Exception e)
{
_listener.OnProducerFinishWithFailure(
_requestId, NAME, e, GetExtraMap(_listener, _requestId, _postprocessor));
MaybeNotifyOnFailure(e);
return;
}
_listener.OnProducerFinishWithSuccess(
_requestId, NAME, GetExtraMap(_listener, _requestId, _postprocessor));
MaybeNotifyOnNewResult(destImageRef, isLast);
}
finally
{
CloseableReference <CloseableImage> .CloseSafely(destImageRef);
}
}
private void OnFinishDiskReads(
Task <EncodedImage> task,
IConsumer <EncodedImage> consumer,
BufferedDiskCache preferredCache,
ICacheKey preferredCacheKey,
IProducerContext producerContext)
{
string requestId = producerContext.Id;
IProducerListener listener = producerContext.Listener;
if (IsTaskCancelled(task))
{
listener.OnProducerFinishWithCancellation(requestId, PRODUCER_NAME, null);
consumer.OnCancellation();
}
else if (task.IsFaulted)
{
listener.OnProducerFinishWithFailure(requestId, PRODUCER_NAME, task.Exception, null);
MaybeStartInputProducer(
consumer,
new DiskCacheConsumer(
_defaultBufferedDiskCache,
_smallImageBufferedDiskCache,
_chooseCacheByImageSize,
_forceSmallCacheThresholdBytes,
consumer,
preferredCache,
preferredCacheKey),
producerContext);
}
else
{
EncodedImage cachedReference = task.Result;
if (cachedReference != null)
{
listener.OnProducerFinishWithSuccess(
requestId,
PRODUCER_NAME,
GetExtraMap(listener, requestId, true));
consumer.OnProgressUpdate(1);
consumer.OnNewResult(cachedReference, true);
cachedReference.Dispose();
}
else
{
listener.OnProducerFinishWithSuccess(
requestId,
PRODUCER_NAME,
GetExtraMap(listener, requestId, false));
MaybeStartInputProducer(
consumer,
new DiskCacheConsumer(
_defaultBufferedDiskCache,
_smallImageBufferedDiskCache,
_chooseCacheByImageSize,
_forceSmallCacheThresholdBytes,
consumer,
preferredCache,
preferredCacheKey),
producerContext);
}
}
}
