1/* 2 * Copyright (c) 2012 The WebRTC project authors. All Rights Reserved. 3 * 4 * Use of this source code is governed by a BSD-style license 5 * that can be found in the LICENSE file in the root of the source 6 * tree. An additional intellectual property rights grant can be found 7 * in the file PATENTS. All contributing project authors may 8 * be found in the AUTHORS file in the root of the source tree. 9 */ 10 11#include "webrtc/modules/video_capture/android/device_info_android.h" 12 13#include <algorithm> 14#include <sstream> 15#include <vector> 16 17#include "json/json.h" 18#include "third_party/icu/source/common/unicode/unistr.h" 19#include "webrtc/modules/video_capture/android/video_capture_android.h" 20#include "webrtc/system_wrappers/interface/logging.h" 21#include "webrtc/system_wrappers/interface/ref_count.h" 22#include "webrtc/system_wrappers/interface/trace.h" 23 24namespace webrtc { 25 26namespace videocapturemodule { 27 28// Helper for storing lists of pairs of ints. Used e.g. for resolutions & FPS 29// ranges. 30typedef std::pair<int, int> IntPair; 31typedef std::vector<IntPair> IntPairs; 32 33static std::string IntPairsToString(const IntPairs& pairs, char separator) { 34 std::stringstream stream; 35 for (size_t i = 0; i < pairs.size(); ++i) { 36 if (i > 0) 37 stream << ", "; 38 stream << "(" << pairs[i].first << separator << pairs[i].second << ")"; 39 } 40 return stream.str(); 41} 42 43struct AndroidCameraInfo { 44 std::string name; 45 bool front_facing; 46 int orientation; 47 IntPairs resolutions; // Pairs are: (width,height). 48 // Pairs are (min,max) in units of FPS*1000 ("milli-frame-per-second"). 49 IntPairs mfpsRanges; 50 51 std::string ToString() { 52 std::stringstream stream; 53 stream << "Name: [" << name << "], MFPS ranges: [" 54 << IntPairsToString(mfpsRanges, ':') 55 << "], front_facing: " << front_facing 56 << ", orientation: " << orientation << ", resolutions: [" 57 << IntPairsToString(resolutions, 'x') << "]"; 58 return stream.str(); 59 } 60}; 61 62// Camera info; populated during DeviceInfoAndroid::Initialize() and immutable 63// thereafter. 64static std::vector<AndroidCameraInfo>* g_camera_info = NULL; 65 66// Set |*index| to the index of |name| in g_camera_info or return false if no 67// match found. 68static bool FindCameraIndexByName(const std::string& name, size_t* index) { 69 for (size_t i = 0; i < g_camera_info->size(); ++i) { 70 if (g_camera_info->at(i).name == name) { 71 *index = i; 72 return true; 73 } 74 } 75 return false; 76} 77 78// Returns a pointer to the named member of g_camera_info, or NULL if no match 79// is found. 80static AndroidCameraInfo* FindCameraInfoByName(const std::string& name) { 81 size_t index = 0; 82 if (FindCameraIndexByName(name, &index)) 83 return &g_camera_info->at(index); 84 return NULL; 85} 86 87// static 88void DeviceInfoAndroid::Initialize(JNIEnv* jni) { 89 // TODO(henrike): this "if" would make a lot more sense as an assert, but 90 // Java_org_webrtc_videoengineapp_ViEAndroidJavaAPI_GetVideoEngine() and 91 // Java_org_webrtc_videoengineapp_ViEAndroidJavaAPI_Terminate() conspire to 92 // prevent this. Once that code is made to only 93 // VideoEngine::SetAndroidObjects() once per process, this can turn into an 94 // assert. 95 if (g_camera_info) 96 return; 97 98 g_camera_info = new std::vector<AndroidCameraInfo>(); 99 jclass j_info_class = 100 jni->FindClass("org/webrtc/videoengine/VideoCaptureDeviceInfoAndroid"); 101 assert(j_info_class); 102 jmethodID j_initialize = jni->GetStaticMethodID( 103 j_info_class, "getDeviceInfo", "()Ljava/lang/String;"); 104 jstring j_json_info = static_cast<jstring>( 105 jni->CallStaticObjectMethod(j_info_class, j_initialize)); 106 107 const jchar* jchars = jni->GetStringChars(j_json_info, NULL); 108 icu::UnicodeString ustr(jchars, jni->GetStringLength(j_json_info)); 109 jni->ReleaseStringChars(j_json_info, jchars); 110 std::string json_info; 111 ustr.toUTF8String(json_info); 112 113 Json::Value cameras; 114 Json::Reader reader(Json::Features::strictMode()); 115 bool parsed = reader.parse(json_info, cameras); 116 if (!parsed) { 117 std::stringstream stream; 118 stream << "Failed to parse configuration:\n" 119 << reader.getFormattedErrorMessages(); 120 assert(false); 121 return; 122 } 123 for (Json::ArrayIndex i = 0; i < cameras.size(); ++i) { 124 const Json::Value& camera = cameras[i]; 125 AndroidCameraInfo info; 126 info.name = camera["name"].asString(); 127 info.front_facing = camera["front_facing"].asBool(); 128 info.orientation = camera["orientation"].asInt(); 129 Json::Value sizes = camera["sizes"]; 130 for (Json::ArrayIndex j = 0; j < sizes.size(); ++j) { 131 const Json::Value& size = sizes[j]; 132 info.resolutions.push_back(std::make_pair( 133 size["width"].asInt(), size["height"].asInt())); 134 } 135 Json::Value mfpsRanges = camera["mfpsRanges"]; 136 for (Json::ArrayIndex j = 0; j < mfpsRanges.size(); ++j) { 137 const Json::Value& mfpsRange = mfpsRanges[j]; 138 info.mfpsRanges.push_back(std::make_pair(mfpsRange["min_mfps"].asInt(), 139 mfpsRange["max_mfps"].asInt())); 140 } 141 g_camera_info->push_back(info); 142 } 143} 144 145void DeviceInfoAndroid::DeInitialize() { 146 if (g_camera_info) { 147 delete g_camera_info; 148 g_camera_info = NULL; 149 } 150} 151 152VideoCaptureModule::DeviceInfo* VideoCaptureImpl::CreateDeviceInfo( 153 const int32_t id) { 154 return new videocapturemodule::DeviceInfoAndroid(id); 155} 156 157DeviceInfoAndroid::DeviceInfoAndroid(const int32_t id) : 158 DeviceInfoImpl(id) { 159} 160 161DeviceInfoAndroid::~DeviceInfoAndroid() { 162} 163 164bool DeviceInfoAndroid::FindCameraIndex(const char* deviceUniqueIdUTF8, 165 size_t* index) { 166 return FindCameraIndexByName(deviceUniqueIdUTF8, index); 167} 168 169int32_t DeviceInfoAndroid::Init() { 170 return 0; 171} 172 173uint32_t DeviceInfoAndroid::NumberOfDevices() { 174 return g_camera_info->size(); 175} 176 177int32_t DeviceInfoAndroid::GetDeviceName( 178 uint32_t deviceNumber, 179 char* deviceNameUTF8, 180 uint32_t deviceNameLength, 181 char* deviceUniqueIdUTF8, 182 uint32_t deviceUniqueIdUTF8Length, 183 char* /*productUniqueIdUTF8*/, 184 uint32_t /*productUniqueIdUTF8Length*/) { 185 if (deviceNumber >= g_camera_info->size()) 186 return -1; 187 const AndroidCameraInfo& info = g_camera_info->at(deviceNumber); 188 if (info.name.length() + 1 > deviceNameLength || 189 info.name.length() + 1 > deviceUniqueIdUTF8Length) { 190 return -1; 191 } 192 memcpy(deviceNameUTF8, info.name.c_str(), info.name.length() + 1); 193 memcpy(deviceUniqueIdUTF8, info.name.c_str(), info.name.length() + 1); 194 return 0; 195} 196 197int32_t DeviceInfoAndroid::CreateCapabilityMap( 198 const char* deviceUniqueIdUTF8) { 199 _captureCapabilities.clear(); 200 const AndroidCameraInfo* info = FindCameraInfoByName(deviceUniqueIdUTF8); 201 if (info == NULL) 202 return -1; 203 204 for (size_t i = 0; i < info->resolutions.size(); ++i) { 205 for (size_t j = 0; j < info->mfpsRanges.size(); ++j) { 206 const IntPair& size = info->resolutions[i]; 207 const IntPair& mfpsRange = info->mfpsRanges[j]; 208 VideoCaptureCapability cap; 209 cap.width = size.first; 210 cap.height = size.second; 211 cap.maxFPS = mfpsRange.second / 1000; 212 cap.expectedCaptureDelay = kExpectedCaptureDelay; 213 cap.rawType = kVideoNV21; 214 _captureCapabilities.push_back(cap); 215 } 216 } 217 return _captureCapabilities.size(); 218} 219 220int32_t DeviceInfoAndroid::GetOrientation( 221 const char* deviceUniqueIdUTF8, 222 VideoCaptureRotation& orientation) { 223 const AndroidCameraInfo* info = FindCameraInfoByName(deviceUniqueIdUTF8); 224 if (info == NULL || 225 !VideoCaptureImpl::RotationFromDegrees(info->orientation, &orientation)) { 226 return -1; 227 } 228 return 0; 229} 230 231void DeviceInfoAndroid::GetMFpsRange(const char* deviceUniqueIdUTF8, 232 int max_fps_to_match, 233 int* min_mfps, int* max_mfps) { 234 const AndroidCameraInfo* info = FindCameraInfoByName(deviceUniqueIdUTF8); 235 if (info == NULL) 236 return; 237 int desired_mfps = max_fps_to_match * 1000; 238 int best_diff_mfps = 0; 239 LOG(LS_INFO) << "Search for best target mfps " << desired_mfps; 240 // Search for best fps range with preference shifted to constant fps modes. 241 for (size_t i = 0; i < info->mfpsRanges.size(); ++i) { 242 int diff_mfps = abs(info->mfpsRanges[i].first - desired_mfps) + 243 abs(info->mfpsRanges[i].second - desired_mfps) + 244 (info->mfpsRanges[i].second - info->mfpsRanges[i].first) / 2; 245 LOG(LS_INFO) << "Fps range " << info->mfpsRanges[i].first << ":" << 246 info->mfpsRanges[i].second << ". Distance: " << diff_mfps; 247 if (i == 0 || diff_mfps < best_diff_mfps) { 248 best_diff_mfps = diff_mfps; 249 *min_mfps = info->mfpsRanges[i].first; 250 *max_mfps = info->mfpsRanges[i].second; 251 } 252 } 253} 254 255} // namespace videocapturemodule 256} // namespace webrtc 257