android_image_reader_compat.cc 5.4 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166
  1. // Copyright 2018 The Chromium Authors. All rights reserved.
  2. // Use of this source code is governed by a BSD-style license that can be
  3. // found in the LICENSE file.
  4. #include "base/android/android_image_reader_compat.h"
  5. #include <dlfcn.h>
  6. #include "base/android/build_info.h"
  7. #include "base/feature_list.h"
  8. #include "base/logging.h"
  9. #include "base/strings/string_util.h"
  10. #define LOAD_FUNCTION(lib, func) \
  11. do { \
  12. func##_ = reinterpret_cast<p##func>(dlsym(lib, #func)); \
  13. if (!func##_) { \
  14. DLOG(ERROR) << "Unable to load function " << #func; \
  15. return false; \
  16. } \
  17. } while (0)
  18. namespace base {
  19. namespace android {
  20. AndroidImageReader& AndroidImageReader::GetInstance() {
  21. // C++11 static local variable initialization is
  22. // thread-safe.
  23. static AndroidImageReader instance;
  24. return instance;
  25. }
  26. bool AndroidImageReader::IsSupported() {
  27. return is_supported_;
  28. }
  29. AndroidImageReader::AndroidImageReader() : is_supported_(LoadFunctions()) {}
  30. bool AndroidImageReader::LoadFunctions() {
  31. // If the Chromium build requires __ANDROID_API__ >= 26 at some
  32. // point in the future, we could directly use the global functions instead of
  33. // dynamic loading. However, since this would be incompatible with pre-Oreo
  34. // devices, this is unlikely to happen in the foreseeable future, so we use
  35. // dynamic loading.
  36. // Functions are not present for android version older than OREO.
  37. // Currently we want to enable AImageReader only for android P+ devices.
  38. if (base::android::BuildInfo::GetInstance()->sdk_int() <
  39. base::android::SDK_VERSION_P) {
  40. return false;
  41. }
  42. void* libmediandk = dlopen("libmediandk.so", RTLD_NOW);
  43. if (libmediandk == nullptr) {
  44. LOG(ERROR) << "Couldnt open libmediandk.so";
  45. return false;
  46. }
  47. LOAD_FUNCTION(libmediandk, AImage_delete);
  48. LOAD_FUNCTION(libmediandk, AImage_deleteAsync);
  49. LOAD_FUNCTION(libmediandk, AImage_getHardwareBuffer);
  50. LOAD_FUNCTION(libmediandk, AImage_getWidth);
  51. LOAD_FUNCTION(libmediandk, AImage_getHeight);
  52. LOAD_FUNCTION(libmediandk, AImage_getCropRect);
  53. LOAD_FUNCTION(libmediandk, AImageReader_newWithUsage);
  54. LOAD_FUNCTION(libmediandk, AImageReader_setImageListener);
  55. LOAD_FUNCTION(libmediandk, AImageReader_delete);
  56. LOAD_FUNCTION(libmediandk, AImageReader_getFormat);
  57. LOAD_FUNCTION(libmediandk, AImageReader_getWindow);
  58. LOAD_FUNCTION(libmediandk, AImageReader_acquireLatestImageAsync);
  59. LOAD_FUNCTION(libmediandk, AImageReader_acquireNextImageAsync);
  60. void* libandroid = dlopen("libandroid.so", RTLD_NOW);
  61. if (libandroid == nullptr) {
  62. LOG(ERROR) << "Couldnt open libandroid.so";
  63. return false;
  64. }
  65. LOAD_FUNCTION(libandroid, ANativeWindow_toSurface);
  66. return true;
  67. }
  68. void AndroidImageReader::AImage_delete(AImage* image) {
  69. AImage_delete_(image);
  70. }
  71. void AndroidImageReader::AImage_deleteAsync(AImage* image, int releaseFenceFd) {
  72. AImage_deleteAsync_(image, releaseFenceFd);
  73. }
  74. media_status_t AndroidImageReader::AImage_getHardwareBuffer(
  75. const AImage* image,
  76. AHardwareBuffer** buffer) {
  77. return AImage_getHardwareBuffer_(image, buffer);
  78. }
  79. media_status_t AndroidImageReader::AImage_getWidth(const AImage* image,
  80. int32_t* width) {
  81. return AImage_getWidth_(image, width);
  82. }
  83. media_status_t AndroidImageReader::AImage_getHeight(const AImage* image,
  84. int32_t* height) {
  85. return AImage_getHeight_(image, height);
  86. }
  87. media_status_t AndroidImageReader::AImage_getCropRect(const AImage* image,
  88. AImageCropRect* rect) {
  89. return AImage_getCropRect_(image, rect);
  90. }
  91. media_status_t AndroidImageReader::AImageReader_newWithUsage(
  92. int32_t width,
  93. int32_t height,
  94. int32_t format,
  95. uint64_t usage,
  96. int32_t maxImages,
  97. AImageReader** reader) {
  98. return AImageReader_newWithUsage_(width, height, format, usage, maxImages,
  99. reader);
  100. }
  101. media_status_t AndroidImageReader::AImageReader_setImageListener(
  102. AImageReader* reader,
  103. AImageReader_ImageListener* listener) {
  104. return AImageReader_setImageListener_(reader, listener);
  105. }
  106. void AndroidImageReader::AImageReader_delete(AImageReader* reader) {
  107. AImageReader_delete_(reader);
  108. }
  109. media_status_t AndroidImageReader::AImageReader_getFormat(
  110. const AImageReader* reader,
  111. int32_t* format) {
  112. return AImageReader_getFormat_(reader, format);
  113. }
  114. media_status_t AndroidImageReader::AImageReader_getWindow(
  115. AImageReader* reader,
  116. ANativeWindow** window) {
  117. return AImageReader_getWindow_(reader, window);
  118. }
  119. media_status_t AndroidImageReader::AImageReader_acquireLatestImageAsync(
  120. AImageReader* reader,
  121. AImage** image,
  122. int* acquireFenceFd) {
  123. return AImageReader_acquireLatestImageAsync_(reader, image, acquireFenceFd);
  124. }
  125. media_status_t AndroidImageReader::AImageReader_acquireNextImageAsync(
  126. AImageReader* reader,
  127. AImage** image,
  128. int* acquireFenceFd) {
  129. return AImageReader_acquireNextImageAsync_(reader, image, acquireFenceFd);
  130. }
  131. jobject AndroidImageReader::ANativeWindow_toSurface(JNIEnv* env,
  132. ANativeWindow* window) {
  133. return ANativeWindow_toSurface_(env, window);
  134. }
  135. } // namespace android
  136. } // namespace base