| /* |
| * Copyright (c) 2014-2018, The Linux Foundation. All rights reserved. |
| * Not a Contribution. |
| * |
| * Copyright 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 __HWC_DISPLAY_H__ |
| #define __HWC_DISPLAY_H__ |
| |
| #include <QService.h> |
| #include <android/hardware/graphics/common/1.1/types.h> |
| #include <core/core_interface.h> |
| #include <hardware/hwcomposer.h> |
| #include <private/color_params.h> |
| #include <qdMetaData.h> |
| #include <sys/stat.h> |
| #include <map> |
| #include <queue> |
| #include <set> |
| #include <string> |
| #include <utility> |
| #include <vector> |
| |
| #include "hwc_buffer_allocator.h" |
| #include "hwc_callbacks.h" |
| #include "hwc_layers.h" |
| #include "histogram_collector.h" |
| |
| using android::hardware::graphics::common::V1_1::ColorMode; |
| using android::hardware::graphics::common::V1_1::Dataspace; |
| using android::hardware::graphics::common::V1_1::RenderIntent; |
| |
| namespace sdm { |
| |
| class BlitEngine; |
| class HWCToneMapper; |
| constexpr uint32_t kColorTransformMatrixCount = 16; |
| |
| // Subclasses set this to their type. This has to be different from DisplayType. |
| // This is to avoid RTTI and dynamic_cast |
| enum DisplayClass { |
| DISPLAY_CLASS_PRIMARY, |
| DISPLAY_CLASS_EXTERNAL, |
| DISPLAY_CLASS_VIRTUAL, |
| DISPLAY_CLASS_NULL |
| }; |
| |
| class HWCColorMatrix { |
| public: |
| HWCColorMatrix(const string &values) : key_values_(values){}; |
| virtual ~HWCColorMatrix() = default; |
| virtual HWC2::Error SetEnabled(bool enabled); |
| bool GetEnabled() const { return enabled_; } |
| // Apply effect to input matrix |
| virtual void ApplyToMatrix(double *in) = 0; |
| bool ParseFloatValueByCommas(const string &values, uint32_t length, |
| std::vector<float> &elements) const; |
| |
| protected: |
| bool enabled_ = false; |
| const string key_values_; |
| }; |
| |
| class WhiteCompensation : public HWCColorMatrix { |
| public: |
| WhiteCompensation(const string &values) : HWCColorMatrix(values){}; |
| int GetCompensatedRed() const { return compensated_red_; } |
| int GetCompensatedGreen() const { return compensated_green_; } |
| int GetCompensatedBlue() const { return compensated_blue_; } |
| HWC2::Error SetEnabled(bool enabled) override; |
| /* |
| * Transform matrix is 4 x 4 |
| * |r.r r.g r.b 0| |
| * |g.r g.g g.b 0| |
| * |b.r b.g b.b 0| |
| * |T.r T.g T.b 1| |
| * R_out = R_in * r.r + G_in * g.r + B_in * b.r + Tr |
| * G_out = R_in * r.g + G_in * g.g + B_in * b.g + Tg |
| * B_out = R_in * r.b + G_in * g.b + B_in * b.b + Tb |
| * |
| * Cr, Cg, Cb for white point compensation |
| * |r.r*Cr r.g*Cg r.b*Cb 0| |
| * |g.r*Cr g.g*Cg g.b*Cb 0| |
| * |b.r*Cr b.g*Cg b.b*Cb 0| |
| * |T.r*Cr T.g*Cg T.b*Cb 1| |
| * R_out = R_in * r.r * Cr + G_in * g.r * Cr + B_in * b.r * Cr + Tr * Cr |
| * G_out = R_in * r.g * Cg + G_in * g.g * Cg + B_in * b.g * Cg + Tg * Cg |
| * B_out = R_in * r.b * Cb + G_in * g.b * Cb + B_in * b.b * Cb + Tb * Cb |
| */ |
| void ApplyToMatrix(double *in) override; |
| |
| private: |
| static constexpr int kCompensatedMaxRGB = 255; |
| static constexpr int kCompensatedMinRGB = 230; |
| static constexpr int kNumOfCompensationData = 3; |
| int compensated_red_ = kCompensatedMaxRGB; |
| int compensated_green_ = kCompensatedMaxRGB; |
| int compensated_blue_ = kCompensatedMaxRGB; |
| |
| double compensated_red_ratio_ = 1.0; |
| double compensated_green_ratio_ = 1.0; |
| double compensated_blue_ratio_ = 1.0; |
| |
| static constexpr int kCoefficientElements = 9; |
| float white_compensated_Coefficients_[kCoefficientElements] = {0.0, 1.0, 0.0, 0.0, 1.0, |
| 0.0, 0.0, 1.0, 0.0}; |
| bool ConfigCoefficients(); |
| bool ParseWhitePointCalibrationData(); |
| inline static constexpr bool CheckCompensatedRGB(int value) { |
| return ((value >= kCompensatedMinRGB) && (value <= kCompensatedMaxRGB)); |
| } |
| void CalculateRGBRatio(); |
| }; |
| |
| class SaturationCompensation : public HWCColorMatrix { |
| public: |
| SaturationCompensation(const string &values) : HWCColorMatrix(values){}; |
| HWC2::Error SetEnabled(bool enabled) override; |
| /* Saturated matrix is 4 x 4 |
| * | s0 s1 s2 s3| |
| * | s4 s5 s6 s7| |
| * | s8 s9 s10 s11| |
| * | s12 s13 s14 s15| |
| * Transform matrix is 4 x 4 |
| * |a0 a1 a2 a3| |
| * |a4 a5 a6 a7| |
| * |a8 a9 a10 a11| |
| * |a12 a13 a14 a15| |
| * |
| * Saturated matrix[] X Transform matrix[] |
| */ |
| void ApplyToMatrix(double *in) override; |
| |
| private: |
| static constexpr int kSaturationParameters = 9; |
| static constexpr int kNumOfRows = 4; |
| static constexpr int kColumnsPerRow = 4; |
| static_assert(kNumOfRows * kColumnsPerRow == kColorTransformMatrixCount, |
| "Rows x Columns should be equal to matrix count"); |
| float saturated_matrix_[kColorTransformMatrixCount] = {1.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, |
| 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 1.0}; |
| bool ConfigSaturationParameter(); |
| }; |
| |
| class HWCColorMode { |
| public: |
| explicit HWCColorMode(DisplayInterface *display_intf); |
| ~HWCColorMode() {} |
| HWC2::Error Init(); |
| HWC2::Error DeInit(); |
| void Dump(std::ostringstream* os); |
| uint32_t GetColorModeCount(); |
| uint32_t GetRenderIntentCount(ColorMode mode); |
| HWC2::Error GetColorModes(uint32_t *out_num_modes, ColorMode *out_modes); |
| HWC2::Error GetRenderIntents(ColorMode mode, uint32_t *out_num_intents, RenderIntent *out_modes); |
| HWC2::Error SetColorModeWithRenderIntent(ColorMode mode, RenderIntent intent); |
| HWC2::Error SetColorModeById(int32_t color_mode_id); |
| HWC2::Error SetColorTransform(const float *matrix, android_color_transform_t hint); |
| HWC2::Error RestoreColorTransform(); |
| PrimariesTransfer GetWorkingColorSpace(); |
| ColorMode GetCurrentColorMode() { return current_color_mode_; } |
| HWC2::Error SetWhiteCompensation(bool enabled); |
| |
| private: |
| void PopulateColorModes(); |
| void FindRenderIntent(const ColorMode &mode, const std::string &mode_string); |
| template <class T> |
| void CopyColorTransformMatrix(const T *input_matrix, double *output_matrix) { |
| for (uint32_t i = 0; i < kColorTransformMatrixCount; i++) { |
| output_matrix[i] = static_cast<double>(input_matrix[i]); |
| } |
| } |
| HWC2::Error ApplyDefaultColorMode(); |
| |
| DisplayInterface *display_intf_ = NULL; |
| |
| ColorMode current_color_mode_ = ColorMode::NATIVE; |
| RenderIntent current_render_intent_ = RenderIntent::COLORIMETRIC; |
| typedef std::map<RenderIntent, std::string> RenderIntentMap; |
| // Initialize supported mode/render intent combination |
| std::map<ColorMode, RenderIntentMap> color_mode_map_ = {}; |
| double color_matrix_[kColorTransformMatrixCount] = { 1.0, 0.0, 0.0, 0.0, \ |
| 0.0, 1.0, 0.0, 0.0, \ |
| 0.0, 0.0, 1.0, 0.0, \ |
| 0.0, 0.0, 0.0, 1.0 }; |
| void InitColorCompensation(); |
| std::unique_ptr<WhiteCompensation> adaptive_white_; |
| std::unique_ptr<SaturationCompensation> adaptive_saturation_; |
| double compensated_color_matrix_[kColorTransformMatrixCount] = { 1.0, 0.0, 0.0, 0.0, \ |
| 0.0, 1.0, 0.0, 0.0, \ |
| 0.0, 0.0, 1.0, 0.0, \ |
| 0.0, 0.0, 0.0, 1.0 }; |
| bool HasWhiteCompensation() { return (adaptive_white_ && adaptive_white_->GetEnabled()); } |
| bool HasSaturationCompensation() { |
| return (adaptive_saturation_ && adaptive_saturation_->GetEnabled()); |
| } |
| |
| const double *PickTransferMatrix(); |
| }; |
| |
| class HWCDisplay : public DisplayEventHandler { |
| public: |
| enum DisplayStatus { |
| kDisplayStatusInvalid = -1, |
| kDisplayStatusOffline, |
| kDisplayStatusOnline, |
| kDisplayStatusPause, |
| kDisplayStatusResume, |
| }; |
| |
| enum DisplayValidateState { |
| kNormalValidate, |
| kInternalValidate, |
| kSkipValidate, |
| }; |
| |
| virtual ~HWCDisplay() {} |
| virtual int Init(); |
| virtual int Deinit(); |
| |
| // Framebuffer configurations |
| virtual void SetIdleTimeoutMs(uint32_t timeout_ms); |
| virtual HWC2::Error SetFrameDumpConfig(uint32_t count, uint32_t bit_mask_layer_type, |
| int32_t format, bool post_processed); |
| virtual DisplayError SetMaxMixerStages(uint32_t max_mixer_stages); |
| virtual DisplayError ControlPartialUpdate(bool enable, uint32_t *pending) { |
| return kErrorNotSupported; |
| } |
| virtual HWC2::PowerMode GetLastPowerMode(); |
| virtual int SetFrameBufferResolution(uint32_t x_pixels, uint32_t y_pixels); |
| virtual void GetFrameBufferResolution(uint32_t *x_pixels, uint32_t *y_pixels); |
| virtual int SetDisplayStatus(DisplayStatus display_status); |
| virtual int OnMinHdcpEncryptionLevelChange(uint32_t min_enc_level); |
| virtual int Perform(uint32_t operation, ...); |
| virtual void SetSecureDisplay(bool secure_display_active); |
| virtual DisplayError SetMixerResolution(uint32_t width, uint32_t height); |
| virtual DisplayError GetMixerResolution(uint32_t *width, uint32_t *height); |
| virtual void GetPanelResolution(uint32_t *width, uint32_t *height); |
| virtual std::string Dump(); |
| virtual DisplayError TeardownConcurrentWriteback(void) { |
| return kErrorNotSupported; |
| } |
| |
| // Captures frame output in the buffer specified by output_buffer_info. The API is |
| // non-blocking and the client is expected to check operation status later on. |
| // Returns -1 if the input is invalid. |
| virtual int FrameCaptureAsync(const BufferInfo &output_buffer_info, bool post_processed) { |
| return -1; |
| } |
| // Client gets release fence of the frame capture, requested with FrameCaptureAsync(). |
| // True : Frame capture configured and client gets release fence. |
| // False: Frame capture is not valid and has not been configured. |
| virtual bool GetFrameCaptureFence(int32_t *release_fence) { return false; } |
| |
| virtual DisplayError SetDetailEnhancerConfig(const DisplayDetailEnhancerData &de_data) { |
| return kErrorNotSupported; |
| } |
| virtual HWC2::Error SetReadbackBuffer(const native_handle_t *buffer, int32_t acquire_fence, |
| bool post_processed_output) { |
| return HWC2::Error::Unsupported; |
| } |
| virtual HWC2::Error GetReadbackBufferFence(int32_t *release_fence) { |
| return HWC2::Error::Unsupported; |
| } |
| |
| // Display Configurations |
| virtual int SetActiveDisplayConfig(uint32_t config); |
| virtual int GetActiveDisplayConfig(uint32_t *config); |
| virtual int GetDisplayConfigCount(uint32_t *count); |
| virtual int GetDisplayAttributesForConfig(int config, |
| DisplayConfigVariableInfo *display_attributes); |
| virtual int SetState(bool connected) { |
| return kErrorNotSupported; |
| } |
| virtual DisplayError Flush() { |
| return kErrorNotSupported; |
| } |
| |
| int SetPanelBrightness(int level); |
| int GetPanelBrightness(int *level); |
| int ToggleScreenUpdates(bool enable); |
| int ColorSVCRequestRoute(const PPDisplayAPIPayload &in_payload, PPDisplayAPIPayload *out_payload, |
| PPPendingParams *pending_action); |
| void SolidFillPrepare(); |
| void SolidFillCommit(); |
| DisplayClass GetDisplayClass(); |
| int GetVisibleDisplayRect(hwc_rect_t *rect); |
| void BuildLayerStack(void); |
| void BuildSolidFillStack(void); |
| HWCLayer *GetHWCLayer(hwc2_layer_t layer_id); |
| void ResetValidation() { validated_ = false; } |
| uint32_t GetGeometryChanges() { return geometry_changes_; } |
| bool CanSkipValidate(); |
| bool HasClientComposition() { return has_client_composition_; } |
| bool IsSkipValidateState() { return (validate_state_ == kSkipValidate); } |
| bool IsInternalValidateState() { return (validated_ && (validate_state_ == kInternalValidate)); } |
| void SetValidationState(DisplayValidateState state) { validate_state_ = state; } |
| ColorMode GetCurrentColorMode() { return current_color_mode_; } |
| |
| // HWC2 APIs |
| virtual HWC2::Error AcceptDisplayChanges(void); |
| virtual HWC2::Error GetActiveConfig(hwc2_config_t *out_config); |
| virtual HWC2::Error SetActiveConfig(hwc2_config_t config); |
| virtual HWC2::Error SetClientTarget(buffer_handle_t target, int32_t acquire_fence, |
| int32_t dataspace, hwc_region_t damage); |
| virtual HWC2::Error SetColorMode(ColorMode mode) { return HWC2::Error::Unsupported; } |
| virtual HWC2::Error SetWhiteCompensation(bool enabled) { return HWC2::Error::Unsupported; } |
| virtual HWC2::Error SetColorModeWithRenderIntent(ColorMode mode, RenderIntent intent) { |
| return HWC2::Error::Unsupported; |
| } |
| virtual HWC2::Error SetColorModeById(int32_t color_mode_id) { |
| return HWC2::Error::Unsupported; |
| } |
| virtual HWC2::Error RestoreColorTransform() { |
| return HWC2::Error::Unsupported; |
| } |
| virtual HWC2::Error SetColorTransform(const float *matrix, android_color_transform_t hint) { |
| return HWC2::Error::Unsupported; |
| } |
| virtual HWC2::Error HandleColorModeTransform(android_color_mode_t mode, |
| android_color_transform_t hint, |
| const double *matrix) { |
| return HWC2::Error::Unsupported; |
| } |
| virtual HWC2::Error GetDisplayConfigs(uint32_t *out_num_configs, hwc2_config_t *out_configs); |
| virtual HWC2::Error GetDisplayAttribute(hwc2_config_t config, HWC2::Attribute attribute, |
| int32_t *out_value); |
| virtual HWC2::Error GetClientTargetSupport(uint32_t width, uint32_t height, int32_t format, |
| int32_t dataspace); |
| virtual HWC2::Error GetColorModes(uint32_t *outNumModes, ColorMode *outModes); |
| virtual HWC2::Error GetRenderIntents(ColorMode mode, uint32_t *out_num_intents, |
| RenderIntent *out_intents); |
| virtual HWC2::Error GetChangedCompositionTypes(uint32_t *out_num_elements, |
| hwc2_layer_t *out_layers, int32_t *out_types); |
| virtual HWC2::Error GetDisplayRequests(int32_t *out_display_requests, uint32_t *out_num_elements, |
| hwc2_layer_t *out_layers, int32_t *out_layer_requests); |
| virtual HWC2::Error GetDisplayName(uint32_t *out_size, char *out_name); |
| virtual HWC2::Error GetDisplayType(int32_t *out_type); |
| virtual HWC2::Error SetCursorPosition(hwc2_layer_t layer, int x, int y); |
| virtual HWC2::Error SetVsyncEnabled(HWC2::Vsync enabled); |
| virtual HWC2::Error SetPowerMode(HWC2::PowerMode mode); |
| virtual HWC2::Error CreateLayer(hwc2_layer_t *out_layer_id); |
| virtual HWC2::Error DestroyLayer(hwc2_layer_t layer_id); |
| virtual HWC2::Error SetLayerZOrder(hwc2_layer_t layer_id, uint32_t z); |
| virtual HWC2::Error Validate(uint32_t *out_num_types, uint32_t *out_num_requests) = 0; |
| virtual HWC2::Error GetReleaseFences(uint32_t *out_num_elements, hwc2_layer_t *out_layers, |
| int32_t *out_fences); |
| virtual HWC2::Error Present(int32_t *out_retire_fence) = 0; |
| virtual HWC2::Error GetHdrCapabilities(uint32_t *out_num_types, int32_t* out_types, |
| float* out_max_luminance, |
| float* out_max_average_luminance, |
| float* out_min_luminance); |
| virtual HWC2::Error GetPerFrameMetadataKeys(uint32_t *out_num_keys, |
| PerFrameMetadataKey *out_keys); |
| virtual HWC2::Error SetDisplayAnimating(bool animating) { |
| animating_ = animating; |
| validated_ = false; |
| return HWC2::Error::None; |
| } |
| virtual HWC2::Error GetValidateDisplayOutput(uint32_t *out_num_types, uint32_t *out_num_requests); |
| virtual HWC2::Error ControlIdlePowerCollapse(bool enable, bool synchronous) { |
| return HWC2::Error::Unsupported; |
| } |
| |
| virtual HWC2::Error SetDisplayedContentSamplingEnabledVndService(bool enabled); |
| virtual HWC2::Error SetDisplayedContentSamplingEnabled(int32_t enabled, uint8_t component_mask, uint64_t max_frames); |
| virtual HWC2::Error GetDisplayedContentSamplingAttributes(int32_t* format, |
| int32_t* dataspace, |
| uint8_t* supported_components); |
| virtual HWC2::Error GetDisplayedContentSample(uint64_t max_frames, |
| uint64_t timestamp, |
| uint64_t* numFrames, |
| int32_t samples_size[NUM_HISTOGRAM_COLOR_COMPONENTS], |
| uint64_t* samples[NUM_HISTOGRAM_COLOR_COMPONENTS]); |
| |
| protected: |
| // Maximum number of layers supported by display manager. |
| static const uint32_t kMaxLayerCount = 32; |
| HWCDisplay(CoreInterface *core_intf, HWCCallbacks *callbacks, DisplayType type, hwc2_display_t id, |
| bool needs_blit, qService::QService *qservice, DisplayClass display_class, |
| BufferAllocator *buffer_allocator); |
| |
| // DisplayEventHandler methods |
| virtual DisplayError VSync(const DisplayEventVSync &vsync); |
| virtual DisplayError Refresh(); |
| virtual DisplayError CECMessage(char *message); |
| virtual DisplayError HandleEvent(DisplayEvent event); |
| virtual void DumpOutputBuffer(const BufferInfo &buffer_info, void *base, int fence); |
| virtual HWC2::Error PrepareLayerStack(uint32_t *out_num_types, uint32_t *out_num_requests); |
| virtual HWC2::Error CommitLayerStack(void); |
| virtual HWC2::Error PostCommitLayerStack(int32_t *out_retire_fence); |
| virtual DisplayError DisablePartialUpdateOneFrame() { |
| return kErrorNotSupported; |
| } |
| LayerBufferFormat GetSDMFormat(const int32_t &source, const int flags); |
| const char *GetDisplayString(); |
| void MarkLayersForGPUBypass(void); |
| void MarkLayersForClientComposition(void); |
| virtual void ApplyScanAdjustment(hwc_rect_t *display_frame); |
| uint32_t GetUpdatingLayersCount(void); |
| bool IsLayerUpdating(HWCLayer *layer); |
| uint32_t SanitizeRefreshRate(uint32_t req_refresh_rate); |
| virtual void GetUnderScanConfig() { } |
| |
| enum { |
| INPUT_LAYER_DUMP, |
| OUTPUT_LAYER_DUMP, |
| }; |
| |
| bool validated_ = false; |
| bool layer_stack_invalid_ = true; |
| CoreInterface *core_intf_ = nullptr; |
| HWCCallbacks *callbacks_ = nullptr; |
| HWCBufferAllocator *buffer_allocator_ = NULL; |
| DisplayType type_; |
| hwc2_display_t id_; |
| bool needs_blit_ = false; |
| DisplayInterface *display_intf_ = NULL; |
| LayerStack layer_stack_; |
| HWCLayer *client_target_ = nullptr; // Also known as framebuffer target |
| std::map<hwc2_layer_t, HWCLayer *> layer_map_; // Look up by Id - TODO |
| std::multiset<HWCLayer *, SortLayersByZ> layer_set_; // Maintain a set sorted by Z |
| std::map<hwc2_layer_t, HWC2::Composition> layer_changes_; |
| std::map<hwc2_layer_t, HWC2::LayerRequest> layer_requests_; |
| bool flush_on_error_ = false; |
| bool flush_ = false; |
| uint32_t dump_frame_count_ = 0; |
| uint32_t dump_frame_index_ = 0; |
| bool dump_input_layers_ = false; |
| HWC2::PowerMode last_power_mode_; |
| bool swap_interval_zero_ = false; |
| bool display_paused_ = false; |
| uint32_t min_refresh_rate_ = 0; |
| uint32_t max_refresh_rate_ = 0; |
| uint32_t current_refresh_rate_ = 0; |
| bool use_metadata_refresh_rate_ = false; |
| uint32_t metadata_refresh_rate_ = 0; |
| uint32_t force_refresh_rate_ = 0; |
| bool boot_animation_completed_ = false; |
| bool shutdown_pending_ = false; |
| bool use_blit_comp_ = false; |
| bool secure_display_active_ = false; |
| bool skip_prepare_ = false; |
| bool solid_fill_enable_ = false; |
| Layer *solid_fill_layer_ = NULL; |
| LayerRect solid_fill_rect_ = {}; |
| LayerSolidFill solid_fill_color_ = {}; |
| LayerRect display_rect_; |
| bool color_tranform_failed_ = false; |
| HWCColorMode *color_mode_ = NULL; |
| HWCToneMapper *tone_mapper_ = nullptr; |
| uint32_t num_configs_ = 0; |
| int disable_hdr_handling_ = 0; // disables HDR handling. |
| uint32_t display_config_ = 0; |
| bool config_pending_ = false; |
| bool pending_commit_ = false; |
| ColorMode current_color_mode_ = ColorMode::NATIVE; |
| ColorPrimaries working_primaries_ = ColorPrimaries_BT709_5; |
| GammaTransfer working_transfer_ = Transfer_sRGB; |
| float hdr_largest_layer_px_ = 0.0f; |
| |
| private: |
| void DumpInputBuffers(void); |
| void UpdateRefreshRate(); |
| bool CanSkipSdmPrepare(uint32_t *num_types, uint32_t *num_requests); |
| |
| qService::QService *qservice_ = NULL; |
| DisplayClass display_class_; |
| uint32_t geometry_changes_ = GeometryChanges::kNone; |
| bool animating_ = false; |
| bool has_client_composition_ = false; |
| DisplayValidateState validate_state_ = kNormalValidate; |
| bool partial_update_enabled_ = false; |
| }; |
| |
| inline int HWCDisplay::Perform(uint32_t operation, ...) { |
| return 0; |
| } |
| |
| } // namespace sdm |
| |
| #endif // __HWC_DISPLAY_H__ |