Exemple #1
0
        public List <FrameField> GetVideoFrameFields(List <int> fieldNumbers)
        {
            var result = new List <FrameField>();

            fieldNumbers = (from f in fieldNumbers orderby f select f).ToList();
            foreach (var frameNumber in fieldNumbers)
            {
                if ((frameNumber < 0) || (frameNumber >= TotalFields))
                {
                    result.Add(null);
                    continue;
                }

                SeekToField(frameNumber, SeekModes.Accurate);
                if (_pendingFrame != null)
                {
                    FrameField frame = _pendingFrame.Fields[_pendingFrame.CurrentIndex];
                    //frame.Image.Save(@"D:\temp\image-" + frame.FrameNumber.ToString("00000") + ".png", System.Drawing.Imaging.ImageFormat.Png);
                    result.Add(frame);
                }
                else
                {
                    result.Add(null);
                }
                _pendingFrame.CurrentIndex++;
                if (_pendingFrame.CurrentIndex >= _pendingFrame.Fields.Length)
                {
                    _pendingFrame = ReadVideoFrame();
                }
            }

            return(result);
        }
Exemple #2
0
        public ILVariable GetOrCreateVariable(FrameField field)
        {
            string name;

            switch (field.FieldKind)
            {
            case FrameFieldKind.Parameter:
                name = "arg_" + field.Index;
                break;

            case FrameFieldKind.ReturnAddress:
                name = "return_address";
                break;

            case FrameFieldKind.CallersBasePointer:
                name = "caller_bp";
                break;

            case FrameFieldKind.LocalVariable:
                name = "local_" + field.Index;
                break;

            default:
                throw new ArgumentOutOfRangeException();
            }

            var variable = GetOrCreateVariable(name);

            variable.IsVirtual = false;
            return(variable);
        }
        public static int GetCurrentFrame()
        {
            if (AnimationWindow == null)
            {
                return(-1);
            }
#if UNITY_5_0
            return((int)FrameField.GetValue(GetState()));
#else
            return((int)FrameProperty.GetValue(GetState(), null));
#endif
        }
Exemple #4
0
        public FrameField GetVideoFrameField(int fieldNumber, SeekModes seekMode = SeekModes.Accurate)
        {
            FrameField frame = null;

            SeekToField(fieldNumber, seekMode);
            if (_pendingFrame != null)
            {
                frame = _pendingFrame.Fields[_pendingFrame.CurrentIndex];
                //frame.Image.Save(@"D:\temp\image-" + frame.FrameNumber.ToString("00000") + ".png", System.Drawing.Imaging.ImageFormat.Png);
            }
            _pendingFrame.CurrentIndex++;
            if (_pendingFrame.CurrentIndex >= _pendingFrame.Fields.Length)
            {
                _pendingFrame = ReadVideoFrame();
            }
            return(frame);
        }
        public static void SetCurrentFrame(int frame, float time)
        {
            if (AnimationWindow == null)
            {
                return;
            }

            object state = GetState();

#if UNITY_5_0
            TimeField.SetValue(state, time);
            FrameField.SetValue(state, frame);

            PreviewFrame.Invoke(AnimationWindow, new object[] { frame });
#else
            CurrentTimeField.SetValue(state, time);
#endif

            _animationWindow.Repaint();
        }
Exemple #6
0
        private PendingFrame ProcessFrame()
        {
            _frameOrig = (FFmpeg.AVFrame)Marshal.PtrToStructure(_pFrameOrig, typeof(FFmpeg.AVFrame));

            IntPtr pStream = Marshal.ReadIntPtr(_formatContext.streams, _videoStreamIndex * 4);
            var    stream  = (FFmpeg.AVStream)Marshal.PtrToStructure(pStream, typeof(FFmpeg.AVStream));

            _videoCodecContext = (FFmpeg.AVCodecContext)Marshal.PtrToStructure(stream.codec, typeof(FFmpeg.AVCodecContext));

            if (_videoFrameFirstDTS == null)
            {
                _videoFrameFirstDTS = _frameOrig.pkt_dts;
            }
            if (_videoFieldDTSDuration == null)
            {
                _videoFieldDTSDuration = _frameOrig.pkt_duration / _videoCodecContext.ticks_per_frame;
            }

            var fieldList = new List <FrameField>();

            //---------- Start YUV Image ----------
            if (OutputYData || OutputYImage)
            {
                _scalerY.ProcessImage(_pFrameOrig, _frameOrig);
            }
            //---------- End YUV Image ----------

            //---------- Start RGB Image ----------
            if (OutputRGBImage && !OutputYImage)
            {
                _scalerRGB.ProcessImage(_pFrameOrig, _frameOrig);
            }
            //---------- End RGB Image ----------

            for (int fieldIndex = 0; fieldIndex < _videoCodecContext.ticks_per_frame; fieldIndex++)
            {
                var field = new FrameField();

                if (OutputYData || OutputYImage)
                {
                    field.YData = _scalerY.GetYData(fieldIndex);
                    if (OutputYImage)
                    {
                        field.Image = _scalerY.GetImage(fieldIndex);
                        //field.Image.Save(@"D:\temp\image.png", System.Drawing.Imaging.ImageFormat.Png);
                    }
                }

                if (OutputRGBImage && !OutputYImage)
                {
                    field.Image = _scalerRGB.GetImage(fieldIndex);
                    //field.Image.Save(@"D:\temp\image.png", System.Drawing.Imaging.ImageFormat.Png);
                }

                field.PTS          = (_frameOrig.pkt_dts - _videoFrameFirstDTS.Value) + (fieldIndex * _videoFieldDTSDuration.Value);
                field.Seconds      = field.PTS * _videoCodecContext.pkt_timebase.num / (double)_videoCodecContext.pkt_timebase.den;
                field.FieldIndex   = fieldIndex;
                field.FieldNumber  = (int)(field.PTS / _videoFieldDTSDuration.Value);
                field.FrameNumber  = (int)(field.FieldNumber / _videoCodecContext.ticks_per_frame);
                field.FilePosition = _frameOrig.pkt_pos;
                field.AVFrame      = _frameOrig;

                fieldList.Add(field);
            }

            var frame = new PendingFrame();

            frame.Fields = fieldList.ToArray();

            return(frame);
        }