Script 'mail_helper' called by obssrc
Hello community,
here is the log from the commit of package schismtracker for openSUSE:Factory checked in at 2024-03-29 13:10:36
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Comparing /work/SRC/openSUSE:Factory/schismtracker (Old)
and /work/SRC/openSUSE:Factory/.schismtracker.new.1905 (New)
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Package is "schismtracker"
Fri Mar 29 13:10:36 2024 rev:29 rq:1163416 version:20240328
Changes:
--------
--- /work/SRC/openSUSE:Factory/schismtracker/schismtracker.changes 2024-03-10 20:26:21.093815966 +0100
+++ /work/SRC/openSUSE:Factory/.schismtracker.new.1905/schismtracker.changes 2024-03-29 13:13:37.301003924 +0100
@@ -1,0 +2,7 @@
+Fri Mar 29 01:28:32 UTC 2024 - Jan Engelhardt <jengelh(a)inai.de>
+
+- Update to release 20240328
+ * Fix entering line breaks into the message editor
+ * Don't abort when IT files report an order list size over 256
+
+-------------------------------------------------------------------
Old:
----
20240308.tar.gz
New:
----
20240328.tar.gz
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Other differences:
------------------
++++++ schismtracker.spec ++++++
--- /var/tmp/diff_new_pack.zGIqSq/_old 2024-03-29 13:13:37.945027582 +0100
+++ /var/tmp/diff_new_pack.zGIqSq/_new 2024-03-29 13:13:37.949027729 +0100
@@ -17,7 +17,7 @@
Name: schismtracker
-Version: 20240308
+Version: 20240328
Release: 0
Summary: Music editor that matches the look and feel of Impulse Tracker
License: GPL-2.0-or-later
++++++ 20240308.tar.gz -> 20240328.tar.gz ++++++
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/schismtracker-20240308/configure.ac new/schismtracker-20240328/configure.ac
--- old/schismtracker-20240308/configure.ac 2024-03-09 03:29:25.000000000 +0100
+++ new/schismtracker-20240328/configure.ac 2024-03-29 01:43:25.000000000 +0100
@@ -85,7 +85,8 @@
dnl Headers, typedef crap, et al.
AC_HEADER_DIRENT
-AC_HEADER_TIME
+AC_CHECK_HEADERS_ONCE([sys/time.h])
+
AC_CHECK_HEADERS(inttypes.h fcntl.h limits.h signal.h unistd.h sys/param.h sys/ioctl.h sys/kd.h linux/fb.h byteswap.h sys/soundcard.h poll.h sys/poll.h)
AM_CONDITIONAL([USE_OSS], [test "$ac_cv_header_sys_soundcard_h" = yes])
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/schismtracker-20240308/fmt/flac.c new/schismtracker-20240328/fmt/flac.c
--- old/schismtracker-20240308/fmt/flac.c 2024-03-09 03:29:25.000000000 +0100
+++ new/schismtracker-20240328/fmt/flac.c 2024-03-29 01:43:25.000000000 +0100
@@ -30,41 +30,50 @@
#include "disko.h"
#include "sndfile.h"
#include "log.h"
+#include "util.h"
#include <stdint.h>
struct flac_file {
FLAC__StreamMetadata_StreamInfo streaminfo;
+
struct {
- char *name;
- int32_t sample_rate;
+ char name[32];
+ uint32_t sample_rate;
uint8_t pan;
uint8_t vol;
struct {
- uint32_t type;
+ int32_t type;
uint32_t start;
uint32_t end;
} loop;
} flags;
+
struct {
const uint8_t* data;
size_t len;
- } raw_data;
- uint8_t* uncomp_buf;
+ } compressed;
+
+ struct {
+ uint8_t* data;
+ size_t len;
+
+ uint32_t samples_decoded, samples_read;
+ } uncompressed;
};
-static uint32_t samples_decoded = 0, samples_read = 0;
-static size_t total_size = 0;
static void on_meta(const FLAC__StreamDecoder *decoder, const FLAC__StreamMetadata *metadata, void *client_data) {
struct flac_file* flac_file = (struct flac_file*)client_data;
int32_t loop_start = -1, loop_length = -1;
+
switch (metadata->type) {
case FLAC__METADATA_TYPE_STREAMINFO:
- flac_file->streaminfo = metadata->data.stream_info;
+ memcpy(&flac_file->streaminfo, &metadata->data.stream_info, sizeof(flac_file->streaminfo));
break;
case FLAC__METADATA_TYPE_VORBIS_COMMENT:
- for (FLAC__uint32 i = 0; i < metadata->data.vorbis_comment.num_comments; i++) {
+ for (size_t i = 0; i < metadata->data.vorbis_comment.num_comments; i++) {
const char *tag = (const char*)metadata->data.vorbis_comment.comments[i].entry;
const FLAC__uint32 length = metadata->data.vorbis_comment.comments[i].length;
+
if (length > 6 && !strncasecmp(tag, "TITLE=", 6) && flac_file->flags.name)
strncpy(flac_file->flags.name, tag + 6, 32);
else if (length > 11 && !strncasecmp(tag, "SAMPLERATE=", 11))
@@ -74,33 +83,35 @@
else if (length > 11 && !strncasecmp(tag, "LOOPLENGTH=", 11))
loop_length = strtol(tag + 11, NULL, 10);
}
+
if (loop_start > 0 && loop_length > 1) {
flac_file->flags.loop.type = 0;
flac_file->flags.loop.start = loop_start;
flac_file->flags.loop.end = loop_start + loop_length - 1;
}
+
break;
case FLAC__METADATA_TYPE_APPLICATION: {
const uint8_t *data = (const uint8_t *)metadata->data.application.data;
- uint32_t chunk_id = *(uint32_t *)data; data += 4;
- uint32_t chunk_len = *(uint32_t *)data; data += 4;
+ uint32_t chunk_id = *(uint32_t*)data; data += sizeof(uint32_t);
+ uint32_t chunk_len = *(uint32_t*)data; data += sizeof(uint32_t);
if (chunk_id == 0x61727478 && chunk_len >= 8) { // "xtra"
- uint32_t xtra_flags = *(uint32_t *)data; data += 4;
+ uint32_t xtra_flags = *(uint32_t*)data; data += sizeof(uint32_t);
// panning (0..256)
if (xtra_flags & 0x20) {
- uint16_t tmp_pan = *(uint16_t *)data;
+ uint16_t tmp_pan = *(uint16_t*)data;
if (tmp_pan > 255)
tmp_pan = 255;
flac_file->flags.pan = (uint8_t)tmp_pan;
}
- data += 2;
+ data += sizeof(uint16_t);
// volume (0..256)
- uint16_t tmp_vol = *(uint16_t *)data;
+ uint16_t tmp_vol = *(uint16_t*)data;
if (tmp_vol > 256)
tmp_vol = 256;
@@ -110,13 +121,13 @@
if (chunk_id == 0x6C706D73 && chunk_len > 52) { // "smpl"
data += 28; // seek to first wanted byte
- uint32_t num_loops = *(uint32_t *)data; data += 4;
+ uint32_t num_loops = *(uint32_t *)data; data += sizeof(uint32_t);
if (num_loops == 1) {
- data += 4+4; // skip "samplerData" and "identifier"
+ data += 4 + 4; // skip "samplerData" and "identifier"
- flac_file->flags.loop.type = *(uint32_t *)data; data += 4;
- flac_file->flags.loop.start = *(uint32_t *)data; data += 4;
- flac_file->flags.loop.end = *(uint32_t *)data; data += 4;
+ flac_file->flags.loop.type = *(uint32_t *)data; data += sizeof(uint32_t);
+ flac_file->flags.loop.start = *(uint32_t *)data; data += sizeof(uint32_t);
+ flac_file->flags.loop.end = *(uint32_t *)data; data += sizeof(uint32_t);
}
}
break;
@@ -125,18 +136,20 @@
break;
}
- (void)client_data;
- (void)decoder;
+ (void)decoder, (void)client_data;
}
static FLAC__StreamDecoderReadStatus on_read(const FLAC__StreamDecoder *decoder, FLAC__byte buffer[], size_t *bytes, void *client_data) {
struct flac_file* flac_file = (struct flac_file*)client_data;
- if (samples_read < flac_file->raw_data.len) {
- if (*bytes > (flac_file->raw_data.len-samples_read))
- *bytes = flac_file->raw_data.len-samples_read;
- memcpy(buffer, flac_file->raw_data.data+samples_read, *bytes);
- samples_read += *bytes;
+ if (flac_file->uncompressed.samples_read < flac_file->compressed.len) {
+ size_t needed = flac_file->compressed.len - flac_file->uncompressed.samples_read;
+ if (*bytes > needed)
+ *bytes = needed;
+
+ memcpy(buffer, flac_file->compressed.data + flac_file->uncompressed.samples_read, *bytes);
+ flac_file->uncompressed.samples_read += *bytes;
+
return FLAC__STREAM_DECODER_READ_STATUS_CONTINUE;
} else {
*bytes = 0;
@@ -146,86 +159,67 @@
(void)decoder;
}
-static void on_error(const FLAC__StreamDecoder *decoder, FLAC__StreamDecoderErrorStatus status, void *client_data)
-{
- (void)decoder, (void)client_data;
-
+static void on_error(const FLAC__StreamDecoder *decoder, FLAC__StreamDecoderErrorStatus status, void *client_data) {
log_appendf(4, "Error loading FLAC: %s", FLAC__StreamDecoderErrorStatusString[status]);
+
+ (void)decoder, (void)client_data;
}
static FLAC__StreamDecoderWriteStatus on_write(const FLAC__StreamDecoder *decoder, const FLAC__Frame *frame, const FLAC__int32 *const buffer[], void *client_data) {
struct flac_file* flac_file = (struct flac_file*)client_data;
- if (!flac_file->streaminfo.total_samples || !flac_file->streaminfo.channels)
+ /* invalid? */
+ if (!flac_file->streaminfo.total_samples || !flac_file->streaminfo.channels
+ || flac_file->streaminfo.channels > 2)
return FLAC__STREAM_DECODER_WRITE_STATUS_ABORT;
- if (flac_file->streaminfo.channels > 2)
- return FLAC__STREAM_DECODER_WRITE_STATUS_ABORT;
+ if (frame->header.number.sample_number == 0) {
+ /* allocate our buffer */
+ flac_file->uncompressed.len = (size_t)(flac_file->streaminfo.total_samples * flac_file->streaminfo.channels * flac_file->streaminfo.bits_per_sample/8);
+ flac_file->uncompressed.data = (uint8_t*)mem_alloc(flac_file->uncompressed.len * ((flac_file->streaminfo.bits_per_sample == 8) ? sizeof(int8_t) : sizeof(int16_t)));
- switch (flac_file->streaminfo.bits_per_sample) {
- case 8: case 12: case 16:
- case 20: case 24: case 32:
- break;
- default:
- return FLAC__STREAM_DECODER_WRITE_STATUS_ABORT;
+ flac_file->uncompressed.samples_decoded = 0;
}
- if (frame->header.number.sample_number == 0)
- {
- total_size = (size_t)(flac_file->streaminfo.total_samples * flac_file->streaminfo.channels * flac_file->streaminfo.bits_per_sample/8);
- flac_file->uncomp_buf = (uint8_t*)malloc(total_size * ((flac_file->streaminfo.bits_per_sample == 8) ? sizeof(int8_t) : sizeof(int16_t)));
- if (flac_file->uncomp_buf == NULL) {
- log_appendf(4, "Error loading FLAC: Out of memory!");
- return FLAC__STREAM_DECODER_WRITE_STATUS_ABORT;
- }
+ uint32_t block_size = frame->header.blocksize * flac_file->streaminfo.channels;
- samples_decoded = 0;
- }
+ const uint32_t samples_allocated = flac_file->streaminfo.total_samples * flac_file->streaminfo.channels;
+ if (flac_file->uncompressed.samples_decoded + block_size > samples_allocated)
+ block_size = samples_allocated - flac_file->uncompressed.samples_decoded;
- /* this isn't true, but it works fine for what we do */
- uint32_t block_size = frame->header.blocksize*flac_file->streaminfo.channels;
+ if (flac_file->streaminfo.bits_per_sample <= 8) {
+ int8_t* buf_ptr = flac_file->uncompressed.data + flac_file->uncompressed.samples_decoded;
+ uint32_t bit_shift = 8 - flac_file->streaminfo.bits_per_sample;
- const uint32_t samples_allocated = flac_file->streaminfo.total_samples*flac_file->streaminfo.channels;
- if (samples_decoded+block_size > samples_allocated)
- block_size = samples_allocated - samples_decoded;
-
- uint32_t i = 0, j = 0;
- switch (flac_file->streaminfo.bits_per_sample) {
- case 8: {
- int8_t *buf_ptr = flac_file->uncomp_buf + samples_decoded;
- for (i = 0, j = 0; i < block_size; j++) {
- buf_ptr[i++] = (int8_t)buffer[0][j];
- if (flac_file->streaminfo.channels == 2)
- buf_ptr[i++] = (int8_t)buffer[1][j];
- }
- break;
+ size_t i, j;
+ for (i = 0, j = 0; i < block_size; j++) {
+ buf_ptr[i++] = (int8_t)(buffer[0][j] << bit_shift);
+ if (flac_file->streaminfo.channels == 2)
+ buf_ptr[i++] = (int8_t)(buffer[1][j] << bit_shift);
}
- /* here we cheat by just increasing 12-bit to 16-bit */
- case 12: case 16: {
- int16_t *buf_ptr = (int16_t*)flac_file->uncomp_buf + samples_decoded;
- uint32_t bit_shift = 16 - flac_file->streaminfo.bits_per_sample;
- for (i = 0, j = 0; i < block_size; j++) {
- buf_ptr[i++] = buffer[0][j] << bit_shift;
- if (flac_file->streaminfo.channels == 2)
- buf_ptr[i++] = buffer[1][j] << bit_shift;
- }
- break;
+ } else if (flac_file->streaminfo.bits_per_sample <= 16) {
+ int16_t* buf_ptr = (int16_t*)flac_file->uncompressed.data + flac_file->uncompressed.samples_decoded;
+ uint32_t bit_shift = 16 - flac_file->streaminfo.bits_per_sample;
+
+ size_t i, j;
+ for (i = 0, j = 0; i < block_size; j++) {
+ buf_ptr[i++] = buffer[0][j] << bit_shift;
+ if (flac_file->streaminfo.channels == 2)
+ buf_ptr[i++] = buffer[1][j] << bit_shift;
}
- /* here we just make everything 16-bit, we don't support
- 24-bit anyway */
- case 20: case 24: case 32: {
- int16_t *buf_ptr = (int16_t*)flac_file->uncomp_buf + samples_decoded;
- uint32_t bit_shift = flac_file->streaminfo.bits_per_sample - 16;
- for (i = 0, j = 0; i < block_size; j++) {
- buf_ptr[i++] = buffer[0][j] >> bit_shift;
- if (flac_file->streaminfo.channels == 2)
- buf_ptr[i++] = buffer[1][j] >> bit_shift;
- }
- break;
+ } else { /* >= 16 */
+ int16_t* buf_ptr = (int16_t*)flac_file->uncompressed.data + flac_file->uncompressed.samples_decoded;
+ uint32_t bit_shift = flac_file->streaminfo.bits_per_sample - 16;
+
+ size_t i, j;
+ for (i = 0, j = 0; i < block_size; j++) {
+ buf_ptr[i++] = buffer[0][j] >> bit_shift;
+ if (flac_file->streaminfo.channels == 2)
+ buf_ptr[i++] = buffer[1][j] >> bit_shift;
}
}
- samples_decoded += block_size;
+ flac_file->uncompressed.samples_decoded += block_size;
return FLAC__STREAM_DECODER_WRITE_STATUS_CONTINUE;
@@ -233,20 +227,26 @@
}
#define FLAC_ERROR(x) \
- if (decoder != NULL) FLAC__stream_decoder_delete(decoder); \
- return x
-static int flac_load(struct flac_file* flac_file, size_t len, int meta_only) {
- if (memcmp(flac_file->raw_data.data, "fLaC", 4))
+ do { \
+ if (!decoder) FLAC__stream_decoder_delete(decoder); \
+ return x; \
+ } while (0);
+
+static int flac_load(struct flac_file* flac_file, int meta_only) {
+ if (flac_file->compressed.len < 4)
return 0;
- FLAC__StreamDecoder *decoder = FLAC__stream_decoder_new();
- if (decoder == NULL)
+
+ if (memcmp(flac_file->compressed.data, "fLaC", 4))
+ return 0;
+
+ FLAC__StreamDecoder* decoder = FLAC__stream_decoder_new();
+ if (!decoder)
return 0;
FLAC__stream_decoder_set_metadata_respond_all(decoder);
FLAC__StreamDecoderInitStatus initStatus =
- FLAC__stream_decoder_init_stream
- (
+ FLAC__stream_decoder_init_stream(
decoder,
on_read, NULL,
NULL, NULL,
@@ -256,32 +256,29 @@
);
if (meta_only) {
- if (!FLAC__stream_decoder_process_until_end_of_metadata(decoder)) {
+ if (!FLAC__stream_decoder_process_until_end_of_metadata(decoder))
FLAC_ERROR(0);
- }
} else {
- if (!FLAC__stream_decoder_process_until_end_of_stream(decoder)) {
+ if (!FLAC__stream_decoder_process_until_end_of_stream(decoder))
FLAC_ERROR(0);
- }
}
FLAC__stream_decoder_finish(decoder);
FLAC__stream_decoder_delete(decoder);
+
return 1;
}
#undef FLAC_ERROR
int fmt_flac_load_sample(const uint8_t *data, size_t len, song_sample_t *smp) {
- samples_read = 0;
- samples_decoded = 0;
- total_size = 0;
- struct flac_file flac_file;
- flac_file.raw_data.data = data;
- flac_file.raw_data.len = len;
- flac_file.flags.name = smp->name;
- flac_file.flags.sample_rate = -1;
+ struct flac_file flac_file = {0};
+ flac_file.compressed.data = data;
+ flac_file.compressed.len = len;
+ strncpy(flac_file.flags.name, smp->name, ARRAY_SIZE(flac_file.flags.name));
+ flac_file.flags.sample_rate = 0;
flac_file.flags.loop.type = -1;
- if (!flac_load(&flac_file, len, 0))
+
+ if (!flac_load(&flac_file, 0))
return 0;
smp->volume = 64 * 4;
@@ -290,50 +287,40 @@
smp->length = flac_file.streaminfo.total_samples;
if (flac_file.flags.loop.type != -1) {
smp->loop_start = flac_file.flags.loop.start;
- smp->loop_end = flac_file.flags.loop.end+1;
+ smp->loop_end = flac_file.flags.loop.end + 1;
smp->flags |= (flac_file.flags.loop.type ? (CHN_LOOP | CHN_PINGPONGLOOP) : CHN_LOOP);
}
- if (flac_file.flags.sample_rate > 0) {
+
+ if (flac_file.flags.sample_rate)
smp->c5speed = flac_file.flags.sample_rate;
- }
// endianness
uint32_t flags = SF_LE;
+
// channels
flags |= (flac_file.streaminfo.channels == 2) ? SF_SI : SF_M;
+
// bit width
- switch (flac_file.streaminfo.bits_per_sample) {
- case 8: flags |= SF_8; break;
- case 12:
- case 16:
- case 20:
- case 24:
- case 32: flags |= SF_16; break;
- default:
- free(flac_file.uncomp_buf);
- return 0;
- }
+ flags |= (flac_file.streaminfo.bits_per_sample <= 8) ? SF_8 : SF_16;
+
// libFLAC always returns signed
flags |= SF_PCMS;
- int ret = csf_read_sample(smp, flags, flac_file.uncomp_buf, total_size);
- free(flac_file.uncomp_buf);
+
+ int ret = csf_read_sample(smp, flags, flac_file.uncompressed.data, flac_file.uncompressed.len);
+ free(flac_file.uncompressed.data);
return ret;
}
int fmt_flac_read_info(dmoz_file_t *file, const uint8_t *data, size_t len)
{
- samples_read = 0;
- samples_decoded = 0;
- total_size = 0;
- struct flac_file flac_file;
- flac_file.raw_data.data = data;
- flac_file.raw_data.len = len;
- flac_file.flags.name = NULL;
+ struct flac_file flac_file = {0};
+ flac_file.compressed.data = data;
+ flac_file.compressed.len = len;
flac_file.flags.loop.type = -1;
- if (!flac_load(&flac_file, len, 1)) {
+
+ if (!flac_load(&flac_file, 1))
return 0;
- }
file->smp_flags = 0;
@@ -342,32 +329,23 @@
!flac_file.streaminfo.channels)
return 0;
- switch (flac_file.streaminfo.bits_per_sample) {
- case 12:
- case 16:
- case 20:
- case 24:
- case 32:
- file->smp_flags |= CHN_16BIT;
- case 8:
- break;
- default:
- return 0;
- }
+ if (flac_file.streaminfo.bits_per_sample > 8)
+ file->smp_flags |= CHN_16BIT;
if (flac_file.streaminfo.channels == 2)
file->smp_flags |= CHN_STEREO;
file->smp_speed = flac_file.streaminfo.sample_rate;
file->smp_length = flac_file.streaminfo.total_samples;
+
if (flac_file.flags.loop.type != -1) {
file->smp_loop_start = flac_file.flags.loop.start;
- file->smp_loop_end = flac_file.flags.loop.end+1;
+ file->smp_loop_end = flac_file.flags.loop.end + 1;
file->smp_flags |= (flac_file.flags.loop.type ? (CHN_LOOP | CHN_PINGPONGLOOP) : CHN_LOOP);
}
- if (flac_file.flags.sample_rate > 0) {
+
+ if (flac_file.flags.sample_rate)
file->smp_speed = flac_file.flags.sample_rate;
- }
file->description = "FLAC Audio File";
file->type = TYPE_SAMPLE_COMPR;
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/schismtracker-20240308/fmt/it.c new/schismtracker-20240328/fmt/it.c
--- old/schismtracker-20240308/fmt/it.c 2024-03-09 03:29:25.000000000 +0100
+++ new/schismtracker-20240328/fmt/it.c 2024-03-29 01:43:25.000000000 +0100
@@ -505,8 +505,8 @@
hdr.reserved = bswapLE32(hdr.reserved);
// Screwy limits?
- if (hdr.ordnum > MAX_ORDERS || hdr.insnum > MAX_INSTRUMENTS
- || hdr.smpnum > MAX_SAMPLES || hdr.patnum > MAX_PATTERNS) {
+ if (hdr.insnum > MAX_INSTRUMENTS || hdr.smpnum > MAX_SAMPLES
+ || hdr.patnum > MAX_PATTERNS) {
return LOAD_FORMAT_ERROR;
}
@@ -516,7 +516,7 @@
song->title[25] = 0;
rtrim_string(song->title);
- if (hdr.cmwt < 0x0214)
+ if (hdr.cmwt < 0x0214 && hdr.cwtv < 0x0214)
ignoremidi = 1;
if (hdr.special & 4) {
/* "reserved" bit, experimentally determined to indicate presence of otherwise-documented row
@@ -571,7 +571,28 @@
channel->volume = MIN(hdr.chan_vol[n], 64);
}
- slurp_read(fp, song->orderlist, hdr.ordnum);
+ /* only read what we can and ignore the rest */
+ slurp_read(fp, song->orderlist, MIN(hdr.ordnum, MAX_ORDERS));
+
+ /* show a warning in the message log if there's too many orders */
+ if (hdr.ordnum > MAX_ORDERS) {
+ const int lostord = hdr.ordnum - MAX_ORDERS;
+ int show_warning = 1;
+
+ /* special exception: ordnum == 257 is valid ONLY if the final order is ORDER_LAST */
+ if (lostord == 1) {
+ uint8_t ord;
+ slurp_read(fp, &ord, sizeof(ord));
+
+ show_warning = (ord != ORDER_LAST);
+ } else {
+ slurp_seek(fp, SEEK_CUR, lostord);
+ }
+
+ if (show_warning)
+ log_appendf(4, " Warning: Too many orders in the order list (%d skipped)", lostord);
+ }
+
slurp_read(fp, para_ins, 4 * hdr.insnum);
slurp_read(fp, para_smp, 4 * hdr.smpnum);
slurp_read(fp, para_pat, 4 * hdr.patnum);
@@ -614,7 +635,7 @@
}
if (ignoremidi) {
if (hdr.special & 8) {
- log_appendf(4, " Warning: ignoring embedded MIDI data (CMWT is too old)");
+ log_appendf(4, " Warning: ignoring embedded MIDI data (CWTV/CMWT is too old)");
slurp_seek(fp, sizeof(midi_config_t), SEEK_CUR);
}
memset(&song->midi_config, 0, sizeof(midi_config_t));
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/schismtracker-20240308/include/headers.h new/schismtracker-20240328/include/headers.h
--- old/schismtracker-20240308/include/headers.h 2024-03-09 03:29:25.000000000 +0100
+++ new/schismtracker-20240328/include/headers.h 2024-03-29 01:43:25.000000000 +0100
@@ -137,16 +137,10 @@
#ifdef NEED_TIME
-# if TIME_WITH_SYS_TIME
+# if HAVE_SYS_TIME_H
# include <sys/time.h>
-# include <time.h>
-# else
-# if HAVE_SYS_TIME_H
-# include <sys/time.h>
-# else
-# include <time.h>
-# endif
# endif
+# include <time.h>
# ifndef timersub
// from FreeBSD
# define timersub(tvp, uvp, vvp) \
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/schismtracker-20240308/schism/page_message.c new/schismtracker-20240328/schism/page_message.c
--- old/schismtracker-20240308/schism/page_message.c 2024-03-09 03:29:25.000000000 +0100
+++ new/schismtracker-20240328/schism/page_message.c 2024-03-29 01:43:25.000000000 +0100
@@ -110,18 +110,13 @@
(*line) = (*line) - 1;
if (*line < 0) *line = 0;
len = get_nth_line(text, *line, &ptr);
- if (len < 0) {
- *ch = 0;
- } else {
- *ch = len;
- }
+ *ch = (len < 0) ? 0 : len;
pos = 0;
-
} else if (len >= pos) {
*ch = pos;
pos = 0;
} else {
- pos -= (len+1); /* EOC */
+ pos -= (len + 1); /* EOC */
(*line) = (*line) + 1;
}
}
@@ -563,11 +558,10 @@
return 0;
for (; *text; text++) {
- if (*text == '\n' || *text == '\t' || *text >= 32) {
- if (clippy_owner(CLIPPY_SELECT) == widgets_message)
- _delete_selection();
- message_insert_char(*text);
- } else return 0;
+ if (clippy_owner(CLIPPY_SELECT) == widgets_message)
+ _delete_selection();
+
+ message_insert_char(*text);
}
return 1;
}
@@ -695,16 +689,32 @@
return 0;
if (k->state == KEY_RELEASE)
return 1;
- if (k->sym.sym && clippy_owner(CLIPPY_SELECT) == widgets_message) {
+
+ if (clippy_owner(CLIPPY_SELECT) == widgets_message)
_delete_selection();
- } else {
+ else
message_delete_next_char();
- }
+
return 1;
+ case SDLK_RETURN:
+ if (NO_MODIFIER(k->mod)) {
+ if (k->state == KEY_RELEASE)
+ return 1;
+
+ if (clippy_owner(CLIPPY_SELECT) == widgets_message)
+ _delete_selection();
+
+ message_insert_char('\r');
+
+ return 1;
+ }
+ return 0;
default:
+ /* keybinds... */
if (k->mod & KMOD_CTRL) {
if (k->state == KEY_RELEASE)
return 1;
+
if (k->sym.sym == SDLK_t) {
message_extfont = !message_extfont;
break;
@@ -716,6 +726,7 @@
} else if (k->mod & KMOD_ALT) {
if (k->state == KEY_RELEASE)
return 1;
+
if (k->sym.sym == SDLK_c) {
prompt_message_clear();
return 1;
