Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 927c0b80 authored by Android Build Coastguard Worker's avatar Android Build Coastguard Worker
Browse files

Snap for 11896415 from 4552f587 to 24Q3-release

Change-Id: I3ba0f78728b25f19b10aff92a5cff4982948ef95
parents ce02eb08 4552f587
Loading
Loading
Loading
Loading
+3 −2
Original line number Diff line number Diff line
@@ -95,7 +95,8 @@ class StreamContextAidl {
    size_t getBufferSizeBytes() const { return mFrameSizeBytes * mBufferSizeFrames; }
    size_t getBufferSizeFrames() const { return mBufferSizeFrames; }
    size_t getBufferDurationMs(int32_t sampleRate) const {
        return sampleRate != 0 ? mBufferSizeFrames * MILLIS_PER_SECOND / sampleRate : 0;
        auto bufferSize = mIsMmapped ? getMmapBurstSize() : mBufferSizeFrames;
        return sampleRate != 0 ? bufferSize * MILLIS_PER_SECOND / sampleRate : 0;
    }
    CommandMQ* getCommandMQ() const { return mCommandMQ.get(); }
    DataMQ* getDataMQ() const { return mDataMQ.get(); }
@@ -104,7 +105,7 @@ class StreamContextAidl {
    bool isAsynchronous() const { return mIsAsynchronous; }
    bool isMmapped() const { return mIsMmapped; }
    const MmapBufferDescriptor& getMmapBufferDescriptor() const { return mMmapBufferDescriptor; }

    size_t getMmapBurstSize() const { return mMmapBufferDescriptor.burstSizeFrames;}
  private:
    static std::unique_ptr<DataMQ> maybeCreateDataMQ(
            const ::aidl::android::hardware::audio::core::StreamDescriptor& descriptor) {
+18 −2
Original line number Diff line number Diff line
@@ -563,15 +563,31 @@ status_t AudioPolicyManager::handleDeviceConfigChange(audio_devices_t device,
        }
    }
    auto musicStrategy = streamToStrategy(AUDIO_STREAM_MUSIC);
    uint32_t muteWaitMs = 0;
    for (size_t i = 0; i < mOutputs.size(); i++) {
       sp<SwAudioOutputDescriptor> desc = mOutputs.valueAt(i);
       // mute media strategies and delay device switch by the largest
       // This avoid sending the music tail into the earpiece or headset.
       // mute media strategies to avoid sending the music tail into
       // the earpiece or headset.
       if (desc->isStrategyActive(musicStrategy)) {
           uint32_t tempRecommendedMuteDuration = desc->getRecommendedMuteDurationMs();
           uint32_t tempMuteDurationMs = tempRecommendedMuteDuration > 0 ?
                        tempRecommendedMuteDuration : desc->latency() * 4;
           if (muteWaitMs < tempMuteDurationMs) {
               muteWaitMs = tempMuteDurationMs;
           }
       }
       setStrategyMute(musicStrategy, true, desc);
       setStrategyMute(musicStrategy, false, desc, MUTE_TIME_MS,
          mEngine->getOutputDevicesForAttributes(attributes_initializer(AUDIO_USAGE_MEDIA),
                                              nullptr, true /*fromCache*/).types());
    }
    // Wait for the muted audio to propagate down the audio path see checkDeviceMuteStrategies().
    // We assume that MUTE_TIME_MS is way larger than muteWaitMs so that unmuting still
    // happens after the actual device switch.
    if (muteWaitMs > 0) {
        ALOGW_IF(MUTE_TIME_MS < muteWaitMs * 2, "%s excessive mute wait %d", __func__, muteWaitMs);
        usleep(muteWaitMs * 1000);
    }
    // Toggle the device state: UNAVAILABLE -> AVAILABLE
    // This will force reading again the device configuration
    status_t status = setDeviceConnectionState(device,
+12 −7
Original line number Diff line number Diff line
@@ -73,13 +73,14 @@ const char* kDevicePathPrefix = "device@1.1/virtual/";

constexpr int32_t kMaxJpegSize = 3 * 1024 * 1024 /*3MiB*/;

constexpr int32_t kMinFps = 15;

constexpr std::chrono::nanoseconds kMaxFrameDuration =
    std::chrono::duration_cast<std::chrono::nanoseconds>(1e9ns / kMinFps);
    std::chrono::duration_cast<std::chrono::nanoseconds>(
        1e9ns / VirtualCameraDevice::kMinFps);

constexpr uint8_t kPipelineMaxDepth = 2;

constexpr int k30Fps = 30;

constexpr MetadataBuilder::ControlRegion kDefaultEmptyControlRegion{};

const std::array<Resolution, 5> kStandardJpegThumbnailSizes{
@@ -130,16 +131,20 @@ std::vector<FpsRange> fpsRangesForInputConfig(
  std::set<FpsRange> availableRanges;

  for (const SupportedStreamConfiguration& config : configs) {
    availableRanges.insert({.minFps = kMinFps, .maxFps = config.maxFps});
    availableRanges.insert(
        {.minFps = VirtualCameraDevice::kMinFps, .maxFps = config.maxFps});
    availableRanges.insert({.minFps = config.maxFps, .maxFps = config.maxFps});
  }

  if (std::any_of(configs.begin(), configs.end(),
                  [](const SupportedStreamConfiguration& config) {
                    return config.maxFps >= 30;
                    return config.maxFps >= k30Fps;
                  })) {
    availableRanges.insert({.minFps = kMinFps, .maxFps = 30});
    availableRanges.insert({.minFps = 30, .maxFps = 30});
    // Extend the set of available ranges with (minFps <= 15, 30) & (30, 30) as
    // required by CDD.
    availableRanges.insert(
        {.minFps = VirtualCameraDevice::kMinFps, .maxFps = k30Fps});
    availableRanges.insert({.minFps = k30Fps, .maxFps = k30Fps});
  }

  return std::vector<FpsRange>(availableRanges.begin(), availableRanges.end());
+4 −0
Original line number Diff line number Diff line
@@ -126,6 +126,10 @@ class VirtualCameraDevice
  // Default JPEG orientation.
  static constexpr uint8_t kDefaultJpegOrientation = 0;

  // TODO(b/342674104) CDD requires <= 15.
  // Change this to lower value after confirming it doesn't cause any issue (timeouts).
  static constexpr int kMinFps = 15;

  // Default Make and Model for Exif
  static constexpr char kDefaultMakeAndModel[] = "Android Virtual Camera";

+34 −1
Original line number Diff line number Diff line
@@ -277,6 +277,16 @@ std::vector<uint8_t> createExif(
  return app1Data;
}

std::chrono::nanoseconds getMaxFrameDuration(
    const RequestSettings& requestSettings) {
  if (requestSettings.fpsRange.has_value()) {
    return std::chrono::nanoseconds(static_cast<uint64_t>(
        1e9 / std::max(1, requestSettings.fpsRange->minFps)));
  }
  return std::chrono::nanoseconds(
      static_cast<uint64_t>(1e9 / VirtualCameraDevice::kMinFps));
}

}  // namespace

CaptureRequestBuffer::CaptureRequestBuffer(int streamId, int bufferId,
@@ -419,7 +429,7 @@ void VirtualCameraRenderThread::processCaptureRequest(
  std::chrono::nanoseconds timestamp =
      std::chrono::duration_cast<std::chrono::nanoseconds>(
          std::chrono::steady_clock::now().time_since_epoch());
  std::chrono::nanoseconds lastAcquisitionTimestamp(
  const std::chrono::nanoseconds lastAcquisitionTimestamp(
      mLastAcquisitionTimestampNanoseconds.exchange(timestamp.count(),
                                                    std::memory_order_relaxed));

@@ -449,6 +459,29 @@ void VirtualCameraRenderThread::processCaptureRequest(
    }
  }

  // Calculate the maximal amount of time we can afford to wait for next frame.
  const std::chrono::nanoseconds maxFrameDuration =
      getMaxFrameDuration(request.getRequestSettings());
  const std::chrono::nanoseconds elapsedDuration =
      timestamp - lastAcquisitionTimestamp;
  if (elapsedDuration < maxFrameDuration) {
    // We can afford to wait for next frame.
    // Note that if there's already new frame in the input Surface, the call
    // below returns immediatelly.
    bool gotNewFrame = mEglSurfaceTexture->waitForNextFrame(maxFrameDuration -
                                                            elapsedDuration);
    timestamp = std::chrono::duration_cast<std::chrono::nanoseconds>(
        std::chrono::steady_clock::now().time_since_epoch());
    if (!gotNewFrame) {
      ALOGV(
          "%s: No new frame received on input surface after waiting for "
          "%" PRIu64 "ns, repeating last frame.",
          __func__,
          static_cast<uint64_t>((timestamp - lastAcquisitionTimestamp).count()));
    }
    mLastAcquisitionTimestampNanoseconds.store(timestamp.count(),
                                               std::memory_order_relaxed);
  }
  // Acquire new (most recent) image from the Surface.
  mEglSurfaceTexture->updateTexture();

Loading