title: Extract Frames from Video C#
body: <p>I'm trying to make an app that use the camera to record a video and process the images of the video. Here is what I want. First, my app records a 10 second video with Torch. Second, I use a method to playback the video to see what I record.</p>
  
  <p>I'm stuck on three things.</p>
  
  <ol>
  <li>How can I convert my video into individual frames (images)?</li>
  <li>Is it possible to asynchronously convert the video while it is being recorded?</li>
  <li>When I do convert the video into individual frames, how do I work with them? Are they JPEGs? Can I simply display them as images? Etc.</li>
  </ol>
  
  <p>Main code:</p>
  
  <pre><code>using System;
  using Windows.UI.Xaml;
  using Windows.UI.Xaml.Controls;
  
  using Windows.UI.Xaml.Navigation;
  
  namespace App3
  {
  
  public sealed partial class MainPage : Page
  {          
      DispatcherTimer D;
      double basetimer = 0;
      public MainPage()
      {
          this.InitializeComponent();       
          this.NavigationCacheMode = NavigationCacheMode.Required;
          D = new DispatcherTimer();      
          D.Interval = new TimeSpan(0, 0, 1);
          D.Tick += timer_Tick;
          txt.Text = basetimer.ToString();
          Play.IsEnabled = false;            
      }  
      public Library Library = new Library();
      public object PreviewImage { get; private set; }
      void timer_Tick(object sender, object e)
      {
          basetimer = basetimer - 1;
          txt.Text = basetimer.ToString();
          if (basetimer == 0)
          {
              D.Stop();               
              Preview.Source = null;
              Library.Stop();
              Record.IsEnabled = false;
              Play.IsEnabled = true;
              Clear.IsEnabled = true;
              if (Library._tc.Enabled)
              {
                  Library._tc.Enabled = false;
              }                
          }
      }
      private void Record_Click(object sender, RoutedEventArgs e)
      {            
          if (Library.Recording)
          {
              Preview.Source = null;
              Library.Stop();
              Record.Icon = new SymbolIcon(Symbol.Video);                
          }
          else
          {
              basetimer = 11;
              D.Start();
              //D.Tick += timer_Tick;
              Display.Source = null;
              Library.Record(Preview);
              Record.Icon = new SymbolIcon(Symbol.VideoChat);
              Record.IsEnabled = false;
              Play.IsEnabled = false;
          }
      }
      private async void Play_Click(object sender, RoutedEventArgs e)
      {            
          await Library.Play(Dispatcher, Display);
          //Extract_Image_From_Video(Library.buffer);            
      }
      private  void Clear_Click(object sender, RoutedEventArgs e)
      {
          Display.Source = null;            
          Record.Icon = new SymbolIcon(Symbol.Video);
          txt.Text = "0";
          basetimer=  0;
          Play.IsEnabled = false;
          Record.IsEnabled =true;
          if (Library.capture != null)
          {
              D.Stop();
              Library.Recording = false;
              Preview.Source = null;               
              Library.capture.Dispose();
              Library.capture = null;
              basetimer = 11;
          }
          }
      }
  }
  </code></pre>
  
  <p>Library Class:</p>
  
  <pre><code>using System;
  using System.Diagnostics;
  using System.Linq;
  using System.Threading.Tasks;
  using Windows.Devices.Enumeration;
  using Windows.Media.Capture;
  using Windows.Media.Devices;
  using Windows.Media.MediaProperties;
  using Windows.Storage;
  using Windows.Storage.Streams;
  using Windows.UI.Core;
  using Windows.UI.Xaml.Controls;
  using Windows.UI.Xaml.Media.Imaging;
  using Windows.Graphics.Imaging;
  using Emgu.CV.Structure;
  using Emgu.CV;
  using System.Collections.Generic;
  
  public class Library
  {
  
  private const string videoFilename = "video.mp4";
  private string filename;
  public MediaCapture capture;
  public InMemoryRandomAccessStream buffer;
  public static bool Recording;
  public TorchControl _tc;
  public int basetimer  ;   
  public async Task&lt;bool&gt; init()
  {
      if (buffer != null)
      {
          buffer.Dispose();
      }
      buffer = new InMemoryRandomAccessStream();
      if (capture != null)
      {
          capture.Dispose();
      }
      try
      {
  
          if (capture == null)
          {
              var allVideoDevices = await DeviceInformation.FindAllAsync(DeviceClass.VideoCapture);               
              DeviceInformation cameraDevice =
              allVideoDevices.FirstOrDefault(x =&gt; x.EnclosureLocation != null &amp;&amp;
              x.EnclosureLocation.Panel == Windows.Devices.Enumeration.Panel.Back);
              capture = new MediaCapture();
              var mediaInitSettings = new MediaCaptureInitializationSettings { VideoDeviceId = cameraDevice.Id };
              // Initialize 
              try
              {
                  await capture.InitializeAsync(mediaInitSettings);
                  var videoDev = capture.VideoDeviceController;
                  _tc = videoDev.TorchControl;
                  Recording = false;
                  _tc.Enabled = false;                                      
              }
              catch (UnauthorizedAccessException)
              {
                  Debug.WriteLine("UnauthorizedAccessExeption&gt;&gt;");
              }
              catch (Exception ex)
              {
                  Debug.WriteLine("Exception when initializing MediaCapture with {0}: {1}", cameraDevice.Id, ex.ToString());
              }
          }
              capture.Failed += (MediaCapture sender, MediaCaptureFailedEventArgs errorEventArgs) =&gt;
          {
              Recording = false;
              _tc.Enabled = false;
              throw new Exception(string.Format("Code: {0}. {1}", errorEventArgs.Code, errorEventArgs.Message));
          };
      }
      catch (Exception ex)
      {
          if (ex.InnerException != null &amp;&amp; ex.InnerException.GetType() == typeof(UnauthorizedAccessException))
          {
              throw ex.InnerException;
          }
          throw;
      }
      return true;
  }
  public async void Record(CaptureElement preview)
  {    
      await init();
      preview.Source = capture; 
      await capture.StartPreviewAsync();
      await capture.StartRecordToStreamAsync(MediaEncodingProfile.CreateMp4(VideoEncodingQuality.Auto), buffer);
      if (Recording) throw new InvalidOperationException("cannot excute two records at the same time");
      Recording = true;
      _tc.Enabled = true;
  
  }
  public async void Stop()
  {
      await capture.StopRecordAsync();
      Recording = false;
      _tc.Enabled = false;       
  }    
  
  public async Task Play(CoreDispatcher dispatcher, MediaElement playback)
  {
      IRandomAccessStream video = buffer.CloneStream();
  
      if (video == null) throw new ArgumentNullException("buffer");
      StorageFolder storageFolder = Windows.ApplicationModel.Package.Current.InstalledLocation;
      if (!string.IsNullOrEmpty(filename))
      {
          StorageFile original = await storageFolder.GetFileAsync(filename);
          await original.DeleteAsync();
      }
      await dispatcher.RunAsync(CoreDispatcherPriority.Normal, async () =&gt;
      {
          StorageFile storageFile = await storageFolder.CreateFileAsync(videoFilename, CreationCollisionOption.GenerateUniqueName);
          filename = storageFile.Name;
          using (IRandomAccessStream fileStream = await storageFile.OpenAsync(FileAccessMode.ReadWrite))
          {
              await RandomAccessStream.CopyAndCloseAsync(video.GetInputStreamAt(0), fileStream.GetOutputStreamAt(0));
              await video.FlushAsync();
              video.Dispose();
          }
          IRandomAccessStream stream = await storageFile.OpenAsync(FileAccessMode.Read);
  
          playback.SetSource(stream, storageFile.FileType);
          playback.Play();
  
  
  
  
  
      });
  
  
  }   
  </code></pre>