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 24 namespace webrtc { 25 26 namespace videocapturemodule { 27 28 // Helper for storing lists of pairs of ints. Used e.g. for resolutions & FPS 29 // ranges. 30 typedef std::pair<int, int> IntPair; 31 typedef std::vector<IntPair> IntPairs; 32 33 static 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 43 struct 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. 64 static 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. 68 static 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. 80 static 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 88 void 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 145 void DeviceInfoAndroid::DeInitialize() { 146 if (g_camera_info) { 147 delete g_camera_info; 148 g_camera_info = NULL; 149 } 150 } 151 152 VideoCaptureModule::DeviceInfo* VideoCaptureImpl::CreateDeviceInfo( 153 const int32_t id) { 154 return new videocapturemodule::DeviceInfoAndroid(id); 155 } 156 157 DeviceInfoAndroid::DeviceInfoAndroid(const int32_t id) : 158 DeviceInfoImpl(id) { 159 } 160 161 DeviceInfoAndroid::~DeviceInfoAndroid() { 162 } 163 164 bool DeviceInfoAndroid::FindCameraIndex(const char* deviceUniqueIdUTF8, 165 size_t* index) { 166 return FindCameraIndexByName(deviceUniqueIdUTF8, index); 167 } 168 169 int32_t DeviceInfoAndroid::Init() { 170 return 0; 171 } 172 173 uint32_t DeviceInfoAndroid::NumberOfDevices() { 174 return g_camera_info->size(); 175 } 176 177 int32_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 197 int32_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 220 int32_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 231 void 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
