← Back to branch summary

~ubuntu-branches/ubuntu/precise/vice/precise

« back to all changes in this revision

Viewing changes to src/arch/unix/macosx/cocoa/video.m

  • Committer: Bazaar Package Importer
  • Author(s): Laszlo Boszormenyi (GCS)
  • Date: 2010-02-11 18:30:16 UTC
  • mfrom: (1.1.8 upstream) (9.2.2 sid)
  • Revision ID: james.westby@ubuntu.com-20100211183016-f6n8usn3tzp0u6dp
Tags: 2.2.dfsg-1
* New upstream release, C64 DTV is included so update package description
  and add it to the menu.
* Drop patch fixing build failure with gcc-4.4 , applied upstream.
* Fix some lintian problems and clean up debian/rules .

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/arch/unix/macosx/cocoa/video.m
27
27
 
28
28
#include "videoarch.h"
29
29
#include "palette.h"
 
30
#include "resources.h"
 
31
#include "cmdline.h"
 
32
#include "translate.h"
 
33
#include "log.h"
30
34
 
31
35
#import "vicemachinenotifier.h"
32
36
#import "vicemachine.h"
33
37
#import "vicewindow.h"
34
38
 
35
 
// VICE Video Resources
 
39
// Mac Video Log
 
40
log_t video_log = LOG_ERR;
 
41
 
 
42
// video parameter struct
 
43
static video_param_t video_param;
 
44
 
 
45
// ---------- VICE Video Resources ----------
 
46
 
 
47
/* tell all canvases to reconfigure after setting new video_param resources */
 
48
static void video_reconfigure()
 
49
{
 
50
    int numCanvases = [theVICEMachine getNumCanvases];
 
51
    int i;
 
52
    
 
53
    for(i=0;i<numCanvases;i++) {
 
54
        video_canvas_t *canvas = [theVICEMachine getCanvasForId:i];
 
55
 
 
56
        NSData *data = [NSData dataWithBytes:&canvas length:sizeof(video_canvas_t *)];
 
57
 
 
58
        // call UI thread to reconfigure canvas
 
59
        [[theVICEMachine app] reconfigureCanvas:data];
 
60
    }
 
61
}
 
62
 
 
63
static int set_sync_draw_mode(int val, void *param)
 
64
{
 
65
    if((val < 0) || (val > SYNC_DRAW_LAST))
 
66
        return;
 
67
    
 
68
    if(val != video_param.sync_draw_mode) {
 
69
        video_param.sync_draw_mode = val;
 
70
        video_reconfigure();
 
71
    }
 
72
}
 
73
 
 
74
static int set_sync_draw_buffers(int val, void *param)
 
75
{
 
76
    if(val < 1)
 
77
        val = 0;
 
78
    else if(val > 16)
 
79
        val = 16;
 
80
 
 
81
    if(val != video_param.sync_draw_buffers) {            
 
82
        video_param.sync_draw_buffers = val;
 
83
        video_reconfigure();
 
84
    }
 
85
}
 
86
 
 
87
static int set_sync_draw_flicker_fix(int val, void *param)
 
88
{
 
89
    if(val)
 
90
        val = 1;
 
91
    else
 
92
        val = 0;
 
93
 
 
94
    if(val != video_param.sync_draw_flicker_fix) {            
 
95
        video_param.sync_draw_flicker_fix = val;
 
96
        video_reconfigure();
 
97
    }
 
98
}
 
99
 
 
100
static resource_int_t resources_int[] =
 
101
{
 
102
    { "SyncDrawMode", 0, RES_EVENT_NO, NULL,
 
103
       &video_param.sync_draw_mode, set_sync_draw_mode, NULL },
 
104
    { "SyncDrawBuffers", 0, RES_EVENT_NO, NULL,
 
105
       &video_param.sync_draw_buffers, set_sync_draw_buffers, NULL },
 
106
    { "SyncDrawFlickerFix", 0, RES_EVENT_NO, NULL,
 
107
       &video_param.sync_draw_flicker_fix, set_sync_draw_flicker_fix, NULL },
 
108
    { NULL }
 
109
 };
36
110
 
37
111
int video_arch_resources_init(void)
38
112
{
39
 
    return 0;
 
113
    return resources_register_int(resources_int);
40
114
}
41
115
 
42
116
void video_arch_resources_shutdown(void)
43
117
{
44
118
}
45
119
 
46
 
// VICE interface:
 
120
// ---------- VICE Video Command Line ----------
 
121
 
 
122
static const cmdline_option_t cmdline_options[] = {
 
123
    { "-syncdrawmode", SET_RESOURCE, 1,
 
124
      NULL, NULL, "SyncDrawMode", NULL,
 
125
      USE_PARAM_STRING, USE_DESCRIPTION_STRING,
 
126
      IDCLS_UNUSED, IDCLS_UNUSED,
 
127
      "<0-3>", T_("Enable draw synchronization to vertical blank") },
 
128
    { "-syncdrawbuffers", SET_RESOURCE, 1,
 
129
      NULL, NULL, "SyncDrawBuffers", NULL,
 
130
      USE_PARAM_STRING, USE_DESCRIPTION_STRING,
 
131
      IDCLS_UNUSED, IDCLS_UNUSED,
 
132
      "<0-8>", T_("Set number of buffers used for sync draw (0=use default)") },
 
133
    { "-syncdrawflickerfix", SET_RESOURCE, 0,
 
134
      NULL, NULL, "SyncDrawFlickerFix", (resource_value_t)1,
 
135
      USE_PARAM_STRING, USE_DESCRIPTION_STRING,
 
136
      IDCLS_UNUSED, IDCLS_UNUSED,
 
137
      NULL, T_("Enable flicker fixing in sync draw") },
 
138
    { "+syncdrawflickerfix", SET_RESOURCE, 0,
 
139
      NULL, NULL, "SyncDrawFlickerFix", (resource_value_t)0,
 
140
      USE_PARAM_STRING, USE_DESCRIPTION_STRING,
 
141
      IDCLS_UNUSED, IDCLS_UNUSED,
 
142
      NULL, T_("Enable flicker fixing in sync draw") },
 
143
    { NULL }
 
144
};
47
145
 
48
146
int video_init_cmdline_options(void)
49
147
{
50
 
    return 0;
 
148
    return cmdline_register_options(cmdline_options);
51
149
}
52
150
 
 
151
// --------- init/exit MacVICE video ----------
 
152
 
53
153
int video_init(void)
54
154
{
55
 
   return 0;
 
155
    if (video_log == LOG_ERR)
 
156
            video_log = log_open("MacVideo");
56
157
}
57
158
 
58
159
void video_shutdown(void)
59
160
{
 
161
    if (video_log != LOG_ERR)
 
162
        log_close(video_log);
60
163
}
61
164
 
62
165
void video_arch_canvas_init(struct video_canvas_s *canvas)
63
166
{
 
167
    canvas->pitch = 0;
64
168
    canvas->window = nil;
 
169
    canvas->view = nil;
 
170
    canvas->canvasId = 0;
 
171
    
 
172
    canvas->video_param = &video_param;
65
173
    canvas->video_draw_buffer_callback = NULL;
66
174
}
67
175
 
79
187
    video_canvas_t *canvasPtr = canvas;
80
188
    NSData *data = [NSData dataWithBytes:&canvasPtr length:sizeof(video_canvas_t *)];
81
189
 
 
190
    // register canvas in machine controller and return Id for it
 
191
    canvas->canvasId = [theVICEMachine registerCanvas:canvas];
 
192
 
82
193
    // call UI thread to create canvas
83
194
    [[theVICEMachine app] createCanvas:data withSize:NSMakeSize(w,h)];
84
195
 
85
196
    // init rendering
86
197
    video_canvas_set_palette(canvas,canvas->palette);
87
198
 
88
 
    // register canvas in machine controller (to allow access via id)
89
 
    canvas->canvasId = [theVICEMachine registerCanvas:canvas];
90
 
 
91
199
    // re-post all required notifications for new window
92
200
    [[theVICEMachine machineNotifier] notifyNewWindow];
93
201
 
129
237
    [[theVICEMachine app] resizeCanvas:data withSize:NSMakeSize(width,height)];
130
238
}
131
239
 
 
240
extern int vsync_frame_counter;
 
241
 
132
242
void video_canvas_refresh(video_canvas_t *canvas,
133
243
                          unsigned int xs, unsigned int ys,
134
244
                          unsigned int xi, unsigned int yi,
145
255
    w = MIN(w, canvas->width - xi);
146
256
    h = MIN(h, canvas->height - yi);
147
257
 
148
 
    // render into texture buffer
149
 
    video_canvas_render(canvas, canvas->buffer,
 
258
    // get drawing buffer
 
259
    VICEGLView *view = canvas->view;
 
260
    BYTE *buffer = [view beginMachineDraw:vsync_frame_counter];
 
261
    if(buffer == NULL) {
 
262
        return;
 
263
    }
 
264
        
 
265
    // draw into buffer
 
266
    video_canvas_render(canvas, buffer,
150
267
                        w, h, xs, ys, xi, yi, 
151
268
                        canvas->pitch, canvas->depth);
152
269
 
153
 
#if 1
154
 
    // call updateCanvas selector in main thread - non-blocking
155
 
    VICEWindow *window = canvas->window;
156
 
    [window performSelectorOnMainThread:@selector(updateCanvas:) 
157
 
                             withObject:nil 
158
 
                          waitUntilDone:NO];
159
 
#else
160
 
    // call updateCanvas via proxy object - blocks if main app blocks
161
 
    // encapsulate canvas ptr
162
 
    video_canvas_t *canvasPtr = canvas;    
163
 
    NSData *data = [NSData dataWithBytes:&canvasPtr length:sizeof(video_canvas_t *)];
164
 
    // call UI thread to resize canvas
165
 
    [[theVICEMachine app] updateCanvas:data];
166
 
#endif
 
270
    // notify end drawing
 
271
    [view endMachineDraw];
167
272
}
168
273
 
169
274
// ----- Palette Stuff -----
182
287
    DWORD bmask = 0;
183
288
 
184
289
    c->palette = p;
 
290
    
 
291
    // set 32bit palette
185
292
    for (i = 0; i < p->num_entries; i++)
186
293
    {
187
294
        DWORD col;
188
295
 
189
 
        switch (c->depth)
190
 
        {
191
 
            case 16:    /* RGB 5:5:5 */
192
 
                /* TODO */
193
 
                rbits = 3; rshift = 10; rmask = 0x1f;
194
 
                gbits = 3; gshift = 5; gmask = 0x1f;
195
 
                bbits = 3; bshift = 0; bmask = 0x1f;
196
 
                break;
197
 
            case 32:    /* RGB 8:8:8 */
198
 
            default:
199
 
                rbits = 0; rshift = 16; rmask = 0xff;
200
 
                gbits = 0; gshift = 8; gmask = 0xff;
201
 
                bbits = 0; bshift = 0; bmask = 0xff;
202
 
        }
 
296
        rbits = 0; rshift = 16; rmask = 0xff;
 
297
        gbits = 0; gshift = 8; gmask = 0xff;
 
298
        bbits = 0; bshift = 0; bmask = 0xff;
 
299
 
203
300
        col = (p->entries[i].red   >> rbits) << rshift
204
301
            | (p->entries[i].green >> gbits) << gshift
205
 
            | (p->entries[i].blue  >> bbits) << bshift;
 
302
            | (p->entries[i].blue  >> bbits) << bshift
 
303
            | 0xff000000; // alpha
206
304
 
207
305
        video_render_setphysicalcolor(c->videoconfig, i, col, c->depth);
208
306
    }
209
 
    if (c->depth > 8)
 
307
 
 
308
    // set colors for palemu
 
309
    for (i = 0; i < 256; i++)
210
310
    {
211
 
        for (i = 0; i < 256; i++)
212
 
        {
213
 
            video_render_setrawrgb(i,
214
 
                                   ((i & (rmask << rbits)) >> rbits) << rshift,
215
 
                                   ((i & (gmask << gbits)) >> gbits) << gshift,
216
 
                                   ((i & (bmask << bbits)) >> bbits) << bshift);
217
 
        }
218
 
        video_render_initraw();
 
311
        video_render_setrawrgb(i,
 
312
                               ((i & (rmask << rbits)) >> rbits) << rshift,
 
313
                               ((i & (gmask << gbits)) >> gbits) << gshift,
 
314
                               ((i & (bmask << bbits)) >> bbits) << bshift);
219
315
    }
 
316
    video_render_setrawalpha(0xff000000);
 
317
    video_render_initraw();
220
318
 
221
319
    return 0;
222
320
}