2244
|
1 /*
|
|
2 * video_out_vesa.c
|
|
3 *
|
|
4 * Copyright (C) Nick Kurshev <nickols_k@mail.ru> - Oct 2001
|
|
5 *
|
|
6 * You can redistribute this file under terms and conditions
|
|
7 * GNU General Public licence v2.
|
|
8 * This file is partly based on vbetest.c from lrmi distributive.
|
|
9 */
|
|
10
|
|
11 /*
|
|
12 TODO:
|
|
13 - DGA support (need volunteers who have corresponding hardware)
|
|
14 - hw YUV support (need volunteers who have corresponding hardware)
|
|
15 - double (triple) buffering (if it will really speedup playback).
|
|
16 - refresh rate support (need additional info from mplayer)
|
|
17 */
|
|
18 #include <stdio.h>
|
|
19 #include <string.h>
|
|
20 #include <stddef.h>
|
|
21 #include <limits.h>
|
|
22
|
|
23 #include "config.h"
|
|
24 #include "video_out.h"
|
|
25 #include "video_out_internal.h"
|
|
26
|
|
27 #include "fastmemcpy.h"
|
|
28 #include "yuv2rgb.h"
|
|
29
|
|
30 #include "linux/lrmi.h"
|
|
31 #include "linux/vbelib.h"
|
|
32 #include "bswap.h"
|
|
33
|
|
34 LIBVO_EXTERN(vesa)
|
|
35 extern int verbose;
|
|
36
|
|
37 #ifndef max
|
|
38 #define max(a,b) ((a)>(b)?(a):(b))
|
|
39 #endif
|
|
40 #ifndef min
|
|
41 #define min(a,b) ((a)<(b)?(a):(b))
|
|
42 #endif
|
|
43
|
|
44
|
|
45 static vo_info_t vo_info =
|
|
46 {
|
|
47 "VESA VBE 2.0 video output",
|
|
48 "vesa",
|
|
49 "Nick Kurshev <nickols_k@mail.ru>",
|
|
50 "Requires ROOT privileges"
|
|
51 };
|
|
52
|
|
53 /* driver data */
|
|
54
|
|
55 /*
|
|
56 TODO: for linear framebuffer mode:
|
|
57 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
58 win.ptr = linear address of frame buffer;
|
|
59 win.low = 0;
|
|
60 win.high = vide_memory_size;
|
|
61 */
|
|
62 struct win_frame
|
|
63 {
|
|
64 uint8_t *ptr; /* pointer to window's frame memory */
|
|
65 uint32_t low; /* lowest boundary of frame */
|
|
66 uint32_t high; /* highest boundary of frame */
|
|
67 uint8_t idx; /* indicates index of relocatable frame (A or B) */
|
|
68 };
|
|
69
|
|
70 static uint32_t image_width, image_height; /* source image dimension */
|
|
71 static uint32_t x_offset,y_offset; /* to center image on screen */
|
|
72 static unsigned init_mode; /* mode before run of mplayer */
|
|
73 static void *init_state = NULL; /* state before run of mplayer */
|
|
74 static struct win_frame win; /* real-mode window to video memory */
|
2293
|
75 static void *yuv_buffer = NULL; /* for yuv2rgb and sw_scaling */
|
2244
|
76 static unsigned video_mode; /* selected video mode for playback */
|
|
77 static struct VesaModeInfoBlock video_mode_info;
|
|
78
|
|
79 #define MOVIE_MODE (MODE_ATTR_COLOR | MODE_ATTR_GRAPHICS)
|
|
80 #define FRAME_MODE (MODE_WIN_RELOCATABLE | MODE_WIN_READABLE | MODE_WIN_WRITEABLE)
|
|
81 static char * vbeErrToStr(int err)
|
|
82 {
|
|
83 char *retval;
|
|
84 static char sbuff[80];
|
|
85 if((err & VBE_VESA_ERROR_MASK) == VBE_VESA_ERROR_MASK)
|
|
86 {
|
2255
|
87 sprintf(sbuff,"VESA failed = 0x4f%x",(err & VBE_VESA_ERRCODE_MASK)>>8);
|
2244
|
88 retval = sbuff;
|
|
89 }
|
|
90 else
|
|
91 switch(err)
|
|
92 {
|
|
93 case VBE_OK: retval = "No error"; break;
|
|
94 case VBE_VM86_FAIL: retval = "vm86() syscall failed"; break;
|
|
95 case VBE_OUT_OF_DOS_MEM: retval = "Out of DOS memory"; break;
|
|
96 case VBE_OUT_OF_MEM: retval = "Out of memory"; break;
|
|
97 default: sprintf(sbuff,"Uknown error: %i",err); retval=sbuff; break;
|
|
98 }
|
|
99 return retval;
|
|
100 }
|
|
101
|
|
102 #define PRINT_VBE_ERR(name,err) { printf("vo_vesa: %s returns: %s\n",name,vbeErrToStr(err)); fflush(stdout); }
|
|
103
|
|
104 static void vesa_term( void )
|
|
105 {
|
|
106 int err;
|
|
107 if((err=vbeRestoreState(init_state)) != VBE_OK) PRINT_VBE_ERR("vbeRestoreState",err);
|
|
108 if((err=vbeSetMode(init_mode,NULL)) != VBE_OK) PRINT_VBE_ERR("vbeSetMode",err);
|
2293
|
109 free(yuv_buffer);
|
2244
|
110 vbeDestroy();
|
|
111 }
|
|
112
|
|
113 #define VALID_WIN_FRAME(offset) (offset >= win.low && offset < win.high)
|
|
114 #define VIDEO_PTR(offset) (win.ptr + offset - win.low)
|
|
115
|
|
116 static inline void __vbeSwitchBank(unsigned long offset)
|
|
117 {
|
|
118 unsigned long gran;
|
|
119 unsigned new_offset;
|
|
120 int err;
|
|
121 gran = video_mode_info.WinGranularity*1024;
|
|
122 new_offset = offset / gran;
|
|
123 if((err=vbeSetWindow(win.idx,new_offset)) != VBE_OK)
|
|
124 {
|
|
125 PRINT_VBE_ERR("vbeSetWindow",err);
|
|
126 printf("vo_vesa: Fatal error occured! Can't continue\n");
|
|
127 vesa_term();
|
|
128 exit(-1);
|
|
129 }
|
|
130 win.low = new_offset * gran;
|
|
131 win.high = win.low + video_mode_info.WinSize*1024;
|
|
132 }
|
|
133
|
|
134 static void __vbeSetPixel(int x, int y, int r, int g, int b)
|
|
135 {
|
|
136 int x_res = video_mode_info.XResolution;
|
|
137 int y_res = video_mode_info.YResolution;
|
|
138 int shift_r = video_mode_info.RedFieldPosition;
|
|
139 int shift_g = video_mode_info.GreenFieldPosition;
|
|
140 int shift_b = video_mode_info.BlueFieldPosition;
|
|
141 int pixel_size = (video_mode_info.BitsPerPixel+7)/8;
|
|
142 int bpl = video_mode_info.BytesPerScanLine;
|
|
143 int color, offset;
|
|
144
|
|
145 if (x < 0 || x >= x_res || y < 0 || y >= y_res) return;
|
|
146 r >>= 8 - video_mode_info.RedMaskSize;
|
|
147 g >>= 8 - video_mode_info.GreenMaskSize;
|
|
148 b >>= 8 - video_mode_info.BlueMaskSize;
|
|
149 color = (r << shift_r) | (g << shift_g) | (b << shift_b);
|
|
150 offset = y * bpl + (x * pixel_size);
|
|
151 if(!VALID_WIN_FRAME(offset)) __vbeSwitchBank(offset);
|
|
152 memcpy(VIDEO_PTR(offset), &color, pixel_size);
|
|
153 }
|
|
154
|
|
155 /*
|
|
156 Copies line of frame to video memory. Data should be in the same format as video
|
|
157 memory.
|
|
158 */
|
|
159 static void __vbeCopyBlock(unsigned long offset,uint8_t *image,unsigned long size)
|
|
160 {
|
|
161 unsigned long delta,src_idx = 0;
|
|
162 while(size)
|
|
163 {
|
|
164 if(!VALID_WIN_FRAME(offset)) __vbeSwitchBank(offset);
|
|
165 delta = min(size,win.high - offset);
|
|
166 memcpy(VIDEO_PTR(offset),&image[src_idx],delta);
|
|
167 src_idx += delta;
|
|
168 offset += delta;
|
|
169 size -= delta;
|
|
170 }
|
|
171 }
|
|
172
|
|
173 static void __vbeCopyBlockSwap(unsigned long offset,uint8_t *image,unsigned long size)
|
|
174 {
|
|
175 unsigned byte_len;
|
|
176 uint8_t ch;
|
|
177 while(size)
|
|
178 {
|
|
179 switch(video_mode_info.BitsPerPixel)
|
|
180 {
|
|
181 case 8: byte_len = 1; break;
|
|
182 default:
|
|
183 case 15:
|
|
184 printf("vo_vesa: Can't swap non byte aligned data\n");
|
|
185 vesa_term();
|
|
186 exit(-1);
|
|
187 case 16: *(image + offset) = ByteSwap16(*(image + offset));
|
|
188 byte_len = 2; break;
|
|
189 case 24: ch = *(image+offset);
|
|
190 *(image+offset) = *(image+offset+3);
|
|
191 *(image+offset+3) = ch;
|
|
192 byte_len = 3; break;
|
|
193 case 32: *(image + offset) = ByteSwap32(*(image + offset));
|
|
194 byte_len = 4; break;
|
|
195 }
|
|
196 __vbeCopyBlock(offset,image,byte_len);
|
|
197 size -= byte_len;
|
|
198 image += byte_len;
|
|
199 offset += byte_len;
|
|
200 }
|
|
201 }
|
|
202
|
|
203 /*
|
|
204 Copies frame to video memory. Data should be in the same format as video
|
|
205 memory.
|
|
206 */
|
|
207 static void __vbeCopyData(uint8_t *image)
|
|
208 {
|
|
209 unsigned long i,image_offset,offset;
|
|
210 unsigned pixel_size,image_line_size,screen_line_size,x_shift;
|
|
211 pixel_size = (video_mode_info.BitsPerPixel+7)/8;
|
|
212 screen_line_size = video_mode_info.XResolution*pixel_size;
|
|
213 image_line_size = image_width*pixel_size;
|
|
214 x_shift = x_offset*pixel_size;
|
|
215 for(i=y_offset;i<image_height;i++)
|
|
216 {
|
|
217 offset = i*screen_line_size+x_shift;
|
|
218 image_offset = i*image_line_size;
|
|
219 __vbeCopyBlock(offset,&image[image_offset],image_line_size);
|
|
220 }
|
|
221 }
|
|
222 /* is called for yuv only */
|
|
223 static uint32_t draw_slice(uint8_t *image[], int stride[], int w,int h,int x,int y)
|
|
224 {
|
2293
|
225 yuv2rgb(yuv_buffer, image[0], image[1], image[2], w, h,
|
|
226 image_width * ((video_mode_info.BitsPerPixel+7)/8),
|
2244
|
227 stride[0], stride[1]);
|
2293
|
228 __vbeCopyData((uint8_t *)yuv_buffer);
|
2244
|
229 return 0;
|
|
230 }
|
|
231
|
|
232 static void draw_osd(void)
|
|
233 {
|
|
234 /* nothing to do for now */
|
|
235 }
|
|
236
|
|
237 static void flip_page(void)
|
|
238 {
|
|
239 /*Is not required*/
|
|
240 }
|
|
241
|
|
242 /* is called for rgb only */
|
|
243 static uint32_t draw_frame(uint8_t *src[])
|
|
244 {
|
|
245 __vbeCopyData(src[0]);
|
|
246 return 0;
|
|
247 }
|
|
248
|
|
249 static uint32_t query_format(uint32_t format)
|
|
250 {
|
|
251 uint32_t retval;
|
|
252 switch(format)
|
|
253 {
|
|
254 #if 0
|
|
255 case IMGFMT_YV12:
|
|
256 case IMGFMT_I420:
|
|
257 case IMGFMT_IYUV:
|
|
258 #endif
|
|
259 case IMGFMT_RGB8:
|
|
260 case IMGFMT_RGB15:
|
|
261 case IMGFMT_RGB16:
|
|
262 case IMGFMT_RGB24:
|
|
263 case IMGFMT_RGB32:
|
|
264 case IMGFMT_BGR8:
|
|
265 case IMGFMT_BGR15:
|
|
266 case IMGFMT_BGR16:
|
|
267 case IMGFMT_BGR24:
|
|
268 case IMGFMT_BGR32:
|
|
269 retval = 1; break;
|
|
270 default:
|
|
271 if(verbose)
|
|
272 printf("vo_vesa: unknown format: %x = %s\n",format,vo_format_name(format));
|
|
273 retval = 0;
|
|
274 }
|
|
275 return retval;
|
|
276 }
|
|
277
|
2293
|
278 static char *model2str(unsigned char type)
|
|
279 {
|
|
280 char *retval;
|
|
281 switch(type)
|
|
282 {
|
|
283 case memText: retval = "Text"; break;
|
|
284 case memCGA: retval="CGA"; break;
|
|
285 case memHercules: retval="Hercules"; break;
|
|
286 case memPL: retval="Planar"; break;
|
|
287 case memPK: retval="Packed pixel"; break;
|
|
288 case mem256: retval="256"; break;
|
|
289 case memRGB: retval="Direct color RGB"; break;
|
|
290 case memYUV: retval="Direct color YUV"; break;
|
|
291 default: retval="Unknown"; break;
|
|
292 }
|
|
293 return retval;
|
|
294 }
|
|
295
|
2244
|
296 /* fullscreen:
|
|
297 * bit 0 (0x01) means fullscreen (-fs)
|
|
298 * bit 1 (0x02) means mode switching (-vm)
|
|
299 * bit 2 (0x04) enables software scaling (-zoom)
|
|
300 * bit 3 (0x08) enables flipping (-flip)
|
|
301 */
|
|
302 static uint32_t
|
|
303 init(uint32_t width, uint32_t height, uint32_t d_width, uint32_t d_height, uint32_t fullscreen, char *title, uint32_t format)
|
|
304 {
|
|
305 struct VbeInfoBlock vib;
|
|
306 struct VesaModeInfoBlock vmib;
|
|
307 size_t i,num_modes;
|
|
308 unsigned short *mode_ptr,win_seg;
|
|
309 unsigned bpp,best_x = UINT_MAX,best_y=UINT_MAX,best_mode_idx = UINT_MAX;
|
|
310 int err;
|
|
311 image_width = width;
|
|
312 image_height = height;
|
|
313 if(fullscreen & (0x1|0x4|0x8))
|
|
314 {
|
|
315 printf("vo_vesa: switches: -fs, -zoom, -flip are not supported\n");
|
|
316 }
|
|
317 if((err=vbeInit()) != VBE_OK) { PRINT_VBE_ERR("vbeInit",err); return -1; }
|
|
318 memcpy(vib.VESASignature,"VBE2",4);
|
|
319 if((err=vbeGetControllerInfo(&vib)) != VBE_OK)
|
|
320 {
|
|
321 PRINT_VBE_ERR("vbeGetControllerInfo",err);
|
|
322 printf("vo_vesa: possible reason: No VBE2 BIOS found\n");
|
|
323 return -1;
|
|
324 }
|
|
325 /* Print general info here */
|
|
326 printf("vo_vesa: Found VESA VBE BIOS Version %x.%x Revision: %x\n",
|
|
327 (int)(vib.VESAVersion >> 8) & 0xff,
|
|
328 (int)(vib.VESAVersion & 0xff),
|
|
329 (int)(vib.OemSoftwareRev & 0xffff));
|
2255
|
330 printf("vo_vesa: Video memory: %u Kb\n",vib.TotalMemory*64);
|
|
331 printf("vo_vesa: VESA Capabilities: %s %s %s %s %s\n"
|
|
332 ,vib.Capabilities & VBE_DAC_8BIT ? "8-bit DAC," : "6-bit DAC,"
|
|
333 ,vib.Capabilities & VBE_NONVGA_CRTC ? "non-VGA CRTC,":"VGA CRTC,"
|
|
334 ,vib.Capabilities & VBE_SNOWED_RAMDAC ? "snowed RAMDAC,":"normal RAMDAC,"
|
|
335 ,vib.Capabilities & VBE_STEREOSCOPIC ? "stereoscopic,":"no stereoscopic,"
|
|
336 ,vib.Capabilities & VBE_STEREO_EVC ? "Stereo EVC":"no stereo");
|
|
337 printf("vo_vesa: !!! Below will be printed OEM info. !!!\n");
|
|
338 printf("vo_vesa: You should watch 5 OEM related lines below else you've broken vm86\n");
|
2244
|
339 printf("vo_vesa: OEM info: %s\n",vib.OemStringPtr);
|
2255
|
340 printf("vo_vesa: OEM Revision: %x\n",vib.OemSoftwareRev);
|
|
341 printf("vo_vesa: OEM vendor: %s\n",vib.OemVendorNamePtr);
|
|
342 printf("vo_vesa: OEM Product Name: %s\n",vib.OemProductNamePtr);
|
|
343 printf("vo_vesa: OEM Product Rev: %s\n",vib.OemProductRevPtr);
|
|
344 printf("vo_vesa: Hint: To get workable TV-Out you should have plugged tv-connector in\n"
|
|
345 "vo_vesa: before booting PC since VESA BIOS initializes itself only during POST\n");
|
2244
|
346 /* Find best mode here */
|
|
347 num_modes = 0;
|
|
348 mode_ptr = vib.VideoModePtr;
|
|
349 while(*mode_ptr++ != 0xffff) num_modes++;
|
|
350 switch(format)
|
|
351 {
|
|
352 case IMGFMT_BGR8:
|
|
353 case IMGFMT_RGB8: bpp = 8; break;
|
|
354 case IMGFMT_BGR15:
|
|
355 case IMGFMT_RGB15: bpp = 15; break;
|
|
356 case IMGFMT_YV12:
|
|
357 case IMGFMT_I420:
|
|
358 case IMGFMT_IYUV:
|
|
359 yuv2rgb_init(video_mode_info.BitsPerPixel, MODE_RGB);
|
|
360 default:
|
|
361 case IMGFMT_BGR16:
|
|
362 case IMGFMT_RGB16: bpp = 16; break;
|
|
363 case IMGFMT_BGR24:
|
|
364 case IMGFMT_RGB24: bpp = 24; break;
|
|
365 case IMGFMT_BGR32:
|
|
366 case IMGFMT_RGB32: bpp = 32; break;
|
|
367 }
|
|
368 if(verbose)
|
|
369 {
|
|
370 printf("vo_vesa: Requested mode: %ux%u@%x bpp=%u\n",width,height,format,bpp);
|
|
371 printf("vo_vesa: Total modes found: %u\n",num_modes);
|
|
372 mode_ptr = vib.VideoModePtr;
|
|
373 printf("vo_vesa: Mode list:");
|
|
374 for(i = 0;i < num_modes;i++)
|
|
375 {
|
|
376 printf(" %04X",mode_ptr[i]);
|
|
377 }
|
|
378 printf("\nvo_vesa: Modes in detail:\n");
|
|
379 }
|
|
380 mode_ptr = vib.VideoModePtr;
|
|
381 for(i=0;i < num_modes;i++)
|
|
382 {
|
|
383 if((err=vbeGetModeInfo(mode_ptr[i],&vmib)) != VBE_OK)
|
|
384 {
|
|
385 PRINT_VBE_ERR("vbeGetModeInfo",err);
|
|
386 return -1;
|
|
387 }
|
2293
|
388 if(vmib.XResolution >= image_width &&
|
|
389 vmib.YResolution >= image_height &&
|
2244
|
390 (vmib.ModeAttributes & MOVIE_MODE) == MOVIE_MODE &&
|
|
391 vmib.BitsPerPixel == bpp &&
|
|
392 vmib.MemoryModel == memRGB)
|
|
393 {
|
2293
|
394 if(vmib.XResolution <= best_x &&
|
|
395 vmib.YResolution <= best_y)
|
2244
|
396 {
|
|
397 best_x = vmib.XResolution;
|
|
398 best_y = vmib.YResolution;
|
|
399 best_mode_idx = i;
|
|
400 }
|
|
401 }
|
|
402 if(verbose)
|
|
403 {
|
2293
|
404 printf("vo_vesa: Mode (%03u): mode=%04X %ux%u@%u attr=%x\n"
|
|
405 "vo_vesa: #planes=%u model=%u(%s) #pages=%u\n"
|
|
406 "vo_vesa: winA=%X(attr=%u) winB=%X(attr=%u) winSize=%u winGran=%u\n"
|
|
407 "vo_vesa: direct_color=%u DGA_phys_addr=%08X\n"
|
2244
|
408 ,i,mode_ptr[i],vmib.XResolution,vmib.YResolution,vmib.BitsPerPixel,vmib.ModeAttributes
|
2293
|
409 ,vmib.NumberOfPlanes,vmib.MemoryModel,model2str(vmib.MemoryModel),vmib.NumberOfImagePages
|
2244
|
410 ,vmib.WinASegment,vmib.WinAAttributes,vmib.WinBSegment,vmib.WinBAttributes,vmib.WinSize,vmib.WinGranularity
|
|
411 ,vmib.DirectColorModeInfo,vmib.PhysBasePtr);
|
|
412 if(vmib.MemoryModel == 6 || vmib.MemoryModel == 7)
|
|
413 printf("vo_vesa: direct_color_info = %u:%u:%u:%u\n"
|
|
414 ,vmib.RedMaskSize,vmib.GreenMaskSize,vmib.BlueMaskSize,vmib.RsvdMaskSize);
|
|
415 fflush(stdout);
|
|
416 }
|
|
417 }
|
|
418 if(best_mode_idx != UINT_MAX)
|
|
419 {
|
|
420 video_mode = vib.VideoModePtr[best_mode_idx];
|
|
421 printf("vo_vesa: Using VESA mode (%u) = %x\n",best_mode_idx,video_mode);
|
|
422 fflush(stdout);
|
|
423 if((err=vbeGetMode(&init_mode)) != VBE_OK)
|
|
424 {
|
|
425 PRINT_VBE_ERR("vbeGetMode",err);
|
|
426 return -1;
|
|
427 }
|
|
428 if(verbose) printf("vo_vesa: Initial video mode: %x\n",init_mode);
|
|
429 if((err=vbeGetModeInfo(video_mode,&video_mode_info)) != VBE_OK)
|
|
430 {
|
|
431 PRINT_VBE_ERR("vbeGetModeInfo",err);
|
|
432 return -1;
|
|
433 }
|
2293
|
434 if(!(yuv_buffer = malloc(video_mode_info.XResolution*video_mode_info.YResolution*4)))
|
|
435 {
|
|
436 printf("vo_vesa: Can't allocate temporary buffer\n");
|
|
437 return -1;
|
|
438 }
|
2244
|
439 if((video_mode_info.WinAAttributes & FRAME_MODE) == FRAME_MODE)
|
|
440 win.idx = 0; /* frame A */
|
|
441 else
|
|
442 if((video_mode_info.WinBAttributes & FRAME_MODE) == FRAME_MODE)
|
|
443 win.idx = 1; /* frame B */
|
|
444 else { printf("vo_vesa: Can't find usable frame of window\n"); return -1; }
|
|
445 if(!(win_seg = win.idx == 0 ? video_mode_info.WinASegment:video_mode_info.WinBSegment))
|
|
446 {
|
|
447 printf("vo_vesa: Can't find valid window address\n");
|
|
448 if(video_mode_info.ModeAttributes & MODE_ATTR_LINEAR)
|
|
449 printf("vo_vesa: Your BIOS supports DGA access which is not implemented for now\n");
|
|
450 return -1;
|
|
451 }
|
|
452 win.ptr = PhysToVirtSO(win_seg,0);
|
|
453 win.low = 0L;
|
|
454 win.high= video_mode_info.WinSize*1024;
|
|
455 x_offset = (video_mode_info.XResolution - image_width) / 2;
|
|
456 y_offset = (video_mode_info.YResolution - image_height) / 2;
|
|
457 if((err=vbeSaveState(&init_state)) != VBE_OK)
|
|
458 {
|
|
459 PRINT_VBE_ERR("vbeSaveState",err);
|
|
460 return -1;
|
|
461 }
|
|
462 if((err=vbeSetMode(video_mode,NULL)) != VBE_OK)
|
|
463 {
|
|
464 PRINT_VBE_ERR("vbeSetMode",err);
|
|
465 return -1;
|
|
466 }
|
|
467 /* Now we are in video mode!!!*/
|
|
468 if(verbose)
|
|
469 {
|
|
470 printf("vo_vesa: Graphics mode was activated\n");
|
|
471 fflush(stdout);
|
|
472 }
|
|
473 }
|
|
474 else
|
|
475 {
|
2255
|
476 printf("vo_vesa: Can't find mode for: %ux%u@%u\n",width,height,bpp);
|
2244
|
477 return -1;
|
|
478 }
|
|
479 if(verbose)
|
|
480 {
|
|
481 printf("vo_vesa: VESA initialization complete\n");
|
|
482 fflush(stdout);
|
|
483 }
|
|
484 if(verbose)
|
|
485 {
|
|
486 int x_res = video_mode_info.XResolution;
|
|
487 int y_res = video_mode_info.YResolution;
|
|
488 int x, y;
|
|
489
|
|
490 for (y = 0; y < y_res; ++y)
|
|
491 {
|
|
492 for (x = 0; x < x_res; ++x)
|
|
493 {
|
|
494 int r, g, b;
|
|
495 if ((x & 16) ^ (y & 16))
|
|
496 {
|
|
497 r = x * 255 / x_res;
|
|
498 g = y * 255 / y_res;
|
|
499 b = 255 - x * 255 / x_res;
|
|
500 }
|
|
501 else
|
|
502 {
|
|
503 r = 255 - x * 255 / x_res;
|
|
504 g = y * 255 / y_res;
|
|
505 b = 255 - y * 255 / y_res;
|
|
506 }
|
|
507
|
|
508 __vbeSetPixel(x, y, r, g, b);
|
|
509 }
|
|
510 }
|
|
511 }
|
|
512 return 0;
|
|
513 }
|
|
514
|
|
515 static const vo_info_t*
|
|
516 get_info(void)
|
|
517 {
|
|
518 return &vo_info;
|
|
519 }
|
|
520
|
|
521 static void
|
|
522 uninit(void)
|
|
523 {
|
|
524 vesa_term();
|
|
525 }
|
|
526
|
|
527
|
|
528 static void check_events(void)
|
|
529 {
|
|
530 /* Nothing to do */
|
|
531 }
|