webrtc/modules/video_capture/android/device_info_android.cc - platform/external/webrtc - Git at Google

 /*
  *  Copyright (c) 2012 The WebRTC project authors. All Rights Reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */

 #include "webrtc/modules/video_capture/android/device_info_android.h"

 #include <algorithm>
 #include <sstream>
 #include <vector>

 #include "unicode/unistr.h"
 #include "webrtc/base/json.h"
 #include "webrtc/modules/video_capture/android/video_capture_android.h"
 #include "webrtc/system_wrappers/interface/logging.h"
 #include "webrtc/system_wrappers/interface/ref_count.h"
 #include "webrtc/system_wrappers/interface/trace.h"

 namespace webrtc {

 namespace videocapturemodule {

 // Helper for storing lists of pairs of ints.  Used e.g. for resolutions & FPS
 // ranges.
 typedef std::pair<int, int> IntPair;
 typedef std::vector<IntPair> IntPairs;

 static std::string IntPairsToString(const IntPairs& pairs, char separator) {
   std::stringstream stream;
   for (size_t i = 0; i < pairs.size(); ++i) {
     if (i > 0)
       stream << ", ";
     stream << "(" << pairs[i].first << separator << pairs[i].second << ")";
   }
   return stream.str();
 }

 struct AndroidCameraInfo {
   std::string name;
   bool front_facing;
   int orientation;
   IntPairs resolutions;  // Pairs are: (width,height).
   // Pairs are (min,max) in units of FPS*1000 ("milli-frame-per-second").
   IntPairs mfpsRanges;

   std::string ToString() {
     std::stringstream stream;
     stream << "Name: [" << name << "], MFPS ranges: ["
            << IntPairsToString(mfpsRanges, ':')
            << "], front_facing: " << front_facing
            << ", orientation: " << orientation << ", resolutions: ["
            << IntPairsToString(resolutions, 'x') << "]";
     return stream.str();
   }
 };

 // Camera info; populated during DeviceInfoAndroid::Initialize() and immutable
 // thereafter.
 static std::vector<AndroidCameraInfo>* g_camera_info = NULL;

 // Set |*index| to the index of |name| in g_camera_info or return false if no
 // match found.
 static bool FindCameraIndexByName(const std::string& name, size_t* index) {
   for (size_t i = 0; i < g_camera_info->size(); ++i) {
     if (g_camera_info->at(i).name == name) {
       *index = i;
       return true;
     }
   }
   return false;
 }

 // Returns a pointer to the named member of g_camera_info, or NULL if no match
 // is found.
 static AndroidCameraInfo* FindCameraInfoByName(const std::string& name) {
   size_t index = 0;
   if (FindCameraIndexByName(name, &index))
     return &g_camera_info->at(index);
   return NULL;
 }

 // static
 void DeviceInfoAndroid::Initialize(JNIEnv* jni) {
   // TODO(henrike): this "if" would make a lot more sense as an assert, but
   // Java_org_webrtc_videoengineapp_ViEAndroidJavaAPI_GetVideoEngine() and
   // Java_org_webrtc_videoengineapp_ViEAndroidJavaAPI_Terminate() conspire to
   // prevent this.  Once that code is made to only
   // VideoEngine::SetAndroidObjects() once per process, this can turn into an
   // assert.
   if (g_camera_info)
     return;

   g_camera_info = new std::vector<AndroidCameraInfo>();
   jclass j_info_class =
       jni->FindClass("org/webrtc/videoengine/VideoCaptureDeviceInfoAndroid");
   assert(j_info_class);
   jmethodID j_initialize = jni->GetStaticMethodID(
       j_info_class, "getDeviceInfo", "()Ljava/lang/String;");
   jstring j_json_info = static_cast<jstring>(
       jni->CallStaticObjectMethod(j_info_class, j_initialize));

   const jchar* jchars = jni->GetStringChars(j_json_info, NULL);
   icu::UnicodeString ustr(jchars, jni->GetStringLength(j_json_info));
   jni->ReleaseStringChars(j_json_info, jchars);
   std::string json_info;
   ustr.toUTF8String(json_info);

   Json::Value cameras;
   Json::Reader reader(Json::Features::strictMode());
   bool parsed = reader.parse(json_info, cameras);
   if (!parsed) {
     std::stringstream stream;
     stream << "Failed to parse configuration:\n"
            << reader.getFormattedErrorMessages();
     assert(false);
     return;
   }
   for (Json::ArrayIndex i = 0; i < cameras.size(); ++i) {
     const Json::Value& camera = cameras[i];
     AndroidCameraInfo info;
     info.name = camera["name"].asString();
     info.front_facing = camera["front_facing"].asBool();
     info.orientation = camera["orientation"].asInt();
     Json::Value sizes = camera["sizes"];
     for (Json::ArrayIndex j = 0; j < sizes.size(); ++j) {
       const Json::Value& size = sizes[j];
       info.resolutions.push_back(std::make_pair(
           size["width"].asInt(), size["height"].asInt()));
     }
     Json::Value mfpsRanges = camera["mfpsRanges"];
     for (Json::ArrayIndex j = 0; j < mfpsRanges.size(); ++j) {
       const Json::Value& mfpsRange = mfpsRanges[j];
       info.mfpsRanges.push_back(std::make_pair(mfpsRange["min_mfps"].asInt(),
                                                mfpsRange["max_mfps"].asInt()));
     }
     g_camera_info->push_back(info);
   }
 }

 void DeviceInfoAndroid::DeInitialize() {
   if (g_camera_info) {
     delete g_camera_info;
     g_camera_info = NULL;
   }
 }

 VideoCaptureModule::DeviceInfo* VideoCaptureImpl::CreateDeviceInfo(
     const int32_t id) {
   return new videocapturemodule::DeviceInfoAndroid(id);
 }

 DeviceInfoAndroid::DeviceInfoAndroid(const int32_t id) :
     DeviceInfoImpl(id) {
 }

 DeviceInfoAndroid::~DeviceInfoAndroid() {
 }

 bool DeviceInfoAndroid::FindCameraIndex(const char* deviceUniqueIdUTF8,
                                         size_t* index) {
   return FindCameraIndexByName(deviceUniqueIdUTF8, index);
 }

 int32_t DeviceInfoAndroid::Init() {
   return 0;
 }

 uint32_t DeviceInfoAndroid::NumberOfDevices() {
   return g_camera_info->size();
 }

 int32_t DeviceInfoAndroid::GetDeviceName(
     uint32_t deviceNumber,
     char* deviceNameUTF8,
     uint32_t deviceNameLength,
     char* deviceUniqueIdUTF8,
     uint32_t deviceUniqueIdUTF8Length,
     char* /*productUniqueIdUTF8*/,
     uint32_t /*productUniqueIdUTF8Length*/) {
   if (deviceNumber >= g_camera_info->size())
     return -1;
   const AndroidCameraInfo& info = g_camera_info->at(deviceNumber);
   if (info.name.length() + 1 > deviceNameLength ||
       info.name.length() + 1 > deviceUniqueIdUTF8Length) {
     return -1;
   }
   memcpy(deviceNameUTF8, info.name.c_str(), info.name.length() + 1);
   memcpy(deviceUniqueIdUTF8, info.name.c_str(), info.name.length() + 1);
   return 0;
 }

 int32_t DeviceInfoAndroid::CreateCapabilityMap(
     const char* deviceUniqueIdUTF8) {
   _captureCapabilities.clear();
   const AndroidCameraInfo* info = FindCameraInfoByName(deviceUniqueIdUTF8);
   if (info == NULL)
     return -1;

   for (size_t i = 0; i < info->resolutions.size(); ++i) {
     for (size_t j = 0; j < info->mfpsRanges.size(); ++j) {
       const IntPair& size = info->resolutions[i];
       const IntPair& mfpsRange = info->mfpsRanges[j];
       VideoCaptureCapability cap;
       cap.width = size.first;
       cap.height = size.second;
       cap.maxFPS = mfpsRange.second / 1000;
       cap.expectedCaptureDelay = kExpectedCaptureDelay;
       cap.rawType = kVideoNV21;
       _captureCapabilities.push_back(cap);
     }
   }
   return _captureCapabilities.size();
 }

 int32_t DeviceInfoAndroid::GetOrientation(const char* deviceUniqueIdUTF8,
                                           VideoRotation& orientation) {
   const AndroidCameraInfo* info = FindCameraInfoByName(deviceUniqueIdUTF8);
   if (info == NULL ||
       VideoCaptureImpl::RotationFromDegrees(info->orientation,
                                             &orientation) != 0) {
     return -1;
   }
   return 0;
 }

 void DeviceInfoAndroid::GetMFpsRange(const char* deviceUniqueIdUTF8,
                                      int max_fps_to_match,
                                      int* min_mfps, int* max_mfps) {
   const AndroidCameraInfo* info = FindCameraInfoByName(deviceUniqueIdUTF8);
   if (info == NULL)
     return;
   int desired_mfps = max_fps_to_match * 1000;
   int best_diff_mfps = 0;
   LOG(LS_INFO) << "Search for best target mfps " << desired_mfps;
   // Search for best fps range with preference shifted to constant fps modes.
   for (size_t i = 0; i < info->mfpsRanges.size(); ++i) {
     int diff_mfps = abs(info->mfpsRanges[i].first - desired_mfps) +
         abs(info->mfpsRanges[i].second - desired_mfps) +
         (info->mfpsRanges[i].second - info->mfpsRanges[i].first) / 2;
     LOG(LS_INFO) << "Fps range " << info->mfpsRanges[i].first << ":" <<
         info->mfpsRanges[i].second << ". Distance: " << diff_mfps;
     if (i == 0 || diff_mfps < best_diff_mfps) {
       best_diff_mfps = diff_mfps;
       *min_mfps = info->mfpsRanges[i].first;
       *max_mfps = info->mfpsRanges[i].second;
     }
   }
 }

 }  // namespace videocapturemodule
 }  // namespace webrtc
	/*
	* Copyright (c) 2012 The WebRTC project authors. All Rights Reserved.
	*
	* Use of this source code is governed by a BSD-style license
	* that can be found in the LICENSE file in the root of the source
	* tree. An additional intellectual property rights grant can be found
	* in the file PATENTS. All contributing project authors may
	* be found in the AUTHORS file in the root of the source tree.
	*/

	#include "webrtc/modules/video_capture/android/device_info_android.h"

	#include <algorithm>
	#include <sstream>
	#include <vector>

	#include "unicode/unistr.h"
	#include "webrtc/base/json.h"
	#include "webrtc/modules/video_capture/android/video_capture_android.h"
	#include "webrtc/system_wrappers/interface/logging.h"
	#include "webrtc/system_wrappers/interface/ref_count.h"
	#include "webrtc/system_wrappers/interface/trace.h"

	namespace webrtc {

	namespace videocapturemodule {

	// Helper for storing lists of pairs of ints. Used e.g. for resolutions & FPS
	// ranges.
	typedef std::pair<int, int> IntPair;
	typedef std::vector<IntPair> IntPairs;

	static std::string IntPairsToString(const IntPairs& pairs, char separator) {
	std::stringstream stream;
	for (size_t i = 0; i < pairs.size(); ++i) {
	if (i > 0)
	stream << ", ";
	stream << "(" << pairs[i].first << separator << pairs[i].second << ")";
	}
	return stream.str();
	}

	struct AndroidCameraInfo {
	std::string name;
	bool front_facing;
	int orientation;
	IntPairs resolutions; // Pairs are: (width,height).
	// Pairs are (min,max) in units of FPS*1000 ("milli-frame-per-second").
	IntPairs mfpsRanges;

	std::string ToString() {
	std::stringstream stream;
	stream << "Name: [" << name << "], MFPS ranges: ["
	<< IntPairsToString(mfpsRanges, ':')
	<< "], front_facing: " << front_facing
	<< ", orientation: " << orientation << ", resolutions: ["
	<< IntPairsToString(resolutions, 'x') << "]";
	return stream.str();
	}
	};

	// Camera info; populated during DeviceInfoAndroid::Initialize() and immutable
	// thereafter.
	static std::vector<AndroidCameraInfo>* g_camera_info = NULL;

	// Set \|*index\| to the index of \|name\| in g_camera_info or return false if no
	// match found.
	static bool FindCameraIndexByName(const std::string& name, size_t* index) {
	for (size_t i = 0; i < g_camera_info->size(); ++i) {
	if (g_camera_info->at(i).name == name) {
	*index = i;
	return true;
	}
	}
	return false;
	}

	// Returns a pointer to the named member of g_camera_info, or NULL if no match
	// is found.
	static AndroidCameraInfo* FindCameraInfoByName(const std::string& name) {
	size_t index = 0;
	if (FindCameraIndexByName(name, &index))
	return &g_camera_info->at(index);
	return NULL;
	}

	// static
	void DeviceInfoAndroid::Initialize(JNIEnv* jni) {
	// TODO(henrike): this "if" would make a lot more sense as an assert, but
	// Java_org_webrtc_videoengineapp_ViEAndroidJavaAPI_GetVideoEngine() and
	// Java_org_webrtc_videoengineapp_ViEAndroidJavaAPI_Terminate() conspire to
	// prevent this. Once that code is made to only
	// VideoEngine::SetAndroidObjects() once per process, this can turn into an
	// assert.
	if (g_camera_info)
	return;

	g_camera_info = new std::vector<AndroidCameraInfo>();
	jclass j_info_class =
	jni->FindClass("org/webrtc/videoengine/VideoCaptureDeviceInfoAndroid");
	assert(j_info_class);
	jmethodID j_initialize = jni->GetStaticMethodID(
	j_info_class, "getDeviceInfo", "()Ljava/lang/String;");
	jstring j_json_info = static_cast<jstring>(
	jni->CallStaticObjectMethod(j_info_class, j_initialize));

	const jchar* jchars = jni->GetStringChars(j_json_info, NULL);
	icu::UnicodeString ustr(jchars, jni->GetStringLength(j_json_info));
	jni->ReleaseStringChars(j_json_info, jchars);
	std::string json_info;
	ustr.toUTF8String(json_info);

	Json::Value cameras;
	Json::Reader reader(Json::Features::strictMode());
	bool parsed = reader.parse(json_info, cameras);
	if (!parsed) {
	std::stringstream stream;
	stream << "Failed to parse configuration:\n"
	<< reader.getFormattedErrorMessages();
	assert(false);
	return;
	}
	for (Json::ArrayIndex i = 0; i < cameras.size(); ++i) {
	const Json::Value& camera = cameras[i];
	AndroidCameraInfo info;
	info.name = camera["name"].asString();
	info.front_facing = camera["front_facing"].asBool();
	info.orientation = camera["orientation"].asInt();
	Json::Value sizes = camera["sizes"];
	for (Json::ArrayIndex j = 0; j < sizes.size(); ++j) {
	const Json::Value& size = sizes[j];
	info.resolutions.push_back(std::make_pair(
	size["width"].asInt(), size["height"].asInt()));
	}
	Json::Value mfpsRanges = camera["mfpsRanges"];
	for (Json::ArrayIndex j = 0; j < mfpsRanges.size(); ++j) {
	const Json::Value& mfpsRange = mfpsRanges[j];
	info.mfpsRanges.push_back(std::make_pair(mfpsRange["min_mfps"].asInt(),
	mfpsRange["max_mfps"].asInt()));
	}
	g_camera_info->push_back(info);
	}
	}

	void DeviceInfoAndroid::DeInitialize() {
	if (g_camera_info) {
	delete g_camera_info;
	g_camera_info = NULL;
	}
	}

	VideoCaptureModule::DeviceInfo* VideoCaptureImpl::CreateDeviceInfo(
	const int32_t id) {
	return new videocapturemodule::DeviceInfoAndroid(id);
	}

	DeviceInfoAndroid::DeviceInfoAndroid(const int32_t id) :
	DeviceInfoImpl(id) {
	}

	DeviceInfoAndroid::~DeviceInfoAndroid() {
	}

	bool DeviceInfoAndroid::FindCameraIndex(const char* deviceUniqueIdUTF8,
	size_t* index) {
	return FindCameraIndexByName(deviceUniqueIdUTF8, index);
	}

	int32_t DeviceInfoAndroid::Init() {
	return 0;
	}

	uint32_t DeviceInfoAndroid::NumberOfDevices() {
	return g_camera_info->size();
	}

	int32_t DeviceInfoAndroid::GetDeviceName(
	uint32_t deviceNumber,
	char* deviceNameUTF8,
	uint32_t deviceNameLength,
	char* deviceUniqueIdUTF8,
	uint32_t deviceUniqueIdUTF8Length,
	char* /productUniqueIdUTF8/,
	uint32_t /productUniqueIdUTF8Length/) {
	if (deviceNumber >= g_camera_info->size())
	return -1;
	const AndroidCameraInfo& info = g_camera_info->at(deviceNumber);
	if (info.name.length() + 1 > deviceNameLength \|\|
	info.name.length() + 1 > deviceUniqueIdUTF8Length) {
	return -1;
	}
	memcpy(deviceNameUTF8, info.name.c_str(), info.name.length() + 1);
	memcpy(deviceUniqueIdUTF8, info.name.c_str(), info.name.length() + 1);
	return 0;
	}

	int32_t DeviceInfoAndroid::CreateCapabilityMap(
	const char* deviceUniqueIdUTF8) {
	_captureCapabilities.clear();
	const AndroidCameraInfo* info = FindCameraInfoByName(deviceUniqueIdUTF8);
	if (info == NULL)
	return -1;

	for (size_t i = 0; i < info->resolutions.size(); ++i) {
	for (size_t j = 0; j < info->mfpsRanges.size(); ++j) {
	const IntPair& size = info->resolutions[i];
	const IntPair& mfpsRange = info->mfpsRanges[j];
	VideoCaptureCapability cap;
	cap.width = size.first;
	cap.height = size.second;
	cap.maxFPS = mfpsRange.second / 1000;
	cap.expectedCaptureDelay = kExpectedCaptureDelay;
	cap.rawType = kVideoNV21;
	_captureCapabilities.push_back(cap);
	}
	}
	return _captureCapabilities.size();
	}

	int32_t DeviceInfoAndroid::GetOrientation(const char* deviceUniqueIdUTF8,
	VideoRotation& orientation) {
	const AndroidCameraInfo* info = FindCameraInfoByName(deviceUniqueIdUTF8);
	if (info == NULL \|\|
	VideoCaptureImpl::RotationFromDegrees(info->orientation,
	&orientation) != 0) {
	return -1;
	}
	return 0;
	}

	void DeviceInfoAndroid::GetMFpsRange(const char* deviceUniqueIdUTF8,
	int max_fps_to_match,
	int* min_mfps, int* max_mfps) {
	const AndroidCameraInfo* info = FindCameraInfoByName(deviceUniqueIdUTF8);
	if (info == NULL)
	return;
	int desired_mfps = max_fps_to_match * 1000;
	int best_diff_mfps = 0;
	LOG(LS_INFO) << "Search for best target mfps " << desired_mfps;
	// Search for best fps range with preference shifted to constant fps modes.
	for (size_t i = 0; i < info->mfpsRanges.size(); ++i) {
	int diff_mfps = abs(info->mfpsRanges[i].first - desired_mfps) +
	abs(info->mfpsRanges[i].second - desired_mfps) +
	(info->mfpsRanges[i].second - info->mfpsRanges[i].first) / 2;
	LOG(LS_INFO) << "Fps range " << info->mfpsRanges[i].first << ":" <<
	info->mfpsRanges[i].second << ". Distance: " << diff_mfps;
	if (i == 0 \|\| diff_mfps < best_diff_mfps) {
	best_diff_mfps = diff_mfps;
	*min_mfps = info->mfpsRanges[i].first;
	*max_mfps = info->mfpsRanges[i].second;
	}
	}
	}

	} // namespace videocapturemodule
	} // namespace webrtc