os/android/libhwcservice/hwcserviceapi.cpp

   1 /*
   2 // Copyright (c) 2017 Intel Corporation
   3 //
   4 // Licensed under the Apache License, Version 2.0 (the "License");
   5 // you may not use this file except in compliance with the License.
   6 // You may obtain a copy of the License at
   7 //
   8 //      http://www.apache.org/licenses/LICENSE-2.0
   9 //
  10 // Unless required by applicable law or agreed to in writing, software
  11 // distributed under the License is distributed on an "AS IS" BASIS,
  12 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13 // See the License for the specific language governing permissions and
  14 // limitations under the License.
  15 */
  16
  17 #include "hwcserviceapi.h"
  18
  19 #include "icontrols.h"
  20 #include "iservice.h"
  21
  22 #include <binder/IServiceManager.h>
  23 #include <binder/ProcessState.h>
  24
  25 #include <utils/RefBase.h>
  26 #include <utils/String8.h>
  27
  28 using namespace std;
  29 using namespace android;
  30
  31 using namespace hwcomposer;
  32
  33 extern "C" {
  34 struct HwcsContext {
  35   sp<IService> mHwcService;
  36   sp<IControls> mControls;
  37 };
  38
  39 HWCSHANDLE HwcService_Connect() {
  40   ProcessState::self()
  41       ->startThreadPool();  // Required for starting binder threads
  42
  43   HwcsContext context;
  44   context.mHwcService = interface_cast<IService>(
  45       defaultServiceManager()->getService(String16(IA_HWC_SERVICE_NAME)));
  46   if (context.mHwcService == NULL) {
  47     return NULL;
  48   }
  49
  50   context.mControls = context.mHwcService->GetControls();
  51   if (context.mControls == NULL) {
  52     return NULL;
  53   }
  54
  55   return new HwcsContext(context);
  56 }
  57
  58 void HwcService_Disconnect(HWCSHANDLE hwcs) {
  59   if (hwcs != NULL) {
  60     delete static_cast<HwcsContext*>(hwcs);
  61   }
  62 }
  63
  64 const char* HwcService_GetHwcVersion(HWCSHANDLE hwcs) {
  65   HwcsContext* pContext = static_cast<HwcsContext*>(hwcs);
  66   if (!pContext) {
  67     return NULL;
  68   }
  69
  70   static String8 version = pContext->mHwcService->GetHwcVersion();
  71   if (version.length() == 0) {
  72     return NULL;
  73   }
  74   return version;
  75 }
  76
  77 status_t HwcService_Display_SetOverscan(HWCSHANDLE hwcs, uint32_t display,
  78                                         int32_t xoverscan, int32_t yoverscan) {
  79   HwcsContext* pContext = static_cast<HwcsContext*>(hwcs);
  80   if (!pContext) {
  81     return android::BAD_VALUE;
  82   }
  83   return pContext->mControls->DisplaySetOverscan(display, xoverscan, yoverscan);
  84 }
  85
  86 status_t HwcService_Display_GetOverscan(HWCSHANDLE hwcs, uint32_t display,
  87                                         int32_t* xoverscan,
  88                                         int32_t* yoverscan) {
  89   HwcsContext* pContext = static_cast<HwcsContext*>(hwcs);
  90   if (!pContext) {
  91     return android::BAD_VALUE;
  92   }
  93   return pContext->mControls->DisplayGetOverscan(display, xoverscan, yoverscan);
  94 }
  95
  96 status_t HwcService_Display_SetScaling(HWCSHANDLE hwcs, uint32_t display,
  97                                        EHwcsScalingMode eScalingMode) {
  98   HwcsContext* pContext = static_cast<HwcsContext*>(hwcs);
  99   if (!pContext) {
 100     return android::BAD_VALUE;
 101   }
 102   return pContext->mControls->DisplaySetScaling(display, eScalingMode);
 103 }
 104
 105 status_t HwcService_Display_GetScaling(HWCSHANDLE hwcs, uint32_t display,
 106                                        EHwcsScalingMode* eScalingMode) {
 107   HwcsContext* pContext = static_cast<HwcsContext*>(hwcs);
 108   if (!pContext) {
 109     return android::BAD_VALUE;
 110   }
 111   return pContext->mControls->DisplayGetScaling(display, eScalingMode);
 112 }
 113
 114 status_t HwcService_Display_EnableBlank(HWCSHANDLE hwcs, uint32_t display,
 115                                         EHwcsBool blank) {
 116   HwcsContext* pContext = static_cast<HwcsContext*>(hwcs);
 117   if (!pContext) {
 118     return android::BAD_VALUE;
 119   }
 120   return pContext->mControls->DisplayEnableBlank(display, blank);
 121 }
 122
 123 status_t HwcService_Display_RestoreDefaultColorParam(HWCSHANDLE hwcs,
 124                                                      uint32_t display,
 125                                                      EHwcsColorControl color) {
 126   HwcsContext* pContext = static_cast<HwcsContext*>(hwcs);
 127   if (!pContext) {
 128     return android::BAD_VALUE;
 129   }
 130   return pContext->mControls->DisplayRestoreDefaultColorParam(display, color);
 131 }
 132
 133 status_t HwcService_Display_RestoreDefaultDeinterlaceParam(HWCSHANDLE hwcs,
 134                                                            uint32_t display) {
 135   HwcsContext* pContext = static_cast<HwcsContext*>(hwcs);
 136   if (!pContext) {
 137     return android::BAD_VALUE;
 138   }
 139   return pContext->mControls->DisplayRestoreDefaultDeinterlaceParam(display);
 140 }
 141
 142 status_t HwcService_Display_GetColorParam(HWCSHANDLE hwcs, uint32_t display,
 143                                           EHwcsColorControl color, float* value,
 144                                           float* startvalue, float* endvalue) {
 145   HwcsContext* pContext = static_cast<HwcsContext*>(hwcs);
 146   if (!pContext) {
 147     return android::BAD_VALUE;
 148   }
 149   return pContext->mControls->DisplayGetColorParam(display, color, value,
 150                                                    startvalue, endvalue);
 151 }
 152
 153 status_t HwcService_Display_SetColorParam(HWCSHANDLE hwcs, uint32_t display,
 154                                           EHwcsColorControl color,
 155                                           float value) {
 156   HwcsContext* pContext = static_cast<HwcsContext*>(hwcs);
 157   if (!pContext) {
 158     return android::BAD_VALUE;
 159   }
 160   return pContext->mControls->DisplaySetColorParam(display, color, value);
 161 }
 162
 163 status_t HwcService_Display_SetDeinterlaceParam(HWCSHANDLE hwcs,
 164                                                 uint32_t display,
 165                                                 uint32_t mode) {
 166   EHwcsDeinterlaceControl de_mode;
 167
 168   switch (mode) {
 169     case 0:
 170       de_mode = HWCS_DEINTERLACE_NONE;
 171       break;
 172     case 1:
 173       de_mode = HWCS_DEINTERLACE_BOB;
 174       break;
 175     case 2:
 176       de_mode = HWCS_DEINTERLACE_WEAVE;
 177       break;
 178     case 3:
 179       de_mode = HWCS_DEINTERLACE_MOTIONADAPTIVE;
 180       break;
 181     case 4:
 182       de_mode = HWCS_DEINTERLACE_MOTIONCOMPENSATED;
 183       break;
 184     default:
 185       de_mode = HWCS_DEINTERLACE_NONE;
 186       break;
 187   }
 188   HwcsContext* pContext = static_cast<HwcsContext*>(hwcs);
 189   if (!pContext) {
 190     return android::BAD_VALUE;
 191   }
 192   return pContext->mControls->DisplaySetDeinterlaceParam(display, de_mode);
 193 }
 194
 195 status_t HwcService_DisplayMode_GetAvailableModes(
 196     HWCSHANDLE hwcs, uint32_t display,
 197     std::vector<HwcsDisplayModeInfo>& pModeList) {
 198   HwcsContext* pContext = static_cast<HwcsContext*>(hwcs);
 199   if (!pContext) {
 200     return android::BAD_VALUE;
 201   }
 202   pModeList = pContext->mControls->DisplayModeGetAvailableModes(display);
 203   return OK;
 204 }
 205
 206 status_t HwcService_DisplayMode_GetMode(HWCSHANDLE hwcs, uint32_t display,
 207                                         HwcsDisplayModeInfo* pMode) {
 208   HwcsContext* pContext = static_cast<HwcsContext*>(hwcs);
 209   if (!pContext) {
 210     return android::BAD_VALUE;
 211   }
 212   return pContext->mControls->DisplayModeGetMode(display, pMode);
 213 }
 214
 215 status_t HwcService_DisplayMode_SetMode(HWCSHANDLE hwcs, uint32_t display,
 216                                         const uint32_t config) {
 217   HwcsContext* pContext = static_cast<HwcsContext*>(hwcs);
 218   if (!pContext) {
 219     return android::BAD_VALUE;
 220   }
 221   return pContext->mControls->DisplayModeSetMode(display, config);
 222 }
 223
 224 status_t HwcService_Video_EnableHDCPSession_ForDisplay(
 225     HWCSHANDLE hwcs, uint32_t connector, EHwcsContentType content_type) {
 226   HwcsContext* pContext = static_cast<HwcsContext*>(hwcs);
 227   if (!pContext) {
 228     return android::BAD_VALUE;
 229   }
 230
 231   return pContext->mControls->EnableHDCPSessionForDisplay(connector,
 232                                                           content_type);
 233 }
 234
 235 status_t HwcService_Video_EnableHDCPSession_AllDisplays(
 236     HWCSHANDLE hwcs, EHwcsContentType content_type) {
 237   HwcsContext* pContext = static_cast<HwcsContext*>(hwcs);
 238   if (!pContext) {
 239     return android::BAD_VALUE;
 240   }
 241
 242   return pContext->mControls->EnableHDCPSessionForAllDisplays(content_type);
 243 }
 244
 245 status_t HwcService_Video_SetHDCPSRM_AllDisplays(HWCSHANDLE hwcs,
 246                                                  const int8_t* SRM,
 247                                                  uint32_t SRMLength) {
 248   HwcsContext* pContext = static_cast<HwcsContext*>(hwcs);
 249   if (!pContext) {
 250     return android::BAD_VALUE;
 251   }
 252
 253   return pContext->mControls->SetHDCPSRMForAllDisplays(SRM, SRMLength);
 254 }
 255
 256 status_t HwcService_Video_SetHDCPSRM_ForDisplay(HWCSHANDLE hwcs,
 257                                                 uint32_t connector,
 258                                                 const int8_t* SRM,
 259                                                 uint32_t SRMLength) {
 260   HwcsContext* pContext = static_cast<HwcsContext*>(hwcs);
 261
 262   if (!pContext) {
 263     return android::BAD_VALUE;
 264   }
 265   return pContext->mControls->SetHDCPSRMForDisplay(connector, SRM, SRMLength);
 266 }
 267
 268 status_t HwcService_Video_DisableHDCPSession_ForDisplay(HWCSHANDLE hwcs,
 269                                                         uint32_t connector) {
 270   HwcsContext* pContext = static_cast<HwcsContext*>(hwcs);
 271   if (!pContext) {
 272     return android::BAD_VALUE;
 273   }
 274
 275   return pContext->mControls->DisableHDCPSessionForDisplay(connector);
 276 }
 277
 278 uint32_t HwcService_GetDisplayIDFromConnectorID(HWCSHANDLE hwcs,
 279                                                 uint32_t connector_id) {
 280   HwcsContext* pContext = static_cast<HwcsContext*>(hwcs);
 281   if (!pContext) {
 282     return android::BAD_VALUE;
 283   }
 284
 285   return pContext->mControls->GetDisplayIDFromConnectorID(connector_id);
 286 }
 287
 288 status_t HwcService_EnableDRMCommit(HWCSHANDLE hwcs, uint32_t enable,
 289                                     uint32_t display_id) {
 290   HwcsContext* pContext = static_cast<HwcsContext*>(hwcs);
 291   if (!pContext) {
 292     return android::BAD_VALUE;
 293   }
 294
 295   return pContext->mControls->EnableDRMCommit(enable, display_id);
 296 }
 297
 298 status_t HwcService_Video_DisableHDCPSession_AllDisplays(HWCSHANDLE hwcs) {
 299   HwcsContext* pContext = static_cast<HwcsContext*>(hwcs);
 300   if (!pContext) {
 301     return android::BAD_VALUE;
 302   }
 303
 304   return pContext->mControls->DisableHDCPSessionForAllDisplays();
 305 }
 306
 307 status_t HwcService_Video_EnableEncryptedSession(HWCSHANDLE hwcs,
 308                                                  uint32_t sessionID,
 309                                                  uint32_t instanceID) {
 310   HwcsContext* pContext = static_cast<HwcsContext*>(hwcs);
 311   if (!pContext) {
 312     return android::BAD_VALUE;
 313   }
 314   return pContext->mControls->VideoEnableEncryptedSession(sessionID,
 315                                                           instanceID);
 316 }
 317
 318 status_t HwcService_Video_DisableEncryptedSession(HWCSHANDLE hwcs,
 319                                                   uint32_t sessionID) {
 320   HwcsContext* pContext = static_cast<HwcsContext*>(hwcs);
 321   if (!pContext) {
 322     return android::BAD_VALUE;
 323   }
 324   return pContext->mControls->VideoDisableAllEncryptedSessions(sessionID);
 325 }
 326
 327 status_t HwcService_Video_DisableAllEncryptedSessions(HWCSHANDLE hwcs) {
 328   HwcsContext* pContext = static_cast<HwcsContext*>(hwcs);
 329   if (!pContext) {
 330     return android::BAD_VALUE;
 331   }
 332   return pContext->mControls->VideoDisableAllEncryptedSessions();
 333 }
 334
 335 EHwcsBool HwcService_Video_IsEncryptedSessionEnabled(HWCSHANDLE hwcs,
 336                                                      uint32_t sessionID,
 337                                                      uint32_t instanceID) {
 338   HwcsContext* pContext = static_cast<HwcsContext*>(hwcs);
 339   if (!pContext) {
 340     return HWCS_FALSE;
 341   }
 342   return pContext->mControls->VideoIsEncryptedSessionEnabled(sessionID,
 343                                                              instanceID)
 344              ? HWCS_TRUE
 345              : HWCS_FALSE;
 346 }
 347
 348 status_t HwcService_Video_SetOptimizationMode(HWCSHANDLE hwcs,
 349                                               EHwcsOptimizationMode mode) {
 350   HwcsContext* pContext = static_cast<HwcsContext*>(hwcs);
 351   if (!pContext) {
 352     return android::BAD_VALUE;
 353   }
 354   return pContext->mControls->VideoSetOptimizationMode(mode);
 355 }
 356
 357 status_t HwcService_MDS_UpdateVideoState(HWCSHANDLE hwcs,
 358                                          int64_t videoSessionID,
 359                                          EHwcsBool isPrepared) {
 360   HwcsContext* pContext = static_cast<HwcsContext*>(hwcs);
 361   if (!pContext) {
 362     return android::BAD_VALUE;
 363   }
 364   return pContext->mControls->MdsUpdateVideoState(videoSessionID, isPrepared);
 365 }
 366
 367 status_t HwcService_MDS_UpdateVideoFPS(HWCSHANDLE hwcs, int64_t videoSessionID,
 368                                        int32_t fps) {
 369   HwcsContext* pContext = static_cast<HwcsContext*>(hwcs);
 370   if (!pContext) {
 371     return android::BAD_VALUE;
 372   }
 373   return pContext->mControls->MdsUpdateVideoFPS(videoSessionID, fps);
 374 }
 375
 376 status_t HwcService_MDS_UpdateInputState(HWCSHANDLE hwcs, EHwcsBool state) {
 377   HwcsContext* pContext = static_cast<HwcsContext*>(hwcs);
 378   if (!pContext) {
 379     return android::BAD_VALUE;
 380   }
 381   return pContext->mControls->MdsUpdateInputState(state);
 382 }
 383
 384 status_t HwcService_Widi_GetSingleDisplay(HWCSHANDLE hwcs, EHwcsBool* enable) {
 385   HwcsContext* pContext = static_cast<HwcsContext*>(hwcs);
 386   if (!pContext) {
 387     return android::BAD_VALUE;
 388   }
 389   if (!enable) {
 390     return android::BAD_VALUE;
 391   }
 392   bool bEnabled = false;
 393   status_t ret = pContext->mControls->WidiGetSingleDisplay(&bEnabled);
 394   *enable = bEnabled ? HWCS_TRUE : HWCS_FALSE;
 395   return ret;
 396 }
 397
 398 status_t HwcService_Widi_SetSingleDisplay(HWCSHANDLE hwcs, EHwcsBool enable) {
 399   HwcsContext* pContext = static_cast<HwcsContext*>(hwcs);
 400   if (!pContext) {
 401     return android::BAD_VALUE;
 402   }
 403   return pContext->mControls->WidiSetSingleDisplay(enable);
 404 }
 405 }