← Back to branch summary

~ubuntu-branches/ubuntu/trusty/vice/trusty

« back to all changes in this revision

Viewing changes to src/drive/drive-snapshot.c

  • Committer: Package Import Robot
  • Author(s): Laszlo Boszormenyi (GCS)
  • Date: 2013-07-28 20:38:23 UTC
  • mfrom: (1.2.5)
  • mto: This revision was merged to the branch mainline in revision 27.
  • Revision ID: package-import@ubuntu.com-20130728203823-w495rps5wuykespp
Tags: upstream-2.4.dfsg
Import upstream version 2.4.dfsg

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/drive/drive-snapshot.c
34
34
#include "diskconstants.h"
35
35
#include "diskimage.h"
36
36
#include "drive-snapshot.h"
 
37
#include "drive-sound.h"
37
38
#include "drive.h"
38
39
#include "drivecpu.h"
 
40
#include "drivecpu65c02.h"
39
41
#include "drivemem.h"
40
42
#include "driverom.h"
41
43
#include "drivetypes.h"
53
55
#include "vdrive-bam.h"
54
56
#include "vdrive-snapshot.h"
55
57
#include "zfile.h"
 
58
#include "p64.h"
56
59
 
57
60
 
58
61
/* Currently the drive snapshot only handles 2 drives.  */
63
66
static int drive_snapshot_write_image_module(snapshot_t *s, unsigned int dnr);
64
67
static int drive_snapshot_write_gcrimage_module(snapshot_t *s,
65
68
                                                unsigned int dnr);
 
69
static int drive_snapshot_write_p64image_module(snapshot_t *s,
 
70
                                                unsigned int dnr);
66
71
static int drive_snapshot_read_image_module(snapshot_t *s, unsigned int dnr);
67
72
static int drive_snapshot_read_gcrimage_module(snapshot_t *s, unsigned int dnr);
68
 
static int drive_snapshot_write_rom_module(snapshot_t *s, unsigned int dnr);
69
 
static int drive_snapshot_read_rom_module(snapshot_t *s, unsigned int dnr);
 
73
static int drive_snapshot_read_p64image_module(snapshot_t *s, unsigned int dnr);
70
74
 
71
75
/*
72
76
This is the format of the DRIVE snapshot module.
101
105
*/
102
106
 
103
107
#define DRIVE_SNAP_MAJOR 1
104
 
#define DRIVE_SNAP_MINOR 1
 
108
#define DRIVE_SNAP_MINOR 4
105
109
 
106
110
int drive_snapshot_write_module(snapshot_t *s, int save_disks, int save_roms)
107
111
{
109
113
    char snap_module_name[] = "DRIVE";
110
114
    snapshot_module_t *m;
111
115
    DWORD rotation_table_ptr[DRIVE_NUM];
112
 
    BYTE GCR_image[2];
 
116
    BYTE GCR_image[4], P64_image[4];
113
117
    int drive_true_emulation;
114
118
    int sync_factor;
115
119
    drive_t *drive;
130
134
        drive = drive_context[i]->drive;
131
135
        GCR_image[i] = (drive->GCR_image_loaded == 0
132
136
                       || !save_disks) ? 0 : 1;
 
137
        P64_image[i] = (drive->P64_image_loaded == 0
 
138
                       || !save_disks) ? 0 : 1;
133
139
    }
134
140
 
135
141
    m = snapshot_module_create(s, snap_module_name, DRIVE_SNAP_MAJOR,
145
151
        return -1;
146
152
    }
147
153
 
 
154
    /* TODO: NUM_DRIVES drives instead of 2 */
148
155
    for (i = 0; i < 2; i++) {
149
156
        drive = drive_context[i]->drive;
150
157
        if (0
151
158
            || SMW_DW(m, (DWORD)(drive->attach_clk)) < 0
152
159
            || SMW_B(m, (BYTE)(drive->byte_ready_level)) < 0
153
160
            || SMW_B(m, (BYTE)(drive->clock_frequency)) < 0
154
 
            || SMW_W(m, (WORD)(drive->current_half_track)) < 0
 
161
            || SMW_W(m, (WORD)(drive->current_half_track + drive->side * 70)) < 0
155
162
            || SMW_DW(m, (DWORD)(drive->detach_clk)) < 0
156
 
            || SMW_B(m, (BYTE)(drive->diskID1)) < 0
157
 
            || SMW_B(m, (BYTE)(drive->diskID2)) < 0
 
163
            || SMW_B(m, (BYTE)0) < 0
 
164
            || SMW_B(m, (BYTE)0) < 0
158
165
            || SMW_B(m, (BYTE)(drive->extend_image_policy)) < 0
159
166
            || SMW_DW(m, (DWORD)(drive->GCR_head_offset)) < 0
160
167
            || SMW_B(m, (BYTE)(drive->GCR_read)) < 0
173
180
            || SMW_W(m, (WORD)(drive->snap_last_read_data)) < 0
174
181
            || SMW_B(m, (BYTE)(drive->snap_last_write_data)) < 0
175
182
            || SMW_DW(m, (BYTE)(drive->snap_seed)) < 0
 
183
            || SMW_DW(m, (DWORD)(drive->snap_speed_zone)) < 0
 
184
            || SMW_DW(m, (DWORD)(drive->snap_ue7_dcba)) < 0
 
185
            || SMW_DW(m, (DWORD)(drive->snap_ue7_counter)) < 0
 
186
            || SMW_DW(m, (DWORD)(drive->snap_uf4_counter)) < 0
 
187
            || SMW_DW(m, (DWORD)(drive->snap_fr_randcount)) < 0
 
188
            || SMW_DW(m, (DWORD)(drive->snap_filter_counter)) < 0
 
189
            || SMW_DW(m, (DWORD)(drive->snap_filter_state)) < 0
 
190
            || SMW_DW(m, (DWORD)(drive->snap_filter_last_state)) < 0
 
191
            || SMW_DW(m, (DWORD)(drive->snap_write_flux)) < 0
 
192
            || SMW_DW(m, (DWORD)(drive->snap_PulseHeadPosition)) < 0
 
193
            || SMW_DW(m, (DWORD)(drive->snap_xorShift32)) < 0
 
194
            || SMW_DW(m, (DWORD)(drive->snap_so_delay)) < 0
 
195
            || SMW_DW(m, (DWORD)(drive->snap_cycle_index)) < 0
 
196
            || SMW_DW(m, (DWORD)(drive->snap_ref_advance)) < 0
 
197
            || SMW_DW(m, (DWORD)(drive->snap_req_ref_cycles)) < 0
 
198
 
176
199
        ) {
177
200
            if (m != NULL)
178
201
                snapshot_module_close(m);
210
233
    for (i = 0; i < 2; i++) {
211
234
        drive = drive_context[i]->drive;
212
235
        if (drive->enable) {
213
 
            if (drivecpu_snapshot_write_module(drive_context[i], s) < 0)
214
 
                return -1;
 
236
            if (drive->type == DRIVE_TYPE_2000 || drive->type == DRIVE_TYPE_4000) {
 
237
                if (drivecpu65c02_snapshot_write_module(drive_context[i], s) < 0)
 
238
                    return -1;
 
239
            } else {
 
240
                if (drivecpu_snapshot_write_module(drive_context[i], s) < 0)
 
241
                    return -1;
 
242
            }
215
243
            if (machine_drive_snapshot_write(drive_context[i], s) < 0)
216
244
                return -1;
217
245
        }
219
247
 
220
248
    if (save_disks) {
221
249
        if (GCR_image[0] > 0) {
222
 
            if (drive_snapshot_write_gcrimage_module(s, 0) < 0)
223
 
                return -1;
 
250
            if (drive_snapshot_write_gcrimage_module(s, 0) < 0) {
 
251
                return -1;
 
252
            }
 
253
        } else if (P64_image[0] > 0) {
 
254
            if (drive_snapshot_write_p64image_module(s, 0) < 0) {
 
255
                return -1;
 
256
            }
224
257
        } else {
225
 
            if (drive_snapshot_write_image_module(s, 0) < 0)
 
258
            if (drive_snapshot_write_image_module(s, 0) < 0) {
226
259
                return -1;
 
260
            }
227
261
        }
228
262
        if (GCR_image[1] > 0) {
229
 
            if (drive_snapshot_write_gcrimage_module(s, 1) < 0)
230
 
                return -1;
 
263
            if (drive_snapshot_write_gcrimage_module(s, 1) < 0) {
 
264
                return -1;
 
265
            }
 
266
        } else if (P64_image[1] > 0) {
 
267
            if (drive_snapshot_write_p64image_module(s, 1) < 0) {
 
268
                return -1;
 
269
            }
231
270
        } else {
232
 
            if (drive_snapshot_write_image_module(s, 1) < 0)
 
271
            if (drive_snapshot_write_image_module(s, 1) < 0) {
233
272
                return -1;
 
273
            }
234
274
        }
235
275
    }
236
276
 
237
277
    for (i = 0; i < 2; i++) {
238
278
        drive = drive_context[i]->drive;
239
 
        if (save_roms && drive->enable)
240
 
            if (drive_snapshot_write_rom_module(s, i) < 0)
 
279
        if (save_roms && drive->enable) {
 
280
            if (driverom_snapshot_write(s, drive) < 0) {
241
281
                return -1;
 
282
            }
 
283
        }
242
284
    }
243
285
 
244
286
    return 0;
258
300
    int sync_factor;
259
301
    drive_t *drive;
260
302
    int dummy;
 
303
    int half_track[DRIVE_NUM];
261
304
 
262
305
    m = snapshot_module_open(s, snap_module_name,
263
306
                             &major_version, &minor_version);
285
328
        return -1;
286
329
    }
287
330
 
 
331
    /* TODO: NUM_DRIVES drives instead of 2 */
288
332
    for (i = 0; i < 2; i++) {
289
333
        drive = drive_context[i]->drive;
290
334
 
296
340
                || SMR_DW_INT(m, &dummy) < 0
297
341
                || SMR_B_INT(m, (int *)&(drive->byte_ready_level)) < 0
298
342
                || SMR_B_INT(m, &(drive->clock_frequency)) < 0
299
 
                || SMR_W_INT(m, &(drive->current_half_track)) < 0
300
 
                || SMR_DW(m, &(detach_clk[i])) < 0
301
 
                || SMR_B(m, &(drive->diskID1)) < 0
302
 
                || SMR_B(m, &(drive->diskID2)) < 0
303
 
                || SMR_B_INT(m, &(drive->extend_image_policy)) < 0
304
 
                || SMR_B_INT(m, &dummy) < 0
305
 
                || SMR_DW_UINT(m, &(drive->GCR_head_offset)) < 0
306
 
                || SMR_B(m, &(drive->GCR_read)) < 0
307
 
                || SMR_B(m, &(drive->GCR_write_value)) < 0
308
 
                || SMR_B_INT(m, &(drive->idling_method)) < 0
309
 
                || SMR_B_INT(m, &dummy) < 0
310
 
                || SMR_B_INT(m, &(drive->parallel_cable)) < 0
311
 
                || SMR_B_INT(m, &(drive->read_only)) < 0
312
 
                || SMR_DW(m, &(drive->snap_rotation_last_clk)) < 0
313
 
                || SMR_DW(m, &rotation_table_ptr[i]) < 0
314
 
                || SMR_DW_UINT(m, &(drive->type)) < 0
315
 
            ) {
316
 
                snapshot_module_close(m);
317
 
                return -1;
318
 
            }
 
343
                || SMR_W_INT(m, &half_track[i]) < 0
 
344
                || SMR_DW(m, &(detach_clk[i])) < 0
 
345
                || SMR_B(m, (BYTE *)&dummy) < 0
 
346
                || SMR_B(m, (BYTE *)&dummy) < 0
 
347
                || SMR_B_INT(m, &(drive->extend_image_policy)) < 0
 
348
                || SMR_B_INT(m, &dummy) < 0
 
349
                || SMR_DW_UINT(m, &(drive->GCR_head_offset)) < 0
 
350
                || SMR_B(m, &(drive->GCR_read)) < 0
 
351
                || SMR_B(m, &(drive->GCR_write_value)) < 0
 
352
                || SMR_B_INT(m, &(drive->idling_method)) < 0
 
353
                || SMR_B_INT(m, &dummy) < 0
 
354
                || SMR_B_INT(m, &(drive->parallel_cable)) < 0
 
355
                || SMR_B_INT(m, &(drive->read_only)) < 0
 
356
                || SMR_DW(m, &(drive->snap_rotation_last_clk)) < 0
 
357
                || SMR_DW(m, &rotation_table_ptr[i]) < 0
 
358
                || SMR_DW_UINT(m, &(drive->type)) < 0
 
359
            ) {
 
360
                snapshot_module_close(m);
 
361
                return -1;
 
362
            }
 
363
 
 
364
        /* Partially read 1.1 snapshots */
 
365
        } else if (major_version == 1 && minor_version == 1) {
 
366
 
 
367
            if (0
 
368
                || SMR_DW(m, &(attach_clk[i])) < 0
 
369
                || SMR_B_INT(m, (int *)&(drive->byte_ready_level)) < 0
 
370
                || SMR_B_INT(m, &(drive->clock_frequency)) < 0
 
371
                || SMR_W_INT(m, &half_track[i]) < 0
 
372
                || SMR_DW(m, &(detach_clk[i])) < 0
 
373
                || SMR_B(m, (BYTE *)&dummy) < 0
 
374
                || SMR_B(m, (BYTE *)&dummy) < 0
 
375
                || SMR_B_INT(m, &(drive->extend_image_policy)) < 0
 
376
                || SMR_DW_UINT(m, &(drive->GCR_head_offset)) < 0
 
377
                || SMR_B(m, &(drive->GCR_read)) < 0
 
378
                || SMR_B(m, &(drive->GCR_write_value)) < 0
 
379
                || SMR_B_INT(m, &(drive->idling_method)) < 0
 
380
                || SMR_B_INT(m, &(drive->parallel_cable)) < 0
 
381
                || SMR_B_INT(m, &(drive->read_only)) < 0
 
382
                || SMR_DW(m, &rotation_table_ptr[i]) < 0
 
383
                || SMR_DW_UINT(m, &(drive->type)) < 0
 
384
 
 
385
                || SMR_DW_UL(m, &(drive->snap_accum)) < 0
 
386
                || SMR_DW(m, &(drive->snap_rotation_last_clk)) < 0
 
387
                || SMR_DW_INT(m, &(drive->snap_bit_counter)) < 0
 
388
                || SMR_DW_INT(m, &(drive->snap_zero_count)) < 0
 
389
                || SMR_W_INT(m, &(drive->snap_last_read_data)) < 0
 
390
                || SMR_B(m, &(drive->snap_last_write_data)) < 0
 
391
                || SMR_DW_INT(m, &(drive->snap_seed)) < 0
 
392
            ) {
 
393
                snapshot_module_close(m);
 
394
                return -1;
 
395
            }
 
396
 
 
397
        /* Partially read 1.2 snapshots */
 
398
        } else if (major_version == 1 && minor_version == 2) {
 
399
 
 
400
            if (0
 
401
                || SMR_DW(m, &(attach_clk[i])) < 0
 
402
                || SMR_B_INT(m, (int *)&(drive->byte_ready_level)) < 0
 
403
                || SMR_B_INT(m, &(drive->clock_frequency)) < 0
 
404
                || SMR_W_INT(m, &half_track[i]) < 0
 
405
                || SMR_DW(m, &(detach_clk[i])) < 0
 
406
                || SMR_B(m, (BYTE *)&dummy) < 0
 
407
                || SMR_B(m, (BYTE *)&dummy) < 0
 
408
                || SMR_B_INT(m, &(drive->extend_image_policy)) < 0
 
409
                || SMR_DW_UINT(m, &(drive->GCR_head_offset)) < 0
 
410
                || SMR_B(m, &(drive->GCR_read)) < 0
 
411
                || SMR_B(m, &(drive->GCR_write_value)) < 0
 
412
                || SMR_B_INT(m, &(drive->idling_method)) < 0
 
413
                || SMR_B_INT(m, &(drive->parallel_cable)) < 0
 
414
                || SMR_B_INT(m, &(drive->read_only)) < 0
 
415
                || SMR_DW(m, &rotation_table_ptr[i]) < 0
 
416
                || SMR_DW_UINT(m, &(drive->type)) < 0
 
417
 
 
418
                || SMR_DW_UL(m, &(drive->snap_accum)) < 0
 
419
                || SMR_DW(m, &(drive->snap_rotation_last_clk)) < 0
 
420
                || SMR_DW_INT(m, &(drive->snap_bit_counter)) < 0
 
421
                || SMR_DW_INT(m, &(drive->snap_zero_count)) < 0
 
422
                || SMR_W_INT(m, &(drive->snap_last_read_data)) < 0
 
423
                || SMR_B(m, &(drive->snap_last_write_data)) < 0
 
424
                || SMR_DW_INT(m, &(drive->snap_seed)) < 0
 
425
                || SMR_DW(m, &(drive->snap_speed_zone)) < 0
 
426
                || SMR_DW(m, &(drive->snap_ue7_dcba)) < 0
 
427
                || SMR_DW(m, &(drive->snap_ue7_counter)) < 0
 
428
                || SMR_DW(m, &(drive->snap_uf4_counter)) < 0
 
429
                || SMR_DW(m, &(drive->snap_fr_randcount)) < 0
 
430
                || SMR_DW(m, &(drive->snap_filter_counter)) < 0
 
431
                || SMR_DW(m, &(drive->snap_filter_state)) < 0
 
432
                || SMR_DW(m, &(drive->snap_filter_last_state)) < 0
 
433
                || SMR_DW(m, &(drive->snap_write_flux)) < 0
 
434
                || SMR_DW(m, &(drive->snap_PulseHeadPosition)) < 0
 
435
                || SMR_DW(m, &(drive->snap_xorShift32)) < 0
 
436
            ) {
 
437
                snapshot_module_close(m);
 
438
                return -1;
 
439
            }
 
440
 
 
441
        } else if (major_version == 1 && minor_version == 3) {
 
442
 
 
443
            if (0
 
444
                || SMR_DW(m, &(attach_clk[i])) < 0
 
445
                || SMR_B_INT(m, (int *)&(drive->byte_ready_level)) < 0
 
446
                || SMR_B_INT(m, &(drive->clock_frequency)) < 0
 
447
                || SMR_W_INT(m, &half_track[i]) < 0
 
448
                || SMR_DW(m, &(detach_clk[i])) < 0
 
449
                || SMR_B(m, (BYTE *)&dummy) < 0
 
450
                || SMR_B(m, (BYTE *)&dummy) < 0
 
451
                || SMR_B_INT(m, &(drive->extend_image_policy)) < 0
 
452
                || SMR_DW_UINT(m, &(drive->GCR_head_offset)) < 0
 
453
                || SMR_B(m, &(drive->GCR_read)) < 0
 
454
                || SMR_B(m, &(drive->GCR_write_value)) < 0
 
455
                || SMR_B_INT(m, &(drive->idling_method)) < 0
 
456
                || SMR_B_INT(m, &(drive->parallel_cable)) < 0
 
457
                || SMR_B_INT(m, &(drive->read_only)) < 0
 
458
                || SMR_DW(m, &rotation_table_ptr[i]) < 0
 
459
                || SMR_DW_UINT(m, &(drive->type)) < 0
 
460
 
 
461
                || SMR_DW_UL(m, &(drive->snap_accum)) < 0
 
462
                || SMR_DW(m, &(drive->snap_rotation_last_clk)) < 0
 
463
                || SMR_DW_INT(m, &(drive->snap_bit_counter)) < 0
 
464
                || SMR_DW_INT(m, &(drive->snap_zero_count)) < 0
 
465
                || SMR_W_INT(m, &(drive->snap_last_read_data)) < 0
 
466
                || SMR_B(m, &(drive->snap_last_write_data)) < 0
 
467
                || SMR_DW_INT(m, &(drive->snap_seed)) < 0
 
468
                || SMR_DW(m, &(drive->snap_speed_zone)) < 0
 
469
                || SMR_DW(m, &(drive->snap_ue7_dcba)) < 0
 
470
                || SMR_DW(m, &(drive->snap_ue7_counter)) < 0
 
471
                || SMR_DW(m, &(drive->snap_uf4_counter)) < 0
 
472
                || SMR_DW(m, &(drive->snap_fr_randcount)) < 0
 
473
                || SMR_DW(m, &(drive->snap_filter_counter)) < 0
 
474
                || SMR_DW(m, &(drive->snap_filter_state)) < 0
 
475
                || SMR_DW(m, &(drive->snap_filter_last_state)) < 0
 
476
                || SMR_DW(m, &(drive->snap_write_flux)) < 0
 
477
                || SMR_DW(m, &(drive->snap_PulseHeadPosition)) < 0
 
478
                || SMR_DW(m, &(drive->snap_xorShift32)) < 0
 
479
                || SMR_DW(m, &(drive->snap_so_delay)) < 0
 
480
            ) {
 
481
                snapshot_module_close(m);
 
482
                return -1;
 
483
            }
 
484
 
319
485
        } else {
320
486
 
321
487
            if (0
322
488
                || SMR_DW(m, &(attach_clk[i])) < 0
323
489
                || SMR_B_INT(m, (int *)&(drive->byte_ready_level)) < 0
324
490
                || SMR_B_INT(m, &(drive->clock_frequency)) < 0
325
 
                || SMR_W_INT(m, &(drive->current_half_track)) < 0
 
491
                || SMR_W_INT(m, &half_track[i]) < 0
326
492
                || SMR_DW(m, &(detach_clk[i])) < 0
327
 
                || SMR_B(m, &(drive->diskID1)) < 0
328
 
                || SMR_B(m, &(drive->diskID2)) < 0
 
493
                || SMR_B(m, (BYTE *)&dummy) < 0
 
494
                || SMR_B(m, (BYTE *)&dummy) < 0
329
495
                || SMR_B_INT(m, &(drive->extend_image_policy)) < 0
330
496
                || SMR_DW_UINT(m, &(drive->GCR_head_offset)) < 0
331
497
                || SMR_B(m, &(drive->GCR_read)) < 0
343
509
                || SMR_W_INT(m, &(drive->snap_last_read_data)) < 0
344
510
                || SMR_B(m, &(drive->snap_last_write_data)) < 0
345
511
                || SMR_DW_INT(m, &(drive->snap_seed)) < 0
 
512
                || SMR_DW(m, &(drive->snap_speed_zone)) < 0
 
513
                || SMR_DW(m, &(drive->snap_ue7_dcba)) < 0
 
514
                || SMR_DW(m, &(drive->snap_ue7_counter)) < 0
 
515
                || SMR_DW(m, &(drive->snap_uf4_counter)) < 0
 
516
                || SMR_DW(m, &(drive->snap_fr_randcount)) < 0
 
517
                || SMR_DW(m, &(drive->snap_filter_counter)) < 0
 
518
                || SMR_DW(m, &(drive->snap_filter_state)) < 0
 
519
                || SMR_DW(m, &(drive->snap_filter_last_state)) < 0
 
520
                || SMR_DW(m, &(drive->snap_write_flux)) < 0
 
521
                || SMR_DW(m, &(drive->snap_PulseHeadPosition)) < 0
 
522
                || SMR_DW(m, &(drive->snap_xorShift32)) < 0
 
523
                || SMR_DW(m, &(drive->snap_so_delay)) < 0
 
524
                || SMR_DW(m, &(drive->snap_cycle_index)) < 0
 
525
                || SMR_DW(m, &(drive->snap_ref_advance)) < 0
 
526
                || SMR_DW(m, &(drive->snap_req_ref_cycles)) < 0
346
527
            ) {
347
528
                snapshot_module_close(m);
348
529
                return -1;
349
530
            }
350
531
        }
351
532
    }
352
 
    
 
533
 
353
534
    /* this one is new, so don't test so stay compatible with old snapshots */
354
535
    for (i = 0; i < 2; i++) {
355
536
        drive = drive_context[i]->drive;
356
537
        SMR_DW(m, &(attach_detach_clk[i]));
357
538
    }
358
 
    
 
539
 
359
540
    /* these are even newer */
360
541
    for (i = 0; i < 2; i++) {
361
542
        drive = drive_context[i]->drive;
362
543
        SMR_B_INT(m, (int *)&(drive->byte_ready_edge));
363
544
        SMR_B_INT(m, (int *)&(drive->byte_ready_active));
364
545
    }
365
 
    
 
546
 
366
547
    snapshot_module_close(m);
367
548
    m = NULL;
368
549
 
369
550
    rotation_table_set(rotation_table_ptr);
370
551
 
371
 
    for (i = 0; i < 2; i++) {
372
 
        drive = drive_context[i]->drive;
373
 
        drive->GCR_track_start_ptr = (drive->gcr->data
374
 
                                     + ((drive->current_half_track / 2 - 1)
375
 
                                     * NUM_MAX_BYTES_TRACK));
376
 
        if (drive->type != DRIVE_TYPE_1570
377
 
            && drive->type != DRIVE_TYPE_1571
378
 
            && drive->type != DRIVE_TYPE_1571CR) {
379
 
            if (drive->type == DRIVE_TYPE_1581) {
380
 
                resources_set_int("MachineVideoStandard", sync_factor);
381
 
            } else {
382
 
                drive->side = 0;
383
 
                resources_set_int("MachineVideoStandard", sync_factor);
384
 
            }
385
 
        }
386
 
    }
387
 
 
388
552
    drive = drive_context[0]->drive;
389
553
    switch (drive->type) {
390
554
      case DRIVE_TYPE_1541:
394
558
      case DRIVE_TYPE_1571:
395
559
      case DRIVE_TYPE_1571CR:
396
560
      case DRIVE_TYPE_1581:
 
561
      case DRIVE_TYPE_2000:
 
562
      case DRIVE_TYPE_4000:
397
563
      case DRIVE_TYPE_2031:
398
564
      case DRIVE_TYPE_1001:
399
565
      case DRIVE_TYPE_2040:
425
591
      case DRIVE_TYPE_1570:
426
592
      case DRIVE_TYPE_1571:
427
593
      case DRIVE_TYPE_1581:
 
594
      case DRIVE_TYPE_2000:
 
595
      case DRIVE_TYPE_4000:
428
596
      case DRIVE_TYPE_2031:
429
597
      case DRIVE_TYPE_1001:
430
598
        /* drive 1 does not allow dual disk drive */
447
615
    }
448
616
 
449
617
    /* Clear parallel cable before undumping parallel port values.  */
450
 
    parallel_cable_drive_write(0xff, PARALLEL_WRITE, 0);
451
 
    parallel_cable_drive_write(0xff, PARALLEL_WRITE, 1);
 
618
    for (i = 0; i < DRIVE_PC_NUM; i++) {
 
619
        parallel_cable_drive_write(i, 0xff, PARALLEL_WRITE, 0);
 
620
        parallel_cable_drive_write(i, 0xff, PARALLEL_WRITE, 1);
 
621
    }
452
622
 
453
623
    for (i = 0; i < 2; i++) {
454
624
        drive = drive_context[i]->drive;
455
625
        if (drive->enable) {
456
 
            if (drivecpu_snapshot_read_module(drive_context[i], s) < 0)
457
 
                return -1;
 
626
            if (drive->type == DRIVE_TYPE_2000 || drive->type == DRIVE_TYPE_4000) {
 
627
                if (drivecpu65c02_snapshot_read_module(drive_context[i], s) < 0)
 
628
                    return -1;
 
629
            } else {
 
630
                if (drivecpu_snapshot_read_module(drive_context[i], s) < 0)
 
631
                    return -1;
 
632
            }
458
633
            if (machine_drive_snapshot_read(drive_context[i], s) < 0)
459
634
                return -1;
460
635
        }
461
636
    }
462
637
 
463
638
    if (drive_snapshot_read_image_module(s, 0) < 0
464
 
        || drive_snapshot_read_gcrimage_module(s, 0) < 0)
 
639
        || drive_snapshot_read_gcrimage_module(s, 0) < 0
 
640
        || drive_snapshot_read_p64image_module(s, 0) < 0) {
465
641
        return -1;
 
642
    }
466
643
    if (drive_snapshot_read_image_module(s, 1) < 0
467
 
        || drive_snapshot_read_gcrimage_module(s, 1) < 0)
468
 
        return -1;
469
 
    if (drive_snapshot_read_rom_module(s, 0) < 0)
470
 
        return -1;
471
 
    if (drive_snapshot_read_rom_module(s, 1) < 0)
472
 
        return -1;
473
 
 
474
 
    for (i = 0; i < 2; i++)
475
 
        drive_current_track_size_set(drive_context[i]->drive);
 
644
        || drive_snapshot_read_gcrimage_module(s, 1) < 0
 
645
        || drive_snapshot_read_p64image_module(s, 1) < 0) {
 
646
        return -1;
 
647
    }
 
648
    if (driverom_snapshot_read(s, drive_context[0]->drive) < 0) {
 
649
        return -1;
 
650
    }
 
651
    if (driverom_snapshot_read(s, drive_context[1]->drive) < 0) {
 
652
        return -1;
 
653
    }
476
654
 
477
655
    for (i = 0; i < 2; i++) {
478
656
        drive = drive_context[i]->drive;
484
662
        }
485
663
    }
486
664
 
 
665
    for (i = 0; i < 2; i++) {
 
666
        int side = 0;
 
667
        drive = drive_context[i]->drive;
 
668
        if (drive->type == DRIVE_TYPE_1570
 
669
            || drive->type == DRIVE_TYPE_1571
 
670
            || drive->type == DRIVE_TYPE_1571CR) {
 
671
            if (half_track[i] > 71) {
 
672
                side = 1;
 
673
                half_track[i] -= 70;
 
674
            }
 
675
        }
 
676
        drive_set_half_track(half_track[i], side, drive);
 
677
        resources_set_int("MachineVideoStandard", sync_factor);
 
678
    }
 
679
 
 
680
    /* stop currently active drive sounds (bug #3539422)
 
681
     * FIXME: when the drive sound emulation becomes more precise, we might
 
682
     *        want/need to save a snapshot of its current state too
 
683
     */
 
684
    drive_sound_stop();
 
685
 
487
686
    iec_update_ports_embedded();
488
687
    drive_update_ui_status();
489
688
 
516
715
    snapshot_module_t *m;
517
716
    BYTE sector_data[0x100];
518
717
    WORD word;
519
 
    int track, sector;
 
718
    disk_addr_t dadr;
520
719
    int rc;
521
720
    drive_t *drive;
522
721
 
526
725
            sprintf(snap_module_name, "NOIMAGE%i", dnr);
527
726
    else
528
727
            sprintf(snap_module_name, "IMAGE%i", dnr);
529
 
    
 
728
 
530
729
    m = snapshot_module_create(s, snap_module_name, IMAGE_SNAP_MAJOR,
531
730
                               IMAGE_SNAP_MINOR);
532
731
    if (m == NULL)
544
743
 
545
744
    /* we use the return code to step through the tracks. So we do not
546
745
       need any geometry info. */
547
 
    for (track = 1; ; track++) {
 
746
    for (dadr.track = 1; ; dadr.track++) {
548
747
        rc = 0;
549
 
        for (sector = 0; ; sector++) {
550
 
            rc = disk_image_read_sector(drive->image, sector_data, track,
551
 
                                        sector);
 
748
        for (dadr.sector = 0; ; dadr.sector++) {
 
749
            rc = disk_image_read_sector(drive->image, sector_data, &dadr);
552
750
            if (rc == 0) {
553
751
                SMW_BA(m, sector_data, 0x100);
554
752
            } else {
555
753
                break;
556
754
            }
557
755
        }
558
 
        if (sector == 0) {
 
756
        if (dadr.sector == 0) {
559
757
            break;
560
758
        }
561
759
    }
576
774
    int len = 0;
577
775
    FILE *fp;
578
776
    BYTE sector_data[0x100];
579
 
    int track, sector;
 
777
    disk_addr_t dadr;
580
778
    int rc;
581
779
    drive_t *drive;
582
780
 
666
864
    /* we use the return code to step through the tracks. So we do not
667
865
       need any geometry info. */
668
866
    SMR_BA(m, sector_data, 0x100);
669
 
    for (track = 1; ; track++) {
 
867
    for (dadr.track = 1; ; dadr.track++) {
670
868
        rc = 0;
671
 
        for (sector = 0; ; sector++) {
672
 
            rc = disk_image_write_sector(drive->image, sector_data, track,
673
 
                                         sector);
 
869
        for (dadr.sector = 0; ; dadr.sector++) {
 
870
            rc = disk_image_write_sector(drive->image, sector_data, &dadr);
674
871
            if (rc == 0) {
675
872
                SMR_BA(m, sector_data, 0x100);
676
873
            } else {
677
874
                break;
678
875
            }
679
876
        }
680
 
        if (sector == 0) {
 
877
        if (dadr.sector == 0) {
681
878
            break;
682
879
        }
683
880
    }
693
890
/* -------------------------------------------------------------------- */
694
891
/* read/write GCR disk image snapshot module */
695
892
 
696
 
#define GCRIMAGE_SNAP_MAJOR 1
697
 
#define GCRIMAGE_SNAP_MINOR 0
 
893
#define GCRIMAGE_SNAP_MAJOR 3
 
894
#define GCRIMAGE_SNAP_MINOR 1
698
895
 
699
896
static int drive_snapshot_write_gcrimage_module(snapshot_t *s, unsigned int dnr)
700
897
{
701
898
    char snap_module_name[10];
702
899
    snapshot_module_t *m;
703
 
    BYTE *tmpbuf;
704
 
    int i;
 
900
    BYTE *data;
 
901
    unsigned int i;
705
902
    drive_t *drive;
 
903
    DWORD num_half_tracks, track_size;
706
904
 
707
905
    drive = drive_context[dnr]->drive;
708
906
    sprintf(snap_module_name, "GCRIMAGE%i", dnr);
712
910
    if (m == NULL)
713
911
        return -1;
714
912
 
715
 
    tmpbuf = lib_malloc(MAX_TRACKS_1571 * 4);
716
 
 
717
 
    for (i = 0; i < MAX_TRACKS_1571; i++) {
718
 
        tmpbuf[i * 4] = drive->gcr->track_size[i] & 0xff;
719
 
        tmpbuf[i * 4 + 1] = (drive->gcr->track_size[i] >> 8) & 0xff;
720
 
        tmpbuf[i * 4 + 2] = (drive->gcr->track_size[i] >> 16) & 0xff;
721
 
        tmpbuf[i * 4 + 3] = (drive->gcr->track_size[i] >> 24) & 0xff;
722
 
    }
723
 
 
724
 
    if (0
725
 
        || SMW_BA(m, drive->gcr->data,
726
 
            sizeof(drive->gcr->data)) < 0
727
 
        || SMW_BA(m, drive->gcr->speed_zone,
728
 
            sizeof(drive->gcr->speed_zone)) < 0
729
 
        || SMW_BA(m, tmpbuf, MAX_TRACKS_1571 * 4) < 0) {
730
 
        if (m != NULL)
731
 
            snapshot_module_close(m);
732
 
        lib_free(tmpbuf);
733
 
        return -1;
734
 
    }
735
 
 
736
 
    lib_free(tmpbuf);
737
 
 
738
 
    if (snapshot_module_close(m) < 0)
739
 
        return -1;
 
913
    num_half_tracks = MAX_TRACKS_1571 * 2;
 
914
 
 
915
    /* Write general data */
 
916
    if (SMW_DW(m, num_half_tracks) < 0) {
 
917
        snapshot_module_close(m);
 
918
        return -1;
 
919
    }
 
920
 
 
921
    /* Write half track data */
 
922
    for (i = 0; i < num_half_tracks; i++) {
 
923
        data = drive->gcr->tracks[i].data;
 
924
        track_size = data ? drive->gcr->tracks[i].size : 0;
 
925
        if (0
 
926
            || SMW_DW(m, (DWORD)track_size) < 0
 
927
            || (track_size && SMW_BA(m, data, track_size) < 0)
 
928
            ) {
 
929
            break;
 
930
        }
 
931
 
 
932
    }
 
933
 
 
934
    if (snapshot_module_close(m) < 0 || (i != num_half_tracks)) {
 
935
        return -1;
 
936
    }
740
937
 
741
938
    return 0;
742
939
}
746
943
    BYTE major_version, minor_version;
747
944
    snapshot_module_t *m;
748
945
    char snap_module_name[10];
749
 
    BYTE *tmpbuf;
750
 
    int i;
 
946
    BYTE *data;
 
947
    unsigned int i;
751
948
    drive_t *drive;
 
949
    DWORD num_half_tracks, track_size;
752
950
 
753
951
    drive = drive_context[dnr]->drive;
754
952
    sprintf(snap_module_name, "GCRIMAGE%i", dnr);
758
956
    if (m == NULL)
759
957
        return 0;
760
958
 
761
 
    if (major_version > GCRIMAGE_SNAP_MAJOR
762
 
        || minor_version > GCRIMAGE_SNAP_MINOR) {
 
959
    if (major_version != GCRIMAGE_SNAP_MAJOR
 
960
        || minor_version != GCRIMAGE_SNAP_MINOR) {
763
961
        log_error(drive_snapshot_log,
764
 
                  "Snapshot module version (%d.%d) newer than %d.%d.",
765
 
                  major_version, minor_version,
766
 
                  GCRIMAGE_SNAP_MAJOR, GCRIMAGE_SNAP_MINOR);
 
962
                  "Snapshot module version (%d.%d) not supported.",
 
963
                  major_version, minor_version);
 
964
        snapshot_module_close(m);
 
965
        return -1;
767
966
    }
768
967
 
769
 
    tmpbuf = lib_malloc(MAX_TRACKS_1571 * 4);
770
968
 
771
969
    if (0
772
 
        || SMR_BA(m, drive->gcr->data,
773
 
            sizeof(drive->gcr->data)) < 0
774
 
        || SMR_BA(m, drive->gcr->speed_zone,
775
 
            sizeof(drive->gcr->speed_zone)) < 0
776
 
        || SMR_BA(m, tmpbuf, MAX_TRACKS_1571 * 4) < 0) {
777
 
 
778
 
        if (m != NULL)
779
 
            snapshot_module_close(m);
780
 
        lib_free(tmpbuf);
 
970
            || SMR_DW(m, &num_half_tracks) < 0
 
971
            || num_half_tracks > MAX_GCR_TRACKS) {
 
972
        snapshot_module_close(m);
781
973
        return -1;
782
974
    }
783
975
 
 
976
    for (i = 0; i < num_half_tracks; i++) {
 
977
 
 
978
        if (SMR_DW(m, &track_size) < 0
 
979
                || track_size > NUM_MAX_MEM_BYTES_TRACK) {
 
980
            snapshot_module_close(m);
 
981
            return -1;
 
982
        }
 
983
 
 
984
        if (track_size) {
 
985
            if (drive->gcr->tracks[i].data == NULL) {
 
986
                drive->gcr->tracks[i].data = lib_calloc(1, track_size);
 
987
            } else if (drive->gcr->tracks[i].size != track_size) {
 
988
                drive->gcr->tracks[i].data = lib_realloc(drive->gcr->tracks[i].data, track_size);
 
989
            }
 
990
            memset(drive->gcr->tracks[i].data, 0, track_size);
 
991
        } else {
 
992
            if (drive->gcr->tracks[i].data) {
 
993
                lib_free(drive->gcr->tracks[i].data);
 
994
                drive->gcr->tracks[i].data = NULL;
 
995
            }
 
996
        }
 
997
        data = drive->gcr->tracks[i].data;
 
998
        drive->gcr->tracks[i].size = track_size;
 
999
 
 
1000
        if (track_size && SMR_BA(m, data, track_size) < 0) {
 
1001
            snapshot_module_close(m);
 
1002
            return -1;
 
1003
        }
 
1004
    }
 
1005
    for (; i < MAX_GCR_TRACKS; i++) {
 
1006
        if (drive->gcr->tracks[i].data) {
 
1007
            lib_free(drive->gcr->tracks[i].data);
 
1008
            drive->gcr->tracks[i].data = NULL;
 
1009
            drive->gcr->tracks[i].size = 0;
 
1010
        }
 
1011
    }
784
1012
    snapshot_module_close(m);
785
 
    m = NULL;
786
 
 
787
 
    for (i = 0; i < MAX_TRACKS_1571; i++)
788
 
        drive->gcr->track_size[i] = tmpbuf[i * 4] + (tmpbuf[i * 4 + 1] << 8)
789
 
                                    + (tmpbuf[i * 4 + 2] << 16)
790
 
                                    + (tmpbuf[i * 4 + 3] << 24);
791
 
 
792
 
    lib_free(tmpbuf);
793
1013
 
794
1014
    drive->GCR_image_loaded = 1;
 
1015
    drive->complicated_image_loaded = 1; /* TODO: verify if it's really like this */
795
1016
    drive->image = NULL;
796
1017
 
797
1018
    return 0;
798
1019
}
799
1020
 
800
1021
/* -------------------------------------------------------------------- */
801
 
 
802
 
#define ROM_SNAP_MAJOR 1
803
 
#define ROM_SNAP_MINOR 0
804
 
 
805
 
static int drive_snapshot_write_rom_module(snapshot_t *s, unsigned int dnr)
 
1022
/* read/write P64 disk image snapshot module */
 
1023
 
 
1024
#define P64IMAGE_SNAP_MAJOR 1
 
1025
#define P64IMAGE_SNAP_MINOR 0
 
1026
 
 
1027
static int drive_snapshot_write_p64image_module(snapshot_t *s, unsigned int dnr)
806
1028
{
807
1029
    char snap_module_name[10];
808
1030
    snapshot_module_t *m;
809
 
    BYTE *base;
810
 
    int len;
811
1031
    drive_t *drive;
 
1032
    TP64MemoryStream P64MemoryStreamInstance;
 
1033
    PP64Image P64Image;
812
1034
 
813
1035
    drive = drive_context[dnr]->drive;
814
 
 
815
 
    sprintf(snap_module_name, "DRIVEROM%i", dnr);
816
 
 
817
 
    m = snapshot_module_create(s, snap_module_name, ROM_SNAP_MAJOR,
818
 
                               ROM_SNAP_MINOR);
819
 
    if (m == NULL)
820
 
       return -1;
821
 
 
822
 
    switch (drive->type) {
823
 
      case DRIVE_TYPE_1541:
824
 
        base = &(drive->rom[0x4000]);
825
 
        len = DRIVE_ROM1541_SIZE;
826
 
        break;
827
 
      case DRIVE_TYPE_1541II:
828
 
        base = &(drive->rom[0x4000]);
829
 
        len = DRIVE_ROM1541II_SIZE;
830
 
        break;
831
 
      case DRIVE_TYPE_1551:
832
 
        base = drive->rom;
833
 
        len = DRIVE_ROM1551_SIZE;
834
 
        break;
835
 
      case DRIVE_TYPE_1570:
836
 
        base = drive->rom;
837
 
        len = DRIVE_ROM1571_SIZE;
838
 
        break;
839
 
      case DRIVE_TYPE_1571:
840
 
        base = drive->rom;
841
 
        len = DRIVE_ROM1571_SIZE;
842
 
        break;
843
 
      case DRIVE_TYPE_1571CR:
844
 
        base = drive->rom;
845
 
        len = DRIVE_ROM1571_SIZE;
846
 
        break;
847
 
      case DRIVE_TYPE_1581:
848
 
        base = drive->rom;
849
 
        len = DRIVE_ROM1581_SIZE;
850
 
        break;
851
 
      case DRIVE_TYPE_2031:
852
 
        base = &(drive->rom[0x4000]);
853
 
        len = DRIVE_ROM2031_SIZE;
854
 
        break;
855
 
      case DRIVE_TYPE_2040:
856
 
        base = &(drive->rom[DRIVE_ROM_SIZE - DRIVE_ROM2040_SIZE]);
857
 
        len = DRIVE_ROM2040_SIZE;
858
 
        break;
859
 
      case DRIVE_TYPE_3040:
860
 
        base = &(drive->rom[DRIVE_ROM_SIZE - DRIVE_ROM3040_SIZE]);
861
 
        len = DRIVE_ROM3040_SIZE;
862
 
        break;
863
 
      case DRIVE_TYPE_4040:
864
 
        base = &(drive->rom[DRIVE_ROM_SIZE - DRIVE_ROM4040_SIZE]);
865
 
        len = DRIVE_ROM4040_SIZE;
866
 
        break;
867
 
      case DRIVE_TYPE_1001:
868
 
      case DRIVE_TYPE_8050:
869
 
      case DRIVE_TYPE_8250:
870
 
        base = &(drive->rom[0x4000]);
871
 
        len = DRIVE_ROM1001_SIZE;
872
 
        break;
873
 
      default:
874
 
        return -1;
875
 
    }
876
 
 
877
 
    if (SMW_BA(m, base, len) < 0) {
878
 
        if (m != NULL)
879
 
            snapshot_module_close(m);
880
 
        return -1;
881
 
    }
882
 
    if (snapshot_module_close(m) < 0)
883
 
        return -1;
 
1036
    sprintf(snap_module_name, "P64IMAGE%i", dnr);
 
1037
 
 
1038
    m = snapshot_module_create(s, snap_module_name, GCRIMAGE_SNAP_MAJOR,
 
1039
                               GCRIMAGE_SNAP_MINOR);
 
1040
    if (m == NULL) {
 
1041
        return -1;
 
1042
    }
 
1043
 
 
1044
    P64Image = (void*)drive->p64;
 
1045
 
 
1046
    if (P64Image == NULL) {
 
1047
        if (m != NULL) {
 
1048
            snapshot_module_close(m);
 
1049
        }
 
1050
        return -1;
 
1051
    }
 
1052
 
 
1053
    P64MemoryStreamCreate(&P64MemoryStreamInstance);
 
1054
    P64MemoryStreamClear(&P64MemoryStreamInstance);
 
1055
    if (!P64ImageWriteToStream(P64Image,&P64MemoryStreamInstance)) {
 
1056
        P64MemoryStreamDestroy(&P64MemoryStreamInstance);
 
1057
        return -1;
 
1058
    }
 
1059
 
 
1060
    if (SMW_DW(m, P64MemoryStreamInstance.Size) < 0 ||
 
1061
        SMW_BA(m, P64MemoryStreamInstance.Data, P64MemoryStreamInstance.Size) < 0) {
 
1062
        if (m != NULL) {
 
1063
            snapshot_module_close(m);
 
1064
        }
 
1065
        P64MemoryStreamDestroy(&P64MemoryStreamInstance);
 
1066
        return -1;
 
1067
    }
 
1068
 
 
1069
    P64MemoryStreamDestroy(&P64MemoryStreamInstance);
 
1070
 
 
1071
    if (snapshot_module_close(m) < 0) {
 
1072
        return -1;
 
1073
    }
 
1074
 
884
1075
    return 0;
885
1076
}
886
1077
 
887
 
static int drive_snapshot_read_rom_module(snapshot_t *s, unsigned int dnr)
 
1078
static int drive_snapshot_read_p64image_module(snapshot_t *s, unsigned int dnr)
888
1079
{
889
1080
    BYTE major_version, minor_version;
890
1081
    snapshot_module_t *m;
891
1082
    char snap_module_name[10];
892
 
    BYTE *base;
893
 
    int len;
 
1083
    BYTE *tmpbuf;
894
1084
    drive_t *drive;
 
1085
    TP64MemoryStream P64MemoryStreamInstance;
 
1086
    PP64Image P64Image;
 
1087
    DWORD size;
895
1088
 
896
1089
    drive = drive_context[dnr]->drive;
897
 
 
898
 
    sprintf(snap_module_name, "DRIVEROM%i", dnr);
 
1090
    sprintf(snap_module_name, "P64IMAGE%i", dnr);
899
1091
 
900
1092
    m = snapshot_module_open(s, snap_module_name,
901
1093
                             &major_version, &minor_version);
902
 
    if (m == NULL)
 
1094
    if (m == NULL) {
903
1095
        return 0;
904
 
 
905
 
    if (major_version > ROM_SNAP_MAJOR || minor_version > ROM_SNAP_MINOR) {
 
1096
    }
 
1097
 
 
1098
    P64Image = (void*)drive->p64;
 
1099
 
 
1100
    if (P64Image == NULL) {
 
1101
        if (m != NULL) {
 
1102
            snapshot_module_close(m);
 
1103
        }
 
1104
        return -1;
 
1105
    }
 
1106
 
 
1107
    if (major_version > P64IMAGE_SNAP_MAJOR
 
1108
        || minor_version > P64IMAGE_SNAP_MINOR) {
906
1109
        log_error(drive_snapshot_log,
907
1110
                  "Snapshot module version (%d.%d) newer than %d.%d.",
908
1111
                  major_version, minor_version,
909
 
                  ROM_SNAP_MAJOR, ROM_SNAP_MINOR);
910
 
    }
911
 
 
912
 
    switch (drive->type) {
913
 
      case DRIVE_TYPE_1541:
914
 
        base = &(drive->rom[0x4000]);
915
 
        len = DRIVE_ROM1541_SIZE;
916
 
        break;
917
 
      case DRIVE_TYPE_1541II:
918
 
        base = &(drive->rom[0x4000]);
919
 
        len = DRIVE_ROM1541II_SIZE;
920
 
        break;
921
 
      case DRIVE_TYPE_1551:
922
 
        base = drive->rom;
923
 
        len = DRIVE_ROM1551_SIZE;
924
 
        break;
925
 
      case DRIVE_TYPE_1570:
926
 
        base = drive->rom;
927
 
        len = DRIVE_ROM1571_SIZE;
928
 
        break;
929
 
      case DRIVE_TYPE_1571:
930
 
        base = drive->rom;
931
 
        len = DRIVE_ROM1571_SIZE;
932
 
        break;
933
 
      case DRIVE_TYPE_1571CR:
934
 
        base = drive->rom;
935
 
        len = DRIVE_ROM1571_SIZE;
936
 
        break;
937
 
      case DRIVE_TYPE_1581:
938
 
        base = drive->rom;
939
 
        len = DRIVE_ROM1581_SIZE;
940
 
        break;
941
 
      case DRIVE_TYPE_2031:
942
 
        base = &(drive->rom[0x4000]);
943
 
        len = DRIVE_ROM2031_SIZE;
944
 
        break;
945
 
      case DRIVE_TYPE_2040:
946
 
        base = &(drive->rom[DRIVE_ROM_SIZE - DRIVE_ROM2040_SIZE]);
947
 
        len = DRIVE_ROM2040_SIZE;
948
 
        break;
949
 
      case DRIVE_TYPE_3040:
950
 
        base = &(drive->rom[DRIVE_ROM_SIZE - DRIVE_ROM3040_SIZE]);
951
 
        len = DRIVE_ROM3040_SIZE;
952
 
        break;
953
 
      case DRIVE_TYPE_4040:
954
 
        base = &(drive->rom[DRIVE_ROM_SIZE - DRIVE_ROM4040_SIZE]);
955
 
        len = DRIVE_ROM4040_SIZE;
956
 
        break;
957
 
      case DRIVE_TYPE_1001:
958
 
      case DRIVE_TYPE_8050:
959
 
      case DRIVE_TYPE_8250:
960
 
        base = &(drive->rom[0x4000]);
961
 
        len = DRIVE_ROM1001_SIZE;
962
 
        break;
963
 
      default:
964
 
        return -1;
965
 
    }
966
 
 
967
 
    if (SMR_BA(m, base, len) < 0) {
968
 
        if (m != NULL)
969
 
            snapshot_module_close(m);
970
 
        return -1;
971
 
    }
972
 
 
973
 
    machine_drive_rom_do_checksum(dnr);
 
1112
                  P64IMAGE_SNAP_MAJOR, P64IMAGE_SNAP_MINOR);
 
1113
    }
 
1114
 
 
1115
    if (SMR_DW(m, &size) < 0) {
 
1116
        if (m != NULL) {
 
1117
            snapshot_module_close(m);
 
1118
        }
 
1119
        return -1;
 
1120
    }
 
1121
 
 
1122
    tmpbuf = lib_malloc(size);
 
1123
 
 
1124
    if (SMR_BA(m, tmpbuf, size) < 0) {
 
1125
        if (m != NULL) {
 
1126
            snapshot_module_close(m);
 
1127
        }
 
1128
        lib_free(tmpbuf);
 
1129
        return -1;
 
1130
    }
 
1131
 
 
1132
    P64MemoryStreamCreate(&P64MemoryStreamInstance);
 
1133
    P64MemoryStreamClear(&P64MemoryStreamInstance);
 
1134
    P64MemoryStreamWrite(&P64MemoryStreamInstance,tmpbuf,size);
 
1135
    P64MemoryStreamSeek(&P64MemoryStreamInstance,0);
 
1136
    if (!P64ImageReadFromStream(P64Image,&P64MemoryStreamInstance)) {
 
1137
        if (m != NULL) {
 
1138
            snapshot_module_close(m);
 
1139
        }
 
1140
        lib_free(tmpbuf);
 
1141
        P64MemoryStreamDestroy(&P64MemoryStreamInstance);
 
1142
        return -1;
 
1143
    }
 
1144
 
 
1145
    P64MemoryStreamDestroy(&P64MemoryStreamInstance);
974
1146
 
975
1147
    snapshot_module_close(m);
 
1148
    m = NULL;
 
1149
 
 
1150
    lib_free(tmpbuf);
 
1151
 
 
1152
    drive->P64_image_loaded = 1;
 
1153
    drive->complicated_image_loaded = 1;
 
1154
    drive->image = NULL;
976
1155
 
977
1156
    return 0;
978
1157
}
979
1158
 
 
1159