Merge "Snap for 11510257 from 76167db6a857119b7c4746f9a92827290f81bfa2 to simpleperf-release" into simpleperf-releasesimpleperf-release

6 files changed, 68 insertions, 20 deletions

diff --git a/audio/include/system/audio.h b/audio/include/system/audio.h
index 826c1a22..2979ba3f 100644
--- a/audio/include/system/audio.h
+++ b/audio/include/system/audio.h
@@ -332,6 +332,24 @@ static inline CONSTEXPR audio_channel_mask_t audio_channel_mask_from_representat
 }
 
 /*
+ * Returns true so long as stereo channels are present in the channel mask.
+ *
+ * This is the minimum constraint for spatialization in Android V.
+ *
+ * Prior to V, AUDIO_CHANNEL_OUT_QUAD was the minimum constraint.
+ * Prior to T, AUDIO_CHANNEL_OUT_5POINT1 was the minimum constraint.
+ *
+ * TODO(b/303920722) rename to audio_is_channel_mask_spatialized() after testing
+ * is complete.
+ * TODO(b/316909431) flagged at caller due to lack of native_bridge flag support.
+ */
+static inline CONSTEXPR bool audio_channel_mask_contains_stereo(audio_channel_mask_t channelMask) {
+    return audio_channel_mask_get_representation(channelMask)
+                == AUDIO_CHANNEL_REPRESENTATION_POSITION
+            && (channelMask & AUDIO_CHANNEL_OUT_STEREO) == AUDIO_CHANNEL_OUT_STEREO;
+}
+
+/*
  * Returns true so long as Quadraphonic channels (FL, FR, BL, BR)
  * or (FL, FR, SL, SR) are completely specified
  * in the channel mask. We expect these 4 channels to be the minimum for
diff --git a/audio/include/system/audio_effects/aidl_effects_utils.h b/audio/include/system/audio_effects/aidl_effects_utils.h
index e6583a18..bf8bec70 100644
--- a/audio/include/system/audio_effects/aidl_effects_utils.h
+++ b/audio/include/system/audio_effects/aidl_effects_utils.h
@@ -49,7 +49,7 @@ static constexpr uint32_t kEventFlagDataMqUpdate = 0x1 << 1;
  * so this method return true.
  */
 template <typename T, typename R>
-bool inRange(const T& target, const R& ranges) {
+static inline bool inRange(const T& target, const R& ranges) {
   for (const auto& r : ranges) {
     if (target.getTag() == r.min.getTag() &&
         target.getTag() == r.max.getTag() &&
@@ -61,16 +61,36 @@ bool inRange(const T& target, const R& ranges) {
 }
 
 template <typename Range::Tag rangeTag, typename T>
-bool inRange(const T& target, const Capability& cap) {
+static inline bool inRange(const T& target, const Capability& cap) {
   if (cap.range.getTag() == rangeTag) {
-      const auto& ranges = cap.range.template get<rangeTag>();
-      return inRange(target, ranges);
+    const auto& ranges = cap.range.template get<rangeTag>();
+    return inRange(target, ranges);
   }
   return true;
 }
 
+/**
+ * Return the range pair (as defined in aidl::android::hardware::audio::effect::Range) of a
+ * parameter.
+ */
+template <typename Range::Tag RangeTag, typename R, typename T>
+static inline std::optional<R> getRange(const Capability& cap, T tag) {
+  if (cap.range.getTag() != RangeTag) {
+    return std::nullopt;
+  }
+
+  const auto& ranges = cap.range.template get<RangeTag>();
+  for (const auto& r : ranges) {
+    if (r.min.getTag() == tag && r.max.getTag() == tag) {
+      return r;
+    }
+  }
+
+  return std::nullopt;
+}
+
 template <typename T, typename R>
-bool isRangeValid(const T& tag, const R& ranges) {
+static inline bool isRangeValid(const T& tag, const R& ranges) {
   for (const auto& r : ranges) {
     if (tag == r.min.getTag() && tag == r.max.getTag()) {
       return r.min <= r.max;
@@ -81,10 +101,10 @@ bool isRangeValid(const T& tag, const R& ranges) {
 }
 
 template <typename Range::Tag rangeTag, typename T>
-bool isRangeValid(const T& paramTag, const Capability& cap) {
+static inline bool isRangeValid(const T& paramTag, const Capability& cap) {
   if (cap.range.getTag() == rangeTag) {
-      const auto& ranges = cap.range.template get<rangeTag>();
-      return isRangeValid(paramTag, ranges);
+    const auto& ranges = cap.range.template get<rangeTag>();
+    return isRangeValid(paramTag, ranges);
   }
   return true;
 }
diff --git a/audio/include/system/audio_effects/effect_spatializer.h b/audio/include/system/audio_effects/effect_spatializer.h
index b92bb50d..2035d45f 100644
--- a/audio/include/system/audio_effects/effect_spatializer.h
+++ b/audio/include/system/audio_effects/effect_spatializer.h
@@ -86,7 +86,14 @@ typedef enum
 
     // Set/get the head tracking data connection mode: passes the mode followed by the sensor ID
     // on uint32_t
-    SPATIALIZER_PARAM_HEADTRACKING_CONNECTION
+    SPATIALIZER_PARAM_HEADTRACKING_CONNECTION,
+    // Set/get the actual input channel mask of the track being spatialized. This is required to
+    // support stereo spatialization (b/303920722) where number of active input channels would be
+    // different from the channel mask received during effect configuration.
+    // Stereo channels will be packed into 5.1 stream where the other 4 channels will contain
+    // silence. The effect can configure spatialization settings accordingly when this parameter is
+    // received.
+    SPATIALIZER_PARAM_INPUT_CHANNEL_MASK,
 } t_virtualizer_stage_params;
 
 // See SpatializationLevel.aidl
diff --git a/audio_utils/Metadata.cpp b/audio_utils/Metadata.cpp
index d580f4cb..1b7062d4 100644
--- a/audio_utils/Metadata.cpp
+++ b/audio_utils/Metadata.cpp
@@ -170,7 +170,8 @@ audio_metadata_t *audio_metadata_from_byte_string(const uint8_t *byteString, siz
         return nullptr;
     }
     return reinterpret_cast<audio_metadata_t *>(
-            new(std::nothrow) Data(dataFromByteString(ByteString(byteString, length))));
+            new(std::nothrow) Data(dataFromByteString(ByteString(byteString,
+                                                                 byteString + length))));
 }
 
 ssize_t byte_string_from_audio_metadata(audio_metadata_t *metadata, uint8_t **byteString) {
@@ -182,7 +183,7 @@ ssize_t byte_string_from_audio_metadata(audio_metadata_t *metadata, uint8_t **by
     if (*byteString == nullptr) {
         return -ENOMEM;
     }
-    memcpy(*byteString, bs.c_str(), bs.size());
+    memcpy(*byteString, bs.data(), bs.size());
     return bs.size();
 }
 
diff --git a/audio_utils/include/audio_utils/Metadata.h b/audio_utils/include/audio_utils/Metadata.h
index 2f1edb33..90186a82 100644
--- a/audio_utils/include/audio_utils/Metadata.h
+++ b/audio_utils/include/audio_utils/Metadata.h
@@ -23,6 +23,7 @@
 
 #ifdef __cplusplus
 
+#include <algorithm>
 #include <any>
 #include <map>
 #include <string>
@@ -554,7 +555,7 @@ using datum_size_t = uint32_t;
 
 // The particular implementation of ByteString may change
 // without affecting compatibility.
-using ByteString = std::basic_string<uint8_t>;
+using ByteString = std::vector<uint8_t>;
 
 /*
     These should correspond to the Java AudioMetadata.java
@@ -592,7 +593,7 @@ std::enable_if_t<
     bool
     >
 copyToByteString(const T& t, ByteString& bs) {
-    bs.append((uint8_t*)&t, sizeof(t));
+    bs.insert(bs.end(), (uint8_t*)&t, (uint8_t*)&t + sizeof(t));
     return true;
 }
 
@@ -609,7 +610,7 @@ bool copyToByteString(const V<Args...>& v, ByteString& bs) {
     index_size_t size = v.size();
     if (!copyToByteString(size, bs)) return false;
     if constexpr (std::is_same_v<std::decay_t<V<Args...>>, std::string>) {
-        bs.append((uint8_t*)v.c_str());
+        bs.insert(bs.end(), (uint8_t*)v.c_str(), (uint8_t*)v.c_str() + v.size());
     }  else /* constexpr */ {
         for (const auto &d : v) { // handles std::vector and std::map
             if (!copyToByteString(d, bs)) return false;
@@ -677,7 +678,8 @@ bool copyToByteString(const Datum& datum, ByteString &bs) {
              const size_t diff = bs.size() - idx - sizeof(datum_size);
              if (diff > std::numeric_limits<datum_size_t>::max()) return;
              datum_size = diff;
-             bs.replace(idx, sizeof(datum_size), (uint8_t*)&datum_size, sizeof(datum_size));
+             std::copy((uint8_t*)&datum_size, (uint8_t*)&datum_size + sizeof(datum_size),
+                       bs.begin() + idx);
              success = true;
          }, &datum) && success;
 }
@@ -707,7 +709,7 @@ std::enable_if_t<
 copyFromByteString(T *dest, const ByteString& bs, size_t& idx,
         ByteStringUnknowns *unknowns __attribute__((unused))) {
     if (idx + sizeof(T) > bs.size()) return false;
-    bs.copy((uint8_t*)dest, sizeof(T), idx);
+    std::copy(bs.begin() + idx, bs.begin() + idx + sizeof(T), (uint8_t*)dest);
     idx += sizeof(T);
     return true;
 }
diff --git a/audio_utils/tests/metadata_tests.cpp b/audio_utils/tests/metadata_tests.cpp
index 3856dc0d..2d63f990 100644
--- a/audio_utils/tests/metadata_tests.cpp
+++ b/audio_utils/tests/metadata_tests.cpp
@@ -458,13 +458,13 @@ TEST(metadata_tests, c) {
     ASSERT_GT(length, 0); // if gt 0, the bs has been updated to a new value.
     ASSERT_EQ((size_t)length, audio_metadata_byte_string_len(bs));
     ASSERT_EQ((size_t)length, dataByteStringLen(bs));
-    ASSERT_EQ(byteStringFromData(d).size(), ByteString(bs, length).size());
+    ASSERT_EQ(byteStringFromData(d).size(), ByteString(bs, bs + length).size());
     audio_metadata_t *metadataFromBs = audio_metadata_from_byte_string(bs, length);
     free(bs);
     bs = nullptr;
     length = byte_string_from_audio_metadata(metadataFromBs, &bs);
     ASSERT_GT(length, 0); // if gt 0, the bs has been updated to a new value.
-    ASSERT_EQ(byteStringFromData(d), ByteString(bs, length));
+    ASSERT_EQ(byteStringFromData(d), ByteString(bs, bs + length));
     ASSERT_EQ((size_t)length, audio_metadata_byte_string_len(bs));
     ASSERT_EQ((size_t)length, dataByteStringLen(bs));
     free(bs);
@@ -499,13 +499,13 @@ TEST(metadata_tests, empty_data_c) {
     ASSERT_EQ((size_t)length, dataByteStringLen(bs));
 
     Data d;  // empty metadata container.
-    ASSERT_EQ(byteStringFromData(d).size(), ByteString(bs, length).size());
+    ASSERT_EQ(byteStringFromData(d).size(), ByteString(bs, bs + length).size());
     std::unique_ptr<audio_metadata_t, decltype(&audio_metadata_destroy)>
             metadataFromBs{audio_metadata_from_byte_string(bs, length), audio_metadata_destroy};
     length = byte_string_from_audio_metadata(metadataFromBs.get(), &bs);
     ASSERT_GT(length, 0); // if gt 0, the bs has been updated to a new value.
     bs_scoped_deleter.reset(bs);
-    ASSERT_EQ(byteStringFromData(d), ByteString(bs, length));
+    ASSERT_EQ(byteStringFromData(d), ByteString(bs, bs + length));
     ASSERT_EQ((size_t)length, audio_metadata_byte_string_len(bs));
     ASSERT_EQ((size_t)length, dataByteStringLen(bs));
 };