src/add-ons/accelerants/via/GetAccelerantHook.c

   1 /*
   2         Copyright 1999, Be Incorporated.   All Rights Reserved.
   3         This file may be used under the terms of the Be Sample Code License.
   4
   5         Other authors:
   6         Mark Watson,
   7         Rudolf Cornelissen 10/2002-1/2016
   8 */
   9
  10 #define MODULE_BIT 0x08000000
  11
  12 #include "acc_std.h"
  13
  14 /*
  15 The standard entry point.  Given a uint32 feature identifier, this routine
  16 returns a pointer to the function that implements the feature.  Some features
  17 require more information than just the identifier to select the proper
  18 function.  The extra information (which is specific to the feature) is
  19 pointed at by the void *data parameter.  By default, no extra information
  20 is available.  Any extra information available to choose the function will be
  21 noted on a case by case below.
  22 */
  23
  24 /*
  25 These definitions are out of pure lazyness.
  26 */
  27 #define CHKO(x) case B_##x: \
  28         if (check_overlay_capability(B_##x) == B_OK) return (void *)x; else return (void *)0
  29 #define CHKA(x) case B_##x: \
  30         if (check_acc_capability(B_##x) == B_OK) return (void *)x; else return (void *)0
  31 #define HOOK(x) case B_##x: return (void *)x
  32 #define ZERO(x) case B_##x: return (void *)0
  33 #define HRDC(x) case B_##x: return si->settings.hardcursor? (void *)x: (void *)0; // apsed
  34
  35 void *  get_accelerant_hook(uint32 feature, void *data)
  36 {
  37         switch (feature)
  38         {
  39                 /*
  40                 One of either B_INIT_ACCELERANT or B_CLONE_ACCELERANT will be requested and
  41                 subsequently called before any other hook is requested.  All other feature
  42                 hook selections can be predicated on variables assigned during the accelerant
  43                 initialization process.
  44                 */
  45
  46                 /* initialization */
  47                 HOOK(INIT_ACCELERANT);
  48                 HOOK(CLONE_ACCELERANT);
  49
  50                 HOOK(ACCELERANT_CLONE_INFO_SIZE);
  51                 HOOK(GET_ACCELERANT_CLONE_INFO);
  52                 HOOK(UNINIT_ACCELERANT);
  53                 HOOK(GET_ACCELERANT_DEVICE_INFO);
  54                 HOOK(ACCELERANT_RETRACE_SEMAPHORE);
  55
  56                 /* mode configuration */
  57                 HOOK(ACCELERANT_MODE_COUNT);
  58                 HOOK(GET_MODE_LIST);
  59                 HOOK(PROPOSE_DISPLAY_MODE);
  60                 HOOK(SET_DISPLAY_MODE);
  61                 HOOK(GET_DISPLAY_MODE);
  62                 HOOK(GET_FRAME_BUFFER_CONFIG);
  63                 HOOK(GET_PIXEL_CLOCK_LIMITS);
  64                 HOOK(MOVE_DISPLAY);
  65                 HOOK(SET_INDEXED_COLORS);
  66                 HOOK(GET_TIMING_CONSTRAINTS);
  67
  68                 HOOK(DPMS_CAPABILITIES);
  69                 HOOK(DPMS_MODE);
  70                 HOOK(SET_DPMS_MODE);
  71
  72                 /* cursor managment */
  73                 HRDC(SET_CURSOR_SHAPE);
  74                 HRDC(MOVE_CURSOR);
  75                 HRDC(SHOW_CURSOR);
  76
  77                 /* synchronization */
  78                 HOOK(ACCELERANT_ENGINE_COUNT);
  79                 HOOK(ACQUIRE_ENGINE);
  80                 HOOK(RELEASE_ENGINE);
  81                 HOOK(WAIT_ENGINE_IDLE);
  82                 HOOK(GET_SYNC_TOKEN);
  83                 HOOK(SYNC_TO_TOKEN);
  84
  85                 /*
  86                 Depending on the engine architecture, you may choose to provide a different
  87                 function to be used with each bit-depth for example.
  88
  89                 Note: These hooks are re-acquired by the app_server after each mode switch.
  90                 */
  91
  92                 /* only export video overlay functions if card is capable of it */
  93                 CHKO(OVERLAY_COUNT);
  94                 CHKO(OVERLAY_SUPPORTED_SPACES);
  95                 CHKO(OVERLAY_SUPPORTED_FEATURES);
  96                 CHKO(ALLOCATE_OVERLAY_BUFFER);
  97                 CHKO(RELEASE_OVERLAY_BUFFER);
  98                 CHKO(GET_OVERLAY_CONSTRAINTS);
  99                 CHKO(ALLOCATE_OVERLAY);
 100                 CHKO(RELEASE_OVERLAY);
 101                 CHKO(CONFIGURE_OVERLAY);
 102
 103                 /*
 104                 When requesting an acceleration hook, the calling application provides a
 105                 pointer to the display_mode for which the acceleration function will be used.
 106                 Depending on the engine architecture, you may choose to provide a different
 107                 function to be used with each bit-depth.  In the sample driver we return
 108                 the same function all the time.
 109
 110                 Note: These hooks are re-acquired by the app_server after each mode switch.
 111                 */
 112
 113                 /* only export 2D acceleration functions in modes that are capable of it */
 114                 /* used by the app_server and applications (BWindowScreen) */
 115                 CHKA(SCREEN_TO_SCREEN_BLIT);
 116                 CHKA(FILL_RECTANGLE);
 117                 CHKA(INVERT_RECTANGLE);
 118                 CHKA(FILL_SPAN);
 119                 /* not (yet) used by the app_server:
 120                  * so just for application use (BWindowScreen) */
 121 //              CHKA(SCREEN_TO_SCREEN_TRANSPARENT_BLIT);
 122 //              CHKA(SCREEN_TO_SCREEN_SCALED_FILTERED_BLIT;
 123         }
 124
 125         /* Return a null pointer for any feature we don't understand. */
 126         return 0;
 127 }
 128 #undef CHKO
 129 #undef CHKA
 130 #undef HOOK
 131 #undef ZERO
 132 #undef HRDC
 133
 134 status_t check_overlay_capability(uint32 feature)
 135 {
 136         char *msg = "";
 137
 138         /* setup logmessage text */
 139         switch (feature)
 140         {
 141         case B_OVERLAY_COUNT:
 142                 msg = "B_OVERLAY_COUNT";
 143                 break;
 144         case B_OVERLAY_SUPPORTED_SPACES:
 145                 msg = "B_OVERLAY_SUPPORTED_SPACES";
 146                 break;
 147         case B_OVERLAY_SUPPORTED_FEATURES:
 148                 msg = "B_OVERLAY_SUPPORTED_FEATURES";
 149                 break;
 150         case B_ALLOCATE_OVERLAY_BUFFER:
 151                 msg = "B_ALLOCATE_OVERLAY_BUFFER";
 152                 break;
 153         case B_RELEASE_OVERLAY_BUFFER:
 154                 msg = "B_RELEASE_OVERLAY_BUFFER";
 155                 break;
 156         case B_GET_OVERLAY_CONSTRAINTS:
 157                 msg = "B_GET_OVERLAY_CONSTRAINTS";
 158                 break;
 159         case B_ALLOCATE_OVERLAY:
 160                 msg = "B_ALLOCATE_OVERLAY";
 161                 break;
 162         case B_RELEASE_OVERLAY:
 163                 msg = "B_RELEASE_OVERLAY";
 164                 break;
 165         case B_CONFIGURE_OVERLAY:
 166                 msg = "B_CONFIGURE_OVERLAY";
 167                 break;
 168         default:
 169                 msg = "UNKNOWN";
 170                 break;
 171         }
 172
 173         /* all supported cards have a bes, but it can't always be used... */
 174         if (eng_bes_chk_bandwidth()) {
 175                 LOG(4, ("Overlay: Exporting hook %s.\n", msg));
 176                 return B_OK;
 177         }
 178
 179         LOG(4, ("Overlay: Not exporting hook %s.\n", msg));
 180         return B_ERROR;
 181 }
 182
 183 status_t check_acc_capability(uint32 feature)
 184 {
 185         char *msg = "";
 186
 187         /* setup logmessage text */
 188         switch (feature)
 189         {
 190         case B_SCREEN_TO_SCREEN_BLIT:
 191                 msg = "B_SCREEN_TO_SCREEN_BLIT";
 192                 break;
 193         case B_FILL_RECTANGLE:
 194                 msg = "B_FILL_RECTANGLE";
 195                 break;
 196         case B_INVERT_RECTANGLE:
 197                 msg = "B_INVERT_RECTANGLE";
 198                 break;
 199         case B_FILL_SPAN:
 200                 msg = "B_FILL_SPAN";
 201                 break;
 202         case B_SCREEN_TO_SCREEN_TRANSPARENT_BLIT:
 203                 msg = "B_SCREEN_TO_SCREEN_TRANSPARENT_BLIT";
 204                 break;
 205         case B_SCREEN_TO_SCREEN_SCALED_FILTERED_BLIT:
 206                 msg = "B_SCREEN_TO_SCREEN_SCALED_FILTERED_BLIT";
 207                 break;
 208         default:
 209                 msg = "UNKNOWN";
 210                 break;
 211         }
 212
 213         /* hardware acceleration is only supported in modes with upto a certain
 214          * memory pitch.. */
 215         if (si->acc_mode)
 216         {
 217                 LOG(4, ("Acc: Exporting hook %s.\n", msg));
 218                 return B_OK;
 219         }
 220         else
 221         {
 222                 LOG(4, ("Acc: Not exporting hook %s.\n", msg));
 223                 return B_ERROR;
 224         }
 225 }