285
|
1 /*
|
292
|
2 Video driver for SVGAlib - alpha, slow
|
285
|
3 by Zoltan Mark Vician <se7en@sch.bme.hu>
|
381
|
4 Code started: Mon Apr 1 23:25:47 2001
|
407
|
5
|
|
6 Uses HW acceleration if your card is supported by SVGAlib.
|
285
|
7 */
|
|
8
|
|
9 #include <stdio.h>
|
|
10 #include <stdlib.h>
|
|
11
|
|
12 #include <vga.h>
|
|
13 #include <vgagl.h>
|
|
14
|
|
15 #include "config.h"
|
|
16 #include "video_out.h"
|
|
17 #include "video_out_internal.h"
|
|
18
|
|
19 #include "yuv2rgb.h"
|
377
|
20 #include "mmx.h"
|
285
|
21
|
407
|
22 extern void rgb15to16_mmx(char* s0,char* d0,int count);
|
|
23
|
285
|
24 LIBVO_EXTERN(svga)
|
|
25
|
|
26 static vo_info_t vo_info = {
|
|
27 "SVGAlib",
|
|
28 "svga",
|
|
29 "Zoltan Mark Vician <se7en@sch.bme.hu>",
|
|
30 ""
|
|
31 };
|
|
32
|
|
33 // SVGAlib definitions
|
|
34
|
|
35 GraphicsContext *screen;
|
|
36 GraphicsContext *virt;
|
|
37
|
407
|
38 static uint8_t *scalebuf = NULL, *yuvbuf = NULL, *bppbuf = NULL;
|
285
|
39
|
|
40 static uint32_t orig_w, orig_h, maxw, maxh; // Width, height
|
377
|
41 static float scaling = 1.0;
|
285
|
42 static uint32_t x_pos, y_pos; // Position
|
|
43
|
|
44 // Order must not change!
|
|
45 #define _640x480x32K 0 // 17
|
|
46 #define _640x480x64K 1 // 18
|
|
47 #define _640x480x16M 2 // 19
|
|
48 #define _640x480x16M32 3 // 34
|
|
49 #define _800x600x32K 4 // 20
|
|
50 #define _800x600x64K 5 // 21
|
|
51 #define _800x600x16M 6 // 22
|
|
52 #define _800x600x16M32 7 // 35
|
|
53 #define _1024x768x32K 8 // 23
|
|
54 #define _1024x768x64K 9 // 24
|
|
55 #define _1024x768x16M 10 // 25
|
|
56 #define _1024x768x16M32 11 // 36
|
|
57 #define VID_MODE_NUM 12
|
|
58
|
|
59 static uint8_t vid_modes[VID_MODE_NUM];
|
290
|
60 static vid_mode_nums[VID_MODE_NUM] = {17,18,19,34,20,21,22,35,23,24,25,36};
|
285
|
61 static uint8_t vid_mode;
|
327
|
62 static uint8_t bpp;
|
285
|
63
|
|
64 static uint32_t pformat;
|
|
65
|
|
66 static uint8_t checked = 0;
|
407
|
67 static uint8_t bpp_conv = 0;
|
285
|
68
|
286
|
69 static void checksupportedmodes() {
|
285
|
70 int i;
|
|
71
|
|
72 checked = 1;
|
|
73 vga_init();
|
|
74 vga_disabledriverreport();
|
|
75 for (i = 0; i < VID_MODE_NUM; i++) {
|
290
|
76 if (vga_hasmode(vid_mode_nums[i]) > 0)
|
285
|
77 vid_modes[i] = 1;
|
|
78 else vid_modes[i] = 0;
|
|
79 }
|
|
80 }
|
|
81
|
|
82 static uint32_t init(uint32_t width, uint32_t height, uint32_t d_width,
|
|
83 uint32_t d_height, uint32_t fullscreen, char *title,
|
|
84 uint32_t format) {
|
387
|
85 uint32_t wid = (d_width > 0 ? d_width : width);
|
|
86
|
285
|
87 if (!checked) {
|
|
88 checksupportedmodes(); // Looking for available video modes
|
|
89 }
|
407
|
90
|
285
|
91 pformat = format;
|
411
|
92
|
|
93 // -bpp check
|
|
94 if (!vo_dbpp) {
|
|
95 if (format == IMGFMT_YV12) bpp = 32;
|
|
96 else bpp = format & 255;
|
|
97 } else {
|
|
98 bpp = vo_dbpp;
|
|
99 switch (bpp) {
|
|
100 case 32: if (!(vid_modes[_640x480x16M32] | vid_modes[_800x600x16M32] | vid_modes[_1024x768x16M32])) {
|
|
101 printf("vo_svga: %dbpp not supported by HW or SVGAlib",bpp);
|
|
102 return(1);
|
|
103 }
|
|
104 case 24: if (!(vid_modes[_640x480x16M] | vid_modes[_800x600x16M] | vid_modes[_1024x768x16M])) {
|
|
105 printf("vo_svga: %dbpp not supported by HW or SVGAlib",bpp);
|
|
106 return(1);
|
|
107 }
|
|
108 case 16: if (!(vid_modes[_640x480x64K] | vid_modes[_800x600x64K] | vid_modes[_1024x768x64K])) {
|
|
109 printf("vo_svga: %dbpp not supported by HW or SVGAlib",bpp);
|
|
110 return(1);
|
|
111 }
|
|
112 case 15: if (!(vid_modes[_640x480x32K] | vid_modes[_800x600x32K] | vid_modes[_1024x768x32K])) {
|
|
113 printf("vo_svga: %dbpp not supported by HW or SVGAlib",bpp);
|
|
114 return(1);
|
|
115 }
|
|
116 }
|
|
117 }
|
|
118
|
387
|
119 if (wid > 800)
|
285
|
120 switch (bpp) {
|
|
121 case 32: vid_mode = 36; break;
|
407
|
122 case 24: vid_mode = bpp_conv ? 36 : 25; bpp = 32; break;
|
285
|
123 case 16: vid_mode = 24; break;
|
407
|
124 case 15: vid_mode = bpp_conv ? 24 : 23; bpp = 16; break;
|
285
|
125 }
|
|
126 else
|
387
|
127 if (wid > 640)
|
285
|
128 switch (bpp) {
|
|
129 case 32: vid_mode = 35; break;
|
407
|
130 case 24: vid_mode = bpp_conv ? 35 : 22; bpp = 32; break;
|
285
|
131 case 16: vid_mode = 21; break;
|
407
|
132 case 15: vid_mode = bpp_conv ? 21 : 20; bpp = 16; break;
|
285
|
133 }
|
|
134 else
|
|
135 switch (bpp) {
|
|
136 case 32: vid_mode = 34; break;
|
407
|
137 case 24: vid_mode = bpp_conv ? 34 : 19; bpp = 32; break;
|
285
|
138 case 16: vid_mode = 18; break;
|
407
|
139 case 15: vid_mode = bpp_conv ? 18 : 17; bpp = 16; break;
|
285
|
140 }
|
407
|
141 if (bpp_conv)
|
|
142 bppbuf = malloc(maxw * maxh * BYTESPERPIXEL);
|
|
143 if (!bppbuf) {
|
|
144 printf("vo_svga: Not enough memory for buffering!");
|
|
145 uninit();
|
|
146 return (1);
|
|
147 }
|
|
148
|
|
149 vga_setlinearaddressing();
|
286
|
150 if (vga_setmode(vid_mode) == -1){
|
|
151 printf("vo_svga: vga_setmode(%d) failed.\n",vid_mode);
|
285
|
152 return(1); // error
|
286
|
153 }
|
|
154 if (gl_setcontextvga(vid_mode)){
|
|
155 printf("vo_svga: gl_setcontextvga(%d) failed.\n",vid_mode);
|
285
|
156 return(1); // error
|
286
|
157 }
|
285
|
158 screen = gl_allocatecontext();
|
|
159 gl_getcontext(screen);
|
286
|
160 if (gl_setcontextvgavirtual(vid_mode)){
|
|
161 printf("vo_svga: gl_setcontextvgavirtual(%d) failed.\n",vid_mode);
|
285
|
162 return(1); // error
|
286
|
163 }
|
285
|
164 virt = gl_allocatecontext();
|
|
165 gl_getcontext(virt);
|
|
166 gl_setcontext(virt);
|
|
167 gl_clearscreen(0);
|
|
168
|
|
169 orig_w = width;
|
|
170 orig_h = height;
|
343
|
171 if ((fullscreen & 0x04) && (WIDTH != orig_w)) {
|
292
|
172 if (((orig_w*1.0) / orig_h) < (4.0/3)) {
|
|
173 maxh = HEIGHT;
|
|
174 scaling = maxh / (orig_h * 1.0);
|
|
175 maxw = (uint32_t) (orig_w * scaling);
|
|
176 scalebuf = malloc(maxw * maxh * BYTESPERPIXEL);
|
407
|
177 if (!scalebuf) {
|
|
178 printf("vo_svga: Not enough memory for buffering!");
|
|
179 uninit();
|
|
180 return (1);
|
|
181 }
|
292
|
182 } else {
|
|
183 maxw = WIDTH;
|
|
184 scaling = maxw / (orig_w * 1.0);
|
|
185 maxh = (uint32_t) (orig_h * scaling);
|
|
186 scalebuf = malloc(maxw * maxh * BYTESPERPIXEL);
|
407
|
187 if (!scalebuf) {
|
|
188 printf("vo_svga: Not enough memory for buffering!");
|
|
189 uninit();
|
|
190 return (1);
|
|
191 }
|
292
|
192 }
|
285
|
193 } else {
|
|
194 maxw = orig_w;
|
|
195 maxh = orig_h;
|
|
196 }
|
|
197 x_pos = (WIDTH - maxw) / 2;
|
|
198 y_pos = (HEIGHT - maxh) / 2;
|
|
199
|
|
200 if (pformat == IMGFMT_YV12) {
|
|
201 yuv2rgb_init(bpp, MODE_RGB);
|
|
202 yuvbuf = malloc(maxw * maxh * BYTESPERPIXEL);
|
407
|
203 if (!yuvbuf) {
|
|
204 printf("vo_svga: Not enough memory for buffering!");
|
|
205 uninit();
|
|
206 return (1);
|
|
207 }
|
285
|
208 }
|
377
|
209
|
292
|
210 printf("SVGAlib resolution: %dx%d %dbpp - ", WIDTH, HEIGHT, bpp);
|
293
|
211 if (maxw != orig_w || maxh != orig_h) printf("Video scaled to: %dx%d\n",maxw,maxh);
|
285
|
212 else printf("No video scaling\n");
|
|
213
|
|
214 return (0);
|
|
215 }
|
|
216
|
|
217 static uint32_t query_format(uint32_t format) {
|
407
|
218 uint8_t res = 0;
|
|
219
|
|
220 if (!checked)
|
|
221 checksupportedmodes(); // Looking for available video modes
|
|
222 switch (format) {
|
|
223 case IMGFMT_RGB32:
|
|
224 case IMGFMT_BGR|32: {
|
|
225 return (vid_modes[_640x480x16M32] | vid_modes[_800x600x16M32] | vid_modes[_1024x768x16M32]);
|
|
226 }
|
|
227 case IMGFMT_RGB24:
|
|
228 case IMGFMT_BGR|24: {
|
|
229 res = vid_modes[_640x480x16M] | vid_modes[_800x600x16M] | vid_modes[_1024x768x16M];
|
|
230 if (!res) {
|
|
231 res = vid_modes[_640x480x16M32] | vid_modes[_800x600x16M32] | vid_modes[_1024x768x16M32];
|
|
232 bpp_conv = 1;
|
285
|
233 }
|
407
|
234 return (res);
|
|
235 }
|
|
236 case IMGFMT_RGB16:
|
|
237 case IMGFMT_BGR|16: {
|
|
238 return (vid_modes[_640x480x64K] | vid_modes[_800x600x64K] | vid_modes[_1024x768x64K]);
|
|
239 }
|
|
240 case IMGFMT_RGB15:
|
|
241 case IMGFMT_BGR|15: {
|
|
242 res = vid_modes[_640x480x32K] | vid_modes[_800x600x32K] | vid_modes[_1024x768x32K];
|
|
243 if (!res) {
|
|
244 res = vid_modes[_640x480x64K] | vid_modes[_800x600x64K] | vid_modes[_1024x768x64K];
|
|
245 bpp_conv = 1;
|
285
|
246 }
|
407
|
247 return (res);
|
285
|
248 }
|
407
|
249 case IMGFMT_YV12: return (1);
|
|
250 }
|
285
|
251 return (0);
|
|
252 }
|
|
253
|
|
254 static const vo_info_t* get_info(void) {
|
|
255 return (&vo_info);
|
|
256 }
|
|
257
|
|
258 static void draw_alpha(int x0, int y0, int w, int h, unsigned char *src,
|
|
259 unsigned char *srca, int stride) {
|
327
|
260 switch (bpp) {
|
|
261 case 32:
|
|
262 vo_draw_alpha_rgb32(w, h, src, srca, stride, virt->vbuf+4*(y0*WIDTH+x0), 4*WIDTH);
|
|
263 break;
|
|
264 case 24:
|
|
265 vo_draw_alpha_rgb24(w, h, src, srca, stride, virt->vbuf+3*(y0*WIDTH+x0), 3*WIDTH);
|
|
266 break;
|
|
267 case 16:
|
|
268 vo_draw_alpha_rgb16(w, h, src, srca, stride, virt->vbuf+2*(y0*WIDTH+x0), 2*WIDTH);
|
|
269 break;
|
|
270 case 15:
|
|
271 vo_draw_alpha_rgb15(w, h, src, srca, stride, virt->vbuf+2*(y0*WIDTH+x0), 2*WIDTH);
|
|
272 break;
|
|
273 }
|
285
|
274 }
|
|
275
|
|
276 static uint32_t draw_frame(uint8_t *src[]) {
|
|
277 if (pformat == IMGFMT_YV12) {
|
|
278 yuv2rgb(yuvbuf, src[0], src[1], src[2], orig_w, orig_h, orig_w * BYTESPERPIXEL, orig_w, orig_w / 2);
|
|
279 src[0] = yuvbuf;
|
|
280 }
|
|
281 if (scalebuf) {
|
|
282 gl_scalebox(orig_w, orig_h, src[0], maxw, maxh, scalebuf);
|
|
283 src[0] = scalebuf;
|
|
284 }
|
407
|
285 if (bpp_conv) {
|
|
286 uint16_t *src = (uint16_t *) src[0];
|
|
287 uint16_t *dest = (uint16_t *) bppbuf;
|
|
288 uint16_t *end;
|
|
289
|
|
290 switch(bpp) {
|
|
291 case 32:
|
|
292 end = src + (maxw * maxh * 2);
|
|
293 while (src < end) {
|
|
294 *dest++ = *src++;
|
|
295 (uint8_t *)dest = (uint8_t *)src;
|
|
296 *(((uint8_t *)dest)+1) = 0;
|
|
297 dest++;
|
|
298 src++;
|
|
299 }
|
|
300 case 16:
|
|
301 #ifdef HAVE_MMX
|
|
302 rgb15to16_mmx(src[0],bppbuf,maxw * maxh * 2);
|
|
303 #else
|
|
304 register uint16_t srcdata;
|
|
305
|
|
306 end = src + (maxw * maxh);
|
|
307 while (src < end) {
|
|
308 srcdata = *src++;
|
|
309 *dest++ = (srcdata & 0x1f) | ((srcdata & 0x7fe0) << 1);
|
|
310 }
|
|
311 #endif
|
|
312 }
|
|
313 src[0] = bppbuf;
|
|
314 }
|
285
|
315 gl_putbox(x_pos, y_pos, maxw, maxh, src[0]);
|
|
316 }
|
|
317
|
|
318 static uint32_t draw_slice(uint8_t *image[], int stride[],
|
|
319 int w, int h, int x, int y) {
|
|
320 uint8_t *src = yuvbuf;
|
377
|
321 uint32_t sw, sh;
|
|
322
|
|
323 emms();
|
|
324 sw = (uint32_t) (w * scaling);
|
|
325 sh = (uint32_t) (h * scaling);
|
285
|
326 yuv2rgb(yuvbuf, image[0], image[1], image[2], w, h, orig_w * BYTESPERPIXEL, stride[0], stride[1]);
|
|
327 if (scalebuf) {
|
377
|
328 gl_scalebox(w, h, yuvbuf, sw, sh, scalebuf);
|
285
|
329 src = scalebuf;
|
|
330 }
|
377
|
331 gl_putbox((int)(x * scaling) + x_pos, (int)(y * scaling) + y_pos, sw, sh, src);
|
285
|
332 }
|
|
333
|
|
334 static void flip_page(void) {
|
292
|
335 if (y_pos) {
|
|
336 gl_fillbox(0, 0, WIDTH, y_pos, 0);
|
|
337 gl_fillbox(0, HEIGHT - y_pos, WIDTH, y_pos, 0);
|
|
338 } else {
|
|
339 gl_fillbox(0, 0, x_pos, HEIGHT, 0);
|
|
340 gl_fillbox(WIDTH - x_pos, 0, x_pos, HEIGHT, 0);
|
327
|
341 }
|
285
|
342 vo_draw_text(WIDTH, HEIGHT, draw_alpha);
|
|
343 gl_copyscreen(screen);
|
|
344 }
|
|
345
|
|
346 static void check_events(void) {
|
|
347 }
|
|
348
|
|
349 static void uninit(void) {
|
|
350 gl_freecontext(screen);
|
|
351 gl_freecontext(virt);
|
|
352 vga_setmode(TEXT);
|
407
|
353 if (bppbuf)
|
|
354 free(bppbuf);
|
285
|
355 if (scalebuf)
|
|
356 free(scalebuf);
|
|
357 if (yuvbuf)
|
|
358 free(yuvbuf);
|
|
359 }
|
|
360 |