/// <summary>
/// Creates a memory-backed encoded image from the stream.
/// The stream is closed.
/// </summary>
protected EncodedImage GetByteBufferBackedEncodedImage(Stream inputStream, int length)
{
var reference = default(CloseableReference <IPooledByteBuffer>);
try
{
if (length <= 0)
{
reference = CloseableReference <IPooledByteBuffer> .of(
_pooledByteBufferFactory.NewByteBuffer(inputStream));
}
else
{
reference = CloseableReference <IPooledByteBuffer> .of(
_pooledByteBufferFactory.NewByteBuffer(inputStream, length));
}
return(new EncodedImage(reference));
}
finally
{
Closeables.CloseQuietly(inputStream);
CloseableReference <IPooledByteBuffer> .CloseSafely(reference);
}
}
/// <summary>
/// Default release method.
/// </summary>
public void Release(T value)
{
try
{
Closeables.Close((IDisposable)value, true);
}
catch (IOException ioe)
{
Debug.WriteLine($"{ ioe.Message }. This will not happen, Closeable.close swallows and logs IOExceptions.");
}
}
void IResourceReleaser <Thing> .Release(Thing value)
{
try
{
Closeables.Close(value, true);
}
catch (IOException ioe)
{
// This should not happen
Debug.WriteLine($"{ ioe.Message } is NOT expected.");
Assert.Fail();
}
}
/// <summary>
/// Reads image header from a file indicated by provided filename and
/// determines its format. This method does not throw IOException if
/// one occurs. In this case, ImageFormat.UNKNOWN will be returned.
/// </summary>
/// <returns>ImageFormat for image stored in filename.</returns>
public static ImageFormat GetImageFormat(string filename)
{
FileStream fileInputStream = null;
try
{
fileInputStream = new FileStream(filename, FileMode.Open, FileAccess.Read);
return(GetImageFormat(fileInputStream));
}
catch (IOException)
{
return(ImageFormat.UNKNOWN);
}
finally
{
Closeables.CloseQuietly(fileInputStream);
}
}
public int computeItemSimilarities(int degreeOfParallelism, int maxDurationInHours, SimilarItemsWriter writer)
{
ExecutorService executorService = Executors.newFixedThreadPool(degreeOfParallelism + 1);
Output output = null;
try {
writer.open();
DataModel dataModel = getRecommender().getDataModel();
BlockingQueue<long[]> itemsIDsInBatches = queueItemIDsInBatches(dataModel, batchSize);
BlockingQueue<List<SimilarItems>> results = new LinkedBlockingQueue<List<SimilarItems>>();
AtomicInteger numActiveWorkers = new AtomicInteger(degreeOfParallelism);
for (int n = 0; n < degreeOfParallelism; n++) {
executorService.execute(new SimilarItemsWorker(n, itemsIDsInBatches, results, numActiveWorkers));
}
output = new Output(results, writer, numActiveWorkers);
executorService.execute(output);
} catch (Exception e) {
throw new IOException(e);
} finally {
executorService.shutdown();
try {
bool succeeded = executorService.awaitTermination(maxDurationInHours, TimeUnit.HOURS);
if (!succeeded) {
throw new RuntimeException("Unable to complete the computation in " + maxDurationInHours + " hours!");
}
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
Closeables.close(writer, false);
}
return output.getNumSimilaritiesProcessed();
}
/// <summary>
/// If this is the first time calling this method, the buffer will
/// be checked to make sure it starts with SOI marker (0xffd8).
/// If the image has been identified as a non-JPEG, data will be
/// ignored and false will be returned immediately on all
/// subsequent calls.
///
/// This object maintains state of the position of the last read
/// byte. On repeated calls to this method, it will continue from
/// where it left off.
/// </summary>
/// <param name="encodedImage">
/// Next set of bytes received by the caller.
/// </param>
/// <returns>true if a new full scan has been found.</returns>
public bool ParseMoreData(EncodedImage encodedImage)
{
if (_parserState == NOT_A_JPEG)
{
return(false);
}
int dataBufferSize = encodedImage.Size;
// Is there any new data to parse?
// _bytesParsed might be greater than size of dataBuffer - that
// happens when we skip more data than is available to read
// inside DoParseMoreData method.
if (dataBufferSize <= _bytesParsed)
{
return(false);
}
Stream bufferedDataStream = new PooledByteArrayBufferedInputStream(
encodedImage.GetInputStream(),
_byteArrayPool.Get(BUFFER_SIZE),
_byteArrayPool);
try
{
StreamUtil.Skip(bufferedDataStream, _bytesParsed);
return(DoParseMoreData(encodedImage, bufferedDataStream));
}
catch (IOException)
{
// Does not happen - streams returned by IPooledByteBuffers
// do not throw IOExceptions.
throw;
}
finally
{
Closeables.CloseQuietly(bufferedDataStream);
}
}
/// <summary>
/// Decodes gif into CloseableImage.
/// </summary>
/// <param name="encodedImage">
/// Input image (encoded bytes plus meta data).
/// </param>
/// <param name="options">Decode options.</param>
/// <returns>A CloseableImage.</returns>
public Task <CloseableImage> DecodeGifAsync(
EncodedImage encodedImage,
ImageDecodeOptions options)
{
Stream inputStream = encodedImage.GetInputStream();
if (inputStream == null)
{
return(Task.FromResult(default(CloseableImage)));
}
try
{
// Phong Cao: always forceStaticImage
return(DecodeStaticImageAsync(encodedImage)
.ContinueWith(
task => ((CloseableImage)task.Result),
TaskContinuationOptions.ExecuteSynchronously));
}
finally
{
Closeables.CloseQuietly(inputStream);
}
}
private async Task DoTransform(EncodedImage encodedImage, bool isLast)
{
_producerContext.Listener.OnProducerStart(_producerContext.Id, PRODUCER_NAME);
ImageRequest imageRequest = _producerContext.ImageRequest;
PooledByteBufferOutputStream outputStream =
_parent._pooledByteBufferFactory.NewOutputStream();
IDictionary <string, string> extraMap = default(IDictionary <string, string>);
EncodedImage ret = default(EncodedImage);
Stream inputStream = default(Stream);
try
{
int numerator = GetScaleNumerator(imageRequest, encodedImage);
extraMap = GetExtraMap(encodedImage, imageRequest, numerator);
inputStream = encodedImage.GetInputStream();
#if HAS_LIBJPEGTURBO
JpegTranscoder.TranscodeJpeg(
inputStream.AsIStream(),
outputStream.AsIStream(),
GetRotationAngle(imageRequest, encodedImage),
numerator,
DEFAULT_JPEG_QUALITY);
#else // HAS_LIBJPEGTURBO
inputStream.CopyTo(outputStream);
#endif // HAS_LIBJPEGTURBO
CloseableReference <IPooledByteBuffer> reference =
CloseableReference <IPooledByteBuffer> .of(outputStream.ToByteBuffer());
try
{
ret = new EncodedImage(reference);
ret.Format = ImageFormat.JPEG;
try
{
await ret.ParseMetaDataAsync().ConfigureAwait(false);
_producerContext.Listener.OnProducerFinishWithSuccess(
_producerContext.Id, PRODUCER_NAME, extraMap);
Consumer.OnNewResult(ret, isLast);
}
finally
{
EncodedImage.CloseSafely(ret);
}
}
finally
{
CloseableReference <IPooledByteBuffer> .CloseSafely(reference);
}
}
catch (Exception e)
{
_producerContext.Listener.OnProducerFinishWithFailure(
_producerContext.Id, PRODUCER_NAME, e, extraMap);
Consumer.OnFailure(e);
return;
}
finally
{
Closeables.CloseQuietly(inputStream);
outputStream.Dispose();
}
}
public void close()
{
Closeables.close(writer, false);
}
