MediaPlayerToolkit.cpp

Go to the documentation of this file.

/*
-----------------------------------------------------------------------------
This source file is part of OpenSpace3D
For the latest info, see http://www.openspace3d.com
 
Copyright (c) 2016 I-maginer
 
This program is free software; you can redistribute it and/or modify it under
the terms of the GNU Lesser General Public License as published by the Free Software
Foundation; either version 2 of the License, or (at your option) any later
version.
 
This program is distributed in the hope that it will be useful, but WITHOUT
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.
 
You should have received a copy of the GNU Lesser General Public License along with
this program; if not, write to the Free Software Foundation, Inc., 59 Temple
Place - Suite 330, Boston, MA 02111-1307, USA, or go to
http://www.gnu.org/copyleft/lesser.txt
 
-----------------------------------------------------------------------------
*/
 
#include <scolPlugin.h>
 
#include <limits>
#include "MediaPlayer.h"
#include "ScolConvert.h"
 
/*
 Scol toolkit for the MediaPlayer object
 First version : jan 2016
 Author : Hector Labanca
 */
 
int OBJMEDIAPLAYERSCOL;
int NBMEDIAPLAYER_CALLBACK = 2;
int MEDIAPLAYER_END_CB;
int MEDIAPLAYER_LOADED_CB;
int SCOL_MEDIAPLAYER_END_CB = 0;
int SCOL_MEDIAPLAYER_LOADED_CB = 1;
 
// Helper function to retrieve a media player parameter from the machine.
MediaPlayer* getPlayerFromStack(mmachine m, int pos)
{
  int playerPtr = MMget(m, pos);
  if (playerPtr == NIL)
    return NULL;
 
  SCOL_PTR_TYPE player = *(SCOL_PTR_TYPE*)MMstart(m, MTOP(playerPtr));
  return (MediaPlayer*)player;
}
 
int destroyMediaPlayerObj(mmachine m, SCOL_PTR_TYPE handsys, int objm)
{
  MediaPlayer* player = (MediaPlayer*) handsys;
  SAFE_DELETE(player);
 
  //reset buffer value
  *(SCOL_PTR_TYPE*)MMstart(m, MTOP(objm)) = 0;
 
  return 0;
}
 
int _CRmediaPlayer(mmachine m)
{
#ifdef  _SCOL_DEBUG_
  MMechostr(MSKDEBUG, "_CRMediaPlayer\n");
#endif
  // Make sure the channel is there
  if (MMget(m, 0)==NIL)
    return SCERRSET(m, EARGNIL, MSKDEBUG);
 
  MediaPlayer* player = 0;
  try
  {
    player = new MediaPlayer();
  }
  catch (std::exception &)
  {
    return SCERRSET(m, EMEM, MSKDEBUG);
  }
 
  if ((MMpushPointer(m, player) != 0))
  {
    SAFE_DELETE(player);
    return SCERRVM(m, MERRMEM);
  }
 
  return OBJcreate(m, OBJMEDIAPLAYERSCOL, SCOL_PTR player, NIL, 0);
}
 
int _DSmediaPlayer(mmachine m)
{
#ifdef  _SCOL_DEBUG_
  MMechostr(MSKDEBUG, "_DSMediaPlayer\n");
#endif
        int obj = MMget(m, 0);
        if (obj == NIL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  OBJdelTM(m, OBJMEDIAPLAYERSCOL, obj);
 
        MMset(m, 0, ITOM(0));
  return 0;
}
 
int _OPENmediaPlayerUrl(mmachine m)
{
#ifdef  _SCOL_DEBUG_
  MMechostr(MSKDEBUG, "_OPENmediaPlayerUrl\n");
#endif
  int ipath = MMpull(m);
  MediaPlayer* player = getPlayerFromStack(m, 0);
 
        if ((player == NULL) || (ipath == NIL))
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  std::string path = MMstartstr(m, MTOP(ipath));
  if (path.empty())
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  try
  {
    player->OpenUrl(path);
  }
  catch(std::exception &e)
  {
    std::string errs = e.what();
    MMechostr(MSKRUNTIME, "_OPENmediaPlayerUrl : %s", e.what());
    MMset(m, 0, NIL);
    return 0;
  }
 
  return 0;
}
 
int _OPENmediaPlayerFile(mmachine m)
{
#ifdef  _SCOL_DEBUG_
  MMechostr(MSKDEBUG, "_OPENmediaPlayerFile\n");
#endif
  int ipath = MMpull(m);
  MediaPlayer* player = getPlayerFromStack(m, 0);
 
        if ((player == NULL) || (ipath == NIL))
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  std::string path = MMstartstr(m, MTOP(ipath));
  if (path.empty())
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  try
  {
    player->Open(path);
  }
  catch(std::exception &e)
  {
    MMechostr(MSKRUNTIME, "_OPENmediaPlayerFile : %s", e.what());
    MMset(m, 0, NIL);
    return 0;
  }
 
  return 0;
}
 
int _BLTmediaPlayer(mmachine m)
{
#ifdef  _SCOL_DEBUG_
  MMechostr(MSKDEBUG, "_BLTmediaPlayer\n");
#endif
  int bitmap = MMpull(m);
  MediaPlayer* player = getPlayerFromStack(m, 0);
 
  if ((player == NULL) || (bitmap == NIL))
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  PtrObjVoid OB = (PtrObjVoid) MMstart(m, MTOP(bitmap));
  PtrObjBitmap B = (PtrObjBitmap) MMstart(m, MTOP(OB->Buffer));
 
  if (player->GetFrame(B))
    MMset(m, 0, bitmap);
  else
    MMset(m, 0, NIL);
 
  return 0;
}
 
int _BLTmediaPlayerBuffer(mmachine m)
{
#ifdef  _SCOL_DEBUG_
  MMechostr(MSKDEBUG, "_BLTmediaPlayerBuffer\n");
#endif
  int ibytesperpixel = MMpull(m);
  int iheight = MMpull(m);
  int iwidth = MMpull(m);
  int iBuff = MMpull(m);
 
  MediaPlayer* player = getPlayerFromStack(m, 0);
 
  if ((player == NULL) || (iBuff == NIL) || (iwidth == NIL) || (iheight == NIL) || (ibytesperpixel == NIL))
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  unsigned char* buffer = MMgetPointer<unsigned char*>(m, MTOP(iBuff));
  if (buffer == NULL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  ibytesperpixel = MTOI(ibytesperpixel);
  iheight = MTOI(iheight);
  iwidth = MTOI(iwidth);
 
  cv::Mat imagesrc = ConversionTools::ScolBitmapBufferToMat((void*)buffer, iwidth, iheight, ibytesperpixel);
  if (imagesrc.empty())
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  if (player->GetFrame(imagesrc))
    MMset(m, 0, iBuff);
  else
    MMset(m, 0, NIL);
 
  return 0;
}
 
int _GETmediaPlayerBuffer(mmachine m)
{
#ifdef  _SCOL_DEBUG_
  MMechostr(MSKDEBUG, "_GETmediaPlayerBuffer\n");
#endif
 
  MediaPlayer* player = getPlayerFromStack(m, 0);
 
  if (player == NULL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
  
  cv::Mat frame = player->GetFrame();
  if (frame.empty())
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  MMpull(m);
  if ((MMpushPointer(m, frame.data) != 0))
  {
    MMpush(m, NIL);
    return 0;
  }
 
  MMpush(m, ITOM(frame.cols));
  MMpush(m, ITOM(frame.rows));
  MMpush(m, ITOM(frame.channels()));
  MMpush(m, ITOM(4));
  MBdeftab(m);
 
  return 0;
}
 
int _PLAYmediaPlayer(mmachine m)
{
#ifdef  _SCOL_DEBUG_
  MMechostr(MSKDEBUG, "_PLAYmediaPlayer\n");
#endif
 
  MediaPlayer* player = getPlayerFromStack(m, 0);
 
  if (player == NULL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  try
  {
    player->Play(-1);
  }
  catch (std::exception &e)
  {
    MMechostr(MSKRUNTIME, "_PLAYmediaPlayer : %s\n", e.what());
    MMset(m, 0, NIL);
  }
 
  return 0;
}
 
int _PAUSEmediaPlayer(mmachine m)
{
#ifdef  _SCOL_DEBUG_
  MMechostr(MSKDEBUG, "_PAUSEmediaPlayer\n");
#endif
 
  MediaPlayer* player = getPlayerFromStack(m, 0);
 
  if (player == NULL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  try
  {
    player->Pause();
  }
  catch (std::exception &e)
  {
    MMechostr(MSKRUNTIME, "_PAUSEmediaPlayer : %s\n", e.what());
    MMset(m, 0, NIL);
  }
 
  return 0;
}
 
int _STOPmediaPlayer(mmachine m)
{
#ifdef  _SCOL_DEBUG_
  MMechostr(MSKDEBUG, "_STOPmediaPlayer\n");
#endif
 
  MediaPlayer* player = getPlayerFromStack(m, 0);
 
  if (player == NULL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  player->Stop();
  return 0;
}
 
int _SETmediaPlayerSize(mmachine m)
{
#ifdef  _SCOL_DEBUG_
  MMechostr(MSKDEBUG, "_SETmediaPlayerSize\n");
#endif
  int iheight = MMpull(m);
  int iwidth = MMpull(m);
  MediaPlayer* player = getPlayerFromStack(m, 0);
 
  if (player == NULL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  int width = 0;
  if (iwidth != NIL)
    width = abs(MTOI(iwidth));
 
  int height = 0;
  if (iheight != NIL)
    height = abs(MTOI(iheight));
 
  player->SetSize(width, height);
  return 0;
}
 
int _GETmediaPlayerSize(mmachine m)
{
#ifdef  _SCOL_DEBUG_
  MMechostr(MSKDEBUG, "_GETmediaPlayerSize\n");
#endif
  MediaPlayer* player = getPlayerFromStack(m, 0);
 
  if (player == NULL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  int width = 0;
  int height = 0;
 
  try
  {
    player->GetSize(width, height);
  }
  catch (std::exception& e)
  {
    MMechostr(MSKRUNTIME, "_GETmediaPlayerSize : %s\n", e.what());
    MMset(m, 0, NIL);
    return 0;
  }
 
  int result = MMmalloc(m, 2, TYPETAB);
        if(result==NIL)
  {
    MMset(m, 0, NIL);
    return MERRMEM;
  }
 
        MMstore(m, result, 0, ITOM(width));
        MMstore(m, result, 1, ITOM(height));
        MMset(m, 0, PTOM(result));
 
  return 0;
}
 
int _GETmediaPlayerSourceSize(mmachine m)
{
#ifdef  _SCOL_DEBUG_
  MMechostr(MSKDEBUG, "_GETmediaPlayerSourceSize\n");
#endif
  MediaPlayer* player = getPlayerFromStack(m, 0);
 
  if (player == NULL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  int width = 0;
  int height = 0;
 
  try
  {
    player->GetSourceSize(width, height);
  }
  catch (std::exception& e)
  {
    MMechostr(MSKRUNTIME, "_GETmediaPlayerSourceSize : %s\n", e.what());
    MMset(m, 0, NIL);
    return 0;
  }
 
  int result = MMmalloc(m, 2, TYPETAB);
        if(result==NIL)
  {
    MMset(m, 0, NIL);
    return MERRMEM;
  }
 
        MMstore(m, result, 0, ITOM(width));
        MMstore(m, result, 1, ITOM(height));
        MMset(m, 0, PTOM(result));
 
  return 0;
}
 
int _GETmediaPlayerTime(mmachine m)
{
#ifdef  _SCOL_DEBUG_
  MMechostr(MSKDEBUG, "_GETmediaPlayerTime\n");
#endif
 
  MediaPlayer* player = getPlayerFromStack(m, 0);
 
  if (player == NULL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  long time = 0;
  try
  {
    time = player->GetCurrentTime();
  }
  catch (std::exception& e)
  {
    MMechostr(MSKRUNTIME, "_GETmediaPlayerTime : %s\n", e.what());
    MMset(m, 0, NIL);
    return 0;
  }
 
  if (time > std::numeric_limits<int>::max())
  {
    MMechostr(MSKRUNTIME, "_GETmediaPlayerTime : warning : timestamp is too large for int type : %u\n", time);
    time = std::numeric_limits<int>::max();
  }
 
  MMset(m, 0, ITOM((int)time));
  return 0;
}
 
 
int _GETmediaPlayerLength(mmachine m)
{
#ifdef  _SCOL_DEBUG_
  MMechostr(MSKDEBUG, "_GETmediaPlayerTime\n");
#endif
 
  MediaPlayer* player = getPlayerFromStack(m, 0);
 
  if (player == NULL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  long length = 0;
  try
  {
    length = player->GetLength();
  }
  catch (std::exception& e)
  {
    MMechostr(MSKRUNTIME, "_GETmediaPlayerLength : %s\n", e.what());
    MMset(m, 0, NIL);
    return 0;
  }
 
  MMset(m, 0, ITOM((int)length));
  return 0;
}
 
int _SEEKmediaPlayer(mmachine m)
{
#ifdef  _SCOL_DEBUG_
  MMechostr(MSKDEBUG, "_SEEKmediaPlayer\n");
#endif
  int vtime = MMpull(m);
  if (vtime == NIL)
  {
    MMechostr(MSKRUNTIME, "_SEEKmediaPlayer : video time is nil.\n");
    MMset(m, 0, NIL);
    return 0;
  }
 
  vtime = MTOI(vtime);
  MediaPlayer* player = getPlayerFromStack(m, 0);
 
  if (player == NULL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  try
  {
    player->SetCurrentTime(vtime);
  }
  catch (std::exception& e)
  {
    MMechostr(MSKRUNTIME, "_SEEKmediaPlayer : %s\n", e.what());
    MMset(m, 0, NIL);
    return 0;
  }
 
  return 0;
}
 
int _SETmediaPlayerLoop(mmachine m)
{
#ifdef  _SCOL_DEBUG_
  MMechostr(MSKDEBUG, "_SETmediaPlayerLoop\n");
#endif
  int iloop = MMpull(m);
  MediaPlayer* player = getPlayerFromStack(m, 0);
 
  if (iloop == NIL)
  {
    MMechostr(MSKRUNTIME, "_SETmediaPlayerLoop : loop value is nil.\n");
    MMset(m, 0, NIL);
    return 0;
  }
 
  if (player == NULL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  player->SetLoop(MTOI(iloop) == 0 ? false : true);
 
  return 0;
}
 
int _SETmediaPlayerStream(mmachine m)
{
#ifdef  _SCOL_DEBUG_
  MMechostr(MSKDEBUG, "_SETmediaPlayerStream\n");
#endif
  int istream = MMpull(m);
  MediaPlayer* player = getPlayerFromStack(m, 0);
 
  if (istream == NIL)
  {
    MMechostr(MSKRUNTIME, "_SETmediaPlayerStream : stream index is nil.\n");
    MMset(m, 0, NIL);
    return 0;
  }
 
  if (player == NULL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  try
  {
    player->SetVideoStream(MTOI(istream));
  }
  catch (std::exception& e)
  {
    MMechostr(MSKRUNTIME, "_SETmediaPlayerStream : couldn't open stream %d : %s\n", MTOI(istream), e.what());
    MMset(m, 0, NIL);
  }
 
  return 0;
}
 
int _SETmediaPlayerAudioStream(mmachine m)
{
#ifdef  _SCOL_DEBUG_
  MMechostr(MSKDEBUG, "_SETmediaPlayerAudioStream\n");
#endif
  int istream = MMpull(m);
  MediaPlayer* player = getPlayerFromStack(m, 0);
 
  if (istream == NIL)
  {
    MMechostr(MSKRUNTIME, "_SETmediaPlayerAudioStream : stream index is nil.\n");
    MMset(m, 0, NIL);
    return 0;
  }
 
  if (player == NULL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  try
  {
    player->SetAudioStream(MTOI(istream));
  }
  catch (std::exception& e)
  {
    MMechostr(MSKRUNTIME, "_SETmediaPlayerAudioStream : couldn't open stream %d : %s\n", MTOI(istream), e.what());
    MMset(m, 0, NIL);
  }
 
  return 0;
}
 
int _GETmediaPlayerAudio(mmachine m)
{
#ifdef  _SCOL_DEBUG_
  MMechostr(MSKDEBUG, "_GETmediaPlayerAudio\n");
#endif
  MediaPlayer* player = getPlayerFromStack(m, 0);
 
  if (player == NULL || !player->HasAudio())
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  char tmpBuffer[MAX_OUT_BUFFER] = {0};
  int bytes = 0;
  try
  {
    bytes = player->GetAudioThreaded(tmpBuffer, MAX_OUT_BUFFER);
  }
  catch (std::exception& e)
  {
    MMechostr(MSKRUNTIME, "_GETmediaPlayerAudio : %s\n", e.what());
    MMset(m, 0, NIL);
    return 0;
  }
 
  if (bytes == 0)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  int res = MMmalloc(m, STR_SIZE(bytes), TYPEBUF);
  if (res == NIL)
  {
    MMset(m, 0, NIL);
    return MERRMEM;
  }
 
  MMstore(m, res, 0, bytes);
  char* buffer = MMstartstr(m, res);
  memcpy(buffer, tmpBuffer, bytes);
  buffer[bytes] = 0;
        MMset(m, 0, PTOM(res));
  return 0;
}
 
int _SETmediaPlayerAudioFormat(mmachine m)
{
#ifdef  _SCOL_DEBUG_
  MMechostr(MSKDEBUG, "_SETmediaPlayerAudioFormat\n");
#endif
  int irate = MMpull(m);
  int iformat = MMpull(m);
  MediaPlayer* player = getPlayerFromStack(m, 0);
 
  if ((irate == NIL) || (iformat == NIL) || (player == NULL))
  {
    MMechostr(MSKRUNTIME, "_SETmediaPlayerAudioFormat : one or more invalid parameter\n");
    MMset(m, 0, NIL);
    return 0;
  }
 
  try
  {
    player->SetAudioFormat(MediaPlayer::AudioFormats(MTOI(iformat)), MTOI(irate));
  }
  catch (const std::exception& e)
  {
    MMechostr(MSKRUNTIME, "_SETmediaPlayerAudioFormat error: %s\n", e.what());
    MMset(m, 0, NIL);
    return 0;
  }
 
  return 0;
}
 
int _GETmediaPlayerHasAudio(mmachine m)
{
#ifdef  _SCOL_DEBUG_
  MMechostr(MSKDEBUG, "_GETmediaPlayerHasAudio\n");
#endif
  MediaPlayer* player = getPlayerFromStack(m, 0);
 
  if (player == NULL)
  {
    MMechostr(MSKRUNTIME, "_GETmediaPlayerHasAudio : invalid media player object\n");
    MMset(m, 0, NIL);
    return 0;
  }
 
  int hasAudio = player->HasAudio() ? 1 : 0;
 
  MMset(m, 0, ITOM(hasAudio));
 
  return 0;
}
 
int _GETmediaPlayerHasVideo(mmachine m)
{
#ifdef  _SCOL_DEBUG_
  MMechostr(MSKDEBUG, "_GETmediaPlayerHasVideo\n");
#endif
  MediaPlayer* player = getPlayerFromStack(m, 0);
 
  if (player == NULL)
  {
    MMechostr(MSKRUNTIME, "_GETmediaPlayerHasVideo : invalid media player object\n");
    MMset(m, 0, NIL);
    return 0;
  }
 
  int hasVideo = player->HasVideo() ? 1 : 0;
 
  MMset(m, 0, ITOM(hasVideo));
 
  return 0;
}
 
int _GETmediaPlayerState(mmachine m)
{
#ifdef  _SCOL_DEBUG_
  MMechostr(MSKDEBUG, "_GETmediaPlayerState\n");
#endif
  MediaPlayer* player = getPlayerFromStack(m, 0);
 
  if (player == NULL)
  {
    MMechostr(MSKRUNTIME, "_GETmediaPlayerState : invalid media player object\n");
    MMset(m, 0, NIL);
    return 0;
  }
 
  int state = (int)player->GetState();
 
  MMset(m, 0, ITOM(state));
 
  return 0;
}
 
int _GETmediaPlayerIsLiveStream(mmachine m)
{
#ifdef  _SCOL_DEBUG_
  MMechostr(MSKDEBUG, "_GETmediaPlayerIsLiveStream\n");
#endif
  MediaPlayer* player = getPlayerFromStack(m, 0);
 
  if (player == NULL)
  {
    MMechostr(MSKRUNTIME, "_GETmediaPlayerIsLiveStream : invalid media player object\n");
    MMset(m, 0, NIL);
    return 0;
  }
 
  int isLive = player->IsLiveStream() ? 1 : 0;
 
  MMset(m, 0, ITOM(isLive));
 
  return 0;
}
 
int _GETmediaPlayerIsSeekable(mmachine m)
{
#ifdef  _SCOL_DEBUG_
  MMechostr(MSKDEBUG, "_GETmediaPlayerIsSeekable\n");
#endif
  MediaPlayer* player = getPlayerFromStack(m, 0);
 
  if (player == NULL)
  {
    MMechostr(MSKRUNTIME, "_GETmediaPlayerIsSeekable : invalid media player object\n");
    MMset(m, 0, NIL);
    return 0;
  }
 
  int isSeekable = player->IsSeekable() ? 1 : 0;
 
  MMset(m, 0, ITOM(isSeekable));
 
  return 0;
}
 
int _GETmediaPlayerAudioStreams(mmachine m)
{
#ifdef  _SCOL_DEBUG_
  MMechostr(MSKDEBUG, "_GETmediaPlayerAudioStreams\n");
#endif
  MediaPlayer* player = getPlayerFromStack(m, 0);
 
  if (player == NULL)
  {
    MMechostr(MSKRUNTIME, "_GETmediaPlayerAudioStreams : invalid media player object\n");
    MMset(m, 0, NIL);
    return 0;
  }
 
  std::vector<std::string> streams = player->ListStreams(AVMEDIA_TYPE_AUDIO);
 
  if (streams.empty())
  {
    MMechostr(MSKRUNTIME, "_GETmediaPlayerAudioStreams : no audio stream\n");
    MMset(m, 0, NIL);
    return 0;
  }
 
  // The initial argument is still there, remove it now
  MMpull(m);
 
  for (unsigned int i = 0; i < streams.size(); i++)
  {
    std::string data = streams.at(i);
    Mpushstrbloc(m, (char*)data.c_str());
        }
 
        if(MMpush(m, NIL))
    return MERRMEM;
 
  for (unsigned int i = 0; i < streams.size(); i++)
        {
                if (MMpush(m, 2*2))
      return MERRMEM;
 
    if (int k=MBdeftab(m))
      return k;
        }
 
  return 0;
}
 
int _GETmediaPlayerVideoStreams(mmachine m)
{
#ifdef  _SCOL_DEBUG_
  MMechostr(MSKDEBUG, "_GETmediaPlayerVideoStreams\n");
#endif
  MediaPlayer* player = getPlayerFromStack(m, 0);
 
  if (player == NULL)
  {
    MMechostr(MSKRUNTIME, "_GETmediaPlayerVideoStreams : invalid media player object\n");
    MMset(m, 0, NIL);
    return 0;
  }
 
  std::vector<std::string> streams = player->ListStreams(AVMEDIA_TYPE_VIDEO);
 
  if (streams.empty())
  {
    MMechostr(MSKRUNTIME, "_GETmediaPlayerAudioStreams : no video stream\n");
    MMset(m, 0, NIL);
    return 0;
  }
 
  MMpull(m);
 
  for (unsigned int i = 0; i < streams.size(); i++)
  {
    std::string data = streams.at(i);
    Mpushstrbloc(m, (char*)data.c_str());
        }
 
        if(MMpush(m, NIL))
    return MERRMEM;
 
  for (unsigned int i = 0; i < streams.size(); i++)
        {
                if (MMpush(m, 2*2))
      return MERRMEM;
 
    if (int k=MBdeftab(m))
      return k;
        }
 
  return 0;
}
 
// Callbacks
 
int _CBmediaPlayerEnd(mmachine m)
{
        return OBJaddreflex(m, OBJMEDIAPLAYERSCOL, SCOL_MEDIAPLAYER_END_CB);
}
 
int getMediaPlayerEndCb(mmachine m, SCOL_PTR_TYPE id, SCOL_PTR_TYPE ret)
{
        MediaPlayer* player = (MediaPlayer *) id;
 
  if (!MediaPlayer::IsValidPlayer(player))
    return 0;
 
        // OBJbeginreflex(mmachine, objecttype, objectptr, cbtype)
  if (OBJbeginreflex(m, OBJMEDIAPLAYERSCOL, SCOL_PTR player, SCOL_MEDIAPLAYER_END_CB))
                return 0;
 
        return OBJcallreflex(m, 0);
}
 
int _CBmediaPlayerLoaded(mmachine m)
{
  return OBJaddreflex(m, OBJMEDIAPLAYERSCOL, SCOL_MEDIAPLAYER_LOADED_CB);
}
 
int getMediaPlayerLoadedCb(mmachine m, SCOL_PTR_TYPE id, SCOL_PTR_TYPE ret)
{
  MediaPlayer* player = (MediaPlayer *)id;
 
  if (!MediaPlayer::IsValidPlayer(player))
    return 0;
 
  // OBJbeginreflex(mmachine, objecttype, objectptr, cbtype)
  if (OBJbeginreflex(m, OBJMEDIAPLAYERSCOL, SCOL_PTR player, SCOL_MEDIAPLAYER_LOADED_CB))
    return 0;
 
  MMpush(m, ITOM((int)ret));
 
  return OBJcallreflex(m, 1);
}
 
// Everything inside _cond and _endcond is ignored by doxygen
 
NativeDefinition videoToolkitEngine[] =
{
  { "ObjMediaPlayer", TYPTYPE, NULL, NULL },
  { "MP_AUDIO_8BIT_MONO", TYPVAR, "I", SCOL_TYPTYPE(MediaPlayer::AUDIO_8BIT_MONO) },
  { "MP_AUDIO_8BIT_STEREO", TYPVAR, "I", SCOL_TYPTYPE(MediaPlayer::AUDIO_8BIT_STEREO) },
  { "MP_AUDIO_16BIT_MONO", TYPVAR, "I", SCOL_TYPTYPE(MediaPlayer::AUDIO_16BIT_MONO) },
  { "MP_AUDIO_16BIT_STEREO", TYPVAR, "I", SCOL_TYPTYPE(MediaPlayer::AUDIO_16BIT_STEREO) },
  { "MP_STATE_STOPPED", TYPVAR, "I", SCOL_TYPTYPE(MediaPlayer::STOPPED) },
  { "MP_STATE_PLAYING", TYPVAR, "I", SCOL_TYPTYPE(MediaPlayer::PLAYING) },
  { "MP_STATE_PAUSED", TYPVAR, "I", SCOL_TYPTYPE(MediaPlayer::PAUSED) },
  { "_CRmediaPlayer", 1, "fun [Chn] ObjMediaPlayer", _CRmediaPlayer },
  { "_DSmediaPlayer", 1, "fun [ObjMediaPlayer] I", _DSmediaPlayer },
  { "_OPENmediaPlayerUrl", 2, "fun [ObjMediaPlayer S] ObjMediaPlayer", _OPENmediaPlayerUrl },
  { "_OPENmediaPlayerFile", 2, "fun [ObjMediaPlayer P] ObjMediaPlayer", _OPENmediaPlayerFile },
  { "_BLTmediaPlayer", 2, "fun [ObjMediaPlayer ObjBitmap] ObjBitmap", _BLTmediaPlayer },
  { "_BLTmediaPlayerBuffer", 5, "fun [ObjMediaPlayer ObjBuff I I I] ObjBuff", _BLTmediaPlayerBuffer },
  { "_GETmediaPlayerBuffer", 1, "fun [ObjMediaPlayer] [ObjBuff I I I]", _GETmediaPlayerBuffer },
  { "_PLAYmediaPlayer", 1, "fun [ObjMediaPlayer] ObjMediaPlayer", _PLAYmediaPlayer },
  { "_PAUSEmediaPlayer", 1, "fun [ObjMediaPlayer] ObjMediaPlayer", _PAUSEmediaPlayer },
  { "_STOPmediaPlayer", 1, "fun [ObjMediaPlayer] ObjMediaPlayer", _STOPmediaPlayer },
  { "_SETmediaPlayerSize", 3, "fun [ObjMediaPlayer I I] ObjMediaPlayer", _SETmediaPlayerSize },
  { "_GETmediaPlayerSize", 1, "fun [ObjMediaPlayer] [I I]", _GETmediaPlayerSize },
  { "_GETmediaPlayerSourceSize", 1, "fun [ObjMediaPlayer] [I I]", _GETmediaPlayerSourceSize },
  { "_GETmediaPlayerTime", 1, "fun [ObjMediaPlayer] I", _GETmediaPlayerTime },
  { "_GETmediaPlayerLength", 1, "fun [ObjMediaPlayer] I", _GETmediaPlayerLength },
  { "_SEEKmediaPlayer", 2, "fun [ObjMediaPlayer I] ObjMediaPlayer", _SEEKmediaPlayer },
  { "_SETmediaPlayerLoop", 2, "fun [ObjMediaPlayer I] ObjMediaPlayer", _SETmediaPlayerLoop },
  { "_SETmediaPlayerStream", 2, "fun [ObjMediaPlayer I] ObjMediaPlayer", _SETmediaPlayerStream },
  { "_SETmediaPlayerAudioStream", 2, "fun [ObjMediaPlayer I] ObjMediaPlayer", _SETmediaPlayerAudioStream },
  { "_GETmediaPlayerAudio", 1, "fun [ObjMediaPlayer] S", _GETmediaPlayerAudio },
  { "_SETmediaPlayerAudioFormat", 3, "fun [ObjMediaPlayer I I] ObjMediaPlayer", _SETmediaPlayerAudioFormat },
  { "_GETmediaPlayerHasAudio", 1, "fun [ObjMediaPlayer] I", _GETmediaPlayerHasAudio },
  { "_GETmediaPlayerHasVideo", 1, "fun [ObjMediaPlayer] I", _GETmediaPlayerHasVideo },
  { "_GETmediaPlayerState", 1, "fun [ObjMediaPlayer] I", _GETmediaPlayerState },
  { "_GETmediaPlayerIsLiveStream", 1, "fun [ObjMediaPlayer] I", _GETmediaPlayerIsLiveStream },
  { "_GETmediaPlayerIsSeekable", 1, "fun [ObjMediaPlayer] I", _GETmediaPlayerIsSeekable },
  { "_GETmediaPlayerAudioStreams", 1, "fun [ObjMediaPlayer] [S r1]", _GETmediaPlayerAudioStreams },
  { "_GETmediaPlayerVideoStreams", 1, "fun [ObjMediaPlayer] [S r1]", _GETmediaPlayerVideoStreams },
  { "_CBmediaPlayerEnd", 3, "fun [ObjMediaPlayer fun [ObjMediaPlayer u0] u1 u0] ObjMediaPlayer", _CBmediaPlayerEnd},
  { "_CBmediaPlayerLoaded", 3, "fun [ObjMediaPlayer fun [ObjMediaPlayer u0 I] u1 u0] ObjMediaPlayer", _CBmediaPlayerLoaded}
};
 
int LoadMediaPlayerToolkit(mmachine m)
{
  int k;
  MMechostr(MSKDEBUG, " > Loading MediaPlayerToolkit\n");
  MediaPlayer::InitFFmpeg();
 
  MEDIAPLAYER_END_CB = OBJgetUserEvent();
  OBJdefEvent(MEDIAPLAYER_END_CB, getMediaPlayerEndCb);
 
  MEDIAPLAYER_LOADED_CB = OBJgetUserEvent();
  OBJdefEvent(MEDIAPLAYER_LOADED_CB, getMediaPlayerLoadedCb);
 
  OBJMEDIAPLAYERSCOL = OBJregister(NBMEDIAPLAYER_CALLBACK, 0, destroyMediaPlayerObj, "OBJMEDIAPLAYERSCOL");
 
  k = PKhardpak2(m, "MediaPlayerToolkitEngine", sizeof(videoToolkitEngine) / sizeof(videoToolkitEngine[0]), videoToolkitEngine);
  MMechostr(MSKDEBUG, " > Successfully Loaded\n\n");
  return k;
}
 
int UnloadMediaPlayerToolkit()
{
  MMechostr(MSKDEBUG,"\n");
  MMechostr(MSKDEBUG," > Unloading MediaPlayerToolkit\n");
 
  MediaPlayer::DeInitFFmpeg();
        MMechostr(MSKDEBUG," > Successfully Unloaded\n\n");
        return 0;
}