Beispiel #1
0
        async void StreamProcessor_JpegRetrieved(object sender, JpegEventArgs e)
        {
            if (IsRendering)
            {
                return;
            }

            IsRendering = true;
            await LiveviewUtil.SetAsBitmap(e.Packet.ImageData, MoviePlaybackData, null);

            IsRendering = false;
        }
Beispiel #2
0
        async void liveview_JpegRetrieved(object sender, JpegEventArgs e)
        {
            if (IsRendering)
            {
                return;
            }

            IsRendering = true;
            await LiveviewUtil.SetAsBitmap(e.Packet.ImageData, liveview_data, HistogramCreator, Dispatcher);

            IsRendering = false;
        }
Beispiel #3
0
        private async Task DecodeLiveviewFrame(JpegPacket packet, bool retry = false)
        {
            Action trailingTask = null;

            if (LiveviewImageBitmap == null || sizeChanged)
            {
                await Dispatcher.RunAsync(CoreDispatcherPriority.Normal, async() =>
                {
                    var writeable  = await LiveviewUtil.AsWriteableBitmap(packet.ImageData, Dispatcher);
                    OriginalLvSize = new BitmapSize {
                        Width = (uint)writeable.PixelWidth, Height = (uint)writeable.PixelHeight
                    };

                    var magnification = CalcLiveviewMagnification();
                    DebugUtil.Log(() => { return("Decode: mag: " + magnification + " offsetV: " + LvOffsetV); });
                    dpi = DEFAULT_DPI / magnification;

                    RefreshOverlayControlParams(magnification);

                    trailingTask = () =>
                    {
                        if (Context?.Target?.Status != null)
                        {
                            RotateLiveviewImage(Context.Target.Status.LiveviewOrientationAsDouble, (sender, arg) =>
                            {
                                RefreshOverlayControlParams(magnification);
                            });
                        }

                        sizeChanged = false;
                    };
                });
            }
            else
            {
                rwLock.EnterWriteLock();

                try
                {
                    var toDelete = LiveviewImageBitmap;
                    trailingTask = () =>
                    {
                        // Dispose after it is drawn
                        toDelete?.Dispose();
                    };
                }
                finally
                {
                    rwLock.ExitWriteLock();
                }
            }

            using (var stream = new InMemoryRandomAccessStream())
            {
                await stream.WriteAsync(packet.ImageData.AsBuffer());

                stream.Seek(0);

                var bmp = await CanvasBitmap.LoadAsync(LiveviewImageCanvas, stream, (float)dpi);

                var size = bmp.SizeInPixels;

                rwLock.EnterWriteLock();
                try
                {
                    LiveviewImageBitmap = bmp;
                }
                finally
                {
                    rwLock.ExitWriteLock();
                }

                if (!OriginalLvSize.Equals(size))
                {
                    DisposeLiveviewImageBitmap();
                    if (!retry)
                    {
                        await DecodeLiveviewFrame(packet, true);
                    }
                    return;
                }
            }

            await Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>
            {
                LiveviewImageCanvas.Invalidate();
                trailingTask?.Invoke();
            });

            if (PendingPakcet != null)
            {
                var task = DecodeLiveviewFrame(PendingPakcet);
                PendingPakcet = null;
            }
        }