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

media/libaudiohal/impl/StreamHalAidl.h

+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) {

services/audiopolicy/managerdefault/AudioPolicyManager.cpp

+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,

services/camera/virtualcamera/VirtualCameraDevice.cc

+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());

services/camera/virtualcamera/VirtualCameraDevice.h

+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";

services/camera/virtualcamera/VirtualCameraRenderThread.cc

+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();