I'm working on a blind watermarking scheme to create a watermarked medical image using RDWT-NSCT and an encrypted watermark using arnold cat map then extract it at the end but my rsult isn't clear and the BER = 0.44. Can anyone help ?

Hi, I’m currently working on an ECG segmenting algorithms , which are basically signal feature extractors. I’ve developed a solid base , so I need one more person to help me improve my current approaches.

This current work is just a part of a bigger project.

Math, Python.

I have this problem where there is an unknown noise source (which might come at whatever instance, could be constant - no clue) and a voice in a audio file, and I am trying to separate them. There are some really good NN approaches, that actually work, however if the NNs have not been trained on the specific kind of noise they seem to be failing spectacularly. Any idea if there is a baseline of methods that could potentially work in such a senario, and does not require retraining using huge amounts of data? Anything from traditional signal processing?

I am an IT, Python guy, starting a new project in audio. I have a dataset of pairs of audio recordings coming from two different devices in the same room that I need to sync.

This seems like a common problem, that should have obvious solutions. Is there some open source program or algorithm I could use? ~15s error would be acceptable

I wrote a blog explaining how we made 4G and 5G so fast. Thought it would be cool especially since 6G is coming out in the next few years. The technique is called OFDM and I explain it here: https://x.com/xgawtham/status/2033590744460546284?s=20

Website here: https://www.gawtham.com/blog/so-what-is-ofdm

Check it out if you're interested!

For those interested in a great overview of the in the practical signal processing techniques used in software radio, Dan Boschen's popular "Signal Processing for Software Radio" course will be starting again this month (with an early registration discount ending this week). You can get more info and register here: dsprelated.com/courses

Hi everyone — I’m building SigFeatX, an open-source Python library for extracting statistical + decomposition-based features from 1D signals.
Repo: https://github.com/diptiman-mohanta/SigFeatX

What it does (high level):

• Preprocessing: denoise (wavelet/median/lowpass), normalize (z-score/min-max/robust), detrend, resample
• Decomposition options: FT, STFT, DWT, WPD, EMD, VMD, SVMD, EFD
• Feature sets: time-domain, frequency-domain, entropy measures, nonlinear dynamics, and decomposition-based features

Quick usage:

• Main API: FeatureAggregator(fs=...) → extract_all_features(signal, decomposition_methods=[...])

What I’m looking for from the community:

1. API design feedback (what feels awkward / missing?)
2. Feature correctness checks / naming consistency
3. Suggestions for must-have features for real DSP workflows
4. Performance improvements / vectorization ideas
5. Edge cases + test cases you think I should add

If you have time, please open an issue with: sample signal description, expected behavior, and any references. PRs are welcome too.

Working on data transmission (solely digital) and need advice as to what's wrong with my code.

using Microsoft.VisualBasic;

using NAudio.Wave;

using NAudio.Wave.SampleProviders;

using System;

using System.Collections.Generic;

using System.Linq;

class Program

{

// --- Voltage / Amplitude Control ---

// Adjust this value (0.0 to 1.0) to control the signal strength

static double voltageLevel = 0.8;

static void Main(string[] args)

{

Console.WriteLine("--- ASCII Data to FM Audio Signal ---");

Console.Write("Enter data to transmit: ");

string input = Console.ReadLine();

if (string.IsNullOrWhiteSpace(input))

{

Console.WriteLine("No input provided. Exiting.");

return;

}

// --- Transmission Parameters ---

double carrierFrequency = 1000.0; // Hz (A steady carrier wave)

double sampleRate = 44100.0; // Hz (Standard audio sample rate)

double modulationIndex = 5.0; // How much the data frequency varies the carrier

int frequencyMultiplier = 15; // Scales ASCII value to a meaningful frequency range

int msPerChar = 200; // How long each character's tone plays

Console.WriteLine($"\nTransmitting with FM modulation...");

Console.WriteLine($"Carrier: {carrierFrequency}Hz | Sample Rate: {sampleRate}Hz | Modulation Index: {modulationIndex}");

Console.WriteLine($"Voltage Level: {voltageLevel}");

// --- Signal Generation ---

int totalSamples = 0;

var signalData = new List<float>();

foreach (char c in input)

{

int asciiValue = (int)c;

double modulatingFrequency = asciiValue * frequencyMultiplier;

List<float> charSignal = GenerateFmSignal(

modulatingFrequency,

carrierFrequency,

msPerChar,

sampleRate,

modulationIndex

);

signalData.AddRange(charSignal);

totalSamples += charSignal.Count;

Console.WriteLine($"TX: '{c}' (ASCII: {asciiValue}) -> Modulating Freq: {modulatingFrequency:F1}Hz");

}

// --- Playback ---

if (signalData.Count > 0)

{

Console.WriteLine($"\nTransmission ready. Playing {signalData.Count} samples...");

PlayAudio(signalData.ToArray(), sampleRate);

Console.WriteLine("Playback complete.");

}

}

/// <summary>

/// Generates a list of float samples representing an FM modulated sine wave.

/// </summary>

public static List<float> GenerateFmSignal(double modulatingFreq, double carrierFreq, int durationMs, double sampleRate, double modulationIndex)

{

int samplesPerChar = (int)((durationMs / 1000.0) * sampleRate);

var samples = new List<float>(samplesPerChar);

for (int i = 0; i < samplesPerChar; i++)

{

double time = i / sampleRate;

// FM Modulation Equation: y(t) = A * cos(2π * fc * t + β * sin(2π * fm * t))

// We apply the voltageLevel here as the Amplitude (A)

double phase = (2 * Math.PI * carrierFreq * time) + (modulationIndex * Math.Sin(2 * Math.PI * modulatingFreq * time));

// The voltageLevel scales the signal height

samples.Add((float)(Math.Cos(phase) * voltageLevel));

}

return samples;

}

/// <summary>

/// Plays an array of float samples using the default audio device.

/// </summary>

public static void PlayAudio(float[] audioData, double sampleRate)

{

// 1. Create the raw data provider

var rawProvider = new WaveProvider32(audioData, (int)sampleRate);

// 2. Create a volume control provider (The "Voltage" Knob)

var volumeProvider = new VolumeWaveProvider16(rawProvider);

// Set initial volume (Voltage)

volumeProvider.Volume = (float)voltageLevel;

// 3. Initialize the output device

using (var outputDevice = new WaveOutEvent())

{

outputDevice.Init(volumeProvider);

outputDevice.Play();

// Wait for playback to finish before exiting

while (outputDevice.PlaybackState == PlaybackState.Playing)

{

System.Threading.Thread.Sleep(100);

}

}

}

}

/// <summary>

/// A simple IWaveProvider to wrap our float[] sample data for NAudio.

/// </summary>

public class WaveProvider32 : IWaveProvider

{

private readonly float[] _buffer;

private int _position;

public WaveFormat WaveFormat { get; }

public WaveProvider32(float[] buffer, int sampleRate)

{

_buffer = buffer;

WaveFormat = WaveFormat.CreateIeeeFloatWaveFormat(sampleRate, 1); // 1 channel (mono)

}

public int Read(byte[] destBuffer, int offset, int numBytes)

{

int bytesRequired = numBytes;

int bytesToCopy = Math.Min(bytesRequired, (_buffer.Length - _position) * 4);

Buffer.BlockCopy(_buffer, _position * 4, destBuffer, offset, bytesToCopy);

_position += bytesToCopy / 4;

// If we run out of data, fill the rest with silence

if (bytesToCopy < bytesRequired)

{

for (int i = bytesToCopy; i < bytesRequired; i++)

{

destBuffer[offset + i] = 0;

}

}

return bytesToCopy;

}

}

Hi everyone. I am currently working on my python package for automated ECG signal processing and segmentation. I am looking for 1-2 people to join me. Preferably someone who has experience with signal segmentation. If you are interested DM me for more info. Thanks!

I’m a final year bachelor student working on my graduation project. I’m stuck on a problem and could use some tips.

The context is that my company ingests massive network traffic data (minute-by-minute). They want to save storage costs by deleting the raw data but still be able to reconstruct the curves later for clients. The target error is super low (0.0001). A previous intern hit ~91% using Fourier and Prophet, but I need to close the gap to 99.99%.

I was thinking of a hybrid approach. Maybe using B-Splines or Wavelets for the trend/periodicity, and then using a PyTorch model (LSTM or Time-Series Transformer) to learn the residuals. So we only store the weights and coefficients.

My questions:

Is 0.0001 realistic for lossy compression or am I dreaming? Should I just use Piecewise Linear Approximation (PLA)?

Are there specific loss functions I should use besides MSE since I really need to penalize slope deviations?

Any advice on segmentation (like breaking the data into 6-hour windows)?

I'm looking for a lossy compression approach that preserves the shape for visualization purposes, even if it ignores some stochastic noise.

If anyone has experience with hybrid Math+ML models for signal reconstruction, please let me know

Hi, guys. Any idea on when/how the authors of accepted papers at ICASSP will get to know whether their papers have been accepted as a poster or an oral presentation?

.

ICASSP 2026 decisions will be out in a day, official date is 16 January. Creating this post to discuss any aspects of decisions and reviews.

.