/// <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> /// 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); } }
/// <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(); } }