CaptureToolkit.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) 2012 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
 
-----------------------------------------------------------------------------
*/
 
/*
 Toolkit based on OpenCV library
 First version : dec 2010
 Author : Bastien BOURINEAU
 */
 
#include "Prerequisites.h"
#include "ICameraInput.h"
#include "ScolConvert.h"
#include <opencv2/highgui/highgui.hpp>
 
#ifdef APPLE_IOS
# include "CameraPermissionIOS.h"
 
extern int(*CallMainThread)(void*, mmachine m);
#endif
 
// OBJCAPTURE Scol
int OBJCAPTURESCOL;
 
// CALLBACK
int NBCAPTURECB = 0;
 
// ~All platforms yet
#include "CameraInputOpenCV.h"
 
#if SCOL_CAMERA_OPENCV
  typedef CameraInputOpenCV CCameraInput;
#else
  #ifdef _WIN32 // Only Windows
    #include "CameraInputWindows.h"
    typedef CameraInputWindows CCameraInput;
  #elif ANDROID // Only Android
    #include "CameraInputAndroid.h"
    typedef CameraInputAndroid CCameraInput;
  #endif
#endif
 
int destroyCaptureObj(mmachine m, SCOL_PTR_TYPE handsys, int obj)
{
  ICameraInput* CaptureOBJ = MMgetPointer<ICameraInput*>(m, MTOP(obj));
  SAFE_DELETE(CaptureOBJ);
 
  MMsetPointer<ICameraInput*>(m, MTOP(obj), 0);
 
  MMechostr(MSKDEBUG, "ObjCapture destroyed.\n");
  return 0;
}
 
 
int _DScapture(mmachine m)
{
#ifdef  _SCOL_DEBUG_
  MMechostr(MSKDEBUG, "_DScapture\n");
#endif
 
  int obj = MMget(m, 0);
  if (obj == NIL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  OBJdelTM(m, OBJCAPTURESCOL, obj);
  MMset(m, 0, ITOM(0));
 
#ifdef  _SCOL_DEBUG_
  MMechostr(MSKDEBUG, "ok\n");
#endif
  return 0;
}
 
#ifdef APPLE_IOS
int CheckCameraPermissionSync(mmachine m)
{
  CheckCameraPermission();
  return 0;
}
#endif
 
#ifdef APPLE_IOS
int _CRcaptureSync(mmachine m)
#else
int _CRcapture(mmachine m)
#endif
{
#ifdef  _SCOL_DEBUG_
  MMechostr(MSKDEBUG, "_CRcapture\n");
#endif
 
#ifdef APPLE_IOS
  //send pause / sync ?
  //CallMainThread((void*)CheckCameraPermissionSync, m);
  CheckCameraPermission();
#endif
 
  int sidx = MMpull(m);
  int idx = 0;
  if ((sidx != NIL) && (MTOI(sidx) > 0))
    idx = MTOI(sidx);
 
  ICameraInput* CaptureOBJ = new CCameraInput(idx);
 
  // failed to create device
  if (!CaptureOBJ)
  {
    MMechostr(MSKDEBUG, "Failed to create device\n");
    MMset(m, 0, NIL);
    return 0;
  }
 
  // failed to open device
  if (!CaptureOBJ->Initialize())
  {
    MMechostr(MSKDEBUG, "Failed to open device\n");
    SAFE_DELETE(CaptureOBJ);
    MMset(m, 0, NIL);
    return 0;
  }
 
  if ((MMpushPointer(m, CaptureOBJ) != 0))
  {
    SAFE_DELETE(CaptureOBJ);
    MMset(m, 0, NIL);
    return MERRMEM;
  }
 
#ifdef  _SCOL_DEBUG_
  MMechostr(MSKDEBUG, "ok\n");
#endif
  return OBJcreate(m, OBJCAPTURESCOL, SCOL_PTR CaptureOBJ, NIL, 0);
}
 
#ifdef APPLE_IOS
int _CRcapture(mmachine m)
{
  return CallMainThread((void*)_CRcaptureSync, m);
}
#endif
 
 
int _BLTcapture(mmachine m)
{
#ifdef  _SCOL_DEBUG_
  MMechostr(MSKDEBUG, "_BLTcapture\n");
#endif
 
  int bitmap = MMpull(m);
  int capture = MMget(m, 0);
  if ((capture == NIL) || (bitmap == NIL))
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  ICameraInput* CaptureOBJ = MMgetPointer<ICameraInput*>(m, MTOP(capture));
  if (CaptureOBJ == NULL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  cv::Mat image;
  try
  {
    image = CaptureOBJ->UpdateImage();
  }
  catch (std::exception e)
  {
    //MMechostr(MSKDEBUG, " error : %s \n", e.what());
    MMset(m, 0, NIL);
    return 0;
  }
    
  if (image.empty())
  {
    MMset(m, 0, NIL);
    return 0;
  }
  
  PtrObjVoid OB = (PtrObjVoid) MMstart(m, MTOP(bitmap));
  PtrObjBitmap B = (PtrObjBitmap) MMstart(m, MTOP(OB->Buffer));
 
  if (B->bits == 0)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  //needed when pixel format is not the same also
  cv::Mat imgdest;
  if (B->TailleH != image.rows || B->TailleW != image.cols)
  {
    imgdest = cv::Mat(B->TailleH, B->TailleW, image.type());
    cv::resize(image, imgdest, imgdest.size(), 0, 0, cv::INTER_LINEAR);
  }
  else
    imgdest = image;
 
  ConversionTools::MatToScolBitmapRGB(imgdest, B);
  
  MMset(m, 0, bitmap);
 
#ifdef  _SCOL_DEBUG_
  MMechostr(MSKDEBUG, "ok\n");
#endif
  return 0;
}
 
 
int _GETcaptureBuffer(mmachine m)
{
#ifdef  _SCOL_DEBUG_
  MMechostr(MSKDEBUG, "_BLTcapture\n");
#endif
 
  int capture = MMget(m, 0);
  if (capture == NIL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  ICameraInput* CaptureOBJ = MMgetPointer<ICameraInput*>(m, MTOP(capture));
  if (CaptureOBJ == NULL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  cv::Mat image;
  try
  {
    image = CaptureOBJ->UpdateImage();
  }
  catch (std::exception e)
  {
    //MMechostr(MSKDEBUG, " error : %s \n", e.what());
    MMset(m, 0, NIL);
    return 0;
  }
 
  if (image.empty())
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  MMpull(m);
  if ((MMpushPointer(m, image.data) != 0))
  {
    MMpush(m, NIL);
    return 0;
  }
 
#ifdef  _SCOL_DEBUG_
  MMechostr(MSKDEBUG, "ok\n");
#endif
  return 0;
}
 
int _GETcaptureBufferExt(mmachine m)
{
#ifdef  _SCOL_DEBUG_
  MMechostr(MSKDEBUG, "_BLTcapture\n");
#endif
 
  int capture = MMget(m, 0);
  if (capture == NIL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  ICameraInput* CaptureOBJ = MMgetPointer<ICameraInput*>(m, MTOP(capture));
  if (CaptureOBJ == NULL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  cv::Mat image;
  try
  {
    image = CaptureOBJ->UpdateImage();
  }
  catch (std::exception e)
  {
    //MMechostr(MSKDEBUG, " error : %s \n", e.what());
    MMset(m, 0, NIL);
    return 0;
  }
 
  if (image.empty())
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  MMpull(m);
  //TODO use scol alignment in buffer
  if ((MMpushPointer(m, image.data) != 0))
  {
    MMpush(m, NIL);
    return 0;
  }
  MMpush (m, ITOM (image.cols));
  MMpush (m, ITOM (image.rows));
  MMpush (m, ITOM (image.channels()));
  MMpush (m, ITOM (4));
  MBdeftab (m);
 
#ifdef  _SCOL_DEBUG_
  MMechostr(MSKDEBUG, "ok\n");
#endif
  return 0;
}
 
int _GETcaptureDeviceList(mmachine m)
{
#ifdef SCOL_DEBUG
  MMechostr(0, "_GETcaptureDeviceList\n");
#endif
 
  std::vector<std::string> devicesList = ICameraInput::GetDevicesList();
 
  if (devicesList.empty())
  {
    MMpush(m, NIL);
    return 0;
  }
 
  int k;
 
  for (unsigned int i = 0; i < devicesList.size(); i++)
  {
    if ((k = Mpushstrbloc(m, const_cast<char*>(devicesList[i].c_str())))) return k;
  }
 
  if (MMpush(m, NIL)) return MERRMEM;
 
  for (unsigned int j = 0; j < devicesList.size(); j++)
  {
    if (MMpush(m, 2 * 2)) return MERRMEM;
    if ((k = MBdeftab(m))) return k;
  }
 
#ifdef SCOL_DEBUG
  MMechostr(0, "ok\n");
#endif
 
  return 0;
}
 
int _SETcaptureMirror(mmachine m)
{
#ifdef  _SCOL_DEBUG_
  MMechostr(MSKDEBUG, "_SETcaptureMirror\n");
#endif
 
  int mMode = MMpull(m);
  int capture = MMget(m, 0);
  if ((capture == NIL) || (mMode == NIL))
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  ICameraInput* CaptureOBJ = MMgetPointer<ICameraInput*>(m, MTOP(capture));
  if (CaptureOBJ == NULL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  CaptureOBJ->SetMirrorMode(MTOI(mMode) == 1);
 
  MMset(m, 0, ITOM(1));
 
#ifdef  _SCOL_DEBUG_
  MMechostr(MSKDEBUG, "ok\n");
#endif
  return 0;
}
 
int _GETcaptureSize(mmachine m)
{
#ifdef  _SCOL_DEBUG_
  MMechostr(MSKDEBUG, "_GETcaptureSize\n");
#endif
 
  int capture = MMget(m, 0);
  if (capture == NIL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  ICameraInput* CaptureOBJ = MMgetPointer<ICameraInput*>(m, MTOP(capture));
  if (CaptureOBJ == NULL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  int tupleSize = MMmalloc(m, 2, TYPETAB);
  if (tupleSize == NIL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  MMstore(m, tupleSize, 0, ITOM(CaptureOBJ->GetWidth()));
  MMstore(m, tupleSize, 1, ITOM(CaptureOBJ->GetHeight()));
  MMset(m, 0, PTOM(tupleSize));
 
#ifdef  _SCOL_DEBUG_
  MMechostr(MSKDEBUG, "ok\n");
#endif
  return 0;
}
 
int _SETcaptureSize(mmachine m)
{
#ifdef  _SCOL_DEBUG_
  MMechostr(MSKDEBUG, "_SETcaptureSize\n");
#endif
 
  int mHeight = MMpull(m);
  int mWidth = MMpull(m);
  int capture = MMget(m, 0);
 
  if ((capture == NIL) || (mHeight == NIL) || (mWidth == NIL))
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  ICameraInput* CaptureOBJ = MMgetPointer<ICameraInput*>(m, MTOP(capture));
 
  if (CaptureOBJ == NULL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  try
  {
    CaptureOBJ->SetSize(MTOI(mWidth), MTOI(mHeight));
  }
  catch (std::exception &)
  {
    MMechostr(MSKRUNTIME, "_SETcaptureSize failed!\n");
    MMset(m, 0, NIL);
    return 0;
  }
 
  MMset(m, 0, ITOM(1));
 
#ifdef  _SCOL_DEBUG_
  MMechostr(MSKDEBUG, "ok\n");
#endif
  return 0;
}
 
int _SETcaptureFocusPoint(mmachine m)
{
#ifdef  _SCOL_DEBUG_
  MMechostr(MSKDEBUG, "_SETcaptureFocusPoint\n");
#endif
 
  int mY = MMpull(m);
  int mX = MMpull(m);
  int capture = MMget(m, 0);
 
  if ((capture == NIL) || (mX == NIL) || (mY == NIL))
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  ICameraInput* CaptureOBJ = MMgetPointer<ICameraInput*>(m, MTOP(capture));
 
  if (CaptureOBJ == NULL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  try
  {
    CaptureOBJ->SetFocusPoint(MTOI(mX), MTOI(mY));
  }
  catch (std::exception &)
  {
    MMechostr(MSKRUNTIME, "_SETcaptureFocusPoint failed!\n");
    MMset(m, 0, NIL);
    return 0;
  }
 
  MMset(m, 0, ITOM(1));
 
#ifdef  _SCOL_DEBUG_
  MMechostr(MSKDEBUG, "ok\n");
#endif
  return 0;
}
 
int _SETcaptureTorchState(mmachine m)
{
#ifdef  _SCOL_DEBUG_
  MMechostr(MSKDEBUG, "_SETcaptureTorchState\n");
#endif
 
  int mMode = MMpull(m);
  int capture = MMget(m, 0);
  if ((capture == NIL) || (mMode == NIL))
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  ICameraInput* CaptureOBJ = MMgetPointer<ICameraInput*>(m, MTOP(capture));
  if (CaptureOBJ == NULL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  CaptureOBJ->SetTorchState(MTOI(mMode) == 1);
 
  MMset(m, 0, ITOM(1));
 
#ifdef  _SCOL_DEBUG_
  MMechostr(MSKDEBUG, "ok\n");
#endif
  return 0;
}
 
int _SAVEcaptureToFile(mmachine m)
{
#ifdef  _SCOL_DEBUG_
  MMechostr(MSKDEBUG, "_SAVEcaptureToFile\n");
#endif
  int path = MMpull(m);
  int capture = MMget(m, 0);
  if (capture == NIL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  std::string spath(MMstartstr(m, MTOP(path)));
 
  ICameraInput* CaptureOBJ = MMgetPointer<ICameraInput*>(m, MTOP(capture));
  if (CaptureOBJ == NULL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  bool success = CaptureOBJ->TakeSnapshot(spath);
  MMset(m, 0, (success) ? ITOM(1) : ITOM(0));
 
#ifdef  _SCOL_DEBUG_
  MMechostr(MSKDEBUG, "ok\n");
#endif
 
  return 0;
}
 
int _AUTORENDERcapture(mmachine m)
{
#ifdef  _SCOL_DEBUG_
  MMechostr(MSKDEBUG, "_AUTORENDERcapture\n");
#endif
  int capture = MMget(m, 0);
  if (capture == NIL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  ICameraInput* CaptureOBJ = MMgetPointer<ICameraInput*>(m, MTOP(capture));
  if (CaptureOBJ == NULL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
#ifdef ANDROID
  CaptureOBJ->RenderToScreen();
  MMset(m, 0, ITOM(1));
#else
  MMechostr(MSKDEBUG, "_AUTORENDERcapture is not implemented on this platform\n");
  MMset(m, 0, ITOM(0));
#endif
 
  return 0;
}
 
/*
*********************************************
* SCOL PART
*********************************************
*/
 
static NativeDefinition sCaptkDef[] =
{
  { "ObjCapture",              TYPTYPE,         NULL,                                     NULL         },
  { "_CRcapture",              2,         "fun [Chn I] ObjCapture",                 _CRcapture            },
  { "_DScapture",              1,         "fun [ObjCapture] I",                     _DScapture            },
  { "_BLTcapture",             2,         "fun [ObjCapture ObjBitmap] ObjBitmap",   _BLTcapture           },
  { "_GETcaptureBuffer",       1,         "fun [ObjCapture] ObjBuff",               _GETcaptureBuffer     },
  { "_GetcaptureBuffer",       1,         "fun [ObjCapture] ObjBuff",               _GETcaptureBuffer     }, //legacy
  { "_GETcaptureBufferExt",    1,         "fun [ObjCapture] [ObjBuff I I I]",       _GETcaptureBufferExt  },
  { "_GETcaptureDeviceList",   0,         "fun [] [S r1]",                          _GETcaptureDeviceList },
  { "_SETcaptureMirror",       2,         "fun [ObjCapture I] I",                   _SETcaptureMirror     },
  { "_GETcaptureSize",         1,         "fun [ObjCapture][I I]",                  _GETcaptureSize       },
  { "_SETcaptureSize",         3,         "fun [ObjCapture I I] I",                 _SETcaptureSize       },
  { "_SETcaptureFocusPoint",   3,         "fun [ObjCapture I I] I",                 _SETcaptureFocusPoint },
  { "_SETcaptureTorchState",   2,         "fun [ObjCapture I] I",                   _SETcaptureTorchState },
  { "_SAVEcaptureToFile",      2,         "fun [ObjCapture W] I",                   _SAVEcaptureToFile    },
  { "_AUTORENDERcapture",      1,         "fun [ObjCapture] I",                     _AUTORENDERcapture    }
};
 
// Everything inside _cond and _endcond is ignored by doxygen
 
int LoadCaptureToolkit(mmachine m)
{
  MMechostr(MSKDEBUG, " > Loading CaptureToolkit\n");
  OBJCAPTURESCOL = OBJregister(NBCAPTURECB, 0, destroyCaptureObj, "OBJCAPTURESCOL");
 
  int k = PKhardpak2(m, "CaptureToolkitEngine.pkg-1.0", sizeof(sCaptkDef) / sizeof(sCaptkDef[0]), sCaptkDef);
  MMechostr(MSKDEBUG, " > Successfully Loaded\n\n");
  return k;
}