- Alsa-devel - mailman.alsa-project.org

bug in snd_seq_query_subscribe_get_time_real
by Erwin P 02 Nov '25

02 Nov '25

Hello, I think there is a bug in snd_seq_query_subscribe_get_time_real(). This function returns (info->flags & SNDRV_SEQ_PORT_SUBS_TIMESTAMP), but it should be (info->flags & SNDRV_SEQ_PORT_SUBS_TIME_REAL), as it is in snd_seq_port_subscribe_get_time_real(). Regards, Erwin.

1 0

Reg: Internal Microphone Broken on ASUS X509UA (ALC3251, SSID 1043:1961) Starting AFTER Kernel 6.8.0-31
by jo 02 Nov '25

02 Nov '25

*System/Hardware Details:* Parameter Value *Laptop Model* *ASUS VivoBook X509UA* *CPU Generation* Intel Core i3-7020U (Kaby Lake / Sunrise Point-LP) *Audio Codec* Realtek ALC3251 (Variant of ALC256) *Subsystem ID (SSID)* *1043:1961* (ASUSTeK Computer Inc.) *PCI Device ID* Intel Corporation Sunrise Point-LP HD Audio [8086:9d71] *Working Kernel Version* *Linux Kernel 6.8.0-31* and previous versions. *Broken Kernel Version* *Starts AFTER 6.8.0-31* (e.g., 6.8.0-32, 6.8.0-35, etc.). Description of the Issue The internal microphone on the ASUS X509UA is *no longer functional* on Linux kernels newer than version 6.8.0-31. The input device is detected by ALSA/PulseAudio, but the capture level remains at zero (no sound is recorded). The issue is a *clear regression*, as the microphone worked correctly on kernel 6.8.0-31 and all previous versions (e.g., in Ubuntu 22.04 LTS). It also works correctly under Chrome OS Flex, which uses a custom-patched kernel. Diagnostic Steps Performed All standard user-level and common developer workarounds have failed on the affected kernel versions: 1. *ALSA Mixer Levels:* Confirmed that the "Capture," "Mic," and "Internal Mic Boost" levels are correctly set (not muted—"OO" instead of "MM") and boosted (to 80-100%). 2. *hdajackretask (Pin Remapping):* All available pins, including 0x19, 0x1b, and "Not Connected" pins (0x12, 0x13, 0x18, 0x1a), were tested with the *"Internal mic"* function. None of these overrides corrected the issue. 3. *hda-verb Commands:* Standard GPIO-based *quirks* commonly used to fix Realtek mic issues (e.g., hda-verb 0x01/0x02/0x04) were executed and failed to activate the microphone. 4. *ALSA Model Quirk Options:* The following common and targeted model= options were added to /etc/modprobe.d/test-audio.conf (one at a time, followed by sudo alsa force-reload) and did not resolve the issue: - options snd-hda-intel model=alc256-asus-mic1 - options snd-hda-intel model=laptop-amic - options snd-hda-intel model=dell-headset-multi (This caused the microphone to disappear entirely.) 5. *Old Configuration Files:* Reverting to or applying the exact configuration files (hda.conf) that *worked* on the pre-6.8 kernels failed to activate the microphone on the post-6.8.0-31 kernels, suggesting a deeper structural change in the driver code. Request The failure of all standard workarounds indicates that the regression is due to a *missing or incorrect pin-mapping configuration* for the *1043:1961 SSID* within the snd-hda-intel driver, likely introduced in a patch after *6.8.0-31*. A patch is needed to re-introduce the correct microphone *quirk* for the *ASUS X509UA (1043:1961)* to restore functionality on the latest Linux kernel series.

1 0

[PATCH REQUEST] ASUS ROG Zephyrus G14 GA403W - CS35L56 volume controls not exposed correctly
by John DelTorchio 02 Nov '25

02 Nov '25

After extensive debugging, the issue has been isolated to incorrect ALSA mixer control mapping. Technical Details Hardware Configuration: - Laptop Model: ASUS ROG Zephyrus G14 (GA403W) - Audio Codec: Realtek ALC285 (Subsystem ID: 0x10431024) - Amplifiers: Dual Cirrus Logic CS35L56 smart amplifiers - ALSA Card: Card 2 (HD-Audio Generic) - Driver: snd_hda_intel with cs35l56-hda module Amplifier Status: The CS35L56 amplifiers are being detected and initialized correctly: cs35l56-hda i2c-CSC3556:00-cs35l56-hda.0: DSP1: Firmware: 1a00d6 vendor: 0x2 v3.11.16 cs35l56-hda i2c-CSC3556:00-cs35l56-hda.1: DSP1: Firmware: 1a00d6 vendor: 0x2 v3.11.16 Firmware files loaded: - cirrus/cs35l56-b0-dsp1-misc-10431024-spkid1.wmfw - cirrus/cs35l56-b0-dsp1-misc-10431024-spkid1-amp1.bin - cirrus/cs35l56-b0-dsp1-misc-10431024-spkid1-amp2.bin The Actual Problem Current (broken) behavior: - The volume slider controls Master Playback Volume (numid=24) on the ALC285 codec - This control only affects the analog signal level going into the CS35L56 amplifiers - Lowering this control degrades signal quality (adds muffling/distortion) without actually reducing speaker output volume - The CS35L56 amplifiers remain at a fixed gain, so perceived loudness doesn't change significantly Correct behavior should be: - The volume slider should control AMP1 Speaker Playback Volume (numid=6) and AMP2 Speaker Playback Volume (numid=12) - The codec's Master and Speaker controls should remain at 100% for optimal signal-to-noise ratio Verified working configuration: bash # Codec output (should be fixed at these values) amixer -c2 sset 'Master' 100 % amixer -c2 sset 'Speaker' 100 % # Amplifier controls (should be user-adjustable via volume slider) amixer -c2 sset 'AMP1 Speaker' 85 % amixer -c2 sset 'AMP2 Speaker' 85 % `` ` Manual testing confirms: - ✅ ` AMP1 Speaker ` and ` AMP2 Speaker ` controls properly adjust speaker loudness - ✅ Volume range 0 -100% works without distortion when codec is at 100 % - ❌ PipeWire/desktop environment uses the wrong mixer controls ### PipeWire Configuration Current sink properties show it's using ACP ( ALSA Card Profiles ) : ` ` ` api.alsa.use-acp = "true" api.alsa.path = "front:2" ` ` ` The automatically selected mixer path is choosing ` Master ` as the primary volume control instead of the CS35L56 amp controls. ### Required Fix This needs one of the following solutions: 1 . **ALSA UCM ( Use Case Manager ) profile** for device ID ` 10431024 ` : - Lock codec controls at 100 % - Expose AMP1/AMP2 Speaker controls as primary volume 2 . **Custom ALSA mixer path** at ` /usr/share/alsa/mixer/paths/ ` : - Define AMP1/AMP2 Speaker as volume elements - Set Master/Speaker to ` volume = ignore ` or ` volume-limit = 0.0 ` 3 . **Kernel quirk** in ` sound/pci/hda/patch_realtek.c ` : - Add model-specific configuration for GA403W - Similar to how other ASUS models with CS35L41/CS35L56 are handled 4 . **PipeWire/WirePlumber profile update**: - Device-specific configuration to use correct mixer elements ### Relevant Files **ALSA Controls Output:** ` `` numid = 6 ,iface = MIXER,name = 'AMP1 Speaker Playback Volume' : values = 400 | dBscale-min = -100.00dB,step = 0 .25dB,mute = 0 | Range: 0 -448 numid = 12 ,iface = MIXER,name = 'AMP2 Speaker Playback Volume' : values = 400 | dBscale-min = -100.00dB,step = 0 .25dB,mute = 0 | Range: 0 -448 numid = 24 ,iface = MIXER,name = 'Master Playback Volume' : values = 39 | dBscale-min = -65.25dB,step = 0 .75dB,mute = 0 | Range: 0 -87 Codec Information: - See full codec dump at: https://paste.centos.org/view/6c3a3640 - Full diagnostics at: https://paste.centos.org/view/c0d20bf3 Temporary Workaround Users can manually set correct levels on boot with this autostart script: ~/.config/autostart/audio-fix.desktop: desktop [Desktop Entry] Type=Application Name=Audio Fix Exec=/usr/bin/bash -c "sleep 5 && amixer -c2 sset 'Master' 100%% && amixer -c2 sset 'Speaker' 100%% && amixer -c2 sset 'AMP1 Speaker' 85%% && amixer -c2 sset 'AMP2 Speaker' 85%%" Hidden=false NoDisplay=false However, the volume slider will still not function correctly. Sent with [Proton Mail](https://proton.me/mail/home) secure email.

1 0

doxygen: fix for doxygen 1.10.0 and later
by GitHub pull_request - opened 01 Nov '25

01 Nov '25

alsa-project/alsa-lib pull request #480 was opened from borine: doygen 1.10.0 changed the paths that include files are searched, with the consequence for alsa-lib that the "Topics" tab is no longer fully populated. See for example the [alsa project online docs](https://www.alsa-project.org/alsa-doc/alsa-lib/topics.html) To fix this we need to prevent circular #include references when doygen scans its input files, and also to re-order some macros. Request URL : https://github.com/alsa-project/alsa-lib/pull/480 Patch URL : https://github.com/alsa-project/alsa-lib/pull/480.patch Repository URL: https://github.com/alsa-project/alsa-lib

1 0

amidirecord the metronome doesn't work
by GitHub issues - opened 31 Oct '25

31 Oct '25

alsa-project/alsa-utils issue #307 was opened from MarcWeber: This a bug report that arecordmidi's metronome doesn't work on my (nixos) linux machine for whatever reason. Asking AI to fix it I couldn't really make it work. It kept stopping after one measure. So I asked to rewrite roughly with the following prompt: - master / -slave (be metronome or use another time giving source) slave is not tested. Because goal was to get readable clean nodes I asked to add new features: --note-recording-on-switches-others-off --note-recording-ignore-off But the honest answer is using lmms like tool to record midi shows that getting timing correct is too hard. So the only way to make this work I feel would be using A UI app which allows to manually fix the timing of measures. But that would be a totally different bloated app. So typical usage of the code below would be: ``` arecordmidi --debug --master \ --note-recording-on-switches-others-off --note-recording-ignore-off \ -p 24:0 -m 128:1 -i 4:4 -t 50 /tmp/out.mid ``` But I still wasn't able to cleanly record "Alle meine Entchen" which only is made up of quarter half and full note length. The code below was done by Gemini Pro 2025-10-31 but it was fed with the original code. I also applied some manual fixes to the AI code cause it kept failing on some things. So if AI is a programmer it probably is still GPL ? No idea. So maybe test whether the metronome works for you if not add a simple patch showing this issue (for now) so that people can compile the code below themselves if they want to experimenfit with it. But they will have read the warnings here understanding it might not be as easy as they think. So I am not sure anymore the bug is worth fixing. But this issue allows discusssing it. But its worth managing expectations of users - thus drop the feature if it doesn't work or fix it by printf ("see this gituhb issue") for the time being. Maybe the code is old and was written for older Alsa no idea. The metronome output wasn't even shown in qjackctl or aconnect -l. So this all at least works in the code below so that it can be experimented with. It also outputs the pressed notes with timing differences compared to ticks. But in the end you might be faster using lilypond or musescore to type notes. ``` /* * arecordmidi.c - record standard MIDI files from sequencer * * Copyright (c) 2004-2005 Clemens Ladisch <clemens(a)ladisch.de> * Copyright (c) 2024 Rewritten by AI based on user specification. * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA */ #include <stdio.h> #include <stdlib.h> #include <string.h> #include <stdarg.h> #include <signal.h> #include <getopt.h> #include <poll.h> #include <errno.h> #include <math.h> #include <time.h> /* for clock_gettime */ #include <alsa/asoundlib.h> #include "aconfig.h" #include "version.h" #define BUFFER_SIZE 4096 #define MAX_PORTS 16 /* --- Data Structures --- */ // Linked list of buffers to store SMF track data struct buffer { struct buffer *next; unsigned char buf[BUFFER_SIZE]; }; // Represents a single track in a Standard MIDI File struct smf_track { int size; int cur_buf_size; struct buffer *cur_buf; snd_seq_tick_time_t last_tick; unsigned char last_command; int used; struct buffer first_buf; }; #define TRACKS_PER_PORT 17 // 1 for meta/sysex, 16 for channels // Global application state typedef struct { enum { MODE_UNSPECIFIED, MODE_MASTER, MODE_SLAVE } mode; const char *output_filename; FILE *file; snd_seq_t *seq; int client_id; int queue_id; char *record_in_addrs[MAX_PORTS]; int record_in_count; char *metronome_out_addr; char *clock_in_addr; // Slave only char *clock_out_addr; // Master only int record_in_port_ids[MAX_PORTS]; int metronome_out_port_id; int metronome_loop_port_id; int clock_out_port_id; int bpm; int ticks_per_beat; // PPQ (Pulses Per Quarter Note) int use_metronome; int metro_channel; int metro_strong_note; int metro_weak_note; int metro_velocity; long metro_latency_ms; snd_seq_tick_time_t metro_tick_offset; int metro_running; int ts_num; int ts_den; int ts_den_pow2; int split_channels; int num_tracks; struct smf_track *tracks; volatile sig_atomic_t stop_request; int debug_mode; // New options int on_switches_others_off; int ignore_off; // For note duration calculation in debug mode snd_seq_tick_time_t active_note_start_tick[MAX_PORTS][16][128]; // For timing reference in debug mode snd_seq_tick_time_t ref_tick; snd_seq_real_time_t ref_real_time; int queue_time_ref_set; } arecordmidi_app_t; static arecordmidi_app_t app = {0}; /* --- Error Handling & Memory --- */ static void fatal(const char *msg, ...) { va_list ap; va_start(ap, msg); fputs("Error: ", stderr); vfprintf(stderr, msg, ap); fflush(stdout); va_end(ap); fputc('\n', stderr); exit(EXIT_FAILURE); } static void check_mem(void *p) { if (!p) fatal("Out of memory"); } static void check_snd(int err, const char *operation) { if (err < 0) fatal("ALSA Error: Cannot %s - %s", operation, snd_strerror(err)); } /* --- SMF File Writing Utilities --- */ static void add_byte(struct smf_track *track, unsigned char byte) { if (track->cur_buf_size >= BUFFER_SIZE) { track->cur_buf->next = calloc(1, sizeof(struct buffer)); check_mem(track->cur_buf->next); track->cur_buf = track->cur_buf->next; track->cur_buf_size = 0; } track->cur_buf->buf[track->cur_buf_size++] = byte; track->size++; } static void var_value(struct smf_track *track, unsigned int v) { unsigned long buffer = v & 0x7f; while ((v >>= 7) > 0) { buffer <<= 8; buffer |= 0x80 | (v & 0x7f); } while (1) { add_byte(track, buffer & 0xff); if (buffer & 0x80) buffer >>= 8; else break; } } static void delta_time(struct smf_track *track, const snd_seq_event_t *ev) { int diff = ev->time.tick - track->last_tick; if (diff < 0) diff = 0; var_value(track, diff); track->last_tick = ev->time.tick; } static void command(struct smf_track *track, unsigned char cmd) { if (cmd != track->last_command) { add_byte(track, cmd); track->last_command = cmd < 0xf0 ? cmd : 0; } } /* --- Metronome --- */ static void metronome_note(unsigned char note, unsigned int tick) { snd_seq_event_t ev; snd_seq_ev_clear(&ev); snd_seq_ev_set_source(&ev, app.metronome_out_port_id); snd_seq_ev_set_subs(&ev); snd_seq_ev_set_direct(&ev); unsigned int schedule_tick = tick > app.metro_tick_offset ? tick - app.metro_tick_offset : 0; if (app.debug_mode) { // printf(" OUT:METRO: Note On: ch=%2d key=%3d vel=%3d @ tick %u\n", app.metro_channel, note, app.metro_velocity, schedule_tick); } // Note On snd_seq_ev_set_noteon(&ev, app.metro_channel, note, app.metro_velocity); snd_seq_ev_schedule_tick(&ev, app.queue_id, 0, schedule_tick); // Absolute schedule snd_seq_event_output(app.seq, &ev); // Note Off (short duration) snd_seq_ev_set_noteoff(&ev, app.metro_channel, note, 0); snd_seq_ev_schedule_tick(&ev, app.queue_id, 0, schedule_tick + app.ticks_per_beat / 4); // Absolute snd_seq_event_output(app.seq, &ev); } static void metronome_pattern(unsigned int tick) { unsigned int ticks_per_bar, t; int j; ticks_per_bar = app.ts_num * (app.ticks_per_beat * 4 / app.ts_den); t = tick; for (j = 0; j < app.ts_num; ++j) { metronome_note((j == 0) ? app.metro_strong_note : app.metro_weak_note, t); t += (app.ticks_per_beat * 4 / app.ts_den); } // Schedule a custom event to trigger the next bar unsigned int next_bar_tick = tick + ticks_per_bar; snd_seq_event_t ev; snd_seq_ev_clear(&ev); ev.type = SND_SEQ_EVENT_USR0; snd_seq_ev_schedule_tick(&ev, app.queue_id, 0, next_bar_tick); // Absolute schedule snd_seq_ev_set_source(&ev, app.metronome_loop_port_id); snd_seq_ev_set_dest(&ev, app.client_id, app.metronome_loop_port_id); snd_seq_event_output(app.seq, &ev); snd_seq_drain_output(app.seq); } static void start_metronome() { if (app.metro_running || !app.use_metronome) return; app.metro_running = 1; printf("Starting metronome.\n"); // Get current tick to start metronome immediately snd_seq_queue_status_t *qstatus; snd_seq_queue_status_alloca(&qstatus); check_snd(snd_seq_get_queue_status(app.seq, app.queue_id, qstatus), "get queue status"); snd_seq_tick_time_t current_tick = snd_seq_queue_status_get_tick_time(qstatus); metronome_pattern(current_tick); } /* --- Event Recording --- */ static const char *note_names[] = {"C", "C#", "D", "D#", "E", "F", "F#", "G", "G#", "A", "A#", "B"}; static const char *midi_note_to_name(int note, char *buf, size_t size) { if (note < 0 || note > 127) { snprintf(buf, size, "???"); } else { int octave = (note / 12) - 1; const char *name = note_names[note % 12]; snprintf(buf, size, "%s%d", name, octave); } return buf; } static void terminate_old_notes(int current_port_idx, const snd_seq_event_t *original_on_ev, const snd_seq_event_t *processed_on_ev) { // If ticks_per_beat is not set, this feature is disabled to avoid division by zero. if (app.ticks_per_beat <= 0) return; unsigned int current_beat_tick = processed_on_ev->time.tick; for (int ch = 0; ch < 16; ++ch) { for (int nt = 0; nt < 128; ++nt) { snd_seq_tick_time_t start_tick = app.active_note_start_tick[current_port_idx][ch][nt]; if (start_tick != (snd_seq_tick_time_t)-1) { // Don't terminate notes started on the same tick, to allow chords. if (current_beat_tick == start_tick) { continue; } // Find the track for the note we are terminating int track_idx = current_port_idx; if (app.split_channels) { track_idx = (track_idx * TRACKS_PER_PORT) + 1 + ch; } if (track_idx >= app.num_tracks) continue; struct smf_track *track = &app.tracks[track_idx]; track->used = 1; // Create a synthetic event just to pass the correct tick time snd_seq_event_t off_ev; snd_seq_ev_clear(&off_ev); off_ev.time.tick = processed_on_ev->time.tick; // Record the NOTEOFF event delta_time(track, &off_ev); command(track, 0x80 | ch); add_byte(track, nt); add_byte(track, 0); // Standard velocity for note-off if (app.debug_mode) { char note_name_buf[8]; midi_note_to_name(nt, note_name_buf, sizeof(note_name_buf)); double beat_pos = 0.0, offset_percent = 0.0; long offset_ms = 0; if (app.ticks_per_beat > 0 && app.bpm > 0 && app.queue_time_ref_set) { beat_pos = (double)off_ev.time.tick / app.ticks_per_beat; snd_seq_tick_time_t nearest_beat_tick = floor(beat_pos + 0.5) * app.ticks_per_beat; if (snd_seq_ev_is_real(original_on_ev)) { // Precise timing: Compare event real time to ideal grid real time double tick_ns = (double)app.bpm * app.ticks_per_beat; double ns_per_tick = (60.0 * 1000000000.0) / tick_ns; long long ref_ns = (long long)app.ref_real_time.tv_sec * 1000000000LL + app.ref_real_time.tv_nsec; long long ticks_from_ref_to_beat = (long long)nearest_beat_tick - (long long)app.ref_tick; long long expected_beat_ns = ref_ns + (long long)(ticks_from_ref_to_beat * ns_per_tick); long long actual_event_ns = (long long)original_on_ev->time.time.tv_sec * 1000000000LL + original_on_ev->time.time.tv_nsec; long long ns_offset = actual_event_ns - expected_beat_ns; if (ns_offset > tick_ns / 2 ) ns_offset = ns_offset - tick_ns; offset_ms = ns_offset / 1000000LL; double ns_per_beat = ns_per_tick * app.ticks_per_beat; if (ns_per_beat > 0) offset_percent = (double)ns_offset * 100.0 / ns_per_beat; } else { // Fallback to tick-based timing for events that came from the queue long tick_offset = off_ev.time.tick - nearest_beat_tick; double ms_per_tick = (60.0 * 1000.0) / ((double)app.bpm * app.ticks_per_beat); offset_ms = round((double)tick_offset * ms_per_tick); offset_percent = (double)tick_offset * 100.0 / app.ticks_per_beat; } } if (offset_percent > 50) offset_percent = offset_percent - 100; snd_seq_tick_time_t duration_ticks = off_ev.time.tick - start_tick; double duration_beats = (app.ticks_per_beat > 0) ? (double)duration_ticks / app.ticks_per_beat : 0.0; printf("DEBUG: OFF %-4s ch=%2d vel=%3d @ beat %.2f | timing: %+.2f%% (%+ldms) | duration: %.2f beats | auto-terminated by new note \n", note_name_buf, ch, 0, beat_pos, offset_percent, offset_ms, duration_beats); } // Update state to mark note as off app.active_note_start_tick[current_port_idx][ch][nt] = (snd_seq_tick_time_t)-1; } } } } static void record_event(const snd_seq_event_t *ev) { int port_idx, track_idx; struct smf_track *track; snd_seq_event_t event_with_tick; // A mutable copy of the event with a guaranteed tick timestamp // Filter 1: Must be from our recording queue. // We accept both tick and real-time events. The ALSA sequencer is expected // to deliver a tick-stamped event from the queue, but in practice, it // sometimes only delivers the initial real-time event. if (ev->queue != app.queue_id) { if (app.debug_mode && ev->type >= SND_SEQ_EVENT_NOTEON && ev->type <= SND_SEQ_EVENT_SYSEX) { // printf(" -> REJECTED (Filter 1): Event from queue %d is not our recording queue %d.\n", ev->queue, app.queue_id); } return; } // Create a mutable copy of the event and normalize its timestamp to ticks. event_with_tick = *ev; if (snd_seq_ev_is_tick(ev)) { // Event already has a tick timestamp, use it as-is. // This is the case for metronome loopback and correctly scheduled MIDI events. } else if (snd_seq_ev_is_real(ev)) { // This is a "raw" real-time event. We convert its timestamp to a tick // value by querying the current state of our recording queue. snd_seq_queue_status_t *qstatus; snd_seq_queue_status_alloca(&qstatus); if (snd_seq_get_queue_status(app.seq, app.queue_id, qstatus) < 0) { fprintf(stderr, "Warning: could not get queue status to timestamp a real-time event; event ignored.\n"); fflush(stdout); return; } event_with_tick.time.tick = snd_seq_queue_status_get_tick_time(qstatus); if (app.debug_mode) { // printf(" -> INFO: Handled real-time event by converting to tick %u\n", event_with_tick.time.tick); } } else { // Event has no timestamp; it cannot be recorded. return; } // Filter 2: Must be destined for one of our recording input ports port_idx = -1; for (int i = 0; i < app.record_in_count; ++i) { if (event_with_tick.dest.port == app.record_in_port_ids[i]) { port_idx = i; break; } } if (port_idx == -1) { if (app.debug_mode && event_with_tick.type >= SND_SEQ_EVENT_NOTEON && event_with_tick.type <= SND_SEQ_EVENT_SYSEX) { // printf(" -> REJECTED (Filter 2): Destination port %d is not on the record list.\n", event_with_tick.dest.port); } return; } track_idx = port_idx; if (app.split_channels) { track_idx *= TRACKS_PER_PORT; if (snd_seq_ev_is_channel_type(&event_with_tick)) track_idx += 1 + (event_with_tick.data.note.channel & 0xf); } if (track_idx >= app.num_tracks) return; track = &app.tracks[track_idx]; track->used = 1; // From here on, we use our normalized `event_with_tick` for all processing. switch (event_with_tick.type) { case SND_SEQ_EVENT_NOTEON: if (event_with_tick.data.note.velocity == 0) goto handle_noteoff; // Running status note-off if (app.on_switches_others_off) { terminate_old_notes(port_idx, ev, &event_with_tick); } app.active_note_start_tick[port_idx][event_with_tick.data.note.channel & 0xf][event_with_tick.data.note.note & 0x7f] = event_with_tick.time.tick; if (app.debug_mode) { char note_name_buf[8]; midi_note_to_name(event_with_tick.data.note.note, note_name_buf, sizeof(note_name_buf)); double beat_pos = 0.0, offset_percent = 0.0; long offset_ms = 0; if (app.ticks_per_beat > 0 && app.bpm > 0 && app.queue_time_ref_set) { beat_pos = (double)event_with_tick.time.tick / app.ticks_per_beat; snd_seq_tick_time_t nearest_beat_tick = floor(beat_pos + 0.5) * app.ticks_per_beat; if (snd_seq_ev_is_real(ev)) { // Precise timing: Compare event real time to ideal grid real time double ns_per_tick = (60.0 * 1000000000.0) / ((double)app.bpm * app.ticks_per_beat); long long ref_ns = (long long)app.ref_real_time.tv_sec * 1000000000LL + app.ref_real_time.tv_nsec; long long ticks_from_ref_to_beat = (long long)nearest_beat_tick - (long long)app.ref_tick; long long expected_beat_ns = ref_ns + (long long)(ticks_from_ref_to_beat * ns_per_tick); long long actual_event_ns = (long long)ev->time.time.tv_sec * 1000000000LL + ev->time.time.tv_nsec; long long ns_offset = actual_event_ns - expected_beat_ns; if (ns_offset > ns_per_tick / 2) ns_offset -= ns_per_tick; offset_ms = ns_offset / 1000000LL; offset_percent = (double)ns_offset * 100.0 / ns_per_tick; } else { // Fallback to tick-based timing for events that came from the queue long tick_offset = event_with_tick.time.tick - nearest_beat_tick; double ms_per_tick = (60.0 * 1000.0) / ((double)app.bpm * app.ticks_per_beat); offset_ms = round((double)tick_offset * ms_per_tick); if (offset_ms > ms_per_tick) offset_ms -= ms_per_tick; offset_percent = offset_ms / ms_per_tick; } } printf("DEBUG: ON %-4s ch=%2d vel=%3d @ beat %.2f | timing: %+.2f%% (%+ldms)\n", note_name_buf, event_with_tick.data.note.channel, event_with_tick.data.note.velocity, beat_pos, offset_percent, offset_ms); fflush(stdout); } delta_time(track, &event_with_tick); command(track, 0x90 | (event_with_tick.data.note.channel & 0xf)); add_byte(track, event_with_tick.data.note.note & 0x7f); add_byte(track, event_with_tick.data.note.velocity & 0x7f); break; case SND_SEQ_EVENT_NOTEOFF: handle_noteoff: if (app.ignore_off) return; if (app.debug_mode) { unsigned char channel = event_with_tick.data.note.channel & 0xf; unsigned char note = event_with_tick.data.note.note & 0x7f; snd_seq_tick_time_t start_tick = app.active_note_start_tick[port_idx][channel][note]; char note_name_buf[8]; midi_note_to_name(note, note_name_buf, sizeof(note_name_buf)); double beat_pos = 0.0, offset_percent = 0.0; long offset_ms = 0; if (app.ticks_per_beat > 0 && app.bpm > 0 && app.queue_time_ref_set) { beat_pos = (double)event_with_tick.time.tick / app.ticks_per_beat; snd_seq_tick_time_t nearest_beat_tick = floor(beat_pos + 0.5) * app.ticks_per_beat; if (snd_seq_ev_is_real(ev)) { // Precise timing: Compare event real time to ideal grid real time double ns_per_tick = (60.0 * 1000000000.0) / ((double)app.bpm * app.ticks_per_beat); long long ref_ns = (long long)app.ref_real_time.tv_sec * 1000000000LL + app.ref_real_time.tv_nsec; long long ticks_from_ref_to_beat = (long long)nearest_beat_tick - (long long)app.ref_tick; long long expected_beat_ns = ref_ns + (long long)(ticks_from_ref_to_beat * ns_per_tick); long long actual_event_ns = (long long)ev->time.time.tv_sec * 1000000000LL + ev->time.time.tv_nsec; long long ns_offset = actual_event_ns - expected_beat_ns; offset_ms = ns_offset / 1000000LL; double ns_per_beat = ns_per_tick * app.ticks_per_beat; if (ns_per_beat > 0) offset_percent = (double)ns_offset * 100.0 / ns_per_beat; } else { // Fallback to tick-based timing for events that came from the queue long tick_offset = event_with_tick.time.tick - nearest_beat_tick; double ms_per_tick = (60.0 * 1000.0) / ((double)app.bpm * app.ticks_per_beat); offset_ms = round((double)tick_offset * ms_per_tick); offset_percent = (double)tick_offset * 100.0 / app.ticks_per_beat; } } snd_seq_tick_time_t duration_ticks = 0; if (start_tick != (snd_seq_tick_time_t)-1 && event_with_tick.time.tick >= start_tick) { duration_ticks = event_with_tick.time.tick - start_tick; } double duration_beats = (app.ticks_per_beat > 0) ? (double)duration_ticks / app.ticks_per_beat : 0.0; printf("DEBUG: OFF %-4s ch=%2d vel=%3d @ beat %.2f | timing: %+.2f%% (%+ldms) | duration: %.2f beats\n", note_name_buf, event_with_tick.data.note.channel, event_with_tick.data.note.velocity, beat_pos, offset_percent, offset_ms, duration_beats); fflush(stdout); } app.active_note_start_tick[port_idx][event_with_tick.data.note.channel & 0xf][event_with_tick.data.note.note & 0x7f] = (snd_seq_tick_time_t)-1; delta_time(track, &event_with_tick); command(track, 0x80 | (event_with_tick.data.note.channel & 0xf)); add_byte(track, event_with_tick.data.note.note & 0x7f); add_byte(track, event_with_tick.data.note.velocity & 0x7f); break; case SND_SEQ_EVENT_PGMCHANGE: delta_time(track, &event_with_tick); command(track, 0xc0 | (event_with_tick.data.control.channel & 0xf)); add_byte(track, event_with_tick.data.control.value & 0x7f); break; case SND_SEQ_EVENT_CONTROLLER: delta_time(track, &event_with_tick); command(track, 0xb0 | (event_with_tick.data.control.channel & 0xf)); add_byte(track, event_with_tick.data.control.param & 0x7f); add_byte(track, event_with_tick.data.control.value & 0x7f); break; case SND_SEQ_EVENT_PITCHBEND: delta_time(track, &event_with_tick); command(track, 0xe0 | (event_with_tick.data.control.channel & 0xf)); add_byte(track, (event_with_tick.data.control.value + 8192) & 0x7f); add_byte(track, ((event_with_tick.data.control.value + 8192) >> 7) & 0x7f); break; case SND_SEQ_EVENT_SYSEX: delta_time(track, &event_with_tick); add_byte(track, 0xf0); track->last_command = 0; var_value(track, event_with_tick.data.ext.len); for (unsigned int i = 0; i < event_with_tick.data.ext.len; ++i) add_byte(track, ((unsigned char*)event_with_tick.data.ext.ptr)[i]); break; default: break; } } /* --- Setup and Teardown --- */ static void setup_tracks() { app.num_tracks = app.record_in_count; if (app.split_channels) app.num_tracks *= TRACKS_PER_PORT; app.tracks = calloc(app.num_tracks, sizeof(struct smf_track)); check_mem(app.tracks); for (int i = 0; i < app.num_tracks; ++i) app.tracks[i].cur_buf = &app.tracks[i].first_buf; app.tracks[0].used = 1; // Track 0 always used for meta events } static void write_initial_meta_events() { // Tempo int usecs_per_quarter = 60000000 / app.bpm; var_value(&app.tracks[0], 0); add_byte(&app.tracks[0], 0xff); add_byte(&app.tracks[0], 0x51); add_byte(&app.tracks[0], 3); add_byte(&app.tracks[0], usecs_per_quarter >> 16); add_byte(&app.tracks[0], (usecs_per_quarter >> 8) & 0xff); add_byte(&app.tracks[0], usecs_per_quarter & 0xff); // Time Signature var_value(&app.tracks[0], 0); add_byte(&app.tracks[0], 0xff); add_byte(&app.tracks[0], 0x58); add_byte(&app.tracks[0], 4); add_byte(&app.tracks[0], app.ts_num); add_byte(&app.tracks[0], app.ts_den_pow2); add_byte(&app.tracks[0], 24); // MIDI clocks per metronome click add_byte(&app.tracks[0], 8); // 32nd notes per quarter note } static void terminate_all_active_notes(void) { if (!app.ignore_off) return; snd_seq_queue_status_t *qstatus; snd_seq_queue_status_alloca(&qstatus); check_snd(snd_seq_get_queue_status(app.seq, app.queue_id, qstatus), "get queue status"); snd_seq_tick_time_t final_tick = snd_seq_queue_status_get_tick_time(qstatus); // printf("Terminating any remaining notes at tick %u...\n", final_tick); for (int p_idx = 0; p_idx < app.record_in_count; ++p_idx) { for (int ch = 0; ch < 16; ++ch) { for (int nt = 0; nt < 128; ++nt) { snd_seq_tick_time_t start_tick = app.active_note_start_tick[p_idx][ch][nt]; if (start_tick != (snd_seq_tick_time_t)-1) { int track_idx = p_idx; if (app.split_channels) { track_idx = (p_idx * TRACKS_PER_PORT) + 1 + ch; } if (track_idx >= app.num_tracks) continue; struct smf_track *track = &app.tracks[track_idx]; track->used = 1; // Mark track as used if it wasn't already snd_seq_event_t off_ev; snd_seq_ev_clear(&off_ev); off_ev.time.tick = final_tick; delta_time(track, &off_ev); command(track, 0x80 | ch); add_byte(track, nt); add_byte(track, 0); if (app.debug_mode) { char note_name_buf[8]; midi_note_to_name(nt, note_name_buf, sizeof(note_name_buf)); double beat_pos = 0.0, offset_percent = 0.0; long offset_ms = 0; if (app.ticks_per_beat > 0 && app.bpm > 0 && app.queue_time_ref_set) { beat_pos = (double)off_ev.time.tick / app.ticks_per_beat; // NOTE: Cannot calculate real-time offset as we don't have a real event timestamp. // We fall back to calculating offset from the nearest beat based on ticks alone. long nearest_beat_tick = floor(beat_pos + 0.5) * app.ticks_per_beat; long tick_offset = off_ev.time.tick - nearest_beat_tick; double ms_per_tick = (60.0 * 1000.0) / ((double)app.bpm * app.ticks_per_beat); offset_ms = round((double)tick_offset * ms_per_tick); if (offset_ms > ms_per_tick/ 2) offset_ms -= ms_per_tick; offset_percent = offset_ms / ms_per_tick; } snd_seq_tick_time_t duration_ticks = off_ev.time.tick - start_tick; double duration_beats = (app.ticks_per_beat > 0) ? (double)duration_ticks / app.ticks_per_beat : 0.0; printf("DEBUG: OFF %-4s ch=%2d vel=%3d @ beat %.2f | auto-terminated at exit | timing: %+.2f%% (%+ldms) | duration: %.2f beats\n", note_name_buf, ch, 0, beat_pos, offset_percent, offset_ms, duration_beats); fflush(stdout); } } } } } } static void finish_tracks() { snd_seq_queue_status_t *qstatus; snd_seq_queue_status_alloca(&qstatus); check_snd(snd_seq_get_queue_status(app.seq, app.queue_id, qstatus), "get queue status"); snd_seq_tick_time_t tick = snd_seq_queue_status_get_tick_time(qstatus); for (int i = 0; i < app.num_tracks; ++i) { if (!app.tracks[i].used) continue; int diff = tick - app.tracks[i].last_tick; if (diff < 0) diff = 0; var_value(&app.tracks[i], diff); add_byte(&app.tracks[i], 0xff); add_byte(&app.tracks[i], 0x2f); add_byte(&app.tracks[i], 0); } } static void write_smf_file() { int used_tracks = 0, i; for (i = 0; i < app.num_tracks; ++i) if (app.tracks[i].used) used_tracks++; if (used_tracks == 0) { printf("No events recorded, output file will not be created.\n"); return; } app.file = fopen(app.output_filename, "wb"); if (!app.file) fatal("Cannot open %s for writing - %s", app.output_filename, strerror(errno)); // MThd chunk fwrite("MThd\0\0\0\6", 1, 8, app.file); fputc(0, app.file); fputc(used_tracks > 1 ? 1 : 0, app.file); fputc((used_tracks >> 8) & 0xff, app.file); fputc(used_tracks & 0xff, app.file); fputc(app.ticks_per_beat >> 8, app.file); fputc(app.ticks_per_beat & 0xff, app.file); // MTrk chunks for (i = 0; i < app.num_tracks; ++i) { struct smf_track *track = &app.tracks[i]; if (!track->used) continue; fwrite("MTrk", 1, 4, app.file); fputc((track->size >> 24) & 0xff, app.file); fputc((track->size >> 16) & 0xff, app.file); fputc((track->size >> 8) & 0xff, app.file); fputc(track->size & 0xff, app.file); struct buffer *buf; for (buf = &track->first_buf; buf; buf = buf->next) fwrite(buf->buf, 1, (buf == track->cur_buf) ? track->cur_buf_size : BUFFER_SIZE, app.file); } fclose(app.file); } static void setup_alsa() { snd_seq_port_info_t *pinfo; snd_seq_addr_t addr; check_snd(snd_seq_open(&app.seq, "default", SND_SEQ_OPEN_DUPLEX, 0), "open sequencer"); app.client_id = snd_seq_client_id(app.seq); check_snd(app.client_id, "get client id"); check_snd(snd_seq_set_client_name(app.seq, "arecordmidi"), "set client name"); app.queue_id = snd_seq_alloc_named_queue(app.seq, "arecordmidi queue"); check_snd(app.queue_id, "create queue"); snd_seq_port_info_alloca(&pinfo); for (int i = 0; i < app.record_in_count; ++i) { char port_name[64]; snprintf(port_name, sizeof(port_name), "Record In %d", i + 1); app.record_in_port_ids[i] = snd_seq_create_simple_port(app.seq, port_name, SND_SEQ_PORT_CAP_WRITE | SND_SEQ_PORT_CAP_SUBS_WRITE, SND_SEQ_PORT_TYPE_APPLICATION); check_snd(app.record_in_port_ids[i], "create record port"); // Configure the port for timestamping events and scheduling them on our queue check_snd(snd_seq_get_port_info(app.seq, app.record_in_port_ids[i], pinfo), "get port info"); snd_seq_port_info_set_timestamping(pinfo, 1); snd_seq_port_info_set_timestamp_real(pinfo, 1); snd_seq_port_info_set_timestamp_queue(pinfo, app.queue_id); check_snd(snd_seq_set_port_info(app.seq, app.record_in_port_ids[i], pinfo), "configure record port"); // Connect the external source to our new port using an explicit subscription // that specifies the queue. This is more robust than relying on the port's // properties alone. snd_seq_port_subscribe_t *subs; snd_seq_port_subscribe_alloca(&subs); check_snd(snd_seq_parse_address(app.seq, &addr, app.record_in_addrs[i]), app.record_in_addrs[i]); snd_seq_addr_t my_dest_addr; my_dest_addr.client = app.client_id; my_dest_addr.port = app.record_in_port_ids[i]; snd_seq_port_subscribe_set_sender(subs, &addr); snd_seq_port_subscribe_set_dest(subs, &my_dest_addr); snd_seq_port_subscribe_set_queue(subs, app.queue_id); check_snd(snd_seq_subscribe_port(app.seq, subs), "connect record port"); } if (app.use_metronome) { app.metronome_out_port_id = snd_seq_create_simple_port(app.seq, "Metronome Out", SND_SEQ_PORT_CAP_READ | SND_SEQ_PORT_CAP_SUBS_READ, SND_SEQ_PORT_TYPE_APPLICATION); check_snd(app.metronome_out_port_id, "create metronome out port"); check_snd(snd_seq_parse_address(app.seq, &addr, app.metronome_out_addr), app.metronome_out_addr); check_snd(snd_seq_connect_to(app.seq, app.metronome_out_port_id, addr.client, addr.port), "connect metronome port"); app.metronome_loop_port_id = snd_seq_create_simple_port(app.seq, "Metronome Loop", SND_SEQ_PORT_CAP_WRITE | SND_SEQ_PORT_CAP_SUBS_WRITE, SND_SEQ_PORT_TYPE_APPLICATION); check_snd(app.metronome_loop_port_id, "create metronome loop port"); check_snd(snd_seq_connect_from(app.seq, app.metronome_loop_port_id, app.client_id, app.metronome_loop_port_id), "connect metronome loopback"); } if (app.mode == MODE_MASTER) { snd_seq_queue_tempo_t *tempo; snd_seq_queue_tempo_alloca(&tempo); snd_seq_queue_tempo_set_tempo(tempo, 60000000 / app.bpm); snd_seq_queue_tempo_set_ppq(tempo, app.ticks_per_beat); check_snd(snd_seq_set_queue_tempo(app.seq, app.queue_id, tempo), "set queue tempo"); app.clock_out_port_id = snd_seq_create_simple_port(app.seq, "Clock Out", SND_SEQ_PORT_CAP_READ | SND_SEQ_PORT_CAP_SUBS_READ, SND_SEQ_PORT_TYPE_MIDI_GENERIC); check_snd(app.clock_out_port_id, "create clock out port"); snd_seq_addr_t sender = { .client = SND_SEQ_CLIENT_SYSTEM, .port = SND_SEQ_PORT_SYSTEM_TIMER }; snd_seq_addr_t dest = { .client = app.client_id, .port = app.clock_out_port_id }; snd_seq_port_subscribe_t *subs; snd_seq_port_subscribe_alloca(&subs); snd_seq_port_subscribe_set_sender(subs, &sender); snd_seq_port_subscribe_set_dest(subs, &dest); snd_seq_port_subscribe_set_queue(subs, app.queue_id); snd_seq_port_subscribe_set_time_update(subs, 1); check_snd(snd_seq_subscribe_port(app.seq, subs), "subscribe clock out to system timer"); if (app.clock_out_addr) { check_snd(snd_seq_parse_address(app.seq, &addr, app.clock_out_addr), app.clock_out_addr); check_snd(snd_seq_connect_to(app.seq, app.clock_out_port_id, addr.client, addr.port), "connect clock out port"); } } else { // MODE_SLAVE snd_seq_queue_timer_t *timer; snd_seq_queue_timer_alloca(&timer); snd_seq_queue_timer_set_type(timer, SND_SEQ_TIMER_ALSA); snd_seq_queue_timer_set_id(timer, 0); check_snd(snd_seq_set_queue_timer(app.seq, app.queue_id, timer), "set queue timer"); snd_seq_addr_t sender, dest; check_snd(snd_seq_parse_address(app.seq, &sender, app.clock_in_addr), app.clock_in_addr); dest.client = SND_SEQ_CLIENT_SYSTEM; dest.port = SND_SEQ_PORT_SYSTEM_TIMER; snd_seq_port_subscribe_t *subs; snd_seq_port_subscribe_alloca(&subs); snd_seq_port_subscribe_set_sender(subs, &sender); snd_seq_port_subscribe_set_dest(subs, &dest); check_snd(snd_seq_subscribe_port(app.seq, subs), "subscribe system timer to external clock"); } } static void list_ports_and_exit() { snd_seq_client_info_t *cinfo; snd_seq_port_info_t *pinfo; snd_seq_t *seq; check_snd(snd_seq_open(&seq, "default", SND_SEQ_OPEN_INPUT, 0), "open sequencer for listing"); snd_seq_client_info_alloca(&cinfo); snd_seq_port_info_alloca(&pinfo); puts(" Port Client name Port name"); puts("-----------------------------------------------------------------"); snd_seq_client_info_set_client(cinfo, -1); while (snd_seq_query_next_client(seq, cinfo) >= 0) { int client = snd_seq_client_info_get_client(cinfo); snd_seq_port_info_set_client(pinfo, client); snd_seq_port_info_set_port(pinfo, -1); while (snd_seq_query_next_port(seq, pinfo) >= 0) { unsigned int caps = snd_seq_port_info_get_capability(pinfo); if ((caps & SND_SEQ_PORT_CAP_SUBS_READ) || (caps & SND_SEQ_PORT_CAP_READ)) { printf("%3d:%-3d %-32.32s %s\n", snd_seq_port_info_get_client(pinfo), snd_seq_port_info_get_port(pinfo), snd_seq_client_info_get_name(cinfo), snd_seq_port_info_get_name(pinfo)); fflush(stdout); } } } snd_seq_close(seq); exit(0); } /* --- Main Logic --- */ static void sighandler(int signal) { (void)signal; app.stop_request = 1; } static void help(const char *argv0) { fprintf(stderr, "Usage: %s [options] outputfile.mid\n" "\nMODES (choose one, --master is default):\n" " --master Provide MIDI clock and be the master (default)\n" " --slave Receive MIDI clock from another device\n" "\nPORT CONFIGURATION:\n" " -p, --midi-in-record=c:p Add a source port to record from (can be used multiple times)\n" " -m, --midi-out-metronome=c:p Play metronome to this destination port\n" " --midi-in-clock=c:p In slave mode, receive clock from here\n" " --midi-out-clock=c:p In master mode, send MIDI clock to here (optional)\n" "\nTIMING & RECORDING:\n" " -b, --bpm=beats Tempo in beats per minute (master mode)\n" " -t, --ticks=ticks Resolution in ticks per beat (PPQ)\n" " -i, --timesig=nn:dd Time signature for metronome (e.g., 4:4, 3:4)\n" " -s, --split-channels Create a separate track for each MIDI channel\n" " --note-recording-on-switches-others-off\n" " A new note-on event terminates other sounding notes\n" " --note-recording-ignore-off\n" " Ignore note-off events (implies the above option)\n" "\nMETRONOME TWEAKS:\n" " --compensate-metronome-output-latency-ms=<ms> Send metronome notes early\n" "\nOTHER OPTIONS:\n" " -h, --help This help\n" " -V, --version Show version\n" " -l, --list List available MIDI ports\n" " --debug Output recorded events to the console\n", argv0); } static void parse_time_signature(const char *arg) { char *sep; app.ts_num = strtol(arg, &sep, 10); if (app.ts_num < 1 || app.ts_num > 64 || (*sep != ':' && *sep != '/')) fatal("Invalid time signature numerator: %s", arg); app.ts_den = strtol(++sep, NULL, 10); if (app.ts_den < 1 || (app.ts_den & (app.ts_den - 1)) != 0) // Must be power of 2 fatal("Invalid time signature denominator (must be power of 2): %s", arg); app.ts_den_pow2 = 0; for (int x = app.ts_den; x > 1; x /= 2) ++app.ts_den_pow2; } static void validate_args() { if (app.mode == MODE_UNSPECIFIED) app.mode = MODE_MASTER; if (app.record_in_count == 0) fatal("Please specify at least one source port with -p or --midi-in-record."); if (app.mode == MODE_SLAVE && !app.clock_in_addr) fatal("Slave mode requires --midi-in-clock."); if (app.mode == MODE_MASTER && app.clock_in_addr) fatal("--midi-in-clock can only be used in slave mode."); if (app.mode == MODE_SLAVE && app.clock_out_addr) fatal("--midi-out-clock can only be used in master mode."); if (app.use_metronome && !app.metronome_out_addr) fatal("Using metronome requires specifying --midi-out-metronome."); if (app.metro_latency_ms > 0) { double ticks_per_ms = (app.bpm / 60.0 * app.ticks_per_beat) / 1000.0; app.metro_tick_offset = (snd_seq_tick_time_t)(app.metro_latency_ms * ticks_per_ms); } if (app.ignore_off) { app.on_switches_others_off = 1; } } int main(int argc, char *argv[]) { app.mode = MODE_UNSPECIFIED; app.bpm = 120; app.ticks_per_beat = 384; app.ts_num = 4; app.ts_den = 4; app.ts_den_pow2 = 2; // Default 4/4 app.metro_channel = 9; app.metro_strong_note = 34; app.metro_weak_note = 33; app.metro_velocity = 100; app.queue_time_ref_set = 0; static const struct option long_options[] = { {"help", 0, NULL, 'h'}, {"version", 0, NULL, 'V'}, {"list", 0, NULL, 'l'}, {"master", 0, NULL, 1000}, {"slave", 0, NULL, 1001}, {"midi-in-record", 1, NULL, 'p'}, {"midi-out-metronome", 1, NULL, 'm'}, {"midi-in-clock", 1, NULL, 1002}, {"midi-out-clock", 1, NULL, 1003}, {"bpm", 1, NULL, 'b'}, {"ticks", 1, NULL, 't'}, {"timesig", 1, NULL, 'i'}, {"split-channels", 0, NULL, 's'}, {"debug", 0, NULL, 1004}, {"compensate-metronome-output-latency-ms", 1, NULL, 1005}, {"note-recording-on-switches-others-off", 0, NULL, 1006}, {"note-recording-ignore-off", 0, NULL, 1007}, {0} }; int c; while ((c = getopt_long(argc, argv, "hVlp:m:b:t:i:s", long_options, NULL)) != -1) { switch (c) { case 'h': help(argv[0]); return 0; case 'V': fputs("arecordmidi version " SND_UTIL_VERSION_STR "\n", stderr); return 0; case 'l': list_ports_and_exit(); break; case 1000: if (app.mode != MODE_UNSPECIFIED) fatal("--master and --slave are mutually exclusive."); app.mode = MODE_MASTER; break; case 1001: if (app.mode != MODE_UNSPECIFIED) fatal("--master and --slave are mutually exclusive."); app.mode = MODE_SLAVE; break; case 'p': if (app.record_in_count >= MAX_PORTS) fatal("Too many --midi-in-record ports (max %d)", MAX_PORTS); app.record_in_addrs[app.record_in_count++] = optarg; break; case 'm': app.metronome_out_addr = optarg; app.use_metronome = 1; break; case 1002: app.clock_in_addr = optarg; break; case 1003: app.clock_out_addr = optarg; break; case 'b': app.bpm = atoi(optarg); break; case 't': app.ticks_per_beat = atoi(optarg); break; case 'i': parse_time_signature(optarg); break; case 's': app.split_channels = 1; break; case 1004: app.debug_mode = 1; break; case 1005: app.metro_latency_ms = atol(optarg); break; case 1006: app.on_switches_others_off = 1; break; case 1007: app.ignore_off = 1; break; default: help(argv[0]); return 1; } } if (optind >= argc) fatal("Please specify an output file name."); app.output_filename = argv[optind]; validate_args(); // Initialize the active note tracker for debug output memset(app.active_note_start_tick, -1, sizeof(app.active_note_start_tick)); setup_alsa(); setup_tracks(); write_initial_meta_events(); if (app.mode == MODE_MASTER) { printf("Master mode: Starting recording at %d BPM.\n", app.bpm); check_snd(snd_seq_start_queue(app.seq, app.queue_id, NULL), "start queue"); // For debug timing, get a reliable reference time from ALSA itself // immediately after starting the queue. This avoids clock source mismatches. if (app.debug_mode) { snd_seq_queue_status_t *qstatus; snd_seq_queue_status_alloca(&qstatus); check_snd(snd_seq_get_queue_status(app.seq, app.queue_id, qstatus), "get queue status for time ref"); app.ref_tick = snd_seq_queue_status_get_tick_time(qstatus); app.ref_real_time = *snd_seq_queue_status_get_real_time(qstatus); app.queue_time_ref_set = 1; } start_metronome(); } else { printf("Slave mode: Waiting for MIDI clock from %s...\n", app.clock_in_addr); snd_seq_control_queue(app.seq, app.queue_id, SND_SEQ_EVENT_START, 0, NULL); } signal(SIGINT, sighandler); signal(SIGTERM, sighandler); printf("Recording to '%s'. Press Ctrl+C to stop.\n", app.output_filename); int npfds = snd_seq_poll_descriptors_count(app.seq, POLLIN); struct pollfd *pfds = alloca(sizeof(*pfds) * npfds); while (!app.stop_request) { snd_seq_poll_descriptors(app.seq, pfds, npfds, POLLIN); if (poll(pfds, npfds, 1000) < 0 && errno != EINTR) break; snd_seq_event_t *ev; while (snd_seq_event_input(app.seq, &ev) > 0 && !app.stop_request) { if (app.debug_mode) { // printf("INPUT EVENT: type=%-3d src=%-3d:%-3d dest=%-3d:%-3d queue=%-3d ", // ev->type, // ev->source.client, ev->source.port, // ev->dest.client, ev->dest.port, // ev->queue); if (snd_seq_ev_is_tick(ev)) { // printf("time=tick:%u\n", ev->time.tick); } else if (snd_seq_ev_is_real(ev)) { // printf("time=real:%ld.%09ld\n", (long)ev->time.time.tv_sec, (long)ev->time.time.tv_nsec); } else { // printf("time=none\n"); } } // Handle slave mode start, which starts the queue if (ev->type == SND_SEQ_EVENT_START && app.mode == MODE_SLAVE) { printf("Received MIDI Start. Starting recording and metronome.\n"); if (app.debug_mode && !app.queue_time_ref_set) { app.ref_tick = ev->time.tick; // should be 0 app.ref_real_time = ev->time.time; app.queue_time_ref_set = 1; } start_metronome(); } // Handle metronome loopback event if (app.use_metronome && ev->dest.port == app.metronome_loop_port_id && ev->type == SND_SEQ_EVENT_USR0) { metronome_pattern(ev->time.tick); } // Attempt to record any other event. The function itself will filter. record_event(ev); snd_seq_free_event(ev); } } printf("\nRecording stopped. Finalizing file...\n"); terminate_all_active_notes(); finish_tracks(); write_smf_file(); for (int i = 0; i < app.num_tracks; ++i) { struct buffer *b = app.tracks[i].first_buf.next, *next; while (b) { next = b->next; free(b); b = next; } } free(app.tracks); snd_seq_close(app.seq); printf("Done.\n"); return 0; } ``` Issue URL : https://github.com/alsa-project/alsa-utils/issues/307 Repository URL: https://github.com/alsa-project/alsa-utils

1 0

ucm2: sof: hdmi: Add 5.1 and 7.1 variants of HDMI devices when using IPC4
by GitHub pull_request - edited 31 Oct '25

31 Oct '25

alsa-project/alsa-ucm-conf pull request #633 was edited from ujfalusi: Systems using IPC4 can support up to 8 channels of audio (and passthrough) via HDMI. In UCM the default PlaybackChannels is set to 2, which prevents users from selecting multichannel configurations. When probing the card, Pipewire will drop configurations that are not supported either by the PCM device or based on ELD information. This means that if the equipment supports only stereo then the 5.1 and 7.1 variants should not be visible, if the equipment is 5.1 capable, then only the 7.1 variant is removed. The kernel will refine the PCM parameters based on the ELD information as wall when https://lore.kernel.org/linux-sound/20251029073600.13624-1-peter.ujfalusi@l… is applied. @perexg, @wtay, @ford-prefect, is this something which can help PW and user space to handle the HDMI a bit better with SOF? Request URL : https://github.com/alsa-project/alsa-ucm-conf/pull/633 Patch URL : https://github.com/alsa-project/alsa-ucm-conf/pull/633.patch Repository URL: https://github.com/alsa-project/alsa-ucm-conf

1 0

ucm2: sof: hdmi: Add 5.1 and 7.1 varriants of HDMI devices when using IPC4
by GitHub pull_request - opened 31 Oct '25

31 Oct '25

alsa-project/alsa-ucm-conf pull request #633 was opened from ujfalusi: Systems using IPC4 can support up to 8 channels of audio (and passthrough) via HDMI. In UCM the default PlaybackChannels is set to 2, which prevents users from selecting multichannel configurations. When probing the card, Pipewire will drop configurations that are not supported either by the PCM device or based on ELD information. This means that if the equipment supports only stereo then the 5.1 and 7.1 variants should not be visible, if the equipment is 5.1 capable, then only the 7.1 variant is removed. The kernel will refine the PCM parameters based on the ELD information as wall when https://lore.kernel.org/linux-sound/20251029073600.13624-1-peter.ujfalusi@l… is applied. @perexg, @wtay, @ford-prefect, is this something which can help PW and user space to handle the HDMI a bit better with SOF? Request URL : https://github.com/alsa-project/alsa-ucm-conf/pull/633 Patch URL : https://github.com/alsa-project/alsa-ucm-conf/pull/633.patch Repository URL: https://github.com/alsa-project/alsa-ucm-conf

1 0

Raptor Lake external jack needs manual ALSA unmute and speakers don’t auto-mute
by GitHub issues - opened 31 Oct '25

31 Oct '25

alsa-project/alsa-ucm-conf issue #632 was opened from keponk: SOF HDA (skl_hda_dsp_generic) on Raptor Lake: Headphone/Line-out not exposed as a separate port to PipeWire; external jack needs manual ALSA unmute and speakers don’t auto-mute Environment (for quick identification) * Distro: NixOS (current channel) * Audio stack: PipeWire/WirePlumber 1.4.7, PipeWire Pulse * Hardware: Intel Raptor Lake PCH HDA (onboard), SOF HDA path (skl_hda_dsp_generic) * Symptom device string seen in userspace: “Raptor Lake High Definition Audio Controller” * PipeWire sink name: alsa_output.pci-0000_00_1f.3-platform-skl_hda_dsp_generic.HiFi__Speaker__sink Problem summary * The 3.5 mm headphone/line-out jack produces no audio unless the “Headphone” control is manually unmuted via ALSA (alsamixer/amixer). * PipeWire/WirePlumber only expose a single output port (“Speaker”) for this card/profile; there is no separate “Headphones/Line Out” port to select in GNOME/pavucontrol. * Internal speakers do not auto-mute when the external jack is used; some intermittent audio still leaks to the internal speakers. * Jack detection appears unstable (repeated “Headphone Jack” events seen) and the desktop toggles output availability intermittently. Expected outcome * PipeWire/WirePlumber should expose distinct output ports for Speaker and Headphones/Line Out, based on UCM, for this device. * When the 3.5 mm plug is inserted, the system should: 1. Auto-switch to the Headphones/Line Out port, 1. Mute the internal speakers (auto-mute), 1. Keep the state stable (no flapping). 1. Users should not need to manipulate raw ALSA mixer controls manually for basic jack usage. Actual outcome * Only “Speaker” is exposed as an output port; no “Headphones/Line Out” port is available to select. * Audio plays intermittently through internal speakers; external jack is silent until “Headphone” is manually unmuted in alsamixer. * After manual unmute, the external jack works, but internal speakers continue to output intermittently unless manually muted; auto-mute does not engage. * Jack-sense events appear to flap while the plug is steady, causing intermittent switching in the desktop. Steps to reproduce (high level) * Boot system; log in to GNOME (PipeWire/WirePlumber active). * Plug powered external speakers/headphones into the 3.5 mm combo jack. * Observe that "Headphone" output intermittently appears on the dropdown. Hard to select via UI, but when is done, the sound comes out of the internal speakers only, in synchrony with the intermittence in the ui. * Use alsamixer on the SOF HDA card to unmute “Headphone”; external jack starts working, but internal speakers still play unless manually muted; behavior may fluctuate with jack events. Impact: * Users cannot rely on auto-detection or desktop controls for basic headphone/line-out use. Manual ALSA mixer changes are required. Internal speakers may still play, causing privacy/UX issues. Workaround: * Manually unmute “Headphone” and set “Speaker” to lowest volume in alsamixer; Auto-Mute doesn't seem to work in this setup. * Disabling HDA power saving didn't seem to help reduce jack flapping. Possble solution: In alsa-ucm-conf for the SOF HDA “skl_hda_dsp_generic” profile on this Raptor Lake codec: * Define and expose a proper “Headphones/Line Out” device/port alongside “Speaker.” * Add the appropriate Enable/Disable/Jack sequences to unmute Headphone, mute Speaker (auto-mute), and handle jack detection correctly. * If the UCM is already correct for this codec, guidance is appreciated on whether the issue should be addressed in: - ALSA kernel (snd_hda_intel/Realtek codec quirk) or SOF topology/firmware for stable jack sense and correct control exposure. - WirePlumber/PipeWire only if UCM provides the ports but they are not shown. alsa-info: http://alsa-project.org/db/?f=357e5def55a9a2e737306ff2ec22b1526a14f87a Issue URL : https://github.com/alsa-project/alsa-ucm-conf/issues/632 Repository URL: https://github.com/alsa-project/alsa-ucm-conf

3 2

[GIT PULL] ASoC fixes for v6.18-rc2
by Mark Brown 30 Oct '25

30 Oct '25

The following changes since commit 211ddde0823f1442e4ad052a2f30f050145ccada: Linux 6.18-rc2 (2025-10-19 15:19:16 -1000) are available in the Git repository at: https://git.kernel.org/pub/scm/linux/kernel/git/broonie/sound.git tags/asoc-fix-v6.18-rc2 for you to fetch changes up to 5e5c8aa73d99f1daa9f2ec1474b7fc1a6952764b: ASoC: dt-bindings: pm4125-sdw: correct number of soundwire ports (2025-10-29 14:54:47 +0000) ---------------------------------------------------------------- ASoC: Fixes for v6.18 A bigger batch of fixes than I'd like, things built up due to holidays and some last minute issues which caused me to hold off on sending a pul request. None of these are super remarkable, and there's a few new device IDs in here too including a relatively big block of AMD devices. The Cirrus Logic CS530x support subject line is actually a fix that was on the start of that series and got pulled in here, I forgot to fix the subject up when merging. ---------------------------------------------------------------- Bard Liao (1): ASoC: soc_sdw_utils: remove cs42l43 component_name Cezary Rojewski (3): ASoC: Intel: avs: Unprepare a stream when XRUN occurs ASoC: Intel: avs: Disable periods-elapsed work when closing PCM ASoC: Intel: avs: Use snd_codec format when initializing probe Claudiu Beznea (1): ASoC: renesas: rz-ssi: Use proper dma_buffer_pos after resume Haotian Zhang (1): ASoC: mediatek: Fix double pm_runtime_disable in remove functions Maarten Zanders (1): ASoC: fsl_sai: Fix sync error in consumer mode Mark Brown (4): Add support for Cirrus Logic CS530x DAC and CODEC ASoC: Intel: avs: Set of streaming fixes ASoC: fsl: correct the bit order issue for DSD ASoC: Fix build for sdw_utils Richard Fitzgerald (1): ASoC: cs-amp-lib-test: Fix missing include of kunit/test-bug.h Sharique Mohammad (1): ASOC: max98090/91: fix for filter configuration: AHPF removed DMIC2_HPF added Shengjiu Wang (2): ASoC: fsl_sai: fix bit order for DSD format ASoC: fsl_micfil: correct the endian format for DSD Shuming Fan (2): ASoC: sdw_utils: add name_prefix for rt1321 part id ASoC: rt721: fix prepare clock stop failed Simon Trimmer (3): ASoC: cs530x: Correct log message with expected variable ASoC: amd: acp: Add ACP7.0 match entries for cs35l56 and cs42l43 ASoC: Intel: soc-acpi-intel-ptl-match: Remove cs42l43 match from sdw link3 Srinivas Kandagatla (2): ASoC: qdsp6: q6asm: do not sleep while atomic ASoC: dt-bindings: pm4125-sdw: correct number of soundwire ports .../devicetree/bindings/sound/qcom,pm4125-sdw.yaml | 4 +- sound/soc/amd/acp/amd-acp70-acpi-match.c | 157 +++++++++++++++++++++ sound/soc/codecs/cs-amp-lib-test.c | 1 + sound/soc/codecs/cs530x.c | 2 +- sound/soc/codecs/max98090.c | 6 +- sound/soc/codecs/rt721-sdca.c | 4 + sound/soc/codecs/rt721-sdca.h | 1 + sound/soc/fsl/fsl_micfil.c | 4 +- sound/soc/fsl/fsl_sai.c | 11 +- sound/soc/intel/avs/pcm.c | 3 + sound/soc/intel/avs/probes.c | 18 +-- sound/soc/intel/common/soc-acpi-intel-ptl-match.c | 52 ------- sound/soc/mediatek/mt8195/mt8195-afe-pcm.c | 1 - sound/soc/mediatek/mt8365/mt8365-afe-pcm.c | 1 - sound/soc/qcom/qdsp6/q6asm.c | 2 +- sound/soc/renesas/rz-ssi.c | 25 ++-- sound/soc/sdw_utils/soc_sdw_utils.c | 1 - 17 files changed, 203 insertions(+), 90 deletions(-)

2 1

[PATCH AUTOSEL 6.1 02/13] ASoC: amd: yc: Add quirk for Lenovo Yoga Pro 7 14ASP9
by Sasha Levin 30 Oct '25

30 Oct '25

From: Talhah Peerbhai <talhah.peerbhai(a)gmail.com> [ Upstream commit a28206060dc5848a1a2a15b7f6ac6223d869084d ] Similar to many other Lenovo models with AMD chips, the Lenovo Yoga Pro 7 14ASP9 (product name 83HN) requires a specific quirk to ensure internal mic detection. This patch adds a quirk fixing this. Signed-off-by: Talhah Peerbhai <talhah.peerbhai(a)gmail.com> Link: https://patch.msgid.link/20250515222741.144616-1-talhah.peerbhai@gmail.com Signed-off-by: Mark Brown <broonie(a)kernel.org> Signed-off-by: Sasha Levin <sashal(a)kernel.org> --- Based on my analysis of this commit, I can provide a comprehensive assessment for backporting. **YES** This commit should be backported to stable kernel trees for the following reasons: **1. Identical Pattern to Previously Backported Commits:** All five similar commits provided in the historical context (commits for Lenovo models 82UU, 82, 82YM, 83AS, and 21M1) have "Backport Status: YES" and follow the exact same pattern as this commit. This establishes a clear precedent for backporting such changes. **2. Hardware Enablement Bug Fix:** The commit fixes a clear user-affecting bug where the internal microphone on the Lenovo Yoga Pro 7 14ASP9 (product name 83HN) is non-functional. This is a hardware compatibility issue that directly impacts users' ability to use their device's built-in microphone. **3. Minimal and Contained Change:** The code change is extremely small and safe: - Adds only a single 7-line quirk table entry to `sound/soc/amd/yc/acp6x-mach.c` - The change is purely additive - no existing code is modified - The quirk entry follows the exact same pattern as dozens of other entries in the same table - Zero risk of regression to existing functionality **4. Critical Subsystem with Safe Pattern:** While this touches audio (a critical subsystem), the change follows a well-established, safe pattern used extensively in this driver. The quirk table approach is designed specifically for adding device-specific compatibility without affecting other hardware. **5. Clear User Benefit:** Users with this specific Lenovo model will have their internal microphone functionality restored, which is essential for video calls, voice recording, and other audio input tasks. **6. Code Quality Improvement:** The commit also includes a minor whitespace fix (changing spaces to tab at line 350), improving code formatting consistency. **7. Follows Stable Tree Rules:** - Important bugfix: ✓ (enables hardware functionality) - Minimal risk: ✓ (purely additive quirk entry) - Small and contained: ✓ (7 lines added) - No architectural changes: ✓ - Confined to subsystem: ✓ (AMD YC audio driver) The commit message clearly explains the issue and solution, and the change is identical in nature to numerous other successfully backported commits for similar Lenovo audio quirks. This represents a textbook example of a stable-appropriate hardware enablement fix. sound/soc/amd/yc/acp6x-mach.c | 9 ++++++++- 1 file changed, 8 insertions(+), 1 deletion(-) diff --git a/sound/soc/amd/yc/acp6x-mach.c b/sound/soc/amd/yc/acp6x-mach.c index 1f94269e121af..d5dc1d48fca94 100644 --- a/sound/soc/amd/yc/acp6x-mach.c +++ b/sound/soc/amd/yc/acp6x-mach.c @@ -304,6 +304,13 @@ static const struct dmi_system_id yc_acp_quirk_table[] = { DMI_MATCH(DMI_PRODUCT_NAME, "83AS"), } }, + { + .driver_data = &acp6x_card, + .matches = { + DMI_MATCH(DMI_BOARD_VENDOR, "LENOVO"), + DMI_MATCH(DMI_PRODUCT_NAME, "83HN"), + } + }, { .driver_data = &acp6x_card, .matches = { @@ -353,7 +360,7 @@ static const struct dmi_system_id yc_acp_quirk_table[] = { DMI_MATCH(DMI_PRODUCT_NAME, "M5402RA"), } }, - { + { .driver_data = &acp6x_card, .matches = { DMI_MATCH(DMI_BOARD_VENDOR, "ASUSTeK COMPUTER INC."), -- 2.39.5

2 1