title: Stream camera into memory using libvlc and display a frame
body: <p>I am trying to stream a capturing device (camera) into memory using libvlc.</p>
  
  <p>I am unable to display image from data stored in memory. The memory content seems to be ok. I checked it using Visual Studio and its Memory window. The picture created by imshow is always grey. How can I display the image stored in the memory? </p>
  
  <p>My code is mostly based on <a href="https://stackoverflow.com/questions/23092940/get-frame-from-video-with-libvlc-smem-and-convert-it-to-opencv-mat-c">this topic</a></p>
  
  <p>Thank you.</p>
  
  <pre><code>using namespace cv; 
  using namespace std;
  
  HANDLE hMutex;
  
  struct VideoDataStruct
  {
      int param;
  };
  
  int done = 0;
  libvlc_media_player_t *mp;
  unsigned int videoBufferSize = 0;
  uint8_t *videoBuffer = 0;
  
  void cbVideoPrerender(void *p_video_data, uint8_t **pp_pixel_buffer, int size) {
      // Locking
      //HANDLE hMutex = ::OpenMutex(SYNCHRONIZE, FALSE, _T("my_mutex"));
  
      if (size &gt; videoBufferSize || !videoBuffer)
      {
          printf("Reallocate raw video buffer\n");
          free(videoBuffer);
          videoBuffer = (uint8_t *) malloc(size);
          videoBufferSize = size;
      }
  
      // videoBuffer = (uint8_t *)malloc(size);
      *pp_pixel_buffer = videoBuffer;
  }  
  void cbVideoPostrender(void *p_video_data, uint8_t *p_pixel_buffer, int width, int height, int pixel_pitch, int size, int64_t pts) {
      // Unlocking
      //CloseHandle(hMutex);
  
  }
  static void handleEvent(const libvlc_event_t* pEvt, void* pUserData)
  {
      libvlc_time_t time;
      switch(pEvt-&gt;type)
      {
          case libvlc_MediaPlayerTimeChanged:
              time = libvlc_media_player_get_time(mp);
              printf("MediaPlayerTimeChanged %lld ms\n", (long long)time);
              break;
          case libvlc_MediaPlayerEndReached:
              printf ("MediaPlayerEndReached\n");
              done = 1;
              break;
          default:
              printf("%s\n", libvlc_event_type_name(pEvt-&gt;type));
      }
  }
  
  
  int _tmain(int argc, _TCHAR* argv[])
   {
      hMutex = CreateMutex( NULL, FALSE, _T("my_mutex"));
  
      cout &lt;&lt; "Test";
  
      // VLC pointers 
      libvlc_instance_t *inst;
      libvlc_media_t *m;
      void *pUserData = 0;
  
      VideoDataStruct dataStruct;
  
      // VLC options
      char smem_options[1000];
  
      // RV24
      sprintf(smem_options
          , "#transcode{vcodec=RV24}:smem{"
           "video-prerender-callback=%lld,"
           "video-postrender-callback=%lld,"
           "video-data=%lld,"
           "no-time-sync},"
          , (long long int)(intptr_t)(void*)&amp;cbVideoPrerender
          , (long long int)(intptr_t)(void*)&amp;cbVideoPostrender
          , (long long int)(intptr_t)(void*)&amp;dataStruct
      );
  
      const char * const vlc_args[] = {
                "-I", "dummy",            // Don't use any interface
                "--ignore-config",        // Don't use VLC's config
                "--extraintf=logger",     // Log anything
                "--verbose=1",            // Be verbose
                "--sout", smem_options    // Stream to memory
                 };
  
      // We launch VLC
      inst = libvlc_new(sizeof(vlc_args) / sizeof(vlc_args[0]), vlc_args);
  
      /* Create a new item */
      m = libvlc_media_new_location(inst, "dshow://");
  
      /* Create a media player playing environement */
      mp = libvlc_media_player_new_from_media (m);
  
      libvlc_event_manager_t* eventManager = libvlc_media_player_event_manager(mp);
      libvlc_event_attach(eventManager, libvlc_MediaPlayerTimeChanged, handleEvent, pUserData);
      libvlc_event_attach(eventManager, libvlc_MediaPlayerEndReached, handleEvent, pUserData);
      libvlc_event_attach(eventManager, libvlc_MediaPlayerPositionChanged, handleEvent, pUserData);
  
      //libvlc_video_set_format(mp, "RV24", 240, 320, 240 * 3 );
  
      /* play the media_player */
      libvlc_media_player_play (mp);
  
      while(1)
      {
          if(videoBuffer)                                             // Check for invalid input
          {
              // CV_8UC3 = 8 bits, 3 chanels
              Mat img = Mat(Size(240, 320), CV_8UC3, videoBuffer);
              // cvtColor(img, img, CV_RGB2BGR);
              namedWindow("Display window", WINDOW_AUTOSIZE);         // Create a window for display.
              imshow("Display window", img);                          // Show our image inside it.
          }
      }
      Sleep (500000); /* Let it play a bit */
      libvlc_release (inst);
  }
  </code></pre>