1 /* tape_accessors.c: accessor functions for libspectrum_tape_block
2    Copyright (c) 2003 Philip Kendall
3 
4    This program is free software; you can redistribute it and/or modify
5    it under the terms of the GNU General Public License as published by
6    the Free Software Foundation; either version 2 of the License, or
7    (at your option) any later version.
8 
9    This program is distributed in the hope that it will be useful,
10    but WITHOUT ANY WARRANTY; without even the implied warranty of
11    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12    GNU General Public License for more details.
13 
14    You should have received a copy of the GNU General Public License along
15    with this program; if not, write to the Free Software Foundation, Inc.,
16    51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
17 
18    Author contact information:
19 
20    E-mail: philip-fuse@shadowmagic.org.uk
21 
22 */
23 
24 /* NB: this file is autogenerated from ../tape_accessors.txt by ../tape_accessors.pl */
25 
26 #include <config.h>
27 
28 #include "internals.h"
29 #include "tape_block.h"
30 
31 libspectrum_dword
libspectrum_tape_block_bit_length(libspectrum_tape_block * block)32 libspectrum_tape_block_bit_length( libspectrum_tape_block *block )
33 {
34   switch( block->type ) {
35 
36     case LIBSPECTRUM_TAPE_BLOCK_RAW_DATA: return block->types.raw_data.bit_length;
37 
38     default:
39       libspectrum_print_error(
40         LIBSPECTRUM_ERROR_INVALID,
41         "invalid block type 0x%02x given to %s", block->type, __func__
42       );
43       return -1;
44   }
45 }
46 
47 libspectrum_dword
libspectrum_tape_block_bit0_length(libspectrum_tape_block * block)48 libspectrum_tape_block_bit0_length( libspectrum_tape_block *block )
49 {
50   switch( block->type ) {
51 
52     case LIBSPECTRUM_TAPE_BLOCK_PURE_DATA: return block->types.pure_data.bit0_length;
53     case LIBSPECTRUM_TAPE_BLOCK_TURBO: return block->types.turbo.bit0_length;
54 
55     default:
56       libspectrum_print_error(
57         LIBSPECTRUM_ERROR_INVALID,
58         "invalid block type 0x%02x given to %s", block->type, __func__
59       );
60       return -1;
61   }
62 }
63 
64 libspectrum_dword
libspectrum_tape_block_bit1_length(libspectrum_tape_block * block)65 libspectrum_tape_block_bit1_length( libspectrum_tape_block *block )
66 {
67   switch( block->type ) {
68 
69     case LIBSPECTRUM_TAPE_BLOCK_PURE_DATA: return block->types.pure_data.bit1_length;
70     case LIBSPECTRUM_TAPE_BLOCK_TURBO: return block->types.turbo.bit1_length;
71 
72     default:
73       libspectrum_print_error(
74         LIBSPECTRUM_ERROR_INVALID,
75         "invalid block type 0x%02x given to %s", block->type, __func__
76       );
77       return -1;
78   }
79 }
80 
81 size_t
libspectrum_tape_block_bits_in_last_byte(libspectrum_tape_block * block)82 libspectrum_tape_block_bits_in_last_byte( libspectrum_tape_block *block )
83 {
84   switch( block->type ) {
85 
86     case LIBSPECTRUM_TAPE_BLOCK_DATA_BLOCK: return block->types.data_block.bits_in_last_byte;
87     case LIBSPECTRUM_TAPE_BLOCK_PURE_DATA: return block->types.pure_data.bits_in_last_byte;
88     case LIBSPECTRUM_TAPE_BLOCK_RAW_DATA: return block->types.raw_data.bits_in_last_byte;
89     case LIBSPECTRUM_TAPE_BLOCK_TURBO: return block->types.turbo.bits_in_last_byte;
90 
91     default:
92       libspectrum_print_error(
93         LIBSPECTRUM_ERROR_INVALID,
94         "invalid block type 0x%02x given to %s", block->type, __func__
95       );
96       return -1;
97   }
98 }
99 
100 size_t
libspectrum_tape_block_bits_per_data_symbol(libspectrum_tape_block * block)101 libspectrum_tape_block_bits_per_data_symbol( libspectrum_tape_block *block )
102 {
103   switch( block->type ) {
104 
105     case LIBSPECTRUM_TAPE_BLOCK_GENERALISED_DATA: return block->types.generalised_data.bits_per_data_symbol;
106 
107     default:
108       libspectrum_print_error(
109         LIBSPECTRUM_ERROR_INVALID,
110         "invalid block type 0x%02x given to %s", block->type, __func__
111       );
112       return -1;
113   }
114 }
115 
116 size_t
libspectrum_tape_block_count(libspectrum_tape_block * block)117 libspectrum_tape_block_count( libspectrum_tape_block *block )
118 {
119   switch( block->type ) {
120 
121     case LIBSPECTRUM_TAPE_BLOCK_PURE_TONE: return block->types.pure_tone.pulses;
122     case LIBSPECTRUM_TAPE_BLOCK_PULSES: return block->types.pulses.count;
123     case LIBSPECTRUM_TAPE_BLOCK_LOOP_START: return block->types.loop_start.count;
124     case LIBSPECTRUM_TAPE_BLOCK_SELECT: return block->types.select.count;
125     case LIBSPECTRUM_TAPE_BLOCK_ARCHIVE_INFO: return block->types.archive_info.count;
126     case LIBSPECTRUM_TAPE_BLOCK_HARDWARE: return block->types.hardware.count;
127     case LIBSPECTRUM_TAPE_BLOCK_PULSE_SEQUENCE: return block->types.pulse_sequence.count;
128     case LIBSPECTRUM_TAPE_BLOCK_DATA_BLOCK: return block->types.data_block.count;
129 
130     default:
131       libspectrum_print_error(
132         LIBSPECTRUM_ERROR_INVALID,
133         "invalid block type 0x%02x given to %s", block->type, __func__
134       );
135       return -1;
136   }
137 }
138 
139 libspectrum_byte*
libspectrum_tape_block_data(libspectrum_tape_block * block)140 libspectrum_tape_block_data( libspectrum_tape_block *block )
141 {
142   switch( block->type ) {
143 
144     case LIBSPECTRUM_TAPE_BLOCK_CUSTOM: return block->types.custom.data;
145     case LIBSPECTRUM_TAPE_BLOCK_DATA_BLOCK: return block->types.data_block.data;
146     case LIBSPECTRUM_TAPE_BLOCK_GENERALISED_DATA: return block->types.generalised_data.data;
147     case LIBSPECTRUM_TAPE_BLOCK_PURE_DATA: return block->types.pure_data.data;
148     case LIBSPECTRUM_TAPE_BLOCK_RAW_DATA: return block->types.raw_data.data;
149     case LIBSPECTRUM_TAPE_BLOCK_RLE_PULSE: return block->types.rle_pulse.data;
150     case LIBSPECTRUM_TAPE_BLOCK_ROM: return block->types.rom.data;
151     case LIBSPECTRUM_TAPE_BLOCK_TURBO: return block->types.turbo.data;
152 
153     default:
154       libspectrum_print_error(
155         LIBSPECTRUM_ERROR_INVALID,
156         "invalid block type 0x%02x given to %s", block->type, __func__
157       );
158       return NULL;
159   }
160 }
161 
162 size_t
libspectrum_tape_block_data_length(libspectrum_tape_block * block)163 libspectrum_tape_block_data_length( libspectrum_tape_block *block )
164 {
165   switch( block->type ) {
166 
167     case LIBSPECTRUM_TAPE_BLOCK_CUSTOM: return block->types.custom.length;
168     case LIBSPECTRUM_TAPE_BLOCK_DATA_BLOCK: return block->types.data_block.length;
169     case LIBSPECTRUM_TAPE_BLOCK_PURE_DATA: return block->types.pure_data.length;
170     case LIBSPECTRUM_TAPE_BLOCK_RAW_DATA: return block->types.raw_data.length;
171     case LIBSPECTRUM_TAPE_BLOCK_RLE_PULSE: return block->types.rle_pulse.length;
172     case LIBSPECTRUM_TAPE_BLOCK_ROM: return block->types.rom.length;
173     case LIBSPECTRUM_TAPE_BLOCK_TURBO: return block->types.turbo.length;
174 
175     default:
176       libspectrum_print_error(
177         LIBSPECTRUM_ERROR_INVALID,
178         "invalid block type 0x%02x given to %s", block->type, __func__
179       );
180       return -1;
181   }
182 }
183 
184 libspectrum_tape_generalised_data_symbol_table*
libspectrum_tape_block_data_table(libspectrum_tape_block * block)185 libspectrum_tape_block_data_table( libspectrum_tape_block *block )
186 {
187   switch( block->type ) {
188 
189     case LIBSPECTRUM_TAPE_BLOCK_GENERALISED_DATA: return &block->types.generalised_data.data_table;
190 
191     default:
192       libspectrum_print_error(
193         LIBSPECTRUM_ERROR_INVALID,
194         "invalid block type 0x%02x given to %s", block->type, __func__
195       );
196       return NULL;
197   }
198 }
199 
200 int
libspectrum_tape_block_ids(libspectrum_tape_block * block,size_t index)201 libspectrum_tape_block_ids( libspectrum_tape_block *block, size_t index )
202 {
203   switch( block->type ) {
204 
205     case LIBSPECTRUM_TAPE_BLOCK_ARCHIVE_INFO: return block->types.archive_info.ids[ index ];
206     case LIBSPECTRUM_TAPE_BLOCK_HARDWARE: return block->types.hardware.ids[ index ];
207 
208     default:
209       libspectrum_print_error(
210         LIBSPECTRUM_ERROR_INVALID,
211         "invalid block type 0x%02x given to %s", block->type, __func__
212       );
213       return -1;
214   }
215 }
216 
217 int
libspectrum_tape_block_offset(libspectrum_tape_block * block)218 libspectrum_tape_block_offset( libspectrum_tape_block *block )
219 {
220   switch( block->type ) {
221 
222     case LIBSPECTRUM_TAPE_BLOCK_JUMP: return block->types.jump.offset;
223 
224     default:
225       libspectrum_print_error(
226         LIBSPECTRUM_ERROR_INVALID,
227         "invalid block type 0x%02x given to %s", block->type, __func__
228       );
229       return 0;
230   }
231 }
232 
233 int
libspectrum_tape_block_offsets(libspectrum_tape_block * block,size_t index)234 libspectrum_tape_block_offsets( libspectrum_tape_block *block, size_t index )
235 {
236   switch( block->type ) {
237 
238     case LIBSPECTRUM_TAPE_BLOCK_SELECT: return block->types.select.offsets[ index ];
239 
240     default:
241       libspectrum_print_error(
242         LIBSPECTRUM_ERROR_INVALID,
243         "invalid block type 0x%02x given to %s", block->type, __func__
244       );
245       return 0;
246   }
247 }
248 
249 libspectrum_dword
libspectrum_tape_block_pause(libspectrum_tape_block * block)250 libspectrum_tape_block_pause( libspectrum_tape_block *block )
251 {
252   switch( block->type ) {
253 
254     case LIBSPECTRUM_TAPE_BLOCK_GENERALISED_DATA: return block->types.generalised_data.pause;
255     case LIBSPECTRUM_TAPE_BLOCK_MESSAGE: return block->types.message.time;
256     case LIBSPECTRUM_TAPE_BLOCK_PAUSE: return block->types.pause.length;
257     case LIBSPECTRUM_TAPE_BLOCK_PURE_DATA: return block->types.pure_data.pause;
258     case LIBSPECTRUM_TAPE_BLOCK_RAW_DATA: return block->types.raw_data.pause;
259     case LIBSPECTRUM_TAPE_BLOCK_ROM: return block->types.rom.pause;
260     case LIBSPECTRUM_TAPE_BLOCK_TURBO: return block->types.turbo.pause;
261 
262     default:
263       libspectrum_print_error(
264         LIBSPECTRUM_ERROR_INVALID,
265         "invalid block type 0x%02x given to %s", block->type, __func__
266       );
267       return -1;
268   }
269 }
270 
271 libspectrum_dword
libspectrum_tape_block_pause_tstates(libspectrum_tape_block * block)272 libspectrum_tape_block_pause_tstates( libspectrum_tape_block *block )
273 {
274   switch( block->type ) {
275 
276     case LIBSPECTRUM_TAPE_BLOCK_GENERALISED_DATA: return block->types.generalised_data.pause_tstates;
277     case LIBSPECTRUM_TAPE_BLOCK_MESSAGE: return block->types.message.time_tstates;
278     case LIBSPECTRUM_TAPE_BLOCK_PAUSE: return block->types.pause.length_tstates;
279     case LIBSPECTRUM_TAPE_BLOCK_PURE_DATA: return block->types.pure_data.pause_tstates;
280     case LIBSPECTRUM_TAPE_BLOCK_RAW_DATA: return block->types.raw_data.pause_tstates;
281     case LIBSPECTRUM_TAPE_BLOCK_ROM: return block->types.rom.pause_tstates;
282     case LIBSPECTRUM_TAPE_BLOCK_TURBO: return block->types.turbo.pause_tstates;
283 
284     default:
285       libspectrum_print_error(
286         LIBSPECTRUM_ERROR_INVALID,
287         "invalid block type 0x%02x given to %s", block->type, __func__
288       );
289       return -1;
290   }
291 }
292 
293 libspectrum_dword
libspectrum_tape_block_pilot_length(libspectrum_tape_block * block)294 libspectrum_tape_block_pilot_length( libspectrum_tape_block *block )
295 {
296   switch( block->type ) {
297 
298     case LIBSPECTRUM_TAPE_BLOCK_TURBO: return block->types.turbo.pilot_length;
299 
300     default:
301       libspectrum_print_error(
302         LIBSPECTRUM_ERROR_INVALID,
303         "invalid block type 0x%02x given to %s", block->type, __func__
304       );
305       return -1;
306   }
307 }
308 
309 size_t
libspectrum_tape_block_pilot_pulses(libspectrum_tape_block * block)310 libspectrum_tape_block_pilot_pulses( libspectrum_tape_block *block )
311 {
312   switch( block->type ) {
313 
314     case LIBSPECTRUM_TAPE_BLOCK_TURBO: return block->types.turbo.pilot_pulses;
315 
316     default:
317       libspectrum_print_error(
318         LIBSPECTRUM_ERROR_INVALID,
319         "invalid block type 0x%02x given to %s", block->type, __func__
320       );
321       return -1;
322   }
323 }
324 
325 libspectrum_word
libspectrum_tape_block_pilot_repeats(libspectrum_tape_block * block,size_t index)326 libspectrum_tape_block_pilot_repeats( libspectrum_tape_block *block, size_t index )
327 {
328   switch( block->type ) {
329 
330     case LIBSPECTRUM_TAPE_BLOCK_GENERALISED_DATA: return block->types.generalised_data.pilot_repeats[ index ];
331 
332     default:
333       libspectrum_print_error(
334         LIBSPECTRUM_ERROR_INVALID,
335         "invalid block type 0x%02x given to %s", block->type, __func__
336       );
337       return -1;
338   }
339 }
340 
341 libspectrum_byte
libspectrum_tape_block_pilot_symbols(libspectrum_tape_block * block,size_t index)342 libspectrum_tape_block_pilot_symbols( libspectrum_tape_block *block, size_t index )
343 {
344   switch( block->type ) {
345 
346     case LIBSPECTRUM_TAPE_BLOCK_GENERALISED_DATA: return block->types.generalised_data.pilot_symbols[ index ];
347 
348     default:
349       libspectrum_print_error(
350         LIBSPECTRUM_ERROR_INVALID,
351         "invalid block type 0x%02x given to %s", block->type, __func__
352       );
353       return -1;
354   }
355 }
356 
357 libspectrum_tape_generalised_data_symbol_table*
libspectrum_tape_block_pilot_table(libspectrum_tape_block * block)358 libspectrum_tape_block_pilot_table( libspectrum_tape_block *block )
359 {
360   switch( block->type ) {
361 
362     case LIBSPECTRUM_TAPE_BLOCK_GENERALISED_DATA: return &block->types.generalised_data.pilot_table;
363 
364     default:
365       libspectrum_print_error(
366         LIBSPECTRUM_ERROR_INVALID,
367         "invalid block type 0x%02x given to %s", block->type, __func__
368       );
369       return NULL;
370   }
371 }
372 
373 libspectrum_dword
libspectrum_tape_block_pulse_length(libspectrum_tape_block * block)374 libspectrum_tape_block_pulse_length( libspectrum_tape_block *block )
375 {
376   switch( block->type ) {
377 
378     case LIBSPECTRUM_TAPE_BLOCK_PURE_TONE: return block->types.pure_tone.length;
379 
380     default:
381       libspectrum_print_error(
382         LIBSPECTRUM_ERROR_INVALID,
383         "invalid block type 0x%02x given to %s", block->type, __func__
384       );
385       return -1;
386   }
387 }
388 
389 libspectrum_dword
libspectrum_tape_block_scale(libspectrum_tape_block * block)390 libspectrum_tape_block_scale( libspectrum_tape_block *block )
391 {
392   switch( block->type ) {
393 
394     case LIBSPECTRUM_TAPE_BLOCK_RLE_PULSE: return block->types.rle_pulse.scale;
395 
396     default:
397       libspectrum_print_error(
398         LIBSPECTRUM_ERROR_INVALID,
399         "invalid block type 0x%02x given to %s", block->type, __func__
400       );
401       return -1;
402   }
403 }
404 
405 libspectrum_dword
libspectrum_tape_block_pulse_lengths(libspectrum_tape_block * block,size_t index)406 libspectrum_tape_block_pulse_lengths( libspectrum_tape_block *block, size_t index )
407 {
408   switch( block->type ) {
409 
410     case LIBSPECTRUM_TAPE_BLOCK_PULSES: return block->types.pulses.lengths[ index ];
411     case LIBSPECTRUM_TAPE_BLOCK_PULSE_SEQUENCE: return block->types.pulse_sequence.lengths[ index ];
412 
413     default:
414       libspectrum_print_error(
415         LIBSPECTRUM_ERROR_INVALID,
416         "invalid block type 0x%02x given to %s", block->type, __func__
417       );
418       return -1;
419   }
420 }
421 
422 size_t
libspectrum_tape_block_pulse_repeats(libspectrum_tape_block * block,size_t index)423 libspectrum_tape_block_pulse_repeats( libspectrum_tape_block *block, size_t index )
424 {
425   switch( block->type ) {
426 
427     case LIBSPECTRUM_TAPE_BLOCK_PULSE_SEQUENCE: return block->types.pulse_sequence.pulse_repeats[ index ];
428 
429     default:
430       libspectrum_print_error(
431         LIBSPECTRUM_ERROR_INVALID,
432         "invalid block type 0x%02x given to %s", block->type, __func__
433       );
434       return -1;
435   }
436 }
437 
438 libspectrum_dword
libspectrum_tape_block_sync1_length(libspectrum_tape_block * block)439 libspectrum_tape_block_sync1_length( libspectrum_tape_block *block )
440 {
441   switch( block->type ) {
442 
443     case LIBSPECTRUM_TAPE_BLOCK_TURBO: return block->types.turbo.sync1_length;
444 
445     default:
446       libspectrum_print_error(
447         LIBSPECTRUM_ERROR_INVALID,
448         "invalid block type 0x%02x given to %s", block->type, __func__
449       );
450       return -1;
451   }
452 }
453 
454 libspectrum_dword
libspectrum_tape_block_sync2_length(libspectrum_tape_block * block)455 libspectrum_tape_block_sync2_length( libspectrum_tape_block *block )
456 {
457   switch( block->type ) {
458 
459     case LIBSPECTRUM_TAPE_BLOCK_TURBO: return block->types.turbo.sync2_length;
460 
461     default:
462       libspectrum_print_error(
463         LIBSPECTRUM_ERROR_INVALID,
464         "invalid block type 0x%02x given to %s", block->type, __func__
465       );
466       return -1;
467   }
468 }
469 
470 libspectrum_dword
libspectrum_tape_block_tail_length(libspectrum_tape_block * block)471 libspectrum_tape_block_tail_length( libspectrum_tape_block *block )
472 {
473   switch( block->type ) {
474 
475     case LIBSPECTRUM_TAPE_BLOCK_DATA_BLOCK: return block->types.data_block.tail_length;
476 
477     default:
478       libspectrum_print_error(
479         LIBSPECTRUM_ERROR_INVALID,
480         "invalid block type 0x%02x given to %s", block->type, __func__
481       );
482       return -1;
483   }
484 }
485 
486 char*
libspectrum_tape_block_text(libspectrum_tape_block * block)487 libspectrum_tape_block_text( libspectrum_tape_block *block )
488 {
489   switch( block->type ) {
490 
491     case LIBSPECTRUM_TAPE_BLOCK_GROUP_START: return block->types.group_start.name;
492     case LIBSPECTRUM_TAPE_BLOCK_COMMENT: return block->types.comment.text;
493     case LIBSPECTRUM_TAPE_BLOCK_MESSAGE: return block->types.message.text;
494     case LIBSPECTRUM_TAPE_BLOCK_CUSTOM: return block->types.custom.description;
495 
496     default:
497       libspectrum_print_error(
498         LIBSPECTRUM_ERROR_INVALID,
499         "invalid block type 0x%02x given to %s", block->type, __func__
500       );
501       return NULL;
502   }
503 }
504 
505 char*
libspectrum_tape_block_texts(libspectrum_tape_block * block,size_t index)506 libspectrum_tape_block_texts( libspectrum_tape_block *block, size_t index )
507 {
508   switch( block->type ) {
509 
510     case LIBSPECTRUM_TAPE_BLOCK_ARCHIVE_INFO: return block->types.archive_info.strings[ index ];
511     case LIBSPECTRUM_TAPE_BLOCK_SELECT: return block->types.select.descriptions[ index ];
512 
513     default:
514       libspectrum_print_error(
515         LIBSPECTRUM_ERROR_INVALID,
516         "invalid block type 0x%02x given to %s", block->type, __func__
517       );
518       return NULL;
519   }
520 }
521 
522 int
libspectrum_tape_block_types(libspectrum_tape_block * block,size_t index)523 libspectrum_tape_block_types( libspectrum_tape_block *block, size_t index )
524 {
525   switch( block->type ) {
526 
527     case LIBSPECTRUM_TAPE_BLOCK_HARDWARE: return block->types.hardware.types[ index ];
528 
529     default:
530       libspectrum_print_error(
531         LIBSPECTRUM_ERROR_INVALID,
532         "invalid block type 0x%02x given to %s", block->type, __func__
533       );
534       return -1;
535   }
536 }
537 
538 int
libspectrum_tape_block_values(libspectrum_tape_block * block,size_t index)539 libspectrum_tape_block_values( libspectrum_tape_block *block, size_t index )
540 {
541   switch( block->type ) {
542 
543     case LIBSPECTRUM_TAPE_BLOCK_HARDWARE: return block->types.hardware.values[ index ];
544 
545     default:
546       libspectrum_print_error(
547         LIBSPECTRUM_ERROR_INVALID,
548         "invalid block type 0x%02x given to %s", block->type, __func__
549       );
550       return -1;
551   }
552 }
553 
554 int
libspectrum_tape_block_level(libspectrum_tape_block * block)555 libspectrum_tape_block_level( libspectrum_tape_block *block )
556 {
557   switch( block->type ) {
558 
559     case LIBSPECTRUM_TAPE_BLOCK_PAUSE: return block->types.pause.level;
560     case LIBSPECTRUM_TAPE_BLOCK_DATA_BLOCK: return block->types.data_block.initial_level;
561     case LIBSPECTRUM_TAPE_BLOCK_SET_SIGNAL_LEVEL: return block->types.set_signal_level.level;
562 
563     default:
564       libspectrum_print_error(
565         LIBSPECTRUM_ERROR_INVALID,
566         "invalid block type 0x%02x given to %s", block->type, __func__
567       );
568       return -1;
569   }
570 }
571 
572 libspectrum_byte
libspectrum_tape_block_bit0_pulse_count(libspectrum_tape_block * block)573 libspectrum_tape_block_bit0_pulse_count( libspectrum_tape_block *block )
574 {
575   switch( block->type ) {
576 
577     case LIBSPECTRUM_TAPE_BLOCK_DATA_BLOCK: return block->types.data_block.bit0_pulse_count;
578 
579     default:
580       libspectrum_print_error(
581         LIBSPECTRUM_ERROR_INVALID,
582         "invalid block type 0x%02x given to %s", block->type, __func__
583       );
584       return -1;
585   }
586 }
587 
588 libspectrum_byte
libspectrum_tape_block_bit1_pulse_count(libspectrum_tape_block * block)589 libspectrum_tape_block_bit1_pulse_count( libspectrum_tape_block *block )
590 {
591   switch( block->type ) {
592 
593     case LIBSPECTRUM_TAPE_BLOCK_DATA_BLOCK: return block->types.data_block.bit1_pulse_count;
594 
595     default:
596       libspectrum_print_error(
597         LIBSPECTRUM_ERROR_INVALID,
598         "invalid block type 0x%02x given to %s", block->type, __func__
599       );
600       return -1;
601   }
602 }
603 
604 libspectrum_word
libspectrum_tape_block_bit0_pulses(libspectrum_tape_block * block,size_t index)605 libspectrum_tape_block_bit0_pulses( libspectrum_tape_block *block, size_t index )
606 {
607   switch( block->type ) {
608 
609     case LIBSPECTRUM_TAPE_BLOCK_DATA_BLOCK: return block->types.data_block.bit0_pulses[ index ];
610 
611     default:
612       libspectrum_print_error(
613         LIBSPECTRUM_ERROR_INVALID,
614         "invalid block type 0x%02x given to %s", block->type, __func__
615       );
616       return -1;
617   }
618 }
619 
620 libspectrum_word
libspectrum_tape_block_bit1_pulses(libspectrum_tape_block * block,size_t index)621 libspectrum_tape_block_bit1_pulses( libspectrum_tape_block *block, size_t index )
622 {
623   switch( block->type ) {
624 
625     case LIBSPECTRUM_TAPE_BLOCK_DATA_BLOCK: return block->types.data_block.bit1_pulses[ index ];
626 
627     default:
628       libspectrum_print_error(
629         LIBSPECTRUM_ERROR_INVALID,
630         "invalid block type 0x%02x given to %s", block->type, __func__
631       );
632       return -1;
633   }
634 }
635 
636