ICameraInput.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 "ICameraInput.h"
 
#ifdef _WIN32
  #include <dshow.h>
#endif
 
#ifdef APPLE_IOS
  #include "CameraTorchIOS.h"
#endif
 
std::list<ICameraInput*> ICameraInput::cameraInputsList;
 
ICameraInput::ICameraInput(int index)
{
  mIndex = index;
  mMirrorMode = false;
  cameraInputsList.push_back(this);
}
 
ICameraInput::~ICameraInput()
{
  cameraInputsList.remove(this);
}
 
bool ICameraInput::GetMirrorMode()
{
  return mMirrorMode;
}
 
void ICameraInput::SetMirrorMode(bool mode)
{
  mMirrorMode = mode;
}
 
std::vector<std::string> ICameraInput::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();
 
#elif SCOL_CAMERA_OPENCV // Using openCV utility
 
  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;
  }
 
#else // Using android classes
 
  int cameraNumber = 0;
  android_app* app = (struct android_app*)SCgetExtra("this_inst");
  JNIEnv* env = 0;
  app->activity->vm->AttachCurrentThread(&env, NULL);
 
  jclass camera_class = env->FindClass("android/hardware/Camera");
  jmethodID getNumberOfCameras_method = env->GetStaticMethodID(camera_class, "getNumberOfCameras", "()I");
  cameraNumber = env->CallStaticIntMethod(camera_class, getNumberOfCameras_method);
 
  if (cameraNumber <= 0)
  {
    result.push_back("no camera available on this device");
  }
  else
  {
    for (int i = 0; i < cameraNumber; i++)
    {
      char buffer[6];
      sprintf(buffer, "cam%d", i);
      result.push_back(buffer);
    }
  }
 
  env->DeleteLocalRef(camera_class);
  app->activity->vm->DetachCurrentThread();
#endif
 
  return result;
}
 
void ICameraInput::SetCameraInputsState(bool state)
{
  std::list<ICameraInput*>::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();
    }
  }
}
 
bool ICameraInput::TakeSnapshot(std::string path) {
  return false;
}
 
bool ICameraInput::SetFocusPoint(int x, int y)
{
  return false;
}
 
void ICameraInput::SetTorchState(bool state)
{
#ifdef APPLE_IOS
  turnTorchOn(state);
#endif
}
 
void ICameraInput::RenderToScreen() {}