经验首页 前端设计 程序设计 Java相关 移动开发 数据库/运维 软件/图像 大数据/云计算 其他经验
当前位置：技术经验 » 移动开发 » Android » 查看文章
MTK Recovery 模式横屏修改(适用于6.0 + 8.1)
来源：cnblogs　　作者：cczheng　　时间：2019/9/17 9:43:08　　对本文有异议

在这里插入图片描述

修改前

在这里插入图片描述

修改后

6.0 Recovery 模式横屏修改方法

修改相关文件
bootable\recovery\minui\Android.mk
bootable\recovery\minui\mt_graphic_rotate.cpp
bootable\recovery\minui\mt_graphic_rotate.h
bootable\recovery\minui\graphics_fbdev.cpp
bootable\recovery\minui\minui.h

1、在 Android.mk 中增加 mt_graphic_rotate.cpp 编译项

  1. LOCAL_SRC_FILES :=     events.cpp     graphics.cpp     graphics_adf.cpp     graphics_drm.cpp     graphics_fbdev.cpp     resources.cpp 
  2. #cczheng add 
  3. LOCAL_SRC_FILES += mt_graphic_rotate.cpp

2、对比修改 mt_graphic_rotate.cpp，没有则直接复制以下类

  1. /*
  2. * Copyright (C) 2014 MediaTek Inc.
  3. * Modification based on code covered by the mentioned copyright
  4. * and/or permission notice(s).
  5. */
  8. #include <stdbool.h>
  9. #include <stdlib.h>
  10. #include <unistd.h>
  11. #include <inttypes.h>
  13. #include <fcntl.h>
  14. #include <stdio.h>
  16. #include <sys/cdefs.h>
  17. #include <sys/ioctl.h>
  18. #include <sys/mman.h>
  19. #include <sys/types.h>
  21. #include <linux/fb.h>
  22. #include <linux/kd.h>
  24. #include "minui.h"
  25. #include "graphics.h"
  27. GRSurface __gr_canvas;
  29. GRSurface* gr_canvas = NULL;
  30. int rotate_index=-1;
  32. static void print_surface_info(GRSurface *s, const char *name)
  33. {
  34.     printf("[graphics] %s > Height:%d, Width:%d, PixelBytes:%d, RowBytes:%d, Size:%d, Data: 0x%08" PRIxPTR "\n",
  35.         name, s->height, s->width, s->pixel_bytes, s->row_bytes, s->height* s->row_bytes, (uintptr_t) s->data);
  36. }
  38. // Read configuration from MTK_LCM_PHYSICAL_ROTATION
  39. #ifndef MTK_LCM_PHYSICAL_ROTATION
  40. #define MTK_LCM_PHYSICAL_ROTATION "undefined"
  41. #endif
  42. static int rotate_config(GRSurface *gr_draw)
  43. {
  44.     if (rotate_index<0)
  45.     {
  46.         if (gr_draw->pixel_bytes != 4) rotate_index=0; // support 4 bytes pixel only
  47.         else if (0 == strncmp(MTK_LCM_PHYSICAL_ROTATION, "90", 2)) rotate_index=1;
  48.         else if (0 == strncmp(MTK_LCM_PHYSICAL_ROTATION, "180", 3)) rotate_index=2;
  49.         else if (0 == strncmp(MTK_LCM_PHYSICAL_ROTATION, "270", 3)) rotate_index=3;
  50.         else rotate_index=0;
  51.         printf("[graphics] rotate_config %d %s\n", rotate_index, MTK_LCM_PHYSICAL_ROTATION);
  52.     }
  53.     return rotate_index;
  54. }
  56. #define swap(x, y, type) {type z; z=x; x=y; y=z;}
  58. // Allocate and setup the canvas object
  59. void rotate_canvas_init(GRSurface *gr_draw)
  60. {
  61.     gr_canvas = &__gr_canvas;
  62.     memcpy(gr_canvas, gr_draw, sizeof(GRSurface));
  64.     // Swap canvas' height and width, if the rotate angle is 90" or 270"
  65.     if (rotate_config(gr_draw)%2) {
  66.         swap(gr_canvas->width, gr_canvas->height, int);
  67.         gr_canvas->row_bytes = gr_canvas->width * gr_canvas->pixel_bytes;
  68.     }
  70.     gr_canvas->data = (unsigned char*) malloc(gr_canvas->height * gr_canvas->row_bytes);
  71.     if (gr_canvas->data == NULL) {
  72.         printf("[graphics] rotate_canvas_init() malloc gr_canvas->data failed\n");
  73.         gr_canvas = NULL;
  74.         return;
  75.     }
  77.     memset(gr_canvas->data,  0, gr_canvas->height * gr_canvas->row_bytes);
  79.     print_surface_info(gr_draw, "gr_draw");
  80.     print_surface_info(gr_canvas, "gr_canvas");
  81. }
  83. // Cleanup the canvas
  84. void rotate_canvas_exit(void)
  85. {
  86.     if (gr_canvas) {
  87.         if (gr_canvas->data)
  88.             free(gr_canvas->data);
  89.         free(gr_canvas);
  90.     }
  91.     gr_canvas=NULL;
  92. }
  94. // Return the canvas object
  95. GRSurface *rotate_canvas_get(GRSurface *gr_draw)
  96. {
  97.     // Initialize the canvas, if it was not exist.
  98.     if (gr_canvas==NULL)
  99.         rotate_canvas_init(gr_draw);
  100.     return gr_canvas;
  101. }
  103. // Surface Rotate Routines
  104. static void rotate_surface_0(GRSurface *dst, GRSurface *src)
  105. {
  106.     memcpy(dst->data, src->data, src->height*src->row_bytes);
  107. }
  109. static void rotate_surface_270(GRSurface *dst, GRSurface *src)
  110. {
  111.     int v, w, h;
  112.     unsigned int *src_pixel;
  113.     unsigned int *dst_pixel;
  115.     for (h=0, v=src->width-1; h<dst->height; h++, v--) {
  116.         for (w=0; w<dst->width; w++) {
  117.             dst_pixel = (unsigned int *)(dst->data + dst->row_bytes*h);
  118.             src_pixel = (unsigned int *)(src->data + src->row_bytes*w);
  119.             *(dst_pixel+w)=*(src_pixel+v);
  120.         }
  121.     }
  122. }
  124. static void rotate_surface_180(GRSurface *dst, GRSurface *src)
  125. {
  126.     int v, w, k, h;
  127.     unsigned int *src_pixel;
  128.     unsigned int *dst_pixel;
  130.     for (h=0, k=src->height-1; h<dst->height && k>=0 ; h++, k--) {
  131.         dst_pixel = (unsigned int *)(dst->data + dst->row_bytes*h);
  132.         src_pixel = (unsigned int *)(src->data + src->row_bytes*k);
  133.         for (w=0, v=src->width-1; w<dst->width && v>=0; w++, v--) {
  134.             *(dst_pixel+w)=*(src_pixel+v);
  135.         }
  136.     }
  137. }
  139. static void rotate_surface_90(GRSurface *dst, GRSurface *src)
  140. {
  141.     int w, k, h;
  142.     unsigned int *src_pixel;
  143.     unsigned int *dst_pixel;
  145.     for (h=0; h<dst->height; h++) {
  146.         for (w=0, k=src->height-1; w<dst->width; w++, k--) {
  147.             dst_pixel = (unsigned int *)(dst->data + dst->row_bytes*h);
  148.             src_pixel = (unsigned int *)(src->data + src->row_bytes*k);
  149.             *(dst_pixel+w)=*(src_pixel+h);
  150.         }
  151.     }
  152. }
  154. typedef void (*rotate_surface_t) (GRSurface *, GRSurface *);
  156. rotate_surface_t rotate_func[4]=
  157. {
  158.     rotate_surface_0,
  159.     rotate_surface_90,
  160.     rotate_surface_180,
  161.     rotate_surface_270
  162. };
  164. // rotate and copy src* surface to dst surface
  165. void rotate_surface(GRSurface *dst, GRSurface *src)
  166. {
  167.     rotate_surface_t rotate;
  168.     rotate=rotate_func[rotate_config(dst)];
  169.     rotate(dst, src);
  170. }

3、对比修改 mt_graphic_rotate.h，没有则直接复制以下类

  1. /*
  2. * Copyright (C) 2014 MediaTek Inc.
  3. * Modification based on code covered by the mentioned copyright
  4. * and/or permission notice(s).
  5. */
  7. #ifndef MT_GRAPHICS_ROTATE_H_
  8. #define MT_GRAPHICS_ROTATE_H_
  10. #include "minui.h"
  12. void rotate_canvas_exit(void);
  13. void rotate_canvas_init(GRSurface *gr_draw);
  14. void rotate_surface(GRSurface *dst, GRSurface *src);
  15. GRSurface *rotate_canvas_get(GRSurface *gr_draw);
  17. #endif

4、对比修改 graphics_fbdev.cpp，没有则直接复制以下类

  1. /*
  2.  * Copyright (C) 2014 The Android Open Source Project
  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.  */
  17. #include <stdbool.h>
  18. #include <stdlib.h>
  19. #include <string.h>
  20. #include <unistd.h>
  22. #include <fcntl.h>
  23. #include <stdio.h>
  25. #include <sys/cdefs.h>
  26. #include <sys/ioctl.h>
  27. #include <sys/mman.h>
  28. #include <sys/types.h>
  30. #include <linux/fb.h>
  31. #include <linux/kd.h>
  33. #include "minui.h"
  34. #include "graphics.h"
  35. #include "mt_graphic_rotate.h"
  37. static GRSurface* fbdev_init(minui_backend*);
  38. static GRSurface* fbdev_flip(minui_backend*);
  39. static void fbdev_blank(minui_backend*, bool);
  40. static void fbdev_exit(minui_backend*);
  42. static GRSurface gr_framebuffer[2];
  43. static bool double_buffered;
  44. static GRSurface* gr_draw = NULL;
  45. static int displayed_buffer;
  47. static fb_var_screeninfo vi;
  48. static int fb_fd = -1;
  50. static minui_backend my_backend = {
  51.     .init = fbdev_init,
  52.     .flip = fbdev_flip,
  53.     .blank = fbdev_blank,
  54.     .exit = fbdev_exit,
  55. };
  57. minui_backend* open_fbdev() {
  58.     return &my_backend;
  59. }
  61. static void fbdev_blank(minui_backend* backend __unused, bool blank)
  62. {
  63.     int ret;
  65.     ret = ioctl(fb_fd, FBIOBLANK, blank ? FB_BLANK_POWERDOWN : FB_BLANK_UNBLANK);
  66.     if (ret < 0)
  67.         perror("ioctl(): blank");
  68. }
  70. static void set_displayed_framebuffer(unsigned n)
  71. {
  72.     if (n > 1 || !double_buffered) return;
  74.     vi.yres_virtual = gr_framebuffer[0].height * 2;
  75.     vi.yoffset = n * gr_framebuffer[0].height;
  76.     vi.bits_per_pixel = gr_framebuffer[0].pixel_bytes * 8;
  77.     if (ioctl(fb_fd, FBIOPUT_VSCREENINFO, &vi) < 0) {
  78.         perror("active fb swap failed");
  79.     }
  80.     displayed_buffer = n;
  81. }
  83. static GRSurface* fbdev_init(minui_backend* backend) {
  84.     int fd = open("/dev/graphics/fb0", O_RDWR);
  85.     if (fd == -1) {
  86.         perror("cannot open fb0");
  87.         return NULL;
  88.     }
  90.     fb_fix_screeninfo fi;
  91.     if (ioctl(fd, FBIOGET_FSCREENINFO, &fi) < 0) {
  92.         perror("failed to get fb0 info");
  93.         close(fd);
  94.         return NULL;
  95.     }
  97.     if (ioctl(fd, FBIOGET_VSCREENINFO, &vi) < 0) {
  98.         perror("failed to get fb0 info");
  99.         close(fd);
  100.         return NULL;
  101.     }
  103.     // We print this out for informational purposes only, but
  104.     // throughout we assume that the framebuffer device uses an RGBX
  105.     // pixel format.  This is the case for every development device I
  106.     // have access to.  For some of those devices (eg, hammerhead aka
  107.     // Nexus 5), FBIOGET_VSCREENINFO *reports* that it wants a
  108.     // different format (XBGR) but actually produces the correct
  109.     // results on the display when you write RGBX.
  110.     //
  111.     // If you have a device that actually *needs* another pixel format
  112.     // (ie, BGRX, or 565), patches welcome...
  114.     printf("fb0 reports (possibly inaccurate):\n"
  115.            "  vi.bits_per_pixel = %d\n"
  116.            "  vi.red.offset   = %3d   .length = %3d\n"
  117.            "  vi.green.offset = %3d   .length = %3d\n"
  118.            "  vi.blue.offset  = %3d   .length = %3d\n",
  119.            vi.bits_per_pixel,
  120.            vi.red.offset, vi.red.length,
  121.            vi.green.offset, vi.green.length,
  122.            vi.blue.offset, vi.blue.length);
  124.     void* bits = mmap(0, fi.smem_len, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
  125.     if (bits == MAP_FAILED) {
  126.         perror("failed to mmap framebuffer");
  127.         close(fd);
  128.         return NULL;
  129.     }
  131.     memset(bits, 0, fi.smem_len);
  133.     gr_framebuffer[0].width = vi.xres;
  134.     gr_framebuffer[0].height = vi.yres;
  135.     gr_framebuffer[0].row_bytes = fi.line_length;
  136.     gr_framebuffer[0].pixel_bytes = vi.bits_per_pixel / 8;
  137.     gr_framebuffer[0].data = reinterpret_cast<uint8_t*>(bits);
  138.     memset(gr_framebuffer[0].data, 0, gr_framebuffer[0].height * gr_framebuffer[0].row_bytes);
  140.     /* check if we can use double buffering */
  141.     printf("[graphics] vi.yres * fi.line_length = %d * %d * 2 = %d, fi.smem_len=%d\n",
  142.         vi.yres, fi.line_length, vi.yres * fi.line_length * 2, fi.smem_len);
  144.     if (vi.yres * fi.line_length * 2 <= fi.smem_len) {
  145.         double_buffered = true;
  146.         printf("[graphics] double buffered\n");
  148.         memcpy(gr_framebuffer+1, gr_framebuffer, sizeof(GRSurface));
  149.         gr_framebuffer[1].data = gr_framebuffer[0].data +
  150.             gr_framebuffer[0].height * gr_framebuffer[0].row_bytes;
  152.         gr_draw = gr_framebuffer+1;
  154.     } else {
  155.         double_buffered = false;
  156.         printf("[graphics] without double buffer\n");
  157.         // Without double-buffering, we allocate RAM for a buffer to
  158.         // draw in, and then "flipping" the buffer consists of a
  159.         // memcpy from the buffer we allocated to the framebuffer.
  161.         gr_draw = (GRSurface*) malloc(sizeof(GRSurface));
  162.         memcpy(gr_draw, gr_framebuffer, sizeof(GRSurface));
  163.         gr_draw->data = (unsigned char*) malloc(gr_draw->height * gr_draw->row_bytes);
  164.         if (!gr_draw->data) {
  165.             perror("failed to allocate in-memory surface");
  166.             return NULL;
  167.         }
  168.     }
  170.     memset(gr_draw->data, 0, gr_draw->height * gr_draw->row_bytes);
  171.     fb_fd = fd;
  172.     set_displayed_framebuffer(0);
  174.     printf("framebuffer: %d (%d x %d)\n", fb_fd, gr_draw->width, gr_draw->height);
  176. #if 0 // to avoid display blink due to display driver not disable backlight after kernel standardization, so that temp state between display suspend/resume is shown
  177.     fbdev_blank(backend, true);
  178.     fbdev_blank(backend, false);
  179. #endif
  181.     return rotate_canvas_get(gr_draw);
  182. }
  184. static GRSurface* fbdev_flip(minui_backend* backend __unused) {
  185.     rotate_surface(gr_draw, rotate_canvas_get(gr_draw));
  186.     if (double_buffered) {
  187. #if defined(RECOVERY_BGRA)
  188.         // In case of BGRA, do some byte swapping
  189.         unsigned int idx;
  190.         unsigned char tmp;
  191.         unsigned char* ucfb_vaddr = (unsigned char*)gr_draw->data;
  192.         for (idx = 0 ; idx < (gr_draw->height * gr_draw->row_bytes);
  193.                 idx += 4) {
  194.             tmp = ucfb_vaddr[idx];
  195.             ucfb_vaddr[idx    ] = ucfb_vaddr[idx + 2];
  196.             ucfb_vaddr[idx + 2] = tmp;
  197.         }
  198. #endif
  199.         // Change gr_draw to point to the buffer currently displayed,
  200.         // then flip the driver so we're displaying the other buffer
  201.         // instead.
  202.         gr_draw = gr_framebuffer + displayed_buffer;
  203.         set_displayed_framebuffer(1-displayed_buffer);
  204.     } else {
  205.         // Copy from the in-memory surface to the framebuffer.
  206.         memcpy(gr_framebuffer[0].data, gr_draw->data,
  207.                gr_draw->height * gr_draw->row_bytes);
  208.     }
  209.     return rotate_canvas_get(gr_draw);
  210. }
  212. static void fbdev_exit(minui_backend* backend __unused) {
  213.     close(fb_fd);
  214.     fb_fd = -1;
  215.     rotate_canvas_exit();
  216.     if (!double_buffered && gr_draw) {
  217.         free(gr_draw->data);
  218.         free(gr_draw);
  219.     }
  220.     gr_draw = NULL;
  221. }

5、对比修改 minui.h，没有则直接复制以下类

  1. /*
  2.  * Copyright (C) 2007 The Android Open Source Project
  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.  */
  17. #ifndef _MINUI_H_
  18. #define _MINUI_H_
  20. #include <sys/types.h>
  22. #include <functional>
  24. //
  25. // Graphics.
  26. //
  28. struct GRSurface {
  29.     int width;
  30.     int height;
  31.     int row_bytes;
  32.     int pixel_bytes;
  33.     unsigned char* data;
  34. };
  36. int gr_init();
  37. void gr_exit();
  39. int gr_fb_width();
  40. int gr_fb_height();
  42. void gr_flip();
  43. void gr_fb_blank(bool blank);
  45. void gr_clear();  // clear entire surface to current color
  46. void gr_color(unsigned char r, unsigned char g, unsigned char b, unsigned char a);
  47. void gr_fill(int x1, int y1, int x2, int y2);
  48. void gr_text(int x, int y, const char *s, bool bold);
  49. void gr_texticon(int x, int y, GRSurface* icon);
  50. int gr_measure(const char *s);
  51. void gr_font_size(int *x, int *y);
  53. void gr_blit(GRSurface* source, int sx, int sy, int w, int h, int dx, int dy);
  54. unsigned int gr_get_width(GRSurface* surface);
  55. unsigned int gr_get_height(GRSurface* surface);
  57. //
  58. // Input events.
  59. //
  61. struct input_event;
  63. // TODO: move these over to std::function.
  64. typedef int (*ev_callback)(int fd, uint32_t epevents, void* data);
  65. typedef int (*ev_set_key_callback)(int code, int value, void* data);
  67. int ev_init(ev_callback input_cb, void* data);
  68. void ev_exit();
  69. int ev_add_fd(int fd, ev_callback cb, void* data);
  70. void ev_iterate_available_keys(std::function<void(int)> f);
  71. int ev_sync_key_state(ev_set_key_callback set_key_cb, void* data);
  73. // 'timeout' has the same semantics as poll(2).
  74. //    0 : don't block
  75. //  < 0 : block forever
  76. //  > 0 : block for 'timeout' milliseconds
  77. int ev_wait(int timeout);
  79. int ev_get_input(int fd, uint32_t epevents, input_event* ev);
  80. void ev_dispatch();
  81. int ev_get_epollfd();
  83. //
  84. // Resources
  85. //
  87. // res_create_*_surface() functions return 0 if no error, else
  88. // negative.
  89. //
  90. // A "display" surface is one that is intended to be drawn to the
  91. // screen with gr_blit().  An "alpha" surface is a grayscale image
  92. // interpreted as an alpha mask used to render text in the current
  93. // color (with gr_text() or gr_texticon()).
  94. //
  95. // All these functions load PNG images from "/res/images/${name}.png".
  97. // Load a single display surface from a PNG image.
  98. int res_create_display_surface(const char* name, GRSurface** pSurface);
  100. // Load an array of display surfaces from a single PNG image.  The PNG
  101. // should have a 'Frames' text chunk whose value is the number of
  102. // frames this image represents.  The pixel data itself is interlaced
  103. // by row.
  104. int res_create_multi_display_surface(const char* name,
  105.                                      int* frames, GRSurface*** pSurface);
  107. // Load a single alpha surface from a grayscale PNG image.
  108. int res_create_alpha_surface(const char* name, GRSurface** pSurface);
  110. // Load part of a grayscale PNG image that is the first match for the
  111. // given locale.  The image is expected to be a composite of multiple
  112. // translations of the same text, with special added rows that encode
  113. // the subimages' size and intended locale in the pixel data.  See
  114. // development/tools/recovery_l10n for an app that will generate these
  115. // specialized images from Android resources.
  116. int res_create_localized_alpha_surface(const char* name, const char* locale,
  117.                                        GRSurface** pSurface);
  119. // Free a surface allocated by any of the res_create_*_surface()
  120. // functions.
  121. void res_free_surface(GRSurface* surface);
  123. #endif

8.1 Recovery 模式横屏修改方法

8.1 的修改步骤和 6.0 大体差不多，前三步都一样，请参考上面的，由于 8.1 中不需要 minui.h 文件，所以 mt_graphic_rotate.h 和 mt_graphic_rotate.cpp 中 需要注释

  1. //#include "minui.h"

4、对比修改 graphics_fbdev.cpp

  1. /*
  2.  * Copyright (C) 2014 The Android Open Source Project
  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.  */
  17. #include "graphics_fbdev.h"
  19. #include <fcntl.h>
  20. #include <linux/fb.h>
  21. #include <stdio.h>
  22. #include <stdlib.h>
  23. #include <string.h>
  24. #include <sys/ioctl.h>
  25. #include <sys/mman.h>
  26. #include <sys/types.h>
  27. #include <unistd.h>
  29. #include "minui/minui.h"
  30. //cczheng add for rotateCanvas
  31. #include "mt_graphic_rotate.h"
  33. MinuiBackendFbdev::MinuiBackendFbdev() : gr_draw(nullptr), fb_fd(-1) {}
  35. void MinuiBackendFbdev::Blank(bool blank) {
  36.   int ret = ioctl(fb_fd, FBIOBLANK, blank ? FB_BLANK_POWERDOWN : FB_BLANK_UNBLANK);
  37.   if (ret < 0) perror("ioctl(): blank");
  38. }
  40. void MinuiBackendFbdev::SetDisplayedFramebuffer(unsigned n) {
  41.   if (n > 1 || !double_buffered) return;
  43.   vi.yres_virtual = gr_framebuffer[0].height * 2;
  44.   vi.yoffset = n * gr_framebuffer[0].height;
  45.   vi.bits_per_pixel = gr_framebuffer[0].pixel_bytes * 8;
  46.   if (ioctl(fb_fd, FBIOPUT_VSCREENINFO, &vi) < 0) {
  47.     perror("active fb swap failed");
  48.   }
  49.   displayed_buffer = n;
  50. }
  52. GRSurface* MinuiBackendFbdev::Init() {
  53.   int fd = open("/dev/graphics/fb0", O_RDWR);
  54.   if (fd == -1) {
  55.     perror("cannot open fb0");
  56.     return nullptr;
  57.   }
  59.   fb_fix_screeninfo fi;
  60.   if (ioctl(fd, FBIOGET_FSCREENINFO, &fi) < 0) {
  61.     perror("failed to get fb0 info");
  62.     close(fd);
  63.     return nullptr;
  64.   }
  66.   if (ioctl(fd, FBIOGET_VSCREENINFO, &vi) < 0) {
  67.     perror("failed to get fb0 info");
  68.     close(fd);
  69.     return nullptr;
  70.   }
  72.   // We print this out for informational purposes only, but
  73.   // throughout we assume that the framebuffer device uses an RGBX
  74.   // pixel format.  This is the case for every development device I
  75.   // have access to.  For some of those devices (eg, hammerhead aka
  76.   // Nexus 5), FBIOGET_VSCREENINFO *reports* that it wants a
  77.   // different format (XBGR) but actually produces the correct
  78.   // results on the display when you write RGBX.
  79.   //
  80.   // If you have a device that actually *needs* another pixel format
  81.   // (ie, BGRX, or 565), patches welcome...
  83.   printf(
  84.       "fb0 reports (possibly inaccurate):\n"
  85.       "  vi.bits_per_pixel = %d\n"
  86.       "  vi.red.offset   = %3d   .length = %3d\n"
  87.       "  vi.green.offset = %3d   .length = %3d\n"
  88.       "  vi.blue.offset  = %3d   .length = %3d\n",
  89.       vi.bits_per_pixel, vi.red.offset, vi.red.length, vi.green.offset, vi.green.length,
  90.       vi.blue.offset, vi.blue.length);
  92.   void* bits = mmap(0, fi.smem_len, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
  93.   if (bits == MAP_FAILED) {
  94.     perror("failed to mmap framebuffer");
  95.     close(fd);
  96.     return nullptr;
  97.   }
  99.   memset(bits, 0, fi.smem_len);
  101.   gr_framebuffer[0].width = vi.xres;
  102.   gr_framebuffer[0].height = vi.yres;
  103.   gr_framebuffer[0].row_bytes = fi.line_length;
  104.   gr_framebuffer[0].pixel_bytes = vi.bits_per_pixel / 8;
  105.   gr_framebuffer[0].data = static_cast<uint8_t*>(bits);
  106.   memset(gr_framebuffer[0].data, 0, gr_framebuffer[0].height * gr_framebuffer[0].row_bytes);
  108.   /* check if we can use double buffering */
  109.   if (vi.yres * fi.line_length * 2 <= fi.smem_len) {
  110.     double_buffered = true;
  112.     memcpy(gr_framebuffer + 1, gr_framebuffer, sizeof(GRSurface));
  113.     gr_framebuffer[1].data =
  114.         gr_framebuffer[0].data + gr_framebuffer[0].height * gr_framebuffer[0].row_bytes;
  116.     gr_draw = gr_framebuffer + 1;
  118.   } else {
  119.     double_buffered = false;
  121.     // Without double-buffering, we allocate RAM for a buffer to
  122.     // draw in, and then "flipping" the buffer consists of a
  123.     // memcpy from the buffer we allocated to the framebuffer.
  125.     gr_draw = static_cast<GRSurface*>(malloc(sizeof(GRSurface)));
  126.     memcpy(gr_draw, gr_framebuffer, sizeof(GRSurface));
  127.     gr_draw->data = static_cast<unsigned char*>(malloc(gr_draw->height * gr_draw->row_bytes));
  128.     if (!gr_draw->data) {
  129.       perror("failed to allocate in-memory surface");
  130.       return nullptr;
  131.     }
  132.   }
  134.   memset(gr_draw->data, 0, gr_draw->height * gr_draw->row_bytes);
  135.   fb_fd = fd;
  136.   SetDisplayedFramebuffer(0);
  138.   printf("framebuffer: %d (%d x %d)\n", fb_fd, gr_draw->width, gr_draw->height);
  139. #if 0
  140.   Blank(true);
  141.   Blank(false);
  142. #endif
  144.   //return gr_draw;
  145.   //cczheng add for rotateCanvas
  146.   return rotate_canvas_get(gr_draw);
  147. }
  149. GRSurface* MinuiBackendFbdev::Flip() {
  150.   //cczheng add for rotateCanvas
  151.   rotate_surface(gr_draw, rotate_canvas_get(gr_draw));
  152.   if (double_buffered) {
  153.     // Change gr_draw to point to the buffer currently displayed,
  154.     // then flip the driver so we're displaying the other buffer
  155.     // instead.
  156.     gr_draw = gr_framebuffer + displayed_buffer;
  157.     SetDisplayedFramebuffer(1 - displayed_buffer);
  158.   } else {
  159.     // Copy from the in-memory surface to the framebuffer.
  160.     memcpy(gr_framebuffer[0].data, gr_draw->data, gr_draw->height * gr_draw->row_bytes);
  161.   }
  162.   //return gr_draw;
  163.   //cczheng add for rotateCanvas
  164.   return rotate_canvas_get(gr_draw);
  165. }
  167. MinuiBackendFbdev::~MinuiBackendFbdev() {
  168.   close(fb_fd);
  169.   fb_fd = -1;
  170.   //cczheng add for rotateCanvas
  171.   rotate_canvas_exit();
  172.   if (!double_buffered && gr_draw) {
  173.     free(gr_draw->data);
  174.     free(gr_draw);
  175.   }
  176.   gr_draw = nullptr;
  177. }

修改旋转角度，在 mt_graphic_rotate.cpp 中的 rotate_config(GRSurface gr_draw)
旋转90度就将 return rotate_index 直接改为 return 1,
依次类推转 180度, 改为 return 2, 270 度改为 return 3.
注意旋转方向为顺时针旋转

我修改的情况对应 return 3.

原文链接：http://www.cnblogs.com/cczheng-666/p/11528773.html

 友情链接：直通硅谷 　点职佳 　北美留学生论坛

Android热门文章

  • 安卓虚拟定位实现与反作弊思路
  • Android之Activity启动流程详解（基于api28）
  • MAUI开发Android程序使PDA扫码广播消息转发至Web页面
  • android开发技巧杂谈
  • 高通CSR8675蓝牙音频芯片介绍
  • Android Studio列表用法之一：ListView图文列表显示（实例）
  • 分析Android 11.0Settings源码之主界面加载
  • 联发科MT6731 4G智能功能手机处理器芯片介绍
  • android 请求接口报错 org.apache.http.conn.HttpHostConnectException: Connection to http://192.168.1.90:9090 refused
  • GSYVideoPlayer使用记录

    • Android推荐文章

  • Jetpack Compose(7)——触摸反馈
  • 安卓开发日志采集和分析面面谈
  • Android桌面Launcher源码浅析
  • Android启动过程-万字长文(Android14)
  • Android Studio制作简单登录界面
  • FFmpeg开发笔记（九）Linux交叉编译Android的x265库
  • 在Android开发中如何使用OpenSL ES库播放解码后的pcm音频文件？
  • Android 开机流程介绍
  • 安卓端出现https请求失败的一次问题排查
  • Android 编译介绍

    • 本站QQ群：前端 618073944 | Java 606181507 | Python 626812652 | C/C++ 612253063 | 微信 634508462 | 苹果 692586424 | C#/.net 182808419 | PHP 305140648 | 运维 608723728

    W3xue 的所有内容仅供测试，对任何法律问题及风险不承担任何责任。通过使用本站内容随之而来的风险与本站无关。
    关于我们  |  意见建议  |  捐助我们  |  报错有奖  |  广告合作、友情链接（目前9元/月）请联系QQ：27243702 沸活量
    皖ICP备17017327号-2　皖公网安备34020702000426号