frame_cadence_adapter.cc | Explore in Territory

/*
 *  Copyright (c) 2021 The WebRTC project authors. All Rights Reserved.
 *
 *  Use of this source code is governed by a BSD-style license
 *  that can be found in the LICENSE file in the root of the source
 *  tree. An additional intellectual property rights grant can be found
 *  in the file PATENTS.  All contributing project authors may
 *  be found in the AUTHORS file in the root of the source tree.
 */

#include "video/frame_cadence_adapter.h"

#include <algorithm>
#include <atomic>
#include <cstdint>
#include <deque>
#include <memory>
#include <utility>
#include <vector>

#include "absl/algorithm/container.h"
#include "absl/base/attributes.h"
#include "absl/cleanup/cleanup.h"
#include "api/sequence_checker.h"
#include "api/task_queue/pending_task_safety_flag.h"
#include "api/task_queue/task_queue_base.h"
#include "api/units/time_delta.h"
#include "api/units/timestamp.h"
#include "api/video/video_frame.h"
#include "rtc_base/checks.h"
#include "rtc_base/logging.h"
#include "rtc_base/race_checker.h"
#include "rtc_base/rate_statistics.h"
#include "rtc_base/synchronization/mutex.h"
#include "rtc_base/system/no_unique_address.h"
#include "rtc_base/system/unused.h"
#include "rtc_base/task_utils/repeating_task.h"
#include "rtc_base/thread_annotations.h"
#include "rtc_base/time_utils.h"
#include "rtc_base/trace_event.h"
#include "system_wrappers/include/clock.h"
#include "system_wrappers/include/metrics.h"
#include "system_wrappers/include/ntp_time.h"

namespace webrtc {
namespace {

// Abstracts concrete modes of the cadence adapter.
class AdapterMode { … };

// Implements a pass-through adapter. Single-threaded.
class PassthroughAdapterMode : public AdapterMode { … };

// Implements a frame cadence adapter supporting zero-hertz input.
class ZeroHertzAdapterMode : public AdapterMode { … };

// Implements a frame cadence adapter supporting VSync aligned encoding.
class VSyncEncodeAdapterMode : public AdapterMode { … };

class FrameCadenceAdapterImpl : public FrameCadenceAdapterInterface { … };

ZeroHertzAdapterMode::ZeroHertzAdapterMode(
    TaskQueueBase* queue,
    Clock* clock,
    FrameCadenceAdapterInterface::Callback* callback,
    double max_fps,
    std::atomic<int>& frames_scheduled_for_processing,
    bool zero_hertz_queue_overload_enabled)
    : … { … }

void ZeroHertzAdapterMode::ReconfigureParameters(
    const FrameCadenceAdapterInterface::ZeroHertzModeParams& params) { … }

void ZeroHertzAdapterMode::UpdateLayerQualityConvergence(
    size_t spatial_index,
    bool quality_converged) { … }

void ZeroHertzAdapterMode::UpdateLayerStatus(size_t spatial_index,
                                             bool enabled) { … }

void ZeroHertzAdapterMode::OnFrame(Timestamp post_time,
                                   bool queue_overload,
                                   const VideoFrame& frame) { … }

void ZeroHertzAdapterMode::OnDiscardedFrame() { … }

absl::optional<uint32_t> ZeroHertzAdapterMode::GetInputFrameRateFps() { … }

void ZeroHertzAdapterMode::UpdateVideoSourceRestrictions(
    absl::optional<double> max_frame_rate) { … }

void ZeroHertzAdapterMode::ProcessKeyFrameRequest() { … }

bool ZeroHertzAdapterMode::HasQualityConverged() const { … }

void ZeroHertzAdapterMode::ResetQualityConvergenceInfo() { … }

void ZeroHertzAdapterMode::ProcessOnDelayedCadence(Timestamp post_time) { … }

void ZeroHertzAdapterMode::ScheduleRepeat(int frame_id, bool idle_repeat) { … }

void ZeroHertzAdapterMode::ProcessRepeatedFrameOnDelayedCadence(int frame_id) { … }

void ZeroHertzAdapterMode::SendFrameNow(absl::optional<Timestamp> post_time,
                                        const VideoFrame& frame) { … }

TimeDelta ZeroHertzAdapterMode::FrameDuration() const { … }

TimeDelta ZeroHertzAdapterMode::RepeatDuration(bool idle_repeat) const { … }

void ZeroHertzAdapterMode::MaybeStartRefreshFrameRequester() { … }

void VSyncEncodeAdapterMode::OnFrame(Timestamp post_time,
                                     bool queue_overload,
                                     const VideoFrame& frame) { … }

void VSyncEncodeAdapterMode::EncodeAllEnqueuedFrames() { … }

FrameCadenceAdapterImpl::FrameCadenceAdapterImpl(
    Clock* clock,
    TaskQueueBase* queue,
    Metronome* metronome,
    TaskQueueBase* worker_queue,
    const FieldTrialsView& field_trials)
    : … { … }

FrameCadenceAdapterImpl::~FrameCadenceAdapterImpl() { … }

void FrameCadenceAdapterImpl::Initialize(Callback* callback) { … }

void FrameCadenceAdapterImpl::SetZeroHertzModeEnabled(
    absl::optional<ZeroHertzModeParams> params) { … }

absl::optional<uint32_t> FrameCadenceAdapterImpl::GetInputFrameRateFps() { … }

void FrameCadenceAdapterImpl::UpdateFrameRate(Timestamp frame_timestamp) { … }

void FrameCadenceAdapterImpl::UpdateLayerQualityConvergence(
    size_t spatial_index,
    bool quality_converged) { … }

void FrameCadenceAdapterImpl::UpdateLayerStatus(size_t spatial_index,
                                                bool enabled) { … }

void FrameCadenceAdapterImpl::UpdateVideoSourceRestrictions(
    absl::optional<double> max_frame_rate) { … }

void FrameCadenceAdapterImpl::ProcessKeyFrameRequest() { … }

void FrameCadenceAdapterImpl::OnFrame(const VideoFrame& frame) { … }

void FrameCadenceAdapterImpl::OnDiscardedFrame() { … }

void FrameCadenceAdapterImpl::OnConstraintsChanged(
    const VideoTrackSourceConstraints& constraints) { … }

void FrameCadenceAdapterImpl::OnFrameOnMainQueue(Timestamp post_time,
                                                 bool queue_overload,
                                                 const VideoFrame& frame) { … }

bool FrameCadenceAdapterImpl::IsZeroHertzScreenshareEnabled() const { … }

void FrameCadenceAdapterImpl::ConfigureCurrentAdapterWithoutZeroHertz() { … }

void FrameCadenceAdapterImpl::MaybeReconfigureAdapters(
    bool was_zero_hertz_enabled) { … }

}  // namespace

std::unique_ptr<FrameCadenceAdapterInterface>
FrameCadenceAdapterInterface::Create(Clock* clock,
                                     TaskQueueBase* queue,
                                     Metronome* metronome,
                                     TaskQueueBase* worker_queue,
                                     const FieldTrialsView& field_trials) { … }

}  // namespace webrtc
chromium/third_party/webrtc/video/frame_cadence_adapter.cc
