Blame view

hw/tcx.c 17.9 KB
1
/*
bellard authored
2
 * QEMU TCX Frame buffer
3
 *
bellard authored
4
 * Copyright (c) 2003-2005 Fabrice Bellard
5
 *
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 * THE SOFTWARE.
 */
pbrook authored
24
25
26
#include "hw.h"
#include "sun4m.h"
#include "console.h"
27
#include "pixel_ops.h"
28
29
30

#define MAXX 1024
#define MAXY 768
bellard authored
31
#define TCX_DAC_NREGS 16
32
33
34
#define TCX_THC_NREGS_8  0x081c
#define TCX_THC_NREGS_24 0x1000
#define TCX_TEC_NREGS    0x1000
35
36

typedef struct TCXState {
37
    target_phys_addr_t addr;
38
    DisplayState *ds;
39
    QEMUConsole *console;
bellard authored
40
    uint8_t *vram;
blueswir1 authored
41
42
43
    uint32_t *vram24, *cplane;
    ram_addr_t vram_offset, vram24_offset, cplane_offset;
    uint16_t width, height, depth;
bellard authored
44
    uint8_t r[256], g[256], b[256];
45
    uint32_t palette[256];
bellard authored
46
    uint8_t dac_index, dac_state;
47
48
} TCXState;
49
static void tcx_screen_dump(void *opaque, const char *filename);
blueswir1 authored
50
static void tcx24_screen_dump(void *opaque, const char *filename);
51
52
static void tcx_invalidate_display(void *opaque);
static void tcx24_invalidate_display(void *opaque);
53
54
55
56
57
58
59
60
61
62
63
static void update_palette_entries(TCXState *s, int start, int end)
{
    int i;
    for(i = start; i < end; i++) {
        switch(s->ds->depth) {
        default:
        case 8:
            s->palette[i] = rgb_to_pixel8(s->r[i], s->g[i], s->b[i]);
            break;
        case 15:
64
65
66
67
            if (s->ds->bgr)
                s->palette[i] = rgb_to_pixel15bgr(s->r[i], s->g[i], s->b[i]);
            else
                s->palette[i] = rgb_to_pixel15(s->r[i], s->g[i], s->b[i]);
68
69
            break;
        case 16:
70
71
72
73
            if (s->ds->bgr)
                s->palette[i] = rgb_to_pixel16bgr(s->r[i], s->g[i], s->b[i]);
            else
                s->palette[i] = rgb_to_pixel16(s->r[i], s->g[i], s->b[i]);
74
75
            break;
        case 32:
76
77
78
79
            if (s->ds->bgr)
                s->palette[i] = rgb_to_pixel32bgr(s->r[i], s->g[i], s->b[i]);
            else
                s->palette[i] = rgb_to_pixel32(s->r[i], s->g[i], s->b[i]);
80
81
82
            break;
        }
    }
83
84
85
86
    if (s->depth == 24)
        tcx24_invalidate_display(s);
    else
        tcx_invalidate_display(s);
87
88
}
89
static void tcx_draw_line32(TCXState *s1, uint8_t *d,
blueswir1 authored
90
                            const uint8_t *s, int width)
91
{
bellard authored
92
93
    int x;
    uint8_t val;
94
    uint32_t *p = (uint32_t *)d;
bellard authored
95
96

    for(x = 0; x < width; x++) {
blueswir1 authored
97
        val = *s++;
98
        *p++ = s1->palette[val];
bellard authored
99
    }
100
101
}
102
static void tcx_draw_line16(TCXState *s1, uint8_t *d,
blueswir1 authored
103
                            const uint8_t *s, int width)
bellard authored
104
105
106
{
    int x;
    uint8_t val;
107
    uint16_t *p = (uint16_t *)d;
bellard authored
108
bellard authored
109
    for(x = 0; x < width; x++) {
blueswir1 authored
110
        val = *s++;
111
        *p++ = s1->palette[val];
bellard authored
112
113
114
    }
}
115
static void tcx_draw_line8(TCXState *s1, uint8_t *d,
blueswir1 authored
116
                           const uint8_t *s, int width)
117
{
bellard authored
118
119
120
121
    int x;
    uint8_t val;

    for(x = 0; x < width; x++) {
blueswir1 authored
122
        val = *s++;
123
        *d++ = s1->palette[val];
124
125
126
    }
}
blueswir1 authored
127
128
129
130
131
/*
  XXX Could be much more optimal:
  * detect if line/page/whole screen is in 24 bit mode
  * if destination is also BGR, use memcpy
  */
blueswir1 authored
132
133
134
135
136
static inline void tcx24_draw_line32(TCXState *s1, uint8_t *d,
                                     const uint8_t *s, int width,
                                     const uint32_t *cplane,
                                     const uint32_t *s24)
{
blueswir1 authored
137
138
    int x, bgr, r, g, b;
    uint8_t val, *p8;
blueswir1 authored
139
140
141
    uint32_t *p = (uint32_t *)d;
    uint32_t dval;
blueswir1 authored
142
    bgr = s1->ds->bgr;
blueswir1 authored
143
    for(x = 0; x < width; x++, s++, s24++) {
blueswir1 authored
144
145
146
147
148
149
150
151
152
153
154
        if ((be32_to_cpu(*cplane++) & 0xff000000) == 0x03000000) {
            // 24-bit direct, BGR order
            p8 = (uint8_t *)s24;
            p8++;
            b = *p8++;
            g = *p8++;
            r = *p8++;
            if (bgr)
                dval = rgb_to_pixel32bgr(r, g, b);
            else
                dval = rgb_to_pixel32(r, g, b);
blueswir1 authored
155
156
157
158
159
160
161
162
        } else {
            val = *s;
            dval = s1->palette[val];
        }
        *p++ = dval;
    }
}
blueswir1 authored
163
static inline int check_dirty(ram_addr_t page, ram_addr_t page24,
blueswir1 authored
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
                              ram_addr_t cpage)
{
    int ret;
    unsigned int off;

    ret = cpu_physical_memory_get_dirty(page, VGA_DIRTY_FLAG);
    for (off = 0; off < TARGET_PAGE_SIZE * 4; off += TARGET_PAGE_SIZE) {
        ret |= cpu_physical_memory_get_dirty(page24 + off, VGA_DIRTY_FLAG);
        ret |= cpu_physical_memory_get_dirty(cpage + off, VGA_DIRTY_FLAG);
    }
    return ret;
}

static inline void reset_dirty(TCXState *ts, ram_addr_t page_min,
                               ram_addr_t page_max, ram_addr_t page24,
                              ram_addr_t cpage)
{
    cpu_physical_memory_reset_dirty(page_min, page_max + TARGET_PAGE_SIZE,
                                    VGA_DIRTY_FLAG);
    page_min -= ts->vram_offset;
    page_max -= ts->vram_offset;
    cpu_physical_memory_reset_dirty(page24 + page_min * 4,
                                    page24 + page_max * 4 + TARGET_PAGE_SIZE,
                                    VGA_DIRTY_FLAG);
    cpu_physical_memory_reset_dirty(cpage + page_min * 4,
                                    cpage + page_max * 4 + TARGET_PAGE_SIZE,
                                    VGA_DIRTY_FLAG);
}
bellard authored
193
194
/* Fixed line length 1024 allows us to do nice tricks not possible on
   VGA... */
195
static void tcx_update_display(void *opaque)
196
{
bellard authored
197
    TCXState *ts = opaque;
198
199
    ram_addr_t page, page_min, page_max;
    int y, y_start, dd, ds;
bellard authored
200
    uint8_t *d, *s;
201
    void (*f)(TCXState *s1, uint8_t *dst, const uint8_t *src, int width);
bellard authored
202
203

    if (ts->ds->depth == 0)
blueswir1 authored
204
        return;
bellard authored
205
    page = ts->vram_offset;
bellard authored
206
    y_start = -1;
207
208
    page_min = 0xffffffff;
    page_max = 0;
bellard authored
209
    d = ts->ds->data;
bellard authored
210
    s = ts->vram;
bellard authored
211
212
213
214
215
    dd = ts->ds->linesize;
    ds = 1024;

    switch (ts->ds->depth) {
    case 32:
blueswir1 authored
216
217
        f = tcx_draw_line32;
        break;
218
219
    case 15:
    case 16:
blueswir1 authored
220
221
        f = tcx_draw_line16;
        break;
bellard authored
222
223
    default:
    case 8:
blueswir1 authored
224
225
        f = tcx_draw_line8;
        break;
bellard authored
226
    case 0:
blueswir1 authored
227
        return;
bellard authored
228
    }
229
bellard authored
230
    for(y = 0; y < ts->height; y += 4, page += TARGET_PAGE_SIZE) {
blueswir1 authored
231
232
        if (cpu_physical_memory_get_dirty(page, VGA_DIRTY_FLAG)) {
            if (y_start < 0)
bellard authored
233
234
235
236
237
                y_start = y;
            if (page < page_min)
                page_min = page;
            if (page > page_max)
                page_max = page;
blueswir1 authored
238
239
240
241
242
243
244
245
246
247
248
249
250
            f(ts, d, s, ts->width);
            d += dd;
            s += ds;
            f(ts, d, s, ts->width);
            d += dd;
            s += ds;
            f(ts, d, s, ts->width);
            d += dd;
            s += ds;
            f(ts, d, s, ts->width);
            d += dd;
            s += ds;
        } else {
bellard authored
251
252
            if (y_start >= 0) {
                /* flush to display */
253
                dpy_update(ts->ds, 0, y_start,
bellard authored
254
                           ts->width, y - y_start);
bellard authored
255
256
                y_start = -1;
            }
blueswir1 authored
257
258
259
            d += dd * 4;
            s += ds * 4;
        }
bellard authored
260
261
    }
    if (y_start >= 0) {
blueswir1 authored
262
263
264
        /* flush to display */
        dpy_update(ts->ds, 0, y_start,
                   ts->width, y - y_start);
bellard authored
265
266
    }
    /* reset modified pages */
267
    if (page_min <= page_max) {
bellard authored
268
269
        cpu_physical_memory_reset_dirty(page_min, page_max + TARGET_PAGE_SIZE,
                                        VGA_DIRTY_FLAG);
bellard authored
270
    }
271
272
}
blueswir1 authored
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
static void tcx24_update_display(void *opaque)
{
    TCXState *ts = opaque;
    ram_addr_t page, page_min, page_max, cpage, page24;
    int y, y_start, dd, ds;
    uint8_t *d, *s;
    uint32_t *cptr, *s24;

    if (ts->ds->depth != 32)
            return;
    page = ts->vram_offset;
    page24 = ts->vram24_offset;
    cpage = ts->cplane_offset;
    y_start = -1;
    page_min = 0xffffffff;
    page_max = 0;
    d = ts->ds->data;
    s = ts->vram;
    s24 = ts->vram24;
    cptr = ts->cplane;
    dd = ts->ds->linesize;
    ds = 1024;

    for(y = 0; y < ts->height; y += 4, page += TARGET_PAGE_SIZE,
            page24 += TARGET_PAGE_SIZE, cpage += TARGET_PAGE_SIZE) {
blueswir1 authored
298
        if (check_dirty(page, page24, cpage)) {
blueswir1 authored
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
            if (y_start < 0)
                y_start = y;
            if (page < page_min)
                page_min = page;
            if (page > page_max)
                page_max = page;
            tcx24_draw_line32(ts, d, s, ts->width, cptr, s24);
            d += dd;
            s += ds;
            cptr += ds;
            s24 += ds;
            tcx24_draw_line32(ts, d, s, ts->width, cptr, s24);
            d += dd;
            s += ds;
            cptr += ds;
            s24 += ds;
            tcx24_draw_line32(ts, d, s, ts->width, cptr, s24);
            d += dd;
            s += ds;
            cptr += ds;
            s24 += ds;
            tcx24_draw_line32(ts, d, s, ts->width, cptr, s24);
            d += dd;
            s += ds;
            cptr += ds;
            s24 += ds;
        } else {
            if (y_start >= 0) {
                /* flush to display */
                dpy_update(ts->ds, 0, y_start,
                           ts->width, y - y_start);
                y_start = -1;
            }
            d += dd * 4;
            s += ds * 4;
            cptr += ds * 4;
            s24 += ds * 4;
        }
    }
    if (y_start >= 0) {
        /* flush to display */
        dpy_update(ts->ds, 0, y_start,
                   ts->width, y - y_start);
    }
    /* reset modified pages */
    if (page_min <= page_max) {
        reset_dirty(ts, page_min, page_max, page24, cpage);
    }
}
349
static void tcx_invalidate_display(void *opaque)
350
{
bellard authored
351
352
353
354
    TCXState *s = opaque;
    int i;

    for (i = 0; i < MAXX*MAXY; i += TARGET_PAGE_SIZE) {
blueswir1 authored
355
        cpu_physical_memory_set_dirty(s->vram_offset + i);
bellard authored
356
    }
357
358
}
blueswir1 authored
359
360
361
362
363
364
365
366
367
368
369
370
static void tcx24_invalidate_display(void *opaque)
{
    TCXState *s = opaque;
    int i;

    tcx_invalidate_display(s);
    for (i = 0; i < MAXX*MAXY * 4; i += TARGET_PAGE_SIZE) {
        cpu_physical_memory_set_dirty(s->vram24_offset + i);
        cpu_physical_memory_set_dirty(s->cplane_offset + i);
    }
}
bellard authored
371
static void tcx_save(QEMUFile *f, void *opaque)
372
373
{
    TCXState *s = opaque;
374
bellard authored
375
376
    qemu_put_be16s(f, (uint16_t *)&s->height);
    qemu_put_be16s(f, (uint16_t *)&s->width);
blueswir1 authored
377
    qemu_put_be16s(f, (uint16_t *)&s->depth);
bellard authored
378
379
380
    qemu_put_buffer(f, s->r, 256);
    qemu_put_buffer(f, s->g, 256);
    qemu_put_buffer(f, s->b, 256);
bellard authored
381
382
    qemu_put_8s(f, &s->dac_index);
    qemu_put_8s(f, &s->dac_state);
383
384
}
bellard authored
385
static int tcx_load(QEMUFile *f, void *opaque, int version_id)
386
{
bellard authored
387
    TCXState *s = opaque;
blueswir1 authored
388
389
390
    uint32_t dummy;

    if (version_id != 3 && version_id != 4)
bellard authored
391
392
        return -EINVAL;
blueswir1 authored
393
394
395
396
397
    if (version_id == 3) {
        qemu_get_be32s(f, (uint32_t *)&dummy);
        qemu_get_be32s(f, (uint32_t *)&dummy);
        qemu_get_be32s(f, (uint32_t *)&dummy);
    }
bellard authored
398
399
    qemu_get_be16s(f, (uint16_t *)&s->height);
    qemu_get_be16s(f, (uint16_t *)&s->width);
blueswir1 authored
400
    qemu_get_be16s(f, (uint16_t *)&s->depth);
bellard authored
401
402
403
    qemu_get_buffer(f, s->r, 256);
    qemu_get_buffer(f, s->g, 256);
    qemu_get_buffer(f, s->b, 256);
bellard authored
404
405
    qemu_get_8s(f, &s->dac_index);
    qemu_get_8s(f, &s->dac_state);
406
    update_palette_entries(s, 0, 256);
407
408
409
410
    if (s->depth == 24)
        tcx24_invalidate_display(s);
    else
        tcx_invalidate_display(s);
411
bellard authored
412
    return 0;
413
414
}
bellard authored
415
static void tcx_reset(void *opaque)
416
{
bellard authored
417
418
419
420
421
422
423
    TCXState *s = opaque;

    /* Initialize palette */
    memset(s->r, 0, 256);
    memset(s->g, 0, 256);
    memset(s->b, 0, 256);
    s->r[255] = s->g[255] = s->b[255] = 255;
424
    update_palette_entries(s, 0, 256);
bellard authored
425
    memset(s->vram, 0, MAXX*MAXY);
blueswir1 authored
426
427
    cpu_physical_memory_reset_dirty(s->vram_offset, s->vram_offset +
                                    MAXX * MAXY * (1 + 4 + 4), VGA_DIRTY_FLAG);
bellard authored
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
    s->dac_index = 0;
    s->dac_state = 0;
}

static uint32_t tcx_dac_readl(void *opaque, target_phys_addr_t addr)
{
    return 0;
}

static void tcx_dac_writel(void *opaque, target_phys_addr_t addr, uint32_t val)
{
    TCXState *s = opaque;
    uint32_t saddr;

    saddr = (addr & (TCX_DAC_NREGS - 1)) >> 2;
    switch (saddr) {
    case 0:
blueswir1 authored
445
446
447
        s->dac_index = val >> 24;
        s->dac_state = 0;
        break;
bellard authored
448
    case 1:
blueswir1 authored
449
450
451
        switch (s->dac_state) {
        case 0:
            s->r[s->dac_index] = val >> 24;
452
            update_palette_entries(s, s->dac_index, s->dac_index + 1);
blueswir1 authored
453
454
455
456
            s->dac_state++;
            break;
        case 1:
            s->g[s->dac_index] = val >> 24;
457
            update_palette_entries(s, s->dac_index, s->dac_index + 1);
blueswir1 authored
458
459
460
461
            s->dac_state++;
            break;
        case 2:
            s->b[s->dac_index] = val >> 24;
462
            update_palette_entries(s, s->dac_index, s->dac_index + 1);
blueswir1 authored
463
            s->dac_index = (s->dac_index + 1) & 255; // Index autoincrement
blueswir1 authored
464
465
466
467
468
        default:
            s->dac_state = 0;
            break;
        }
        break;
bellard authored
469
    default:
blueswir1 authored
470
        break;
bellard authored
471
472
    }
    return;
473
474
}
bellard authored
475
static CPUReadMemoryFunc *tcx_dac_read[3] = {
476
477
    NULL,
    NULL,
bellard authored
478
479
480
481
    tcx_dac_readl,
};

static CPUWriteMemoryFunc *tcx_dac_write[3] = {
482
483
    NULL,
    NULL,
bellard authored
484
485
486
    tcx_dac_writel,
};
487
488
489
490
491
492
493
494
495
496
497
static uint32_t tcx_dummy_readl(void *opaque, target_phys_addr_t addr)
{
    return 0;
}

static void tcx_dummy_writel(void *opaque, target_phys_addr_t addr,
                             uint32_t val)
{
}

static CPUReadMemoryFunc *tcx_dummy_read[3] = {
498
499
    NULL,
    NULL,
500
501
502
503
    tcx_dummy_readl,
};

static CPUWriteMemoryFunc *tcx_dummy_write[3] = {
504
505
    NULL,
    NULL,
506
507
508
    tcx_dummy_writel,
};
509
void tcx_init(DisplayState *ds, target_phys_addr_t addr, uint8_t *vram_base,
blueswir1 authored
510
511
              unsigned long vram_offset, int vram_size, int width, int height,
              int depth)
512
513
{
    TCXState *s;
514
    int io_memory, dummy_memory;
blueswir1 authored
515
    int size;
516
517
518

    s = qemu_mallocz(sizeof(TCXState));
    if (!s)
519
        return;
520
    s->ds = ds;
bellard authored
521
    s->addr = addr;
bellard authored
522
    s->vram_offset = vram_offset;
bellard authored
523
524
    s->width = width;
    s->height = height;
blueswir1 authored
525
526
527
528
529
    s->depth = depth;

    // 8-bit plane
    s->vram = vram_base;
    size = vram_size;
530
    cpu_register_physical_memory(addr + 0x00800000ULL, size, vram_offset);
blueswir1 authored
531
532
    vram_offset += size;
    vram_base += size;
bellard authored
533
bellard authored
534
    io_memory = cpu_register_io_memory(0, tcx_dac_read, tcx_dac_write, s);
blueswir1 authored
535
536
    cpu_register_physical_memory(addr + 0x00200000ULL, TCX_DAC_NREGS,
                                 io_memory);
blueswir1 authored
537
538
539
    dummy_memory = cpu_register_io_memory(0, tcx_dummy_read, tcx_dummy_write,
                                          s);
540
    cpu_register_physical_memory(addr + 0x00700000ULL, TCX_TEC_NREGS,
541
                                 dummy_memory);
blueswir1 authored
542
543
544
545
546
    if (depth == 24) {
        // 24-bit plane
        size = vram_size * 4;
        s->vram24 = (uint32_t *)vram_base;
        s->vram24_offset = vram_offset;
547
        cpu_register_physical_memory(addr + 0x02000000ULL, size, vram_offset);
blueswir1 authored
548
549
550
551
552
553
554
        vram_offset += size;
        vram_base += size;

        // Control plane
        size = vram_size * 4;
        s->cplane = (uint32_t *)vram_base;
        s->cplane_offset = vram_offset;
555
        cpu_register_physical_memory(addr + 0x0a000000ULL, size, vram_offset);
556
557
558
        s->console = graphic_console_init(s->ds, tcx24_update_display,
                                          tcx24_invalidate_display,
                                          tcx24_screen_dump, NULL, s);
blueswir1 authored
559
    } else {
560
        cpu_register_physical_memory(addr + 0x00300000ULL, TCX_THC_NREGS_8,
561
                                     dummy_memory);
562
563
564
        s->console = graphic_console_init(s->ds, tcx_update_display,
                                          tcx_invalidate_display,
                                          tcx_screen_dump, NULL, s);
blueswir1 authored
565
    }
566
    // NetBSD writes here even with 8-bit display
567
    cpu_register_physical_memory(addr + 0x00301000ULL, TCX_THC_NREGS_24,
568
                                 dummy_memory);
bellard authored
569
blueswir1 authored
570
    register_savevm("tcx", addr, 4, tcx_save, tcx_load, s);
bellard authored
571
572
    qemu_register_reset(tcx_reset, s);
    tcx_reset(s);
573
    qemu_console_resize(s->console, width, height);
574
575
}
576
static void tcx_screen_dump(void *opaque, const char *filename)
bellard authored
577
{
bellard authored
578
    TCXState *s = opaque;
bellard authored
579
    FILE *f;
bellard authored
580
    uint8_t *d, *d1, v;
bellard authored
581
582
583
584
    int y, x;

    f = fopen(filename, "wb");
    if (!f)
bellard authored
585
        return;
bellard authored
586
587
588
    fprintf(f, "P6\n%d %d\n%d\n", s->width, s->height, 255);
    d1 = s->vram;
    for(y = 0; y < s->height; y++) {
bellard authored
589
        d = d1;
bellard authored
590
        for(x = 0; x < s->width; x++) {
bellard authored
591
            v = *d;
bellard authored
592
593
594
            fputc(s->r[v], f);
            fputc(s->g[v], f);
            fputc(s->b[v], f);
bellard authored
595
596
            d++;
        }
bellard authored
597
        d1 += MAXX;
bellard authored
598
599
600
601
602
    }
    fclose(f);
    return;
}
blueswir1 authored
603
604
605
606
607
608
609
static void tcx24_screen_dump(void *opaque, const char *filename)
{
    TCXState *s = opaque;
    FILE *f;
    uint8_t *d, *d1, v;
    uint32_t *s24, *cptr, dval;
    int y, x;
bellard authored
610
blueswir1 authored
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
    f = fopen(filename, "wb");
    if (!f)
        return;
    fprintf(f, "P6\n%d %d\n%d\n", s->width, s->height, 255);
    d1 = s->vram;
    s24 = s->vram24;
    cptr = s->cplane;
    for(y = 0; y < s->height; y++) {
        d = d1;
        for(x = 0; x < s->width; x++, d++, s24++) {
            if ((*cptr++ & 0xff000000) == 0x03000000) { // 24-bit direct
                dval = *s24 & 0x00ffffff;
                fputc((dval >> 16) & 0xff, f);
                fputc((dval >> 8) & 0xff, f);
                fputc(dval & 0xff, f);
            } else {
                v = *d;
                fputc(s->r[v], f);
                fputc(s->g[v], f);
                fputc(s->b[v], f);
            }
        }
        d1 += MAXX;
    }
    fclose(f);
    return;
}