239 lines
7.7 KiB
C++
Executable File
239 lines
7.7 KiB
C++
Executable File
/*
|
|
* Copyright (C) 2015 The Android Open Source Project
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
|
|
#ifndef ANDROID_DRM_DISPLAY_COMPOSITOR_H_
|
|
#define ANDROID_DRM_DISPLAY_COMPOSITOR_H_
|
|
|
|
#include "drmdisplaycomposition.h"
|
|
#include "drmframebuffer.h"
|
|
#include "drmlayer.h"
|
|
#include "resources/resourcemanager.h"
|
|
#include "vsyncworker.h"
|
|
#include "drmcompositorworker.h"
|
|
#ifdef USE_LIBPQ
|
|
#include "rkpq.h"
|
|
#endif
|
|
|
|
#include <pthread.h>
|
|
#include <memory>
|
|
#include <sstream>
|
|
#include <tuple>
|
|
#include <queue>
|
|
|
|
#include <hardware/hardware.h>
|
|
#include <hardware/hwcomposer.h>
|
|
|
|
#define OVERSCAN_MIN_VALUE (80)
|
|
#define OVERSCAN_MAX_VALUE (100)
|
|
|
|
// One for the front, one for the back, and one for cases where we need to
|
|
// squash a frame that the hw can't display with hw overlays.
|
|
#define DRM_DISPLAY_BUFFERS 3
|
|
|
|
// If a scene is still for this number of vblanks flatten it to reduce power
|
|
// consumption.
|
|
#define FLATTEN_COUNTDOWN_INIT 60
|
|
|
|
namespace android {
|
|
class ResourceManager;
|
|
|
|
class DrmDisplayCompositor {
|
|
public:
|
|
DrmDisplayCompositor();
|
|
~DrmDisplayCompositor();
|
|
|
|
int Init(ResourceManager *resource_manager, int display);
|
|
|
|
std::unique_ptr<DrmDisplayComposition> CreateComposition() const;
|
|
std::unique_ptr<DrmDisplayComposition> CreateInitializedComposition() const;
|
|
int QueueComposition(std::unique_ptr<DrmDisplayComposition> composition);
|
|
int TestComposition(DrmDisplayComposition *composition);
|
|
int Composite();
|
|
int CollectSFInfo();
|
|
// 顺序模式
|
|
int CollectSFInfoBySequence();
|
|
// 丢帧模式
|
|
int CollectSFInfoByDrop();
|
|
|
|
int CollectVPInfo();
|
|
int CollectVPHdrInfo(DrmHwcLayer &layer);
|
|
// HwVirtualDisplay功能
|
|
int WriteBackByRGA();
|
|
void Dump(std::ostringstream *out) const;
|
|
void Vsync(int display, int64_t timestamp);
|
|
void SingalCompsition(std::unique_ptr<DrmDisplayComposition> composition);
|
|
void ClearDisplayHdrState();
|
|
void ClearDisplay();
|
|
int display() { return display_;};
|
|
std::tuple<uint32_t, uint32_t, int> GetActiveModeResolution();
|
|
|
|
bool HaveQueuedComposites() const;
|
|
bool IsSidebandMode() const;
|
|
int GetCompositeQueueMaxSize(DrmDisplayComposition* composition);
|
|
|
|
private:
|
|
struct ModeState {
|
|
bool needs_modeset = false;
|
|
DrmMode mode;
|
|
uint32_t blob_id = 0;
|
|
uint32_t old_blob_id = 0;
|
|
};
|
|
|
|
struct SidebandState {
|
|
bool enable_ = false;
|
|
uint64_t tunnel_id_ = 0;
|
|
std::shared_ptr<DrmBuffer> buffer_ = NULL;
|
|
};
|
|
|
|
struct HdrState{
|
|
DrmHdrType mode_ = DRM_HWC_SDR;
|
|
bool bHasYuv10bit_ = false;
|
|
android_dataspace_t datespace_;
|
|
};
|
|
|
|
struct ModeSetState{
|
|
HdrState hdr_;
|
|
};
|
|
|
|
DrmDisplayCompositor(const DrmDisplayCompositor &) = delete;
|
|
|
|
// We'll wait for acquire fences to fire for kAcquireWaitTimeoutMs,
|
|
// kAcquireWaitTries times, logging a warning in between.
|
|
static const int kAcquireWaitTries = 5;
|
|
static const int kAcquireWaitTimeoutMs = 100;
|
|
int CheckOverscan(drmModeAtomicReqPtr pset, DrmCrtc* crtc, int display, const char *UniqueName);
|
|
// Multi Thread function.
|
|
int GetTimestamp();
|
|
int64_t GetPhasedVSync(int64_t frame_ns, int64_t current);
|
|
int SyntheticWaitVBlank();
|
|
int CollectInfo(std::unique_ptr<DrmDisplayComposition> composition,
|
|
int status, bool writeback = false);
|
|
void Commit();
|
|
int CollectCommitInfo(drmModeAtomicReqPtr pset,
|
|
DrmDisplayComposition *display_comp,
|
|
bool test_only,
|
|
DrmConnector *writeback_conn = NULL,
|
|
DrmHwcBuffer *writeback_buffer = NULL);
|
|
int CommitSidebandStream(drmModeAtomicReqPtr pset,
|
|
DrmPlane* plane,
|
|
DrmHwcLayer &layer,
|
|
int zpos,
|
|
int crtc_id);
|
|
int CommitFrame(DrmDisplayComposition *display_comp,
|
|
bool test_only,
|
|
DrmConnector *writeback_conn = NULL,
|
|
DrmHwcBuffer *writeback_buffer = NULL);
|
|
int SetupWritebackCommit(drmModeAtomicReqPtr pset, uint32_t crtc_id,
|
|
DrmConnector *writeback_conn,
|
|
DrmHwcBuffer *writeback_buffer);
|
|
int DisableWritebackCommit(drmModeAtomicReqPtr pset,
|
|
DrmConnector *writeback_conn);
|
|
int CollectModeSetInfo(drmModeAtomicReqPtr pset,
|
|
DrmDisplayComposition *display_comp,
|
|
bool is_sideband_collect);
|
|
int UpdateModeSetState();
|
|
int UpdateSidebandState();
|
|
int ApplyDpms(DrmDisplayComposition *display_comp);
|
|
int DisablePlanes(DrmDisplayComposition *display_comp);
|
|
|
|
void ApplyFrame(std::unique_ptr<DrmDisplayComposition> composition,
|
|
int status, bool writeback = false);
|
|
int FlattenActiveComposition();
|
|
int FlattenSerial(DrmConnector *writeback_conn);
|
|
int FlattenConcurrent(DrmConnector *writeback_conn);
|
|
int FlattenOnDisplay(std::unique_ptr<DrmDisplayComposition> &src,
|
|
DrmConnector *writeback_conn, DrmMode &src_mode,
|
|
DrmHwcLayer *writeback_layer);
|
|
|
|
bool CountdownExpired() const;
|
|
|
|
std::tuple<int, uint32_t> CreateModeBlob(const DrmMode &mode);
|
|
|
|
ResourceManager *resource_manager_;
|
|
int display_;
|
|
DrmCompositorWorker worker_;
|
|
drmModeAtomicReqPtr pset_ = NULL;
|
|
|
|
// Store the display request from SF.
|
|
std::queue<std::unique_ptr<DrmDisplayComposition>> composite_queue_;
|
|
// Store the display request from SF.
|
|
std::queue<std::unique_ptr<DrmDisplayComposition>> composite_queue_temp_;
|
|
// Store the request that is about to be submitted for display.
|
|
std::map<int,std::unique_ptr<DrmDisplayComposition>> collect_composition_map_;
|
|
// Store the request currently being displayed on the screen.
|
|
std::map<int,std::unique_ptr<DrmDisplayComposition>> active_composition_map_;
|
|
|
|
std::unique_ptr<DrmDisplayComposition> active_composition_;
|
|
|
|
pthread_cond_t composite_queue_cond_;
|
|
|
|
bool initialized_;
|
|
bool active_;
|
|
bool use_hw_overlays_;
|
|
// Enter ClearDisplay state must SignalCompositionDone to signal releaseFence
|
|
bool clear_;
|
|
|
|
ModeState mode_;
|
|
|
|
// RK Support:
|
|
bool need_mode_set_;
|
|
ModeSetState request_mode_set_;
|
|
ModeSetState current_mode_set_;
|
|
|
|
int framebuffer_index_;
|
|
DrmFramebuffer framebuffers_[DRM_DISPLAY_BUFFERS];
|
|
|
|
// mutable since we need to acquire in HaveQueuedComposites
|
|
mutable pthread_mutex_t lock_;
|
|
|
|
// State tracking progress since our last Dump(). These are mutable since
|
|
// we need to reset them on every Dump() call.
|
|
mutable uint64_t dump_frames_composited_;
|
|
mutable uint64_t dump_last_timestamp_ns_;
|
|
VSyncWorker vsync_worker_;
|
|
int64_t flatten_countdown_;
|
|
std::unique_ptr<Planner> planner_;
|
|
int writeback_fence_;
|
|
// Multi Thread function.
|
|
int64_t last_timestamp_;
|
|
struct timespec vsync_;
|
|
|
|
std::map<int, uint64_t> mapDisplayHaveQeueuCnt_;
|
|
|
|
bool bWriteBackRequestDisable_;
|
|
bool bWriteBackEnable_;
|
|
|
|
uint32_t hdr_blob_id_ = 0;
|
|
|
|
uint64_t frame_no_ = 0;
|
|
// RK Support Sideband mode
|
|
SidebandState current_sideband2_;
|
|
SidebandState drawing_sideband2_;
|
|
|
|
// 丢帧模式
|
|
bool drop_mode_ = false;
|
|
|
|
#ifdef USE_LIBPQ
|
|
// Sideband YUV444 tmp buffer
|
|
std::shared_ptr<DrmBuffer> sidbenad_pq_tmp_buffer_ = NULL;
|
|
std::shared_ptr<rkpq> pq_ = NULL;
|
|
int pq_last_init_format_ = 0;
|
|
#endif
|
|
};
|
|
} // namespace android
|
|
|
|
#endif // ANDROID_DRM_DISPLAY_COMPOSITOR_H_
|