private async Task DoJob()
{
long now = SystemClock.UptimeMillis;
EncodedImage input;
bool isLast;
lock (_gate)
{
input = _encodedImage;
isLast = _isLast;
_encodedImage = null;
_isLast = false;
_jobState = JobState.RUNNING;
_jobStartTime = now;
}
try
{
// we need to do a check in case the job got cleared in the meantime
if (ShouldProcess(input, isLast))
{
await _jobRunnable.Invoke(input, isLast).ConfigureAwait(false);
}
}
finally
{
EncodedImage.CloseSafely(input);
OnJobFinished();
}
}
public HttpResponseMessage FileUpload(EncodedImage encodedImage)
{
try
{
FileUploadService fSvc = new FileUploadService();
byte[] newBytes = Convert.FromBase64String(encodedImage.EncodedImageFile);;
UploadFile model = new UploadFile();
model.FileUploadName = "img";
model.ByteArray = newBytes;
model.Extension = encodedImage.FileExtension;
model.Location = "TestImages";
int fileId = fSvc.Insert(model);
ItemResponse <int> resp = new ItemResponse <int>();
resp.Item = fileId;
return(Request.CreateResponse(HttpStatusCode.OK, resp));
}
catch (Exception ex)
{
return(Request.CreateErrorResponse(HttpStatusCode.BadRequest, ex.Message));
}
}
protected override bool UpdateDecodeJob(EncodedImage encodedImage, bool isLast)
{
lock (_gate)
{
bool ret = base.UpdateDecodeJob(encodedImage, isLast);
if (!isLast && EncodedImage.IsValid(encodedImage))
{
if (!_progressiveJpegParser.ParseMoreData(encodedImage))
{
return(false);
}
int scanNum = _progressiveJpegParser.BestScanNumber;
if (scanNum <= _lastScheduledScanNumber ||
scanNum < _progressiveJpegConfig.GetNextScanNumberToDecode(
_lastScheduledScanNumber))
{
return(false);
}
_lastScheduledScanNumber = scanNum;
}
return(ret);
}
}
private void buttonDecode_Click(object sender, EventArgs e)
{
using (var encodedImageReader = new EncodedImageReader())
{
encodedImage = encodedImageReader.ReadEncodedImage(encodedFilePath);
}
decodedImage = Decoder.GetDecodedImage(encodedImage);
decodedBitmap = Decoder.Decode(encodedImage);
predictorSettings = decodedImage.PredictorSettings;
UpdateUiFromSettings();
lastOperationWasEncode = false;
this.decodedImagePanel.BackgroundImage = decodedBitmap;
this.toolStripStatusLabel.Text = "Image decoded.";
this.groupBoxHistogram.Enabled = true;
this.buttonSaveDecoded.Enabled = true;
this.radioButtonQuantizedErrorPrediction.Enabled = true;
this.radioButtonErrorPrediction.Enabled = true;
this.radioButtonDecoded.Enabled = true;
RefreshErrorImage();
RefreshHistogram();
}
public void TestCopyMetaData()
{
EncodedImage encodedImage = new EncodedImage(_byteBufferRef);
encodedImage.Format = ImageFormat.JPEG;
encodedImage.RotationAngle = 0;
encodedImage.Width = 1;
encodedImage.Height = 2;
encodedImage.SampleSize = 3;
EncodedImage encodedImage2 = new EncodedImage(_byteBufferRef);
encodedImage2.CopyMetaDataFrom(encodedImage);
Assert.AreEqual(encodedImage.Format, encodedImage2.Format);
Assert.AreEqual(encodedImage.Width, encodedImage2.Width);
Assert.AreEqual(encodedImage.Height, encodedImage2.Height);
Assert.AreEqual(encodedImage.SampleSize, encodedImage2.SampleSize);
Assert.AreEqual(encodedImage.Size, encodedImage2.Size);
EncodedImage encodedImage3 = new EncodedImage(_inputStreamSupplier);
encodedImage3.Format = ImageFormat.JPEG;
encodedImage3.RotationAngle = 0;
encodedImage3.Width = 1;
encodedImage3.Height = 2;
encodedImage3.SampleSize = 3;
encodedImage3.StreamSize = 4;
EncodedImage encodedImage4 = new EncodedImage(_inputStreamSupplier);
encodedImage4.CopyMetaDataFrom(encodedImage3);
Assert.AreEqual(encodedImage3.Format, encodedImage4.Format);
Assert.AreEqual(encodedImage3.Width, encodedImage4.Width);
Assert.AreEqual(encodedImage3.Height, encodedImage4.Height);
Assert.AreEqual(encodedImage3.SampleSize, encodedImage4.SampleSize);
Assert.AreEqual(encodedImage3.Size, encodedImage4.Size);
}
public void TestCloseSafely()
{
EncodedImage encodedImage = new EncodedImage(_byteBufferRef);
EncodedImage.CloseSafely(encodedImage);
Assert.AreEqual(1, _byteBufferRef.GetUnderlyingReferenceTestOnly().GetRefCountTestOnly());
}
/// <summary>
/// Removes item from the StagingArea.
/// </summary>
/// <param name="key">The cache key.</param>
/// <returns>true if item was removed.</returns>
public bool Remove(ICacheKey key)
{
// For unit test
++_removeCallsTestOnly;
Preconditions.CheckNotNull(key);
EncodedImage encodedImage = default(EncodedImage);
lock (_mapGate)
{
if (!_map.TryGetValue(key, out encodedImage))
{
return(false);
}
_map.Remove(key);
}
try
{
return(encodedImage.Valid);
}
finally
{
encodedImage.Dispose();
}
}
/// <summary>
/// Gets the best scan end offset.
/// </summary>
/// <returns>
/// Offset at which parsed data should be cut to decode best available
/// partial result.
/// </returns>
public int GetBestScanEndOffset(EncodedImage encodedImage)
{
int bestScanEndOffset = 0;
_bestScanEndOffsetList.TryGetValue(encodedImage.Size, out bestScanEndOffset);
return(bestScanEndOffset);
}
public async Task TestCacheMiss()
{
ICacheKey cacheKey = new SimpleCacheKey("http://hello.uri");
EncodedImage image = await _bufferedDiskCache.Get(cacheKey, _isCancelled);
Assert.IsNull(image);
}
/// <summary>
/// Performs key-value loop up in staging area and file cache.
/// Any error manifests itself as a miss, i.e. returns false.
/// </summary>
/// <param name="key">The cache key.</param>
/// <returns>
/// true if the image is found in staging area or File cache,
/// false if not found.
/// </returns>
private bool CheckInStagingAreaAndFileCache(ICacheKey key)
{
EncodedImage result = _stagingArea.Get(key);
if (result != null)
{
result.Dispose();
Debug.WriteLine($"Found image for { key.ToString() } in staging area");
_imageCacheStatsTracker.OnStagingAreaHit();
return(true);
}
else
{
Debug.WriteLine($"Did not find image for { key.ToString() } in staging area");
_imageCacheStatsTracker.OnStagingAreaMiss();
try
{
return(_fileCache.HasKey(key));
}
catch (Exception)
{
return(false);
}
}
}
public void TestCloneOrNull()
{
EncodedImage encodedImage = new EncodedImage(_byteBufferRef);
encodedImage.Format = ImageFormat.JPEG;
encodedImage.RotationAngle = 0;
encodedImage.Width = 1;
encodedImage.Height = 2;
encodedImage.SampleSize = 4;
EncodedImage encodedImage2 = EncodedImage.CloneOrNull(encodedImage);
Assert.AreEqual(3, _byteBufferRef.GetUnderlyingReferenceTestOnly().GetRefCountTestOnly());
Assert.AreSame(
encodedImage.GetByteBufferRef().GetUnderlyingReferenceTestOnly(),
encodedImage2.GetByteBufferRef().GetUnderlyingReferenceTestOnly());
Assert.AreEqual(encodedImage.Format, encodedImage2.Format);
Assert.AreEqual(encodedImage.RotationAngle, encodedImage2.RotationAngle);
Assert.AreEqual(encodedImage.Height, encodedImage2.Height);
Assert.AreEqual(encodedImage.Width, encodedImage2.Width);
Assert.AreEqual(encodedImage.SampleSize, encodedImage2.SampleSize);
encodedImage = new EncodedImage(_inputStreamSupplier, 100);
encodedImage.Format = ImageFormat.JPEG;
encodedImage.RotationAngle = 0;
encodedImage.Width = 1;
encodedImage.Height = 2;
encodedImage2 = EncodedImage.CloneOrNull(encodedImage);
Assert.AreSame(encodedImage.GetInputStream(), encodedImage2.GetInputStream());
Assert.AreEqual(encodedImage2.Size, encodedImage.Size);
}
public static Bitmap Decode(EncodedImage encodedImage)
{
var inversePredictionAlgorithm = new InversePredictionAlgorithm(encodedImage);
var decodedImage = inversePredictionAlgorithm.GetDecodedImage();
return(ImageMapper.GetImageFromPixelMatrix(decodedImage.Decoded));
}
public void TestCloneOrNull_WithInvalidOrNullReferences()
{
Assert.AreEqual(null, EncodedImage.CloneOrNull(null));
EncodedImage encodedImage = new EncodedImage(_byteBufferRef);
encodedImage.Dispose();
Assert.AreEqual(null, EncodedImage.CloneOrNull(encodedImage));
}
public void TestByteBufferRef()
{
EncodedImage encodedImage = new EncodedImage(_byteBufferRef);
Assert.AreEqual(2, _byteBufferRef.GetUnderlyingReferenceTestOnly().GetRefCountTestOnly());
Assert.AreSame(
encodedImage.GetByteBufferRef().GetUnderlyingReferenceTestOnly(),
_byteBufferRef.GetUnderlyingReferenceTestOnly());
}
private void NewScanOrImageEndFound(EncodedImage encodedImage, int offset)
{
if (_nextFullScanNumber > 0)
{
_bestScanEndOffsetList[encodedImage.Size] = offset;
}
_bestScanNumber = _nextFullScanNumber++;
}
public async Task TestFromStagingArea()
{
Task putTask = _bufferedDiskCache.Put(_cacheKey, _encodedImage);
EncodedImage image = _stagingArea.Get(_cacheKey);
Assert.AreSame(
_closeableReference.GetUnderlyingReferenceTestOnly(),
image.GetByteBufferRef().GetUnderlyingReferenceTestOnly());
await putTask;
}
public void SaveToFile(EncodedImage encodedImage, string originalImagePath, SaveMode saveMode)
{
InitializeBitWriter(GetOutputPath(originalImagePath, encodedImage.PredictorSettings, saveMode));
ImageHeaderHandler.CopyHeaderFromFile(originalImagePath, bitWriter);
WritePredictorSettings(encodedImage.PredictorSettings, saveMode);
WriteMatrix(encodedImage.QuantizedErrorPredictionMatrix, saveMode);
}
private Task <EncodedImage> GetAsync(ICacheKey key, AtomicBoolean isCancelled)
{
try
{
if (isCancelled.Value)
{
throw new OperationCanceledException();
}
EncodedImage result = _stagingArea.Get(key);
if (result != null)
{
Debug.WriteLine($"Found image for { key.ToString() } in staging area");
_imageCacheStatsTracker.OnStagingAreaHit();
}
else
{
Debug.WriteLine($"Did not find image for { key.ToString() } in staging area");
_imageCacheStatsTracker.OnStagingAreaMiss();
try
{
IPooledByteBuffer buffer = ReadFromDiskCache(key);
if (buffer == null)
{
return(Task.FromResult(default(EncodedImage)));
}
CloseableReference <IPooledByteBuffer> reference =
CloseableReference <IPooledByteBuffer> .of(buffer);
try
{
result = new EncodedImage(reference);
}
finally
{
CloseableReference <IPooledByteBuffer> .CloseSafely(reference);
}
}
catch (Exception)
{
return(Task.FromResult(default(EncodedImage)));
}
}
return(Task.FromResult(result));
}
catch (Exception)
{
// Log failure
// TODO: 3697790
Debug.WriteLine($"Failed to schedule disk-cache read for { key.ToString() }");
throw;
}
}
/// <summary>
/// Performs key-value look up in disk cache. If value is not
/// found in disk cache staging area then disk cache read is
/// scheduled on background thread.
/// Any error manifests itself as cache miss, i.e. the returned
/// task resolves to null.
/// </summary>
/// <param name="key">The cache key.</param>
/// <param name="isCancelled">The cancellation flag.</param>
/// <returns>
/// Task that resolves to cached element or null if one cannot
/// be retrieved; returned task never rethrows any exception.
/// </returns>
public Task <EncodedImage> Get(ICacheKey key, AtomicBoolean isCancelled)
{
EncodedImage pinnedImage = _stagingArea.Get(key);
if (pinnedImage != null)
{
return(FoundPinnedImage(key, pinnedImage));
}
return(GetAsync(key, isCancelled));
}
public void EncodeImage()
{
// Crop a slightly different interior region of the same size and verify that the data is different (as a sanity check)
EncodedImage encImg = new EncodedImage();
encImg.EncodeFrom(this.testImage, new PngBitmapEncoder());
Image target = new Image(this.testImage.Width, this.testImage.Height, this.testImage.Stride, this.testImage.PixelFormat);
encImg.DecodeTo(target);
this.AssertAreImagesEqual(this.testImage, target);
}
public InversePredictionAlgorithm(EncodedImage encodedImage) : base(encodedImage.PredictorSettings)
{
this.quantizedErrorPrediction = encodedImage.QuantizedErrorPredictionMatrix;
width = quantizedErrorPrediction.GetLength(1);
height = quantizedErrorPrediction.GetLength(0);
dequantizedQuantizedErrorPrediction = new int[height, width];
predictionFromDecoded = new int[height, width];
decoded = new int[height, width];
}
public void TestIsMetaDataAvailable()
{
EncodedImage encodedImage1 = new EncodedImage(_byteBufferRef);
EncodedImage encodedImage2 = new EncodedImage(_byteBufferRef);
encodedImage2.RotationAngle = 1;
encodedImage2.Width = 1;
encodedImage2.Height = 1;
Assert.IsFalse(EncodedImage.IsMetaDataAvailable(encodedImage1));
Assert.IsTrue(EncodedImage.IsMetaDataAvailable(encodedImage2));
}
protected override bool UpdateDecodeJob(EncodedImage encodedImage, bool isLast)
{
lock (_gate)
{
if (!isLast)
{
return(false);
}
return(base.UpdateDecodeJob(encodedImage, isLast));
}
}
/// <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);
}
}
public void TestIsJpegCompleteAt_Complete()
{
byte[] encodedBytes = new byte[ENCODED_BYTES_LENGTH];
encodedBytes[ENCODED_BYTES_LENGTH - 2] = JfifUtil.MARKER_FIRST_BYTE;
encodedBytes[ENCODED_BYTES_LENGTH - 1] = JfifUtil.MARKER_EOI;
IPooledByteBuffer buf = new TrivialPooledByteBuffer(encodedBytes);
EncodedImage encodedImage = new EncodedImage(
CloseableReference <IPooledByteBuffer> .of(buf, _releaser));
encodedImage.Format = ImageFormat.JPEG;
Assert.IsTrue(encodedImage.IsCompleteAt(ENCODED_BYTES_LENGTH));
}
public void Initialize()
{
_stagingArea = StagingArea.Instance;
_closeableReference = CloseableReference <IPooledByteBuffer> .of(new TrivialPooledByteBuffer(BYTES));
_closeableReference2 = CloseableReference <IPooledByteBuffer> .of(new TrivialPooledByteBuffer(BYTES));
_encodedImage = new EncodedImage(_closeableReference);
_secondEncodedImage = new EncodedImage(_closeableReference2);
_cacheKey = new SimpleCacheKey("http://this.is/uri");
_stagingArea.Put(_cacheKey, _encodedImage);
}
} //Label_UPCA
#endregion
#endregion
#region Misc
private string GetXML()
{
#if PocketPC
return("not implemented");
#else
if (EncodedValue == "")
{
throw new Exception("EGETXML-1: Could not retrieve XML due to the barcode not being encoded first. Please call Encode first.");
}
else
{
try
{
using (BarcodeXML xml = new BarcodeXML())
{
BarcodeXML.BarcodeRow row = xml.Barcode.NewBarcodeRow();
row.Type = EncodedType.ToString();
row.RawData = RawData;
row.EncodedValue = EncodedValue;
row.EncodingTime = EncodingTime;
row.IncludeLabel = IncludeLabel;
row.Forecolor = ColorTranslator.ToHtml(ForeColor);
row.Backcolor = ColorTranslator.ToHtml(BackColor);
row.CountryAssigningManufacturingCode = Country_Assigning_Manufacturer_Code;
row.ImageWidth = Width;
row.ImageHeight = Height;
row.RotateFlipType = this.RotateFlipType;
row.LabelPosition = (int)this.LabelPosition;
row.LabelFont = this.LabelFont.ToString();
row.ImageFormat = this.ImageFormat.ToString();
row.Alignment = (int)this.Alignment;
//get image in base 64
using (MemoryStream ms = new MemoryStream())
{
EncodedImage.Save(ms, ImageFormat);
row.Image = Convert.ToBase64String(ms.ToArray(), Base64FormattingOptions.None);
}//using
xml.Barcode.AddBarcodeRow(row);
StringWriter sw = new StringWriter();
xml.WriteXml(sw, XmlWriteMode.WriteSchema);
return(sw.ToString());
} //using
} //try
catch (Exception ex)
{
throw new Exception("EGETXML-2: " + ex.Message);
} //catch
} //else
#endif
}
public async Task TestQueriesDiskCache()
{
await _bufferedDiskCache.Put(_cacheKey, _encodedImage);
EncodedImage image = await _bufferedDiskCache.Get(_cacheKey, _isCancelled);
Assert.IsTrue(2 == image.GetByteBufferRef().GetUnderlyingReferenceTestOnly().GetRefCountTestOnly());
byte[] buf1 = new byte[_pooledByteBuffer.Size];
_pooledByteBuffer.Read(0, buf1, 0, _pooledByteBuffer.Size);
byte[] buf2 = new byte[image.GetByteBufferRef().Get().Size];
image.GetByteBufferRef().Get().Read(0, buf2, 0, image.GetByteBufferRef().Get().Size);
CollectionAssert.AreEqual(buf1, buf2);
}
/// <summary>
/// Clears the currently set job.
///
/// <para /> In case the currently set job has been scheduled but
/// not started yet, the job won't be executed.
/// </summary>
public void ClearJob()
{
EncodedImage oldEncodedImage;
lock (_gate)
{
oldEncodedImage = _encodedImage;
_encodedImage = null;
_isLast = false;
}
EncodedImage.CloseSafely(oldEncodedImage);
}
public async Task TestFromStagingAreaLater()
{
await _bufferedDiskCache.Put(_cacheKey, _encodedImage);
EncodedImage image = await _bufferedDiskCache.Get(_cacheKey, _isCancelled);
Assert.IsTrue(_encodedImage.Size == image.Size);
// Ref count should be equal to 3 (One for _closeableReference, one that is cloned when
// _encodedImage is created and a third one that is cloned when the method GetByteBufferRef is
// called in EncodedImage).
Assert.IsTrue(3 == _encodedImage.GetByteBufferRef().GetUnderlyingReferenceTestOnly().GetRefCountTestOnly());
}
