CameraInput.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
 
-----------------------------------------------------------------------------
*/
 
#include "CameraInput.h"
 
#ifdef _WIN32
#include <dshow.h>
#endif
 
std::list<CameraInput*> CameraInput::cameraInputsList;
 
#ifdef ANDROID
static cv::Size calc_optimal_camera_resolution(const char* supported, int width, int height)
{
  int frame_width = 0;
  int frame_height = 0;
 
  size_t prev_idx = 0;
  size_t idx = 0;
  float min_diff = FLT_MAX;
 
  do
  {
    int tmp_width;
    int tmp_height;
 
    prev_idx = idx;
    while ((supported[idx] != '\0') && (supported[idx] != ','))
      idx++;
 
    sscanf(&supported[prev_idx], "%dx%d", &tmp_width, &tmp_height);
 
    int w_diff = width - tmp_width;
    int h_diff = height - tmp_height;
    if ((h_diff >= 0) && (w_diff >= 0))
    {
      if ((h_diff <= min_diff) && (tmp_height <= 720))
      {
        frame_width = tmp_width;
        frame_height = tmp_height;
        min_diff = h_diff;
      }
    }
 
    idx++; // to skip comma symbol
 
  } while (supported[idx - 1] != '\0');
 
  return cv::Size(frame_width, frame_height);
}
#endif
 
CameraInput::CameraInput(int index)
{
#ifdef _WIN32
  mVI = new videoInput();
#else
  mVI = new cv::VideoCapture();
#endif
 
  mIndex = index;
  mMirrorMode = false;
  cameraInputsList.push_back(this);
  mBufferSize = cv::Size(640, 480);
}
 
bool CameraInput::Initialize()
{
  bool ret = false;
 
#ifdef _WIN32
  ret = mVI->setupDevice(mIndex); // crash when problem occured
  if (!ret)
    ret = mVI->setupDevice(mIndex, VI_COMPOSITE); // crash when problem occured
 
  if (ret)
    mBuffer.resize(mVI->getSize(mIndex));
 
#elif ANDROID
  if (mIndex == 0)
    mIndex = CV_CAP_ANDROID_BACK;
  else if (mIndex == 1)
    mIndex = CV_CAP_ANDROID_FRONT;
 
  ret = mVI->open(mIndex);
 
  // init default size (Pass the webcam in preview mode !!)
 
  mVI->set(CV_CAP_PROP_ANDROID_ANTIBANDING, CV_CAP_ANDROID_ANTIBANDING_OFF);
  mVI->set(CV_CAP_PROP_ANDROID_FOCUS_MODE, CV_CAP_ANDROID_FOCUS_MODE_CONTINUOUS_VIDEO);
  //mVI->set(CV_CAP_PROP_ANDROID_FLASH_MODE, CV_CAP_ANDROID_FLASH_MODE_TORCH);
 
  SetSize(mBufferSize.width, mBufferSize.height);
 
#else
  ret = mVI->open(mIndex);
#endif
 
  return ret;
}
 
void CameraInput::Close()
{
#ifdef _WIN32
  mVI->stopDevice(mIndex);
#else
  mVI->release();
#endif
}
 
CameraInput::~CameraInput()
{
#ifdef _WIN32
  mVI->stopDevice(mIndex);
#else
  mVI->release();
#endif
 
  cameraInputsList.remove(this);
  SAFE_DELETE(mVI);
}
 
bool CameraInput::IsOpened()
{
#ifdef _WIN32
  return mVI->isDeviceSetup(mIndex);
#else
  return mVI->isOpened();
#endif
}
 
cv::Mat CameraInput::UpdateImage()
{
  if (!IsOpened())
    throw std::logic_error("Device not initialised");
 
#ifdef _WIN32
  // Capture the picture
  if (!mVI->isFrameNew(mIndex) || !mVI->getPixels(mIndex, &mBuffer[0], false, true))
  {
    throw std::logic_error("Device has bad pixel buffer");
  }
 
  cv::Mat frame(mVI->getHeight(mIndex), mVI->getWidth(mIndex), CV_8UC3, &mBuffer[0]);
 
  //if (mMirrorMode)    cv::flip(frame,frame,1);
  return frame;
#else
  if (!mVI->grab())
    throw std::logic_error("Device has bad pixel buffer");
 
  cv::Mat frame;
  if (!mVI->retrieve(frame, CV_CAP_ANDROID_COLOR_FRAME_BGR) || frame.empty())
    throw std::logic_error("frame is empty");
 
  return frame;
#endif
}
 
int CameraInput::GetWidth()
{
  if (IsOpened())
  {
#ifdef _WIN32
    return mVI->getWidth(mIndex);
#else
    return mBufferSize.width;//mVI->get(CV_CAP_PROP_FRAME_WIDTH);
#endif
  }
  else
    return 0;
}
 
int CameraInput::GetHeight()
{
  if (IsOpened())
  {
#ifdef _WIN32
    return mVI->getHeight(mIndex);
#else
    return mBufferSize.height;//mVI->get(CV_CAP_PROP_FRAME_HEIGHT);
#endif
  }
  else
    return 0;
}
 
void CameraInput::SetSize(int width, int height)
{
  if (IsOpened())
  {
#ifdef _WIN32
    mVI->stopDevice(mIndex);
    mVI->setupDevice(mIndex, width, height);
 
    //if the size is not supported we restart with the default size
    if (!IsOpened())
      mVI->setupDevice(mIndex);
 
    mBuffer.resize(mVI->getSize(mIndex));
#else
    union { double prop; const char* name; } u;
    u.prop = mVI->get(CV_CAP_PROP_SUPPORTED_PREVIEW_SIZES_STRING);
 
    mBufferSize = cv::Size(0, 0);
    if (u.name)
    {
      mBufferSize = calc_optimal_camera_resolution(u.name, width, height);
    }
    else
    {
      MMechostr(MSKRUNTIME, ">> Cannot get supported camera camera_resolutions\n");
    }
 
    MMechostr(MSKDEBUG, ">>>> Camera set size : %ix%i\n", mBufferSize.width, mBufferSize.height);
 
    if ((mBufferSize.width != 0) && (mBufferSize.height != 0))
    {
      mVI->set(CV_CAP_PROP_FRAME_WIDTH, mBufferSize.width);
      mVI->set(CV_CAP_PROP_FRAME_HEIGHT, mBufferSize.height);
    }
    else
    {
      mBufferSize = cv::Size(640, 480);
    }
#endif
  }
}
 
bool CameraInput::GetMirrorMode()
{
  return mMirrorMode;
}
 
void CameraInput::SetMirrorMode(bool mode)
{
  mMirrorMode = mode;
}
 
std::vector<std::string> CameraInput::GetDevicesList()
{
  std::vector<std::string> result;
 
#ifdef _WIN32
  IBaseFilter *p_base_filter = NULL;
  IMoniker *p_moniker = NULL;
  ULONG i_fetched;
  HRESULT hr;
 
  /*Create the system device enumerator*/
  ICreateDevEnum *p_dev_enum = NULL;
 
  hr = CoCreateInstance(CLSID_SystemDeviceEnum, NULL, CLSCTX_INPROC, IID_ICreateDevEnum, (void **)&p_dev_enum);
 
  if (FAILED(hr))
  {
    return result;
  }
 
  /* Create an enumerator for the video capture devices */
  IEnumMoniker *p_class_enum = NULL;
  hr = p_dev_enum->CreateClassEnumerator(CLSID_VideoInputDeviceCategory, &p_class_enum, 0);
 
  p_dev_enum->Release();
  if (FAILED(hr))
  {
    return result;
  }
 
  /* If there are no enumerators for the requested type, then
  * CreateClassEnumerator will succeed, but p_class_enum will be NULL */
  if (p_class_enum == NULL)
  {
    return result;
  }
 
  /* Enumerate the devices */
 
  /* Note that if the Next() call succeeds but there are no monikers,
  * it will return S_FALSE (which is not a failure). Therefore, we check
  * that the return code is S_OK instead of using SUCCEEDED() macro. */
 
  int n = 0;
 
  while (p_class_enum->Next(1, &p_moniker, &i_fetched) == S_OK)
  {
    /* Getting the property page to get the device name */
    IPropertyBag *p_bag;
    hr = p_moniker->BindToStorage(0, 0, IID_IPropertyBag, (void **)&p_bag);
    if (SUCCEEDED(hr))
    {
      VARIANT var;
      var.vt = VT_BSTR;
      hr = p_bag->Read(L"FriendlyName", &var, NULL);
      p_bag->Release();
 
      if (SUCCEEDED(hr))
      {
        int i_convert = WideCharToMultiByte(CP_ACP, 0, var.bstrVal, SysStringLen(var.bstrVal), NULL, 0, NULL, NULL);
        char *p_buf = (char *)malloc(i_convert + 1);
        p_buf[0] = 0;
 
        WideCharToMultiByte(CP_ACP, 0, var.bstrVal, SysStringLen(var.bstrVal), p_buf, i_convert, NULL, NULL);
        SysFreeString(var.bstrVal);
        p_buf[i_convert] = '\0';
 
        result.push_back(std::string(p_buf));
 
        free(p_buf);
        n++;
      }
    }
    p_moniker->Release();
  }
 
  p_class_enum->Release();
 
#else // unix, android ...
 
  unsigned int cameraNumber = 0;  // number of cameras detected
  cv::VideoCapture temp_camera;
 
  for (int i = 0; i < 128; i++)
  {
    cv::VideoCapture temp_camera(i);
    if (temp_camera.isOpened())
    {
      char buffer[6];
      sprintf(buffer, "cam%d", cameraNumber);
      result.push_back(buffer);
      cameraNumber++;
    }
    else if (temp_camera.open(i))
    {
      char buffer[6];
      sprintf(buffer, "cam%d", cameraNumber);
      result.push_back(buffer);
      cameraNumber++;
      temp_camera.release();
    }
    else
      break;
  }
 
#endif
 
  return result;
}
 
bool CameraInput::TakeSnapshot(std::string path)
{
  std::cout << "taking a snapshot of camera" << mIndex << "... ";
  if (!IsOpened())
  {
    std::cout << "failed. camera not opened yet." << std::endl;
    return false;
  }
 
  cv::Mat frame = UpdateImage();
  if (frame.empty())
  {
    std::cout << "failed. Frame is empty." << std::endl;
    return false;
  }
 
  if (!cv::imwrite(path, frame))
  {
    std::cout << "failed. Couldn't write to " << path << "." << std::endl;
    return false;
  }
 
  std::cout << "success. Frame written to " << path << "." << std::endl;
  return true;
}
 
#ifndef ANDROID
void CameraInput::RenderToScreen(){}
#else
void CameraInput::RenderToScreen()
{
  cv::Mat frame;
  try
  {
    MMechostr(MSKDEBUG, ">>>> updating frame");
    frame = UpdateImage();
  }
  catch (std::exception e)
  {
    MMechostr(MSKDEBUG, ">>>> %s", e.what());
    return;
  }
 
  if (frame.empty())
  {
    MMechostr(MSKDEBUG, ">>>> frame empty!");
    return;
  }
 
  ANativeWindow* window = (ANativeWindow*)SCgetExtra("hscol");
  if (!window)
  {
    MMechostr(MSKDEBUG, "error: window empty !");
    return;
  }
  ANativeWindow_Buffer buffer;
 
  // Try lock buffer
  if (ANativeWindow_lock(window, &buffer, 0) < 0)
    return;
 
  //MMechostr(MSKDEBUG, "buffer info :: width = %d height = %d stride = %d format = %d", buffer.width, buffer.height, buffer.stride, buffer.format);
 
  cv::resize(frame, frame, cv::Size(buffer.width, buffer.height), 0, 0, cv::INTER_CUBIC);
 
  for (unsigned int y = 0; y < frame.rows; y++)
  {
    for (unsigned int x = 0; x < frame.cols; x++)
    {
      unsigned long srcByte = (x * 3) + (frame.cols * 3 * y);
      unsigned long destByte = (x * 4) + (buffer.width * 4 * y);
 
      ((unsigned char*)buffer.bits)[destByte + 2] = frame.data[srcByte];
      ((unsigned char*)buffer.bits)[destByte + 1] = frame.data[srcByte + 1];
      ((unsigned char*)buffer.bits)[destByte + 0] = frame.data[srcByte + 2];
      ((unsigned char*)buffer.bits)[destByte + 3] = 255;
    }
  }
 
  // Unlock buffer
  ANativeWindow_unlockAndPost(window);
}
#endif
 
void CameraInput::SetCameraInputsState(bool state)
{
  std::list<CameraInput*>::iterator it;
  if (state)
  {
    for(it = cameraInputsList.begin(); it != cameraInputsList.end(); it++)
    {
      (*it)->Initialize();
    }
  }
  else
  {
    for(it = cameraInputsList.begin(); it != cameraInputsList.end(); it++)
    {
      (*it)->Close();
    }
  }
}