video/video.c

   1 /*
   2  *  GRUB  --  GRand Unified Bootloader
   3  *  Copyright (C) 2006,2007,2008,2009  Free Software Foundation, Inc.
   4  *
   5  *  GRUB is free software: you can redistribute it and/or modify
   6  *  it under the terms of the GNU General Public License as published by
   7  *  the Free Software Foundation, either version 3 of the License, or
   8  *  (at your option) any later version.
   9  *
  10  *  GRUB is distributed in the hope that it will be useful,
  11  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  *  GNU General Public License for more details.
  14  *
  15  *  You should have received a copy of the GNU General Public License
  16  *  along with GRUB.  If not, see <http://www.gnu.org/licenses/>.
  17  */
  18
  19 #include <grub/video.h>
  20 #include <grub/types.h>
  21 #include <grub/dl.h>
  22 #include <grub/misc.h>
  23 #include <grub/mm.h>
  24
  25 /* The list of video adapters registered to system.  */
  26 static grub_video_adapter_t grub_video_adapter_list;
  27
  28 /* Active video adapter.  */
  29 static grub_video_adapter_t grub_video_adapter_active;
  30
  31 /* Register video driver.  */
  32 void
  33 grub_video_register (grub_video_adapter_t adapter)
  34 {
  35   adapter->next = grub_video_adapter_list;
  36   grub_video_adapter_list = adapter;
  37 }
  38
  39 /* Unregister video driver.  */
  40 void
  41 grub_video_unregister (grub_video_adapter_t adapter)
  42 {
  43   grub_video_adapter_t *p, q;
  44
  45   for (p = &grub_video_adapter_list, q = *p; q; p = &(q->next), q = q->next)
  46     if (q == adapter)
  47       {
  48         *p = q->next;
  49         break;
  50       }
  51 }
  52
  53 /* Iterate thru all registered video drivers.  */
  54 void
  55 grub_video_iterate (int (*hook) (grub_video_adapter_t adapter))
  56 {
  57   grub_video_adapter_t p;
  58
  59   for (p = grub_video_adapter_list; p; p = p->next)
  60     if (hook (p))
  61       break;
  62 }
  63
  64 /* Restore back to initial mode (where applicable).  */
  65 grub_err_t
  66 grub_video_restore (void)
  67 {
  68   if (grub_video_adapter_active)
  69     {
  70       grub_video_adapter_active->fini ();
  71       if (grub_errno != GRUB_ERR_NONE)
  72         return grub_errno;
  73
  74       grub_video_adapter_active = 0;
  75     }
  76   return GRUB_ERR_NONE;
  77 }
  78
  79 /* Get information about active video mode.  */
  80 grub_err_t
  81 grub_video_get_info (struct grub_video_mode_info *mode_info)
  82 {
  83   if (! grub_video_adapter_active)
  84     return grub_error (GRUB_ERR_BAD_DEVICE, "No video mode activated");
  85
  86   /* If mode_info is NULL just report that video adapter is active.  */
  87   if (! mode_info)
  88     {
  89       grub_errno = GRUB_ERR_NONE;
  90       return grub_errno;
  91     }
  92
  93   return grub_video_adapter_active->get_info (mode_info);
  94 }
  95
  96 /* Get information about active video mode.  */
  97 grub_err_t
  98 grub_video_get_info_and_fini (struct grub_video_mode_info *mode_info,
  99                               void **framebuffer)
 100 {
 101   grub_err_t err;
 102
 103   if (! grub_video_adapter_active)
 104     return grub_error (GRUB_ERR_BAD_DEVICE, "No video mode activated");
 105
 106   err = grub_video_adapter_active->get_info_and_fini (mode_info, framebuffer);
 107   if (err)
 108     return err;
 109
 110   grub_video_adapter_active = 0;
 111   return GRUB_ERR_NONE;
 112 }
 113
 114 /* Determine optimized blitting formation for specified video mode info.  */
 115 enum grub_video_blit_format
 116 grub_video_get_blit_format (struct grub_video_mode_info *mode_info)
 117 {
 118   /* Check if we have any known 32 bit modes.  */
 119   if (mode_info->bpp == 32)
 120     {
 121       if ((mode_info->red_mask_size == 8)
 122           && (mode_info->red_field_pos == 16)
 123           && (mode_info->green_mask_size == 8)
 124           && (mode_info->green_field_pos == 8)
 125           && (mode_info->blue_mask_size == 8)
 126           && (mode_info->blue_field_pos == 0))
 127         {
 128           return GRUB_VIDEO_BLIT_FORMAT_BGRA_8888;
 129         }
 130       else if ((mode_info->red_mask_size == 8)
 131                && (mode_info->red_field_pos == 0)
 132                && (mode_info->green_mask_size == 8)
 133                && (mode_info->green_field_pos == 8)
 134                && (mode_info->blue_mask_size == 8)
 135                && (mode_info->blue_field_pos == 16))
 136         {
 137           return GRUB_VIDEO_BLIT_FORMAT_RGBA_8888;
 138         }
 139     }
 140   /* Check if we have any known 24 bit modes.  */
 141   else if (mode_info->bpp == 24)
 142     {
 143       if ((mode_info->red_mask_size == 8)
 144           && (mode_info->red_field_pos == 16)
 145           && (mode_info->green_mask_size == 8)
 146           && (mode_info->green_field_pos == 8)
 147           && (mode_info->blue_mask_size == 8)
 148           && (mode_info->blue_field_pos == 0))
 149         {
 150           return GRUB_VIDEO_BLIT_FORMAT_BGR_888;
 151         }
 152       else if ((mode_info->red_mask_size == 8)
 153                && (mode_info->red_field_pos == 0)
 154                && (mode_info->green_mask_size == 8)
 155                && (mode_info->green_field_pos == 8)
 156                && (mode_info->blue_mask_size == 8)
 157                && (mode_info->blue_field_pos == 16))
 158         {
 159           return GRUB_VIDEO_BLIT_FORMAT_RGB_888;
 160         }
 161     }
 162   /* Check if we have any known 16 bit modes.  */
 163   else if (mode_info->bpp == 16)
 164     {
 165       if ((mode_info->red_mask_size == 5)
 166           && (mode_info->red_field_pos == 11)
 167           && (mode_info->green_mask_size == 6)
 168           && (mode_info->green_field_pos == 5)
 169           && (mode_info->blue_mask_size == 5)
 170           && (mode_info->blue_field_pos == 0))
 171         {
 172           return GRUB_VIDEO_BLIT_FORMAT_BGR_565;
 173         }
 174       else if ((mode_info->red_mask_size == 5)
 175                && (mode_info->red_field_pos == 0)
 176                && (mode_info->green_mask_size == 6)
 177                && (mode_info->green_field_pos == 5)
 178                && (mode_info->blue_mask_size == 5)
 179                && (mode_info->blue_field_pos == 11))
 180         {
 181           return GRUB_VIDEO_BLIT_FORMAT_RGB_565;
 182         }
 183     }
 184
 185   /* Backup route.  Unknown format.  */
 186
 187   /* If there are more than 8 bits per color, assume RGB(A) mode.  */
 188   if (mode_info->bpp > 8)
 189     {
 190       if (mode_info->reserved_mask_size > 0)
 191         {
 192           return GRUB_VIDEO_BLIT_FORMAT_RGBA;
 193         }
 194       else
 195         {
 196           return GRUB_VIDEO_BLIT_FORMAT_RGB;
 197         }
 198     }
 199
 200   /* Assume as indexcolor mode.  */
 201   return GRUB_VIDEO_BLIT_FORMAT_INDEXCOLOR;
 202 }
 203
 204 /* Set new indexed color palette entries.  */
 205 grub_err_t
 206 grub_video_set_palette (unsigned int start, unsigned int count,
 207                         struct grub_video_palette_data *palette_data)
 208 {
 209   if (! grub_video_adapter_active)
 210     return grub_error (GRUB_ERR_BAD_DEVICE, "No video mode activated");
 211
 212   return grub_video_adapter_active->set_palette (start, count, palette_data);
 213 }
 214
 215 /* Get indexed color palette entries.  */
 216 grub_err_t
 217 grub_video_get_palette (unsigned int start, unsigned int count,
 218                         struct grub_video_palette_data *palette_data)
 219 {
 220   if (! grub_video_adapter_active)
 221     return grub_error (GRUB_ERR_BAD_DEVICE, "No video mode activated");
 222
 223   return grub_video_adapter_active->get_palette (start, count, palette_data);
 224 }
 225
 226 /* Set viewport dimensions.  */
 227 grub_err_t
 228 grub_video_set_viewport (unsigned int x, unsigned int y,
 229                          unsigned int width, unsigned int height)
 230 {
 231   if (! grub_video_adapter_active)
 232     return grub_error (GRUB_ERR_BAD_DEVICE, "No video mode activated");
 233
 234   return grub_video_adapter_active->set_viewport (x, y, width, height);
 235 }
 236
 237 /* Get viewport dimensions.  */
 238 grub_err_t
 239 grub_video_get_viewport (unsigned int *x, unsigned int *y,
 240                          unsigned int *width, unsigned int *height)
 241 {
 242   if (! grub_video_adapter_active)
 243     return grub_error (GRUB_ERR_BAD_DEVICE, "No video mode activated");
 244
 245   return grub_video_adapter_active->get_viewport (x, y, width, height);
 246 }
 247
 248 /* Map color name to adapter specific color.  */
 249 grub_video_color_t
 250 grub_video_map_color (grub_uint32_t color_name)
 251 {
 252   if (! grub_video_adapter_active)
 253     return 0;
 254
 255   return grub_video_adapter_active->map_color (color_name);
 256 }
 257
 258 /* Map RGB value to adapter specific color.  */
 259 grub_video_color_t
 260 grub_video_map_rgb (grub_uint8_t red, grub_uint8_t green, grub_uint8_t blue)
 261 {
 262   if (! grub_video_adapter_active)
 263     return 0;
 264
 265   return grub_video_adapter_active->map_rgb (red, green, blue);
 266 }
 267
 268 /* Map RGBA value to adapter specific color.  */
 269 grub_video_color_t
 270 grub_video_map_rgba (grub_uint8_t red, grub_uint8_t green, grub_uint8_t blue,
 271                      grub_uint8_t alpha)
 272 {
 273   if (! grub_video_adapter_active)
 274     return 0;
 275
 276   return grub_video_adapter_active->map_rgba (red, green, blue, alpha);
 277 }
 278
 279 /* Unmap video color back to RGBA components.  */
 280 grub_err_t
 281 grub_video_unmap_color (grub_video_color_t color, grub_uint8_t *red,
 282                         grub_uint8_t *green, grub_uint8_t *blue,
 283                         grub_uint8_t *alpha)
 284 {
 285   if (! grub_video_adapter_active)
 286     return grub_error (GRUB_ERR_BAD_DEVICE, "No video mode activated");
 287
 288   return grub_video_adapter_active->unmap_color (color,
 289                                                  red,
 290                                                  green,
 291                                                  blue,
 292                                                  alpha);
 293 }
 294
 295 /* Fill rectangle using specified color.  */
 296 grub_err_t
 297 grub_video_fill_rect (grub_video_color_t color, int x, int y,
 298                       unsigned int width, unsigned int height)
 299 {
 300   if (! grub_video_adapter_active)
 301     return grub_error (GRUB_ERR_BAD_DEVICE, "No video mode activated");
 302
 303   return grub_video_adapter_active->fill_rect (color, x, y, width, height);
 304 }
 305
 306 /* Blit bitmap to screen.  */
 307 grub_err_t
 308 grub_video_blit_bitmap (struct grub_video_bitmap *bitmap,
 309                         enum grub_video_blit_operators oper,
 310                         int x, int y, int offset_x, int offset_y,
 311                         unsigned int width, unsigned int height)
 312 {
 313   if (! grub_video_adapter_active)
 314     return grub_error (GRUB_ERR_BAD_DEVICE, "No video mode activated");
 315
 316   return grub_video_adapter_active->blit_bitmap (bitmap, oper, x, y,
 317                                                  offset_x, offset_y,
 318                                                  width, height);
 319 }
 320
 321 /* Blit render target to active render target.  */
 322 grub_err_t
 323 grub_video_blit_render_target (struct grub_video_render_target *target,
 324                                enum grub_video_blit_operators oper,
 325                                int x, int y, int offset_x, int offset_y,
 326                                unsigned int width, unsigned int height)
 327 {
 328   if (! grub_video_adapter_active)
 329     return grub_error (GRUB_ERR_BAD_DEVICE, "No video mode activated");
 330
 331   return grub_video_adapter_active->blit_render_target (target, oper, x, y,
 332                                                         offset_x, offset_y,
 333                                                         width, height);
 334 }
 335
 336 /* Scroll viewport and fill new areas with specified color.  */
 337 grub_err_t
 338 grub_video_scroll (grub_video_color_t color, int dx, int dy)
 339 {
 340   if (! grub_video_adapter_active)
 341     return grub_error (GRUB_ERR_BAD_DEVICE, "No video mode activated");
 342
 343   return grub_video_adapter_active->scroll (color, dx, dy);
 344 }
 345
 346 /* Swap buffers (swap active render target).  */
 347 grub_err_t
 348 grub_video_swap_buffers (void)
 349 {
 350   if (! grub_video_adapter_active)
 351     return grub_error (GRUB_ERR_BAD_DEVICE, "No video mode activated");
 352
 353   return grub_video_adapter_active->swap_buffers ();
 354 }
 355
 356 /* Create new render target.  */
 357 grub_err_t
 358 grub_video_create_render_target (struct grub_video_render_target **result,
 359                                  unsigned int width, unsigned int height,
 360                                  unsigned int mode_type)
 361 {
 362   if (! grub_video_adapter_active)
 363     return grub_error (GRUB_ERR_BAD_DEVICE, "No video mode activated");
 364
 365   return grub_video_adapter_active->create_render_target (result,
 366                                                           width, height,
 367                                                           mode_type);
 368 }
 369
 370 /* Delete render target.  */
 371 grub_err_t
 372 grub_video_delete_render_target (struct grub_video_render_target *target)
 373 {
 374   if (! grub_video_adapter_active)
 375     return grub_error (GRUB_ERR_BAD_DEVICE, "No video mode activated");
 376
 377   return grub_video_adapter_active->delete_render_target (target);
 378 }
 379
 380 /* Set active render target.  */
 381 grub_err_t
 382 grub_video_set_active_render_target (struct grub_video_render_target *target)
 383 {
 384   if (! grub_video_adapter_active)
 385     return grub_error (GRUB_ERR_BAD_DEVICE, "No video mode activated");
 386
 387   return grub_video_adapter_active->set_active_render_target (target);
 388 }
 389
 390 /* Get active render target.  */
 391 grub_err_t
 392 grub_video_get_active_render_target (struct grub_video_render_target **target)
 393 {
 394   if (! grub_video_adapter_active)
 395     return grub_error (GRUB_ERR_BAD_DEVICE, "No video mode activated");
 396
 397   return grub_video_adapter_active->get_active_render_target (target);
 398 }
 399
 400 grub_err_t
 401 grub_video_set_mode (const char *modestring,
 402                      int NESTED_FUNC_ATTR (*hook) (grub_video_adapter_t p,
 403                                                    struct grub_video_mode_info *mode_info))
 404 {
 405   char *tmp;
 406   char *next_mode;
 407   char *current_mode;
 408   char *param;
 409   char *value;
 410   char *modevar;
 411   int width = -1;
 412   int height = -1;
 413   int depth = -1;
 414   int flags = 0;
 415
 416   /* Take copy of env.var. as we don't want to modify that.  */
 417   modevar = grub_strdup (modestring);
 418
 419   /* Initialize next mode.  */
 420   next_mode = modevar;
 421
 422   if (! modevar)
 423     return grub_error (GRUB_ERR_OUT_OF_MEMORY,
 424                        "couldn't allocate space for local modevar copy");
 425
 426   if (grub_memcmp (next_mode, "keep", sizeof ("keep")) == 0
 427       || grub_memcmp (next_mode, "keep,", sizeof ("keep,") - 1) == 0
 428       || grub_memcmp (next_mode, "keep;", sizeof ("keep;") - 1) == 0)
 429     {
 430       struct grub_video_mode_info mode_info;
 431       int suitable = 1;
 432       grub_err_t err;
 433
 434       grub_memset (&mode_info, 0, sizeof (mode_info));
 435
 436       if (grub_video_adapter_active)
 437         {
 438           err = grub_video_get_info (&mode_info);
 439           if (err)
 440             {
 441               suitable = 0;
 442               grub_errno = GRUB_ERR_NONE;
 443             }
 444         }
 445       else
 446         mode_info.mode_type = GRUB_VIDEO_MODE_TYPE_PURE_TEXT;
 447
 448       if (suitable && hook)
 449         suitable = hook (grub_video_adapter_active, &mode_info);
 450       if (suitable)
 451         {
 452           grub_free (modevar);
 453           return GRUB_ERR_NONE;
 454         }
 455       next_mode += sizeof ("keep") - 1;
 456       if (! *next_mode)
 457         {
 458           grub_free (modevar);
 459
 460           return grub_error (GRUB_ERR_BAD_ARGUMENT,
 461                              "No suitable mode found.");
 462         }
 463
 464       /* Skip separator. */
 465       next_mode++;
 466     }
 467
 468   /* De-activate last set video adapter.  */
 469   if (grub_video_adapter_active)
 470     {
 471       /* Finalize adapter.  */
 472       grub_video_adapter_active->fini ();
 473       if (grub_errno != GRUB_ERR_NONE)
 474         grub_errno = GRUB_ERR_NONE;
 475
 476       /* Mark active adapter as not set.  */
 477       grub_video_adapter_active = 0;
 478     }
 479
 480   /* Loop until all modes has been tested out.  */
 481   while (next_mode != NULL)
 482     {
 483       /* Use last next_mode as current mode.  */
 484       tmp = next_mode;
 485
 486       /* Reset video mode settings.  */
 487       width = -1;
 488       height = -1;
 489       depth = -1;
 490       flags = 0;
 491
 492       /* Save position of next mode and separate modes.  */
 493       for (; *next_mode; next_mode++)
 494         if (*next_mode == ',' || *next_mode == ';')
 495           break;
 496       if (*next_mode)
 497         {
 498           *next_mode = 0;
 499           next_mode++;
 500         }
 501       else
 502         next_mode = 0;
 503
 504       /* Skip whitespace.  */
 505       while (grub_isspace (*tmp))
 506         tmp++;
 507
 508       /* Initialize token holders.  */
 509       current_mode = tmp;
 510       param = tmp;
 511       value = NULL;
 512
 513       /* XXX: we assume that we're in pure text mode if
 514          no video mode is initialized. Is it always true? */
 515       if (grub_strcmp (param, "text") == 0)
 516         {
 517           struct grub_video_mode_info mode_info;
 518
 519           grub_memset (&mode_info, 0, sizeof (mode_info));
 520           mode_info.mode_type = GRUB_VIDEO_MODE_TYPE_PURE_TEXT;
 521
 522           if (! hook || hook (0, &mode_info))
 523             {
 524               /* Valid mode found from adapter, and it has been activated.
 525                  Specify it as active adapter.  */
 526               grub_video_adapter_active = NULL;
 527
 528               /* Free memory.  */
 529               grub_free (modevar);
 530
 531               return GRUB_ERR_NONE;
 532             }
 533         }
 534
 535       /* Parse <width>x<height>[x<depth>]*/
 536
 537       /* Find width value.  */
 538       value = param;
 539       param = grub_strchr(param, 'x');
 540       if (param == NULL)
 541         {
 542           grub_err_t rc;
 543
 544           /* First setup error message.  */
 545           rc = grub_error (GRUB_ERR_BAD_ARGUMENT,
 546                            "Invalid mode: %s\n",
 547                            current_mode);
 548
 549           /* Free memory before returning.  */
 550           grub_free (modevar);
 551
 552           return rc;
 553         }
 554
 555       *param = 0;
 556       param++;
 557
 558       width = grub_strtoul (value, 0, 0);
 559       if (grub_errno != GRUB_ERR_NONE)
 560         {
 561           grub_err_t rc;
 562
 563           /* First setup error message.  */
 564           rc = grub_error (GRUB_ERR_BAD_ARGUMENT,
 565                            "Invalid mode: %s\n",
 566                            current_mode);
 567
 568           /* Free memory before returning.  */
 569           grub_free (modevar);
 570
 571           return rc;
 572         }
 573
 574       /* Find height value.  */
 575       value = param;
 576       param = grub_strchr(param, 'x');
 577       if (param == NULL)
 578         {
 579           height = grub_strtoul (value, 0, 0);
 580           if (grub_errno != GRUB_ERR_NONE)
 581             {
 582               grub_err_t rc;
 583
 584               /* First setup error message.  */
 585               rc = grub_error (GRUB_ERR_BAD_ARGUMENT,
 586                                "Invalid mode: %s\n",
 587                                current_mode);
 588
 589               /* Free memory before returning.  */
 590               grub_free (modevar);
 591
 592               return rc;
 593             }
 594         }
 595       else
 596         {
 597           /* We have optional color depth value.  */
 598           *param = 0;
 599           param++;
 600
 601           height = grub_strtoul (value, 0, 0);
 602           if (grub_errno != GRUB_ERR_NONE)
 603             {
 604               grub_err_t rc;
 605
 606               /* First setup error message.  */
 607               rc = grub_error (GRUB_ERR_BAD_ARGUMENT,
 608                                "Invalid mode: %s\n",
 609                                current_mode);
 610
 611               /* Free memory before returning.  */
 612               grub_free (modevar);
 613
 614               return rc;
 615             }
 616
 617           /* Convert color depth value.  */
 618           value = param;
 619           depth = grub_strtoul (value, 0, 0);
 620           if (grub_errno != GRUB_ERR_NONE)
 621             {
 622               grub_err_t rc;
 623
 624               /* First setup error message.  */
 625               rc = grub_error (GRUB_ERR_BAD_ARGUMENT,
 626                                "Invalid mode: %s\n",
 627                                current_mode);
 628
 629               /* Free memory before returning.  */
 630               grub_free (modevar);
 631
 632               return rc;
 633             }
 634         }
 635
 636       /* Try out video mode.  */
 637
 638       /* If we have 8 or less bits, then assume that it is indexed color mode.  */
 639       if ((depth <= 8) && (depth != -1))
 640         flags |= GRUB_VIDEO_MODE_TYPE_INDEX_COLOR;
 641
 642       /* We have more than 8 bits, then assume that it is RGB color mode.  */
 643       if (depth > 8)
 644         flags |= GRUB_VIDEO_MODE_TYPE_RGB;
 645
 646       /* If user requested specific depth, forward that information to driver.  */
 647       if (depth != -1)
 648         flags |= (depth << GRUB_VIDEO_MODE_TYPE_DEPTH_POS)
 649           & GRUB_VIDEO_MODE_TYPE_DEPTH_MASK;
 650
 651       /* Try to initialize requested mode.  Ignore any errors.  */
 652       grub_video_adapter_t p;
 653
 654       /* Loop thru all possible video adapter trying to find requested mode.  */
 655       for (p = grub_video_adapter_list; p; p = p->next)
 656         {
 657           grub_err_t err;
 658           struct grub_video_mode_info mode_info;
 659
 660           grub_memset (&mode_info, 0, sizeof (mode_info));
 661
 662           /* Try to initialize adapter, if it fails, skip to next adapter.  */
 663           err = p->init ();
 664           if (err != GRUB_ERR_NONE)
 665             {
 666               grub_errno = GRUB_ERR_NONE;
 667               continue;
 668             }
 669
 670           /* Try to initialize video mode.  */
 671           err = p->setup (width, height, flags);
 672           if (err != GRUB_ERR_NONE)
 673             {
 674               p->fini ();
 675               grub_errno = GRUB_ERR_NONE;
 676               continue;
 677             }
 678
 679           err = p->get_info (&mode_info);
 680           if (err != GRUB_ERR_NONE)
 681             {
 682               p->fini ();
 683               grub_errno = GRUB_ERR_NONE;
 684               continue;
 685             }
 686
 687           if (hook && ! hook (p, &mode_info))
 688             {
 689               p->fini ();
 690               grub_errno = GRUB_ERR_NONE;
 691               continue;
 692             }
 693
 694           /* Valid mode found from adapter, and it has been activated.
 695              Specify it as active adapter.  */
 696           grub_video_adapter_active = p;
 697
 698           /* Free memory.  */
 699           grub_free (modevar);
 700
 701           return GRUB_ERR_NONE;
 702         }
 703
 704     }
 705
 706   /* Free memory.  */
 707   grub_free (modevar);
 708
 709   return grub_error (GRUB_ERR_BAD_ARGUMENT,
 710                      "No suitable mode found.");
 711 }
 712
 713 /* Initialize Video API module.  */
 714 GRUB_MOD_INIT(video_video)
 715 {
 716 }
 717
 718 /* Finalize Video API module.  */
 719 GRUB_MOD_FINI(video_video)
 720 {
 721 }