Beispiel #1
0
        private void thread_DoWork(CancellationToken token)
        {
            while (!token.IsCancellationRequested)
            {
                if (decode)
                {
                    MFFrame frame = null;

                    M_AV_PROPS properties = new M_AV_PROPS {
                        vidProps = new M_VID_PROPS {
                            eVideoFormat = eMVideoFormat.eMVF_Custom, nWidth = 800, nHeight = 600, fccType = eMFCC.eMFCC_ARGB32
                        }
                    };
                    //M_AV_PROPS properties = new M_AV_PROPS { vidProps = new M_VID_PROPS { eVideoFormat = eMVideoFormat.eMVF_HD720_50p, fccType = eMFCC.eMFCC_ARGB32 } };
                    m_objReader.SourceFrameConvertedGet(ref properties, -1, out frame, "");

                    frame.MFVideoGetBytes(out var size, out var buffer);
                    Console.Out.WriteLine($"Frame size: {size}");

                    frame.MFAVPropsGet(out var frameProperties, out var sampleCount);
                    Console.Out.WriteLine($"Expected: {properties.vidProps.nWidth}, {properties.vidProps.nHeight}, {properties.vidProps.fccType}");
                    Console.Out.WriteLine($"Found: {frameProperties.vidProps.nWidth}, {frameProperties.vidProps.nHeight}, {frameProperties.vidProps.fccType}");

                    m_objPreview.ReceiverFramePut(frame, -1, "");

                    Marshal.FinalReleaseComObject(frame);
                }
            }
        }
        private void BodyAction(object sender)
        {
            try
            {
                flagIsOver = false;
                MFFrame pFrame = (MFFrame)sender;
                MFFrame clonedFrame;
                pFrame.MFClone(out clonedFrame, eMFrameClone.eMFC_Video, eMFCC.eMFCC_ARGB32);
                M_AV_PROPS avProps;
                int        audiosamples;
                clonedFrame.MFAVPropsGet(out avProps, out audiosamples);

                int  cbPicture;
                long pbPicture;
                clonedFrame.MFVideoGetBytes(out cbPicture, out pbPicture);
                int    nRowBytes = avProps.vidProps.nRowBytes;
                IntPtr ptr       = new IntPtr(pbPicture);
                Image  bSource   = new Bitmap(avProps.vidProps.nWidth, Math.Abs(avProps.vidProps.nHeight), nRowBytes,
                                              PixelFormat.Format32bppRgb, ptr);
                this.Invoke(new Action(() => MainPreview.SetSource(bSource)));
                Marshal.ReleaseComObject(clonedFrame);

                m_nFrameCounter++;
                if (m_nFrameCounter == 10)
                {
                    GC.Collect();
                    m_nFrameCounter = 0;
                }
                flagIsOver = true;
            }
            catch
            {
                flagIsOver = true;
            }
        }
Beispiel #3
0
        private void thread_DoWork(CancellationToken token)
        {
            MFFrame[] arrFrames = new MFFrame[COUNT];
            while (!token.IsCancellationRequested)
            {
                M_AV_PROPS props = new M_AV_PROPS();
                props.vidProps.eInterlace = eMInterlace.eMI_Progressive;

                for (int i = 0; i < COUNT; i++)
                {
                    lock (m_objLock)
                    {
                        if (m_arrLives[i] != null && m_arrLiveState[i])
                        {
                            // Get next frame
                            try
                            {
                                m_arrLives[i].SourceFrameConvertedGetByTime(ref props, -1, -1,
                                                                            out arrFrames[i], " scaling_quality=2 async_id=ch" + i.ToString());
                                m_arrPreviews[i].ReceiverFramePut(arrFrames[i], -1, "");
                                if (m_arrWritersState[i])
                                {
                                    m_arrWriters[i].ReceiverFramePut(arrFrames[i], -1, "");
                                }

                                Marshal.FinalReleaseComObject(arrFrames[i]);
                            }
                            catch
                            {
                            }
                        }
                    }
                }
            }
        }
Beispiel #4
0
        private void thread_DoWork(CancellationToken token)
        {
            while (!token.IsCancellationRequested)
            {
                if (decode)
                {
                    if (firstFrame)
                    {
                        prevFrameTime = DateTime.Now;
                        firstFrame    = false;
                    }
                    MFFrame frame = null;

                    m_objReader.SourceFrameGet(-1, out frame, "");
                    m_objPreview.ReceiverFramePut(frame, -1, "");
                    TimeSpan tick = DateTime.Now - prevFrameTime;
                    framesTimes.Add(tick.TotalMilliseconds);

                    frame.MFTimeGet(out M_TIME time);
                    mes += $"start_time ={time.rtStartTime}, end_time = {time.rtEndTime}, span ={tick.TotalMilliseconds}, dif = {framesTimes[framesTimes.Count-1] - framesTimes[framesTimes.Count-2]}";

                    BeginInvoke(new InvokeDelegate(UpdateListBox));


                    Marshal.FinalReleaseComObject(frame);
                }
            }
        }
Beispiel #5
0
        public static Bitmap MFrame2Bitmap(ref MFFrame _mFrame, out M_VID_PROPS _vidProps)
        {
            // Clone frame to RGB32
            MFFrame mFrame = _mFrame;

            _mFrame.MFClone(out mFrame, eMFrameClone.eMFC_Reference, eMFCC.eMFCC_ARGB32);

            // FrameVideoGetBytes(out cbPicture, out pbPicture);
            int  cbSize;
            long pbVideo;

            mFrame.MFVideoGetBytes(out cbSize, out pbVideo);

            // Get Props from frame
            int        audioSample;
            M_AV_PROPS avProps;

            mFrame.MFAVPropsGet(out avProps, out audioSample);

            // Create a bitmap from frame
            Bitmap bmpPicture = new Bitmap(avProps.vidProps.nWidth, Math.Abs(avProps.vidProps.nHeight),
                                           avProps.vidProps.nRowBytes,
                                           System.Drawing.Imaging.PixelFormat.Format32bppRgb,
                                           new IntPtr(pbVideo));

            _vidProps = avProps.vidProps;
            _mFrame   = mFrame;

            return(bmpPicture);
        }
Beispiel #6
0
        private void thread_DoWork(CancellationToken token)
        {
            while (!token.IsCancellationRequested)
            {
                if (start && path != null)
                {
                    MFFrame pFrame = null;

                    m_objReader.SourceFrameGet(-1, out pFrame, "");

                    M_TIME timeF;
                    pFrame.MFTimeGet(out timeF);


                    if (TC)
                    {
                        GetTC(timeF);
                    }

                    m_objPrev.ReceiverFramePut(pFrame, -1, "");

                    Marshal.ReleaseComObject(pFrame);
                }
            }
        }
Beispiel #7
0
        private void thread_DoWork(CancellationToken token)
        {
            while (!token.IsCancellationRequested)
            {
                if (encode)
                {
                    MFFrame frame = null;

                    M_AV_PROPS props = new M_AV_PROPS();
                    props.vidProps.eVideoFormat = eMVideoFormat.eMVF_HD1080_25p;

                    //m_objReader.IMFSource_SourceFrameGet(-1, out frame, "");
                    m_objReader.SourceFrameConvertedGet(ref props, -1, out frame, "");

                    if (cg)
                    {
                        ShowPluggin(m_objCharGen, ref frame);
                    }

                    m_objWriter.ReceiverFramePut(frame, -1, "");

                    m_objPreview.ReceiverFramePut(frame, -1, "");

                    Marshal.FinalReleaseComObject(frame);
                }
            }
        }
        public MFFrame DrawTextOnFrame(MFFrame mFrame, string text, int fontSize = 8)
        {
            if (fontSize < 0)
            {
                throw new ArgumentOutOfRangeException();
            }

            if (!string.IsNullOrEmpty(text))
            {
                MFFrame mFrameClone = null;
                try
                {
                    mFrame.MFClone(out mFrameClone, eMFrameClone.eMFC_Full, eMFCC.eMFCC_Default);

                    var overlay = Overlay;
                    mFrameClone.MFPrint(text, fontSize, ref overlay, eMFTextFlags.eMFT_WordBreaks, "");
                    Marshal.ReleaseComObject(mFrame);
                    return(mFrameClone);
                }
                catch
                {
                    if (mFrameClone != null)
                    {
                        Marshal.ReleaseComObject(mFrameClone);
                    }

                    return(mFrame);
                }
            }

            return(mFrame);
        }
Beispiel #9
0
        private void buttonLogo_Click(object sender, EventArgs e)
        {
            openFileDialog        = new System.Windows.Forms.OpenFileDialog();
            openFileDialog.Filter = "Image Files |*.jpeg; *.jpg; *.bmp; *.png";
            if (openFileDialog.ShowDialog() == DialogResult.OK && openFileDialog.FileName != string.Empty)
            {
                // Create new MFrame from image file
                MFFrame frOverlay;
                m_objFactory.MFFrameCreateFromFile(openFileDialog.FileName, out frOverlay, "");

                lock (m_objLock)
                {
                    if (m_frOverlay != null)
                    {
                        releaseComObj(m_frOverlay);
                        m_frOverlay = null;
                    }

                    // Resize Overlay to 300x200 (for example)
                    frOverlay.MFResize(eMFCC.eMFCC_Default, 300, 200, 0, out m_frOverlay, "", "");

                    releaseComObj(frOverlay);
                }
            }
        }
Beispiel #10
0
 private void CopyAudio(MFFrame from, ref MFFrame to)
 {
     if (from != null)
     {
         from.MFAudioCopyTo("ch1", to);
     }
 }
        private void Clone(ref MFFrame frame)
        {
            frame.MFClone(out MFFrame clonedFrame, eMFrameClone.eMFC_Reference, eMFCC.eMFCC_ARGB32);

            Marshal.ReleaseComObject(frame);

            frame = clonedFrame;
        }
Beispiel #12
0
        public void UpdatePreview(MFFrame _pFrame)
        {
            int nASamples = 0;

            _pFrame.MFAVPropsGet(out m_avProps, out nASamples);

            m_objPreview.ReceiverFramePut(_pFrame, -1, "");
        }
        private Bitmap ToBitmap(ref MFFrame frame)
        {
            frame.MFVideoGetBytes(out int cbSize, out long pbVideo);
            frame.MFAVPropsGet(out M_AV_PROPS avProps, out int audioSample);

            var v = avProps.vidProps;
            var f = PixelFormat.Format32bppRgb;

            return(new Bitmap(v.nWidth, Math.Abs(v.nHeight), v.nRowBytes, f, new IntPtr(pbVideo)));
        }
Beispiel #14
0
        private void ShowPluggin(object _obj, ref MFFrame pFrame)
        {
            int     nFramesRes;
            MFFrame pFrameOut = null;

            ((MFORMATSLib.IMFProcess)_obj).ProcessFrame(pFrame, out pFrameOut, out nFramesRes, "");
            if (pFrameOut != null)
            {
                releaseComObj(pFrame);
                pFrame = pFrameOut;
            }
        }
        private bool ReleaseFrame(ref MFFrame frame)
        {
            if (frame == null)
            {
                return(false);
            }

            Marshal.ReleaseComObject(frame);
            frame = null;

            return(true);
        }
Beispiel #16
0
        private void thread_DoWork(CancellationToken token)
        {
            while (!token.IsCancellationRequested)
            {
                MFFrame pFrame = null;

                m_objMFReader.SourceFrameGetByTime(90000000000000, -1, out pFrame, "");
                //m_objMFReader.SourceFrameConvertedGetByTime(ref m_avProps, dblRequest, -1, out pFrame, strParams);

                m_objPreview.ReceiverFramePut(pFrame, -1, "");

                Marshal.ReleaseComObject(pFrame);
            }
        }
Beispiel #17
0
        bool NextFrame()
        {
            MFFrame pFrame = null;

            if (start)
            {
                m_objRed.SourceFrameGet(-1, out pFrame, "");
                m_objWriter.ReceiverFramePut(pFrame, -1, "");
                m_objPrev.ReceiverFramePut(pFrame, -1, "");

                Marshal.ReleaseComObject(pFrame);
            }
            return(true);
        }
Beispiel #18
0
        private void thread_DoWork(CancellationToken token)
        {
            while (!token.IsCancellationRequested)
            {
                if (encode || live)
                {
                    MFFrame    frameLive = null;
                    MFFrame    frameFile = null;
                    M_AV_PROPS props     = new M_AV_PROPS();
                    if (live)
                    {
                        M_VID_PROPS vidProps = new M_VID_PROPS();
                        vidProps.eVideoFormat = eMVideoFormat.eMVF_HD1080_5994i;
                        m_objLive.FormatVideoSet(eMFormatType.eMFT_Input, ref vidProps);
                        props.vidProps.eVideoFormat = eMVideoFormat.eMVF_Custom;
                        m_objLive.SourceFrameConvertedGet(ref props, -1, out frameLive, "");
                    }
                    if (encode)
                    {
                        props.vidProps.eVideoFormat = eMVideoFormat.eMVF_HD1080_5994i;

                        m_objReader.SourceFrameConvertedGet(ref props, -1, out frameFile, "");
                        if (frameLive != null)
                        {
                            frameLive.MFOverlay(frameFile, null, 0, 0, 0, "audio_gain=0", "ch1");
                        }
                    }

                    if (frameLive != null)
                    {
                        m_objPreview.ReceiverFramePut(frameLive, -1, "");
                    }
                    else
                    {
                        m_objPreview.ReceiverFramePut(frameFile, -1, "");
                    }

                    if (frameLive != null)
                    {
                        Marshal.FinalReleaseComObject(frameLive);
                    }
                    if (frameFile != null)
                    {
                        Marshal.FinalReleaseComObject(frameFile);
                    }
                }
            }
        }
        public MFFrame DrawLinesOnFrame(MFFrame mFrame, bool isDrawing, List <CurveLine> lines, int panelWidth, int panelHeight, int x, int y)
        {
            if (panelHeight <= 0 || panelWidth <= 0)
            {
                throw new ArgumentOutOfRangeException();
            }

            if (lines.Any())
            {
                MFFrame mFrameDraw = CurveDraw.DrawFrame(isDrawing, mFrame, panelWidth, panelHeight, x, y, lines);
                Marshal.ReleaseComObject(mFrame);
                return(mFrameDraw);
            }

            return(mFrame);
        }
Beispiel #20
0
        private void thread_DoWork(CancellationToken cancelSource)
        {
            while (!cancelSource.IsCancellationRequested)
            {
                if (isWorking)
                {
                    MFFrame frame = null;
                    mLive.SourceFrameConvertedGet(ref avProps, -1, out frame, "");

                    if (frame != null)
                    {
                        if (isRec)
                        {
                            btnRecord.Enabled   = false;
                            btnRecord.Text      = "Recording";
                            btnRecord.BackColor = Color.Red;

                            try
                            {
                                mWriter.ReceiverFramePut(frame, -1, "");

                                //UpdateStatistic()
                            }
                            catch (Exception e)
                            {
                                MessageBox.Show("Error: " + e.ToString());
                            }
                        }
                    }
                    else
                    {
                        btnRecord.Enabled   = true;
                        btnRecord.Text      = "Record";
                        btnRecord.BackColor = Color.AntiqueWhite;
                    }

                    mPreview.ReceiverFramePut(frame, -1, "");

                    Marshal.ReleaseComObject(frame);
                }
                else
                {
                    Thread.Sleep(1);
                }
            }
        }
Beispiel #21
0
 private void SendToRenderer(MFFrame pFrame)
 {
     if (checkBoxRenderer.Checked)
     {
         if (m_objRenderer != null && comboBoxRenrerers.SelectedItem != null)
         {
             lock (m_objLock)
             {
                 // Send pFrame to renderer
                 try
                 {
                     m_objRenderer.ReceiverFramePut(pFrame, -1, "");
                 }
                 catch
                 { }
             }
         }
     }
 }
Beispiel #22
0
 private void SendToSink(MFFrame pFrame)
 {
     if (checkBoxVirtDev.Checked)
     {
         if (m_objMFSink != null)
         {
             lock (m_objLock)
             {
                 // Send pFrame to Sink
                 try
                 {
                     m_objMFSink.ReceiverFramePut(pFrame, -1, "");
                 }
                 catch
                 { }
             }
         }
     }
 }
Beispiel #23
0
        private void thread_DoWork(CancellationToken token)
        {
            while (!token.IsCancellationRequested)
            {
                if (encode)
                {
                    MFFrame frame = null;

                    M_AV_PROPS props = new M_AV_PROPS();
                    props.vidProps.eVideoFormat = eMVideoFormat.eMVF_Disabled;

                    m_objReader.SourceFrameConvertedGet(ref props, -1, out frame, "");

                    m_objPreview.ReceiverFramePut(frame, -1, "");

                    Marshal.FinalReleaseComObject(frame);
                }
            }
        }
 private void thread_DoWork(CancellationToken token)
 {
     while (!token.IsCancellationRequested)
     {
         MFFrame frame = null;
         if (!decoder)
         {
             noSignalFrame.MFClone(out frame, eMFrameClone.eMFC_Full, eMFCC.eMFCC_Default);
             m_objPreview.ReceiverFramePut(frame, -1, "");
         }
         if (decoder)
         {
             m_objLive.SourceFrameGet(-1, out frame, "");
             m_objPreview.ReceiverFramePut(frame, -1, "");
         }
         if (frame != null)
         {
             Marshal.ReleaseComObject(frame);
         }
     }
 }
Beispiel #25
0
        bool NextFrame()
        {
            MFFrame pFrame = null;

            if (start)
            {
                count++;
                if (count > 150)
                {
                    WriterSet();
                    count = 0;
                }


                m_objRed.SourceFrameGet(-1, out pFrame, "");
                m_objWr1.ReceiverFramePut(pFrame, -1, "");
                m_objPrev.ReceiverFramePut(pFrame, -1, "");

                Marshal.ReleaseComObject(pFrame);
            }
            return(true);
        }
Beispiel #26
0
        private void thread_DoWork(CancellationToken token)
        {
            while (!token.IsCancellationRequested)
            {
                if (start && path != null)
                {
                    MFFrame pFrame       = null;
                    MFFrame pFrameResize = null;


                    m_objReader.SourceFrameGet(-1, out pFrame, "");

                    if (Resize_chb.Checked)
                    {
                        pFrame.MFResize(eMFCC.eMFCC_RGB32, 256, 144, 0, out pFrameResize, "", "");

                        m_objPrevResize.ReceiverFramePut(pFrameResize, -1, "");
                    }

                    M_TIME timeF;
                    pFrame.MFTimeGet(out timeF);


                    if (TC)
                    {
                        GetTC(timeF);
                    }

                    m_objPrev.ReceiverFramePut(pFrame, -1, "");

                    Marshal.ReleaseComObject(pFrame);

                    if (pFrameResize != null)
                    {
                        Marshal.ReleaseComObject(pFrameResize);
                    }
                }
            }
        }
Beispiel #27
0
        private bool NextFrame()
        {
            if (m_objReader != null)
            {
                MFFrame frame      = null;
                MFFrame frameOver  = null;
                MFFrame frameClone = null;

                M_AV_PROPS props;
                m_objReader.SourceAVPropsGet(out props);
                props.vidProps.eVideoFormat = eMVideoFormat.eMVF_HD1080_50i;


                m_objReader.SourceFrameConvertedGet(ref props, -1, out frame, "");

                if (start)
                {
                    m_objReader.SourceFrameConvertedGet(ref props, 0, out frameOver, "");
                    //frame.MFOverlayRect(frameOver, null, ref overlayRect, eMFOverlayFlags.eMFOF_Crop, 1, "", "");
                    //frame.MFOverlay(frameOver, null, 10, 10, 1, "", "ch1");
                }
                frame.MFClone(out frameClone, eMFrameClone.eMFC_Reference, eMFCC.eMFCC_RGB24);
                m_objPrev.ReceiverFramePut(frameClone, -1, "");

                Marshal.ReleaseComObject(frame);

                if (frameOver != null)
                {
                    Marshal.ReleaseComObject(frameOver);
                }
                if (frameClone != null)
                {
                    Marshal.ReleaseComObject(frameClone);
                }
            }
            return(true);
        }
Beispiel #28
0
        public static MFFrame DrawFrame(bool _draw, MFFrame _mFrame, int _panelWidth, int _panelHeight, int _x, int _y, List <CurveLine> _linesToDraw)
        {
            if (_mFrame != null)
            {
                M_VID_PROPS vidProps;
                Bitmap      bmpPicture = MFrame2Bitmap(ref _mFrame, out vidProps);

                // Calculate mouse position
                if (_draw)
                {
                    int x = Math.Abs(vidProps.nWidth * _x / _panelWidth);
                    int y = Math.Abs(vidProps.nHeight * _y / _panelHeight);

                    _linesToDraw.Last().PenPath.Add(new Point(x, y));
                }

                // Draw lines
                var graphic = Graphics.FromImage(bmpPicture);

                for (int index = 0; index < _linesToDraw.Count; index++)
                {
                    CurveLine curveLine = _linesToDraw[index];
                    if (curveLine.PenPath.Count > 1)
                    {
                        graphic.DrawLines(new Pen(curveLine.PenColor, curveLine.PenSize), curveLine.PenPath.ToArray());
                    }
                }

                bmpPicture.Dispose();
                graphic.Dispose();

                return(_mFrame);
            }

            return(null);
        }
Beispiel #29
0
        private bool NextFrame()
        {
            // Get request pos and set pause and reverse flags
            double dblRequest = -1.0;
            string strParams  = string.Empty;

            // Update player state
            lock (playerState.stateLock)
            {
                if (playerState.state == eState.eST_Pause)
                {
                    strParams = " pause=true";
                }
                else if (playerState.state == eState.eST_PlayRev || playerState.state == eState.eST_StepRev)
                {
                    strParams = " reverse=true";
                }

                // Update player state
                if (playerState.state == eState.eST_StepFwd || playerState.state == eState.eST_StepRev)
                {
                    // Pause on next iteration - because single frame was requested
                    playerState.state = eState.eST_Pause;
                }

                // Get request time and set next cycle request to next frame
                // -1 as first parameter means "give me next frame", -5 means "give me next next 5th frame" etc,
                // this works accordingly when the reverse=true parameter is set.
                // positive values are uninterpreted as "give me frame at position"
                dblRequest = playerState.dblFrameRequest;
                playerState.dblFrameRequest = -1 * (int)(playerState.dblRate);
            }


            // Next frame cycle:
            // Get frame from reader and send to preview
            // Note: Preview keep frame according to frame time

            MFFrame pFrame = null;

            lock (objLock) // For prevent reader replace in OpenFile() and overlay change
            {
                // Get next frame or frame by position
                // -1 as first parameter means "give me next frame", -5 means "give me next next 5th frame" etc,
                // this works accordingly when the reverse=true parameter is set.
                // positive values are uninterpreted as "give me frame at position"
                try
                {
                    if (objMFReader != null)
                    {
                        objMFReader.SourceFrameConvertedGetByTime(ref avProps, dblRequest, -1, out pFrame, strParams);
                    }

                    // Update avProps
                    if (pFrame != null)
                    {
                        int nASamples = 0;
                        pFrame.MFAVPropsGet(out avProps, out nASamples);
                    }
                }
                catch (System.Exception ex)
                {
                    MessageBox.Show("Error occurs during file decoding:\n\n" + ex.Message, playerState.strFileName, MessageBoxButtons.OK, MessageBoxIcon.Warning);
                }
            }


            if (pFrame != null)
            {
                try
                {
                    objPreview.ReceiverFramePut(pFrame, -1, "");
                    releaseComObj(pFrame);
                }

                catch (System.Exception ex)
                {
                    MessageBox.Show("Error occurs during frame processing:\n\n" + ex.Message, playerState.strFileName, MessageBoxButtons.OK, MessageBoxIcon.Warning);
                    return(false);
                }
            }


            // Check for the last frame
            if ((Time.eFFlags & eMFrameFlags.eMFF_Last) != 0)
            {
                lock (playerState.stateLock)
                {
                    // Pause playback at the end of the file if loop is disabled
                    if (!playerState.bLoop)
                    {
                        pause();
                    }

                    if (playerState.state == eState.eST_PlayRev)
                    {
                        // Rewind to end in case of reverse playback
                        seek(playerState.dblDuration);
                    }
                    else if (playerState.state == eState.eST_PlayFwd)
                    {
                        // Rewind to start in case of direct playback
                        seek(0);
                    }
                }
            }
            return(true);
        }
Beispiel #30
0
        private bool NextFrame()
        {
            // Get request pos and set pause and reverse flags
            double dblRequest = -1.0;
            string strParams  = string.Empty;

            // Update player state
            lock (m_playerState.stateLock)
            {
                if (m_playerState.state == eState.eST_Pause)
                {
                    strParams = " pause=true";
                }
                else if (m_playerState.state == eState.eST_PlayRev || m_playerState.state == eState.eST_StepRev)
                {
                    strParams = " reverse=true";
                }

                // Update player state
                if (m_playerState.state == eState.eST_StepFwd || m_playerState.state == eState.eST_StepRev)
                {
                    // Pause on next iteration - because single frame was requested
                    m_playerState.state = eState.eST_Pause;
                }

                // Get request time and set next cycle request to next frame
                // -1 as first parameter means "give me next frame", -5 means "give me next next 5th frame" etc,
                // this works accordingly when the reverse=true parameter is set.
                // positive values are uninterpreted as "give me frame at position"
                dblRequest = m_playerState.dblFrameRequest;
                m_playerState.dblFrameRequest = -1 * (int)(m_playerState.dblRate);
            }


            // Next frame cycle:
            // Get frame from reader and send to preview
            // Note: Preview keep frame according to frame time

            MFFrame pFrame = null;

            lock (m_objLock) // For prevent reader replace in OpenFile() and overlay change
            {
                // Get next frame or frame by position
                // -1 as first parameter means "give me next frame", -5 means "give me next next 5th frame" etc,
                // this works accordingly when the reverse=true parameter is set.
                // positive values are uninterpreted as "give me frame at position"
                try
                {
                    if (m_objMFReader != null)
                    {
                        m_objMFReader.SourceFrameConvertedGetByTime(ref m_avProps, dblRequest, -1, out pFrame, strParams + " rate=0.1");
                    }
                    int samples;
                    pFrame.MFAVPropsGet(out currentProps, out samples);
                }
                catch (System.Exception ex)
                {
                    MessageBox.Show("Error occurs during file decoding:\n\n" + ex.Message, m_playerState.strFileName, MessageBoxButtons.OK, MessageBoxIcon.Warning);
                    return(false);
                }
            }

            if (pFrame == null)
            {
                Thread.Sleep(5);
                return(true);
            }

            try
            {
                // Demonstrate overlay - overlay another frame if any
                if (m_frOverlay != null)
                {
                    pFrame.MFOverlay(m_frOverlay, null, 50, 100, 0.5, "", "");
                }

                // Show CG object
                if (checkBoxCG.Checked)
                {
                    ShowPluggin(m_objCharGen, ref pFrame);
                    if (cgEditor != null)
                    {
                        cgEditor.m_objEditor_FrameProcessed(pFrame, null);
                    }
                }

                // Show CC
                if (checkBoxCC.Checked)
                {
                    if (m_objCCDisplay != null)
                    {
                        ShowPluggin(m_objCCDisplay, ref pFrame);
                    }
                }

                // Show HTML
                if (checkBoxHTML.Checked)
                {
                    lock (m_objHTMLLock)
                    {
                        if (m_objOverlayHTML != null)
                        {
                            ShowPluggin(m_objOverlayHTML, ref pFrame);
                            if (overlayHTMLWind != null && !overlayHTMLWind.IsDisposed)
                            {
                                overlayHTMLWind.UpdatePreview(pFrame);
                            }
                        }
                    }
                }

                mAudioMeter1.pFrame = pFrame;
                mAudioMeter1.SetValues();
                // Get frame timings
                pFrame.MFTimeGet(out mTime);

                double dblDur = 0;
                m_objMFReader.ReaderDurationGet(out dblDur);
                if (m_playerState.dblDuration != dblDur)
                {
                    m_playerState.dblDuration = dblDur;
                }

                // Send frame to Renderer
                SendToRenderer(pFrame);

                //Send frame to the preview
                m_objPreview.ReceiverFramePut(pFrame, checkBoxRenderer.Checked ? 0 : -1, "");

                //Send to Sink
                SendToSink(pFrame);

                //Release frame - DO NOT FORGOT TO DO THIS !!!
                releaseComObj(pFrame);
            }
            catch (System.Exception ex)
            {
                MessageBox.Show("Error occurs during frame processing:\n\n" + ex.Message, m_playerState.strFileName, MessageBoxButtons.OK, MessageBoxIcon.Warning);
                return(false);
            }

            // Check for the last frame
            if ((mTime.eFFlags & eMFrameFlags.eMFF_Last) != 0)
            {
                lock (m_playerState.stateLock)
                {
                    // Pause playback at the end of the file if loop is disabled
                    if (!m_playerState.bLoop)
                    {
                        pause();
                    }

                    if (m_playerState.state == eState.eST_PlayRev)
                    {
                        // Rewind to end in case of reverse playback
                        rewindToEnd();
                    }
                    else if (m_playerState.state == eState.eST_PlayFwd)
                    {
                        // Rewind to start in case of direct playback
                        rewindToStart();
                    }
                }
            }

            return(true);
        }