[VM][CMT] Align endianess around loading/saving WAV.

diff --git a/source/src/qt/osd_sound.cpp b/source/src/qt/osd_sound.cpp
index 00a6061..f0bad2c 100644 (file)
--- a/source/src/qt/osd_sound.cpp
+++ b/source/src/qt/osd_sound.cpp
@@ -381,21 +381,42 @@ void OSD_BASE::stop_record_sound()
                        // update wave header
                        wav_header_t wav_header;
                        wav_chunk_t wav_chunk;
+                       pair16_t tmpval16;
+                       pair_t tmpval32;
                        
                        memcpy(wav_header.riff_chunk.id, "RIFF", 4);
-                       wav_header.riff_chunk.size = EndianToLittle_DWORD(rec_sound_bytes + sizeof(wav_header_t) - 8);
+                       
+                       tmpval32.d = rec_sound_bytes + sizeof(wav_header_t) - 8;
+                       wav_header.riff_chunk.size = tmpval32.get_4bytes_le_to();
+                       
                        memcpy(wav_header.wave, "WAVE", 4);
                        memcpy(wav_header.fmt_chunk.id, "fmt ", 4);
-                       wav_header.fmt_chunk.size = EndianToLittle_DWORD(16);
-                       wav_header.format_id = EndianToLittle_WORD(1);
-                       wav_header.channels =  EndianToLittle_WORD(2);
-                       wav_header.sample_bits = EndianToLittle_WORD(16);
-                       wav_header.sample_rate = EndianToLittle_DWORD(snd_spec_presented.freq);
-                       wav_header.block_size = EndianToLittle_WORD(wav_header.channels * wav_header.sample_bits / 8);
-                       wav_header.data_speed = EndianToLittle_DWORD(wav_header.sample_rate * wav_header.block_size);
+                       
+                       tmpval32.d = 16;
+                       wav_header.fmt_chunk.size = tmpval32.get_4bytes_le_to();
+
+                       tmpval16.w = 1;
+                       wav_header.format_id = tmpval16.get_2bytes_le_to();
+                       
+                       tmpval16.w = 2;
+                       wav_header.channels =  tmpval16.get_2bytes_le_to();
+                       
+                       tmpval16.w = 16;
+                       wav_header.sample_bits = tmpval16.get_2bytes_le_to();
+
+                       tmpval32.d = snd_spec_presented.freq;
+                       wav_header.sample_rate = tmpval32.get_4bytes_le_to();
+
+                       tmpval16.w = wav_header.channels * wav_header.sample_bits / 8;
+                       wav_header.block_size = tmpval16.get_2bytes_le_to();
+
+                       tmpval32.d = wav_header.sample_rate * wav_header.block_size;
+                       wav_header.data_speed = tmpval32.get_4bytes_le_to();
                        
                        memcpy(wav_chunk.id, "data", 4);
-                       wav_chunk.size = EndianToLittle_DWORD(rec_sound_bytes);
+
+                       tmpval32.d = rec_sound_bytes;
+                       wav_chunk.size = tmpval32.get_4bytes_le_to();
 
                        rec_sound_fio->Fseek(0, FILEIO_SEEK_SET);
                        rec_sound_fio->Fwrite(&wav_header, sizeof(wav_header_t), 1);

diff --git a/source/src/vm/datarec.cpp b/source/src/vm/datarec.cpp
index 4837475..e8c9017 100644 (file)
--- a/source/src/vm/datarec.cpp
+++ b/source/src/vm/datarec.cpp
@@ -720,38 +720,57 @@ int DATAREC::load_wav_image(int offset)
        // check wave header
        wav_header_t header;
        wav_chunk_t chunk;
+       pair_t tmpval32;
+       pair16_t tmpval16;
+       
+       pair16_t __fmt_id;
+       pair16_t __sample_bits;
+       pair16_t __channels;
+       pair_t __sample_rate;
+       pair_t __chunk_size;
        
        play_fio->Fseek(offset, FILEIO_SEEK_SET);
        play_fio->Fread(&header, sizeof(header), 1);
-       if(header.format_id != 1 || !(header.sample_bits == 8 || header.sample_bits == 16)) {
+       
+       __fmt_id.set_2bytes_le_from(header.format_id);
+       __sample_bits.set_2bytes_le_from(header.sample_bits);
+       
+       if((__fmt_id.w != 1) || !((__sample_bits.w == 8) || (__sample_bits.w == 16))) {
                return 0;
        }
-       play_fio->Fseek(header.fmt_chunk.size - 16, FILEIO_SEEK_CUR);
+       tmpval32.set_4bytes_le_from(header.fmt_chunk.size);
+       play_fio->Fseek(tmpval32.d - 16, FILEIO_SEEK_CUR);
        while(1) {
                play_fio->Fread(&chunk, sizeof(chunk), 1);
+               __chunk_size.set_4bytes_le_from(chunk.size);
                if(strncmp(chunk.id, "data", 4) == 0) {
                        break;
                }
-               play_fio->Fseek(chunk.size, FILEIO_SEEK_CUR);
+
+               play_fio->Fseek(tmpval32.d, FILEIO_SEEK_CUR);
        }
+
+       __channels.set_2bytes_le_from(header.channels);
        
-       int samples = chunk.size / header.channels, loaded_samples = 0;
-       if(header.sample_bits == 16) {
+       int samples = (int)(__chunk_size.d / (uint32_t)(__channels.w)), loaded_samples = 0;
+
+       if(__sample_bits.w == 16) {
                samples /= 2;
        }
-       sample_rate = header.sample_rate;
-       sample_usec = 1000000. / sample_rate;
+       __sample_rate.set_4bytes_le_from(header.sample_rate);
+       sample_rate = __sample_rate.d;
+       sample_usec = 1000000. / (float)sample_rate;
        
        // load samples
        if(samples > 0) {
-               #define TMP_LENGTH (0x10000 * header.channels)
+               #define TMP_LENGTH (0x10000 * (uint32_t)(__channels.w))
                
                uint8_t *tmp_buffer = (uint8_t *)malloc(TMP_LENGTH);
                play_fio->Fread(tmp_buffer, TMP_LENGTH, 1);
                
                #define GET_SAMPLE { \
-                       for(int ch = 0; ch < header.channels; ch++) { \
-                               if(header.sample_bits == 16) { \
+                       for(int ch = 0; ch < __channels.sw; ch++) { \
+                               if(__sample_bits.w == 16) { \
                                        union { \
                                                int16_t s16; \
                                                struct { \
@@ -773,7 +792,7 @@ int DATAREC::load_wav_image(int offset)
 
                bool __t = false;
                if(__DATAREC_SOUND) {
-                  if(!config.wave_shaper[drive_num] || header.channels > 1) {
+                  if(!config.wave_shaper[drive_num] || __channels.w > 1) {
                           __t = true;
                   }
                } else {
@@ -790,7 +809,7 @@ int DATAREC::load_wav_image(int offset)
                        // load samples
 //#ifdef DATAREC_SOUND
                        if(__DATAREC_SOUND) {
-                               if(header.channels > 1) {
+                               if(__channels.w > 1) {
                                        sound_buffer_length = samples * sizeof(int16_t);
                                        sound_buffer = (int16_t *)malloc(sound_buffer_length);
                                }
@@ -803,7 +822,7 @@ int DATAREC::load_wav_image(int offset)
                                int16_t sample_signal = sample[0];
 //#ifdef DATAREC_SOUND
                                if(__DATAREC_SOUND) {
-                                       if(header.channels > 1) {
+                                       if(__channels.w > 1) {
 //#ifdef DATAREC_SOUND_LEFT
                                                if(__DATAREC_SOUND_LEFT) {
                                                        sample_signal = sample[1];
@@ -818,7 +837,7 @@ int DATAREC::load_wav_image(int offset)
 //#endif
                                wav_buffer[i] = sample_signal;
                        }
-                       adjust_zero_position(wav_buffer, samples, header.sample_rate);
+                       adjust_zero_position(wav_buffer, samples, __sample_rate.d);
                        
                        // copy to dest buffer
                        buffer = (uint8_t *)malloc(samples);
@@ -883,14 +902,14 @@ int DATAREC::load_wav_image(int offset)
                                GET_SAMPLE
                                wav_buffer[i] = sample[0];
                        }
-                       adjust_zero_position(wav_buffer, samples, header.sample_rate);
+                       adjust_zero_position(wav_buffer, samples, __sample_rate.d);
                        
                        // t=0 : get thresholds
                        // t=1 : get number of samples
                        // t=2 : load samples
                        #define FREQ_SCALE 16
-                       int min_threshold = (int)(header.sample_rate * FREQ_SCALE / 2400.0 / 2.0 / 3.0 + 0.5);
-                       int max_threshold = (int)(header.sample_rate * FREQ_SCALE / 1200.0 / 2.0 * 3.0 + 0.5);
+                       int min_threshold = (int)(__sample_rate.d * FREQ_SCALE / 2400.0 / 2.0 / 3.0 + 0.5);
+                       int max_threshold = (int)(__sample_rate.d * FREQ_SCALE / 1200.0 / 2.0 * 3.0 + 0.5);
                        int half_threshold, hi_count, lo_count;
                        int *counts = (int *)calloc(max_threshold, sizeof(int));
                        
@@ -946,7 +965,7 @@ int DATAREC::load_wav_image(int offset)
                                        if(sum_count > 60 * 1920) {
                                                half_tmp = (int)((double)sum_value / (double)sum_count + 0.5);
                                        } else {
-                                               half_tmp = (int)(header.sample_rate * FREQ_SCALE / 1920.0 / 2.0 + 0.5);
+                                               half_tmp = (int)(__sample_rate.d * FREQ_SCALE / 1920.0 / 2.0 + 0.5);
                                        }
                                        
                                        sum_value = sum_count = 0;
@@ -988,7 +1007,7 @@ int DATAREC::load_wav_image(int offset)
                                        buffer = (uint8_t *)malloc(loaded_samples);
 //#ifdef DATAREC_SOUND
                                        if(__DATAREC_SOUND) {
-                                               if(header.channels > 1) {
+                                               if(__channels.w > 1) {
                                                        sound_buffer_length = loaded_samples * sizeof(int16_t);
                                                        sound_buffer = (int16_t *)malloc(sound_buffer_length);
                                                }
@@ -1016,21 +1035,39 @@ void DATAREC::save_wav_image()
        
        wav_header_t wav_header;
        wav_chunk_t wav_chunk;
+       pair_t __riff_chunk_size;
+       pair_t __fmt_chunk_size;
+       pair_t __wav_chunk_size;
+       pair16_t __fmt_id;
+       pair16_t __channels;
+       pair_t __sample_rate;
+       pair16_t __block_size;
+       pair16_t __sample_bits;
+
+       __riff_chunk_size.d = length - 8;
+       __fmt_chunk_size.d = 16;
+       __fmt_id.w = 1;
+       __channels.w = 1;
+       __sample_rate.d = sample_rate;
+       __block_size.w = 1;
+       __sample_bits.w = 8;
        
        memcpy(wav_header.riff_chunk.id, "RIFF", 4);
-       wav_header.riff_chunk.size = length - 8;
+       wav_header.riff_chunk.size = __riff_chunk_size.get_4bytes_le_to();
+       
        memcpy(wav_header.wave, "WAVE", 4);
        memcpy(wav_header.fmt_chunk.id, "fmt ", 4);
-       wav_header.fmt_chunk.size = 16;
-       wav_header.format_id = 1;
-       wav_header.channels = 1;
-       wav_header.sample_rate = sample_rate;
-       wav_header.data_speed = sample_rate;
-       wav_header.block_size = 1;
-       wav_header.sample_bits = 8;
+       wav_header.fmt_chunk.size = __riff_chunk_size.get_4bytes_le_to();
+       wav_header.format_id = __fmt_id.get_2bytes_le_to();
+       wav_header.channels = __channels.get_2bytes_le_to();
+       wav_header.sample_rate = __sample_rate.get_4bytes_le_to();
+       wav_header.data_speed =  __sample_rate.get_4bytes_le_to();
+       wav_header.block_size = __block_size.get_2bytes_le_to();
+       wav_header.sample_bits = __sample_bits.get_2bytes_le_to();
        
        memcpy(wav_chunk.id, "data", 4);
-       wav_chunk.size = length - sizeof(wav_header) - sizeof(wav_chunk);
+       __wav_chunk_size.d = length - sizeof(wav_header) - sizeof(wav_chunk);
+       wav_chunk.size = __wav_chunk_size.get_4bytes_le_to();
        
        rec_fio->Fseek(0, FILEIO_SEEK_SET);
        rec_fio->Fwrite(&wav_header, sizeof(wav_header), 1);

diff --git a/source/src/vm/fp200/io.cpp b/source/src/vm/fp200/io.cpp
index 4712e89..c3183a9 100644 (file)
--- a/source/src/vm/fp200/io.cpp
+++ b/source/src/vm/fp200/io.cpp
@@ -508,20 +508,39 @@ void IO::close_tape()
                                wav_header_t wav_header;
                                wav_chunk_t wav_chunk;
                                
+                               pair_t __riff_chunk_size;
+                               pair_t __fmt_chunk_size;
+                               pair_t __wav_chunk_size;
+                               pair16_t __fmt_id;
+                               pair16_t __channels;
+                               pair_t __sample_rate;
+                               pair16_t __block_size;
+                               pair16_t __sample_bits;
+
+                               __riff_chunk_size.d = length - 8;
+                               __fmt_chunk_size.d = 16;
+                               __fmt_id.w = 1;
+                               __channels.w = 1;
+                               __sample_rate.d = CMT_SAMPLE_RATE;
+                               __block_size.w = 1;
+                               __sample_bits.w = 8;
+       
                                memcpy(wav_header.riff_chunk.id, "RIFF", 4);
-                               wav_header.riff_chunk.size = length - 8;
+                               wav_header.riff_chunk.size = __riff_chunk_size.get_4bytes_le_to();
+       
                                memcpy(wav_header.wave, "WAVE", 4);
                                memcpy(wav_header.fmt_chunk.id, "fmt ", 4);
-                               wav_header.fmt_chunk.size = 16;
-                               wav_header.format_id = 1;
-                               wav_header.channels = 1;
-                               wav_header.sample_rate = CMT_SAMPLE_RATE;
-                               wav_header.data_speed = CMT_SAMPLE_RATE;
-                               wav_header.block_size = 1;
-                               wav_header.sample_bits = 8;
-                               
+                               wav_header.fmt_chunk.size = __riff_chunk_size.get_4bytes_le_to();
+                               wav_header.format_id = __fmt_id.get_2bytes_le_to();
+                               wav_header.channels = __channels.get_2byte_le_to();
+                               wav_header.sample_rate = __sample_rate.get_4bytes_le_to();
+                               wav_header.data_speed =  __sample_rate.get_4bytes_le_to();
+                               wav_header.block_size = __block_size.get_2bytes_le_to();
+                               wav_header.sample_bits = __sample_bits_get_2bytes_le_to();
+       
                                memcpy(wav_chunk.id, "data", 4);
-                               wav_chunk.size = length - sizeof(wav_header) - sizeof(wav_chunk);
+                               __wav_chunk_size.d = length - sizeof(wav_header) - sizeof(wav_chunk);
+                               wav_chunk.size = __wav_chunk_size.get_4bytes_le_to();
                                
                                cmt_fio->Fseek(0, FILEIO_SEEK_SET);
                                cmt_fio->Fwrite(&wav_header, sizeof(wav_header), 1);

diff --git a/source/src/vm/noise.cpp b/source/src/vm/noise.cpp
index 9ac64a5..d7f9671 100644 (file)
--- a/source/src/vm/noise.cpp
+++ b/source/src/vm/noise.cpp
@@ -79,45 +79,54 @@ bool NOISE::load_wav_file(const _TCHAR *file_name)
        if(fio->Fopen(create_local_path(file_name), FILEIO_READ_BINARY)) {
                wav_header_t header;
                wav_chunk_t chunk;
-               uint16_t __nr_channels;
-               uint16_t __nr_bits;
+               pair16_t __fmt_id;
+               pair16_t __sample_bits;
+               pair16_t __channels;
+               pair_t __sample_rate;
+               pair_t __chunk_size;
+
                fio->Fread(&header, sizeof(header), 1);
+               __fmt_id.set_2bytes_le_from(header.format_id);
+               __sample_bits.set_2bytes_le_from(header.sample_bits);
+               __chunk_size.set_4bytes_le_from(header.fmt_chunk.size);
+               __channels.set_2bytes_le_from(header.channels);
+               __sample_rate.set_4bytes_le_from(header.sample_rate);
                
-               if((EndianToLittle_WORD(header.format_id) == 1) && ((EndianToLittle_WORD(header.sample_bits) == 8) || (EndianToLittle_DWORD(header.sample_bits) == 16))) {
-                       fio->Fseek(EndianToLittle_DWORD(header.fmt_chunk.size) - 16, FILEIO_SEEK_CUR);
+               if((__fmt_id.w == 1) && ((__sample_bits.w == 8) || (__sample_bits.w == 16))) {
+                       fio->Fseek(__chunk_size.d - 16, FILEIO_SEEK_CUR);
                        bool is_eof = false;
                        while(1) {
                                if(fio->Fread(&chunk, sizeof(chunk), 1) != 1) {
                                        is_eof = true;
                                        break;
                                }
+                               __chunk_size.set_4bytes_le_from(chunk.size);
                                if(strncmp(chunk.id, "data", 4) == 0) {
                                        break;
                                }
-                               fio->Fseek(EndianToLittle_DWORD(chunk.size), FILEIO_SEEK_CUR);
+                               fio->Fseek(__chunk_size.d, FILEIO_SEEK_CUR);
                        }
+                       __chunk_size.set_4bytes_le_from(chunk.size);
                        if(is_eof) {
                                buffer_l = buffer_r = NULL;
                                fio->Fclose();
                                delete fio;
                                return false;
                        }
-                       __nr_channels = EndianToLittle_WORD(header.channels);
-                       __nr_bits = EndianToLittle_WORD(header.sample_bits);
-                       if((samples = EndianToLittle_DWORD(chunk.size) / __nr_channels) > 0) {
-                               if(__nr_bits == 16) {
+                       if((samples = __chunk_size.d / __channels.w) > 0) {
+                               if(__sample_bits.w == 16) {
                                        samples /= 2;
                                }
-                               sample_rate = EndianToLittle_DWORD(header.sample_rate);
+                               sample_rate = __sample_rate.d;
                           
                                buffer_l = (int16_t *)malloc(samples * sizeof(int16_t));
                                buffer_r = (int16_t *)malloc(samples * sizeof(int16_t));
                                
                                for(int i = 0; i < samples; i++) {
                                        int sample_lr[2];
-                                       for(int ch = 0; ch < __nr_channels; ch++) {
+                                       for(int ch = 0; ch < __channels.sw; ch++) {
                                                int16_t sample = 0;
-                                               if(__nr_bits == 16) {
+                                               if(__sample_bits.w == 16) {
                                                        union {
                                                                int16_t s16;
                                                                struct {
@@ -134,7 +143,7 @@ bool NOISE::load_wav_file(const _TCHAR *file_name)
                                                if(ch < 2) sample_lr[ch] = sample;
                                        }
                                        buffer_l[i] = sample_lr[0];
-                                       buffer_r[i] = sample_lr[(__nr_channels > 1) ? 1 : 0];
+                                       buffer_r[i] = sample_lr[(__channels.w > 1) ? 1 : 0];
                                }
                                result = true;
                        }

diff --git a/source/src/vm/pc6001/psub.cpp b/source/src/vm/pc6001/psub.cpp
index 4248b00..f58314d 100644 (file)
--- a/source/src/vm/pc6001/psub.cpp
+++ b/source/src/vm/pc6001/psub.cpp
@@ -816,21 +816,40 @@ void PSUB::close_tape()
 #endif
                                uint32_t length = fio->Ftell();
                                
+                               pair_t __riff_chunk_size;
+                               pair_t __fmt_chunk_size;
+                               pair_t __wav_chunk_size;
+                               pair16_t __fmt_id;
+                               pair16_t __channels;
+                               pair_t __sample_rate;
+                               pair16_t __block_size;
+                               pair16_t __sample_bits;
+
+                               __riff_chunk_size.d = length - 8;
+                               __fmt_chunk_size.d = 16;
+                               __fmt_id.w = 1;
+                               __channels.w = 1;
+                               __sample_rate.d = sample_rate;
+                               __block_size.w = 1;
+                               __sample_bits.w = 8;
+       
                                memcpy(wav_header.riff_chunk.id, "RIFF", 4);
-                               wav_header.riff_chunk.size = length - 8;
+                               wav_header.riff_chunk.size = __riff_chunk_size.get_4bytes_le_to();
+       
                                memcpy(wav_header.wave, "WAVE", 4);
                                memcpy(wav_header.fmt_chunk.id, "fmt ", 4);
-                               wav_header.fmt_chunk.size = 16;
-                               wav_header.format_id = 1;
-                               wav_header.channels = 1;
-                               wav_header.sample_rate = sample_rate;
-                               wav_header.data_speed = sample_rate;
-                               wav_header.block_size = 1;
-                               wav_header.sample_bits = 8;
-                               
+                               wav_header.fmt_chunk.size = __riff_chunk_size.get_4bytes_le_to();
+                               wav_header.format_id = __fmt_id.get_2bytes_le_to();
+                               wav_header.channels = __channels.get_2byte_le_to();
+                               wav_header.sample_rate = __sample_rate.get_4bytes_le_to();
+                               wav_header.data_speed =  __sample_rate.get_4bytes_le_to();
+                               wav_header.block_size = __block_size.get_2bytes_le_to();
+                               wav_header.sample_bits = __sample_bits_get_2bytes_le_to();
+       
                                memcpy(wav_chunk.id, "data", 4);
-                               wav_chunk.size = length - sizeof(wav_header) - sizeof(wav_chunk);
-                               
+                               __wav_chunk_size.d = length - sizeof(wav_header) - sizeof(wav_chunk);
+                               wav_chunk.size = __wav_chunk_size.get_4bytes_le_to();
+       
                                fio->Fseek(0, FILEIO_SEEK_SET);
                                fio->Fwrite(&wav_header, sizeof(wav_header), 1);
                                fio->Fwrite(&wav_chunk, sizeof(wav_chunk), 1);

diff --git a/source/src/vm/pc6001/sub.cpp b/source/src/vm/pc6001/sub.cpp
index da4ad9b..f6a37da 100644 (file)
--- a/source/src/vm/pc6001/sub.cpp
+++ b/source/src/vm/pc6001/sub.cpp
@@ -292,20 +292,39 @@ void SUB::close_tape()
 #endif
                                uint32_t length = fio->Ftell();
                                
+                               pair_t __riff_chunk_size;
+                               pair_t __fmt_chunk_size;
+                               pair_t __wav_chunk_size;
+                               pair16_t __fmt_id;
+                               pair16_t __channels;
+                               pair_t __sample_rate;
+                               pair16_t __block_size;
+                               pair16_t __sample_bits;
+
+                               __riff_chunk_size.d = length - 8;
+                               __fmt_chunk_size.d = 16;
+                               __fmt_id.w = 1;
+                               __channels.w = 1;
+                               __sample_rate.d = sample_rate;
+                               __block_size.w = 1;
+                               __sample_bits.w = 8;
+       
                                memcpy(wav_header.riff_chunk.id, "RIFF", 4);
-                               wav_header.riff_chunk.size = length - 8;
+                               wav_header.riff_chunk.size = __riff_chunk_size.get_4bytes_le_to();
+       
                                memcpy(wav_header.wave, "WAVE", 4);
                                memcpy(wav_header.fmt_chunk.id, "fmt ", 4);
-                               wav_header.fmt_chunk.size = 16;
-                               wav_header.format_id = 1;
-                               wav_header.channels = 1;
-                               wav_header.sample_rate = sample_rate;
-                               wav_header.data_speed = sample_rate;
-                               wav_header.block_size = 1;
-                               wav_header.sample_bits = 8;
-                               
+                               wav_header.fmt_chunk.size = __riff_chunk_size.get_4bytes_le_to();
+                               wav_header.format_id = __fmt_id.get_2bytes_le_to();
+                               wav_header.channels = __channels.get_2byte_le_to();
+                               wav_header.sample_rate = __sample_rate.get_4bytes_le_to();
+                               wav_header.data_speed =  __sample_rate.get_4bytes_le_to();
+                               wav_header.block_size = __block_size.get_2bytes_le_to();
+                               wav_header.sample_bits = __sample_bits_get_2bytes_le_to();
+       
                                memcpy(wav_chunk.id, "data", 4);
-                               wav_chunk.size = length - sizeof(wav_header) - sizeof(wav_chunk);
+                               __wav_chunk_size.d = length - sizeof(wav_header) - sizeof(wav_chunk);
+                               wav_chunk.size = __wav_chunk_size.get_4bytes_le_to();
                                
                                fio->Fseek(0, FILEIO_SEEK_SET);
                                fio->Fwrite(&wav_header, sizeof(wav_header), 1);

diff --git a/source/src/vm/pc8201/cmt.cpp b/source/src/vm/pc8201/cmt.cpp
index 3b320b2..1fcf514 100644 (file)
--- a/source/src/vm/pc8201/cmt.cpp
+++ b/source/src/vm/pc8201/cmt.cpp
@@ -131,20 +131,40 @@ void CMT::close_tape()
                        wav_header_t wav_header;
                        wav_chunk_t wav_chunk;
                        
+                       pair_t __riff_chunk_size;
+                       pair_t __fmt_chunk_size;
+                       pair_t __wav_chunk_size;
+                       pair16_t __fmt_id;
+                       pair16_t __channels;
+                       pair_t __sample_rate;
+                       pair16_t __block_size;
+                       pair16_t __sample_bits;
+
+                       __riff_chunk_size.d = length - 8;
+                       __fmt_chunk_size.d = 16;
+                       __fmt_id.w = 1;
+                       __channels.w = 1;
+                       __sample_rate.d = SAMPLE_RATE;
+                       __block_size.w = 1;
+                       __sample_bits.w = 8;
+       
                        memcpy(wav_header.riff_chunk.id, "RIFF", 4);
-                       wav_header.riff_chunk.size = length - 8;
+                       wav_header.riff_chunk.size = __riff_chunk_size.get_4bytes_le_to();
+       
                        memcpy(wav_header.wave, "WAVE", 4);
                        memcpy(wav_header.fmt_chunk.id, "fmt ", 4);
-                       wav_header.fmt_chunk.size = 16;
-                       wav_header.format_id = 1;
-                       wav_header.channels = 1;
-                       wav_header.sample_rate = SAMPLE_RATE;
-                       wav_header.data_speed = SAMPLE_RATE;
-                       wav_header.block_size = 1;
-                       wav_header.sample_bits = 8;
-                       
+                       wav_header.fmt_chunk.size = __riff_chunk_size.get_4bytes_le_to();
+                       wav_header.format_id = __fmt_id.get_2bytes_le_to();
+                       wav_header.channels = __channels.get_2byte_le_to();
+                       wav_header.sample_rate = __sample_rate.get_4bytes_le_to();
+                       wav_header.data_speed =  __sample_rate.get_4bytes_le_to();
+                       wav_header.block_size = __block_size.get_2bytes_le_to();
+                       wav_header.sample_bits = __sample_bits_get_2bytes_le_to();
+       
                        memcpy(wav_chunk.id, "data", 4);
-                       wav_chunk.size = length - sizeof(wav_header) - sizeof(wav_chunk);
+                       __wav_chunk_size.d = length - sizeof(wav_header) - sizeof(wav_chunk);
+                       wav_chunk.size = __wav_chunk_size.get_4bytes_le_to();
+
                        
                        fio->Fseek(0, FILEIO_SEEK_SET);
                        fio->Fwrite(&wav_header, sizeof(wav_header), 1);