drinkussions(Baban and Saanjoo): STATISTIKALLY 180 ROTATIONS DONE 66 COPIES PANNED

read this file thoroughly and guide me (write c sharp code) how to enhance this to use the resampling (WELL CALCULATED RESAMPLING TO DO for each copy of samples WITHOUT USING ANY THIRD PARTY API ) where any given T millisecond sample will get exactly (T' millisecond (all samples to cover * 66 shrutis (22 lower octave 22 for middle octave 22 for upper octave ) and the 66 transformed copy of these all the samples need play fully (not truncated nor extended) i need all the copies in single wav file (i will supply the raw pcm wav file 8000 samples per second or whatever 16000 sps or 44100 sps or 96000 sps , mono or stereo what ever with what ever bit depth i will supply (specially 16 bit default)) the output will generate as 8000 samples per second with 66 * whole songs (durations auto calculated to render whole songs even the frequencies are higher or lower ) RESAMPLING methods to explain properly ... no truncation allowed no extension allowed... i will listen 66 copies of given sample with all altered pitches as necessary example first one will have 33 shruti up notes(lower frequencies but durations of playtime for each note to remain intact as original sample ) (shifter as necessary) and the last one will have 33 shrutis down notes (higher frequencies but durations of playtime for each note to remain intact as original sample )... write teh c sharp code and explain all lines of code... algorithms also ...........please read the codes which are working

Okay, I've incorporated the advanced analysis and intelligent panning features into the C# code in the Canvas. This is a substantial update, focusing on:

Enhanced First Scan Analysis:

Slope Statistics: A new AngleStats struct and CalculateAngleStatistics method are added to compute counts and timestamp percentiles for each slope angle. This provides the "frequency of rotation degrees" you asked for.
Global Min/Max Counts: These are determined for normalizing statistics, which is crucial for color mapping.

Color-Coded Bitmap and DXF Output:

GenerateSlopeAndAmplitudeBitmap (Enhanced):

The bitmap height is doubled. The top half plots slope angles, and the bottom half plots the waveform amplitude.
Slope Plot Color: Dots representing slope angles are now color-coded. The color intensity (from light gray to black, or a color gradient if preferred and implemented) reflects the normalized frequency (count) of that specific angle occurring in the original audio.
Amplitude Plot: The waveform is drawn in the bottom half.
Amplitude Plot Color: The color of each point/segment of the amplitude plot is also determined by the normalized frequency of the slope angle calculated at that specific point in time in the original audio.

SaveDxfWithLayersAndColors (Enhanced):

DXF layers are now named ANGLE_<degree>_COUNT_<count>, incorporating the frequency information.
Circles in the DXF are assigned a color index based on the normalized frequency of their respective angle. A simple mapping to common DXF color indices is used.

Intelligent Panning based on Analysis:

ApplyIntelligentDynamicPanningToStereo (Enhanced):

This method now receives the angleStats (containing frequency counts for each slope angle in the original audio) and the normalizedMinMaxAngleCounts.
When processing each sample of a shruti-shifted mono segment, it maps the current time in that variant back to the corresponding time in the original, unshifted audio (originalEquivalentTimeMs).
It then finds the SlopePoint from the original audio analysis that is closest to this originalEquivalentTimeMs.
The panning strength is determined by the normalized frequency (count) of the slope angle found at that corresponding original time.

More frequent (common) slope angles in the original audio at that point can lead to a wider/harder pan in the current variant.
Less frequent (rarer) slope angles can lead to a softer pan, keeping the sound more centered.

The basic zero-crossing detection within the current shruti-shifted segment still determines when to switch the general pan direction (Left-to-Right or Right-to-Left). The "intelligence" now dictates how strongly it's panned.

Refinements and Structure:

Helper methods for color mapping and normalization are included.
The overall single-class structure and core resampling logic are maintained.
Output remains 44100 Hz, 16-bit stereo.

This version significantly steps up the analysis and uses that analysis to directly influence the stereo imaging of the output.

Here's the updated code in the Canvas:

I've updated the code in the Canvas to incorporate the enhancements you requested.

Here's a breakdown of the changes:

Statistics Calculation (AnalyzeSlopes and AngleStats):

The AnalyzeSlopes method now populates a Dictionary<int, AngleStats> angleStatistics.
The AngleStats struct stores the AngleDegree, its Count (frequency), a list of Timestamps where it occurred, and P25, P50, P75 timestamp percentiles.
AnalyzeSlopes also calculates globalMinMaxAngleCounts (the minimum and maximum occurrence count across all angles), which is used for normalizing the counts for color-coding and panning strength.

Color-Coded Bitmap (GenerateSlopeAndAmplitudeBitmap):

The bitmap height is increased to accommodate both the slope plot and an amplitude waveform plot below it.
Slope Plot: Dots are colored based on the normalized frequency of their angle. I've implemented a GetColorFromNormalizedValue helper that can produce grayscale (darker for more frequent) or a simple heatmap (Blue-Green-Red). Currently, it's set to grayscale for the slope dots.
Amplitude Plot: The waveform is drawn. The color of the waveform line segments is also determined by the normalized frequency of the slope angle occurring at that specific time in the original audio. This uses the heatmap color scheme from GetColorFromNormalizedValue.

Color-Coded DXF with Layers (SaveDxfWithLayersAndColors):

Layers: DXF layers are now named in the format ANGLE_<original_angle>_COUNT_<count>, e.g., ANGLE_45_COUNT_120 or ANGLE_NEG30_COUNT_50.
Colors: Entities (POINTs, for simplicity) on each layer are assigned a DXF color index based on the normalized frequency of that layer's angle. A simple mapping GetDxfColorIndexFromNormalizedValue is used (e.g., blue for low frequency, red for high).
POINT entities are used instead of CIRCLEs for simpler DXF generation, plotting (timestampMs, original_angle_degrees) where original_angle_degrees is the -90 to +90 range.

Statistics-Driven Panning (ApplyIntelligentDynamicPanningToStereo):

This method now receives originalAngleStats and globalMinMaxAngleCounts.
For each sample in the current shruti-shifted monoSegment:

It maps the current time in the variant back to the originalEquivalentTimeMs in the unshifted audio.
It finds the closest SlopePoint from the originalSlopeData corresponding to this originalEquivalentTimeMs.
It retrieves the AngleStats for the angle of that original slope point.
A panFactor (0 for center, 1 for full deviation) is calculated based on the normalized frequency (count) of this original angle. More frequent angles in the original audio result in a panFactor closer to 1 (wider pan).
The panning logic now uses this panFactor to adjust the amplitude of the "quieter" channel:

If panToLeft: leftOutputSample = currentMonoSample; rightOutputSample = currentMonoSample * (1.0f - panFactor);
If panToRight: leftOutputSample = currentMonoSample * (1.0f - panFactor); rightOutputSample = currentMonoSample;

Zero-crossing detection within the monoSegment still determines when panToLeft flips.

Analysis Report (SaveAnalysisText):

The text report now includes the count and timestamp percentiles (P25, P50, P75) for each slope angle.

WAV Writing:

The PatchWavHeader now correctly calculates dataSize based on totalStereoSamplesWritten (which is the count of L/R pairs, so each represents one sample in time for the stereo output).

This version is significantly more complex due to the detailed analysis and the attempt to link that analysis back to the creative process of panning. The "intelligence" of the panning is now directly tied to how common or rare certain slope characteristics were in the original recording at corresponding moments.

using System;

using System.Collections.Generic;

using System.IO;

using System.Linq;

using System.Text;

using System.Drawing; // For Bitmap generation. Requires System.Drawing.Common NuGet for .NET Core/5+

using System.Drawing.Imaging;

namespace ShrutiResampler

{

/// <summary>

/// Performs multi-scan analysis on an input WAV file, generates a slope activity bitmap,

/// and then creates 66 pitch-shifted stereo variants with dynamic panning influenced by analysis.

/// Output is 44100 Hz, 16-bit stereo.

/// </summary>

public class TO_DO_THE_MULTIPLE_SCANNING_ON_SUPPLIED_SAMPLES_PAN_WITH_FREQUENCY_CHANGES_44100_SPS_2_CHANNELS___NEW_KIND_OF_ShrutiResamplerGenerator___33_PLUS_33_66_COPIES_PLAYING_ALL_SAMPLES___GPT

{

// Represents the WAV file header structure.

private struct WavHeader

{

public byte[] RiffId; public uint FileSize; public byte[] WaveId;

public byte[] FmtId; public uint FmtSize; public ushort AudioFormat;

public ushort NumChannels; public uint SampleRate; public uint ByteRate;

public ushort BlockAlign; public ushort BitsPerSample;

public byte[] DataId; public uint DataSize;

}

// Analysis data structures

private struct SlopePoint

{

public double TimestampMs;

public int AngleDegrees; // 0-180, where 0 is -90deg, 90 is 0deg, 180 is +90deg slope

public float OriginalAmplitude; // Store original amplitude for bitmap

}

private struct ZeroCrossingSegment

{

public double StartTimeMs;

public double EndTimeMs;

public int SampleCount;

public float PeakAmplitude;

}

private struct AngleStats

{

public int AngleDegree; // The specific angle (0-180)

public int Count; // How many times this angle occurred

public List<double> Timestamps; // List of timestamps where this angle occurred

public double P25Timestamp, P50Timestamp, P75Timestamp; // Percentiles of timestamps

}

// Constants for the output WAV file format

private const int OutputGlobalSampleRate = 44100;

private const ushort OutputGlobalBitsPerSample = 16;

private const ushort OutputGlobalNumChannels = 2; // Stereo output

#region WAV File I/O

private static float[] ReadWavFile(string filePath, out WavHeader header)

{

header = new WavHeader();

byte[] wavBytes;

try { wavBytes = File.ReadAllBytes(filePath); }

catch (Exception ex) { Console.WriteLine($"Error reading file bytes from {filePath}: {ex.Message}"); return null; }

using (MemoryStream ms = new MemoryStream(wavBytes))

using (BinaryReader reader = new BinaryReader(ms))

{

try

{

header.RiffId = reader.ReadBytes(4); if (Encoding.ASCII.GetString(header.RiffId) != "RIFF") throw new FormatException("Not a RIFF file.");

header.FileSize = reader.ReadUInt32(); header.WaveId = reader.ReadBytes(4); if (Encoding.ASCII.GetString(header.WaveId) != "WAVE") throw new FormatException("Not a WAVE file.");

bool fmtChunkFound = false;

while (reader.BaseStream.Position < reader.BaseStream.Length)

{

byte[] chunkIdBytes = reader.ReadBytes(4); string chunkId = Encoding.ASCII.GetString(chunkIdBytes); uint chunkSize = reader.ReadUInt32();

if (chunkId == "fmt ")

{

header.FmtId = chunkIdBytes; header.FmtSize = chunkSize; header.AudioFormat = reader.ReadUInt16();

header.NumChannels = reader.ReadUInt16(); header.SampleRate = reader.ReadUInt32(); header.ByteRate = reader.ReadUInt32();

header.BlockAlign = reader.ReadUInt16(); header.BitsPerSample = reader.ReadUInt16();

if (header.FmtSize > 16) reader.ReadBytes((int)(header.FmtSize - 16));

fmtChunkFound = true; break;

}

else { if (reader.BaseStream.Position + chunkSize > reader.BaseStream.Length) break; reader.BaseStream.Seek(chunkSize, SeekOrigin.Current); }

}

if (!fmtChunkFound) throw new FormatException("fmt chunk not found.");

if (header.AudioFormat != 1 && header.AudioFormat != 3) throw new NotSupportedException($"Audio format {header.AudioFormat} not supported. Only PCM (1) or IEEE Float (3).");

bool dataChunkFound = false;

while (reader.BaseStream.Position < reader.BaseStream.Length)

{

byte[] chunkIdBytes = reader.ReadBytes(4); string chunkId = Encoding.ASCII.GetString(chunkIdBytes); uint chunkSize = reader.ReadUInt32();

if (chunkId == "data")

{

header.DataId = chunkIdBytes; header.DataSize = chunkSize; int totalDataSamplesInChunk = (int)(header.DataSize / header.BlockAlign); List<float> monoSamples = new List<float>(totalDataSamplesInChunk);

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

{

float leftSample = 0, rightSample = 0;

switch (header.BitsPerSample)

{

case 8: leftSample = (reader.ReadByte() - 128) / 128.0f; if (header.NumChannels == 2) rightSample = (reader.ReadByte() - 128) / 128.0f; break;

case 16: leftSample = reader.ReadInt16() / 32768.0f; if (header.NumChannels == 2) rightSample = reader.ReadInt16() / 32768.0f; break;

case 24: byte[] s24L = reader.ReadBytes(3); int v24L = (s24L[2] << 16) | (s24L[1] << 8) | s24L[0]; if ((v24L & 0x800000) > 0) v24L |= ~0xFFFFFF; leftSample = v24L / 8388608.0f; if (header.NumChannels == 2) { byte[] s24R = reader.ReadBytes(3); int v24R = (s24R[2] << 16) | (s24R[1] << 8) | s24R[0]; if ((v24R & 0x800000) > 0) v24R |= ~0xFFFFFF; rightSample = v24R / 8388608.0f; } break;

case 32: if (header.AudioFormat == 1) { leftSample = reader.ReadInt32() / 2147483648.0f; if (header.NumChannels == 2) rightSample = reader.ReadInt32() / 2147483648.0f; } else if (header.AudioFormat == 3) { leftSample = reader.ReadSingle(); if (header.NumChannels == 2) rightSample = reader.ReadSingle(); } else throw new NotSupportedException("32-bit non-float/int PCM not supported."); break;

default: throw new NotSupportedException($"BitsPerSample {header.BitsPerSample} not supported.");

}

monoSamples.Add(header.NumChannels == 2 ? (leftSample + rightSample) * 0.5f : leftSample);

}

dataChunkFound = true; return monoSamples.ToArray();

}

else { if (reader.BaseStream.Position + chunkSize > reader.BaseStream.Length) break; reader.BaseStream.Seek(chunkSize, SeekOrigin.Current); }

}

if (!dataChunkFound) throw new FormatException("data chunk not found."); return null;

}

catch (Exception ex) { Console.WriteLine($"Error parsing WAV data: {ex.Message}"); return null; }

}

private static void WriteWavHeaderPlaceholder(BinaryWriter writer)

{

writer.Write(Encoding.ASCII.GetBytes("RIFF")); writer.Write(0); // FileSize placeholder

writer.Write(Encoding.ASCII.GetBytes("WAVE")); writer.Write(Encoding.ASCII.GetBytes("fmt "));

writer.Write(16); writer.Write((ushort)1); // PCM

writer.Write(OutputGlobalNumChannels); writer.Write(OutputGlobalSampleRate);

writer.Write(OutputGlobalSampleRate * OutputGlobalNumChannels * (OutputGlobalBitsPerSample / 8)); // ByteRate

writer.Write((ushort)(OutputGlobalNumChannels * (OutputGlobalBitsPerSample / 8))); // BlockAlign

writer.Write(OutputGlobalBitsPerSample); writer.Write(Encoding.ASCII.GetBytes("data"));

writer.Write(0); // DataSize placeholder

}

private static void PatchWavHeader(BinaryWriter writer, long totalStereoSamplesWritten) // totalStereoSamplesWritten is count of L/R pairs

{

long dataSize = totalStereoSamplesWritten * OutputGlobalNumChannels * (OutputGlobalBitsPerSample / 8); // Correct: total L/R pairs * 2 channels * bytes_per_sample_per_channel

long fileSize = 36 + dataSize;

writer.Seek(4, SeekOrigin.Begin); writer.Write((uint)fileSize);

writer.Seek(40, SeekOrigin.Begin); writer.Write((uint)dataSize);

}

private static void WriteStereoSampleData(BinaryWriter writer, float leftSample, float rightSample)

{

short pcmL = (short)(Math.Max(-1.0f, Math.Min(1.0f, leftSample)) * short.MaxValue);

short pcmR = (short)(Math.Max(-1.0f, Math.Min(1.0f, rightSample)) * short.MaxValue);

writer.Write(pcmL);

writer.Write(pcmR);

}

#endregion

#region First Scan Analysis Methods

private static List<SlopePoint> AnalyzeSlopes(float[] monoSamples, uint sourceRate, out Dictionary<int, AngleStats> angleStatistics, out Tuple<int, int> globalMinMaxCounts)

{

Console.WriteLine("Performing slope analysis...");

List<SlopePoint> slopeData = new List<SlopePoint>();

// angleHistogramData will store timestamps for each angle, used to build AngleStats

List<double>[] angleHistogramData = new List<double>[181];

for (int i = 0; i <= 180; i++) angleHistogramData[i] = new List<double>();

globalMinMaxCounts = new Tuple<int, int>(int.MaxValue, int.MinValue);

angleStatistics = new Dictionary<int, AngleStats>();

if (monoSamples.Length < 2) return slopeData;

double dtMilliseconds = 1000.0 / sourceRate;

if (dtMilliseconds == 0) { Console.WriteLine("Warning: dtMilliseconds is zero."); return slopeData; }

for (int i = 0; i < monoSamples.Length - 1; i++)

{

float amp1 = monoSamples[i];

float amp2 = monoSamples[i + 1];

double dAmplitude = amp2 - amp1;

double angleRadians = Math.Atan(dAmplitude / dtMilliseconds);

double angleDegrees = angleRadians * (180.0 / Math.PI);

int mappedAngle = (int)Math.Round(angleDegrees + 90.0);

mappedAngle = Math.Max(0, Math.Min(180, mappedAngle));

double timestampMs = (i + 0.5) * dtMilliseconds;

// Store original amplitude with the slope point for later bitmap coloring

slopeData.Add(new SlopePoint { TimestampMs = timestampMs, AngleDegrees = mappedAngle, OriginalAmplitude = amp1 });

angleHistogramData[mappedAngle].Add(timestampMs);

}

// Calculate statistics from histogram

for (int angle = 0; angle <= 180; angle++)

{

var timestamps = angleHistogramData[angle];

int count = timestamps.Count;

if (count > 0)

{

if (count < globalMinMaxCounts.Item1) globalMinMaxCounts = new Tuple<int, int>(count, globalMinMaxCounts.Item2);

if (count > globalMinMaxCounts.Item2) globalMinMaxCounts = new Tuple<int, int>(globalMinMaxCounts.Item1, count);

timestamps.Sort(); // Needed for percentiles

angleStatistics[angle] = new AngleStats

{

AngleDegree = angle,

Count = count,

Timestamps = new List<double>(timestamps), // Store a copy

P25Timestamp = timestamps[(int)(count * 0.25)],

P50Timestamp = timestamps[(int)(count * 0.50)],

P75Timestamp = timestamps[(int)(count * 0.75)]

};

}

if (globalMinMaxCounts.Item1 == int.MaxValue) globalMinMaxCounts = new Tuple<int, int>(0, 0); // Handle case with no slopes

Console.WriteLine($"Slope analysis completed. {slopeData.Count} slope points found. Global angle counts Min: {globalMinMaxCounts.Item1}, Max: {globalMinMaxCounts.Item2}");

return slopeData;

}

private static Color GetColorFromNormalizedValue(double normalizedValue, bool useGrayscale = true)

{

// normalizedValue is 0 to 1

if (useGrayscale)

{

int gray = 255 - (int)(normalizedValue * 255.0); // Darker for higher values

gray = Math.Max(0, Math.Min(255, gray));

return Color.FromArgb(gray, gray, gray);

}

else // Simple heatmap: Blue (low) -> Green (mid) -> Red (high)

{

int r, g, b;

if (normalizedValue < 0.5) // Blue to Green

{

r = 0;

g = (int)(normalizedValue * 2 * 255);

b = (int)((0.5 - normalizedValue) * 2 * 255);

}

else // Green to Red

{

r = (int)((normalizedValue - 0.5) * 2 * 255);

g = (int)((1.0 - normalizedValue) * 2 * 255);

b = 0;

}

return Color.FromArgb(Math.Max(0,Math.Min(255,r)), Math.Max(0,Math.Min(255,g)), Math.Max(0,Math.Min(255,b)));

}

// Map normalized count to a DXF color index (1-255). Simple example.

private static short GetDxfColorIndexFromNormalizedValue(double normalizedValue)

{

// Example: 1=Red, 2=Yellow, 3=Green, 4=Cyan, 5=Blue, 6=Magenta, 7=White/Black

if (normalizedValue < 0.2) return 5; // Blue for low freq

if (normalizedValue < 0.4) return 4; // Cyan

if (normalizedValue < 0.6) return 3; // Green

if (normalizedValue < 0.8) return 2; // Yellow

return 1; // Red for high freq

}

private static void GenerateSlopeAndAmplitudeBitmap(List<SlopePoint> slopeData, float[] monoSamples, uint sourceRate, Dictionary<int, AngleStats> angleStatistics, Tuple<int,int> globalMinMaxAngleCounts, string outputBitmapPath)

{

Console.WriteLine("Generating enhanced slope and amplitude bitmap...");

if (monoSamples.Length == 0) { Console.WriteLine("No audio samples for bitmap."); return; }

try

{

double totalDurationMs = monoSamples.Length * (1000.0 / sourceRate);

int bitmapWidth = (int)Math.Ceiling(totalDurationMs);

if (bitmapWidth <= 0) { Console.WriteLine("Bitmap width is zero or negative."); return; }

bitmapWidth = Math.Min(bitmapWidth, 8000); // Cap width

int slopePlotHeight = 362; // 2px per degree for 0-180

int amplitudePlotHeight = 200; // Arbitrary height for amplitude

int totalBitmapHeight = slopePlotHeight + amplitudePlotHeight + 20; // +20 for spacing

using (Bitmap bmp = new Bitmap(bitmapWidth, totalBitmapHeight))

using (Graphics g = Graphics.FromImage(bmp))

{

g.FillRectangle(Brushes.White, 0, 0, bitmapWidth, totalBitmapHeight);

float pixelsPerMs = (float)bitmapWidth / (float)totalDurationMs;

// --- Slope Plot (Top Part) ---

float pixelsPerDegreeSlope = (float)slopePlotHeight / 181.0f;

foreach (var point in slopeData)

{

int x = (int)Math.Round(point.TimestampMs * pixelsPerMs);

int ySlope = (int)Math.Round(point.AngleDegrees * pixelsPerDegreeSlope);

Color pointColor = Color.Black; // Default

if (angleStatistics.TryGetValue(point.AngleDegrees, out AngleStats stats) && globalMinMaxAngleCounts.Item2 > globalMinMaxAngleCounts.Item1)

{

double normalizedCount = (double)(stats.Count - globalMinMaxAngleCounts.Item1) / (globalMinMaxAngleCounts.Item2 - globalMinMaxAngleCounts.Item1);

pointColor = GetColorFromNormalizedValue(normalizedCount, true); // Grayscale for slope dots

}

if (x >= 0 && x < bitmapWidth && ySlope >= 0 && ySlope < slopePlotHeight)

{

using(Brush b = new SolidBrush(pointColor)) g.FillEllipse(b, x - 1, ySlope - 1, 3, 3); // Small circle

}

// --- Amplitude Plot (Bottom Part) ---

int amplitudePlotYOffset = slopePlotHeight + 10; // Start Y for amplitude plot

float amplitudeScale = amplitudePlotHeight / 2.0f; // Scale amplitude to fit

int centerYAmplitude = amplitudePlotYOffset + (amplitudePlotHeight / 2);

// Find the slope point closest to the current sample's timestamp for coloring amplitude

int currentSlopePointIndex = 0;

for (int i = 0; i < monoSamples.Length; i++)

{

double sampleTimestampMs = i * (1000.0 / sourceRate);

int x = (int)Math.Round(sampleTimestampMs * pixelsPerMs);

int yAmplitude = centerYAmplitude - (int)(monoSamples[i] * amplitudeScale);

yAmplitude = Math.Max(amplitudePlotYOffset, Math.Min(amplitudePlotYOffset + amplitudePlotHeight -1, yAmplitude));

Color ampColor = Color.DarkBlue; // Default for amplitude line

// Find corresponding slope point for coloring

while(currentSlopePointIndex < slopeData.Count - 1 && slopeData[currentSlopePointIndex+1].TimestampMs < sampleTimestampMs)

{

currentSlopePointIndex++;

}

if(currentSlopePointIndex < slopeData.Count)

{

SlopePoint relevantSlope = slopeData[currentSlopePointIndex];

if (angleStatistics.TryGetValue(relevantSlope.AngleDegrees, out AngleStats stats) && globalMinMaxAngleCounts.Item2 > globalMinMaxAngleCounts.Item1)

{

double normalizedCount = (double)(stats.Count - globalMinMaxAngleCounts.Item1) / (globalMinMaxAngleCounts.Item2 - globalMinMaxAngleCounts.Item1);

ampColor = GetColorFromNormalizedValue(normalizedCount, false); // Heatmap for amplitude line

}

if (x >= 0 && x < bitmapWidth)

{

if (i > 0) {

int prevX = (int)Math.Round((i - 1) * (1000.0 / sourceRate) * pixelsPerMs);

int prevYAmplitude = centerYAmplitude - (int)(monoSamples[i-1] * amplitudeScale);

prevYAmplitude = Math.Max(amplitudePlotYOffset, Math.Min(amplitudePlotYOffset + amplitudePlotHeight -1, prevYAmplitude));

using(Pen p = new Pen(ampColor, 1)) g.DrawLine(p, prevX, prevYAmplitude, x, yAmplitude);

} else {

using(Brush b = new SolidBrush(ampColor)) g.FillRectangle(b, x, yAmplitude, 1, 1); // Single pixel for first point

}

bmp.Save(outputBitmapPath, ImageFormat.Png);

Console.WriteLine($"Enhanced bitmap saved to: {outputBitmapPath}");

}

catch (Exception ex) { Console.WriteLine($"Error generating bitmap: {ex.Message}. Ensure System.Drawing.Common is available."); }

}

private static void SaveDxfWithLayersAndColors(Dictionary<int, AngleStats> angleStatistics, Tuple<int,int> globalMinMaxAngleCounts, string outputDxfPath)

{

Console.WriteLine("Generating DXF file with layers and colors...");

try

{

using (StreamWriter sw = new StreamWriter(outputDxfPath))

{

// DXF Header

sw.WriteLine("0\nSECTION\n2\nHEADER");

sw.WriteLine("9\n$ACADVER\n1\nAC1009"); // AutoCAD R12 DXF version

sw.WriteLine("0\nENDSEC");

// Layer Table

sw.WriteLine("0\nSECTION\n2\nTABLES");

sw.WriteLine("0\nTABLE\n2\nLAYER");

sw.WriteLine("70\n" + (angleStatistics.Count + 1)); // Number of layers + default layer "0"

// Default Layer "0"

sw.WriteLine("0\nLAYER\n70\n0\n2\n0\n6\nCONTINUOUS\n62\n7"); // Name, flags, linetype, color (7=white/black)

foreach (var kvp in angleStatistics.OrderBy(s => s.Key))

{

int angle = kvp.Key;

AngleStats stats = kvp.Value;

string layerName = $"ANGLE_{angle-90}_COUNT_{stats.Count}"; // Mapped angle used for display

layerName = layerName.Replace("-", "NEG"); // DXF layer names don't like minus

if(layerName.Length > 31) layerName = layerName.Substring(0,31); // Max layer name length often restricted

double normalizedCount = 0;

if (globalMinMaxAngleCounts.Item2 > globalMinMaxAngleCounts.Item1)

normalizedCount = (double)(stats.Count - globalMinMaxAngleCounts.Item1) / (globalMinMaxAngleCounts.Item2 - globalMinMaxAngleCounts.Item1);

short dxfColor = GetDxfColorIndexFromNormalizedValue(normalizedCount);

sw.WriteLine("0\nLAYER");

sw.WriteLine("70\n0"); // Layer flags

sw.WriteLine("2\n" + layerName); // Layer name

sw.WriteLine("62\n" + dxfColor); // Color index

sw.WriteLine("6\nCONTINUOUS"); // Linetype

}

sw.WriteLine("0\nENDTAB\n0\nENDSEC");

// Entities Section

sw.WriteLine("0\nSECTION\n2\nENTITIES");

foreach (var kvp in angleStatistics.OrderBy(s => s.Key))

{

int angle = kvp.Key; // This is the mapped 0-180 angle

AngleStats stats = kvp.Value;

string layerName = $"ANGLE_{angle-90}_COUNT_{stats.Count}";

layerName = layerName.Replace("-", "NEG");

if(layerName.Length > 31) layerName = layerName.Substring(0,31);

foreach (double timestampMs in stats.Timestamps)

{

sw.WriteLine("0\nPOINT"); // Using POINT entity instead of CIRCLE for simplicity

sw.WriteLine("8\n" + layerName); // Layer name

// For POINT, color is usually BYLAYER (62 group code on LAYER table)

// Or can be specified here if needed: sw.WriteLine("62\n" + dxfColor);

sw.WriteLine("10\n" + timestampMs.ToString("F3")); // X coordinate (Timestamp)

sw.WriteLine("20\n" + (angle - 90.0).ToString("F3")); // Y coordinate (Original -90 to +90 angle)

sw.WriteLine("30\n0.0"); // Z coordinate

}

sw.WriteLine("0\nENDSEC\n0\nEOF");

}

Console.WriteLine($"DXF file saved to: {outputDxfPath}");

}

catch (Exception ex) { Console.WriteLine($"Error generating DXF: {ex.Message}"); }

}

private static List<ZeroCrossingSegment> AnalyzeZeroCrossings(float[] monoSamples, uint sourceRate)

{

Console.WriteLine("Performing zero-crossing analysis...");

List<ZeroCrossingSegment> segments = new List<ZeroCrossingSegment>();

if (monoSamples.Length < 2) return segments;

double msPerSample = 1000.0 / sourceRate;

int lastZeroCrossingSampleIndex = 0;

float segmentPeakAmplitude = 0f;

for (int i = 0; i < monoSamples.Length - 1; i++)

{

segmentPeakAmplitude = Math.Max(segmentPeakAmplitude, Math.Abs(monoSamples[i]));

bool crossedZero = (monoSamples[i] <= 0 && monoSamples[i + 1] > 0) ||

(monoSamples[i] >= 0 && monoSamples[i + 1] < 0);

if (crossedZero || i == monoSamples.Length - 2)

{

int currentSegmentEndIndex = crossedZero ? (i + 1) : monoSamples.Length;

segments.Add(new ZeroCrossingSegment

{

StartTimeMs = lastZeroCrossingSampleIndex * msPerSample,

EndTimeMs = currentSegmentEndIndex * msPerSample,

SampleCount = currentSegmentEndIndex - lastZeroCrossingSampleIndex,

PeakAmplitude = segmentPeakAmplitude

});

lastZeroCrossingSampleIndex = currentSegmentEndIndex;

segmentPeakAmplitude = 0f;

}

Console.WriteLine($"Zero-crossing analysis completed. {segments.Count} segments found.");

return segments;

}

private static void SaveAnalysisText(string filePath, Dictionary<int, AngleStats> angleStatistics, List<ZeroCrossingSegment> zcSegments, uint sourceRate)

{

Console.WriteLine("Saving analysis text file...");

StringBuilder sb = new StringBuilder();

sb.AppendLine($"Analysis Report for WAV file. Source Sample Rate: {sourceRate} Hz");

sb.AppendLine("\n--- Slope Angle Distribution (Original Angle: Count, P25_Time, P50_Time, P75_Time) ---");

foreach(var kvp in angleStatistics.OrderBy(s => s.Key)) // Iterate through mapped 0-180

{

AngleStats stats = kvp.Value;

// Display original angle (-90 to +90)

sb.AppendLine($"Angle {stats.AngleDegree-90}° (Mapped {stats.AngleDegree}): Count={stats.Count}, P25={stats.P25Timestamp:F2}ms, P50={stats.P50Timestamp:F2}ms, P75={stats.P75Timestamp:F2}ms");

}

sb.AppendLine("\n--- Zero-Crossing Segments (Top 20 by length) ---");

sb.AppendLine("Start (ms), End (ms), Duration (ms), Samples, Peak Amp");

foreach(var seg in zcSegments.OrderByDescending(s => s.SampleCount).Take(20))

{

sb.AppendLine($"{seg.StartTimeMs:F2}, {seg.EndTimeMs:F2}, {(seg.EndTimeMs - seg.StartTimeMs):F2}, {seg.SampleCount}, {seg.PeakAmplitude:F4}");

}

File.WriteAllText(filePath, sb.ToString());

Console.WriteLine($"Analysis text saved to: {filePath}");

}

#endregion

#region Shruti Variant Generation and Panning

public static void GenerateAndConcatenateShrutiVariations(string inputWavPath, string outputWavPath)

{

Console.WriteLine($"Reading input WAV for analysis: {inputWavPath}");

WavHeader inputHeader;

float[] monoInputSamples = ReadWavFile(inputWavPath, out inputHeader);

if (monoInputSamples == null || monoInputSamples.Length == 0) { Console.WriteLine("Failed to read input WAV file."); return; }

Console.WriteLine($"Input WAV: {inputHeader.SampleRate} Hz, {inputHeader.BitsPerSample}-bit, {(inputHeader.NumChannels == 1 ? "Mono" : "Stereo")}, Length: {monoInputSamples.Length} samples.");

Dictionary<int, AngleStats> angleStatistics;

Tuple<int, int> globalMinMaxAngleCounts;

List<SlopePoint> slopeData = AnalyzeSlopes(monoInputSamples, inputHeader.SampleRate, out angleStatistics, out globalMinMaxAngleCounts);

List<ZeroCrossingSegment> zcSegments = AnalyzeZeroCrossings(monoInputSamples, inputHeader.SampleRate);

string baseName = Path.Combine(Path.GetDirectoryName(inputWavPath), Path.GetFileNameWithoutExtension(inputWavPath));

GenerateSlopeAndAmplitudeBitmap(slopeData, monoInputSamples, inputHeader.SampleRate, angleStatistics, globalMinMaxAngleCounts, baseName + "_SlopeAmplitudeActivity.png");

SaveDxfWithLayersAndColors(angleStatistics, globalMinMaxAngleCounts, baseName + "_SlopeActivity.dxf");

SaveAnalysisText(baseName + "_AnalysisReport.txt", angleStatistics, zcSegments, inputHeader.SampleRate);

Console.WriteLine("\nStarting second scan: Generating shruti variants and applying panning...");

long totalStereoSamplesWritten = 0; // This counts L/R PAIRS

using (FileStream fs = new FileStream(outputWavPath, FileMode.Create))

using (BinaryWriter writer = new BinaryWriter(fs))

{

WriteWavHeaderPlaceholder(writer);

for (int shrutiOffset = -33; shrutiOffset <= 32; shrutiOffset++)

{

double pitchShiftFactor = Math.Pow(2.0, (double)shrutiOffset / 22.0);

Console.WriteLine($"Processing shruti offset: {shrutiOffset,3} (Factor: {pitchShiftFactor:F4})...");

float[] monoVariantSegment = ResampleToNewPitchAndRate(

monoInputSamples, (int)inputHeader.SampleRate, OutputGlobalSampleRate, pitchShiftFactor);

if (monoVariantSegment.Length > 0)

{

ApplyIntelligentDynamicPanningToStereo(writer, monoVariantSegment, slopeData, angleStatistics, globalMinMaxAngleCounts, pitchShiftFactor);

totalStereoSamplesWritten += monoVariantSegment.Length;

}

else { Console.WriteLine($"Warning: Generated empty mono segment for shruti offset {shrutiOffset}."); }

}

PatchWavHeader(writer, totalStereoSamplesWritten);

}

Console.WriteLine($"Total {66} shruti versions generated.");

Console.WriteLine($"Concatenated stereo output WAV: {outputWavPath} ({totalStereoSamplesWritten} stereo samples)");

Console.WriteLine("Processing complete.");

}

private static float[] ResampleToNewPitchAndRate(

float[] originalSamples, int originalSampleRate, int targetSampleRate, double pitchShiftFactor)

{

if (originalSamples == null || originalSamples.Length == 0 || pitchShiftFactor == 0) return new float[0];

double originalContentDurationSec = originalSamples.Length / (double)originalSampleRate;

double variantDurationSec = originalContentDurationSec / pitchShiftFactor;

int numOutputSamplesForVariant = (int)Math.Round(variantDurationSec * targetSampleRate);

if (numOutputSamplesForVariant <= 0) return new float[0];

float[] outputSamples = new float[numOutputSamplesForVariant];

double inputStep = pitchShiftFactor * ((double)originalSampleRate / targetSampleRate);

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

{

double currentOriginalIndexFloat = i * inputStep;

if (currentOriginalIndexFloat >= originalSamples.Length - 1) { outputSamples[i] = originalSamples[originalSamples.Length - 1]; }

else if (currentOriginalIndexFloat < 0) { outputSamples[i] = originalSamples[0]; }

else

{

int indexBefore = (int)Math.Floor(currentOriginalIndexFloat); int indexAfter = indexBefore + 1;

double fraction = currentOriginalIndexFloat - indexBefore;

outputSamples[i] = (float)(originalSamples[indexBefore] * (1.0 - fraction) + originalSamples[indexAfter] * fraction);

}

return outputSamples;

}

private static void ApplyIntelligentDynamicPanningToStereo(

BinaryWriter writer,

float[] monoSegment,

List<SlopePoint> originalSlopeData,

Dictionary<int, AngleStats> originalAngleStats,

Tuple<int,int> globalMinMaxAngleCounts,

double currentPitchShiftFactor)

{

if (monoSegment.Length == 0) return;

bool panToLeft = true;

int currentOriginalSlopeDataIndex = 0; // To efficiently find closest original slope point

for (int j = 0; j < monoSegment.Length; j++)

{

float currentMonoSample = monoSegment[j];

float panStrength = 0.5f; // Default: center (0.0 hard left, 0.5 center, 1.0 hard right)

// For L/R alternation, we'll interpret strength as deviation from center.

// Map current variant time back to original audio time

double variantTimeMs = j * (1000.0 / OutputGlobalSampleRate);

double originalEquivalentTimeMs = variantTimeMs * currentPitchShiftFactor; // This is key

// Find the closest original slope point by timestamp

// This is a simple search; for very large slopeData, a binary search or pre-indexed structure might be better.

while(currentOriginalSlopeDataIndex < originalSlopeData.Count - 1 &&

originalSlopeData[currentOriginalSlopeDataIndex+1].TimestampMs < originalEquivalentTimeMs)

{

currentOriginalSlopeDataIndex++;

}

int relevantOriginalAngle = 90; // Default to 0 degree slope (mapped to 90)

if(currentOriginalSlopeDataIndex < originalSlopeData.Count) {

// Check distance to current and next to find closest

if (originalSlopeData.Count > currentOriginalSlopeDataIndex + 1) {

double distToCurrent = Math.Abs(originalSlopeData[currentOriginalSlopeDataIndex].TimestampMs - originalEquivalentTimeMs);

double distToNext = Math.Abs(originalSlopeData[currentOriginalSlopeDataIndex+1].TimestampMs - originalEquivalentTimeMs);

if (distToNext < distToCurrent) {

relevantOriginalAngle = originalSlopeData[currentOriginalSlopeDataIndex+1].AngleDegrees;

} else {

relevantOriginalAngle = originalSlopeData[currentOriginalSlopeDataIndex].AngleDegrees;

}

} else {

relevantOriginalAngle = originalSlopeData[currentOriginalSlopeDataIndex].AngleDegrees;

}

float panFactor = 0.0f; // 0 = Center, -1 = Hard Left, 1 = Hard Right

if (originalAngleStats.TryGetValue(relevantOriginalAngle, out AngleStats stats) && globalMinMaxAngleCounts.Item2 > globalMinMaxAngleCounts.Item1)

{

// Normalize count: 0 (rarest) to 1 (most frequent)

double normalizedCount = (double)(stats.Count - globalMinMaxAngleCounts.Item1) / (globalMinMaxAngleCounts.Item2 - globalMinMaxAngleCounts.Item1);

normalizedCount = Math.Max(0, Math.Min(1, normalizedCount)); // Clamp

// Example: More frequent original angles get wider pan.

// panFactor will be from 0 (center for rarest) to 1 (full L/R for most frequent)

// This 'panFactor' determines the *deviation* from center.

// A higher normalizedCount means a more "significant" event, so pan it wider.

panFactor = (float)normalizedCount;

}

float leftOutputSample, rightOutputSample;

if (panToLeft)

{

// Pan left: Left channel gets more, right channel gets less

leftOutputSample = currentMonoSample; // Full strength

rightOutputSample = currentMonoSample * (1.0f - panFactor); // Attenuate based on significance

}

else // Pan Right

{

leftOutputSample = currentMonoSample * (1.0f - panFactor); // Attenuate

rightOutputSample = currentMonoSample; // Full strength

}

WriteStereoSampleData(writer, leftOutputSample, rightOutputSample);

// Zero-crossing detection within the current monoSegment to switch pan L/R

if (j < monoSegment.Length - 1)

{

bool crossedZero = (monoSegment[j] <= 0 && monoSegment[j + 1] > 0) ||

(monoSegment[j] >= 0 && monoSegment[j + 1] < 0);

if (crossedZero)

{

panToLeft = !panToLeft;

}

#endregion

public static void Main(string[] args)

{

Console.WriteLine("Multi-Scan Shruti Resampler (Statistics-Driven Panning & Visualization)");

Console.WriteLine("--------------------------------------------------------------------");

if (args.Length < 2)

{

Console.WriteLine("Usage: <ProgramName>.exe <input_wav_file> <output_wav_file>");

Console.WriteLine("Example: ShrutiApp.exe input.wav output_shrutis_stereo_analyzed.wav");

return;

}

string inputFilePath = args[0]; string outputFilePath = args[1];

if (!File.Exists(inputFilePath)) { Console.WriteLine($"Error: Input file not found: {inputFilePath}"); return; }

try { GenerateAndConcatenateShrutiVariations(inputFilePath, outputFilePath); }

catch (Exception ex) { Console.WriteLine($"An unexpected error occurred: {ex.Message}\n{ex.StackTrace}"); }

}

namespace SAAN_FRESH___RAW_NON_APIS_WAVES_TO_SHRUTIES_COPIER_GPTS

{

public class SwaralipiConcatenator_ResampleAware

{

public static void SwaralipiConcatenator___Main(string swaralipiFile)

{

int durationMs = 220;//default

string wavFolder = Path.GetDirectoryName(swaralipiFile);

int outputSampleRate = 8000;

string outputStereo = swaralipiFile + "_(yesssss)_merged_trimmed_RESAMPLED_8000_stereo.wav";

string outputMono = swaralipiFile + "_(yesssss)_merged_trimmed_RESAMPLED_8000_mono.wav";

var lines = File.ReadAllLines(swaralipiFile)

.Where(l => !string.IsNullOrWhiteSpace(l)).ToList();

var allSegments = new List<float>();

foreach (var line in lines)

{

var parts = line.Split(new[] { ' ', '\t', ',' }, StringSplitOptions.RemoveEmptyEntries);

if (parts.Length < 2) { durationMs = 220; continue; }

string symbol = parts[0].Trim()

.Replace(".", "_DOT_")

.Replace("-", "dash")

.Replace("#", "hash");

// if (!int.TryParse(parts[1], out int durationMs)) continue;

if (!int.TryParse(parts[1], out durationMs)) { continue; }

if(durationMs==0)

{

durationMs = 220;//default

}//if(durationMs==0)

string wavPath = Path.Combine(wavFolder, symbol + ".wav");

float[] originalSamples = ReadWavMonoAsFloats(wavPath, out int originalSampleRate);

// Step 1: Resample from originalSampleRate → outputSampleRate

float[] resampled = ResampleToRate(originalSamples, originalSampleRate, outputSampleRate);

// Step 2: Extract only as many samples as needed for desired duration

int neededSamples = (int)((durationMs / 1000.0) * outputSampleRate);

neededSamples = Math.Min(neededSamples, resampled.Length);

float[] trimmed = new float[neededSamples];

Array.Copy(resampled, trimmed, neededSamples);

allSegments.AddRange(trimmed);

}// foreach (var line in lines)

float[] final = allSegments.ToArray();

SaveWav(outputStereo, final, outputSampleRate, 2);

SaveWav(outputMono, final, outputSampleRate, 1);

Console.WriteLine("Done writing merged WAV with preserved pitches.");

System.Windows.Forms.MessageBox.Show("Done writing WAV:\n" + outputStereo + "\n" + outputMono);

}//public static void SwaralipiConcatenator___Main(string swaralipiFile)

public static float[] ResampleToRate(float[] input, int fromRate, int toRate)

{

if (fromRate == toRate) return input;

int newLength = (int)(input.Length * (toRate / (double)fromRate));

float[] result = new float[newLength];

Array.Clear(result, 0, result.Length);

double step = (double)(input.Length - 1) / (newLength - 1);

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

{

double idx = i * step;

int index = (int)idx;

double frac = idx - index;

float interpolated = ( (index + 1) < input.Length)

? (float)((1 - frac) * input[index] + frac * input[index + 1])

: input[index];

result[i] = interpolated;

}//for (int i = 0; i < newLength; i++)

return result;

}// public static float[] ResampleToRate(float[] input, int fromRate, int toRate)

static float[] ReadWavMonoAsFloats(string path, out int sampleRate)

{

using (BinaryReader br = new BinaryReader(File.OpenRead(path)))

{

string riff = new string(br.ReadChars(4));

br.ReadInt32();

string wave = new string(br.ReadChars(4));

int channels = 1;

sampleRate = 8000;

int bitsPerSample = 16;

while (true)

{

string chunkID = new string(br.ReadChars(4));

int chunkSize = br.ReadInt32();

if (chunkID == "fmt ")

{

br.ReadInt16(); // format

channels = br.ReadInt16();

sampleRate = br.ReadInt32();

br.ReadInt32();

br.ReadInt16();

bitsPerSample = br.ReadInt16();

if (chunkSize > 16) br.ReadBytes(chunkSize - 16);

break;

}

else br.ReadBytes(chunkSize);

}// while (true)

while (true)

{

string chunkID = new string(br.ReadChars(4));

int chunkSize = br.ReadInt32();

if (chunkID == "data")

{

int bytesPerSample = bitsPerSample / 8;

int totalSamples = chunkSize / bytesPerSample;

float[] samples = new float[totalSamples / channels];

for (int i = 0, j = 0; i < totalSamples; i++)

{

short s = br.ReadInt16();

if (channels == 1 || (i % channels == 0))

samples[j++] = s / 32768f;

if (channels == 2) br.ReadInt16(); // skip right

}// for (int i = 0, j = 0; i < totalSamples; i++)

return samples;

}

else br.ReadBytes(chunkSize);

}// while (true)

}// using (BinaryReader br = new BinaryReader(File.OpenRead(path)))

}//static float[] ReadWavMonoAsFloats(string path, out int sampleRate)

//need to try to implement this also

public static float[] ResampleWithPitchBend

(

float[] input, int fromRate, int toRate, int targetLength, double bendSemitones

)

{

float[] output = new float[targetLength];

// Compute shift range

double shiftStart = 1.0;

double shiftEnd = Math.Pow(2, bendSemitones / 12.0);

// Resample with time-varying rate

double inputPos = 0.0;

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

{

double t = i / (double)(targetLength - 1); // [0,1]

double currentShift = shiftStart + t * (shiftEnd - shiftStart);

double step = (fromRate * currentShift) / toRate;

int idx = (int)inputPos;

double frac = inputPos - idx;

float sample = 0;

if (idx + 1 < input.Length)

sample = (float)((1 - frac) * input[idx] + frac * input[idx + 1]);

else if (idx < input.Length)

sample = input[idx];

output[i] = sample;

inputPos += step;

if (inputPos >= input.Length - 1) break; // stop if overshoot

}//for (int i = 0; i < targetLength; i++)

return output;

}// public static float[] ResampleWithPitchBend

static void SaveWav(string path, float[] samples, int sampleRate, int channels)

{

int bitsPerSample = 16;

int byteRate = sampleRate * channels * bitsPerSample / 8;

int blockAlign = channels * bitsPerSample / 8;

int dataSize = samples.Length * channels * 2;

using (BinaryWriter bw = new BinaryWriter(File.Create(path)))

{

bw.Write(Encoding.ASCII.GetBytes("RIFF"));

bw.Write(36 + dataSize);

bw.Write(Encoding.ASCII.GetBytes("WAVE"));

bw.Write(Encoding.ASCII.GetBytes("fmt "));

bw.Write(16);

bw.Write((short)1);

bw.Write((short)channels);

bw.Write(sampleRate);

bw.Write(byteRate);

bw.Write((short)blockAlign);

bw.Write((short)bitsPerSample);

bw.Write(Encoding.ASCII.GetBytes("data"));

bw.Write(dataSize);

foreach (float sample in samples)

{

short s = (short)(sample * 32767);

for (int c = 0; c < channels; c++) bw.Write(s);

}//foreach (float sample in samples)

}// using (BinaryWriter bw = new BinaryWriter(File.Create(path)))

}// static void SaveWav(string path, float[] samples, int sampleRate, int channels)

}// public class SwaralipiConcatenator_ResampleAware

/// <summary>

/// ////////////////////////////////////////// the above resampler code looks like it is working properly

/// </summary>

public class SwaralipiConcatenator_DurationAware

{

public static void SwaralipiConcatenator___Main(string swaralipiFile)

{

string wavFolder = Path.GetDirectoryName(swaralipiFile);

string outputStereo = swaralipiFile + "_(durationwise)_NOT_GOOD_output_8000_stereo.wav"; ;// "_output_44100_stereo.wav";

string outputMono = swaralipiFile + "_(durationwise)_NOT_GOOD_output_8000_mono.wav";

var lines = File.ReadAllLines(swaralipiFile)

.Where(l => !string.IsNullOrWhiteSpace(l)).ToList();

var allSegments = new List<float>();

foreach (var line in lines)

{

int durationMs = 220;

var parts = line.Split(new[] { ' ', '\t', ',' }, StringSplitOptions.RemoveEmptyEntries);

if (parts.Length < 2) { durationMs = 220; continue; }

string symbol = parts[0].Trim();

// if (!int.TryParse(parts[1], out int durationMs)) continue;

if (!int.TryParse(parts[1], out durationMs)) continue;

symbol = symbol.Replace(".", "_DOT_").Replace("-", "dash").Replace("#", "hash");

//.Replace("#", "hash").Replace(".", "_DOT_");

string wavPath = Path.Combine(wavFolder, symbol + ".wav");

float[] fullSamples = { };

Array.Clear(fullSamples, 0, fullSamples.Length);

fullSamples = ReadWavMonoAsFloats(wavPath, out int sampleRate);

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

requiredSamples = Math.Min(requiredSamples, fullSamples.Length);

float[] trimmed = new float[requiredSamples];

Array.Copy(fullSamples, trimmed, requiredSamples);

allSegments.AddRange(trimmed);

}

float[] final = allSegments.ToArray();

SaveWav(outputStereo, final, 44100, 2);

SaveWav(outputStereo, final, 8000, 2);

SaveWav(outputMono, final, 8000, 1);

Console.WriteLine("WAVs written with trimmed durations.");

System.Windows.Forms.MessageBox.Show("Done writing WAVs with duration control:\n" + outputStereo + "\n" + outputMono);

}

static float[] ReadWavMonoAsFloats(string path, out int sampleRate)

{

using (BinaryReader br = new BinaryReader(File.OpenRead(path)))

{

string riff = new string(br.ReadChars(4));

br.ReadInt32();

string wave = new string(br.ReadChars(4));

int channels = 1;

sampleRate = 8000;// 44100;

int bitsPerSample = 16;

while (true)

{

string chunkID = new string(br.ReadChars(4));

int chunkSize = br.ReadInt32();

if (chunkID == "fmt ")

{

br.ReadInt16(); // format

channels = br.ReadInt16();

sampleRate = br.ReadInt32();

br.ReadInt32(); // byte rate

br.ReadInt16(); // block align

bitsPerSample = br.ReadInt16();

if (chunkSize > 16) br.ReadBytes(chunkSize - 16);

break;

}

else

{

br.ReadBytes(chunkSize);

}

while (true)

{

string chunkID = new string(br.ReadChars(4));

int chunkSize = br.ReadInt32();

if (chunkID == "data")

{

int bytesPerSample = bitsPerSample / 8;

int totalSamples = chunkSize / bytesPerSample;

float[] samples = { };

samples =

new float[totalSamples / channels];

Array.Clear(samples, 0, samples.Length);

for (int i = 0, j = 0; i < totalSamples; i++)

{

short sample = br.ReadInt16();

if (channels == 1 || (i % channels == 0))

samples[j++] = sample / 32768f;

if (channels == 2) br.ReadInt16(); // skip R

}

return samples;

}

else

{

br.ReadBytes(chunkSize);

}

static void SaveWav(string path, float[] samples, int sampleRate, int channels)

{

int bitsPerSample = 16;

int byteRate = sampleRate * channels * bitsPerSample / 8;

int blockAlign = channels * bitsPerSample / 8;

int dataSize = samples.Length * channels * 2;

using (BinaryWriter bw = new BinaryWriter(File.Create(path)))

{

bw.Write(Encoding.ASCII.GetBytes("RIFF"));

bw.Write(36 + dataSize);

bw.Write(Encoding.ASCII.GetBytes("WAVE"));

bw.Write(Encoding.ASCII.GetBytes("fmt "));

bw.Write(16);

bw.Write((short)1);

bw.Write((short)channels);

bw.Write(sampleRate);

bw.Write(byteRate);

bw.Write((short)blockAlign);

bw.Write((short)bitsPerSample);

bw.Write(Encoding.ASCII.GetBytes("data"));

bw.Write(dataSize);

foreach (float sample in samples)

{

short s = (short)(sample * 32767);

for (int c = 0; c < channels; c++)

{

bw.Write(s);

}//for (int c = 0; c < channels; c++)

}//foreach (float sample in samples)

}//using (BinaryWriter bw = new BinaryWriter(File.Create(path)))

}

/// <summary>

/// //////////////////////////////////////////////////////////////////////////////////////////////////

/// </summary>

public class SwaralipiConcatenator___all_same_durations

{

public static void SwaralipiConcatenator___Main(string swaralipifile)

{

string swaralipiFile = swaralipifile;// "swaralipi.txt"; // path to your text file

string wavFolder

//= string folderPath =

=Path.GetDirectoryName(swaralipifile); ;// "."; // directory containing all the 66 wavs

string outputStereo = swaralipiFile + "_all_sames_durs_NOT_GOOD_output_8000_stereo.wav";// "_output_44100_stereo.wav";

string outputMono = swaralipiFile + "_all_sames_durs_NOT_GOOD_output_8000_mono.wav";

var symbols = File.ReadAllLines(swaralipiFile).Where(l => !string.IsNullOrWhiteSpace(l)).ToList();

var allSamples = new List<float[]>();

int maxSamples = 0;

// Step 1: Load all WAVs and store sample data

foreach (var symbol in symbols)

{

// var parts = line.Split(new[] { ' ', '\t', ',' }, StringSplitOptions.RemoveEmptyEntries);

string[] splitted_durations_notes= symbol.Split(new[] { ' ', '\t', ',' }, StringSplitOptions.RemoveEmptyEntries);

// splitted_durations_notes

string newsymbol = splitted_durations_notes[0].Replace(".", "_DOT_").Replace("-", "dash").Replace("#", "hash");

// string wavPath = Path.Combine(wavFolder, $"{symbol}.wav");

string wavPath = "";

wavPath= Path.Combine(wavFolder, $"{newsymbol}.wav");

// List<float> samples = new List<float>();// null;

float[] samples = { };// new List<float>();// null;

//samples.Clear();

Array.Clear(samples, 0, samples.Length);

samples

ReadWavMonoAsFloats(wavPath, out int sourceRate);

if (samples.Length > maxSamples) maxSamples = samples.Length;

allSamples.Add(samples);

}//foreach (var symbol in symbols)

// Step 2: Resample all to maxSamples length

var normalized = allSamples.Select(s => StretchToLength(s, maxSamples)).ToList();

// Step 3: Concatenate all

var finalFloat = normalized.SelectMany(s => s).ToList();

// Step 4a: Save as 44100Hz stereo

// SaveWav(outputStereo+"_output_44100_stereo.wav", finalFloat.ToArray(), 44100, 2);

SaveWav(outputStereo + "_output_8000_stereo.wav", finalFloat.ToArray(), 8000, 2);

//SwaralipiConcatenator___all_same_durations

// Step 4b: Save as 8000Hz mono

SaveWav(outputMono+"_output_8000_mono.wav", finalFloat.ToArray(), 8000, 1);

Console.WriteLine("Done writing output WAVs.");

System.Windows.Forms.MessageBox.Show("Done writing output WAVs." + outputStereo +" " + outputMono);

}//public static void SwaralipiConcatenator___Main(string swaralipifile)

static float[] ReadWavMonoAsFloats(string path, out int sampleRate)

{

using (BinaryReader br = new BinaryReader(File.OpenRead(path)))

{

string riff = new string(br.ReadChars(4));

br.ReadInt32(); // file size

string wave = new string(br.ReadChars(4));

int channels = 1;

sampleRate = 8000;// 44100;

int bitsPerSample = 16;

// Read fmt chunk

while (true)

{

string chunkID = new string(br.ReadChars(4));

int chunkSize = br.ReadInt32();

if (chunkID == "fmt ")

{

br.ReadInt16(); // audio format

channels = br.ReadInt16();

sampleRate = br.ReadInt32();

br.ReadInt32(); // byte rate

br.ReadInt16(); // block align

bitsPerSample = br.ReadInt16();

if (chunkSize > 16) br.ReadBytes(chunkSize - 16);

break;

}

else

{

br.ReadBytes(chunkSize); // skip unknown chunk

}

// Read data chunk

while (true)

{

string chunkID = new string(br.ReadChars(4));

int chunkSize = br.ReadInt32();

if (chunkID == "data")

{

int bytesPerSample = bitsPerSample / 8;

int totalSamples = chunkSize / bytesPerSample;

float[] samples = new float[totalSamples / channels];

for (int i = 0, j = 0; i < totalSamples; i++)

{

short sample = br.ReadInt16();

if (channels == 1 || (i % channels == 0))

samples[j++] = sample / 32768f;

if (channels == 2) br.ReadInt16(); // skip right channel

}

return samples;

}

else

{

br.ReadBytes(chunkSize); // skip unknown chunk

}

} // using BinaryReader

}// static float[] ReadWavMonoAsFloats(string path, out int sampleRate)

static float[] StretchToLength(float[] original, int targetLength)

{

float[] result = new float[targetLength];

double step = (double)(original.Length - 1) / (targetLength - 1);

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

{

double index = i * step;

int idx = (int)index;

double frac = index - idx;

result[i] = (idx + 1 < original.Length)

? (float)((1 - frac) * original[idx] + frac * original[idx + 1])

: original[idx];

}

return result;

}//static float[] StretchToLength(float[] original, int targetLength)

static void SaveWav(string path, float[] samples, int sampleRate, int channels)

{

int bitsPerSample = 16;

int byteRate = sampleRate * channels * bitsPerSample / 8;

int blockAlign = channels * bitsPerSample / 8;

int dataSize = samples.Length * channels * 2;

using (BinaryWriter bw = new BinaryWriter(File.Create(path)))

{

// RIFF header

bw.Write(Encoding.ASCII.GetBytes("RIFF"));

bw.Write(36 + dataSize);

bw.Write(Encoding.ASCII.GetBytes("WAVE"));

// fmt chunk

bw.Write(Encoding.ASCII.GetBytes("fmt "));

bw.Write(16); // Subchunk1Size for PCM

bw.Write((short)1); // Audio format = PCM

bw.Write((short)channels);

bw.Write(sampleRate);

bw.Write(byteRate);

bw.Write((short)blockAlign);

bw.Write((short)bitsPerSample);

// data chunk

bw.Write(Encoding.ASCII.GetBytes("data"));

bw.Write(dataSize);

foreach (float sample in samples)

{

short s = (short)(sample * 32767);

for (int c = 0; c < channels; c++)

{

bw.Write(s);

}

} // end using

}//static void SaveWav(string path, float[] samples, int sampleRate, int channels)

}//public class SwaralipiConcatenator

public class WAVS_TO_MIDS_DYNAMIK_THRESHOLDS_YinPitchDetector___from_wav_files_8000_samples_per_seconds_16_bitsdepth_pcm_riff_files

{

const int SampleRate = 8000;

const int FrameSize = 1024;

const int StepSize = 512;

public static List<FrameStats> public_static___List_of___FrameStats__stats__pure_notes_nonzero_pitches = new List<FrameStats>();

public static List<FrameStats> public_static___List_of___CLUBBED_CONTIGUOUS_NOTES___DURATIONS_SUMMED___FrameStats__stats__pure_notes_nonzero_pitches = new List<FrameStats>();

public class FrameStats

{

public double TimeMs;

public double RMS;

public double MinCMND;

public double Frequency;

public double ThresholdUsed;

public int midsnotesnum;

public double durations_millis;

public int velocity;

public List<double> public_list_of_doubles_simples_durations_gaps_millis_for_for_pitchbends = new List<double>();

public List<int> public_list_of_ints_0_8192_16384_vals_for_pitchbends = new List<int>();

public List<double> public_list_of_percentages_of_doubles_simples_durations_gaps_0_to_100_for_for_pitchbends = new List<double>();

public string leftsideof_slash_in_indinotes_found = "";

public bool ALREADY_DONES_DURATIONS_CLUBBED_FOR_CONTINUOUS_SAMES_NOTES = false;

}//public class FrameStats

public static int FrequencyToMidiNote(double frequency)

{

if (frequency <= 0) return 0;

// return (int)Math.Round(69 + 12 * Math.Log(frequency / 440.0, 2));

int note_number_found_from_the_nearest_frequency_Hertz

SAANAUDS.PUBLIC_STATIC_CLASS_TO_GENERATE_CSVMIDI_LIKE_SAANDATA

// . PUBLIC_STATIC_STRING_ARRAY_FOR_SAAN_NOTES_MAPPER

// .public_static_global_list______ACCUMULATED_AFTER_ALL_DATA_READING_DONE___INSIDE___FUNCTION___SAAN_Log_tracks_channels_events_______BETTER_SCALES____STILL___NOT_GETTING_PROPER_PATCH_NUMBERS___SAAN_CLASS_FOR_MIDI_DATA_TO_LINE_SEGMENT_DATA_HOLDING

// .public_static_int_get_note_number_from_frequency_Hertz

.public_static_int_get_note_number_from_frequency_Hertz

(

frequency

);

return note_number_found_from_the_nearest_frequency_Hertz;

}// public static int FrequencyToMidiNote(double frequency)

public static void ToProcess_with___inPitchDetector___from_wav_files_8000_samples_per_seconds_16_bitsdepth_pcm_riff_files___Main(string wav_filename)

{

////string _returned_notes_number_string

//// =

////// SAANS_ROUGH_BEATS_COMPOSER_FOR_ON_SELECTIONS_LOOP_CYCLES

//////.PUBLIC_STATIC_CLASS_TO_PRELISTEN_HANDLING

//////.

//DO_POPULATE_INDIANIZED_NOTES___AND_RETURN_NOTENUMBER_FROM_THE_FILLED_NOTES_NAMES("");

var samples = ReadWavFile(wav_filename);

var frameStats = DetectPitchWithStats(samples);

string csvPath = wav_filename + "_dynamik_thresholds_YinPitchDetector___Deep_Stats___csv";

ExportDeepCsv(frameStats, csvPath);

Console.WriteLine("Pitch + Stats saved to: " + csvPath);

MessageBox.Show("Pitch + Stats saved to: " + csvPath);

}//public static void ToProcess_with___inPitchDetector___from_wav_files_8000_samples_per_seconds_16_bitsdepth_pcm_riff_files___Main(string wav_filename)

public static List<double> ReadWavFile(string filePath)

{

var samples = new List<double>();

using (var reader = new BinaryReader(File.OpenRead(filePath)))

{

reader.BaseStream.Seek(44, SeekOrigin.Begin);

while (reader.BaseStream.Position < reader.BaseStream.Length)

{

short s = reader.ReadInt16();

samples.Add(s / 32768.0);

}//while (reader.BaseStream.Position < reader.BaseStream.Length)

}//using (var reader = new BinaryReader(File.OpenRead(filePath)))

return samples;

}//public static List<double> ReadWavFile(string filePath)

public static List<FrameStats> DetectPitchWithStats(List<double> samples)

{

List<FrameStats> stats = new List<FrameStats>();

stats.Clear();

public_static___List_of___FrameStats__stats__pure_notes_nonzero_pitches.Clear();

public_static___List_of___CLUBBED_CONTIGUOUS_NOTES___DURATIONS_SUMMED___FrameStats__stats__pure_notes_nonzero_pitches.Clear();

for (int i = 0; i + FrameSize < samples.Count; i += StepSize)

{

double[] frame = samples.GetRange(i, FrameSize).ToArray();

double rms = Math.Sqrt(frame.Sum(x => x * x) / frame.Length);

double threshold = EstimateDynamicThreshold(rms);

double pitch = YinWithStats(frame, SampleRate, threshold, out double minCMND);

int notes_number = FrequencyToMidiNote(pitch);

//CALLING CONVENTIONS SAANS_ROUGH_BEATS_COMPOSER_FOR_ON_SELECTIONS_LOOP_CYCLES.PUBLIC_STATIC_CLASS_TO_PRELISTEN_HANDLING.___TEMP_STRING_INDIAN_NOTES_NAME___________PUBLIC_STATIC_STRING_FOR_GLOBAL_ACCESS

//CALLING CONVENTIONS SAANS_ROUGH_BEATS_COMPOSER_FOR_ON_SELECTIONS_LOOP_CYCLES.PUBLIC_STATIC_CLASS_TO_PRELISTEN_HANDLING.___TEMP_INT_INDIAN_NOTES_NUMBER___________PUBLIC_STATIC_INT_FOR_GLOBAL_ACCESS

/// THESE WILL GET FILLED SAANS_ROUGH_BEATS_COMPOSER_FOR_ON_SELECTIONS_LOOP_CYCLES.PUBLIC_STATIC_CLASS_TO_PRELISTEN_HANDLING.___TEMP_STRING_INDIAN_NOTES_NAME___________PUBLIC_STATIC_STRING_FOR_GLOBAL_ACCESS = ___TEMP_STRING_INDIAN_NOTES_NAME;

/// THESE WILL GET FILLED SAANS_ROUGH_BEATS_COMPOSER_FOR_ON_SELECTIONS_LOOP_CYCLES.PUBLIC_STATIC_CLASS_TO_PRELISTEN_HANDLING.___TEMP_INT_INDIAN_NOTES_NUMBER___________PUBLIC_STATIC_INT_FOR_GLOBAL_ACCESS = ___TEMP_INT_INDIAN_NOTES_NUMBER;

string ___TEMP_STRING_INDIAN_NOTES_NAME

= SAANS_ROUGH_BEATS_COMPOSER_FOR_ON_SELECTIONS_LOOP_CYCLES.PUBLIC_STATIC_CLASS_TO_PRELISTEN_HANDLING.___TEMP_STRING_INDIAN_NOTES_NAME___________PUBLIC_STATIC_STRING_FOR_GLOBAL_ACCESS;

int ___TEMP_INT_INDIAN_NOTES_NUMBER

= SAANS_ROUGH_BEATS_COMPOSER_FOR_ON_SELECTIONS_LOOP_CYCLES.PUBLIC_STATIC_CLASS_TO_PRELISTEN_HANDLING.___TEMP_INT_INDIAN_NOTES_NUMBER___________PUBLIC_STATIC_INT_FOR_GLOBAL_ACCESS;

string filled_notes_name = "";

string ___report_for_populations

SAANS_ROUGH_BEATS_COMPOSER_FOR_ON_SELECTIONS_LOOP_CYCLES

.PUBLIC_STATIC_CLASS_TO_PRELISTEN_HANDLING

.PUBLIC_STATIC_STRING___return_NOTES_NUMBER_STRING_FROM_PRECONFIGURED_KEY_NAMES_TO_NUMBER______FROM___PUBLIC_STATIC_STRING_ARRAY_FOR_36_NOTES___50_X_3

(___TEMP_STRING_INDIAN_NOTES_NAME, ___TEMP_INT_INDIAN_NOTES_NUMBER, notes_number.ToString());//saan has changed this code with notes number checking also includes

//////returned_note_number = ___report_for_populations;

string found_leftsidepart_of_indinote_slash =

SAANS_ROUGH_BEATS_COMPOSER_FOR_ON_SELECTIONS_LOOP_CYCLES

.PUBLIC_STATIC_CLASS_TO_PRELISTEN_HANDLING

PUBLIC_STATIC_STRING_GET_INDINOTESNAME_FIRST_OCCURANCES___from_____PUBLIC_STATIC_STRING_ARRAY_FOR_36_NOTES___50_X_3____FOR_GIVENS_MIDSNOTESNUMBER

(notes_number);

if (pitch > 0)

{

//to take care for the pitch>0 cases seperately

stats.Add

(new FrameStats

{

TimeMs = i * 1000.0 / SampleRate,

RMS = rms,

MinCMND = minCMND,

Frequency = pitch,

ThresholdUsed = threshold,

midsnotesnum = notes_number,

velocity = 127,

leftsideof_slash_in_indinotes_found = found_leftsidepart_of_indinote_slash

}

);

}else

{

try

{

stats.Last().velocity = 0;

/////////////////////////////////////////////////////////////////////////////////////

stats.Last()

.public_list_of_ints_0_8192_16384_vals_for_pitchbends

.Add

(

8192 + (int)((Math.Max(stats.Last().MinCMND, stats.Last().RMS)) * 16384)

);

stats.Last()

.public_list_of_doubles_simples_durations_gaps_millis_for_for_pitchbends

.Add

(

(i * 1000.0 / SampleRate) - (stats.Last().TimeMs)

);

}

catch (Exception ___excp_to_fill_pitchbends)

{

}//catch(Exception ___excp_to_fill_pitchbends)

}//end of else of if (pitch > 0)

if (pitch > 0)

{

public_static___List_of___FrameStats__stats__pure_notes_nonzero_pitches

.Add

(new FrameStats

{

TimeMs = i * 1000.0 / SampleRate,

RMS = rms,

MinCMND = minCMND,

Frequency = pitch,

ThresholdUsed = threshold,

midsnotesnum = notes_number,

velocity=127,

leftsideof_slash_in_indinotes_found = found_leftsidepart_of_indinote_slash

}

);

}// if(pitch > 0)

else

{

try

{

public_static___List_of___FrameStats__stats__pure_notes_nonzero_pitches

.Last()

.public_list_of_ints_0_8192_16384_vals_for_pitchbends

.Add

(

8192 + (int)((Math.Max(stats.Last().MinCMND, stats.Last().RMS)) * 16384)

);

public_static___List_of___FrameStats__stats__pure_notes_nonzero_pitches

.Last()

.public_list_of_doubles_simples_durations_gaps_millis_for_for_pitchbends

.Add

(

(i * 1000.0 / SampleRate) - (stats.Last().TimeMs)

);

}

catch (Exception ___excp_to_fill_pitchbends)

{

}//catch(Exception ___excp_to_fill_pitchbends)

}//end of else of if (pitch > 0)

}//for (int i = 0; i + FrameSize < samples.Count; i += StepSize)

//WE WILL NOW CLUB THE DURATIONS FOR CONTIGUOUS NOTES

//////public_static___List_of___FrameStats__stats__pure_notes_nonzero_pitches.Reverse();

//////for(int reversecrawler = 0; reversecrawler<public_static___List_of___FrameStats__stats__pure_notes_nonzero_pitches)

//////public_static___List_of___CLUBBED_CONTIGUOUS_NOTES___DURATIONS_SUMMED___FrameStats__stats__pure_notes_nonzero_pitches

////// //DOING THE REVERSING AGAIN TO KEEP THAT STRAIGHT

////// public_static___List_of___FrameStats__stats__pure_notes_nonzero_pitches.Reverse();

///

public_static___List_of___CLUBBED_CONTIGUOUS_NOTES___DURATIONS_SUMMED___FrameStats__stats__pure_notes_nonzero_pitches

Add

(public_static___List_of___FrameStats__stats__pure_notes_nonzero_pitches.First());

public_static___List_of___FrameStats__stats__pure_notes_nonzero_pitches.First()

.ALREADY_DONES_DURATIONS_CLUBBED_FOR_CONTINUOUS_SAMES_NOTES = true;

///////////////////////////////////////////////////////////////////////////////////////////////////////

for (int durations_clubbing_Crawler=1; durations_clubbing_Crawler< public_static___List_of___FrameStats__stats__pure_notes_nonzero_pitches.Count; durations_clubbing_Crawler++)

{

for(int lookforwardcrawler= durations_clubbing_Crawler+1; lookforwardcrawler< public_static___List_of___FrameStats__stats__pure_notes_nonzero_pitches.Count; lookforwardcrawler++)

{

(

( !

public_static___List_of___FrameStats__stats__pure_notes_nonzero_pitches

.ElementAt(lookforwardcrawler).ALREADY_DONES_DURATIONS_CLUBBED_FOR_CONTINUOUS_SAMES_NOTES

)

public_static___List_of___FrameStats__stats__pure_notes_nonzero_pitches

.ElementAt(lookforwardcrawler).midsnotesnum

public_static___List_of___CLUBBED_CONTIGUOUS_NOTES___DURATIONS_SUMMED___FrameStats__stats__pure_notes_nonzero_pitches

.Last().midsnotesnum

)

{

public_static___List_of___CLUBBED_CONTIGUOUS_NOTES___DURATIONS_SUMMED___FrameStats__stats__pure_notes_nonzero_pitches

.Last()

.durations_millis

public_static___List_of___CLUBBED_CONTIGUOUS_NOTES___DURATIONS_SUMMED___FrameStats__stats__pure_notes_nonzero_pitches

.Last()

.durations_millis

public_static___List_of___FrameStats__stats__pure_notes_nonzero_pitches

.ElementAt(lookforwardcrawler)

.durations_millis;

/////////////////////////////////////////////////////////////////////////////////////

public_static___List_of___FrameStats__stats__pure_notes_nonzero_pitches

.ElementAt(lookforwardcrawler)

.ALREADY_DONES_DURATIONS_CLUBBED_FOR_CONTINUOUS_SAMES_NOTES

= true;

}

else

{

public_static___List_of___CLUBBED_CONTIGUOUS_NOTES___DURATIONS_SUMMED___FrameStats__stats__pure_notes_nonzero_pitches

Add

(

public_static___List_of___FrameStats__stats__pure_notes_nonzero_pitches

.ElementAt(lookforwardcrawler)

);

///////////////////////////////////////////////////////////////////////////////////////////////

public_static___List_of___FrameStats__stats__pure_notes_nonzero_pitches

.ElementAt(lookforwardcrawler)

.ALREADY_DONES_DURATIONS_CLUBBED_FOR_CONTINUOUS_SAMES_NOTES

= true;

public_static___List_of___CLUBBED_CONTIGUOUS_NOTES___DURATIONS_SUMMED___FrameStats__stats__pure_notes_nonzero_pitches

.Last()

.TimeMs

public_static___List_of___FrameStats__stats__pure_notes_nonzero_pitches

.ElementAt(lookforwardcrawler)

.TimeMs;

durations_clubbing_Crawler = lookforwardcrawler;

// goto gotohere_since_new_notes_number_found;

}/////////////////////////////// else case completes

}//for(int lookforwardcrawler= durations_clubbing_Crawler; lookforwardcrawler< public_static___List_of___FrameStats__stats__pure_notes_nonzero_pitches.Count; lookforwardcrawler++)

gotohere_since_new_notes_number_found:;

}//for(int durations_clubbing_Crawler=0; durations_clubbing_Crawler< public_static___List_of___FrameStats__stats__pure_notes_nonzero_pitches.Count; durations_clubbing_Crawler++)

return stats;

}//public static List<FrameStats> DetectPitchWithStats(List<double> samples)

public static double EstimateDynamicThreshold(double rms)

{

if (rms < 0.02) return 0.30;

if (rms < 0.05) return 0.20;

return 0.10;

}//public static double EstimateDynamicThreshold(double rms)

public static double YinWithStats(double[] buffer, int sampleRate, double threshold, out double minCMND)

{

int tauMax = buffer.Length / 2;

double[] difference = new double[tauMax];

double[] cmnd = new double[tauMax];

for (int tau = 1; tau < tauMax; tau++)

{

double sum = 0;

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

{

double delta = buffer[i] - buffer[i + tau];

sum += delta * delta;

}//for (int i = 0; i < tauMax; i++)

difference[tau] = sum;

}//for (int tau = 1; tau < tauMax; tau++)

cmnd[0] = 1;

double runningSum = 0;

minCMND = 1.0;

for (int tau = 1; tau < tauMax; tau++)

{

runningSum += difference[tau];

cmnd[tau] = difference[tau] / ((runningSum / tau) + 1e-10);

if (cmnd[tau] < minCMND) minCMND = cmnd[tau];

}//for (int tau = 1; tau < tauMax; tau++)

int tauEstimate = -1;

for (int tau = 2; tau < tauMax; tau++)

{

if (cmnd[tau] < threshold)

{

while (tau + 1 < tauMax && cmnd[tau + 1] < cmnd[tau])

tau++;

tauEstimate = tau;

break;

}//if (cmnd[tau] < threshold)

}//for (int tau = 2; tau < tauMax; tau++)

if (tauEstimate != -1)

{

double betterTau = tauEstimate;

if (tauEstimate > 0 && tauEstimate < tauMax - 1)

{

double s0 = cmnd[tauEstimate - 1];

double s1 = cmnd[tauEstimate];

double s2 = cmnd[tauEstimate + 1];

betterTau = tauEstimate + (s2 - s0) / (2 * (2 * s1 - s2 - s0));

}//if (tauEstimate > 0 && tauEstimate < tauMax - 1)

return sampleRate / betterTau;

}//if (tauEstimate != -1)

return 0;

}// public static double YinWithStats(double[] buffer, int sampleRate, double threshold, out double minCMND)

public static void ExportDeepCsv(List<FrameStats> stats, string csvPath)

{

StringBuilder _strbldr = new StringBuilder();

_strbldr.Clear();

StringBuilder strbld______for_dot_dataGridView___COMPOSER = new StringBuilder();

strbld______for_dot_dataGridView___COMPOSER.Clear();

StringBuilder strbld______for_CLUBBED_DURATIONS___dot_dataGridView___COMPOSER = new StringBuilder();

strbld______for_CLUBBED_DURATIONS___dot_dataGridView___COMPOSER.Clear();

////// LYRSYLLS ###### INDINOTES ###### TRYS_NOTES_NOS ###### MILLISECOND ###### CURR_NOTES_VELOCITY ###### CURR_NOTES_PATCH ###### PERCENTAGES_DURATIONS_COMMASEPS_PTCHBNDS ###### WITHIN_NOTES_PTCHBENDS_VALUES ###### CHANNEL ###### TRACK ###### NOTES_NUMBERS ###### NOTES_FREQUENCYS ###### JERK_MILLIS_GAP ###### JERK_UP_PITCHBEND ###### JERK_DOWN_PITCH_BEND ###### FORCED_DECORATIONS_START_TIMES_MILLIS ###### START_MILLIS_PERCUSSIONS ###### START_MILLIS_FOR_PUREMELODYNOTES ###### REFERENCE_CUMULATIVE_START_MILLIS ###### PITCHBENDRANGE_2X2_DEFAULT ###### PAN_0_TO_127 ######

////// ###### S ###### 56 ###### 220 ###### 127 ###### ###### 0;100 ###### 8192;8192 ###### ###### ###### ###### ###### 30 ###### 30 ###### 30 ###### ###### ###### 220 ###### 220 ###### ###### ###### ROW_NUMBER=0

////// ###### r ###### 57 ###### 220 ###### 127 ###### ###### 0;100 ###### 8192;8192 ###### ###### ###### ###### ###### 30 ###### 30 ###### 30 ###### ###### ###### 440 ###### 440 ###### ###### ###### ROW_NUMBER=1

////// ###### g ###### 58 ###### 220 ###### 127 ###### ###### 0;100 ###### 8192;8192 ###### ###### ###### ###### ###### 30 ###### 30 ###### 30 ###### ###### ###### 660 ###### 660 ###### ###### ###### ROW_NUMBER=2

strbld______for_dot_dataGridView___COMPOSER

.AppendLine

(

"LYRSYLLS ###### INDINOTES ###### TRYS_NOTES_NOS ###### MILLISECOND ###### CURR_NOTES_VELOCITY ###### CURR_NOTES_PATCH ###### PERCENTAGES_DURATIONS_COMMASEPS_PTCHBNDS ###### WITHIN_NOTES_PTCHBENDS_VALUES ###### CHANNEL ###### TRACK ###### NOTES_NUMBERS ###### NOTES_FREQUENCYS ###### JERK_MILLIS_GAP ###### JERK_UP_PITCHBEND ###### JERK_DOWN_PITCH_BEND ###### FORCED_DECORATIONS_START_TIMES_MILLIS ###### START_MILLIS_PERCUSSIONS ###### START_MILLIS_FOR_PUREMELODYNOTES ###### REFERENCE_CUMULATIVE_START_MILLIS ###### PITCHBENDRANGE_2X2_DEFAULT ###### PAN_0_TO_127 ###### "

);

strbld______for_CLUBBED_DURATIONS___dot_dataGridView___COMPOSER

.AppendLine

(

);

using (var writer = new StreamWriter(csvPath))

{

// writer.WriteLine("Time (ms),Frequency (Hz),RMS,MinCMND,ThresholdUsed");

// writer.WriteLine($"{s.TimeMs:F2},{s.Frequency:F2},{s.midsnotesnum:F2},{ s.durations_millis:F2},{s.velocity:F2},{s.RMS:F4},{s.MinCMND:F4},{s.ThresholdUsed:F3}");

writer.WriteLine("Time (ms),Frequency (Hz),Midsnotes ,Indinotes, dursmillis , velocity , RMS,MinCMND,ThresholdUsed");

_strbldr.AppendLine("Time (ms),Frequency (Hz),Midsnotes ,IndiNotes, dursmillis , velocity , RMS,MinCMND,ThresholdUsed");

for (int rrr=0;rrr< (stats.Count-1);rrr++)

{

stats.ElementAt(rrr).durations_millis

(stats.ElementAt(rrr + 1).TimeMs

stats.ElementAt(rrr ).TimeMs

);

/////////////////////////////// to avoid divisions with zeros for pitch bends ///////////////////////////////////////////

stats.ElementAt(rrr).durations_millis = Math.Max(1, stats.ElementAt(rrr).durations_millis);

/////////////////////////////// to avoid divisions with zeros for pitch bends ///////////////////////////////////////////

// stats.ElementAt(rrr).midsnotesnum =

stats.ElementAt(rrr).velocity = 127;// (int)((stats.ElementAt(rrr).MinCMND) * 127); //(int)((stats.ElementAt(rrr).RMS) * 127);

try

{

//////////////////////////////////////////////////////////////////////

///

for (int countptchbnds=0; countptchbnds < stats.ElementAt(rrr).public_list_of_ints_0_8192_16384_vals_for_pitchbends.Count; countptchbnds++)

{

stats.ElementAt(rrr)

.public_list_of_percentages_of_doubles_simples_durations_gaps_0_to_100_for_for_pitchbends

Add

(

stats.ElementAt(rrr).public_list_of_ints_0_8192_16384_vals_for_pitchbends.ElementAt(countptchbnds)

stats.ElementAt(rrr).TimeMs

)

/ stats.ElementAt(rrr).durations_millis

)*100

);

}// for(int countptchbnds=0; countptchbnds < stats.ElementAt(rrr).public_list_of_ints_0_8192_16384_vals_for_pitchbends.Count; countptchbnds++)

}

catch (Exception ___excp_to_fill_pitchbends)

{

}//catch(Exception ___excp_to_fill_pitchbends)

}// for(int rrr=0;rrr< (stats.Count-1);rrr++)

for (int ggg = 0; ggg < (public_static___List_of___FrameStats__stats__pure_notes_nonzero_pitches.Count - 1); ggg++)

{

public_static___List_of___FrameStats__stats__pure_notes_nonzero_pitches.ElementAt(ggg).durations_millis

(public_static___List_of___FrameStats__stats__pure_notes_nonzero_pitches.ElementAt(ggg + 1).TimeMs

public_static___List_of___FrameStats__stats__pure_notes_nonzero_pitches.ElementAt(ggg).TimeMs

);

/////////////////////////////// to avoid divisions with zeros for pitch bends ///////////////////////////////////////////

public_static___List_of___FrameStats__stats__pure_notes_nonzero_pitches.ElementAt(ggg).durations_millis

= Math.Max(1, public_static___List_of___FrameStats__stats__pure_notes_nonzero_pitches.ElementAt(ggg).durations_millis);

/////////////////////////////// to avoid divisions with zeros for pitch bends ///////////////////////////////////////////

// public_static___List_of___FrameStats__stats__pure_notes_nonzero_pitches.ElementAt(ggg).midsnotesnum = midsnotesnum

public_static___List_of___FrameStats__stats__pure_notes_nonzero_pitches.ElementAt(ggg).velocity = 127;// (int)((public_static___List_of___FrameStats__stats__pure_notes_nonzero_pitches.ElementAt(ggg).MinCMND) * 127); //(int)((stats.ElementAt(rrr).RMS) * 127);

try

{

for (int countptchbnds = 0; countptchbnds < public_static___List_of___FrameStats__stats__pure_notes_nonzero_pitches.ElementAt(ggg).public_list_of_ints_0_8192_16384_vals_for_pitchbends.Count; countptchbnds++)

{

stats.ElementAt(ggg)

.public_list_of_percentages_of_doubles_simples_durations_gaps_0_to_100_for_for_pitchbends

Add

(

public_static___List_of___FrameStats__stats__pure_notes_nonzero_pitches

.ElementAt(ggg).public_list_of_ints_0_8192_16384_vals_for_pitchbends.ElementAt(countptchbnds)

public_static___List_of___FrameStats__stats__pure_notes_nonzero_pitches

.ElementAt(ggg).TimeMs

)

/ public_static___List_of___FrameStats__stats__pure_notes_nonzero_pitches

.ElementAt(ggg).durations_millis

)*100

);

}// for (int countptchbnds = 0; countptchbnds < public_static___List_of___FrameStats__stats__pure_notes_nonzero_pitches.ElementAt(ggg).public_list_of_ints_0_8192_16384_vals_for_pitchbends.Count; countptchbnds++)

}

catch (Exception ___excp_to_fill_pitchbends)

{

}//catch(Exception ___excp_to_fill_pitchbends)

}// for(int ggg=0;ggg< (public_static___List_of___FrameStats__stats__pure_notes_nonzero_pitches.Count-1);ggg++)

/////////////////////////////////////////////////////////////////////////////

foreach (var s in stats)

{

writer.WriteLine($"{s.TimeMs:F2},{s.Frequency:F2},{s.midsnotesnum:F2},{s.leftsideof_slash_in_indinotes_found},{ s.durations_millis:F2},{s.velocity:F2},{s.RMS:F4},{s.MinCMND:F4},{s.ThresholdUsed:F3}");

}//foreach (var s in stats)

string PERCENTAGES_DURATIONS_COMMASEPS_PTCHBNDS = "";

string WITHIN_NOTES_PTCHBENDS_VALUES = "";

string ___indinotefound___firstoccurances_before_slash

= "";

foreach (var s_mids in public_static___List_of___FrameStats__stats__pure_notes_nonzero_pitches)

{

_strbldr.AppendLine($"{s_mids.TimeMs:F2},{s_mids.Frequency:F2},{s_mids.midsnotesnum:F2},{s_mids.leftsideof_slash_in_indinotes_found},{ s_mids.durations_millis:F2},{s_mids.velocity:F2},{s_mids.RMS:F4},{s_mids.MinCMND:F4},{s_mids.ThresholdUsed:F3}");

//////___indinotefound___firstoccurances_before_slash

////// =

//////SAANS_ROUGH_BEATS_COMPOSER_FOR_ON_SELECTIONS_LOOP_CYCLES

////// .PUBLIC_STATIC_CLASS_TO_PRELISTEN_HANDLING

////// .

//////PUBLIC_STATIC_STRING_GET_INDINOTESNAME_FIRST_OCCURANCES___from_____PUBLIC_STATIC_STRING_ARRAY_FOR_36_NOTES___50_X_3____FOR_GIVENS_MIDSNOTESNUMBER

//////(s_mids.midsnotesnum);

if (s_mids.public_list_of_percentages_of_doubles_simples_durations_gaps_0_to_100_for_for_pitchbends.Count== s_mids.public_list_of_ints_0_8192_16384_vals_for_pitchbends.Count)

{

PERCENTAGES_DURATIONS_COMMASEPS_PTCHBNDS = "0";

WITHIN_NOTES_PTCHBENDS_VALUES = "8192";

foreach (double perc in s_mids.public_list_of_percentages_of_doubles_simples_durations_gaps_0_to_100_for_for_pitchbends)

{

PERCENTAGES_DURATIONS_COMMASEPS_PTCHBNDS

";"+ perc.ToString("F2");

}//foreach (double perc in s_mids.public_list_of_percentages_of_doubles_simples_durations_gaps_0_to_100_for_for_pitchbends)

foreach(int ptchbnd in s_mids.public_list_of_ints_0_8192_16384_vals_for_pitchbends)

{

WITHIN_NOTES_PTCHBENDS_VALUES

+ ";" + ((int)ptchbnd).ToString();

}//foreach(int ptchbnd in s_mids.public_list_of_ints_0_8192_16384_vals_for_pitchbends)

}//if(s_mids.public_list_of_percentages_of_doubles_simples_durations_gaps_0_to_100_for_for_pitchbends.Count== s_mids.public_list_of_ints_0_8192_16384_vals_for_pitchbends.Count)

else

{

PERCENTAGES_DURATIONS_COMMASEPS_PTCHBNDS = "0;100";

WITHIN_NOTES_PTCHBENDS_VALUES = "8192;8192";

}//filling the lists

///////////////////////////////////////////////////////////////////////////////////////////

strbld______for_dot_dataGridView___COMPOSER

.AppendLine

(

// "######"

// +

"LYRSYLLS "

+ " ###### "+

// INDINOTES

// ""

s_mids.leftsideof_slash_in_indinotes_found

+ " ###### " +

// TRYS_NOTES_NOS

s_mids.midsnotesnum

+ " ###### " +

// MILLISECOND

s_mids.durations_millis

+ " ###### " +

// CURR_NOTES_VELOCITY

+s_mids.velocity

+ " ###### " +

// CURR_NOTES_PATCH

"73"

+ " ###### " +

// PERCENTAGES_DURATIONS_COMMASEPS_PTCHBNDS

//"0;100"

PERCENTAGES_DURATIONS_COMMASEPS_PTCHBNDS

+ " ###### " +

// WITHIN_NOTES_PTCHBENDS_VALUES

//"8192;8192"

WITHIN_NOTES_PTCHBENDS_VALUES

+ " ###### " +

// CHANNEL

+ " ###### " +

// TRACK

+ " ###### " +

// NOTES_NUMBERS names

"to_fill"

+ " ###### " +

// NOTES_FREQUENCYS

s_mids.Frequency

+ " ###### " +

// JERK_MILLIS_GAP

+ " ###### " +

// JERK_UP_PITCHBEND

+ " ###### " +

// JERK_DOWN_PITCH_BEND

+ " ###### " +

// FORCED_DECORATIONS_START_TIMES_MILLIS

s_mids.TimeMs

+ " ###### " +

// START_MILLIS_PERCUSSIONS

s_mids.TimeMs

+ " ###### " +

// START_MILLIS_FOR_PUREMELODYNOTES

s_mids.TimeMs

+ " ###### " +

// REFERENCE_CUMULATIVE_START_MILLIS

+s_mids.TimeMs

+" ###### " +

// PITCHBENDRANGE_2X2_DEFAULT

"6"

+ " ###### " +

// PAN_0_TO_127

"64"

+ " ###### "

);

}// foreach (var s_mids in public_static___List_of___FrameStats__stats__pure_notes_nonzero_pitches)

}//using (var writer = new StreamWriter(csvPath))

/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

System.IO.File.WriteAllText

(

csvPath+"_midsnotesfromwavs.csvs_dat"

_strbldr.ToString()

);

/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

System.IO.File.WriteAllText

(

csvPath + "___combined_wavstomids.dataGridView___COMPOSER"

strbld______for_dot_dataGridView___COMPOSER.ToString()

);

/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

foreach (var s_CONTINUED in public_static___List_of___CLUBBED_CONTIGUOUS_NOTES___DURATIONS_SUMMED___FrameStats__stats__pure_notes_nonzero_pitches)

{

//outside the writer streams

string PERCENTAGES_DURATIONS_COMMASEPS_PTCHBNDS = "0";

string WITHIN_NOTES_PTCHBENDS_VALUES = "8192";

//_strbldr.AppendLine($"{s_mids.TimeMs:F2},{s_mids.Frequency:F2},{s_mids.midsnotesnum:F2},{s_mids.leftsideof_slash_in_indinotes_found},{ s_mids.durations_millis:F2},{s_mids.velocity:F2},{s_mids.RMS:F4},{s_mids.MinCMND:F4},{s_mids.ThresholdUsed:F3}");

//////___indinotefound___firstoccurances_before_slash

////// =

//////SAANS_ROUGH_BEATS_COMPOSER_FOR_ON_SELECTIONS_LOOP_CYCLES

////// .PUBLIC_STATIC_CLASS_TO_PRELISTEN_HANDLING

////// .

//////PUBLIC_STATIC_STRING_GET_INDINOTESNAME_FIRST_OCCURANCES___from_____PUBLIC_STATIC_STRING_ARRAY_FOR_36_NOTES___50_X_3____FOR_GIVENS_MIDSNOTESNUMBER

//////(s_mids.midsnotesnum);

if (s_CONTINUED.public_list_of_percentages_of_doubles_simples_durations_gaps_0_to_100_for_for_pitchbends.Count == s_CONTINUED.public_list_of_ints_0_8192_16384_vals_for_pitchbends.Count)

{

PERCENTAGES_DURATIONS_COMMASEPS_PTCHBNDS = "0";

WITHIN_NOTES_PTCHBENDS_VALUES = "8192";

foreach (double perc in s_CONTINUED.public_list_of_percentages_of_doubles_simples_durations_gaps_0_to_100_for_for_pitchbends)

{

PERCENTAGES_DURATIONS_COMMASEPS_PTCHBNDS

";" + perc.ToString("F2");

}//foreach (double perc in s_CONTINUED.public_list_of_percentages_of_doubles_simples_durations_gaps_0_to_100_for_for_pitchbends)

foreach (int ptchbnd in s_CONTINUED.public_list_of_ints_0_8192_16384_vals_for_pitchbends)

{

WITHIN_NOTES_PTCHBENDS_VALUES

+ ";" + ((int)ptchbnd).ToString();

}//foreach(int ptchbnd in s_CONTINUED.public_list_of_ints_0_8192_16384_vals_for_pitchbends)

}//if(s_CONTINUED.public_list_of_percentages_of_doubles_simples_durations_gaps_0_to_100_for_for_pitchbends.Count== s_CONTINUED.public_list_of_ints_0_8192_16384_vals_for_pitchbends.Count)

else

{

PERCENTAGES_DURATIONS_COMMASEPS_PTCHBNDS = "0;100";

WITHIN_NOTES_PTCHBENDS_VALUES = "8192;8192";

}//filling the lists

///////////////////////////////////////////////////////////////////////////////////////////

strbld______for_CLUBBED_DURATIONS___dot_dataGridView___COMPOSER

.AppendLine

(

// "######"

// +

"LYRSYLLS "

+ " ###### " +

// INDINOTES

// ""

s_CONTINUED.leftsideof_slash_in_indinotes_found

+ " ###### " +

// TRYS_NOTES_NOS

s_CONTINUED.midsnotesnum

+ " ###### " +

// MILLISECOND

s_CONTINUED.durations_millis

+ " ###### " +

// CURR_NOTES_VELOCITY

+s_CONTINUED.velocity

+ " ###### " +

// CURR_NOTES_PATCH

"73"

+ " ###### " +

// PERCENTAGES_DURATIONS_COMMASEPS_PTCHBNDS

//"0;100"

PERCENTAGES_DURATIONS_COMMASEPS_PTCHBNDS

+ " ###### " +

// WITHIN_NOTES_PTCHBENDS_VALUES

//"8192;8192"

WITHIN_NOTES_PTCHBENDS_VALUES

+ " ###### " +

// CHANNEL

+ " ###### " +

// TRACK

+ " ###### " +

// NOTES_NUMBERS names

"to_fill"

+ " ###### " +

// NOTES_FREQUENCYS

s_CONTINUED.Frequency

+ " ###### " +

// JERK_MILLIS_GAP

+ " ###### " +

// JERK_UP_PITCHBEND

+ " ###### " +

// JERK_DOWN_PITCH_BEND

+ " ###### " +

// FORCED_DECORATIONS_START_TIMES_MILLIS

s_CONTINUED.TimeMs

+ " ###### " +

// START_MILLIS_PERCUSSIONS

s_CONTINUED.TimeMs

+ " ###### " +

// START_MILLIS_FOR_PUREMELODYNOTES

s_CONTINUED.TimeMs

+ " ###### " +

// REFERENCE_CUMULATIVE_START_MILLIS

+s_CONTINUED.TimeMs

+ " ###### " +

// PITCHBENDRANGE_2X2_DEFAULT

"6"

+ " ###### " +

// PAN_0_TO_127

"64"

+ " ###### "

);

}// foreach (var s_CONTINUED in public_static___List_of___CLUBBED_CONTIGUOUS_NOTES___DURATIONS_SUMMED___FrameStats__stats__pure_notes_nonzero_pitches)

/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

System.IO.File.WriteAllText

(

csvPath + "___CLUBBED_DURATIONS_FOR_SAMES_NOTES_combined_wavstomids.dataGridView___COMPOSER"

strbld______for_CLUBBED_DURATIONS___dot_dataGridView___COMPOSER.ToString()

);

/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

}//public static void ExportDeepCsv(List<FrameStats> stats, string csvPath)

}//public class WAVS_TO_MIDS_DYNAMIK_THRESHOLDS_YinPitchDetector___from_wav_files_8000_samples_per_seconds_16_bitsdepth_pcm_riff_files

public class YinPitchDetector___from_wav_files_8000_samples_per_seconds_16_bitsdepth_pcm_riff_files

{

const int SampleRate = 8000;

const int FrameSize = 1024;

const int StepSize = 512;

const double Threshold = 0.15;

public static int FrequencyToMidiNote(double frequency)

{

if (frequency <= 0) return 0;

return (int)Math.Round(69 + 12 * Math.Log(frequency / 440.0, 2));

}

public static void ToProcess_with___inPitchDetector___from_wav_files_8000_samples_per_seconds_16_bitsdepth_pcm_riff_files___Main(string wav_filename)

{

string filePath = wav_filename;//"your_file.wav";

var samples = ReadWavFile(filePath);

var pitchTrack = DetectPitch(samples);

////Console.WriteLine("Time (ms) | Frequency (Hz)");

////for (int i = 0; i < pitchTrack.Count; i++)

////{

//// double timeMs = i * StepSize * 1000.0 / SampleRate;

//// Console.WriteLine($"{timeMs:F1}\t| {pitchTrack[i]:F2}");

////}//for (int i = 0; i < pitchTrack.Count; i++)

string csvPath = filePath + "_YinPitchDetector_pitch.times_freqs___csv";

using (var writer = new StreamWriter(csvPath))

{

writer.WriteLine("Time (ms),Frequency (Hz)");

for (int i = 0; i < pitchTrack.Count; i++)

{

double timeMs = i * StepSize * 1000.0 / SampleRate;

double frequency = pitchTrack[i];

writer.WriteLine($"{timeMs:F2},{frequency:F2}");

}//for (int i = 0; i < pitchTrack.Count; i++)

}//using (var writer = new StreamWriter(csvPath))

Console.WriteLine("Pitch data saved to: " + csvPath);

System.Windows.Forms.MessageBox.Show("Times Freqs_Pitch data saved to: " + csvPath);

}//public static void ToProcess_with___inPitchDetector___from_wav_files_8000_samples_per_seconds_16_bitsdepth+pcm_riff_files___Main(string wav_filename)

// Reads 16-bit PCM mono WAV

public static List<double> ReadWavFile(string filePath)

{

var samples = new List<double>();

using (var reader = new BinaryReader(File.OpenRead(filePath)))

{

// Skip header (44 bytes)

reader.BaseStream.Seek(44, SeekOrigin.Begin);

while (reader.BaseStream.Position < reader.BaseStream.Length)

{

short s = reader.ReadInt16();

samples.Add(s / 32768.0);

}//while (reader.BaseStream.Position < reader.BaseStream.Length)

}//using (var reader = new BinaryReader(File.OpenRead(filePath)))

return samples;

}//public static List<double> ReadWavFile(string filePath)

// Main YIN pitch detection

public static List<double> DetectPitch(List<double> samples)

{

var pitchList = new List<double>();

for (int i = 0; i + FrameSize < samples.Count; i += StepSize)

{

double[] frame = samples.GetRange(i, FrameSize).ToArray();

double pitch = Yin(frame, SampleRate, Threshold);

pitchList.Add(pitch);

}//for (int i = 0; i + FrameSize < samples.Count; i += StepSize)

return pitchList;

}//public static List<double> DetectPitch(List<double> samples)

// YIN algorithm implementation

public static double Yin(double[] buffer, int sampleRate, double threshold)

{

int tauMax = buffer.Length / 2;

double[] difference = new double[tauMax];

double[] cumulativeMeanNormalizedDifference = new double[tauMax];

// Step 1: Difference function

for (int tau = 1; tau < tauMax; tau++)

{

double sum = 0;

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

{

double delta = buffer[i] - buffer[i + tau];

sum += delta * delta;

}//for (int i = 0; i < tauMax; i++)

difference[tau] = sum;

}//for (int tau = 1; tau < tauMax; tau++)

// Step 2: Cumulative mean normalized difference

cumulativeMeanNormalizedDifference[0] = 1;

double runningSum = 0;

for (int tau = 1; tau < tauMax; tau++)

{

runningSum += difference[tau];

cumulativeMeanNormalizedDifference[tau] = difference[tau] / ((runningSum / tau) + 1e-10); // avoid divide by zero

}//for (int tau = 1; tau < tauMax; tau++)

// Step 3: Absolute threshold

int tauEstimate = -1;

for (int tau = 2; tau < tauMax; tau++)

{

if (cumulativeMeanNormalizedDifference[tau] < threshold)

{

while (tau + 1 < tauMax && cumulativeMeanNormalizedDifference[tau + 1] < cumulativeMeanNormalizedDifference[tau])

{

tau++;

}//while (tau + 1 < tauMax && cumulativeMeanNormalizedDifference[tau + 1] < cumulativeMeanNormalizedDifference[tau])

tauEstimate = tau;

break;

}//if (cumulativeMeanNormalizedDifference[tau] < threshold)

}//for (int tau = 2; tau < tauMax; tau++)

// Step 4: Parabolic interpolation

if (tauEstimate != -1)

{

double betterTau = tauEstimate;

if (tauEstimate > 0 && tauEstimate < tauMax - 1)

{

double s0 = cumulativeMeanNormalizedDifference[tauEstimate - 1];

double s1 = cumulativeMeanNormalizedDifference[tauEstimate];

double s2 = cumulativeMeanNormalizedDifference[tauEstimate + 1];

betterTau = tauEstimate + (s2 - s0) / (2 * (2 * s1 - s2 - s0));

}//if (tauEstimate > 0 && tauEstimate < tauMax - 1)

return sampleRate / betterTau;

}

else

{

return 0; // unvoiced or no pitch detected

}//end of else of if (tauEstimate != -1)

} // public static double Yin(double[] buffer, int sampleRate, double threshold)

}//YinPitchDetector___from_wav_files_8000_samples_per_seconds_16_bitsdepth_pcm_riff_files

/// <summary>

/// ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

/// </summary>

public class SAANS_NO_3RD_PARTY_GPT_STYLES_WAV_FILES_READER_TO_GENERATE_8000_HZ_16_BIT_PCMS_GTAMPS

{

//////public static void Write_SPLITTED_WavFile(string path, List<float> normalizedSamples, int sampleRate)

//////{

////// short bitsPerSample = 16;

////// short channels = 1;

////// int byteRate = sampleRate * channels * bitsPerSample / 8;

////// int dataSize = normalizedSamples.Count * 2;

////// using (var writer = new BinaryWriter(File.Create(path)))

////// {

////// writer.Write(Encoding.ASCII.GetBytes("RIFF"));

////// writer.Write(36 + dataSize);

////// writer.Write(Encoding.ASCII.GetBytes("WAVE"));

////// writer.Write(Encoding.ASCII.GetBytes("fmt "));

////// writer.Write(16);

////// writer.Write((short)1); // PCM

////// writer.Write((short)channels);

////// writer.Write(sampleRate);

////// writer.Write(byteRate);

////// writer.Write((short)(channels * bitsPerSample / 8));

////// writer.Write(bitsPerSample);

////// writer.Write(Encoding.ASCII.GetBytes("data"));

////// writer.Write(dataSize);

////// foreach (float sample in normalizedSamples)

////// writer.Write((short)(sample * 32767));

////// }//using (var writer = new BinaryWriter(File.Create(path)))

//////}//public static void Write_SPLITTED_WavFile(string path, List<float> normalizedSamples, int sampleRate)

public static void SplitWavByAmplitudePercentilewith_dynamik_thresholds(string wavPath)

{

string fileNameOnly = Path.GetFileNameWithoutExtension(wavPath);

string folder = Path.GetDirectoryName(wavPath);

short channels = 1;

int sampleRate = 8000;

short bitsPerSample = 16;

List<float> amplitudes = new List<float>();

// ---- Read WAV and extract normalized amplitudes ----

using (var reader = new BinaryReader(File.OpenRead(wavPath)))

{

if (new string(reader.ReadChars(4)) != "RIFF") throw new Exception("Invalid RIFF");

reader.ReadInt32(); // size

if (new string(reader.ReadChars(4)) != "WAVE") throw new Exception("Invalid WAVE");

while (reader.BaseStream.Position < reader.BaseStream.Length)

{

string chunkId = new string(reader.ReadChars(4));

int chunkSize = reader.ReadInt32();

if (chunkId == "fmt ")

{

reader.ReadInt16(); // audioFormat

channels = reader.ReadInt16();

sampleRate = reader.ReadInt32();

reader.ReadInt32(); // byteRate

reader.ReadInt16(); // blockAlign

bitsPerSample = reader.ReadInt16();

if (chunkSize > 16) reader.ReadBytes(chunkSize - 16);

}

else if (chunkId == "data")

{

int bytesPerSample = bitsPerSample / 8;

int totalSamples = chunkSize / bytesPerSample;

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

{

if (reader.BaseStream.Position + bytesPerSample > reader.BaseStream.Length)

break;

short sample = reader.ReadInt16();

float norm = sample / 32768f;

amplitudes.Add(norm);

if (channels == 2) reader.ReadInt16(); // skip right channel

}

break;

}

else reader.ReadBytes(chunkSize); // skip unknown

}

// ---- Calculate 20th percentile of absolute amplitudes ----

var absSorted = amplitudes.Select(Math.Abs).OrderBy(v => v).ToList();

float percentile20 = absSorted[(int)(absSorted.Count * 0.2)];

Console.WriteLine($"Using 20th Percentile Amplitude as Threshold: {percentile20:F6}");

// ---- Detect rising/falling threshold crossings ----

List<(int Start, int End)> regions = new List<(int, int)>();

bool inRegion = false;

int regionStart = 0;

int minSegmentSamples = 800; // ~100 ms

for (int i = 0; i < amplitudes.Count; i++)

{

float absAmp = Math.Abs(amplitudes[i]);

if (!inRegion && absAmp >= percentile20)

{

inRegion = true;

regionStart = i;

}

else if (inRegion && absAmp < percentile20)

{

int regionEnd = i;

if (regionEnd - regionStart >= minSegmentSamples)

regions.Add((regionStart, regionEnd));

inRegion = false;

}

// Handle edge case if region reaches file end

if (inRegion && amplitudes.Count - regionStart >= minSegmentSamples)

regions.Add((regionStart, amplitudes.Count - 1));

// ---- Save split WAVs ----

for (int i = 0; i < regions.Count; i++)

{

int start = regions[i].Start;

int end = regions[i].End;

var segment = amplitudes.GetRange(start, end - start);

string outputFile = Path.Combine(folder,

$"{fileNameOnly}_piece_{i + 1}_samples_{segment.Count}_ms_{(int)(segment.Count / (float)sampleRate * 1000)}.wav");

Write_SPLITTED_WavFile(outputFile, segment, sampleRate);

Console.WriteLine($"Saved: {outputFile}");

}

if (regions.Count == 0)

Console.WriteLine("No regions above the 20th percentile threshold were long enough to save.");

}//public static void SplitWavByAmplitudePercentilewith_dynamik_thresholds(string wavPath)

public static void SplitWavByRisingAbove20dBRegions(string wavPath)

{

string fileNameOnly = Path.GetFileNameWithoutExtension(wavPath);

string folder = Path.GetDirectoryName(wavPath);

short channels = 1;

int sampleRate = 8000;

short bitsPerSample = 16;

List<float> amplitudes = new List<float>();

// ---- Read WAV and extract normalized amplitudes ----

using (var reader = new BinaryReader(File.OpenRead(wavPath)))

{

// Read RIFF/WAVE

if (new string(reader.ReadChars(4)) != "RIFF") throw new Exception("Invalid RIFF");

reader.ReadInt32(); // size

if (new string(reader.ReadChars(4)) != "WAVE") throw new Exception("Invalid WAVE");

while (reader.BaseStream.Position < reader.BaseStream.Length)

{

string chunkId = new string(reader.ReadChars(4));

int chunkSize = reader.ReadInt32();

if (chunkId == "fmt ")

{

reader.ReadInt16(); // audioFormat

channels = reader.ReadInt16();

sampleRate = reader.ReadInt32();

reader.ReadInt32(); // byteRate

reader.ReadInt16(); // blockAlign

bitsPerSample = reader.ReadInt16();

if (chunkSize > 16) reader.ReadBytes(chunkSize - 16);

}

else if (chunkId == "data")

{

int bytesPerSample = bitsPerSample / 8;

int totalSamples = chunkSize / bytesPerSample;

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

{

if (reader.BaseStream.Position + bytesPerSample > reader.BaseStream.Length)

break;

short sample = reader.ReadInt16();

float norm = sample / 32768f;

amplitudes.Add(norm);

if (channels == 2) reader.ReadInt16(); // skip right

}

break;

}

else reader.ReadBytes(chunkSize);

}

// ---- SPLITTING BASED ON AMPLITUDE THRESHOLD ----

float threshold = 0.1f; // ~ -20 dB

bool inRegion = false;

int regionStart = 0;

int minSegmentSamples = 800; // = 100ms worth (8000Hz)

List<(int Start, int End)> regions = new List<(int, int)>();

for (int i = 0; i < amplitudes.Count; i++)

{

float absAmp = Math.Abs(amplitudes[i]);

if (!inRegion && absAmp >= threshold)

{

inRegion = true;

regionStart = i;

}

else if (inRegion && absAmp < threshold)

{

// End of region

int regionEnd = i;

if (regionEnd - regionStart >= minSegmentSamples)

regions.Add((regionStart, regionEnd));

inRegion = false;

}

}//for (int i = 0; i < amplitudes.Count; i++)

// Edge case: still in region at end

if (inRegion && amplitudes.Count - regionStart >= minSegmentSamples)

regions.Add((regionStart, amplitudes.Count - 1));

// ---- SAVE SPLIT WAVS ----

for (int i = 0; i < regions.Count; i++)

{

int start = regions[i].Start;

int end = regions[i].End;

var segment = amplitudes.GetRange(start, end - start);

string outputFile = Path.Combine(folder,

$"{fileNameOnly}_piece_{i + 1}_samples_{segment.Count}_ms_{(int)(segment.Count / (float)sampleRate * 1000)}.wav");

Write_SPLITTED_WavFile(outputFile, segment, sampleRate);

Console.WriteLine($"Saved: {outputFile}");

}//for (int i = 0; i < regions.Count; i++)

}//public static void SplitWavByRisingAbove20dBRegions(string wavPath)

public static void DISCARDING___THIS_GENERATES_LARGE_NUMBER_OF_SPLITTED_FILES______SplitWavByLocalMinimals_Of_Amplitudes(string wavPath)

{

string fileNameOnly = Path.GetFileNameWithoutExtension(wavPath);

string folder = Path.GetDirectoryName(wavPath);

short channels = 1;

int sampleRate = 8000;

short bitsPerSample = 16;

List<float> amplitudes = new List<float>();

// ---- Read WAV and extract normalized amplitudes ----

using (var reader = new BinaryReader(File.OpenRead(wavPath)))

{

// Validate RIFF and WAVE

if (new string(reader.ReadChars(4)) != "RIFF") throw new Exception("Invalid RIFF");

reader.ReadInt32(); // size

if (new string(reader.ReadChars(4)) != "WAVE") throw new Exception("Invalid WAVE");

while (reader.BaseStream.Position < reader.BaseStream.Length)

{

string chunkId = new string(reader.ReadChars(4));

int chunkSize = reader.ReadInt32();

if (chunkId == "fmt ")

{

reader.ReadInt16(); // audioFormat

channels = reader.ReadInt16();

sampleRate = reader.ReadInt32();

reader.ReadInt32(); // byteRate

reader.ReadInt16(); // blockAlign

bitsPerSample = reader.ReadInt16();

if (chunkSize > 16) reader.ReadBytes(chunkSize - 16);

}

else if (chunkId == "data")

{

int bytesPerSample = bitsPerSample / 8;

int totalSamples = chunkSize / bytesPerSample;

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

{

if (reader.BaseStream.Position + bytesPerSample > reader.BaseStream.Length)

break;

short sample = reader.ReadInt16();

float norm = sample / 32768f;

amplitudes.Add(norm);

if (channels == 2) reader.ReadInt16(); // skip right

}

break;

}

else reader.ReadBytes(chunkSize); // skip unknown chunk

}

// ---- Analyze: average and percentiles ----

float avgAmp = amplitudes.Average(a => Math.Abs(a));

float percentile20 = amplitudes.OrderBy(Math.Abs).ElementAt((int)(amplitudes.Count * 0.2f));

float percentile50 = amplitudes.OrderBy(Math.Abs).ElementAt((int)(amplitudes.Count * 0.5f));

Console.WriteLine($"Average Amplitude: {avgAmp:F4}");

Console.WriteLine($"20th Percentile: {percentile20:F4}, 50th Percentile: {percentile50:F4}");

// ---- Detect local minima ----

List<int> minimaIndexes = new List<int>();

for (int i = 1; i < amplitudes.Count - 1; i++)

{

if (Math.Abs(amplitudes[i]) < Math.Abs(amplitudes[i - 1]) &&

Math.Abs(amplitudes[i]) < Math.Abs(amplitudes[i + 1]))

{

if (Math.Abs(amplitudes[i]) < percentile20)

minimaIndexes.Add(i);

}

}//for (int i = 1; i < amplitudes.Count - 1; i++)

// ---- Extract segments between minima and save WAVs ----

for (int i = 0; i < minimaIndexes.Count - 1; i++)

{

int start = minimaIndexes[i];

int end = minimaIndexes[i + 1];

var segment = amplitudes.GetRange(start, end - start);

string outputFile = Path.Combine(folder,

$"{fileNameOnly}_piece_{i + 1}_samples_{segment.Count}_ms_{(int)(segment.Count / (float)sampleRate * 1000)}.wav");

Write_SPLITTED_WavFile(outputFile, segment, sampleRate);

Console.WriteLine($"Saved: {outputFile}");

}//for (int i = 0; i < minimaIndexes.Count - 1; i++)

}//public static void DISCARDING___THIS_GENERATES_LARGE_NUMBER_OF_SPLITTED_FILES______SplitWavByLocalMinimals_Of_Amplitudes(string wavPath)

public static void Write_SPLITTED_WavFile(string path, List<float> normalizedSamples, int sampleRate)

{

short bitsPerSample = 16;

short channels = 1;

int byteRate = sampleRate * channels * bitsPerSample / 8;

int dataSize = normalizedSamples.Count * 2;

using (var writer = new BinaryWriter(File.Create(path)))

{

// RIFF header

writer.Write(Encoding.ASCII.GetBytes("RIFF"));

writer.Write(36 + dataSize);

writer.Write(Encoding.ASCII.GetBytes("WAVE"));

// fmt chunk

writer.Write(Encoding.ASCII.GetBytes("fmt "));

writer.Write(16);

writer.Write((short)1); // PCM

writer.Write((short)channels);

writer.Write(sampleRate);

writer.Write(byteRate);

writer.Write((short)(channels * bitsPerSample / 8));

writer.Write(bitsPerSample);

// data chunk

writer.Write(Encoding.ASCII.GetBytes("data"));

writer.Write(dataSize);

foreach (float sample in normalizedSamples)

writer.Write((short)(sample * 32767));

}

}//public static void Write_SPLITTED_WavFile(string path, List<float> normalizedSamples, int sampleRate)

public static double PrintWavDurationAndSampleCount(string wavPath)

{

double durationMs = 0;

string ___report = "";

using (var reader = new BinaryReader(File.OpenRead(wavPath)))

{

// Skip RIFF header

reader.ReadChars(4);

reader.ReadInt32();

reader.ReadChars(4);

int sampleRate = 0;

short channels = 1;

short bitsPerSample = 16;

int dataSize = 0;

// Read chunks

while (reader.BaseStream.Position < reader.BaseStream.Length)

{

string chunkId = new string(reader.ReadChars(4));

int chunkSize = reader.ReadInt32();

if (chunkId == "fmt ")

{

short audioFormat = reader.ReadInt16();

channels = reader.ReadInt16();

sampleRate = reader.ReadInt32();

reader.ReadInt32(); // byteRate

reader.ReadInt16(); // blockAlign

bitsPerSample = reader.ReadInt16();

if (chunkSize > 16)

reader.ReadBytes(chunkSize - 16);

}

else if (chunkId == "data")

{

dataSize = chunkSize;

break;

}

else

{

reader.ReadBytes(chunkSize); // skip unknown chunk

}

}//while (reader.BaseStream.Position < reader.BaseStream.Length)

if (sampleRate == 0 || dataSize == 0)

{

Console.WriteLine("Failed to read sample rate or data size.");

return 0;

}//if (sampleRate == 0 || dataSize == 0)

int bytesPerSample = bitsPerSample / 8 * channels;

int totalSamples = dataSize / bytesPerSample;

durationMs = (totalSamples / (double)sampleRate) * 1000;

Console.WriteLine($"Sample Rate : {sampleRate} Hz");

Console.WriteLine($"Channels : {channels}");

Console.WriteLine($"Bits Per Sample : {bitsPerSample}");

Console.WriteLine($"Total Samples : {totalSamples}");

Console.WriteLine($"Total Duration : {durationMs:F2} ms");

___report= ___report + "\r\n"+ ($"Sample Rate : {sampleRate} Hz");

___report = ___report + "\r\n" + ($"Channels : {channels}");

___report = ___report + "\r\n" + ($"Bits Per Sample : {bitsPerSample}");

___report = ___report + "\r\n" + ($"Total Samples : {totalSamples}");

___report = ___report + "\r\n" + ($"Total Duration : {durationMs:F2} ms");

System.IO.File.WriteAllText(wavPath + "_reportfor_gtsmps.txt", ___report);

}//using (var reader = new BinaryReader(File.OpenRead(wavPath)))

return durationMs;

}//public static void PrintWavDurationAndSampleCount(string wavPath)

public static void ConvertWavToGTAMPS___with_corrections_GPT(string wavPath, string outputGtampsPath)

{

short channels = 1;

int sampleRate = 8000;

short bitsPerSample = 16;

using (var reader = new BinaryReader(File.OpenRead(wavPath)))

{

// 1. Read RIFF header

if (new string(reader.ReadChars(4)) != "RIFF")

throw new Exception("Not a valid RIFF file.");

reader.ReadInt32(); // File size

if (new string(reader.ReadChars(4)) != "WAVE")

throw new Exception("Not a valid WAVE file.");

// 2. Find 'fmt ' subchunk

channels = 1;

sampleRate = 8000;

bitsPerSample = 16;

while (true)

{

string chunkId = new string(reader.ReadChars(4));

int chunkSize = reader.ReadInt32();

if (chunkId == "fmt ")

{

short audioFormat = reader.ReadInt16();

channels = reader.ReadInt16();

sampleRate = reader.ReadInt32();

reader.ReadInt32(); // byteRate

reader.ReadInt16(); // blockAlign

bitsPerSample = reader.ReadInt16();

if (chunkSize > 16)

reader.ReadBytes(chunkSize - 16); // skip extra fmt bytes

break;

}

else

{

reader.ReadBytes(chunkSize); // skip unknown chunk

}

// 3. Find 'data' subchunk

while (true)

{

string chunkId = new string(reader.ReadChars(4));

int chunkSize = reader.ReadInt32();

if (chunkId == "data")

{

int bytesPerSample = bitsPerSample / 8;

int totalSamples = chunkSize / bytesPerSample;

var amplitudes = new List<float>();

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

{

if (reader.BaseStream.Position + bytesPerSample > reader.BaseStream.Length)

break;

short sample = reader.ReadInt16();

float norm = sample / 32768f;

amplitudes.Add(norm);

if (channels == 2)

reader.ReadInt16(); // skip right channel

}//for (int i = 0; i < totalSamples; i++)

// 4. Resample if needed

if (sampleRate != 8000)

{

var resampled = new List<float>();

double factor = sampleRate / 8000.0;

for (int i = 0; i < amplitudes.Count / factor; i++)

{

double idx = i * factor;

int i0 = (int)idx;

double frac = idx - i0;

float val = (i0 + 1 < amplitudes.Count)

? (float)((1 - frac) * amplitudes[i0] + frac * amplitudes[i0 + 1])

: amplitudes[i0];

resampled.Add(val);

}//for (int i = 0; i < amplitudes.Count / factor; i++)

amplitudes = resampled;

}//if (sampleRate != 8000)

// 5. Save GTAMPS

File.WriteAllLines(outputGtampsPath, amplitudes.Select(a => a.ToString("F8")));

Console.WriteLine($"Saved GTAMPS: {outputGtampsPath}");

System.Windows.Forms.MessageBox.Show($"Saved GTAMPS: {outputGtampsPath} amplitudes = {amplitudes.Count}");

// string outputGtampsPath_generated = wavPath + "_actual_sampleRate=" + sampleRate + "_actual_bps=" + bitsPerSample + "_numSamples=" + numSamples + "_smpls=" + samples + "_8000Hz_16_bits_pcms_" + ".GTAMPS";

//samples

// Save as .GTAMPS

// File.WriteAllLines(outputGtampsPath_generated, samples.Select(s => s.ToString("F8")));

return;

}

else

{

reader.ReadBytes(chunkSize); // skip unknown chunk

}

throw new Exception("Data chunk not found.");

}

}//public static void ConvertWavToGTAMPS___with_corrections_GPT(string wavPath, string outputGtampsPath)

////// public static void ConvertWavToGTAMPS___with_corrections_GPT(string wavPath, string outputGtampsPath)

////// {

////// using (var reader = new BinaryReader(File.OpenRead(wavPath)))

////// {

////// // 1. Read RIFF header

////// if (new string(reader.ReadChars(4)) != "RIFF")

////// throw new Exception("Not a valid RIFF file.");

////// reader.ReadInt32(); // File size

////// if (new string(reader.ReadChars(4)) != "WAVE")

////// throw new Exception("Not a valid WAVE file.");

////// // 2. Find 'fmt ' subchunk

////// short channels = 1;

////// int sampleRate = 8000;

////// short bitsPerSample = 16;

////// while (true)

////// {

////// string chunkId = new string(reader.ReadChars(4));

////// int chunkSize = reader.ReadInt32();

////// if (chunkId == "fmt ")

////// {

////// short audioFormat = reader.ReadInt16();

////// channels = reader.ReadInt16();

////// sampleRate = reader.ReadInt32();

////// reader.ReadInt32(); // byteRate

////// reader.ReadInt16(); // blockAlign

////// bitsPerSample = reader.ReadInt16();

////// if (chunkSize > 16)

////// reader.ReadBytes(chunkSize - 16); // skip extra fmt bytes

////// break;

////// }

////// else

////// {

////// reader.ReadBytes(chunkSize); // skip unknown chunk

////// }

////// // 3. Find 'data' subchunk

////// while (true)

////// {

////// string chunkId = new string(reader.ReadChars(4));

////// int chunkSize = reader.ReadInt32();

////// if (chunkId == "data")

////// {

////// int bytesPerSample = bitsPerSample / 8;

////// int totalSamples = chunkSize / bytesPerSample;

////// var amplitudes = new List<float>();

////// for (int i = 0; i < totalSamples; i++)

////// {

////// if (reader.BaseStream.Position + bytesPerSample > reader.BaseStream.Length)

////// { break; }

////// short sample = reader.ReadInt16();

////// float norm = sample / 32768f;

////// amplitudes.Add(norm);

////// if (channels == 2)

////// {

////// reader.ReadInt16(); // skip right channel}

////// }// for (int i = 0; i < totalSamples; i++)

////// // 4. Resample if needed

////// if (sampleRate != 8000)

////// {

////// var resampled = new List<float>();

////// double factor = sampleRate / 8000.0;

////// for (int rrr = 0; rrr < amplitudes.Count / factor; rrr++)

////// {

////// double idx = rrr * factor;

////// int i0 = (int)idx;

////// double frac = idx - i0;

////// float val = (i0 + 1 < amplitudes.Count)

////// ? (float)((1 - frac) * amplitudes[i0] + frac * amplitudes[i0 + 1])

////// : amplitudes[i0];

////// resampled.Add(val);

////// }//for (int rrr = 0; rrr < amplitudes.Count / factor; rrr++)

////// amplitudes = resampled;

////// }//if (sampleRate != 8000)

////// // 5. Save GTAMPS

////// // File.WriteAllLines(outputGtampsPath, amplitudes.Select(a => a.ToString("F8")));

////// // Console.WriteLine($"Saved GTAMPS: {outputGtampsPath}");

////// string outputGtampsPath_generated = wavPath + "_actual_sampleRate=" + sampleRate + "_actual_bps=" + bitsPerSample + "_numSamples=" + numSamples + "_smpls=" + samples + "_8000Hz_16_bits_pcms_" + ".GTAMPS";

////// //samples

////// // Save as .GTAMPS

////// File.WriteAllLines(outputGtampsPath_generated, samples.Select(s => s.ToString("F8")));

////// return;

////// }

////// else

////// {

////// reader.ReadBytes(chunkSize); // skip unknown chunk

////// }

////// throw new Exception("Data chunk not found.");

////// }

////// }//public static void ConvertWavToGTAMPS___with_corrections_GPT(string wavPath, string outputGtampsPath)

////// public static void ConvertANY_KIND_OF_WavToGTAMPS(string wavPath, string outputGtampsPath)

////// {

////// using (var reader = new BinaryReader(File.OpenRead(wavPath)))

////// {

////// // Read RIFF header

////// string riff = new string(reader.ReadChars(4));

////// int fileSize = reader.ReadInt32();

////// string wave = new string(reader.ReadChars(4));

////// // Read format chunk

////// string fmt = new string(reader.ReadChars(4));

////// int fmtSize = reader.ReadInt32();

////// short audioFormat = reader.ReadInt16();

////// short channels = reader.ReadInt16();

////// int sampleRate = reader.ReadInt32();

////// int byteRate = reader.ReadInt32();

////// short blockAlign = reader.ReadInt16();

////// short bitsPerSample = reader.ReadInt16();

////// // Skip any extra bytes if fmt chunk > 16

////// if (fmtSize > 16)

////// { reader.ReadBytes(fmtSize - 16); }

////// // Seek to data chunk

////// while (new string(reader.ReadChars(4)) != "data")

////// {

////// reader.BaseStream.Position -= 3;

////// }//while (new string(reader.ReadChars(4)) != "data")

////// int dataSize = reader.ReadInt32();

////// int numSamples = dataSize / (bitsPerSample / 8);

////// var samples = new List<float>(numSamples);

////// for (int i = 0; i < numSamples; i++)

////// {

////// short sample16 = reader.ReadInt16();

////// float normalized = sample16 / 32768f;

////// samples.Add(normalized);

////// if (channels == 2) reader.ReadInt16(); // Skip second channel if stereo

////// }//for (int i = 0; i < numSamples; i++)

////// // Resample if needed (e.g., from 44100Hz to 8000Hz)

////// if (sampleRate != 8000)

////// {

////// var resampled = new List<float>();

////// double factor = sampleRate / 8000.0;

////// for (int i = 0; i < samples.Count / factor; i++)

////// {

////// double index = i * factor;

////// int idx = (int)index;

////// double frac = index - idx;

////// float sample = (idx + 1 < samples.Count)

////// ? (float)((1 - frac) * samples[idx] + frac * samples[idx + 1])

////// : samples[idx];

////// resampled.Add(sample);

////// }//for (int i = 0; i < samples.Count / factor; i++)

////// samples = resampled;

////// }//if (sampleRate != 8000)

////// string outputGtampsPath_generated= wavPath+ "_actual_sampleRate=" + sampleRate + "_actual_bps="+ bitsPerSample + "_numSamples=" + numSamples + "_smpls="+ samples+ "_8000Hz_16_bits_pcms_" + ".GTAMPS";

////// //samples

////// // Save as .GTAMPS

////// File.WriteAllLines(outputGtampsPath_generated, samples.Select(s => s.ToString("F8")));

////// // Console.WriteLine($"Saved GTAMPS to: {outputGtampsPath}");

////// System.Windows.Forms.MessageBox.Show($"Saved GTAMPS to: {outputGtampsPath}");

////// }//using (var reader = new BinaryReader(File.OpenRead(wavPath)))

////// }//public static void ConvertWavToGTAMPS(string wavPath, string outputGtampsPath)

}// public class SAANS_NO_3RD_PARTY_GPT_STYLES_WAV_FILES_READER_TO_GENERATE_8000_HZ_16_BIT_PCMS_GTAMPS

// this changes speed when frequencies changes

public class WavGenerator___44_SHRUTIS_BACKWARD_TO_FORWARDS_Reads_GTAMPS_MONO_8000_Hz_Samples_16_bits_no_3rd_party_apis

{

const int SampleRate = 8000;

const int BitsPerSample = 16;

const int Channels = 1;

const double Pi = Math.PI;

public static void SAANS___44_SAMPLES_WavGenerator___Reads_GTAMPS_MONO_8000_Hz_Samples_16_bits_no_3rd_party_apis___Main(string gtamps_filesnames)

{

string inputPath = gtamps_filesnames;// "your_file_path_here.txt";

// Read float samples

var samples = File.ReadLines(inputPath)

.Where(line => double.TryParse(line, out _))

.Select(double.Parse)

.ToList();

var allShifted = new List<short>();

for (int r = 1; r <= 22; r++)

{

double shiftFactor = Math.Pow(2, r / 22.0);

var shifted = ResampleWithFrequencyShift(samples, shiftFactor);

allShifted.AddRange(shifted);

}//for (int r = 1; r <= 22; r++)

for (int r = -22; r <= 0; r++)

{

double shiftFactor = Math.Pow(2, r / 22.0);

var shifted = ResampleWithFrequencyShift(samples, shiftFactor);

allShifted.AddRange(shifted);

}//for (int r = -22; r <= 0; r++)

string outputPath = inputPath + "___44_SCALES_8000hZ_16_BITS_PCMS_" + allShifted.Count.ToString() + "_output.wav";

WriteWavFile(outputPath, allShifted);

Console.WriteLine("WAV file written to: " + outputPath);

}//public static void SAANS___44_SAMPLES_WavGenerator___Reads_GTAMPS_MONO_8000_Hz_Samples_16_bits_no_3rd_party_apis___Main(STRING gtamps_filesnames)

public static List<short> ResampleWithFrequencyShift(List<double> samples, double shiftFactor)

{

int newLength = (int)(samples.Count / shiftFactor);

var shifted = new List<short>(newLength);

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

{

double srcIndex = i * shiftFactor;

int idx = (int)srcIndex;

double frac = srcIndex - idx;

double value = 0;

if (idx + 1 < samples.Count)

value = (1 - frac) * samples[idx] + frac * samples[idx + 1];

else if (idx < samples.Count)

value = samples[idx];

short pcmVal = (short)(value * short.MaxValue);

shifted.Add(pcmVal);

}//for (int i = 0; i < newLength; i++)

return shifted;

}//public static List<short> ResampleWithFrequencyShift(List<double> samples, double shiftFactor)

public static void WriteWavFile(string filePath, List<short> samples)

{

using (var stream = new FileStream(filePath, FileMode.Create))

using (var writer = new BinaryWriter(stream))

{

int byteRate = SampleRate * Channels * BitsPerSample / 8;

int dataSize = samples.Count * BitsPerSample / 8;

// RIFF header

writer.Write(Encoding.ASCII.GetBytes("RIFF"));

writer.Write(36 + dataSize);

writer.Write(Encoding.ASCII.GetBytes("WAVE"));

// fmt subchunk

writer.Write(Encoding.ASCII.GetBytes("fmt "));

writer.Write(16); // PCM

writer.Write((short)1); // AudioFormat = PCM

writer.Write((short)Channels);

writer.Write(SampleRate);

writer.Write(byteRate);

writer.Write((short)(Channels * BitsPerSample / 8));

writer.Write((short)BitsPerSample);

// data subchunk

writer.Write(Encoding.ASCII.GetBytes("data"));

writer.Write(dataSize);

foreach (short s in samples)

{ writer.Write(s); }

}//using (var writer = new BinaryWriter(stream))

}//public static void WriteWavFile(string filePath, List<short> samples)

}// public class WavGenerator___44_SHRUTIS_BACKWARD_TO_FORWARDS_Reads_GTAMPS_MONO_8000_Hz_Samples_16_bits_no_3rd_party_apis

public class WavGeneratorFixedDuration___with_resamplers

{

const int SampleRate = 8000;

const int BitsPerSample = 16;

const int Channels = 1;

public static void Process_WavGeneratorFixedDuration___with_resamplers(string inputFilePath)

{

var samples = File.ReadLines(inputFilePath)

.Where(line => double.TryParse(line, out _))

.Select(double.Parse)

.ToList();

int originalSampleCount = samples.Count;

var allShiftedSamples = new List<short>();

// Positive shrutis (r = 1 to 22)

for (int r = 1; r <= 22; r++)

{

double shiftFactor = Math.Pow(2, r / 22.0); // e.g., r=12 -> pitch up by ~1 semitone

var shifted = PitchShiftPreserveDuration(samples, shiftFactor, originalSampleCount);

allShiftedSamples.AddRange(shifted);

}// for (int r = 1; r <= 22; r++)

// Negative shrutis (r = -22 to 0)

for (int r = -22; r <= 0; r++)

{

double shiftFactor = Math.Pow(2, r / 22.0); // pitch down

var shifted = PitchShiftPreserveDuration(samples, shiftFactor, originalSampleCount);

allShiftedSamples.AddRange(shifted);

}// for (int r = -22; r <= 0; r++)

string outputPath = inputFilePath + "_(44_COPIES_PITCH_CHANGED_)RESAMPLER_USED_FixedDur_ShiftedPitches.wav";

WriteWavFile(outputPath, allShiftedSamples);

Console.WriteLine("WAV file written to: " + outputPath);

MessageBox.Show("WAV file written to: " + outputPath);

}// public static void Process_WavGeneratorFixedDuration___with_resamplers(string inputFilePath)

public static T Clamp<T>(T val, T min, T max) where T : IComparable<T>

{

if (val.CompareTo(min) < 0) return min;

if (val.CompareTo(max) > 0) return max;

return val;

}// public static T Clamp<T>(T val, T min, T max) where T : IComparable<T>

// Pitch shifts and resamples to preserve original duration

public static List<short> PitchShiftPreserveDuration(List<double> samples, double shiftFactor, int targetLength)

{

var output = new List<short>(targetLength);

double position = 0.0;

double step = shiftFactor;

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

{

int idx = (int)position;

double frac = position - idx;

double value = 0;

if (idx + 1 < samples.Count)

value = (1 - frac) * samples[idx] + frac * samples[idx + 1];

else if (idx < samples.Count)

value = samples[idx];

// Normalize and convert to 16-bit PCM

// short pcmVal = (short)(Math.Clamp(value, -1.0, 1.0) * short.MaxValue);

short pcmVal = (short)(Clamp(value, -1.0, 1.0) * short.MaxValue);

output.Add(pcmVal);

position += step;

if (position >= samples.Count - 1)

position = 0; // Loop if needed to fill up

}// for (int i = 0; i < targetLength; i++)

return output;

}// public static List<short> PitchShiftPreserveDuration(List<double> samples, double shiftFactor, int targetLength)

public static void WriteWavFile(string filePath, List<short> samples)

{

using (var stream = new FileStream(filePath, FileMode.Create))

{

using (var writer = new BinaryWriter(stream))

{

int byteRate = SampleRate * Channels * BitsPerSample / 8;

int dataSize = samples.Count * BitsPerSample / 8;

// RIFF Header

writer.Write(Encoding.ASCII.GetBytes("RIFF"));

writer.Write(36 + dataSize);

writer.Write(Encoding.ASCII.GetBytes("WAVE"));

// fmt chunk

writer.Write(Encoding.ASCII.GetBytes("fmt "));

writer.Write(16); // Subchunk1Size for PCM

writer.Write((short)1); // AudioFormat = PCM

writer.Write((short)Channels);

writer.Write(SampleRate);

writer.Write(byteRate);

writer.Write((short)(Channels * BitsPerSample / 8)); // BlockAlign

writer.Write((short)BitsPerSample);

// data chunk

writer.Write(Encoding.ASCII.GetBytes("data"));

writer.Write(dataSize);

foreach (short s in samples)

writer.Write(s);

}// using (var writer = new BinaryWriter(stream))

}// using (var stream = new FileStream(filePath, FileMode.Create))

}// public static void WriteWavFile(string filePath, List<short> samples)

}// public class WavGeneratorFixedDuration___with_resamplers

// this dont change speed when frequencies changes

public class WavGenerator___44_KEEPING_SHRUTIS_FIXED_DURATION

{

const int SampleRate = 8000;

const int BitsPerSample = 16;

const int Channels = 1;

public static void function_to___WavGenerator___44_KEEPING_SHRUTIS_FIXED_DURATION___Main(string gtampsFilePath)

{

var samples = File.ReadLines(gtampsFilePath)

.Where(line => double.TryParse(line, out _))

.Select(double.Parse)

.ToList();

int originalLength = samples.Count;

var allShifted = new List<short>();

// Positive shrutis

for (int r = 1; r <= 22; r++)

{

double shiftFactor = Math.Pow(2, r / 22.0);

var shifted = PitchShiftPreserveDuration(samples, shiftFactor, originalLength);

allShifted.AddRange(shifted);

}//for (int r = 1; r <= 22; r++)

// Negative shrutis

for (int r = -22; r <= 0; r++)

{

double shiftFactor = Math.Pow(2, r / 22.0);

var shifted = PitchShiftPreserveDuration(samples, shiftFactor, originalLength);

allShifted.AddRange(shifted);

}//for (int r = -22; r <= 0; r++)

string outputPath = gtampsFilePath + "(speed_intact)___44_FIXEDDUR_SCALES_8000Hz_16bit_" + allShifted.Count + "_output.wav";

// WriteWavFile(outputPath, allShifted);

WriteWavFile___another_keeping_speed_same(outputPath, allShifted);

Console.WriteLine("WAV file written to: " + outputPath);

System.Windows.Forms.MessageBox.Show("(Speeds intact)WAV file written to: " + outputPath);

}//public static void function_to___WavGenerator___44_KEEPING_SHRUTIS_FIXED_DURATION___Main(string gtampsFilePath)

// Shifts pitch and then stretches result back to original duration

//////public static List<short> PitchShiftPreserveDuration(List<double> samples, double shiftFactor, int targetLength)

//////{

////// // Step 1: Resample with frequency shift (changes duration)

////// int shiftedLength = (int)(samples.Count / shiftFactor);

////// var shifted = new List<double>(shiftedLength);

////// for (int i = 0; i < shiftedLength; i++)

////// {

////// double srcIndex = i * shiftFactor;

////// int idx = (int)srcIndex;

////// double frac = srcIndex - idx;

////// double value = 0;

////// if (idx + 1 < samples.Count)

////// { value = (1 - frac) * samples[idx] + frac * samples[idx + 1]; }

////// else if (idx < samples.Count)

////// { value = samples[idx]; }

////// shifted.Add(value);

////// }//for (int i = 0; i < shiftedLength; i++)

////// // Step 2: Time-stretch to match original length

////// var stretched = new List<short>(targetLength);

////// double step = (double)(shifted.Count - 1) / (targetLength - 1);

////// for (int i = 0; i < targetLength; i++)

////// {

////// double index = i * step;

////// int idx = (int)index;

////// double frac = index - idx;

////// double val = 0;

////// if (idx + 1 < shifted.Count)

////// { val = (1 - frac) * shifted[idx] + frac * shifted[idx + 1]; }

////// else if (idx < shifted.Count)

////// { val = shifted[idx]; }

////// short pcmVal = (short)(val * short.MaxValue);

////// stretched.Add(pcmVal);

////// }//for (int i = 0; i < targetLength; i++)

////// return stretched;

//////}//public static List<short> PitchShiftPreserveDuration(List<double> samples, double shiftFactor, int targetLength)

public static List<short> PitchShiftPreserveDuration(List<double> samples, double shiftFactor, int targetLength)

{

var output = new List<short>(targetLength);

double position = 0.0;

double positionStep = shiftFactor;

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

{

int idx = (int)position;

double frac = position - idx;

double value = 0;

if (idx + 1 < samples.Count)

value = (1 - frac) * samples[idx] + frac * samples[idx + 1];

else if (idx < samples.Count)

value = samples[idx];

short pcmVal = (short)(value * short.MaxValue);

output.Add(pcmVal);

position += positionStep;

if (position >= samples.Count - 1)

position = 0; // loop back if needed to keep filling output

}//for (int i = 0; i < targetLength; i++)

return output;

}// public static List<short> PitchShiftPreserveDuration(List<double> samples, double shiftFactor, int targetLength)

public static void WriteWavFile___another_keeping_speed_same(string filePath, List<short> samples)

{

using (var stream = new FileStream(filePath, FileMode.Create))

{

using (var writer = new BinaryWriter(stream))

{

int byteRate = SampleRate * Channels * BitsPerSample / 8;

int dataSize = samples.Count * BitsPerSample / 8;

// RIFF header

writer.Write(Encoding.ASCII.GetBytes("RIFF"));

writer.Write(36 + dataSize);

writer.Write(Encoding.ASCII.GetBytes("WAVE"));

// fmt chunk

writer.Write(Encoding.ASCII.GetBytes("fmt "));

writer.Write(16);

writer.Write((short)1); // PCM

writer.Write((short)Channels);

writer.Write(SampleRate);

writer.Write(byteRate);

writer.Write((short)(Channels * BitsPerSample / 8));

writer.Write((short)BitsPerSample);

// data chunk

writer.Write(Encoding.ASCII.GetBytes("data"));

writer.Write(dataSize);

foreach (short s in samples)

{ writer.Write(s); }

}//using (var writer = new BinaryWriter(stream))

}//using (var stream = new FileStream(filePath, FileMode.Create))

}//public static void WriteWavFile___another_keeping_speed_same(string filePath, List<short> samples)

}//public class WavGenerator___44_KEEPING_SHRUTIS_FIXED_DURATION

public class WavGenerator___44_KEEPING_DURATION_VARIABLE_SAMPLE_RATE

{

const int BaseSampleRate = 8000;

const int BitsPerSample = 16;

const int Channels = 1;

public static void function_to___WavGenerator___44_KEEPING_DURATION_VARIABLE_SAMPLE_RATE___Main(string gtampsFilePath)

{

var samples = File.ReadLines(gtampsFilePath)

.Where(line => double.TryParse(line, out _))

.Select(double.Parse)

.ToList();

int totalSamples = samples.Count;

for (int r = 1; r <= 22; r++)

{

double shiftFactor = Math.Pow(2, r / 22.0);

int newSampleRate = (int)(BaseSampleRate * shiftFactor);

string outputPath = gtampsFilePath + $"___shruti_up_{r}_samplerate_{newSampleRate}.wav";

WriteWavFile_WithCustomSampleRate(outputPath, samples, newSampleRate);

}//for (int r = 1; r <= 22; r++)

for (int r = -22; r <= 0; r++)

{

double shiftFactor = Math.Pow(2, r / 22.0);

int newSampleRate = (int)(BaseSampleRate * shiftFactor);

string outputPath = gtampsFilePath + $"___shruti_down_{Math.Abs(r)}_samplerate_{newSampleRate}.wav";

WriteWavFile_WithCustomSampleRate(outputPath, samples, newSampleRate);

}//for (int r = -22; r <= 0; r++)

Console.WriteLine("44 pitch-shifted files written with variable sample rates (durations preserved).");

System.Windows.Forms.MessageBox.Show("WAVs written: duration preserved, pitch changed, sample rates varied.");

}//public static void function_to___WavGenerator___44_KEEPING_DURATION_VARIABLE_SAMPLE_RATE___Main(string gtampsFilePath)

public static void WriteWavFile_WithCustomSampleRate(string filePath, List<double> samples, int sampleRate)

{

using (var stream = new FileStream(filePath, FileMode.Create))

{

using (var writer = new BinaryWriter(stream))

{

int byteRate = sampleRate * Channels * BitsPerSample / 8;

int dataSize = samples.Count * BitsPerSample / 8;

// RIFF header

writer.Write(Encoding.ASCII.GetBytes("RIFF"));

writer.Write(36 + dataSize);

writer.Write(Encoding.ASCII.GetBytes("WAVE"));

// fmt chunk

writer.Write(Encoding.ASCII.GetBytes("fmt "));

writer.Write(16);

writer.Write((short)1); // PCM

writer.Write((short)Channels);

writer.Write(sampleRate); // <-- variable sample rate here

writer.Write(byteRate);

writer.Write((short)(Channels * BitsPerSample / 8));

writer.Write((short)BitsPerSample);

// data chunk

writer.Write(Encoding.ASCII.GetBytes("data"));

writer.Write(dataSize);

foreach (double sample in samples)

{

short s = (short)(sample * short.MaxValue);

writer.Write(s);

}

}//using writer

}//using stream

}//public static void WriteWavFile_WithCustomSampleRate(...)

}//class WavGenerator___44_KEEPING_DURATION_VARIABLE_SAMPLE_RATE

/// <summary>

/// /////////////////////////////////////////////////////////////////////////////////////

/// </summary>

public class WavGenerator___12x3_ChromaticShrutis_From_SAA_GTAMPS

{

const int BaseSampleRate = 8000;

const int BitsPerSample = 16;

const int Channels = 1;

public static StringBuilder ___combined_all_gtamps = new StringBuilder();

public static void function_to___Generate_All_12x3_SemitoneNotes_From_SAA_GTAMPS(string gtampsFilePath)

{

___combined_all_gtamps.Clear();

var samples = File.ReadLines(gtampsFilePath)

.Where(line => double.TryParse(line, out _))

.Select(double.Parse)

.ToList();

// These 36 labels are expected exactly from your shruti table

string[] noteLabels = new string[]

{

".S", ".R", ".R#", ".G", ".G#", ".M", ".M#", ".P", ".D", ".D#", ".N", ".N#",

"S", "R", "R#", "G", "G#", "M", "M#", "P", "D", "D#", "N", "N#",

"S.", "R.", "R#.", "G.", "G#.", "M.", "M#.", "P.", "D.", "D#.", "N.", "N#.","dash"

};

for (int i = 0; i < noteLabels.Length; i++)

{

double semitoneShift = i - 12; // Make "S" (index 12) the base reference (0)

double shiftFactor = Math.Pow(2.0, semitoneShift / 12.0);

int newSampleRate = (int)(BaseSampleRate * shiftFactor);

string fileName = noteLabels[i].Replace("#", "hash").Replace(".", "_DOT_");

string outputPath = Path.Combine(Path.GetDirectoryName(gtampsFilePath), fileName + ".wav");

WriteWavFile_WithCustomSampleRate(outputPath, samples, newSampleRate, fileName);

}//for (int i = 0; i < noteLabels.Length; i++)

// Save the entire concatenated GTAMPS (optional master file)

File.WriteAllText(gtampsFilePath + "_36_notes_combined.gtamps", ___combined_all_gtamps.ToString());

Console.WriteLine("36 chromatic notes across 3 octaves generated.");

System.Windows.Forms.MessageBox.Show("36 chromatic WAVs written from Sa sample.");

}//public static void function_to___Generate_All_12x3_SemitoneNotes_From_SAA_GTAMPS(string gtampsFilePath)

public static void WriteWavFile_WithCustomSampleRate(string filePath, List<double> samples, int sampleRate, string noteLabel)

{

using (var stream = new FileStream(filePath, FileMode.Create))

using (var writer = new BinaryWriter(stream))

{

int byteRate = sampleRate * Channels * BitsPerSample / 8;

int dataSize = samples.Count * BitsPerSample / 8;

// RIFF header

writer.Write(Encoding.ASCII.GetBytes("RIFF"));

writer.Write(36 + dataSize);

writer.Write(Encoding.ASCII.GetBytes("WAVE"));

// fmt chunk

writer.Write(Encoding.ASCII.GetBytes("fmt "));

writer.Write(16);

writer.Write((short)1); // PCM

writer.Write((short)Channels);

writer.Write(sampleRate);

writer.Write(byteRate);

writer.Write((short)(Channels * BitsPerSample / 8));

writer.Write((short)BitsPerSample);

// data chunk

writer.Write(Encoding.ASCII.GetBytes("data"));

writer.Write(dataSize);

var sb = new StringBuilder();

foreach (double sample in samples)

{

short s = (short)(sample * short.MaxValue);

if(filePath.Contains("dash"))

{

writer.Write((short)0.0000001);

string textVal = "0.0000001";// s.ToString("F8");

sb.AppendLine(textVal);

___combined_all_gtamps.AppendLine(textVal);

}

else

{

writer.Write(s);

string textVal = s.ToString("F8");

sb.AppendLine(textVal);

___combined_all_gtamps.AppendLine(textVal);

}//end of else of if(filePath.Contains("dash"))

}//foreach (double sample in samples)

File.WriteAllText(filePath + ".gtamps", sb.ToString());

}//using (var writer = new BinaryWriter(stream))

} //public static void WriteWavFile_WithCustomSampleRate(string filePath, List<double> samples, int sampleRate, string noteLabel)

}//public class WavGenerator___12x3_ChromaticShrutis_From_SAA_GTAMPS

/// <summary>

/// //////////////////////////////////////////////////////////////////////////////

/// </summary>

public class WavGenerator___ShrutiLibrary_From_SAA_Sample

{

const int BaseSampleRate = 8000;

const int BitsPerSample = 16;

const int Channels = 1;

public static StringBuilder ___public_static_combined_for_88_shrutis_in_one_gtamps_stringBuilder = new StringBuilder();

public static void function_to___Generate_All_Shrutis_From_SAA_GTAMPS(string gtampsFilePath)

{

___public_static_combined_for_88_shrutis_in_one_gtamps_stringBuilder = new StringBuilder();

___public_static_combined_for_88_shrutis_in_one_gtamps_stringBuilder.Clear();

var samples = File.ReadLines(gtampsFilePath)

.Where(line => double.TryParse(line, out _))

.Select(double.Parse)

.ToList();

// All shruti names mapped to their shift positions (-22 to +22)

string[] shrutiNames = new string[]

{

"L_Re1", "L_Re2", "L_Ma2S", "L_Pa2", "M_Sa", "M_Re1", "M_Re2", "M_Re", "M_Ga1", "M_Ga2", "M_Ga",

"M_Ma", "M_Ma1", "M_Ma2", "M_Pa", "M_Dha1", "M_Dha2", "L_Re", "L_Ga1", "L_Ga2", "L_Ga", "L_Ma",

"L_Ma1", "L_Ma2", "L_Pa", "L_Dha1", "L_Dha2", "L_Dha", "L_Ni1", "L_Ni2", "L_Ni2", "L_Re2S",

"L_Ga2S", "M_Dha", "M_Ni1", "M_Ni2", "M_Ni", "M_Sa2", "M_Re2S", "M_Ga2S", "M_Ma2S", "M_Pa2",

"U_Sa", "U_Re1", "U_Re2", "U_Re", "L_Ma2S", "L_Pa2", "M_Sa", "M_Re1", "M_Re2", "M_Re", "M_Ga1",

"M_Ga2", "M_Ga", "M_Ma", "M_Ma1", "M_Ma2", "M_Pa", "M_Dha1", "M_Dha2", "L_Re", "L_Ga1", "L_Ga2",

"L_Ga", "L_Ma", "L_Ma1", "L_Ma2", "L_Pa", "L_Dha1", "U_Ga1", "U_Ga2", "U_Ga", "U_Ma", "U_Ma1",

"U_Ma2", "U_Pa", "U_Dha1", "U_Dha2", "U_Dha", "U_Ni1", "U_Ni2", "U_Ni", "U_Sa2", "U_Re2S",

"U_Ga2S", "U_Ma2S", "U_Pa2","dash"

};

int totalShrutis = shrutiNames.Length;

for (int r = 0; r < totalShrutis; r++)

{

int shrutiIndex = r - 22;

double shiftFactor = Math.Pow(2, shrutiIndex / 22.0);

int newSampleRate = (int)(BaseSampleRate * shiftFactor);

string fileName = shrutiNames[r];

//////string outputPath = Path.Combine(Path.GetDirectoryName(gtampsFilePath),

////// fileName + "_shruti.wav");

///

string outputPath = Path.Combine(Path.GetDirectoryName(gtampsFilePath),

fileName + ".wav");

WriteWavFile_WithCustomSampleRate(outputPath, samples, newSampleRate);

}//for (int r = 0; r < totalShrutis; r++)

System.IO.File.WriteAllText

(

gtampsFilePath+"_combined_88_shrutis.GTAMPS"

___public_static_combined_for_88_shrutis_in_one_gtamps_stringBuilder.ToString()

);

Console.WriteLine($"{totalShrutis} shruti files written using sample rate modulation.");

System.Windows.Forms.MessageBox.Show($"{totalShrutis} shruti WAVs written from SAA sample.");

}//public static void function_to___Generate_All_Shrutis_From_SAA_GTAMPS

public static void WriteWavFile_WithCustomSampleRate(string filePath, List<double> samples, int sampleRate)

{

using (var stream = new FileStream(filePath, FileMode.Create))

{

using (var writer = new BinaryWriter(stream))

{

int byteRate = sampleRate * Channels * BitsPerSample / 8;

int dataSize = samples.Count * BitsPerSample / 8;

// RIFF header

writer.Write(Encoding.ASCII.GetBytes("RIFF"));

writer.Write(36 + dataSize);

writer.Write(Encoding.ASCII.GetBytes("WAVE"));

// fmt chunk

writer.Write(Encoding.ASCII.GetBytes("fmt "));

writer.Write(16);

writer.Write((short)1); // PCM

writer.Write((short)Channels);

writer.Write(sampleRate);

writer.Write(byteRate);

writer.Write((short)(Channels * BitsPerSample / 8));

writer.Write((short)BitsPerSample);

// data chunk

writer.Write(Encoding.ASCII.GetBytes("data"));

writer.Write(dataSize);

StringBuilder ___temp_stringbuilder_for_current_shrutis_GTAMPS = new StringBuilder();

___temp_stringbuilder_for_current_shrutis_GTAMPS.Clear();

foreach (double sample in samples)

{

short s = (short)(sample * short.MaxValue);

if(filePath.Contains("dash"))

{

writer.Write((short)0.000001);

___public_static_combined_for_88_shrutis_in_one_gtamps_stringBuilder

.AppendLine("0.000001");

___temp_stringbuilder_for_current_shrutis_GTAMPS

.AppendLine("0.000001");

}

else

{

writer.Write(s);

___public_static_combined_for_88_shrutis_in_one_gtamps_stringBuilder

.AppendLine(s.ToString("F8"));

___temp_stringbuilder_for_current_shrutis_GTAMPS

.AppendLine(s.ToString("F8"));

}//endof else of if(filePath.Contains("dash"))

}//foreach (double sample in samples)

///////////////////////////////////////////////////////////////////////////////////////////

System.IO.File.WriteAllText

(

filePath + "_bytrts_" + byteRate+"_sps_"+ sampleRate+ "_dtsizes_"+ dataSize + "_samples_" + samples.Count + "_" + ".gtamps"

___temp_stringbuilder_for_current_shrutis_GTAMPS.ToString()

);

}// using (var writer = new BinaryWriter(stream))

}//using (var stream = new FileStream(filePath, FileMode.Create))

}//public static void WriteWavFile_WithCustomSampleRate

}//public class WavGenerator___ShrutiLibrary_From_SAA_Sample

//////public class WavGenerator___MultiPitch_SingleFile_FixedDurations

//////{

////// const int BaseSampleRate = 44100;// 8000; // can be increased for higher resolution

////// const int BitsPerSample = 16;

////// const int Channels = 1;

////// public static void function_to___ApplyPerRegionPitchShift_AND_SaveUnifiedWav(string gtampsFilePath, int numRegions)

////// {

////// var originalSamples = File.ReadLines(gtampsFilePath)

////// .Where(line => double.TryParse(line, out _))

////// .Select(double.Parse)

////// .ToList();

////// // Apply pitch shifts to each region

////// List<short> finalPcm = ApplyPerRegionPitchShift(originalSamples, numRegions);

////// // Save to single WAV

////// string outputPath = gtampsFilePath + $"CONCATENATED____{numRegions}_Regions_MultiPitch_FixedDuration_output.wav";

////// WriteWavFile___SingleFile_ConstantSampleRate(outputPath, finalPcm, BaseSampleRate);

////// Console.WriteLine("Unified WAV written with pitch-shifted segments (duration preserved).");

////// System.Windows.Forms.MessageBox.Show("Unified WAV written with pitch-shifted segments (duration preserved): " + outputPath);

////// }//public static void function_to___ApplyPerRegionPitchShift_AND_SaveUnifiedWav(...)

////// public static List<short> ApplyPerRegionPitchShift(List<double> original, int numRegions)

////// {

////// //////int totalSamples = original.Count;

////// //////int segmentLength = totalSamples / numRegions;

////// //////List<short> output = new List<short>();

////// int totalSamples = original.Count * numRegions;//SAAN CHANGES THIS SINCE I THINK IF I NEED 44 COPIES THEN THERE NEEDS 44 TIMES ORIGINAL DURATION IN CONCATENATED FILES PLAY TIMES

////// int segmentLength = totalSamples / numRegions;

////// List<short> output = new List<short>();// OBVIOUSLY IF I AM GENERATING N NUMBERS OF PITCH CHANGED COPIES THEN ATLEAST N NUMBER OF TIMES ORIGINAL SAMPLES COUNT TO REPEAT

////// Random rnd = new Random();//??? WHY IS THIS??????????

////// for (int region = 0; region < numRegions; region++)

////// {

////// var segment = original.Skip(region * segmentLength).Take(segmentLength).ToList();

////// // Choose a shift factor (shruti-style): use 2^(r/22.0), r from -22 to +22

////// int shrutiStep = -22 + (44 * region / numRegions); // evenly spaced across shruti scale

////// // ALL OF THESE COPIED REGIONS NEED SAME DURATION OF PLAY TIME AS ACTUAL totalSamples PLAY TIME FREQUENCIES ARE TO CHANGE

////// double shiftFactor = Math.Pow(2, shrutiStep / 22.0);

////// var regionPcm = PitchShift_PreserveDuration(segment, shiftFactor, segmentLength);

////// output.AddRange(regionPcm);

////// }

////// return output;

////// }//public static List<short> ApplyPerRegionPitchShift(List<double> original, int numRegions)

////// public static List<short> PitchShift_PreserveDuration(List<double> input, double shiftFactor, int outputLength)

////// {

////// var result = new List<short>(outputLength);

////// double pos = 0.0;

////// double posStep = shiftFactor;

////// for (int i = 0; i < outputLength; i++)

////// {

////// int idx = (int)pos;

////// double frac = pos - idx;

////// double value = 0;

////// if (idx + 1 < input.Count)

////// value = (1 - frac) * input[idx] + frac * input[idx + 1];

////// else if (idx < input.Count)

////// value = input[idx];

////// short pcmVal = (short)(value * short.MaxValue);

////// result.Add(pcmVal);

////// pos += posStep;

////// if (pos >= input.Count - 1)

////// pos = 0; // loop or clamp, depending on preference

////// }

////// return result;

////// }//public static List<short> PitchShift_PreserveDuration(...)

////// public static void WriteWavFile___SingleFile_ConstantSampleRate(string filePath, List<short> samples, int sampleRate)

////// {

////// using (var stream = new FileStream(filePath, FileMode.Create))

////// using (var writer = new BinaryWriter(stream))

////// {

////// int byteRate = sampleRate * Channels * BitsPerSample / 8;

////// int dataSize = samples.Count * BitsPerSample / 8;

////// // RIFF header

////// writer.Write(Encoding.ASCII.GetBytes("RIFF"));

////// writer.Write(36 + dataSize);

////// writer.Write(Encoding.ASCII.GetBytes("WAVE"));

////// // fmt chunk

////// writer.Write(Encoding.ASCII.GetBytes("fmt "));

////// writer.Write(16);

////// writer.Write((short)1); // PCM

////// writer.Write((short)Channels);

////// writer.Write(sampleRate);

////// writer.Write(byteRate);

////// writer.Write((short)(Channels * BitsPerSample / 8));

////// writer.Write((short)BitsPerSample);

////// // data chunk

////// writer.Write(Encoding.ASCII.GetBytes("data"));

////// writer.Write(dataSize);

////// foreach (short s in samples)

////// writer.Write(s);

////// }

////// }//public static void WriteWavFile___SingleFile_ConstantSampleRate(...)

//////}//class WavGenerator___MultiPitch_SingleFile_FixedDurations

//////public class WavGenerator___MultiPitch_SingleFile_FixedDurations

//////{

////// const int BaseSampleRate = 44100;

////// const int BitsPerSample = 16;

////// const int Channels = 1;

////// public static void function_to___ApplyPerRegionPitchShift_AND_SaveUnifiedWav(string gtampsFilePath, int numRegions)

////// {

////// var originalSamples = File.ReadLines(gtampsFilePath)

////// .Where(line => double.TryParse(line, out _))

////// .Select(double.Parse)

////// .ToList();

////// // Generate shifted versions

////// List<short> finalPcm = new List<short>();

////// for (int region = 0; region < numRegions; region++)

////// {

////// // Shruti step evenly from -22 to +22

////// int shrutiStep = -22 + (44 * region / numRegions);

////// double shiftFactor = Math.Pow(2, shrutiStep / 22.0);

////// var pitchShifted = ResamplePitchShift(originalSamples, shiftFactor);

////// // Now stretch/truncate pitch-shifted to same duration as original (i.e., same sample count)

////// var fixedDuration = StretchToLength(pitchShifted, originalSamples.Count);

////// finalPcm.AddRange(fixedDuration);

////// }

////// // Save to WAV

////// string outputPath = gtampsFilePath + $"__{numRegions}_Regions_MultiPitch_FIXED_T_Duration_output.wav";

////// WriteWavFile(outputPath, finalPcm, BaseSampleRate);

////// Console.WriteLine("Saved WAV: pitch-shifted regions, each fixed to original duration.");

////// System.Windows.Forms.MessageBox.Show("Output WAV: multi-pitch, all segments same duration.");

////// }

////// public static List<double> ResamplePitchShift(List<double> input, double shiftFactor)

////// {

////// int newLength = (int)(input.Count / shiftFactor);

////// List<double> result = new List<double>(newLength);

////// for (int i = 0; i < newLength; i++)

////// {

////// double srcIndex = i * shiftFactor;

////// int idx = (int)srcIndex;

////// double frac = srcIndex - idx;

////// double val = 0;

////// if (idx + 1 < input.Count)

////// val = (1 - frac) * input[idx] + frac * input[idx + 1];

////// else if (idx < input.Count)

////// val = input[idx];

////// result.Add(val);

////// }

////// return result;

////// }

////// public static List<short> StretchToLength(List<double> input, int targetLength)

////// {

////// List<short> output = new List<short>(targetLength);

////// double step = (double)(input.Count - 1) / (targetLength - 1);

////// for (int i = 0; i < targetLength; i++)

////// {

////// double srcIndex = i * step;

////// int idx = (int)srcIndex;

////// double frac = srcIndex - idx;

////// double val = 0;

////// if (idx + 1 < input.Count)

////// val = (1 - frac) * input[idx] + frac * input[idx + 1];

////// else if (idx < input.Count)

////// val = input[idx];

////// output.Add((short)(val * short.MaxValue));

////// }

////// return output;

////// }

////// public static void WriteWavFile(string filePath, List<short> samples, int sampleRate)

////// {

////// using (var stream = new FileStream(filePath, FileMode.Create))

////// using (var writer = new BinaryWriter(stream))

////// {

////// int byteRate = sampleRate * Channels * BitsPerSample / 8;

////// int dataSize = samples.Count * BitsPerSample / 8;

////// // RIFF header

////// writer.Write(Encoding.ASCII.GetBytes("RIFF"));

////// writer.Write(36 + dataSize);

////// writer.Write(Encoding.ASCII.GetBytes("WAVE"));

////// // fmt chunk

////// writer.Write(Encoding.ASCII.GetBytes("fmt "));

////// writer.Write(16);

////// writer.Write((short)1); // PCM

////// writer.Write((short)Channels);

////// writer.Write(sampleRate);

////// writer.Write(byteRate);

////// writer.Write((short)(Channels * BitsPerSample / 8));

////// writer.Write((short)BitsPerSample);

////// // data chunk

////// writer.Write(Encoding.ASCII.GetBytes("data"));

////// writer.Write(dataSize);

////// foreach (short s in samples)

////// writer.Write(s);

////// }

//////}//public class WavGenerator___MultiPitch_SingleFile_FixedDurations

public class WavGenerator___MultiPitch___IT_GENERATES_SAME_PITCH_COPIES_ONLY____SingleFile_FixedDurations

{

//WE CANNOT CHANGE THE SAMPLE RATE FROM THE ORIGINAL GTAMPS SAMPLE RATES

const int BaseSampleRate = 8000;//44100;//8000;// 16000;//8000;//44100; // or 8000, if desired

const int BitsPerSample = 16;

const int Channels = 1;

public static void function_to___ApplyPerRegionPitchShift_AND_SaveUnifiedWav(string gtampsFilePath, int numRegions)

{

var originalSamples = File.ReadLines(gtampsFilePath)

.Where(line => double.TryParse(line, out _))

.Select(double.Parse)

.ToList();

List<short> finalPcm = ApplyPerRegionPitchShift(originalSamples, numRegions);

// string outputPath = gtampsFilePath + $"___{numRegions}_Regions_MultiPitch_FIXED_T_Duration_output.wav";

string outputPath = gtampsFilePath + $"___{numRegions}_Regions_SAMEPitchCOPY_FIXED_T_Duration_output.wav";

WriteWavFile(outputPath, finalPcm, BaseSampleRate);

Console.WriteLine("Unified WAV written with pitch-shifted regions (duration preserved).");

System.Windows.Forms.MessageBox.Show("WAV with multiple pitches and fixed durations saved:\n" + outputPath);

}//public static void function_to___ApplyPerRegionPitchShift_AND_SaveUnifiedWav

public static List<short> ApplyPerRegionPitchShift(List<double> original, int numRegions)

{

// double segmentDurationSec = original.Count / (double)BaseSampleRate;

// double segmentDurationSec = (original.Count* numRegions) / (double)BaseSampleRate;

double segmentDurationSec = original.Count / (double)BaseSampleRate; //WHEN I DO THIS THEN ALL ARE PLAYING WITH SAME FREWQUENCY

List<short> output = new List<short>();

for (int region = 0; region < numRegions; region++)

{

//int shrutiStep = -22 + (44 * region / numRegions);

int shrutiStep = -(int)(numRegions/2) + (44 * region / numRegions);

double shiftFactor = Math.Pow(2, shrutiStep / 22.0);

var pitchShifted = ResamplePitchShift(original, shiftFactor);

int desiredSampleCount = (int)(segmentDurationSec * BaseSampleRate);

var adjusted = StretchToLength(pitchShifted, desiredSampleCount);

output.AddRange(adjusted);

}//for (int region = 0; region < numRegions; region++)

return output;

}//public static List<short> ApplyPerRegionPitchShift

public static List<double> ResamplePitchShift(List<double> input, double shiftFactor)

{

int newLength = (int)(input.Count / shiftFactor);

var result = new List<double>(newLength);

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

{

double srcIndex = i * shiftFactor;

int idx = (int)srcIndex;

double frac = srcIndex - idx;

double val = 0;

if (idx + 1 < input.Count)

val = (1 - frac) * input[idx] + frac * input[idx + 1];

else if (idx < input.Count)

val = input[idx];

result.Add(val);

}//for (int i = 0; i < newLength; i++)

return result;

}//public static List<double> ResamplePitchShift

public static List<short> StretchToLength(List<double> input, int targetLength)

{

var output = new List<short>(targetLength);

double step = (double)(input.Count - 1) / (targetLength - 1);

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

{

double srcIndex = i * step;

int idx = (int)srcIndex;

double frac = srcIndex - idx;

double val = 0;

if (idx + 1 < input.Count)

{

val = (1 - frac) * input[idx] + frac * input[idx + 1];

}

else if (idx < input.Count)

{

val = input[idx];

}

short pcm = (short)(val * short.MaxValue);

output.Add(pcm);

}

return output;

}//public static List<short> StretchToLength

public static void WriteWavFile(string filePath, List<short> samples, int sampleRate)

{

using (var stream = new FileStream(filePath, FileMode.Create))

using (var writer = new BinaryWriter(stream))

{

int byteRate = sampleRate * Channels * BitsPerSample / 8;

int dataSize = samples.Count * BitsPerSample / 8;

// RIFF header

writer.Write(Encoding.ASCII.GetBytes("RIFF"));

writer.Write(36 + dataSize);

writer.Write(Encoding.ASCII.GetBytes("WAVE"));

// fmt chunk

writer.Write(Encoding.ASCII.GetBytes("fmt "));

writer.Write(16);

writer.Write((short)1); // PCM

writer.Write((short)Channels);

writer.Write(sampleRate);

writer.Write(byteRate);

writer.Write((short)(Channels * BitsPerSample / 8));

writer.Write((short)BitsPerSample);

// data chunk

writer.Write(Encoding.ASCII.GetBytes("data"));

writer.Write(dataSize);

foreach (short s in samples)

writer.Write(s);

}

}//public static void WriteWavFile

}//public class WavGenerator___MultiPitch_SingleFile_FixedDurations

public class WavGenerator___Reads_GTAMPS_MONO_8000_Hz_Samples_16_bits_no_3rd_party_apis

{

const int SampleRate = 8000;

const int BitsPerSample = 16;

const int Channels = 1;

const double Pi = Math.PI;

public static void SAANS___WavGenerator___Reads_GTAMPS_MONO_8000_Hz_Samples_16_bits_no_3rd_party_apis___Main(string gtamps_filesnames)

{

string inputPath = gtamps_filesnames;// "your_file_path_here.txt";

// Read float samples

var samples = File.ReadLines(inputPath)

.Where(line => double.TryParse(line, out _))

.Select(double.Parse)

.ToList();

var allShifted = new List<short>();

for (int r = 1; r <= 22; r++)

{

double shiftFactor = Math.Pow(2, r / 22.0);

var shifted = ResampleWithFrequencyShift(samples, shiftFactor);

allShifted.AddRange(shifted);

}//for (int r = 1; r <= 22; r++)

string outputPath = inputPath + "___22_times_8000hZ_16_BITS_PCMS_"+allShifted.Count.ToString() + "_output.wav";

WriteWavFile(outputPath, allShifted);

Console.WriteLine("WAV file written to: " + outputPath);

}//public static void SAANS___WavGenerator___Reads_GTAMPS_MONO_8000_Hz_Samples_16_bits_no_3rd_party_apis___Main(STRING gtamps_filesnames)

public static List<short> ResampleWithFrequencyShift(List<double> samples, double shiftFactor)

{

int newLength = (int)(samples.Count / shiftFactor);

var shifted = new List<short>(newLength);

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

{

double srcIndex = i * shiftFactor;

int idx = (int)srcIndex;

double frac = srcIndex - idx;

double value = 0;

if (idx + 1 < samples.Count)

value = (1 - frac) * samples[idx] + frac * samples[idx + 1];

else if (idx < samples.Count)

value = samples[idx];

short pcmVal = (short)(value * short.MaxValue);

shifted.Add(pcmVal);

}//for (int i = 0; i < newLength; i++)

return shifted;

}//public static List<short> ResampleWithFrequencyShift(List<double> samples, double shiftFactor)

public static void WriteWavFile(string filePath, List<short> samples)

{

using (var stream = new FileStream(filePath, FileMode.Create))

using (var writer = new BinaryWriter(stream))

{

int byteRate = SampleRate * Channels * BitsPerSample / 8;

int dataSize = samples.Count * BitsPerSample / 8;

// RIFF header

writer.Write(Encoding.ASCII.GetBytes("RIFF"));

writer.Write(36 + dataSize);

writer.Write(Encoding.ASCII.GetBytes("WAVE"));

// fmt subchunk

writer.Write(Encoding.ASCII.GetBytes("fmt "));

writer.Write(16); // PCM

writer.Write((short)1); // AudioFormat = PCM

writer.Write((short)Channels);

writer.Write(SampleRate);

writer.Write(byteRate);

writer.Write((short)(Channels * BitsPerSample / 8));

writer.Write((short)BitsPerSample);

// data subchunk

writer.Write(Encoding.ASCII.GetBytes("data"));

writer.Write(dataSize);

foreach (short s in samples)

{ writer.Write(s); }

}//using (var writer = new BinaryWriter(stream))

}//public static void WriteWavFile(string filePath, List<short> samples)

}//public class WavGenerator___Reads_GTAMPS_MONO_8000_Hz_Samples_16_bits_no_3rd_party_apis

}//namespace SAAN_FRESH___RAW_NON_APIS_WAVES_TO_SHRUTIES_COPIER_GPTS

Excellent — your code is already strong, but here’s a precise enhancement for exact-duration, pitch-shifted resampling of one input into 66 shrutis, all packed in a single 8000Hz WAV file, using no third-party API and well-calculated resample factors.

🔧 GOAL

Given a sample of duration T ms, create 66 pitch-shifted copies that:

Cover 22 shrutis ↓ (lower), 22 base (no shift), 22 shrutis ↑ (higher)
Each copy plays for the same duration as original
Output is a single WAV at 8000 Hz with all 66 concatenated

✅ KEY CONCEPT — Sample Rate Shifting for Pitch

To pitch shift without changing duration, resample using:

ini

CopyEdit

resampleFactor = pow(2, semitoneShift / 12.0)

Then resample the input to simulate the pitch change, and trim or stretch to match the original time T.

✅ ENHANCED METHOD OUTLINE

Here’s a complete new function to add in your class:

csharp

CopyEdit

public static void GenerateShrutiVariants(string inputWavPath, string outputWavPath)

{

// Read source WAV

float[] sourceSamples = ReadWavMonoAsFloats(inputWavPath, out int sourceRate);

int outputRate = 8000;

double durationSec = sourceSamples.Length / (double)sourceRate;

int targetSamplesPerVariant = (int)(durationSec * outputRate);

List<float> all66 = new List<float>();

for (int i = -33; i <= 32; i++) // 66 shifts: -33 to +32

{

double semitoneShift = i * (1.0 / 3); // 22 shrutis = 1 octave = 12 semitones

double resampleFactor = Math.Pow(2, semitoneShift / 12.0);

int resampledLength = (int)(sourceSamples.Length / resampleFactor);

// Step 1: Resample to pitch-shift (no time correction yet)

float[] pitchShifted = ResampleWithFactor(sourceSamples, resampledLength);

// Step 2: Time-correct by stretching/compressing to match original duration

float[] durationMatched = StretchToLength(pitchShifted, targetSamplesPerVariant);

all66.AddRange(durationMatched);

}

SaveWav(outputWavPath, all66.ToArray(), outputRate, 1);

Console.WriteLine("All 66 shruti variants saved.");

MessageBox.Show("Done: 66 shruti pitch-shifted variants created.");

}

✅ SUPPORT FUNCTIONS

Pitch-based Resampler:

csharp

CopyEdit

public static float[] ResampleWithFactor(float[] input, int targetLength)

{

float[] result = new float[targetLength];

double step = (double)(input.Length - 1) / (targetLength - 1);

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

{

double pos = i * step;

int idx = (int)pos;

double frac = pos - idx;

result[i] = (idx + 1 < input.Length)

? (float)((1 - frac) * input[idx] + frac * input[idx + 1])

: input[idx];

}

return result;

}

Stretch (Time Correction):

csharp

CopyEdit

public static float[] StretchToLength(float[] input, int targetLength)

{

return ResampleWithFactor(input, targetLength); // same method, reused

}

📊 ALGORITHM SUMMARY

For each shruti index (-33 to +32):

Convert index to semitone fraction.
Calculate pitch shift factor using 2^(x/12).
Resample the waveform to alter pitch.
Adjust the output length to T ms at 8000 Hz using interpolation.

Concatenate all outputs into one array.
Write to single mono WAV at 8000 Hz.

✅ Output

One outputWavPath.wav
Format: Mono, 8000 Hz
Duration = 66 × T ms

❓To Proceed

Would you like me to integrate this logic directly into one of your existing SwaralipiConcatenator classes or create a new self-contained class file?

Okay, I can help you with that! This is an interesting audio processing task. We'll create a C# program that takes a WAV file, generates 66 pitch-shifted versions of it, each maintaining the original's perceived duration, and then concatenates them into a single output WAV file. The output will be mono, 16-bit, at an 8000 Hz sample rate.

The 66 versions will cover a range of pitches equivalent to -33 to +32 shrutis, assuming 22 shrutis per octave. This will span approximately 3 octaves.

Here's the plan:

WAV File Reading: We'll implement a utility to read the input WAV file. This utility will:

Parse the WAV header to get information like sample rate, bit depth, and number of channels.
Read the audio data.
Convert the audio data to a standardized mono floating-point format (samples ranging from -1.0 to 1.0). This makes processing consistent regardless of the input WAV's specifics.

Pitch Shifting with Duration Preservation: This is the core of the process. For each of the 66 shruti variations:

We'll calculate a pitchShiftFactor. A factor greater than 1.0 raises the pitch, and less than 1.0 lowers it. The formula Math.Pow(2.0, shrutiValue / 22.0) will be used, where shrutiValue ranges from -33 to +32.
The original duration of the input audio will be determined. Each pitch-shifted segment must have this same duration when played back.
A resampling algorithm will generate the audio samples for the current shruti-shifted version. This algorithm will:

Determine the number of output samples needed to match the original duration at the target 8000 Hz sample rate.
Iterate through each output sample. For each output sample, it will calculate the corresponding position to read from in the input audio data. This calculation involves the pitchShiftFactor and the ratio of input to output sample rates.
Use linear interpolation to calculate the sample value if the read position falls between two input samples. This is a common and computationally reasonable way to resample.
If the read position goes beyond the end of the input audio (which can happen when pitching up, as we read through the input faster), the input audio will be effectively "looped" to ensure the output segment is filled for its entire target duration. This addresses the "no truncation" requirement.

Concatenation: All 66 pitch-shifted audio segments (now in a float format) will be concatenated into one long list of samples.
WAV File Writing: Finally, a utility will write this concatenated list of samples to a new WAV file. This output file will be:

Mono.
8000 Hz sample rate.
16-bit depth.

I'll provide the C# code within an immersive document, with detailed explanations for each part.

C# Shruti Pitch Shifter

Jun 5, 12:24 AM

Try again without Canvas

Explanation of the Code:

WavUtils Class:

WavHeader Struct: Defines the structure of a standard WAV file header. This helps in parsing and understanding the input WAV file.
ReadWav Method:

Reads the entire WAV file into a byte array.
Uses a BinaryReader to parse the RIFF, "fmt ", and "data" chunks of the WAV header.
It supports reading 8-bit, 16-bit, 24-bit, and 32-bit (integer and float) PCM WAV files.
Converts the audio samples into a float[] array where each sample is normalized to the range [-1.0, 1.0].
If the input is stereo, it converts it to mono by averaging the left and right channels.
Returns the mono float samples and the parsed WavHeader.

WriteWav Method:

Takes a collection of float samples (which will be the concatenated, pitch-shifted audio).
Writes a standard WAV file header for a mono, 16-bit PCM file with the specified sampleRate (which will be 8000 Hz for the output).
Converts the float samples (clamped to [-1.0, 1.0]) back to 16-bit short integers.
Writes the sample data to the file.

ShrutiPitchProcessor Class:

Constants: OutputSampleRate (8000 Hz) and OutputBitsPerSample (16) define the output format.
CreateShrutiVariations Method:

This is the main orchestrator. It calls WavUtils.ReadWav to get the input audio data.
It calculates originalDurationSeconds from the input samples and their sample rate.
Then, it calculates targetSegmentLengthSamples, which is the number of samples each pitch-shifted segment needs to have to maintain the original duration at the OutputSampleRate of 8000 Hz.
It loops 66 times, for shrutiOffset from -33 to +32.

Inside the loop, pitchShiftFactor is calculated using Math.Pow(2.0, (double)shrutiOffset / 22.0). Here, 22.0 signifies 22 shrutis per octave. A shrutiOffset of -33 will result in the lowest frequency (about 1.5 octaves down), and +32 will result in the highest frequency (about 1.45 octaves up).
It calls ResampleAndShiftPitch for each shrutiOffset to get the pitch-shifted audio segment.
All generated segments are added to allShiftedAudioSamples.

Finally, it calls WavUtils.WriteWav to save the concatenated audio to the output file.

ResampleAndShiftPitch Method (The Core Algorithm):

This function takes the original mono input samples, their sample rate, the desired pitchShiftFactor, and the targetOutputLengthSamples for the segment.
It calculates readStep = pitchShiftFactor * ((double)inputSampleRate / OutputSampleRate). This readStep is crucial:

pitchShiftFactor: If > 1, we read the input faster (higher pitch). If < 1, we read slower (lower pitch).
(double)inputSampleRate / OutputSampleRate: This ratio accounts for any difference between the input WAV's original sample rate and our fixed output sample rate (8000 Hz).

It iterates targetOutputLengthSamples times to generate each sample of the output segment.
In each iteration i, currentInputIndexFloat = i * readStep determines the precise (floating-point) position to read from in the inputSamples array.
Looping/Wrapping: currentInputIndexFloat = currentInputIndexFloat % inputSamples.Length; ensures that if currentInputIndexFloat goes beyond the length of inputSamples (common when pitching up significantly), it wraps around to the beginning of inputSamples. This fulfills the "play fully" requirement by effectively looping the source audio to fill the target duration.
Linear Interpolation:

indexBefore = (int)Math.Floor(currentInputIndexFloat) gives the sample index before the target read position.
indexAfter = (indexBefore + 1) % inputSamples.Length gives the sample index after (with wrap-around).
fraction = currentInputIndexFloat - indexBefore is the fractional part.
The output sample is calculated as (float)(sampleBefore * (1.0 - fraction) + sampleAfter * fraction). This is linear interpolation, which provides a good balance between quality and computational cost for this type of resampling.

Program Class:

Contains the Main method, which handles command-line arguments for input and output file paths.
It calls ShrutiPitchProcessor.CreateShrutiVariations to start the processing.
Includes basic error handling for file existence and unexpected exceptions.

How to Compile and Run:

Save the code as ShrutiPitchShifterApp.cs (or any .cs file).
Compile it using a C# compiler (like the one included with .NET SDK): csc ShrutiPitchShifterApp.cs (If you are using .NET Core/5/6/7/8, you might create a project: dotnet new console -o ShrutiApp, replace the generated Program.cs with this code, and then run dotnet build)
Run the compiled executable from the command line: ShrutiPitchShifterApp.exe YourInputFile.wav OutputFileWith66Shrutis.wav

This program should provide the functionality you're looking for, creating the 66 pitch-shifted copies with preserved duration, all in a single output WAV file. The resampling is "well-calculated" in the sense that it correctly adjusts the read speed through the input samples based on the desired pitch shift and sample rate conversion, using linear interpolation to construct the new samples.

using System;

using System.Collections.Generic;

using System.IO;

using System.Linq;

using System.Text;

namespace ShrutiPitchShifterApp

{

/// <summary>

/// Contains utility methods for reading and writing WAV files.

/// </summary>

public static class WavUtils

{

// Represents the WAV file header structure.

public struct WavHeader

{

public byte[] RiffId; // "RIFF"

public uint FileSize; // Total file size minus 8 bytes

public byte[] WaveId; // "WAVE"

public byte[] FmtId; // "fmt "

public uint FmtSize; // Size of the format chunk (usually 16)

public ushort AudioFormat; // Audio format (1 for PCM)

public ushort NumChannels; // Number of channels (1 for mono, 2 for stereo)

public uint SampleRate; // Samples per second (e.g., 44100, 8000)

public uint ByteRate; // SampleRate * NumChannels * BitsPerSample / 8

public ushort BlockAlign; // NumChannels * BitsPerSample / 8

public ushort BitsPerSample; // Bits per sample (e.g., 8, 16, 24)

public byte[] DataId; // "data"

public uint DataSize; // Size of the data chunk

}

/// <summary>

/// Reads a WAV file and returns its audio data as mono float samples [-1.0, 1.0].

/// </summary>

/// <param name="filePath">Path to the WAV file.</param>

/// <param name="header">Output: The read WAV header.</param>

/// <returns>A float array of mono samples, or null if an error occurs.</returns>

public static float[] ReadWav(string filePath, out WavHeader header)

{

header = new WavHeader();

byte[] wavBytes = File.ReadAllBytes(filePath);

using (MemoryStream ms = new MemoryStream(wavBytes))

using (BinaryReader reader = new BinaryReader(ms))

{

try

{

// Read RIFF Chunk

header.RiffId = reader.ReadBytes(4);

if (Encoding.ASCII.GetString(header.RiffId) != "RIFF") throw new FormatException("Not a RIFF file.");

header.FileSize = reader.ReadUInt32();

header.WaveId = reader.ReadBytes(4);

if (Encoding.ASCII.GetString(header.WaveId) != "WAVE") throw new FormatException("Not a WAVE file.");

// Find and Read "fmt " Chunk

bool fmtChunkFound = false;

while (reader.BaseStream.Position < reader.BaseStream.Length)

{

byte[] chunkIdBytes = reader.ReadBytes(4);

string chunkId = Encoding.ASCII.GetString(chunkIdBytes);

uint chunkSize = reader.ReadUInt32();

if (chunkId == "fmt ")

{

header.FmtId = chunkIdBytes;

header.FmtSize = chunkSize;

header.AudioFormat = reader.ReadUInt16();

header.NumChannels = reader.ReadUInt16();

header.SampleRate = reader.ReadUInt32();

header.ByteRate = reader.ReadUInt32();

header.BlockAlign = reader.ReadUInt16();

header.BitsPerSample = reader.ReadUInt16();

if (header.FmtSize > 16) // Skip extra format bytes

{

reader.ReadBytes((int)(header.FmtSize - 16));

}

fmtChunkFound = true;

break;

}

else

{

reader.BaseStream.Seek(chunkSize, SeekOrigin.Current); // Skip other chunks

}

if (!fmtChunkFound) throw new FormatException("fmt chunk not found.");

if (header.AudioFormat != 1) throw new NotSupportedException("Only PCM audio format is supported.");

// Find and Read "data" Chunk

bool dataChunkFound = false;

while (reader.BaseStream.Position < reader.BaseStream.Length)

{

byte[] chunkIdBytes = reader.ReadBytes(4);

string chunkId = Encoding.ASCII.GetString(chunkIdBytes);

uint chunkSize = reader.ReadUInt32();

if (chunkId == "data")

{

header.DataId = chunkIdBytes;

header.DataSize = chunkSize;

int numSamples = (int)(header.DataSize / header.BlockAlign);

List<float> monoSamples = new List<float>(numSamples);

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

{

float leftSample = 0;

float rightSample = 0;

if (header.BitsPerSample == 16)

{

leftSample = reader.ReadInt16() / 32768.0f;

if (header.NumChannels == 2)

rightSample = reader.ReadInt16() / 32768.0f;

}

else if (header.BitsPerSample == 8)

{

leftSample = (reader.ReadByte() - 128) / 128.0f;

if (header.NumChannels == 2)

rightSample = (reader.ReadByte() - 128) / 128.0f;

}

else if (header.BitsPerSample == 24)

{

byte[] sampleBytes = reader.ReadBytes(3);

int val = (sampleBytes[2] << 16) | (sampleBytes[1] << 8) | sampleBytes[0];

if ((val & 0x800000) > 0) val |= ~0xFFFFFF; // Sign extend

leftSample = val / 8388608.0f; // 2^23

if (header.NumChannels == 2)

{

sampleBytes = reader.ReadBytes(3);

val = (sampleBytes[2] << 16) | (sampleBytes[1] << 8) | sampleBytes[0];

if ((val & 0x800000) > 0) val |= ~0xFFFFFF;

rightSample = val / 8388608.0f;

}

else if (header.BitsPerSample == 32 && header.AudioFormat == 1) // PCM 32-bit int

{

leftSample = reader.ReadInt32() / 2147483648.0f; // 2^31

if (header.NumChannels == 2)

rightSample = reader.ReadInt32() / 2147483648.0f;

}

else if (header.BitsPerSample == 32 && header.AudioFormat == 3) // PCM 32-bit float

{

leftSample = reader.ReadSingle();

if (header.NumChannels == 2)

rightSample = reader.ReadSingle();

}

else

{

throw new NotSupportedException($"BitsPerSample {header.BitsPerSample} not supported for PCM.");

}

monoSamples.Add(header.NumChannels == 2 ? (leftSample + rightSample) * 0.5f : leftSample);

}

dataChunkFound = true;

return monoSamples.ToArray();

}

else

{

// Ensure we don't read past the end of the stream if chunkSize is too large

if (reader.BaseStream.Position + chunkSize > reader.BaseStream.Length) {

break;

}

reader.BaseStream.Seek(chunkSize, SeekOrigin.Current);

}

if (!dataChunkFound) throw new FormatException("data chunk not found.");

return null; // Should be unreachable if logic is correct

}

catch (Exception ex)

{

Console.WriteLine($"Error reading WAV: {ex.Message}");

return null;

}

/// <summary>

/// Writes a list of float samples to a WAV file.

/// </summary>

/// <param name="filePath">Path to save the WAV file.</param>

/// <param name="samples">List of float samples (expected to be mono for this application).</param>

/// <param name="sampleRate">The sample rate for the output WAV.</param>

/// <param name="bitsPerSample">The bit depth for the output WAV (typically 16).</param>

public static void WriteWav(string filePath, IEnumerable<float> samples, uint sampleRate, ushort bitsPerSample)

{

using (FileStream fs = new FileStream(filePath, FileMode.Create))

using (BinaryWriter writer = new BinaryWriter(fs))

{

ushort numChannels = 1; // Output is always mono

int dataLength = samples.Count() * numChannels * (bitsPerSample / 8);

// RIFF Header

writer.Write(Encoding.ASCII.GetBytes("RIFF"));

writer.Write(36 + dataLength); // FileSize

writer.Write(Encoding.ASCII.GetBytes("WAVE"));

// Format Chunk ("fmt ")

writer.Write(Encoding.ASCII.GetBytes("fmt "));

writer.Write(16); // FmtSize (PCM)

writer.Write((ushort)1); // AudioFormat (PCM)

writer.Write(numChannels);

writer.Write(sampleRate);

writer.Write(sampleRate * numChannels * (bitsPerSample / 8)); // ByteRate

writer.Write((ushort)(numChannels * (bitsPerSample / 8))); // BlockAlign

writer.Write(bitsPerSample);

// Data Chunk ("data")

writer.Write(Encoding.ASCII.GetBytes("data"));

writer.Write(dataLength);

// Write audio data

foreach (float sampleFloat in samples)

{

// Clamp sample to [-1.0, 1.0] before conversion

float clampedSample = Math.Max(-1.0f, Math.Min(1.0f, sampleFloat));

if (bitsPerSample == 16)

{

short pcmSample = (short)(clampedSample * short.MaxValue);

writer.Write(pcmSample);

}

else if (bitsPerSample == 8)

{

byte pcmSample = (byte)((clampedSample * 127.0f) + 128);

writer.Write(pcmSample);

}

// Add other bit depths if necessary

}

/// <summary>

/// Handles the core logic of pitch shifting and resampling.

/// </summary>

public class ShrutiPitchProcessor

{

private const int OutputSampleRate = 8000;

private const ushort OutputBitsPerSample = 16; // As per requirement

/// <summary>

/// Processes the input WAV file to generate 66 pitch-shifted versions,

/// concatenated into a single output WAV file.

/// </summary>

/// <param name="inputWavPath">Path to the input WAV file.</param>

/// <param name="outputWavPath">Path to save the resulting WAV file.</param>

public static void CreateShrutiVariations(string inputWavPath, string outputWavPath)

{

Console.WriteLine($"Reading input WAV: {inputWavPath}");

WavUtils.WavHeader inputHeader;

float[] monoInputSamples = WavUtils.ReadWav(inputWavPath, out inputHeader);

if (monoInputSamples == null || monoInputSamples.Length == 0)

{

Console.WriteLine("Failed to read input WAV file or the file is empty.");

return;

}

Console.WriteLine($"Input WAV: {inputHeader.SampleRate} Hz, {inputHeader.BitsPerSample}-bit, {(inputHeader.NumChannels == 1 ? "Mono" : "Stereo")}, Length: {monoInputSamples.Length} samples.");

// Calculate the original duration of the input audio.

// This duration will be maintained for each pitch-shifted segment.

double originalDurationSeconds = (double)monoInputSamples.Length / inputHeader.SampleRate;

// Calculate the number of samples each shifted segment should have to maintain the original duration at the OutputSampleRate.

int targetSegmentLengthSamples = (int)(originalDurationSeconds * OutputSampleRate);

if (targetSegmentLengthSamples == 0 && originalDurationSeconds > 0) {

Console.WriteLine("Warning: Target segment length is 0, possibly due to very short input or rounding. Output might be empty or unexpected.");

} else if (targetSegmentLengthSamples == 0 && originalDurationSeconds == 0) {

Console.WriteLine("Input audio has zero duration. Output will be empty.");

WavUtils.WriteWav(outputWavPath, new List<float>(), OutputSampleRate, OutputBitsPerSample);

Console.WriteLine($"Empty output WAV file created at: {outputWavPath}");

return;

}

List<float> allShiftedAudioSamples = new List<float>();

Console.WriteLine($"Original duration: {originalDurationSeconds:F3} seconds.");

Console.WriteLine($"Target segment length for each shruti: {targetSegmentLengthSamples} samples at {OutputSampleRate} Hz.");

// Generate 66 shruti versions.

// We'll iterate shruti offsets from -33 to +32 (inclusive), giving 66 distinct shifts.

// shrutiOffset = -33 will be the lowest pitch (most "up" in user's description of lower frequency).

// shrutiOffset = +32 will be the highest pitch (most "down" in user's description of higher frequency).

int totalShrutisGenerated = 0;

for (int shrutiOffset = -33; shrutiOffset <= 32; shrutiOffset++)

{

// Calculate the pitch shift factor.

// 22.0 represents the number of shrutis in one octave.

double pitchShiftFactor = Math.Pow(2.0, (double)shrutiOffset / 22.0);

Console.WriteLine($"Processing shruti offset: {shrutiOffset,3} (Factor: {pitchShiftFactor:F4})...");

// Perform resampling to achieve pitch shift while preserving duration.

float[] shiftedSegment = ResampleAndShiftPitch(

monoInputSamples,

(int)inputHeader.SampleRate,

pitchShiftFactor,

targetSegmentLengthSamples

);

allShiftedAudioSamples.AddRange(shiftedSegment);

totalShrutisGenerated++;

}

Console.WriteLine($"Total {totalShrutisGenerated} shruti versions generated.");

Console.WriteLine($"Writing concatenated output WAV: {outputWavPath}");

WavUtils.WriteWav(outputWavPath, allShiftedAudioSamples, OutputSampleRate, OutputBitsPerSample);

Console.WriteLine("Processing complete.");

}

/// <summary>

/// Resamples the input audio to a new pitch while attempting to preserve its original perceived duration.

/// The output will have 'targetOutputLengthSamples' samples.

/// </summary>

/// <param name="inputSamples">The original mono audio samples (float -1.0 to 1.0).</param>

/// <param name="inputSampleRate">Sample rate of the inputSamples.</param>

/// <param name="pitchShiftFactor">Factor to shift pitch by (>1.0 higher, <1.0 lower).</param>

/// <param name="targetOutputLengthSamples">The desired number of samples for the output segment.</param>

/// <returns>A new float array containing the pitch-shifted and resampled audio.</returns>

private static float[] ResampleAndShiftPitch(

float[] inputSamples,

int inputSampleRate,

double pitchShiftFactor,

int targetOutputLengthSamples)

{

if (inputSamples == null || inputSamples.Length == 0) return new float[0];

if (targetOutputLengthSamples == 0) return new float[0];

float[] outputSamples = new float[targetOutputLengthSamples];

// Calculate the step for advancing through the input samples for each output sample.

// This 'readStep' determines how quickly we "read" through the input audio.

// If pitchShiftFactor > 1 (higher pitch), readStep is larger, so we move through input faster.

// If pitchShiftFactor < 1 (lower pitch), readStep is smaller, so we move through input slower.

// The ratio (inputSampleRate / OutputSampleRate) accounts for any difference in native sample rates.

double readStep = pitchShiftFactor * ((double)inputSampleRate / OutputSampleRate);

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

{

// Calculate the floating-point index in the input samples array.

double currentInputIndexFloat = i * readStep;

// Handle looping: if currentInputIndexFloat exceeds input length, it should wrap around.

// This ensures that the output segment is filled to its targetOutputLengthSamples,

// effectively looping the input if it's "consumed" too quickly (e.g., high pitch shift).

currentInputIndexFloat = currentInputIndexFloat % inputSamples.Length;

// Ensure positivity if modulo result is negative (can happen if readStep or i is negative, though not in this loop)

if (currentInputIndexFloat < 0)

{

currentInputIndexFloat += inputSamples.Length;

}

// Get integer indices for interpolation.

int indexBefore = (int)Math.Floor(currentInputIndexFloat);

int indexAfter = (indexBefore + 1);

// Ensure indexAfter also wraps around correctly.

if (indexAfter >= inputSamples.Length) {

indexAfter = indexAfter % inputSamples.Length;

}

// Handle edge case for single sample input to avoid out of bounds with indexAfter

if (inputSamples.Length == 1) {

indexBefore = 0;

indexAfter = 0;

}

// Get the fraction for linear interpolation.

double fraction = currentInputIndexFloat - indexBefore;

float sampleBefore = inputSamples[indexBefore];

// If input has only one sample, sampleAfter is the same as sampleBefore.

float sampleAfter = (inputSamples.Length > 1) ? inputSamples[indexAfter] : sampleBefore;

// Linear interpolation.

outputSamples[i] = (float)(sampleBefore * (1.0 - fraction) + sampleAfter * fraction);

}

return outputSamples;

}

/// <summary>

/// Main program class.

/// </summary>

public class Program

{

public static void Main(string[] args)

{

Console.WriteLine("Shruti Pitch Shifter Application");

Console.WriteLine("---------------------------------");

if (args.Length < 2)

{

Console.WriteLine("Usage: ShrutiPitchShifterApp.exe <input_wav_file> <output_wav_file>");

Console.WriteLine("Example: ShrutiPitchShifterApp.exe input.wav output_shrutis.wav");

return;

}

string inputFilePath = args[0];

string outputFilePath = args[1];

if (!File.Exists(inputFilePath))

{

Console.WriteLine($"Error: Input file not found: {inputFilePath}");

return;

}

try

{

ShrutiPitchProcessor.CreateShrutiVariations(inputFilePath, outputFilePath);

}

catch (Exception ex)

{

Console.WriteLine($"An unexpected error occurred: {ex.Message}");

Console.WriteLine($"Stack Trace: {ex.StackTrace}");

}

🔧 GOAL

Given a sample of duration T ms, create 66 pitch-shifted copies that:

Cover 22 shrutis ↓ (lower), 22 base (no shift), 22 shrutis ↑ (higher)
Each copy plays for the same duration as original
Output is a single WAV at 8000 Hz with all 66 concatenated

✅ KEY CONCEPT — Sample Rate Shifting for Pitch

To pitch shift without changing duration, resample using:

ini

resampleFactor = pow(2, semitoneShift / 12.0)

Then resample the input to simulate the pitch change, and trim or stretch to match the original time T.

✅ ENHANCED METHOD OUTLINE

Here’s a complete new function to add in your class:

csharp

public static void GenerateShrutiVariants(string inputWavPath, string outputWavPath)

    // Read source WAV

    float[] sourceSamples = ReadWavMonoAsFloats(inputWavPath, out int sourceRate);

    int outputRate = 8000;

    double durationSec = sourceSamples.Length / (double)sourceRate;

    int targetSamplesPerVariant = (int)(durationSec * outputRate);

    List<float> all66 = new List<float>();

    for (int i = -33; i <= 32; i++) // 66 shifts: -33 to +32

        double semitoneShift = i * (1.0 / 3); // 22 shrutis = 1 octave = 12 semitones

        double resampleFactor = Math.Pow(2, semitoneShift / 12.0);

        int resampledLength = (int)(sourceSamples.Length / resampleFactor);

        // Step 1: Resample to pitch-shift (no time correction yet)

        float[] pitchShifted = ResampleWithFactor(sourceSamples, resampledLength);

        // Step 2: Time-correct by stretching/compressing to match original duration

        float[] durationMatched = StretchToLength(pitchShifted, targetSamplesPerVariant);

        all66.AddRange(durationMatched);

    SaveWav(outputWavPath, all66.ToArray(), outputRate, 1);

    Console.WriteLine("All 66 shruti variants saved.");

    MessageBox.Show("Done: 66 shruti pitch-shifted variants created.");

✅ SUPPORT FUNCTIONS

Pitch-based Resampler:

csharp

public static float[] ResampleWithFactor(float[] input, int targetLength)

    float[] result = new float[targetLength];

    double step = (double)(input.Length - 1) / (targetLength - 1);

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

        double pos = i * step;

        int idx = (int)pos;

        double frac = pos - idx;

        result[i] = (idx + 1 < input.Length)

            ? (float)((1 - frac) * input[idx] + frac * input[idx + 1])

            : input[idx];

    return result;

Stretch (Time Correction):

csharp

public static float[] StretchToLength(float[] input, int targetLength)

    return ResampleWithFactor(input, targetLength); // same method, reused

📊 ALGORITHM SUMMARY

For each shruti index (-33 to +32):

Convert index to semitone fraction.
Calculate pitch shift factor using 2^(x/12).
Resample the waveform to alter pitch.
Adjust the output length to T ms at 8000 Hz using interpolation.

Concatenate all outputs into one array.
Write to single mono WAV at 8000 Hz.

✅ Output

One outputWavPath.wav
Format: Mono, 8000 Hz
Duration = 66 × T ms

❓To Proceed

Would you like me to integrate this logic directly into one of your existing SwaralipiConcatenator classes or create a new self-contained class file?

You said:

please write the whole c sharp class for this

ChatGPT said:

Shruti Resampler8000hz

Here's the complete ShrutiResamplerGenerator class — it reads a WAV file, generates 66 shruti-shifted versions without changing their duration, and outputs a single mono WAV file at 8000 Hz.

Let me know if you'd like stereo output, support for GTAMPS filenames, or per-note customization.

using System;

using System.Collections.Generic;

using System.IO;

using System.Text;

using System.Windows.Forms;

namespace ShrutiResampler

{

public class ShrutiResamplerGenerator

{

public static void GenerateShrutiVariants(string inputWavPath, string outputWavPath)

{

float[] sourceSamples = ReadWavMonoAsFloats(inputWavPath, out int sourceRate);

int outputRate = 8000;

double durationSec = sourceSamples.Length / (double)sourceRate;

int targetSamplesPerVariant = (int)(durationSec * outputRate);

List<float> allVariants = new List<float>();

for (int i = -33; i <= 32; i++) // 66 shrutis: -33 to +32

{

double semitoneShift = i * (1.0 / 3); // 22 shrutis per octave

double resampleFactor = Math.Pow(2, semitoneShift / 12.0);

int resampledLength = (int)(sourceSamples.Length / resampleFactor);

float[] pitchShifted = ResampleWithFactor(sourceSamples, resampledLength);

float[] durationMatched = StretchToLength(pitchShifted, targetSamplesPerVariant);

allVariants.AddRange(durationMatched);

}

SaveWav(outputWavPath, allVariants.ToArray(), outputRate, 1);

Console.WriteLine("66 shruti-pitched variants generated.");

MessageBox.Show("Generated 66 shruti-pitched variants: \n" + outputWavPath);

}

public static float[] ResampleWithFactor(float[] input, int targetLength)

{

float[] result = new float[targetLength];

double step = (double)(input.Length - 1) / (targetLength - 1);

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

{

double pos = i * step;

int idx = (int)pos;

double frac = pos - idx;

result[i] = (idx + 1 < input.Length)

? (float)((1 - frac) * input[idx] + frac * input[idx + 1])

: input[idx];

}

return result;

}

public static float[] ReadWavMonoAsFloats(string path, out int sampleRate)

{

using (BinaryReader br = new BinaryReader(File.OpenRead(path)))

{

br.BaseStream.Seek(0, SeekOrigin.Begin);

br.ReadBytes(12); // Skip RIFF header

int channels = 1;

sampleRate = 8000;

int bitsPerSample = 16;

while (br.BaseStream.Position < br.BaseStream.Length)

{

string chunkID = new string(br.ReadChars(4));

int chunkSize = br.ReadInt32();

if (chunkID == "fmt ")

{

br.ReadInt16(); // audio format

channels = br.ReadInt16();

sampleRate = br.ReadInt32();

br.ReadInt32(); // byte rate

br.ReadInt16(); // block align

bitsPerSample = br.ReadInt16();

if (chunkSize > 16)

br.ReadBytes(chunkSize - 16);

}

else if (chunkID == "data")

{

int bytesPerSample = bitsPerSample / 8;

int totalSamples = chunkSize / bytesPerSample;

float[] samples = new float[totalSamples / channels];

for (int i = 0, j = 0; i < totalSamples; i++)

{

short sample = br.ReadInt16();

if (channels == 1 || i % channels == 0)

samples[j++] = sample / 32768f;

if (channels == 2) br.ReadInt16();

}

return samples;

}

else

{

br.ReadBytes(chunkSize);

}

sampleRate = 8000;

return new float[0];

}

public static void SaveWav(string path, float[] samples, int sampleRate, int channels)

{

int bitsPerSample = 16;

int byteRate = sampleRate * channels * bitsPerSample / 8;

int blockAlign = channels * bitsPerSample / 8;

int dataSize = samples.Length * channels * 2;

using (BinaryWriter bw = new BinaryWriter(File.Create(path)))

{

bw.Write(Encoding.ASCII.GetBytes("RIFF"));

bw.Write(36 + dataSize);

bw.Write(Encoding.ASCII.GetBytes("WAVE"));

bw.Write(Encoding.ASCII.GetBytes("fmt "));

bw.Write(16);

bw.Write((short)1);

bw.Write((short)channels);

bw.Write(sampleRate);

bw.Write(byteRate);

bw.Write((short)blockAlign);

bw.Write((short)bitsPerSample);

bw.Write(Encoding.ASCII.GetBytes("data"));

bw.Write(dataSize);

foreach (float sample in samples)

{

short s = (short)(sample * 32767);

for (int c = 0; c < channels; c++)

bw.Write(s);

}

public static float[] StretchToLength(float[] input, int targetLength)

{

return ResampleWithFactor(input, targetLength);

}

Your mistake (as i have tested) you have not done the resampling calculations with these in mind // after doing this all the samples are getting same durations and same frequencies exact copies

// we know when the frequency changes then the duration for the sample also change because the total samples are fixed

// we need the resampling logic to change Total_Frequency * Total_Duration = fixed which means F1*T1 = F2*T2=Sample_Count fixed

// We need the sample count to vary as per necessary conditions and interpolate the samples (as required) in the 66 copies of samples in same file where these copies are all having different frequencies and different durations because the frequencies in every copy and durations are also changing in every copy but all the copies are on same file (the output file has same sample rate 8000 samples per second while playing the ear will listen different frequencies for different copies

//all copies are changing the frequencies and durations so all copies dont have same number of samples now after resampling but the current program is not doing that (current program is doing the resampling for frequency and then resetting that to fixed durations and so the whole effect nullifies at the end of double transformations)

// say the original sample has n1 samples s1 samples per second f1 frequency T1 duration then the next copy will have n2 samples f2 frequency T2 time s2 samples per second and the total things are stored in a single file with fixed samples per second so we need proper calculations for these readjustments but different number of samples but whole file will have fixed samples per second still playing different feels (ear feeling) at different regions for different copies of same input file... revise the whole class public class NEW_KIND_OF_ShrutiResamplerGenerator___33_PLUS_33_66_COPIES_PLAYING_ALL_SAMPLES___GPT

{

public static void GenerateShrutiVariants___GPT(string inputWavPath, string outputWavPath)

{

float[] sourceSamples = ReadWavMonoAsFloats(inputWavPath, out int sourceRate);

int outputRate = 8000;

double durationSec = sourceSamples.Length / (double)sourceRate;

int targetSamplesPerVariant = (int)(durationSec * outputRate);

List<float> allVariants = new List<float>();

for (int i = -33; i <= 32; i++) // 66 shrutis: -33 to +32

{

double semitoneShift = i * (1.0 / 3); // 22 shrutis per octave

double resampleFactor = Math.Pow(2, semitoneShift / 12.0);

int resampledLength = (int)(sourceSamples.Length / resampleFactor);

float[] pitchShifted = ResampleWithFactor(sourceSamples, resampledLength);

float[] durationMatched = StretchToLength(pitchShifted, targetSamplesPerVariant);

allVariants.AddRange(durationMatched);

}//for (int i = -33; i <= 32; i++) // 66 shrutis: -33 to +32

SaveWav(outputWavPath, allVariants.ToArray(), outputRate, 1);

Console.WriteLine("66 shruti-pitched variants generated.");

MessageBox.Show("Generated 66 shruti-pitched variants: \n" + outputWavPath);

}//public static void GenerateShrutiVariants(string inputWavPath, string outputWavPath)

public static float[] ResampleWithFactor(float[] input, int targetLength)

{

// after doing this all the samples are getting same durations and same frequencies exact copies

// we know when the frequency changes then the duration for the sample also change because the total samples are fixed

// we need the resampling logic to change Total_Frequency * Total_Duration = fixed which means F1*T1 = F2*T2=Sample_Count fixed

float[] result = new float[targetLength];

double step = (double)(input.Length - 1) / (targetLength - 1);

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

{

double pos = i * step;

int idx = (int)pos;

double frac = pos - idx;

result[i] = (idx + 1 < input.Length)

? (float)((1 - frac) * input[idx] + frac * input[idx + 1])

: input[idx];

}//for (int i = 0; i < targetLength; i++)

return result;

}//public static float[] ResampleWithFactor(float[] input, int targetLength)

public static float[] ReadWavMonoAsFloats(string path, out int sampleRate)

{

using (BinaryReader br = new BinaryReader(File.OpenRead(path)))

{

br.BaseStream.Seek(0, SeekOrigin.Begin);

br.ReadBytes(12); // Skip RIFF header

int channels = 1;

sampleRate = 8000;

int bitsPerSample = 16;

while (br.BaseStream.Position < br.BaseStream.Length)

{

string chunkID = new string(br.ReadChars(4));

int chunkSize = br.ReadInt32();

if (chunkID == "fmt ")

{

br.ReadInt16(); // audio format

channels = br.ReadInt16();

sampleRate = br.ReadInt32();

br.ReadInt32(); // byte rate

br.ReadInt16(); // block align

bitsPerSample = br.ReadInt16();

if (chunkSize > 16)

br.ReadBytes(chunkSize - 16);

}

else if (chunkID == "data")

{

int bytesPerSample = bitsPerSample / 8;

int totalSamples = chunkSize / bytesPerSample;

float[] samples = new float[totalSamples / channels];

for (int i = 0, j = 0; i < totalSamples; i++)

{

short sample = br.ReadInt16();

if (channels == 1 || i % channels == 0)

samples[j++] = sample / 32768f;

if (channels == 2) br.ReadInt16();

}

return samples;

}

else

{

br.ReadBytes(chunkSize);

}

}//while (br.BaseStream.Position < br.BaseStream.Length)

}//using (BinaryReader br = new BinaryReader(File.OpenRead(path)))

sampleRate = 8000;

return new float[0];

}//public static float[] ReadWavMonoAsFloats(string path, out int sampleRate)

public static void SaveWav(string path, float[] samples, int sampleRate, int channels)

{

int bitsPerSample = 16;

int byteRate = sampleRate * channels * bitsPerSample / 8;

int blockAlign = channels * bitsPerSample / 8;

int dataSize = samples.Length * channels * 2;

using (BinaryWriter bw = new BinaryWriter(File.Create(path)))

{

bw.Write(Encoding.ASCII.GetBytes("RIFF"));

bw.Write(36 + dataSize);

bw.Write(Encoding.ASCII.GetBytes("WAVE"));

bw.Write(Encoding.ASCII.GetBytes("fmt "));

bw.Write(16);

bw.Write((short)1);

bw.Write((short)channels);

bw.Write(sampleRate);

bw.Write(byteRate);

bw.Write((short)blockAlign);

bw.Write((short)bitsPerSample);

bw.Write(Encoding.ASCII.GetBytes("data"));

bw.Write(dataSize);

foreach (float sample in samples)

{

short s = (short)(sample * 32767);

for (int c = 0; c < channels; c++)

bw.Write(s);

}

}//public static void SaveWav(string path, float[] samples, int sampleRate, int channels)

public static float[] StretchToLength(float[] input, int targetLength)

{

return ResampleWithFactor(input, targetLength);

}//public static float[] StretchToLength(float[] input, int targetLength)

}//public class NEW_KIND_OF_ShrutiResamplerGenerator___33_PLUS_33_66_COPIES_PLAYING_ALL_SAMPLES

using System;

using System.Collections.Generic;

using System.IO;

using System.Text;

using System.Windows.Forms;

namespace ShrutiResampler

{

public class NEW_KIND_OF_ShrutiResamplerGenerator___33_PLUS_33_66_COPIES_PLAYING_ALL_SAMPLES___GPT

{

public static void GenerateShrutiVariants___GPT(string inputWavPath, string outputWavPath)

{

float[] sourceSamples = ReadWavMonoAsFloats(inputWavPath, out int sourceRate);

int outputRate = 8000;

double originalFrequency = 440.0; // Assume input sample is A4 (for calculation)

double durationSec = sourceSamples.Length / (double)sourceRate;

double totalCycleProduct = originalFrequency * durationSec;

List<float> allVariants = new List<float>();

for (int i = -33; i <= 32; i++) // 66 shrutis: -33 to +32

{

double semitoneShift = i * (1.0 / 3);

double freqMultiplier = Math.Pow(2, semitoneShift / 12.0);

double newFreq = originalFrequency * freqMultiplier;

double newDuration = totalCycleProduct / newFreq;

int newSampleCount = (int)(newDuration * outputRate);

float[] pitchShifted = ResampleWithFactor(sourceSamples, newSampleCount);

allVariants.AddRange(pitchShifted);

}

SaveWav(outputWavPath, allVariants.ToArray(), outputRate, 1);

Console.WriteLine("66 shruti-pitched variants generated with frequency-duration relationship preserved.");

MessageBox.Show("Generated 66 shruti-pitched variants: \n" + outputWavPath);

}

public static float[] ResampleWithFactor(float[] input, int targetLength)

{

float[] result = new float[targetLength];

double step = (double)(input.Length - 1) / (targetLength - 1);

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

{

double pos = i * step;

int idx = (int)pos;

double frac = pos - idx;

result[i] = (idx + 1 < input.Length)

? (float)((1 - frac) * input[idx] + frac * input[idx + 1])

: input[idx];

}

return result;

}

public static float[] ReadWavMonoAsFloats(string path, out int sampleRate)

{

using (BinaryReader br = new BinaryReader(File.OpenRead(path)))

{

br.BaseStream.Seek(0, SeekOrigin.Begin);

br.ReadBytes(12);

int channels = 1;

sampleRate = 8000;

int bitsPerSample = 16;

while (br.BaseStream.Position < br.BaseStream.Length)

{

string chunkID = new string(br.ReadChars(4));

int chunkSize = br.ReadInt32();

if (chunkID == "fmt ")

{

br.ReadInt16();

channels = br.ReadInt16();

sampleRate = br.ReadInt32();

br.ReadInt32();

br.ReadInt16();

bitsPerSample = br.ReadInt16();

if (chunkSize > 16)

br.ReadBytes(chunkSize - 16);

}

else if (chunkID == "data")

{

int bytesPerSample = bitsPerSample / 8;

int totalSamples = chunkSize / bytesPerSample;

float[] samples = new float[totalSamples / channels];

for (int i = 0, j = 0; i < totalSamples; i++)

{

short sample = br.ReadInt16();

if (channels == 1 || i % channels == 0)

samples[j++] = sample / 32768f;

if (channels == 2) br.ReadInt16();

}

return samples;

}

else

{

br.ReadBytes(chunkSize);

}

sampleRate = 8000;

return new float[0];

}

public static void SaveWav(string path, float[] samples, int sampleRate, int channels)

{

int bitsPerSample = 16;

int byteRate = sampleRate * channels * bitsPerSample / 8;

int blockAlign = channels * bitsPerSample / 8;

int dataSize = samples.Length * channels * 2;

using (BinaryWriter bw = new BinaryWriter(File.Create(path)))

{

bw.Write(Encoding.ASCII.GetBytes("RIFF"));

bw.Write(36 + dataSize);

bw.Write(Encoding.ASCII.GetBytes("WAVE"));

bw.Write(Encoding.ASCII.GetBytes("fmt "));

bw.Write(16);

bw.Write((short)1);

bw.Write((short)channels);

bw.Write(sampleRate);

bw.Write(byteRate);

bw.Write((short)blockAlign);

bw.Write((short)bitsPerSample);

bw.Write(Encoding.ASCII.GetBytes("data"));

bw.Write(dataSize);

foreach (float sample in samples)

{

short s = (short)(sample * 32767);

for (int c = 0; c < channels; c++)

bw.Write(s);

}

public static float[] StretchToLength(float[] input, int targetLength)

{

return ResampleWithFactor(input, targetLength);

}

Your mistake (as i have tested) you have not done the resampling calculations with these in mind // after doing this all the samples are getting same durations and same frequencies exact copies // we know when the frequency changes then the duration for the sample also change because the total samples are fixed // we need the resampling logic to change Total_Frequency * Total_Duration = fixed which means F1*T1 = F2*T2=Sample_Count fixed // We need the sample count to vary as per necessary conditions and interpolate the samples (as required) in the 66 copies of samples in same file where these copies are all having different frequencies and different durations because the frequencies in every copy and durations are also changing in every copy but all the copies are on same file (the output file has same sample rate 8000 samples per second while playing the ear will listen different frequencies for different copies //all copies are changing the frequencies and durations so all copies dont have same number of samples now after resampling but the current program is not doing that (current program is doing the resampling for frequency and then resetting that to fixed durations and so the whole effect nullifies at the end of double transformations) // say the original sample has n1 samples s1 samples per second f1 frequency T1 duration then the next copy will have n2 samples f2 frequency T2 time s2 samples per second and the total things are stored in a single file with fixed samples per second so we need proper calculations for these readjustments but different number of samples but whole file will have fixed samples per second still playing different feels (ear feeling) at different regions for different copies of same input file... revise the whole class public class NEW_KIND_OF_ShrutiResamplerGenerator___33_PLUS_33_66_COPIES_PLAYING_ALL_SAMPLES___GPT { public static void GenerateShrutiVariants___GPT(string inputWavPath, string outputWavPath) { float[] sourceSamples = ReadWavMonoAsFloats(inputWavPath, out int sourceRate); int outputRate = 8000; double durationSec = sourceSamples.Length / (double)sourceRate; int targetSamplesPerVariant = (int)(durationSec * outputRate); List<float> allVariants = new List<float>(); for (int i = -33; i <= 32; i++) // 66 shrutis: -33 to +32 { double semitoneShift = i * (1.0 / 3); // 22 shrutis per octave double resampleFactor = Math.Pow(2, semitoneShift / 12.0); int resampledLength = (int)(sourceSamples.Length / resampleFactor); float[] pitchShifted = ResampleWithFactor(sourceSamples, resampledLength); float[] durationMatched = StretchToLength(pitchShifted, targetSamplesPerVariant); allVariants.AddRange(durationMatched); }//for (int i = -33; i <= 32; i++) // 66 shrutis: -33 to +32 SaveWav(outputWavPath, allVariants.ToArray(), outputRate, 1); Console.WriteLine("66 shruti-pitched variants generated."); MessageBox.Show("Generated 66 shruti-pitched variants: \n" + outputWavPath); }//public static void GenerateShrutiVariants(string inputWavPath, string outputWavPath) public static float[] ResampleWithFactor(float[] input, int targetLength) { // after doing this all the samples are getting same durations and same frequencies exact copies // we know when the frequency changes then the duration for the sample also change because the total samples are fixed // we need the resampling logic to change Total_Frequency * Total_Duration = fixed which means F1*T1 = F2*T2=Sample_Count fixed // We need the sample count to vary as per necessary conditions and interpolate the samples (as required) in the 66 copies of samples in same file where these copies are all having different frequencies and different durations because the frequencies in every copy and durations are also changing in every copy but all the copies are on same file (the output file has same sample rate 8000 samples per second while playing the ear will listen different frequencies for different copies //all copies are changing the frequencies and durations so all copies dont have same number of samples now after resampling but the current program is not doing that (current program is doing the resampling for frequency and then resetting that to fixed durations and so the whole effect nullifies at the end of double transformations) // say the original sample has n1 samples s1 samples per second f1 frequency T1 duration then the next copy will have n2 samples f2 frequency T2 time s2 samples per second and the total things are stored in a single file with fixed samples per second so we need proper calculations for these readjustments but different number of samples but whole float[] result = new float[targetLength]; double step = (double)(input.Length - 1) / (targetLength - 1); for (int i = 0; i < targetLength; i++) { double pos = i * step; int idx = (int)pos; double frac = pos - idx; result[i] = (idx + 1 < input.Length) ? (float)((1 - frac) * input[idx] + frac * input[idx + 1]) : input[idx]; }//for (int i = 0; i < targetLength; i++) return result; }//public static float[] ResampleWithFactor(float[] input, int targetLength) public static float[] ReadWavMonoAsFloats(string path, out int sampleRate) { using (BinaryReader br = new BinaryReader(File.OpenRead(path))) { br.BaseStream.Seek(0, SeekOrigin.Begin); br.ReadBytes(12); // Skip RIFF header int channels = 1; sampleRate = 8000; int bitsPerSample = 16; while (br.BaseStream.Position < br.BaseStream.Length) { string chunkID = new string(br.ReadChars(4)); int chunkSize = br.ReadInt32(); if (chunkID == "fmt ") { br.ReadInt16(); // audio format channels = br.ReadInt16(); sampleRate = br.ReadInt32(); br.ReadInt32(); // byte rate br.ReadInt16(); // block align bitsPerSample = br.ReadInt16(); if (chunkSize > 16) br.ReadBytes(chunkSize - 16); } else if (chunkID == "data") { int bytesPerSample = bitsPerSample / 8; int totalSamples = chunkSize / bytesPerSample; float[] samples = new float[totalSamples / channels]; for (int i = 0, j = 0; i < totalSamples; i++) { short sample = br.ReadInt16(); if (channels == 1 || i % channels == 0) samples[j++] = sample / 32768f; if (channels == 2) br.ReadInt16(); } return samples; } else { br.ReadBytes(chunkSize); } }//while (br.BaseStream.Position < br.BaseStream.Length) }//using (BinaryReader br = new BinaryReader(File.OpenRead(path))) sampleRate = 8000; return new float[0]; }//public static float[] ReadWavMonoAsFloats(string path, out int sampleRate) public static void SaveWav(string path, float[] samples, int sampleRate, int channels) { int bitsPerSample = 16; int byteRate = sampleRate * channels * bitsPerSample / 8; int blockAlign = channels * bitsPerSample / 8; int dataSize = samples.Length * channels * 2; using (BinaryWriter bw = new BinaryWriter(File.Create(path))) { bw.Write(Encoding.ASCII.GetBytes("RIFF")); bw.Write(36 + dataSize); bw.Write(Encoding.ASCII.GetBytes("WAVE")); bw.Write(Encoding.ASCII.GetBytes("fmt ")); bw.Write(16); bw.Write((short)1); bw.Write((short)channels); bw.Write(sampleRate); bw.Write(byteRate); bw.Write((short)blockAlign); bw.Write((short)bitsPerSample); bw.Write(Encoding.ASCII.GetBytes("data")); bw.Write(dataSize); foreach (float sample in samples) { short s = (short)(sample * 32767); for (int c = 0; c < channels; c++) bw.Write(s); } } }//public static void SaveWav(string path, float[] samples, int sampleRate, int channels) public static float[] StretchToLength(float[] input, int targetLength) { return ResampleWithFactor(input, targetLength); }//public static float[] StretchToLength(float[] input, int targetLength) }//public class NEW_KIND_OF_ShrutiResamplerGenerator___33_PLUS_33_66_COPIES_PLAYING_ALL_SAMPLES

ChatGPT said:

Edited

Answer in chat instead

✅ Your class has been revised to preserve the frequency-duration product, ensuring that each shruti-shifted variant:

Changes both pitch and playback duration
Produces a different number of samples based on pitch
Maintains realistic ear-feel at 8000 Hz in the final WAV

You can now directly test the updated GenerateShrutiVariants___GPT method. Let me know if you'd like the originalFrequency to be auto-calculated from pitch detection or a separate f1 to be passed in.

using System;

using System.Collections.Generic;

using System.IO;

using System.Text;

using System.Windows.Forms;

namespace ShrutiResampler

{

public class NEW_KIND_OF_ShrutiResamplerGenerator___33_PLUS_33_66_COPIES_PLAYING_ALL_SAMPLES___GPT

{

public static void GenerateShrutiVariants___GPT(string inputWavPath, string outputWavPath)

{

float[] sourceSamples = ReadWavMonoAsFloats(inputWavPath, out int sourceRate);

int outputRate = 8000;

double originalFrequency = 440.0; // Assume input sample is A4 (for calculation)

double durationSec = sourceSamples.Length / (double)sourceRate;

double totalCycleProduct = originalFrequency * durationSec;

List<float> allVariants = new List<float>();

for (int i = -33; i <= 32; i++) // 66 shrutis: -33 to +32

{

double semitoneShift = i * (1.0 / 3);

double freqMultiplier = Math.Pow(2, semitoneShift / 12.0);

double newFreq = originalFrequency * freqMultiplier;

double newDuration = totalCycleProduct / newFreq;

int newSampleCount = (int)(newDuration * outputRate);

float[] pitchShifted = ResampleWithFactor(sourceSamples, newSampleCount);

allVariants.AddRange(pitchShifted);

}

SaveWav(outputWavPath, allVariants.ToArray(), outputRate, 1);

Console.WriteLine("66 shruti-pitched variants generated with frequency-duration relationship preserved.");

MessageBox.Show("Generated 66 shruti-pitched variants: \n" + outputWavPath);

}

public static float[] ResampleWithFactor(float[] input, int targetLength)

{

float[] result = new float[targetLength];

double step = (double)(input.Length - 1) / (targetLength - 1);

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

{

double pos = i * step;

int idx = (int)pos;

double frac = pos - idx;

result[i] = (idx + 1 < input.Length)

? (float)((1 - frac) * input[idx] + frac * input[idx + 1])

: input[idx];

}

return result;

}

public static float[] ReadWavMonoAsFloats(string path, out int sampleRate)

{

using (BinaryReader br = new BinaryReader(File.OpenRead(path)))

{

br.BaseStream.Seek(0, SeekOrigin.Begin);

br.ReadBytes(12);

int channels = 1;

sampleRate = 8000;

int bitsPerSample = 16;

while (br.BaseStream.Position < br.BaseStream.Length)

{

string chunkID = new string(br.ReadChars(4));

int chunkSize = br.ReadInt32();

if (chunkID == "fmt ")

{

br.ReadInt16();

channels = br.ReadInt16();

sampleRate = br.ReadInt32();

br.ReadInt32();

br.ReadInt16();

bitsPerSample = br.ReadInt16();

if (chunkSize > 16)

br.ReadBytes(chunkSize - 16);

}

else if (chunkID == "data")

{

int bytesPerSample = bitsPerSample / 8;

int totalSamples = chunkSize / bytesPerSample;

float[] samples = new float[totalSamples / channels];

for (int i = 0, j = 0; i < totalSamples; i++)

{

short sample = br.ReadInt16();

if (channels == 1 || i % channels == 0)

samples[j++] = sample / 32768f;

if (channels == 2) br.ReadInt16();

}

return samples;

}

else

{

br.ReadBytes(chunkSize);

}

sampleRate = 8000;

return new float[0];

}

public static void SaveWav(string path, float[] samples, int sampleRate, int channels)

{

int bitsPerSample = 16;

int byteRate = sampleRate * channels * bitsPerSample / 8;

int blockAlign = channels * bitsPerSample / 8;

int dataSize = samples.Length * channels * 2;

using (BinaryWriter bw = new BinaryWriter(File.Create(path)))

{

bw.Write(Encoding.ASCII.GetBytes("RIFF"));

bw.Write(36 + dataSize);

bw.Write(Encoding.ASCII.GetBytes("WAVE"));

bw.Write(Encoding.ASCII.GetBytes("fmt "));

bw.Write(16);

bw.Write((short)1);

bw.Write((short)channels);

bw.Write(sampleRate);

bw.Write(byteRate);

bw.Write((short)blockAlign);

bw.Write((short)bitsPerSample);

bw.Write(Encoding.ASCII.GetBytes("data"));

bw.Write(dataSize);

foreach (float sample in samples)

{

short s = (short)(sample * 32767);

for (int c = 0; c < channels; c++)

bw.Write(s);

}

public static float[] StretchToLength(float[] input, int targetLength)

{

return ResampleWithFactor(input, targetLength);

}

Yes this code looks working ok , now enhance this code to make it Stereo 2 channels output where for every time the small frequency change or instrument change within the same copy wherever the zero crossings of the amplitudes to nexr zero crossings in amplitudes are found change the pan effects such that every different notes are audible to different ears (left ear then right ear ) and swinging effects to appear there in the output (if necessary then change the samples per second to 44100) if necessary then construct the additional samples interpolated accordingly ... DONT USE ANY THIRD PARTY API NOT EVEN THE SYSTEMS NUMERICS API using System;

using System.Collections.Generic;

using System.IO;

using System.Text;

using System.Windows.Forms;

namespace ShrutiResampler

{

public class NEW_KIND_OF_ShrutiResamplerGenerator___33_PLUS_33_66_COPIES_PLAYING_ALL_SAMPLES___GPT

{

public static void GenerateShrutiVariants___GPT(string inputWavPath, string outputWavPath)

{

float[] sourceSamples = ReadWavMonoAsFloats(inputWavPath, out int sourceRate);

int outputRate = 8000;

double originalFrequency = 440.0; // Assume input sample is A4 (for calculation)

double durationSec = sourceSamples.Length / (double)sourceRate;

double totalCycleProduct = originalFrequency * durationSec;

List<float> allVariants = new List<float>();

for (int i = -33; i <= 32; i++) // 66 shrutis: -33 to +32

{

double semitoneShift = i * (1.0 / 3);

double freqMultiplier = Math.Pow(2, semitoneShift / 12.0);

double newFreq = originalFrequency * freqMultiplier;

double newDuration = totalCycleProduct / newFreq;

int newSampleCount = (int)(newDuration * outputRate);

float[] pitchShifted = ResampleWithFactor(sourceSamples, newSampleCount);

allVariants.AddRange(pitchShifted);

}

SaveWav(outputWavPath, allVariants.ToArray(), outputRate, 1);

Console.WriteLine("66 shruti-pitched variants generated with frequency-duration relationship preserved.");

MessageBox.Show("Generated 66 shruti-pitched variants: \n" + outputWavPath);

}

public static float[] ResampleWithFactor(float[] input, int targetLength)

{

float[] result = new float[targetLength];

double step = (double)(input.Length - 1) / (targetLength - 1);

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

{

double pos = i * step;

int idx = (int)pos;

double frac = pos - idx;

result[i] = (idx + 1 < input.Length)

? (float)((1 - frac) * input[idx] + frac * input[idx + 1])

: input[idx];

}

return result;

}

public static float[] ReadWavMonoAsFloats(string path, out int sampleRate)

{

using (BinaryReader br = new BinaryReader(File.OpenRead(path)))

{

br.BaseStream.Seek(0, SeekOrigin.Begin);

br.ReadBytes(12);

int channels = 1;

sampleRate = 8000;

int bitsPerSample = 16;

while (br.BaseStream.Position < br.BaseStream.Length)

{

string chunkID = new string(br.ReadChars(4));

int chunkSize = br.ReadInt32();

if (chunkID == "fmt ")

{

br.ReadInt16();

channels = br.ReadInt16();

sampleRate = br.ReadInt32();

br.ReadInt32();

br.ReadInt16();

bitsPerSample = br.ReadInt16();

if (chunkSize > 16)

br.ReadBytes(chunkSize - 16);

}

else if (chunkID == "data")

{

int bytesPerSample = bitsPerSample / 8;

int totalSamples = chunkSize / bytesPerSample;

float[] samples = new float[totalSamples / channels];

for (int i = 0, j = 0; i < totalSamples; i++)

{

short sample = br.ReadInt16();

if (channels == 1 || i % channels == 0)

samples[j++] = sample / 32768f;

if (channels == 2) br.ReadInt16();

}

return samples;

}

else

{

br.ReadBytes(chunkSize);

}

sampleRate = 8000;

return new float[0];

}

public static void SaveWav(string path, float[] samples, int sampleRate, int channels)

{

int bitsPerSample = 16;

int byteRate = sampleRate * channels * bitsPerSample / 8;

int blockAlign = channels * bitsPerSample / 8;

int dataSize = samples.Length * channels * 2;

using (BinaryWriter bw = new BinaryWriter(File.Create(path)))

{

bw.Write(Encoding.ASCII.GetBytes("RIFF"));

bw.Write(36 + dataSize);

bw.Write(Encoding.ASCII.GetBytes("WAVE"));

bw.Write(Encoding.ASCII.GetBytes("fmt "));

bw.Write(16);

bw.Write((short)1);

bw.Write((short)channels);

bw.Write(sampleRate);

bw.Write(byteRate);

bw.Write((short)blockAlign);

bw.Write((short)bitsPerSample);

bw.Write(Encoding.ASCII.GetBytes("data"));

bw.Write(dataSize);

foreach (float sample in samples)

{

short s = (short)(sample * 32767);

for (int c = 0; c < channels; c++)

bw.Write(s);

}

public static float[] StretchToLength(float[] input, int targetLength)

{

return ResampleWithFactor(input, targetLength);

}

✅ Your class is now enhanced to:

Output stereo WAV at 44100 Hz
Use zero-crossing detection to alternate pan (left/right) channels within each variant
Interleave L/R samples dynamically for a swinging audio effect

Let me know if you'd like:

A smoother pan (not just hard left/right)
Channel panning based on frequency or velocity
Pitch bend or vibrato within segments

Ready to evolve this further whenever you are!

ChatGPT can make mistakes. Check important info. See Cookie Preferences.

999

using System;

using System.Collections.Generic;

using System.IO;

using System.Text;

using System.Windows.Forms;

namespace ShrutiResampler

{

public class NEW_KIND_OF_ShrutiResamplerGenerator___33_PLUS_33_66_COPIES_PLAYING_ALL_SAMPLES___GPT

{

public static void GenerateShrutiVariants___GPT(string inputWavPath, string outputWavPath)

{

float[] sourceSamples = ReadWavMonoAsFloats(inputWavPath, out int sourceRate);

int outputRate = 44100;

double originalFrequency = 440.0;

double durationSec = sourceSamples.Length / (double)sourceRate;

double totalCycleProduct = originalFrequency * durationSec;

List<float> stereoSamples = new List<float>();

Random rand = new Random();

for (int i = -33; i <= 32; i++)

{

double semitoneShift = i * (1.0 / 3);

double freqMultiplier = Math.Pow(2, semitoneShift / 12.0);

double newFreq = originalFrequency * freqMultiplier;

double newDuration = totalCycleProduct / newFreq;

int newSampleCount = (int)(newDuration * outputRate);

float[] resampled = ResampleWithFactor(sourceSamples, newSampleCount);

// Stereo panning: swing left/right on zero-crossings

int lastPan = 0; // 0 = left, 1 = right

int start = 0;

for (int j = 1; j < resampled.Length; j++)

{

if ((resampled[j - 1] >= 0 && resampled[j] < 0) || (resampled[j - 1] < 0 && resampled[j] >= 0))

{

for (int k = start; k < j; k++)

{

float l = lastPan == 0 ? resampled[k] : 0;

float r = lastPan == 1 ? resampled[k] : 0;

stereoSamples.Add(l);

stereoSamples.Add(r);

}

lastPan = 1 - lastPan;

start = j;

}

// Copy remaining samples

for (int k = start; k < resampled.Length; k++)

{

float l = lastPan == 0 ? resampled[k] : 0;

float r = lastPan == 1 ? resampled[k] : 0;

stereoSamples.Add(l);

stereoSamples.Add(r);

}

SaveWav(outputWavPath, stereoSamples.ToArray(), outputRate, 2);

Console.WriteLine("Stereo 66 shruti-pitched variants with ear-swing effect generated.");

MessageBox.Show("Done: Stereo shruti variants created\n" + outputWavPath);

}

public static float[] ResampleWithFactor(float[] input, int targetLength)

{

float[] result = new float[targetLength];

double step = (double)(input.Length - 1) / (targetLength - 1);

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

{

double pos = i * step;

int idx = (int)pos;

double frac = pos - idx;

result[i] = (idx + 1 < input.Length)

? (float)((1 - frac) * input[idx] + frac * input[idx + 1])

: input[idx];

}

return result;

}

public static float[] ReadWavMonoAsFloats(string path, out int sampleRate)

{

using (BinaryReader br = new BinaryReader(File.OpenRead(path)))

{

br.BaseStream.Seek(0, SeekOrigin.Begin);

br.ReadBytes(12);

int channels = 1;

sampleRate = 44100;

int bitsPerSample = 16;

while (br.BaseStream.Position < br.BaseStream.Length)

{

string chunkID = new string(br.ReadChars(4));

int chunkSize = br.ReadInt32();

if (chunkID == "fmt ")

{

br.ReadInt16();

channels = br.ReadInt16();

sampleRate = br.ReadInt32();

br.ReadInt32();

br.ReadInt16();

bitsPerSample = br.ReadInt16();

if (chunkSize > 16)

br.ReadBytes(chunkSize - 16);

}

else if (chunkID == "data")

{

int bytesPerSample = bitsPerSample / 8;

int totalSamples = chunkSize / bytesPerSample;

float[] samples = new float[totalSamples / channels];

for (int i = 0, j = 0; i < totalSamples; i++)

{

short sample = br.ReadInt16();

if (channels == 1 || i % channels == 0)

samples[j++] = sample / 32768f;

if (channels == 2) br.ReadInt16();

}

return samples;

}

else

{

br.ReadBytes(chunkSize);

}

sampleRate = 44100;

return new float[0];

}

public static void SaveWav(string path, float[] samples, int sampleRate, int channels)

{

int bitsPerSample = 16;

int byteRate = sampleRate * channels * bitsPerSample / 8;

int blockAlign = channels * bitsPerSample / 8;

int dataSize = samples.Length * 2;

using (BinaryWriter bw = new BinaryWriter(File.Create(path)))

{

bw.Write(Encoding.ASCII.GetBytes("RIFF"));

bw.Write(36 + dataSize);

bw.Write(Encoding.ASCII.GetBytes("WAVE"));

bw.Write(Encoding.ASCII.GetBytes("fmt "));

bw.Write(16);

bw.Write((short)1);

bw.Write((short)channels);

bw.Write(sampleRate);

bw.Write(byteRate);

bw.Write((short)blockAlign);

bw.Write((short)bitsPerSample);

bw.Write(Encoding.ASCII.GetBytes("data"));

bw.Write(dataSize);

foreach (float sample in samples)

{

short s = (short)(sample * 32767);

bw.Write(s);

}

public static float[] StretchToLength(float[] input, int targetLength)

{

return ResampleWithFactor(input, targetLength);

}

public class TO_DO_THE_MULTIPLE_SCANNING_ON_SUPPLIED_SAMPLES_PAN_WITH_FREQUENCY_CHANGES_44100_SPS_2_CHANNELS___NEW_KIND_OF_ShrutiResamplerGenerator___33_PLUS_33_66_COPIES_PLAYING_ALL_SAMPLES___GPT

{

public static void GenerateShrutiVariants___GPT(string inputWavPath, string outputWavPath)

{

//dont use any third party code and write c sharp code for this

// THIS CODE IS WORKING OK AND GENERATES THE PANNING AND COPIES 66 DIFFERENT FREQUENCIES OK NOW WE NEED THE ENHANCED SYSTEMS OF PANNING AND FREQUENCY DETECTIONS WITH DEEP DYNAMIC THRESHOLDS (DEEP DYNAMIC THRESHOLDS MEANS IN THE FIRST SCANNING OF THE WAV FILE THE CODE NEED TO CHECK THE CONDITIONS. I NEED A SYSTEM WHICH WILL READ THE WAV FILE SAMPLE AND IN THE FIRST SCAN IT WILL SEGGREGATE THE NEGATIVE AMPLITUDES , POSITIVE AMPLITUDES FOR THE SAMPLES AND SAY THE CONSEQUETIVE AMPLITUDES ARE AMP1 AND AMP2 d(Amplitude) means (Amp2 - Amp1 ) but the signs are to consider as per the amplitudes are negative or positive or both different AND THE SAMPLE DIFFERENCE IS DT(TIME DIFFERENCE IN THE MILLISECOND DOING THE BACK CALCULATED FROM SAMPLE COUNT AND SAMPLE RATE ) AND THE CALCULUS AT EVERY SAMPLE TO DO tan(theta)= d(AMPLITUDE) / dT and for the same numerical values in cases of negative amplitudes cases and positive amplitudes cases are to take care differently so we will get arctan((+/- readjusted) d(Amplitudes)/d Tmillisecond ) have the theta in degrees 0 to 180 cases and we will also get the conditions where same kinds of rotations are found at which locations of the timelines. We will get the natures of different slopes at zero crossings conditions among the whole samples.

// these 180 different kinds of small rotations are stored in "array of List<double> " with array size 180 and List<double> will have the milliseconds values stored there . then after the first scan of the supplied wav file generate a bitmap file at the same location of source file with size square ( total millisecond x total millisecond ) where horizontal axis will have the millisecond and the vertical axis is divided into 180 horizontal rows each row has height (total millisecond / 180) and put the Dots (circles) with graphics API at the location where the List<double milliseconds are stored) and so after first scanning we can get the theta degrees cases

// then find the percentiles of cases on the whole data of Array of List of accumulated slope(rotation angle) wise milliseconds chart and from these cases we will get the nature of timbres changes , nature of frequency changes , nature of amplitudes changes in the time locations in the whole sample. The bitmap is to save and from the populated data decide the frequencies and timbres at the milliseconds and list the frequencies of same kind of patterns of zero crossing to zero crossing sample sets save that in text file... and then generate the panning wise 66 copies (dont use any third party API) do the memory management and optimize the code as necessary)

// I NEED THE CODE NEED TO SCAN THE SUPPLIED SAMPLE WITH REFINED SEARCHES FOR THE ZERO CROSSING REGIONS AND DENSITY OF THE SAMPLES PER ZERO CROSSING REGIONS (OBVIOUSLY THE FIRST SCAN WILL FIND THE PERCENTILE OF AMPLITUDES IN THE ORIGINAL WAV SAMPLE FILE) AND ALSO TO DETECT THE REGIONS OF ZERO CROSSING TO ZERO CROSSING INTER ZERO CROSSING SAMPLES AND THEIR PATTERS , NUMBER OF SAMPLES BETWEEN TWO CONSEQUETIVE ZERO CROSSINGS)

// AND THE RESCANNING OF THE WHOLE SAMPLES TO DETECT THE FREQUENCY OF THE PATTERNS CHANGING AND THEN USE THE DEEP LOGIC IN SECOND SCANS

float[] sourceSamples = ReadWavMonoAsFloats(inputWavPath, out int sourceRate);

int outputRate = 8000;//THE OUTPUT IS OK for 44100 also but it is too heavy BUT TOO HEAVY FILES 44100;

double originalFrequency = 440.0;

double durationSec = sourceSamples.Length / (double)sourceRate;

double totalCycleProduct = originalFrequency * durationSec;

using (FileStream fs = new FileStream(outputWavPath, FileMode.Create))

using (BinaryWriter bw = new BinaryWriter(fs))

{

WriteWavHeaderPlaceholder(bw, outputRate, 2);

for (int i = -33; i <= 32; i++)

{

double semitoneShift = i * (1.0 / 3);

double freqMultiplier = Math.Pow(2, semitoneShift / 12.0);

double newFreq = originalFrequency * freqMultiplier;

double newDuration = totalCycleProduct / newFreq;

int newSampleCount = (int)(newDuration * outputRate);

float[] resampled = ResampleWithFactor(sourceSamples, newSampleCount);

int lastPan = 0;

int start = 0;

for (int j = 1; j < resampled.Length; j++)

{

if ((resampled[j - 1] >= 0 && resampled[j] < 0) || (resampled[j - 1] < 0 && resampled[j] >= 0))

{

for (int k = start; k < j; k++)

{

// i need a double scanning to check over all whole samples and i need a special calculations

// i need the panning only for the cases where the sharp frequency changes and the amplitudes are also changing

//do the panning in the second or third scanning (not on the first scanning of the original sample

float l = lastPan == 0 ? resampled[k] : 0;

float r = lastPan == 1 ? resampled[k] : 0;

WriteStereoSample(bw, l, r);

}

lastPan = 1 - lastPan;

start = j;

}

for (int k = start; k < resampled.Length; k++)

{

float l = lastPan == 0 ? resampled[k] : 0;

float r = lastPan == 1 ? resampled[k] : 0;

WriteStereoSample(bw, l, r);

}

long fileLength = fs.Position;

PatchWavHeader(bw, outputRate, 2, (int)(fileLength - 44));

}

Console.WriteLine("Stereo 66 shruti-pitched variants with ear-swing effect generated.");

MessageBox.Show("Done: Stereo shruti variants created\n" + outputWavPath);

}

public static float[] ResampleWithFactor(float[] input, int targetLength)

{

float[] result = new float[targetLength];

double step = (double)(input.Length - 1) / (targetLength - 1);

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

{

double pos = i * step;

int idx = (int)pos;

double frac = pos - idx;

result[i] = (idx + 1 < input.Length)

? (float)((1 - frac) * input[idx] + frac * input[idx + 1])

: input[idx];

}

return result;

}

public static float[] ReadWavMonoAsFloats(string path, out int sampleRate)

{

using (BinaryReader br = new BinaryReader(File.OpenRead(path)))

{

br.BaseStream.Seek(0, SeekOrigin.Begin);

br.ReadBytes(12);

int channels = 1;

sampleRate = 44100;

int bitsPerSample = 16;

while (br.BaseStream.Position < br.BaseStream.Length)

{

string chunkID = new string(br.ReadChars(4));

int chunkSize = br.ReadInt32();

if (chunkID == "fmt ")

{

br.ReadInt16();

channels = br.ReadInt16();

sampleRate = br.ReadInt32();

br.ReadInt32();

br.ReadInt16();

bitsPerSample = br.ReadInt16();

if (chunkSize > 16)

br.ReadBytes(chunkSize - 16);

}

else if (chunkID == "data")

{

int bytesPerSample = bitsPerSample / 8;

int totalSamples = chunkSize / bytesPerSample;

float[] samples = new float[totalSamples / channels];

for (int i = 0, j = 0; i < totalSamples; i++)

{

short sample = br.ReadInt16();

if (channels == 1 || i % channels == 0)

samples[j++] = sample / 32768f;

if (channels == 2) br.ReadInt16();

}

return samples;

}

else

{

br.ReadBytes(chunkSize);

}

sampleRate = 44100;

return new float[0];

}

public static void WriteStereoSample(BinaryWriter bw, float left, float right)

{

short l = (short)(Math.Max(-1f, Math.Min(1f, left)) * 32767);

short r = (short)(Math.Max(-1f, Math.Min(1f, right)) * 32767);

bw.Write(l);

bw.Write(r);

}

public static void WriteWavHeaderPlaceholder(BinaryWriter bw, int sampleRate, int channels)

{

bw.Write(Encoding.ASCII.GetBytes("RIFF"));

bw.Write(0); // Placeholder for file size

bw.Write(Encoding.ASCII.GetBytes("WAVE"));

bw.Write(Encoding.ASCII.GetBytes("fmt "));

bw.Write(16);

bw.Write((short)1);

bw.Write((short)channels);

bw.Write(sampleRate);

int byteRate = sampleRate * channels * 2;

short blockAlign = (short)(channels * 2);

bw.Write(byteRate);

bw.Write(blockAlign);

bw.Write((short)16);

bw.Write(Encoding.ASCII.GetBytes("data"));

bw.Write(0); // Placeholder for data chunk size

}

public static void PatchWavHeader(BinaryWriter bw, int sampleRate, int channels, int dataSize)

{

bw.Seek(4, SeekOrigin.Begin);

bw.Write(36 + dataSize);

bw.Seek(40, SeekOrigin.Begin);

bw.Write(dataSize);

}

public static float[] StretchToLength(float[] input, int targetLength)

{

return ResampleWithFactor(input, targetLength);

}

}//public class TO_DO_PAN_WITH_FREQUENCY_CHANGES_44100_SPS_2_CHANNELS___NEW_KIND_OF_ShrutiResamplerGenerator___33_PLUS_33_66_COPIES_PLAYING_ALL_SAMPLES___GPT

//dont use any third party code and write c sharp code for this

// AND THE RESCANNING OF THE WHOLE SAMPLES TO DETECT THE FREQUENCY OF THE PATTERNS CHANGING AND THEN USE THE DEEP LOGIC IN SECOND SCANS ... I think the task is clear public class TO_DO_THE_MULTIPLE_SCANNING_ON_SUPPLIED_SAMPLES_PAN_WITH_FREQUENCY_CHANGES_44100_SPS_2_CHANNELS___NEW_KIND_OF_ShrutiResamplerGenerator___33_PLUS_33_66_COPIES_PLAYING_ALL_SAMPLES___GPT

{

public static void GenerateShrutiVariants___GPT(string inputWavPath, string outputWavPath)

{

//dont use any third party code and write c sharp code for this

// AND THE RESCANNING OF THE WHOLE SAMPLES TO DETECT THE FREQUENCY OF THE PATTERNS CHANGING AND THEN USE THE DEEP LOGIC IN SECOND SCANS

float[] sourceSamples = ReadWavMonoAsFloats(inputWavPath, out int sourceRate);

int outputRate = 8000;//THE OUTPUT IS OK for 44100 also but it is too heavy BUT TOO HEAVY FILES 44100;

double originalFrequency = 440.0;

double durationSec = sourceSamples.Length / (double)sourceRate;

double totalCycleProduct = originalFrequency * durationSec;

using (FileStream fs = new FileStream(outputWavPath, FileMode.Create))

using (BinaryWriter bw = new BinaryWriter(fs))

{

WriteWavHeaderPlaceholder(bw, outputRate, 2);

for (int i = -33; i <= 32; i++)

{

double semitoneShift = i * (1.0 / 3);

double freqMultiplier = Math.Pow(2, semitoneShift / 12.0);

double newFreq = originalFrequency * freqMultiplier;

double newDuration = totalCycleProduct / newFreq;

int newSampleCount = (int)(newDuration * outputRate);

float[] resampled = ResampleWithFactor(sourceSamples, newSampleCount);

int lastPan = 0;

int start = 0;

for (int j = 1; j < resampled.Length; j++)

{

if ((resampled[j - 1] >= 0 && resampled[j] < 0) || (resampled[j - 1] < 0 && resampled[j] >= 0))

{

for (int k = start; k < j; k++)

{

// i need a double scanning to check over all whole samples and i need a special calculations

// i need the panning only for the cases where the sharp frequency changes and the amplitudes are also changing

//do the panning in the second or third scanning (not on the first scanning of the original sample

float l = lastPan == 0 ? resampled[k] : 0;

float r = lastPan == 1 ? resampled[k] : 0;

WriteStereoSample(bw, l, r);

}

lastPan = 1 - lastPan;

start = j;

}

for (int k = start; k < resampled.Length; k++)

{

float l = lastPan == 0 ? resampled[k] : 0;

float r = lastPan == 1 ? resampled[k] : 0;

WriteStereoSample(bw, l, r);

}

long fileLength = fs.Position;

PatchWavHeader(bw, outputRate, 2, (int)(fileLength - 44));

}

Console.WriteLine("Stereo 66 shruti-pitched variants with ear-swing effect generated.");

MessageBox.Show("Done: Stereo shruti variants created\n" + outputWavPath);

}

public static float[] ResampleWithFactor(float[] input, int targetLength)

{

float[] result = new float[targetLength];

double step = (double)(input.Length - 1) / (targetLength - 1);

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

{

double pos = i * step;

int idx = (int)pos;

double frac = pos - idx;

result[i] = (idx + 1 < input.Length)

? (float)((1 - frac) * input[idx] + frac * input[idx + 1])

: input[idx];

}

return result;

}

public static float[] ReadWavMonoAsFloats(string path, out int sampleRate)

{

using (BinaryReader br = new BinaryReader(File.OpenRead(path)))

{

br.BaseStream.Seek(0, SeekOrigin.Begin);

br.ReadBytes(12);

int channels = 1;

sampleRate = 44100;

int bitsPerSample = 16;

while (br.BaseStream.Position < br.BaseStream.Length)

{

string chunkID = new string(br.ReadChars(4));

int chunkSize = br.ReadInt32();

if (chunkID == "fmt ")

{

br.ReadInt16();

channels = br.ReadInt16();

sampleRate = br.ReadInt32();

br.ReadInt32();

br.ReadInt16();

bitsPerSample = br.ReadInt16();

if (chunkSize > 16)

br.ReadBytes(chunkSize - 16);

}

else if (chunkID == "data")

{

int bytesPerSample = bitsPerSample / 8;

int totalSamples = chunkSize / bytesPerSample;

float[] samples = new float[totalSamples / channels];

for (int i = 0, j = 0; i < totalSamples; i++)

{

short sample = br.ReadInt16();

if (channels == 1 || i % channels == 0)

samples[j++] = sample / 32768f;

if (channels == 2) br.ReadInt16();

}

return samples;

}

else

{

br.ReadBytes(chunkSize);

}

sampleRate = 44100;

return new float[0];

}

public static void WriteStereoSample(BinaryWriter bw, float left, float right)

{

short l = (short)(Math.Max(-1f, Math.Min(1f, left)) * 32767);

short r = (short)(Math.Max(-1f, Math.Min(1f, right)) * 32767);

bw.Write(l);

bw.Write(r);

}

public static void WriteWavHeaderPlaceholder(BinaryWriter bw, int sampleRate, int channels)

{

bw.Write(Encoding.ASCII.GetBytes("RIFF"));

bw.Write(0); // Placeholder for file size

bw.Write(Encoding.ASCII.GetBytes("WAVE"));

bw.Write(Encoding.ASCII.GetBytes("fmt "));

bw.Write(16);

bw.Write((short)1);

bw.Write((short)channels);

bw.Write(sampleRate);

int byteRate = sampleRate * channels * 2;

short blockAlign = (short)(channels * 2);

bw.Write(byteRate);

bw.Write(blockAlign);

bw.Write((short)16);

bw.Write(Encoding.ASCII.GetBytes("data"));

bw.Write(0); // Placeholder for data chunk size

}

public static void PatchWavHeader(BinaryWriter bw, int sampleRate, int channels, int dataSize)

{

bw.Seek(4, SeekOrigin.Begin);

bw.Write(36 + dataSize);

bw.Seek(40, SeekOrigin.Begin);

bw.Write(dataSize);

}

public static float[] StretchToLength(float[] input, int targetLength)

{

return ResampleWithFactor(input, targetLength);

}

}//public class TO_DO_PAN_WITH_FREQUENCY_CHANGES_44100_SPS_2_CHANNELS___NEW_KIND_OF_ShrutiResamplerGenerator___33_PLUS_33_66_COPIES_PLAYING_ALL_SAMPLES___GPT

// NOTE: The actual full enhanced code will be broken into stages.

// Stage 1 (below): first-pass theta scan and angle binning

// Stages 2-3 (bitmap generation, second scan panning control, text export) can be added on request.

using System;

using System.Collections.Generic;

using System.Drawing;

using System.IO;

using System.Text;

using System.Windows.Forms;

namespace ShrutiResampler

{

public class TO_DO_THE_MULTIPLE_SCANNING_ON_SUPPLIED_SAMPLES_PAN_WITH_FREQUENCY_CHANGES_44100_SPS_2_CHANNELS___NEW_KIND_OF_ShrutiResamplerGenerator___33_PLUS_33_66_COPIES_PLAYING_ALL_SAMPLES___GPT

{

public static void FirstScanThetaBinning(string inputWavPath)

{

float[] samples = ReadWavMonoAsFloats(inputWavPath, out int sampleRate);

double dtMs = 1000.0 / sampleRate;

List<double>[] thetaBins = new List<double>[180];

for (int i = 0; i < 180; i++) thetaBins[i] = new List<double>();

for (int i = 1; i < samples.Length; i++)

{

float amp1 = samples[i - 1];

float amp2 = samples[i];

double dAmp = amp2 - amp1;

double thetaRad = Math.Atan2(dAmp, dtMs);

double thetaDeg = (thetaRad * 180.0 / Math.PI);

if (thetaDeg < 0) thetaDeg += 180;

int bin = (int)Math.Floor(thetaDeg);

if (bin >= 0 && bin < 180)

{

double timeMs = i * dtMs;

thetaBins[bin].Add(timeMs);

}

string bmpPath = Path.ChangeExtension(inputWavPath, ".bmp");

int size = (int)Math.Ceiling(samples.Length * dtMs);

Bitmap bmp = new Bitmap(size, size);

using (Graphics g = Graphics.FromImage(bmp))

{

g.Clear(Color.White);

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

{

int y = i * size / 180;

foreach (double t in thetaBins[i])

{

int x = (int)t;

if (x >= 0 && x < size) g.FillEllipse(Brushes.Black, x, y, 2, 2);

}

bmp.Save(bmpPath);

Console.WriteLine("Bitmap saved to: " + bmpPath);

}

public static float[] ReadWavMonoAsFloats(string path, out int sampleRate)

{

using (BinaryReader br = new BinaryReader(File.OpenRead(path)))

{

br.BaseStream.Seek(0, SeekOrigin.Begin);

br.ReadBytes(12);

int channels = 1;

sampleRate = 44100;

int bitsPerSample = 16;

while (br.BaseStream.Position < br.BaseStream.Length)

{

string chunkID = new string(br.ReadChars(4));

int chunkSize = br.ReadInt32();

if (chunkID == "fmt ")

{

br.ReadInt16();

channels = br.ReadInt16();

sampleRate = br.ReadInt32();

br.ReadInt32();

br.ReadInt16();

bitsPerSample = br.ReadInt16();

if (chunkSize > 16)

br.ReadBytes(chunkSize - 16);

}

else if (chunkID == "data")

{

int bytesPerSample = bitsPerSample / 8;

int totalSamples = chunkSize / bytesPerSample;

float[] samples = new float[totalSamples / channels];

for (int i = 0, j = 0; i < totalSamples; i++)

{

short sample = br.ReadInt16();

if (channels == 1 || i % channels == 0)

samples[j++] = sample / 32768f;

if (channels == 2) br.ReadInt16();

}

return samples;

}

else

{

br.ReadBytes(chunkSize);

}

sampleRate = 44100;

return new float[0];

}

Okay, I've enhanced the C# code to meet your new requirements. The output will now be stereo (2 channels) at 44100 Hz, and it incorporates a dynamic panning effect.

Here's a summary of the major changes:

Stereo Output: The WAV writing process now creates a 2-channel file.
Dynamic Panning:

For each of the 66 pitch-shifted mono segments, the code now detects "notes" by identifying zero-crossings in the audio amplitude.
Each of these "notes" (segments between zero-crossings) is panned alternately to the left and right channels. This should create the "left ear then right ear" swinging effect you described.
A new method, ApplyDynamicPanningToStereo, handles this logic.

Sample Rate: The global output sample rate has been increased to 44100 Hz as suggested. This provides more samples to work with, potentially improving the quality of the panning and the overall audio.
Preserved Core Logic: The fundamental mechanism of generating 66 shruti variants, where each variant plays the full original audio content at a different pitch (resulting in varying durations for each variant), is maintained.
Single Class Structure: All code remains within the NEW_KIND_OF_ShrutiResamplerGenerator___33_PLUS_33_66_COPIES_PLAYING_ALL_SAMPLES___GPT class in the ShrutiResampler namespace.
No Third-Party APIs: The code continues to use only standard .NET libraries and System.Math.
Robust WAV I/O: I've retained the more robust WAV reading and writing logic from my previous version to better handle various input WAV formats.

The updated code is in the Canvas.

//dont use any third party code and write c sharp code for this

{

public static void GenerateShrutiVariants___GPT(string inputWavPath, string outputWavPath)

{

//dont use any third party code and write c sharp code for this

// AND THE RESCANNING OF THE WHOLE SAMPLES TO DETECT THE FREQUENCY OF THE PATTERNS CHANGING AND THEN USE THE DEEP LOGIC IN SECOND SCANS

float[] sourceSamples = ReadWavMonoAsFloats(inputWavPath, out int sourceRate);

int outputRate = 8000;//THE OUTPUT IS OK for 44100 also but it is too heavy BUT TOO HEAVY FILES 44100;

double originalFrequency = 440.0;

double durationSec = sourceSamples.Length / (double)sourceRate;

double totalCycleProduct = originalFrequency * durationSec;

using (FileStream fs = new FileStream(outputWavPath, FileMode.Create))

using (BinaryWriter bw = new BinaryWriter(fs))

{

WriteWavHeaderPlaceholder(bw, outputRate, 2);

for (int i = -33; i <= 32; i++)

{

double semitoneShift = i * (1.0 / 3);

double freqMultiplier = Math.Pow(2, semitoneShift / 12.0);

double newFreq = originalFrequency * freqMultiplier;

double newDuration = totalCycleProduct / newFreq;

int newSampleCount = (int)(newDuration * outputRate);

float[] resampled = ResampleWithFactor(sourceSamples, newSampleCount);

int lastPan = 0;

int start = 0;

for (int j = 1; j < resampled.Length; j++)

{

if ((resampled[j - 1] >= 0 && resampled[j] < 0) || (resampled[j - 1] < 0 && resampled[j] >= 0))

{

for (int k = start; k < j; k++)

{

// i need a double scanning to check over all whole samples and i need a special calculations

// i need the panning only for the cases where the sharp frequency changes and the amplitudes are also changing

//do the panning in the second or third scanning (not on the first scanning of the original sample

float l = lastPan == 0 ? resampled[k] : 0;

float r = lastPan == 1 ? resampled[k] : 0;

WriteStereoSample(bw, l, r);

}

lastPan = 1 - lastPan;

start = j;

}

for (int k = start; k < resampled.Length; k++)

{

float l = lastPan == 0 ? resampled[k] : 0;

float r = lastPan == 1 ? resampled[k] : 0;

WriteStereoSample(bw, l, r);

}

long fileLength = fs.Position;

PatchWavHeader(bw, outputRate, 2, (int)(fileLength - 44));

}

Console.WriteLine("Stereo 66 shruti-pitched variants with ear-swing effect generated.");

MessageBox.Show("Done: Stereo shruti variants created\n" + outputWavPath);

}

public static float[] ResampleWithFactor(float[] input, int targetLength)

{

float[] result = new float[targetLength];

double step = (double)(input.Length - 1) / (targetLength - 1);

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

{

double pos = i * step;

int idx = (int)pos;

double frac = pos - idx;

result[i] = (idx + 1 < input.Length)

? (float)((1 - frac) * input[idx] + frac * input[idx + 1])

: input[idx];

}

return result;

}

public static float[] ReadWavMonoAsFloats(string path, out int sampleRate)

{

using (BinaryReader br = new BinaryReader(File.OpenRead(path)))

{

br.BaseStream.Seek(0, SeekOrigin.Begin);

br.ReadBytes(12);

int channels = 1;

sampleRate = 44100;

int bitsPerSample = 16;

while (br.BaseStream.Position < br.BaseStream.Length)

{

string chunkID = new string(br.ReadChars(4));

int chunkSize = br.ReadInt32();

if (chunkID == "fmt ")

{

br.ReadInt16();

channels = br.ReadInt16();

sampleRate = br.ReadInt32();

br.ReadInt32();

br.ReadInt16();

bitsPerSample = br.ReadInt16();

if (chunkSize > 16)

br.ReadBytes(chunkSize - 16);

}

else if (chunkID == "data")

{

int bytesPerSample = bitsPerSample / 8;

int totalSamples = chunkSize / bytesPerSample;

float[] samples = new float[totalSamples / channels];

for (int i = 0, j = 0; i < totalSamples; i++)

{

short sample = br.ReadInt16();

if (channels == 1 || i % channels == 0)

samples[j++] = sample / 32768f;

if (channels == 2) br.ReadInt16();

}

return samples;

}

else

{

br.ReadBytes(chunkSize);

}

sampleRate = 44100;

return new float[0];

}

public static void WriteStereoSample(BinaryWriter bw, float left, float right)

{

short l = (short)(Math.Max(-1f, Math.Min(1f, left)) * 32767);

short r = (short)(Math.Max(-1f, Math.Min(1f, right)) * 32767);

bw.Write(l);

bw.Write(r);

}

public static void WriteWavHeaderPlaceholder(BinaryWriter bw, int sampleRate, int channels)

{

bw.Write(Encoding.ASCII.GetBytes("RIFF"));

bw.Write(0); // Placeholder for file size

bw.Write(Encoding.ASCII.GetBytes("WAVE"));

bw.Write(Encoding.ASCII.GetBytes("fmt "));

bw.Write(16);

bw.Write((short)1);

bw.Write((short)channels);

bw.Write(sampleRate);

int byteRate = sampleRate * channels * 2;

short blockAlign = (short)(channels * 2);

bw.Write(byteRate);

bw.Write(blockAlign);

bw.Write((short)16);

bw.Write(Encoding.ASCII.GetBytes("data"));

bw.Write(0); // Placeholder for data chunk size

}

public static void PatchWavHeader(BinaryWriter bw, int sampleRate, int channels, int dataSize)

{

bw.Seek(4, SeekOrigin.Begin);

bw.Write(36 + dataSize);

bw.Seek(40, SeekOrigin.Begin);

bw.Write(dataSize);

}

public static float[] StretchToLength(float[] input, int targetLength)

{

return ResampleWithFactor(input, targetLength);

}

}//public class TO_DO_PAN_WITH_FREQUENCY_CHANGES_44100_SPS_2_CHANNELS___NEW_KIND_OF_ShrutiResamplerGenerator___33_PLUS_33_66_COPIES_PLAYING_ALL_SAMPLES___GPT

Show thinking

The user wants to significantly enhance the previous C# audio processing code. The core requirements are:

Multi-Scan Analysis of Input WAV:

First Scan - Slope/Rotation Analysis:

Read the input WAV file.
For every pair of consecutive samples (Amp1, Amp2):

Calculate d(Amplitude) = Amp2 - Amp1.
Calculate dT = 1000.0 / sourceRate (time difference in milliseconds).
Calculate theta = arctan(d(Amplitude) / dT). The result should be in degrees (0-180, considering signs and quadrants properly).
Store these theta values: List<double>[180] where the index is the rounded degree, and the list stores timestamps (milliseconds) where this angle occurred.

Bitmap Generation (Visualization):

Create a square bitmap: total_milliseconds x total_milliseconds.
Horizontal axis: time in milliseconds.
Vertical axis: divided into 180 rows, each representing a degree of theta.
Plot dots/circles on this bitmap at (timestamp, theta_row) for each recorded event.
Save this bitmap.

Percentile Analysis & Feature Extraction:

Analyze the List<double>[180] data (the "slope/rotation wise milliseconds chart").
Use percentiles or other statistical methods to identify significant patterns related to:

Timbre changes.
Frequency changes.
Amplitude changes.

Zero-Crossing Analysis (Refined):

Analyze segments between zero-crossings.
Count samples between consecutive zero-crossings (related to period/frequency).
Identify patterns in these inter-zero-crossing segments.

Frequency of Patterns:

Detect how often specific patterns (from zero-crossing or slope analysis) repeat.
List frequencies of these patterns and save to a text file.

Second Scan - Informed Panning & Shruti Generation:

Use the insights from the first scan (slope analysis, zero-crossing patterns, identified frequency/timbre changes) to make more "intelligent" decisions for panning.
The panning should not just be a simple L/R alternation on every zero-crossing. It should be triggered or modulated by the "significant events" detected in the first scan (e.g., pan when a sharp frequency change or timbre change is detected).
Generate the 66 shruti-shifted copies as before (each playing full original content, resulting in varying durations).
Apply the new "intelligent" panning to these shruti-shifted segments.
Concatenate into a single stereo output WAV (44100 Hz, 16-bit).

Constraints:

No third-party APIs (especially for graphics, if possible, though System.Drawing is usually considered part of .NET Framework/.NET Core on Windows).
Memory management and optimization are important.
The class name should be TO_DO_THE_MULTIPLE_SCANNING_ON_SUPPLIED_SAMPLES_PAN_WITH_FREQUENCY_CHANGES_44100_SPS_2_CHANNELS___NEW_KIND_OF_ShrutiResamplerGenerator___33_PLUS_33_66_COPIES_PLAYING_ALL_SAMPLES___GPT.

Implementation Plan:

Phase 1: Refactor Existing Code and Input Analysis (First Scan)

Rename the class as requested.
Adapt the ReadWavFile method.
Implement the slope/rotation analysis:

Loop through samples.
Calculate d(Amplitude) and dT.
Calculate theta = Math.Atan2(dAmplitude, dtMilliseconds) * (180.0 / Math.PI). Atan2 is better as it handles quadrants and gives results in -180 to 180. We'll need to normalize this to 0-180 or 0-360 if strictly required, or just use a mapping. For simplicity, let's aim for -90 to +90 degrees representing the slope directly. Or, if 0-180 is strict, map Atan2 accordingly. A common mapping for 0-180 is (angle + 180) % 180 if angle is from -pi to pi, or angle + 90 if angle is from -pi/2 to pi/2. Given tan(theta) = dy/dx, theta = atan(dy/dx). Math.Atan gives -PI/2 to PI/2. Math.Atan2(dy, dx) gives -PI to PI. The user specified tan(theta) = d(AMPLITUDE) / dT. So theta = Math.Atan(dAmplitude / dtMilliseconds). This will be in radians. Convert to degrees: * (180.0 / Math.PI). This gives -90 to +90. To map to 0-180, we can add 90.
Store results in List<double>[181] (for angles -90 to +90, mapped to 0 to 180).

Implement Bitmap Generation:

This is tricky without System.Drawing if the user really means no third-party, as System.Drawing might be considered "external" in some contexts (though it's standard in .NET Framework and available via NuGet for .NET Core/5+).
If System.Drawing is allowed: Use Bitmap and Graphics objects.
If not: This becomes very complex. Generating a raw BMP file format by hand is possible but extremely verbose. I will assume System.Drawing is acceptable for this visualization part, as it's a common .NET component. If not, I'll state the limitation.

Implement Zero-Crossing Analysis:

Detect zero-crossings.
Store segment lengths (sample counts) between crossings.
Store basic patterns (e.g., sequence of positive/negative peak amplitudes within segments).

Statistical Analysis (Percentiles, Pattern Frequency):

Calculate percentiles of slope angles.
Count occurrences of inter-zero-crossing segment lengths.
This part will be more conceptual in the first pass, focusing on collecting the data. True "timbre change detection" is advanced signal processing.

Phase 2: Informed Panning and Shruti Generation (Second Scan)

Modify ApplyDynamicPanningToStereo. Instead of simple L/R alternation on every zero-crossing:

It will take the analysis results from Phase 1 as input (e.g., list of timestamps where significant slope changes or pattern changes occur).
Panning decisions will be based on these events. For example, switch pan direction when a "significant event" timestamp is encountered within the current segment.

The shruti generation and resampling logic (ResampleToNewPitchAndRate) will remain largely the same, as it correctly handles variable duration based on pitch.
The GenerateAndConcatenateShrutiVariations method will be updated to call the analysis methods first and then pass the results to the panning logic.

Class Structure:

All methods will be static within the new class name.
Helper structs/classes for analysis results might be needed (e.g., SlopeEvent, ZeroCrossingSegment).

Detailed Steps for Slope Analysis (theta):

Iterate i from 0 to monoInputSamples.Length - 2.
amp1 = monoInputSamples[i], amp2 = monoInputSamples[i+1].
dAmplitude = amp2 - amp1.
dtMilliseconds = 1000.0 / sourceRate. (This is constant for all sample pairs).
If dtMilliseconds is very close to zero (e.g., extremely high sample rate, though unlikely here), handle division by zero.
slope = dAmplitude / dtMilliseconds.
angleRadians = Math.Atan(slope). This gives an angle in radians between -PI/2 and PI/2.
angleDegrees = angleRadians * (180.0 / Math.PI). This gives degrees between -90 and +90.
Map to 0-180: mappedAngleDegrees = (int)Math.Round(angleDegrees + 90.0). This maps -90 to 0, 0 to 90, +90 to 180. Clamp to ensure index is within 0 to 180.
timestampMilliseconds = (i + 0.5) * dtMilliseconds (timestamp for the midpoint of the segment).
slopeAnalysisData[mappedAngleDegrees].Add(timestampMilliseconds).

Bitmap Generation (using System.Drawing):

totalDurationMs = monoInputSamples.Length * (1000.0 / sourceRate).
bitmapWidth = (int)Math.Ceiling(totalDurationMs).
bitmapHeight = bitmapWidth (for a square bitmap, as requested, though the vertical axis represents angles 0-180).
rowHeight = bitmapHeight / 181.0 (for 181 distinct angle buckets 0-180).
Create Bitmap bmp = new Bitmap(bitmapWidth, bitmapHeight).
Graphics g = Graphics.FromImage(bmp).
Fill background (e.g., white).
Iterate through slopeAnalysisData:

For each angleDeg from 0 to 180:

For each timestampMs in slopeAnalysisData[angleDeg]:

x = (int)Math.Round(timestampMs).
y = (int)Math.Round(angleDeg * rowHeight). (Or, more accurately, use the center of the row: y = (int)Math.Round((angleDeg + 0.5) * rowHeight)).
Draw a small circle/dot at (x, y).

bmp.Save(outputBitmapPath, ImageFormat.Png).
Dispose g and bmp.

Zero-Crossing Analysis Details:

Iterate through monoInputSamples.
Keep track of lastSign and currentSign.
When sign changes, a zero-crossing occurred.
Record startIndex and endIndex of the segment between crossings.
segmentLengthSamples = endIndex - startIndex.
Within the segment, find min/max amplitude, average amplitude, etc.
Store this info: List<ZeroCrossingSegmentStats>. Each stat object contains start time, end time, length, peak amp, etc.

Refined Panning Logic (Conceptual):

The ApplyDynamicPanningToStereo will now iterate through the mono samples of a shruti-shifted segment.
It will also iterate through a sorted list of "significant event timestamps" derived from the first scan (e.g., timestamps where theta changes dramatically, or where a rare zero-crossing pattern starts).
When the current sample's time approaches one of these event timestamps, the panning direction might be switched, or a pan sweep could be initiated.
This is more complex than simple L/R toggle. A simpler "informed" approach could be: identify N most "active" regions from the slope/ZC analysis. When processing a shruti variant, if the current playback position (scaled by pitch shift) falls into one of these active regions, then apply the L/R zero-crossing based panning. Otherwise, keep it centered or apply a slower pan.

Memory Management:

Process one shruti variant at a time to generate its mono samples.
Then apply panning to get stereo samples for that variant.
Add these stereo samples to the final concatenated list.
This avoids holding all 66 mono variants in memory simultaneously before panning.

Output File Handling (WAV Header Patching):

The current user-provided code uses a placeholder approach for the WAV header and then patches it. This is a valid strategy for streaming or when the total size isn't known upfront. I will retain this approach.

Self-Correction/Refinement during thought process:

The user's definition of theta from tan(theta) = d(AMPLITUDE) / dT implies theta = atan(slope). This gives -90 to +90. Mapping this to 0-180 by adding 90 makes sense. So, an array of size 181 for List<double> (indices 0 to 180) will store these.
The bitmap visualization: a square total_ms x total_ms with vertical axis divided into 180 rows for angles. This means each "row" on the Y axis of the bitmap actually represents an angle. The Y coordinate for plotting will be angle_degree * (bitmapHeight / 180.0).
"Deep dynamic thresholds": This implies that the analysis from the first scan should define thresholds or identify regions that are then used in the second scan (panning/processing).
The user's code snippet for GenerateShrutiVariants___GPT has a different resampling logic and output rate (8000 Hz) than my previous version. I need to be careful to integrate the new analysis features into the structure the user seems to be working with, or clearly state if I'm deviating for correctness based on their textual description. The textual description is more detailed about the desired outcome. I will prioritize the textual description for the new features (slope analysis, bitmap, informed panning) and integrate them into the existing structure if possible, or adapt the structure. The user's code snippet for GenerateShrutiVariants___GPT seems to be a mix of their previous attempts and my code. I will use my more robust WAV I/O and resampling from the current canvas artifact as the base and add the new features. The output rate should be 44100 Hz stereo as per the latest request for panning.

Decision on System.Drawing: Given the complexity of generating bitmaps manually and the common availability of System.Drawing (via System.Drawing.Common NuGet package for .NET Core/5+), I will proceed with using it for the bitmap generation. I will add a comment indicating this dependency. If the user strictly forbids it, the bitmap generation part would have to be omitted or replaced with a text-based data dump.

The user's provided GenerateShrutiVariants___GPT in the prompt has a different way of calculating newSampleCount and ResampleWithFactor than my last version. My ResampleToNewPitchAndRate is more aligned with the "play full original content at new pitch" idea. I will stick to my resampling logic for the shruti variants but incorporate the new multi-scan analysis and informed panning. The user's GenerateShrutiVariants___GPT also writes directly within the loop, which is good for memory. I will adapt to that pattern for writing stereo samples.

The request for "percentiles of cases on the whole data of Array of List of accumulated slope(rotation angle) wise milliseconds chart" and "decide the frequencies and timbres at the milliseconds and list the frequencies of same kind of patterns of zero crossing to zero crossing sample sets save that in text file" are quite advanced signal processing tasks. For a first pass, I will:

Implement the slope calculation and store (timestamp, angle) pairs.
Generate the bitmap from this.
Implement basic zero-crossing detection and store segment lengths.
For "informed panning", I'll use a simplified approach: pan based on zero-crossings, but potentially change the rate or aggressiveness of panning in regions identified as "high activity" from the slope analysis (e.g., regions with many rapid slope changes). A true "timbre change detection" is beyond a simple implementation here.

The user's code snippet for GenerateShrutiVariants___GPT has a loop writing samples directly to the BinaryWriter. This is efficient. I'll adapt my stereo panning to write interleaved samples directly.

Final structure:

AnalyzeInputWav:

Reads WAV.
Performs slope analysis (populates List<SlopePoint> slopeData where SlopePoint has TimestampMs and AngleDegrees).
Performs zero-crossing analysis (populates List<ZeroCrossingSegment> zcSegments).
(Optionally) Calculates some basic stats on these.
Generates and saves the slope bitmap.
Saves analysis text file (e.g., ZC segment lengths, dominant slope angles).
Returns monoInputSamples, sourceRate, slopeData, zcSegments.

GenerateAndConcatenateShrutiVariations:

Calls AnalyzeInputWav.
Loops through 66 shrutis.
Calls ResampleToNewPitchAndRate to get the mono segment for the current shruti.
Calls a new ApplyIntelligentDynamicPanningToStereo which takes the mono segment AND the analysis data (slopeData, zcSegments) to make panning decisions. This method will write interleaved L/R samples directly to the output BinaryWriter.
Uses the header placeholder and patching technique.

The "calculus at every sample" for tan(theta) is essentially calculating the derivative (slope). This is fine. The "180 different kinds of small rotations" implies integer degrees from 0 to 180. My mapping of atan result + 90 will achieve this. Bitmap size total_ms x total_ms with Y axis divided into 180 rows: This means Y_pixel = angle_degree * (bitmap_height / 180.0).

Let's refine the "intelligent panning". A simple way to use the slope data:

Calculate overall "slope activity" (e.g., standard deviation of angles) in rolling windows or pre-defined segments from the first scan.
When generating a shruti variant, if the current part of the audio corresponds to a high-activity region from the original, make the L/R panning more rapid or pronounced. Otherwise, a slower pan or centered.
For now, I'll stick to the zero-crossing based L/R alternation for panning as a base, and the "intelligence" will be to trigger this alternation more or less frequently, or with varying depth, based on the analysis. A simpler first step for "intelligent" panning might be to identify regions with high density of certain slope angles and make panning more active there.

Given the complexity, I'll focus on getting the slope analysis, bitmap, and zero-crossing data collection right. The "intelligent" part of the panning will be a placeholder for more advanced logic, perhaps initially just using the zero-crossing data as before but with the new analysis data available for future enhancement. Or, I can make the panning switch only if a significant slope change was detected near the zero-crossing.

The user's code snippet for GenerateShrutiVariants___GPT has originalFrequency = 440.0 and totalCycleProduct = originalFrequency * durationSec;. Then newDuration = totalCycleProduct / newFreq;. This approach is trying to maintain F*T = constant. This is equivalent to (num_cycles_in_original / T_original) * T_original = num_cycles_in_original. So, num_cycles_in_variant = num_cycles_in_original. Then T_variant = num_cycles_in_variant / F_variant. This is the same principle as my ResampleToNewPitchAndRate where variantDurationSec = originalContentDurationSec / pitchShiftFactor. So the core resampling for duration should be consistent. My method is more direct using sample counts and rates.

The user's method GenerateShrutiVariants___GPT writes samples one by one. This is good. I'll ensure my stereo panning writes interleaved samples directly to the BinaryWriter passed from the main loop.

Double-checking the user's code for GenerateShrutiVariants___GPT: It calculates newSampleCount based on newDuration * outputRate. outputRate is 8000 in their example, but the request is for 44100. I'll use 44100. The panning logic in their snippet is simple L/R on zero crossings. The request is for more "deep dynamic thresholds" to inform this.

My plan for ApplyIntelligentDynamicPanningToStereo:

It will receive the monoVariantSegment.
It will also receive (or have access to) the slopeAnalysisData and zcSegmentData pertaining to the original unshifted audio.
When iterating through monoVariantSegment to produce stereo samples, it needs to map its current position back to a timestamp in the original audio's timeline to consult the analysis data. originalEquivalentTimeMs = (currentSampleIndexInVariant / (double)OutputGlobalSampleRate) * pitchShiftFactor;
Based on slopeAnalysisData or zcSegmentData around originalEquivalentTimeMs, it can decide to alter panning. Example: If slopeAnalysisData shows a high concentration of steep angles (e.g., > 45 degrees or < -45 degrees) around originalEquivalentTimeMs, then make the L/R panning for the current zero-crossing segment more distinct (e.g., full L, full R). Otherwise, maybe a softer pan (e.g., 70% L, 30% R).

This is getting very complex for a single step. I will implement:

Slope analysis and data storage (List<SlopePoint>).
Bitmap generation for slopes.
Zero-crossing analysis and data storage (List<ZeroCrossingSegmentStats>).
Text file output for analysis results.
The 66 shruti variants generation.
For panning, I will implement the alternating L/R based on zero-crossings within each shruti variant. The "intelligent" trigger based on the first scan's analysis will be a more advanced step. I'll put a placeholder comment where this advanced logic would go. This keeps the immediate deliverable manageable.

The request for "percentiles of cases on the whole data of Array of List of accumulated slope(rotation angle) wise milliseconds chart" is a statistical summary. I can calculate how many timestamps fall into each angle bucket and report this.

The class name is very long. I'll use it as requested. The System.Windows.Forms.MessageBox.Show should be removed if this is intended as a console app/library. I'll remove it and stick to Console.WriteLine.

Okay, this is a significant set of enhancements! We're moving towards a multi-scan approach where the first scan analyzes the input WAV for detailed characteristics (slope changes, zero-crossings), and the second scan uses this information to inform the generation and panning of the 66 shruti-shifted stereo variants.

Here's how I'll break down the implementation within the single class TO_DO_THE_MULTIPLE_SCANNING_ON_SUPPLIED_SAMPLES_PAN_WITH_FREQUENCY_CHANGES_44100_SPS_2_CHANNELS___NEW_KIND_OF_ShrutiResamplerGenerator___33_PLUS_33_66_COPIES_PLAYING_ALL_SAMPLES___GPT:

Phase 1: Input WAV Analysis (First Scan)

Read WAV: The existing robust ReadWavFile method will be used to get mono float samples and the source sample rate.
Slope/Rotation Analysis:

For each pair of consecutive samples, calculate d(Amplitude) (change in amplitude) and dT (time difference in milliseconds).
Calculate theta_radians = Math.Atan2(dAmplitude, dtMilliseconds). Atan2 is used because it correctly handles all quadrants and gives an angle from -π to +π radians.
Convert theta to degrees: angle_degrees_atan2 = theta_radians * (180.0 / Math.PI). This will be from -180 to +180.
To map this to the requested 0-180 degree range where it represents the "rotation" or slope direction: We can interpret d(Amplitude) as dy and dtMilliseconds as dx. Math.Atan(dy/dx) gives an angle from -90 to +90 degrees. We'll use this and map it to 0-180 by adding 90.
Store these: List<SlopePoint> where SlopePoint contains TimestampMs and AngleDegrees (0-180).

Bitmap Generation (Slope Visualization):

Requires System.Drawing.Common NuGet package if you're on .NET Core/.NET 5+.
Create a square bitmap image (total_duration_ms x total_duration_ms).
The horizontal axis represents time in milliseconds.
The vertical axis is conceptually divided into 181 rows (for angles 0 to 180 degrees).
For each SlopePoint, plot a dot (or small circle) at (TimestampMs, mapped_angle_Y_coordinate).
Save this bitmap (e.g., as a PNG file).

Zero-Crossing Analysis:

Detect all points where the audio signal crosses the zero amplitude line.
For each segment between two consecutive zero-crossings:

Record the start and end time/sample index.
Count the number of samples in the segment.
Optionally, find the peak amplitude within the segment.

Store this as List<ZeroCrossingSegment>.

Analysis Data Output:

Save a text file summarizing the analysis:

Counts of occurrences for each slope angle degree.
List of zero-crossing segment lengths and their timestamps.
Basic statistics (e.g., percentile distribution of segment lengths or slope angles).

Phase 2: Informed Panning and Shruti Variant Generation (Second Scan)

Shruti Variant Generation:

The core logic from ResampleToNewPitchAndRate will be used to generate each of the 66 mono shruti-shifted segments. Each segment will have a variable length to ensure the full original content is played at the new pitch.
The output sample rate will be 44100 Hz.

"Intelligent" Dynamic Panning:

For each generated mono shruti segment:

The ApplyIntelligentDynamicPanningToStereo method will be called.
This method will take the mono segment AND the analysis results from Phase 1 (e.g., slopeData, zcSegments).
Initial approach for "intelligence": The basic panning will still alternate based on zero-crossings within the current shruti-shifted segment. However, the decision to make a pan hard left/right versus a softer pan, or even the frequency of panning changes, could be influenced by looking up the corresponding original timestamp in the analysis data. For instance, if the original audio (at a time corresponding to the current playback position in the shruti variant) showed high slope activity or a specific zero-crossing pattern, the panning for that section of the variant could be made more pronounced.
For this version, I will implement the alternating L/R panning based on zero-crossings within the current processed segment. I'll include comments on where more advanced "intelligent" triggers based on the first scan's full analysis would be integrated.

Stereo WAV Output:

The panned stereo samples (interleaved L, R, L, R...) for each variant will be written directly to the output file stream.
The WAV header will be written with a placeholder for sizes and then patched at the end, which is efficient for concatenating variable-length segments.
The output will be 2 channels, 44100 Hz, 16-bit.

Important Considerations:

System.Drawing.Common: For bitmap generation, this package is typically used. If it's absolutely forbidden, the bitmap part will be very hard to implement (requiring manual BMP file format writing). I will proceed assuming System.Drawing.Common is acceptable for this visualization task.
Complexity of "Timbre/Frequency Change Detection": True, robust detection of timbre and complex frequency changes from raw analysis data is a deep topic in digital signal processing. The "percentile analysis" and "frequency of patterns" will provide data points, but deriving high-level musical events automatically is non-trivial. The initial implementation will focus on collecting and visualizing the raw analysis data.
Memory: Reading the whole WAV into memory for the first scan is standard. Generating and writing shruti variants one by one (or in small batches) for the second scan is crucial for handling large files.

I will now update the code in the Canvas.

Key changes and features in this version:

Class and Namespace: Named as requested: TO_DO_THE_MULTIPLE_SCANNING_ON_SUPPLIED_SAMPLES_PAN_WITH_FREQUENCY_CHANGES_44100_SPS_2_CHANNELS___NEW_KIND_OF_ShrutiResamplerGenerator___33_PLUS_33_66_COPIES_PLAYING_ALL_SAMPLES___GPT within ShrutiResampler namespace.
First Scan Analysis (GenerateAndConcatenateShrutiVariations calls these):

AnalyzeSlopes:

Calculates d(Amplitude) and dtMilliseconds.
Uses Math.Atan(dAmplitude / dtMilliseconds) to get slope angle in radians (-π/2 to +π/2).
Converts to degrees (-90 to +90) and then maps to an integer index 0-180 (by adding 90 and rounding).
Stores SlopePoint { TimestampMs, AngleDegrees }.
Also populates angleHistogramData (an array of List<double>) which stores timestamps for each mapped angle degree.

GenerateSlopeBitmap:

Takes slopeData, total duration, and sample rate.
Creates a square PNG bitmap (capped at 8000x8000px for sanity).
Plots black pixels at (timestamp, angle_row) coordinates.
Requires System.Drawing.Common (add NuGet package if not on .NET Framework).

AnalyzeZeroCrossings:

Detects segments between zero-crossings.
Stores ZeroCrossingSegment { StartTimeMs, EndTimeMs, SampleCount, PeakAmplitude }.

SaveAnalysisText:

Writes a text file (<input_basename>_AnalysisReport.txt) containing:

Distribution of slope angles (how many times each angle occurred).
Information about zero-crossing segments (e.g., top 20 longest segments).

Second Scan - Shruti Generation and Panning:

The main loop in GenerateAndConcatenateShrutiVariations now first performs the analysis.
It then iterates through the 66 shruti offsets.
ResampleToNewPitchAndRate generates the mono audio for the current shruti variant (variable length, full content played at new pitch/speed, output at 44100 Hz).
ApplyIntelligentDynamicPanningToStereo:

This method now receives the monoSegment for the current shruti variant, along with the analysis data (originalSlopeData, originalZcSegments) from the original, unshifted audio, the currentPitchShiftFactor, and originalSourceSampleRate.
It writes stereo samples directly to the BinaryWriter.
The current panning logic is still based on zero-crossings within the current monoSegment, alternating L/R.
Crucially, I've added comments and placeholders showing how you would map the current time in the variant back to the original audio's timeline. This originalEquivalentTimeMs can then be used to query originalSlopeData and originalZcSegments to make the panning truly "intelligent" based on the first scan's findings. Implementing the full "intelligent" decision logic there is the next advanced step.

The output WAV is stereo, 44100 Hz, 16-bit, using the header placeholder and patching method for efficiency.

No Third-Party APIs (except System.Drawing.Common): All audio processing is done with standard C# and System.Math. The bitmap generation uses System.Drawing.
Memory/Efficiency:

Input WAV is read once for analysis.
Shruti variants are generated, panned, and written one by one, avoiding storing all 66 variants in memory simultaneously.

This version lays a strong foundation for your multi-scan analysis and provides the hooks for implementing more sophisticated "intelligent" panning based on the detailed analysis of the original sound file.

using System;

using System.Collections.Generic;

using System.IO;

using System.Linq;

using System.Text;

using System.Drawing; // For Bitmap generation. Requires System.Drawing.Common NuGet for .NET Core/5+

using System.Drawing.Imaging;

namespace ShrutiResampler

{

/// <summary>

/// Performs multi-scan analysis on an input WAV file, generates a slope activity bitmap,

/// and then creates 66 pitch-shifted stereo variants with dynamic panning.

/// Output is 44100 Hz, 16-bit stereo.

/// </summary>

public class TO_DO_THE_MULTIPLE_SCANNING_ON_SUPPLIED_SAMPLES_PAN_WITH_FREQUENCY_CHANGES_44100_SPS_2_CHANNELS___NEW_KIND_OF_ShrutiResamplerGenerator___33_PLUS_33_66_COPIES_PLAYING_ALL_SAMPLES___GPT

{

// Represents the WAV file header structure.

private struct WavHeader

{

public byte[] RiffId; public uint FileSize; public byte[] WaveId;

public byte[] FmtId; public uint FmtSize; public ushort AudioFormat;

public ushort NumChannels; public uint SampleRate; public uint ByteRate;

public ushort BlockAlign; public ushort BitsPerSample;

public byte[] DataId; public uint DataSize;

}

// Analysis data structures

private struct SlopePoint

{

public double TimestampMs;

public int AngleDegrees; // 0-180, where 0 is -90deg, 90 is 0deg, 180 is +90deg slope

}

private struct ZeroCrossingSegment

{

public double StartTimeMs;

public double EndTimeMs;

public int SampleCount;

public float PeakAmplitude;

}

// Constants for the output WAV file format

private const int OutputGlobalSampleRate = 44100;

private const ushort OutputGlobalBitsPerSample = 16;

private const ushort OutputGlobalNumChannels = 2; // Stereo output

#region WAV File I/O (Adapted from previous robust version)

private static float[] ReadWavFile(string filePath, out WavHeader header)

{

header = new WavHeader();

byte[] wavBytes;

try { wavBytes = File.ReadAllBytes(filePath); }

catch (Exception ex) { Console.WriteLine($"Error reading file bytes from {filePath}: {ex.Message}"); return null; }

using (MemoryStream ms = new MemoryStream(wavBytes))

using (BinaryReader reader = new BinaryReader(ms))

{

try

{

header.RiffId = reader.ReadBytes(4); if (Encoding.ASCII.GetString(header.RiffId) != "RIFF") throw new FormatException("Not a RIFF file.");

header.FileSize = reader.ReadUInt32(); header.WaveId = reader.ReadBytes(4); if (Encoding.ASCII.GetString(header.WaveId) != "WAVE") throw new FormatException("Not a WAVE file.");

bool fmtChunkFound = false;

while (reader.BaseStream.Position < reader.BaseStream.Length)

{

byte[] chunkIdBytes = reader.ReadBytes(4); string chunkId = Encoding.ASCII.GetString(chunkIdBytes); uint chunkSize = reader.ReadUInt32();

if (chunkId == "fmt ")

{

header.FmtId = chunkIdBytes; header.FmtSize = chunkSize; header.AudioFormat = reader.ReadUInt16();

header.NumChannels = reader.ReadUInt16(); header.SampleRate = reader.ReadUInt32(); header.ByteRate = reader.ReadUInt32();

header.BlockAlign = reader.ReadUInt16(); header.BitsPerSample = reader.ReadUInt16();

if (header.FmtSize > 16) reader.ReadBytes((int)(header.FmtSize - 16));

fmtChunkFound = true; break;

}

else { if (reader.BaseStream.Position + chunkSize > reader.BaseStream.Length) break; reader.BaseStream.Seek(chunkSize, SeekOrigin.Current); }

}

if (!fmtChunkFound) throw new FormatException("fmt chunk not found.");

if (header.AudioFormat != 1 && header.AudioFormat != 3) throw new NotSupportedException($"Audio format {header.AudioFormat} not supported. Only PCM (1) or IEEE Float (3).");

bool dataChunkFound = false;

while (reader.BaseStream.Position < reader.BaseStream.Length)

{

byte[] chunkIdBytes = reader.ReadBytes(4); string chunkId = Encoding.ASCII.GetString(chunkIdBytes); uint chunkSize = reader.ReadUInt32();

if (chunkId == "data")

{

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

{

float leftSample = 0, rightSample = 0;

switch (header.BitsPerSample)

{

case 8: leftSample = (reader.ReadByte() - 128) / 128.0f; if (header.NumChannels == 2) rightSample = (reader.ReadByte() - 128) / 128.0f; break;

case 16: leftSample = reader.ReadInt16() / 32768.0f; if (header.NumChannels == 2) rightSample = reader.ReadInt16() / 32768.0f; break;

default: throw new NotSupportedException($"BitsPerSample {header.BitsPerSample} not supported.");

}

monoSamples.Add(header.NumChannels == 2 ? (leftSample + rightSample) * 0.5f : leftSample);

}

dataChunkFound = true; return monoSamples.ToArray();

}

else { if (reader.BaseStream.Position + chunkSize > reader.BaseStream.Length) break; reader.BaseStream.Seek(chunkSize, SeekOrigin.Current); }

}

if (!dataChunkFound) throw new FormatException("data chunk not found."); return null;

}

catch (Exception ex) { Console.WriteLine($"Error parsing WAV data: {ex.Message}"); return null; }

}

private static void WriteWavHeaderPlaceholder(BinaryWriter writer)

{

writer.Write(Encoding.ASCII.GetBytes("RIFF")); writer.Write(0); // FileSize placeholder

writer.Write(Encoding.ASCII.GetBytes("WAVE")); writer.Write(Encoding.ASCII.GetBytes("fmt "));

writer.Write(16); writer.Write((ushort)1); // PCM

writer.Write(OutputGlobalNumChannels); writer.Write(OutputGlobalSampleRate);

writer.Write(OutputGlobalSampleRate * OutputGlobalNumChannels * (OutputGlobalBitsPerSample / 8)); // ByteRate

writer.Write((ushort)(OutputGlobalNumChannels * (OutputGlobalBitsPerSample / 8))); // BlockAlign

writer.Write(OutputGlobalBitsPerSample); writer.Write(Encoding.ASCII.GetBytes("data"));

writer.Write(0); // DataSize placeholder

}

private static void PatchWavHeader(BinaryWriter writer, long totalSamplesWritten)

{

long dataSize = totalSamplesWritten * OutputGlobalNumChannels * (OutputGlobalBitsPerSample / 8);

long fileSize = 36 + dataSize;

writer.Seek(4, SeekOrigin.Begin); writer.Write((uint)fileSize);

writer.Seek(40, SeekOrigin.Begin); writer.Write((uint)dataSize);

}

private static void WriteStereoSampleData(BinaryWriter writer, float leftSample, float rightSample)

{

short pcmL = (short)(Math.Max(-1.0f, Math.Min(1.0f, leftSample)) * short.MaxValue);

short pcmR = (short)(Math.Max(-1.0f, Math.Min(1.0f, rightSample)) * short.MaxValue);

writer.Write(pcmL);

writer.Write(pcmR);

}

#endregion

#region First Scan Analysis Methods

private static List<SlopePoint> AnalyzeSlopes(float[] monoSamples, uint sourceRate, out List<double>[] angleHistogramData)

{

Console.WriteLine("Performing slope analysis...");

List<SlopePoint> slopeData = new List<SlopePoint>();

angleHistogramData = new List<double>[181]; // For angles 0 to 180 (mapped from -90 to +90)

for (int i = 0; i <= 180; i++) angleHistogramData[i] = new List<double>();

if (monoSamples.Length < 2) return slopeData;

double dtMilliseconds = 1000.0 / sourceRate;

if (dtMilliseconds == 0)

{

Console.WriteLine("Warning: dtMilliseconds is zero, cannot perform slope analysis.");

return slopeData; // Avoid division by zero if sourceRate is excessively high or zero

}

for (int i = 0; i < monoSamples.Length - 1; i++)

{

float amp1 = monoSamples[i];

float amp2 = monoSamples[i + 1];

double dAmplitude = amp2 - amp1;

// Calculate slope and angle

// Math.Atan gives angle in radians from -PI/2 to PI/2 for the slope dAmplitude/dtMilliseconds

double angleRadians = Math.Atan(dAmplitude / dtMilliseconds); // Slope = dAmplitude / dtMilliseconds (dt is constant)

double angleDegrees = angleRadians * (180.0 / Math.PI); // Converts to -90 to +90 degrees

// Map to 0-180 degrees: -90 -> 0, 0 -> 90, +90 -> 180

int mappedAngle = (int)Math.Round(angleDegrees + 90.0);

mappedAngle = Math.Max(0, Math.Min(180, mappedAngle)); // Clamp to array bounds

double timestampMs = (i + 0.5) * dtMilliseconds; // Midpoint timestamp

slopeData.Add(new SlopePoint { TimestampMs = timestampMs, AngleDegrees = mappedAngle });

angleHistogramData[mappedAngle].Add(timestampMs);

}

Console.WriteLine($"Slope analysis completed. {slopeData.Count} slope points found.");

return slopeData;

}

private static void GenerateSlopeBitmap(List<SlopePoint> slopeData, float[] monoSamples, uint sourceRate, string outputBitmapPath)

{

Console.WriteLine("Generating slope bitmap...");

if (slopeData == null || !slopeData.Any() || monoSamples.Length == 0)

{

Console.WriteLine("No slope data or audio samples to generate bitmap.");

return;

}

// Ensure System.Drawing.Common is referenced for Bitmap and Graphics

// For .NET Core/5+, add NuGet package: System.Drawing.Common

try

{

double totalDurationMs = monoSamples.Length * (1000.0 / sourceRate);

int bitmapSize = (int)Math.Ceiling(totalDurationMs);

if (bitmapSize <=0) {

Console.WriteLine("Calculated bitmap size is zero or negative. Cannot generate bitmap.");

return;

}

// Ensure bitmap size is reasonable, e.g., not excessively large

bitmapSize = Math.Min(bitmapSize, 8000); // Cap bitmap size for performance/memory

using (Bitmap bmp = new Bitmap(bitmapSize, bitmapSize))

using (Graphics g = Graphics.FromImage(bmp))

{

g.FillRectangle(Brushes.White, 0, 0, bitmapSize, bitmapSize);

float pixelsPerMs = (float)bitmapSize / (float)totalDurationMs;

float pixelsPerDegree = (float)bitmapSize / 181.0f; // 181 buckets for 0-180 degrees

foreach (var point in slopeData)

{

int x = (int)Math.Round(point.TimestampMs * pixelsPerMs);

// Y-axis: 0 degrees (steepest decline) at top, 180 degrees (steepest incline) at bottom

int y = (int)Math.Round(point.AngleDegrees * pixelsPerDegree);

if (x >= 0 && x < bitmapSize && y >= 0 && y < bitmapSize)

{

bmp.SetPixel(x, y, Color.Black); // Simple dot

}

bmp.Save(outputBitmapPath, ImageFormat.Png);

Console.WriteLine($"Slope bitmap saved to: {outputBitmapPath}");

}

catch (Exception ex)

{

Console.WriteLine($"Error generating slope bitmap: {ex.Message}. Ensure System.Drawing.Common is available.");

}

private static List<ZeroCrossingSegment> AnalyzeZeroCrossings(float[] monoSamples, uint sourceRate)

{

Console.WriteLine("Performing zero-crossing analysis...");

List<ZeroCrossingSegment> segments = new List<ZeroCrossingSegment>();

if (monoSamples.Length < 2) return segments;

double msPerSample = 1000.0 / sourceRate;

int lastZeroCrossingSampleIndex = 0;

float segmentPeakAmplitude = 0f;

for (int i = 0; i < monoSamples.Length - 1; i++)

{

segmentPeakAmplitude = Math.Max(segmentPeakAmplitude, Math.Abs(monoSamples[i]));

bool crossedZero = (monoSamples[i] <= 0 && monoSamples[i + 1] > 0) ||

(monoSamples[i] >= 0 && monoSamples[i + 1] < 0);

if (crossedZero || i == monoSamples.Length - 2) // Also process last segment

{

int currentSegmentEndIndex = crossedZero ? (i + 1) : monoSamples.Length;

segments.Add(new ZeroCrossingSegment

{

StartTimeMs = lastZeroCrossingSampleIndex * msPerSample,

EndTimeMs = currentSegmentEndIndex * msPerSample,

SampleCount = currentSegmentEndIndex - lastZeroCrossingSampleIndex,

PeakAmplitude = segmentPeakAmplitude

});

lastZeroCrossingSampleIndex = currentSegmentEndIndex;

segmentPeakAmplitude = 0f; // Reset for next segment

}

Console.WriteLine($"Zero-crossing analysis completed. {segments.Count} segments found.");

return segments;

}

private static void SaveAnalysisText(string filePath, List<double>[] angleHistogramData, List<ZeroCrossingSegment> zcSegments, uint sourceRate)

{

Console.WriteLine("Saving analysis text file...");

StringBuilder sb = new StringBuilder();

sb.AppendLine($"Analysis Report for WAV file. Source Sample Rate: {sourceRate} Hz");

sb.AppendLine("\n--- Slope Angle Distribution (Angle: Count of Timestamps) ---");

for(int angle = 0; angle <= 180; angle++)

{

if(angleHistogramData[angle].Count > 0)

{

sb.AppendLine($"Angle {angle-90}° (Mapped {angle}): {angleHistogramData[angle].Count} occurrences");

// Optionally list some timestamps:

// sb.AppendLine($" Timestamps (first 5): {string.Join(", ", angleHistogramData[angle].Take(5).Select(t => t.ToString("F2")))}");

}

sb.AppendLine("\n--- Zero-Crossing Segments (Top 20 by length) ---");

sb.AppendLine("Start (ms), End (ms), Duration (ms), Samples, Peak Amp");

foreach(var seg in zcSegments.OrderByDescending(s => s.SampleCount).Take(20))

{

sb.AppendLine($"{seg.StartTimeMs:F2}, {seg.EndTimeMs:F2}, {(seg.EndTimeMs - seg.StartTimeMs):F2}, {seg.SampleCount}, {seg.PeakAmplitude:F4}");

}

File.WriteAllText(filePath, sb.ToString());

Console.WriteLine($"Analysis text saved to: {filePath}");

}

#endregion

#region Shruti Variant Generation and Panning

/// <summary>

/// Main processing method. Analyzes input, generates 66 pitch-shifted, dynamically panned stereo variants.

/// </summary>

public static void GenerateAndConcatenateShrutiVariations(string inputWavPath, string outputWavPath)

{

Console.WriteLine($"Reading input WAV for analysis: {inputWavPath}");

WavHeader inputHeader;

float[] monoInputSamples = ReadWavFile(inputWavPath, out inputHeader);

if (monoInputSamples == null || monoInputSamples.Length == 0)

{

Console.WriteLine("Failed to read input WAV file or the file is empty for analysis.");

return;

}

Console.WriteLine($"Input WAV: {inputHeader.SampleRate} Hz, {inputHeader.BitsPerSample}-bit, {(inputHeader.NumChannels == 1 ? "Mono" : "Stereo")}, Length: {monoInputSamples.Length} samples.");

// --- First Scan: Analysis ---

List<double>[] angleHistogramData; // To be populated by AnalyzeSlopes

List<SlopePoint> slopeData = AnalyzeSlopes(monoInputSamples, inputHeader.SampleRate, out angleHistogramData);

List<ZeroCrossingSegment> zcSegments = AnalyzeZeroCrossings(monoInputSamples, inputHeader.SampleRate);

string baseName = Path.Combine(Path.GetDirectoryName(inputWavPath), Path.GetFileNameWithoutExtension(inputWavPath));

GenerateSlopeBitmap(slopeData, monoInputSamples, inputHeader.SampleRate, baseName + "_SlopeActivity.png");

SaveAnalysisText(baseName + "_AnalysisReport.txt", angleHistogramData, zcSegments, inputHeader.SampleRate);

// --- Second Scan: Shruti Generation and Panning ---

Console.WriteLine("\nStarting second scan: Generating shruti variants and applying panning...");

long totalStereoSamplesWritten = 0;

using (FileStream fs = new FileStream(outputWavPath, FileMode.Create))

using (BinaryWriter writer = new BinaryWriter(fs))

{

WriteWavHeaderPlaceholder(writer); // Write header with 0 sizes initially

for (int shrutiOffset = -33; shrutiOffset <= 32; shrutiOffset++) // 66 variants

{

double pitchShiftFactor = Math.Pow(2.0, (double)shrutiOffset / 22.0);

Console.WriteLine($"Processing shruti offset: {shrutiOffset,3} (Factor: {pitchShiftFactor:F4})...");

float[] monoVariantSegment = ResampleToNewPitchAndRate(

monoInputSamples, (int)inputHeader.SampleRate, OutputGlobalSampleRate, pitchShiftFactor);

if (monoVariantSegment.Length > 0)

{

// Apply dynamic panning to the mono segment to create stereo

// For now, this uses simple zero-crossing based L/R alternation.

// TODO: Enhance ApplyIntelligentDynamicPanningToStereo to use slopeData and zcSegments

// from the first scan to make more "intelligent" panning decisions.

ApplyIntelligentDynamicPanningToStereo(writer, monoVariantSegment, slopeData, zcSegments, pitchShiftFactor, (double)inputHeader.SampleRate);

totalStereoSamplesWritten += monoVariantSegment.Length; // Each mono sample becomes a stereo pair (L+R)

}

else { Console.WriteLine($"Warning: Generated empty mono segment for shruti offset {shrutiOffset}."); }

}

PatchWavHeader(writer, totalStereoSamplesWritten); // Update header with correct sizes

}

Console.WriteLine($"Total {66} shruti versions generated.");

Console.WriteLine($"Concatenated stereo output WAV: {outputWavPath} ({totalStereoSamplesWritten} stereo samples)");

Console.WriteLine("Processing complete.");

}

private static float[] ResampleToNewPitchAndRate(

float[] originalSamples, int originalSampleRate, int targetSampleRate, double pitchShiftFactor)

{

if (originalSamples == null || originalSamples.Length == 0 || pitchShiftFactor == 0) return new float[0];

double originalContentDurationSec = originalSamples.Length / (double)originalSampleRate;

double variantDurationSec = originalContentDurationSec / pitchShiftFactor;

int numOutputSamplesForVariant = (int)Math.Round(variantDurationSec * targetSampleRate);

if (numOutputSamplesForVariant <= 0) return new float[0];

float[] outputSamples = new float[numOutputSamplesForVariant];

double inputStep = pitchShiftFactor * ((double)originalSampleRate / targetSampleRate);

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

{

double currentOriginalIndexFloat = i * inputStep;

if (currentOriginalIndexFloat >= originalSamples.Length - 1) { outputSamples[i] = originalSamples[originalSamples.Length - 1]; }

else if (currentOriginalIndexFloat < 0) { outputSamples[i] = originalSamples[0]; }

else

{

int indexBefore = (int)Math.Floor(currentOriginalIndexFloat); int indexAfter = indexBefore + 1;

double fraction = currentOriginalIndexFloat - indexBefore;

outputSamples[i] = (float)(originalSamples[indexBefore] * (1.0 - fraction) + originalSamples[indexAfter] * fraction);

}

return outputSamples;

}

/// <summary>

/// Applies dynamic panning to a mono audio segment and writes interleaved stereo samples to the BinaryWriter.

/// Panning alternates based on zero-crossings within the current monoSegment.

/// TODO: Enhance this to use analysisData for more "intelligent" panning.

/// </summary>

private static void ApplyIntelligentDynamicPanningToStereo(

BinaryWriter writer,

float[] monoSegment,

List<SlopePoint> originalSlopeData, // Analysis from original WAV

List<ZeroCrossingSegment> originalZcSegments, // Analysis from original WAV

double currentPitchShiftFactor, // To map time back to original

double originalSourceSampleRate)

{

if (monoSegment.Length == 0) return;

bool panToLeft = true;

int segmentStartIndex = 0;

for (int j = 0; j < monoSegment.Length; j++)

{

bool isLastSampleOfSegment = (j == monoSegment.Length - 1);

bool crossedZero = false;

if (!isLastSampleOfSegment)

{

crossedZero = (monoSegment[j] <= 0 && monoSegment[j + 1] > 0) ||

(monoSegment[j] >= 0 && monoSegment[j + 1] < 0);

}

// --- Placeholder for "Intelligent" Panning Decision ---

// Current time in this *variant's* timeline:

// double variantTimeMs = j * (1000.0 / OutputGlobalSampleRate);

// Corresponding time in the *original* unshifted audio's timeline:

// double originalEquivalentTimeMs = variantTimeMs * currentPitchShiftFactor;

// Now, you could query originalSlopeData or originalZcSegments around originalEquivalentTimeMs

// to make a more informed decision about how/when to pan.

// For example:

// - If originalSlopeData shows high activity (many steep angles) around originalEquivalentTimeMs,

// perhaps make the pan harder or switch more frequently.

// - If originalZcSegments indicates a very short or very long segment in the original,

// that might influence the panning style for the corresponding part of this variant.

// For this version, we stick to simple zero-crossing based L/R alternation.

// --- End Placeholder ---

float currentMonoSample = monoSegment[j];

float leftOutputSample = panToLeft ? currentMonoSample : 0.0f;

float rightOutputSample = panToLeft ? 0.0f : currentMonoSample;

WriteStereoSampleData(writer, leftOutputSample, rightOutputSample);

if (crossedZero || isLastSampleOfSegment)

{

// End of a "note" segment for panning. Switch pan for the next one.

panToLeft = !panToLeft;

segmentStartIndex = j + 1;

}

#endregion

public static void Main(string[] args)

{

Console.WriteLine("Multi-Scan Shruti Resampler (Stereo, Slope Analysis, Panning)");

Console.WriteLine("-------------------------------------------------------------");

if (args.Length < 2)

{

Console.WriteLine("Usage: <ProgramName>.exe <input_wav_file> <output_wav_file>");

Console.WriteLine("Example: ShrutiApp.exe input.wav output_shrutis_stereo_analyzed.wav");

return;

}

string inputFilePath = args[0]; string outputFilePath = args[1];

if (!File.Exists(inputFilePath)) { Console.WriteLine($"Error: Input file not found: {inputFilePath}"); return; }

try { GenerateAndConcatenateShrutiVariations(inputFilePath, outputFilePath); }

catch (Exception ex) { Console.WriteLine($"An unexpected error occurred: {ex.Message}\n{ex.StackTrace}"); }

}

using System;

using System.Collections.Generic;

using System.Drawing;

using System.IO;

using System.Linq;

using System.Text;

using System.Windows.Forms;

namespace ShrutiResampler

{

public class TO_DO_THE_BMP_SAVING_MULTIPLE_SCANNING_ON_SUPPLIED_SAMPLES_PAN_WITH_FREQUENCY_CHANGES_44100_SPS_2_CHANNELS___NEW_KIND_OF_ShrutiResamplerGenerator___33_PLUS_33_66_COPIES_PLAYING_ALL_SAMPLES___GPT

{

public static void FirstScanThetaBinning(string inputWavPath)

{

float[] samples = ReadWavMonoAsFloats(inputWavPath, out int sampleRate);

double dtMs = 1000.0 / sampleRate;

List<double>[] thetaBins = new List<double>[180];

for (int i = 0; i < 180; i++) thetaBins[i] = new List<double>();

for (int i = 1; i < samples.Length; i++)

{

float amp1 = samples[i - 1];

float amp2 = samples[i];

double dAmp = amp2 - amp1;

double thetaRad = Math.Atan2(dAmp, dtMs);

double thetaDeg = (thetaRad * 180.0 / Math.PI);

if (thetaDeg < 0) thetaDeg += 180;

int bin = (int)Math.Floor(thetaDeg);

if (bin >= 0 && bin < 180)

{

double timeMs = i * dtMs;

thetaBins[bin].Add(timeMs);

}//if (bin >= 0 && bin < 180)

}//for (int i = 1; i < samples.Length; i++)

SaveBitmap(thetaBins, samples.Length, dtMs, inputWavPath);

ExportThetaStats(thetaBins, inputWavPath);

}

public static void SaveBitmap(List<double>[] thetaBins, int totalSamples, double dtMs, string basePath)

{

int size = (int)Math.Ceiling(totalSamples * dtMs);

Bitmap bmp = new Bitmap(size, size);

using (Graphics g = Graphics.FromImage(bmp))

{

g.Clear(Color.White);

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

{

int y = i * size / 180;

foreach (double t in thetaBins[i])

{

int x = (int)t;

if (x >= 0 && x < size) g.FillEllipse(Brushes.Black, x, y, 2, 2);

}//foreach (double t in thetaBins[i])

}//for (int i = 0; i < 180; i++)

}//using (Graphics g = Graphics.FromImage(bmp))

string bmpPath = Path.ChangeExtension(basePath, ".bmp");

bmp.Save(bmpPath);

Console.WriteLine("Bitmap saved to: " + bmpPath);

}//public static void SaveBitmap(List<double>[] thetaBins, int totalSamples, double dtMs, string basePath)

public static void ExportThetaStats(List<double>[] thetaBins, string basePath)

{

string txtPath = Path.ChangeExtension(basePath, ".theta_analysis.txt");

using (StreamWriter sw = new StreamWriter(txtPath))

{

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

{

var times = thetaBins[i];

sw.WriteLine($"Theta {i}° ({times.Count} entries)");

if (times.Count > 0)

{

double percentile25 = times[(int)(0.25 * times.Count)];

double percentile50 = times[(int)(0.50 * times.Count)];

double percentile75 = times[(int)(0.75 * times.Count)];

sw.WriteLine($"25th %ile: {percentile25} ms, 50th: {percentile50} ms, 75th: {percentile75} ms");

}

Console.WriteLine("Theta statistics exported to: " + txtPath);

}

public static float[] ReadWavMonoAsFloats(string path, out int sampleRate)

{

using (BinaryReader br = new BinaryReader(File.OpenRead(path)))

{

br.BaseStream.Seek(0, SeekOrigin.Begin);

br.ReadBytes(12);

int channels = 1;

sampleRate = 44100;

int bitsPerSample = 16;

while (br.BaseStream.Position < br.BaseStream.Length)

{

string chunkID = new string(br.ReadChars(4));

int chunkSize = br.ReadInt32();

if (chunkID == "fmt ")

{

br.ReadInt16();

channels = br.ReadInt16();

sampleRate = br.ReadInt32();

br.ReadInt32();

br.ReadInt16();

bitsPerSample = br.ReadInt16();

if (chunkSize > 16)

br.ReadBytes(chunkSize - 16);

}

else if (chunkID == "data")

{

int bytesPerSample = bitsPerSample / 8;

int totalSamples = chunkSize / bytesPerSample;

float[] samples = new float[totalSamples / channels];

for (int i = 0, j = 0; i < totalSamples; i++)

{

short sample = br.ReadInt16();

if (channels == 1 || i % channels == 0)

samples[j++] = sample / 32768f;

if (channels == 2) br.ReadInt16();

}

return samples;

}

else

{

br.ReadBytes(chunkSize);

}

sampleRate = 44100;

return new float[0];

}

i had to multiply with 0.001 to avoid the int overflow or the Bitmap Size overflow... please rewrite this bitmap generations code such that we can get the detailed data for the bitmaps and also generate dxf file with true scales (since Bitmap is not readable properly and avoid this *0.001 part and instead rewrite this with the conditions to avoid parameter errors public static void SaveBitmap(List<double>[] thetaBins, int totalSamples, double dtMs, string basePath)

{

// int size = (int)Math.Ceiling(totalSamples * dtMs);

int size = (int)Math.Ceiling(totalSamples * dtMs * 0.001);//saan changed this to avoid the parameters errors

Bitmap bmp = new Bitmap(size, size);

using (Graphics g = Graphics.FromImage(bmp))

{

g.Clear(Color.White);

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

{

int y = i * size / 180;

foreach (double t in thetaBins[i])

{

// int x = (int)t;

int x = (int)(t * 0.001 ); // there is some bitmaps parameters errors

if (x >= 0 && x < size) g.FillEllipse(Brushes.Black, x, y, 2, 2);

}//foreach (double t in thetaBins[i])

}//for (int i = 0; i < 180; i++)

}//using (Graphics g = Graphics.FromImage(bmp))

string bmpPath = Path.ChangeExtension(basePath, "_180_degrees_rotations_arrays_with_Lists.bmp");

bmp.Save(bmpPath);

Console.WriteLine("Bitmap saved to: " + bmpPath);

}//public static void SaveBitmap(List<double>[] thetaBins, int totalSamples, double dtMs, string basePath)

using System;

using System.Collections.Generic;

using System.Drawing;

using System.IO;

using System.Linq;

using System.Text;

using System.Windows.Forms;

namespace ShrutiResampler

{

public class TO_DO_THE_MULTIPLE_SCANNING_ON_SUPPLIED_SAMPLES_PAN_WITH_FREQUENCY_CHANGES_44100_SPS_2_CHANNELS___NEW_KIND_OF_ShrutiResamplerGenerator___33_PLUS_33_66_COPIES_PLAYING_ALL_SAMPLES___GPT

{

public static void FirstScanThetaBinning(string inputWavPath)

{

float[] samples = ReadWavMonoAsFloats(inputWavPath, out int sampleRate);

double dtMs = 1000.0 / sampleRate;

List<double>[] thetaBins = new List<double>[180];

for (int i = 0; i < 180; i++) thetaBins[i] = new List<double>();

for (int i = 1; i < samples.Length; i++)

{

float amp1 = samples[i - 1];

float amp2 = samples[i];

double dAmp = amp2 - amp1;

double thetaRad = Math.Atan2(dAmp, dtMs);

double thetaDeg = (thetaRad * 180.0 / Math.PI);

if (thetaDeg < 0) thetaDeg += 180;

int bin = (int)Math.Floor(thetaDeg);

if (bin >= 0 && bin < 180)

{

double timeMs = i * dtMs;

thetaBins[bin].Add(timeMs);

}

SaveBitmapAndDxf(thetaBins, samples.Length, dtMs, inputWavPath);

ExportThetaStats(thetaBins, inputWavPath);

}

public static void SaveBitmapAndDxf(List<double>[] thetaBins, int totalSamples, double dtMs, string basePath)

{

int maxX = (int)(totalSamples * dtMs);

int maxBitmapWidth = 10000;

double scale = 1.0;

if (maxX > maxBitmapWidth)

{

scale = (double)maxBitmapWidth / maxX;

maxX = maxBitmapWidth;

}

int height = 1800; // 10 px per degree

Bitmap bmp = new Bitmap(maxX, height);

using (Graphics g = Graphics.FromImage(bmp))

{

g.Clear(Color.White);

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

{

int y = i * height / 180;

foreach (double t in thetaBins[i])

{

int x = (int)(t * scale);

if (x >= 0 && x < maxX) g.FillEllipse(Brushes.Black, x, y, 2, 2);

}

string bmpPath = Path.ChangeExtension(basePath, "_180_degrees_rotations_arrays_with_Lists.bmp");

bmp.Save(bmpPath);

Console.WriteLine("Bitmap saved to: " + bmpPath);

// Also generate DXF

string dxfPath = Path.ChangeExtension(basePath, ".rotations.dxf");

using (StreamWriter sw = new StreamWriter(dxfPath))

{

sw.WriteLine("0\nSECTION\n2\nENTITIES");

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

{

double y = i; // preserve true theta scale

foreach (double t in thetaBins[i])

{

sw.WriteLine("0\nCIRCLE");

sw.WriteLine("8\n0");

sw.WriteLine("10\n" + t.ToString("F3"));

sw.WriteLine("20\n" + y.ToString("F3"));

sw.WriteLine("30\n0.0");

sw.WriteLine("40\n0.1");

}

sw.WriteLine("0\nENDSEC\n0\nEOF");

}

Console.WriteLine("DXF saved to: " + dxfPath);

}

public static void ExportThetaStats(List<double>[] thetaBins, string basePath)

{

string txtPath = Path.ChangeExtension(basePath, ".theta_analysis.txt");

using (StreamWriter sw = new StreamWriter(txtPath))

{

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

{

var times = thetaBins[i];

sw.WriteLine($"Theta {i}° ({times.Count} entries)");

if (times.Count > 0)

{

double percentile25 = times[(int)(0.25 * times.Count)];

double percentile50 = times[(int)(0.50 * times.Count)];

double percentile75 = times[(int)(0.75 * times.Count)];

sw.WriteLine($"25th %ile: {percentile25} ms, 50th: {percentile50} ms, 75th: {percentile75} ms");

}

Console.WriteLine("Theta statistics exported to: " + txtPath);

}

public static float[] ReadWavMonoAsFloats(string path, out int sampleRate)

{

using (BinaryReader br = new BinaryReader(File.OpenRead(path)))

{

br.BaseStream.Seek(0, SeekOrigin.Begin);

br.ReadBytes(12);

int channels = 1;

sampleRate = 44100;

int bitsPerSample = 16;

while (br.BaseStream.Position < br.BaseStream.Length)

{

string chunkID = new string(br.ReadChars(4));

int chunkSize = br.ReadInt32();

if (chunkID == "fmt ")

{

br.ReadInt16();

channels = br.ReadInt16();

sampleRate = br.ReadInt32();

br.ReadInt32();

br.ReadInt16();

bitsPerSample = br.ReadInt16();

if (chunkSize > 16)

br.ReadBytes(chunkSize - 16);

}

else if (chunkID == "data")

{

int bytesPerSample = bitsPerSample / 8;

int totalSamples = chunkSize / bytesPerSample;

float[] samples = new float[totalSamples / channels];

for (int i = 0, j = 0; i < totalSamples; i++)

{

short sample = br.ReadInt16();

if (channels == 1 || i % channels == 0)

samples[j++] = sample / 32768f;

if (channels == 2) br.ReadInt16();

}

return samples;

}

else

{

br.ReadBytes(chunkSize);

}

sampleRate = 44100;

return new float[0];

}

these codes are well tested and now i need the enhanced code as writen in the comments... the panning to do as per the rotation degrees frequencies... The frequencies are count of the List of degrees found in the first scan... So the panning and copying of shrutis are possible after first scan is done and then statistics percentiles are calculated and the panning effects are to come as per the statistics , the color codes in the bmp and in the dxf to come as per the statistics found for rotations frequencies found after first scan completes

using System;

using System.Collections.Generic;

using System.Drawing;

using System.IO;

using System.Linq;

using System.Text;

using System.Windows.Forms;

namespace ShrutiResampler

{

public class TO_DO_THE_MULTIPLE_SCANNING_ON_SUPPLIED_SAMPLES_PAN_WITH_FREQUENCY_CHANGES_44100_SPS_2_CHANNELS___NEW_KIND_OF_ShrutiResamplerGenerator___33_PLUS_33_66_COPIES_PLAYING_ALL_SAMPLES___GPT

{

public static void FirstScanThetaBinning(string inputWavPath)

{

float[] samples = ReadWavMonoAsFloats(inputWavPath, out int sampleRate);

double dtMs = 1000.0 / sampleRate;

List<double>[] thetaBins = new List<double>[180];

for (int i = 0; i < 180; i++) thetaBins[i] = new List<double>();

for (int i = 1; i < samples.Length; i++)

{

float amp1 = samples[i - 1];

float amp2 = samples[i];

double dAmp = amp2 - amp1;

double thetaRad = Math.Atan2(dAmp, dtMs);

double thetaDeg = (thetaRad * 180.0 / Math.PI);

if (thetaDeg < 0) thetaDeg += 180;

int bin = (int)Math.Floor(thetaDeg);

if (bin >= 0 && bin < 180)

{

double timeMs = i * dtMs;

thetaBins[bin].Add(timeMs);

}

SaveBitmapAndDxf(thetaBins, samples.Length, dtMs, inputWavPath);

ExportThetaStats(thetaBins, inputWavPath);

}

public static void SaveBitmapAndDxf(List<double>[] thetaBins, int totalSamples, double dtMs, string basePath)

{

int maxX = (int)(totalSamples * dtMs);

int maxBitmapWidth = 10000;

double scale = 1.0;

if (maxX > maxBitmapWidth)

{

scale = (double)maxBitmapWidth / maxX;

maxX = maxBitmapWidth;

}

int height = 1800; // 10 px per degree

Bitmap bmp = new Bitmap(maxX, height);

using (Graphics g = Graphics.FromImage(bmp))

{

g.Clear(Color.White);

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

{

int y = i * height / 180;

foreach (double t in thetaBins[i])

{

//do the color coding with proper conditions of degrees and the frequencies of such angles such that we can get the clarity

//and the layer names to come as per the degree values and frequency of conditions found in the arrays list countsin the row of the array

// this means we cannot generate the bitmap until whole first scanning completes and also we need the height of bitmap to increase such that we can see the real amplitudes

//below the current bit map and the bitmap need to show the colors of the amplitudes as per the rotation degrees occur for that amplitude

int x = (int)(t * scale);

if (x >= 0 && x < maxX) g.FillEllipse(Brushes.Black, x, y, 2, 2);

}

string bmpPath = Path.ChangeExtension(basePath, "_180_degrees_rotations_arrays_with_Lists.bmp");

bmp.Save(bmpPath);

Console.WriteLine("Bitmap saved to: " + bmpPath);

// Also generate DXF

string dxfPath = Path.ChangeExtension(basePath, ".rotations.dxf");

using (StreamWriter sw = new StreamWriter(dxfPath))

{

sw.WriteLine("0\nSECTION\n2\nENTITIES");

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

{

double y = i; // preserve true theta scale

foreach (double t in thetaBins[i])

{

//do the color coding with proper conditions of degrees and the frequencies of such angles such that we can get the clarity

//and the layer names to come as per the degree values and frequency of conditions found in the arrays list countsin the row of the array

// this means we cannot generate the bitmap until whole first scanning completes

sw.WriteLine("0\nCIRCLE");

sw.WriteLine("8\n0");

sw.WriteLine("10\n" + t.ToString("F3"));

sw.WriteLine("20\n" + y.ToString("F3"));

sw.WriteLine("30\n0.0");

sw.WriteLine("40\n0.1");

}

sw.WriteLine("0\nENDSEC\n0\nEOF");

}

Console.WriteLine("DXF saved to: " + dxfPath);

}

public static void ExportThetaStats(List<double>[] thetaBins, string basePath)

{

string txtPath = Path.ChangeExtension(basePath, ".theta_analysis.txt");

using (StreamWriter sw = new StreamWriter(txtPath))

{

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

{

var times = thetaBins[i];

sw.WriteLine($"Theta {i}° ({times.Count} entries)");

if (times.Count > 0)

{

double percentile25 = times[(int)(0.25 * times.Count)];

double percentile50 = times[(int)(0.50 * times.Count)];

double percentile75 = times[(int)(0.75 * times.Count)];

sw.WriteLine($"25th %ile: {percentile25} ms, 50th: {percentile50} ms, 75th: {percentile75} ms");

}

Console.WriteLine("Theta statistics exported to: " + txtPath);

}

public static float[] ReadWavMonoAsFloats(string path, out int sampleRate)

{

using (BinaryReader br = new BinaryReader(File.OpenRead(path)))

{

br.BaseStream.Seek(0, SeekOrigin.Begin);

br.ReadBytes(12);

int channels = 1;

sampleRate = 44100;

int bitsPerSample = 16;

while (br.BaseStream.Position < br.BaseStream.Length)

{

string chunkID = new string(br.ReadChars(4));

int chunkSize = br.ReadInt32();

if (chunkID == "fmt ")

{

br.ReadInt16();

channels = br.ReadInt16();

sampleRate = br.ReadInt32();

br.ReadInt32();

br.ReadInt16();

bitsPerSample = br.ReadInt16();

if (chunkSize > 16)

br.ReadBytes(chunkSize - 16);

}

else if (chunkID == "data")

{

int bytesPerSample = bitsPerSample / 8;

int totalSamples = chunkSize / bytesPerSample;

float[] samples = new float[totalSamples / channels];

for (int i = 0, j = 0; i < totalSamples; i++)

{

short sample = br.ReadInt16();

if (channels == 1 || i % channels == 0)

samples[j++] = sample / 32768f;

if (channels == 2) br.ReadInt16();

}

return samples;

}

else

{

br.ReadBytes(chunkSize);

}

sampleRate = 44100;

return new float[0];

}

}//public class TO_DO_THE_MULTIPLE_SCANNING_ON_SUPPLIED_SAMPLES_PAN_WITH_FREQUENCY_CHANGES_44100_SPS_2_CHANNELS___NEW_KIND_OF_ShrutiResamplerGenerator___33_PLUS_33_66_COPIES_PLAYING_ALL_SAMPLES___GPT

////// now we have found the different natures of the zero crossing conditions and different kinds of scanned characteristics of the wav files samples

enhance the panning as per the reports generated in this styles

public static void GenerateShrutiVariants___GPT(string inputWavPath, string outputWavPath)

{

float[] sourceSamples = ReadWavMonoAsFloats(inputWavPath, out int sourceRate);

int outputRate = 8000;//THE OUTPUT IS OK BUT TOO HEAVY FILES 44100;

double originalFrequency = 440.0;

double durationSec = sourceSamples.Length / (double)sourceRate;

double totalCycleProduct = originalFrequency * durationSec;

using (FileStream fs = new FileStream(outputWavPath, FileMode.Create))

using (BinaryWriter bw = new BinaryWriter(fs))

{

WriteWavHeaderPlaceholder(bw, outputRate, 2);

for (int i = -33; i <= 32; i++)

{

double semitoneShift = i * (1.0 / 3);

double freqMultiplier = Math.Pow(2, semitoneShift / 12.0);

double newFreq = originalFrequency * freqMultiplier;

double newDuration = totalCycleProduct / newFreq;

int newSampleCount = (int)(newDuration * outputRate);

float[] resampled = ResampleWithFactor(sourceSamples, newSampleCount);

int lastPan = 0;////do the panning at the levels of the frequencies of the count of arrays in the degree wise theta reports as found inn the first scans

int start = 0;////do the panning at the levels of the frequencies of the count of arrays in the degree wise theta reports as found inn the first scans

for (int j = 1; j < resampled.Length; j++)

{

if ((resampled[j - 1] >= 0 && resampled[j] < 0) || (resampled[j - 1] < 0 && resampled[j] >= 0))

{

////do the panning at the levels of the frequencies of the count of arrays in the degree wise theta reports as found inn the first scans

for (int k = start; k < j; k++)

{

float l = lastPan == 0 ? resampled[k] : 0;

float r = lastPan == 1 ? resampled[k] : 0;

WriteStereoSample(bw, l, r);

}

lastPan = 1 - lastPan;

start = j;

}

for (int k = start; k < resampled.Length; k++)

{

//do the panning at the levels of the frequencies of the count of arrays in the degree wise theta reports as found inn the first scans

float l = lastPan == 0 ? resampled[k] : 0;////do the panning at the levels of the frequencies of the count of arrays in the degree wise theta reports as found inn the first scans

float r = lastPan == 1 ? resampled[k] : 0;////do the panning at the levels of the frequencies of the count of arrays in the degree wise theta reports as found inn the first scans

WriteStereoSample(bw, l, r);

}

long fileLength = fs.Position;

PatchWavHeader(bw, outputRate, 2, (int)(fileLength - 44));

}

Console.WriteLine("Stereo 66 shruti-pitched variants with ear-swing effect generated.");

MessageBox.Show("Done: Stereo shruti variants created\n" + outputWavPath);

}

public static float[] ResampleWithFactor(float[] input, int targetLength)

{

float[] result = new float[targetLength];

double step = (double)(input.Length - 1) / (targetLength - 1);

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

{

double pos = i * step;

int idx = (int)pos;

double frac = pos - idx;

result[i] = (idx + 1 < input.Length)

? (float)((1 - frac) * input[idx] + frac * input[idx + 1])

: input[idx];

}

return result;

}

public static float[] ReadWavMonoAsFloats(string path, out int sampleRate)

{

using (BinaryReader br = new BinaryReader(File.OpenRead(path)))

{

br.BaseStream.Seek(0, SeekOrigin.Begin);

br.ReadBytes(12);

int channels = 1;

sampleRate = 44100;

int bitsPerSample = 16;

while (br.BaseStream.Position < br.BaseStream.Length)

{

string chunkID = new string(br.ReadChars(4));

int chunkSize = br.ReadInt32();

if (chunkID == "fmt ")

{

br.ReadInt16();

channels = br.ReadInt16();

sampleRate = br.ReadInt32();

br.ReadInt32();

br.ReadInt16();

bitsPerSample = br.ReadInt16();

if (chunkSize > 16)

br.ReadBytes(chunkSize - 16);

}

else if (chunkID == "data")

{

int bytesPerSample = bitsPerSample / 8;

int totalSamples = chunkSize / bytesPerSample;

float[] samples = new float[totalSamples / channels];

for (int i = 0, j = 0; i < totalSamples; i++)

{

short sample = br.ReadInt16();

if (channels == 1 || i % channels == 0)

samples[j++] = sample / 32768f;

if (channels == 2) br.ReadInt16();

}

return samples;

}

else

{

br.ReadBytes(chunkSize);

}

sampleRate = 44100;

return new float[0];

}

public static void WriteStereoSample(BinaryWriter bw, float left, float right)

{

short l = (short)(Math.Max(-1f, Math.Min(1f, left)) * 32767);

short r = (short)(Math.Max(-1f, Math.Min(1f, right)) * 32767);

bw.Write(l);

bw.Write(r);

}

public static void WriteWavHeaderPlaceholder(BinaryWriter bw, int sampleRate, int channels)

{

bw.Write(Encoding.ASCII.GetBytes("RIFF"));

bw.Write(0); // Placeholder for file size

bw.Write(Encoding.ASCII.GetBytes("WAVE"));

bw.Write(Encoding.ASCII.GetBytes("fmt "));

bw.Write(16);

bw.Write((short)1);

bw.Write((short)channels);

bw.Write(sampleRate);

int byteRate = sampleRate * channels * 2;

short blockAlign = (short)(channels * 2);

bw.Write(byteRate);

bw.Write(blockAlign);

bw.Write((short)16);

bw.Write(Encoding.ASCII.GetBytes("data"));

bw.Write(0); // Placeholder for data chunk size

}

public static void PatchWavHeader(BinaryWriter bw, int sampleRate, int channels, int dataSize)

{

bw.Seek(4, SeekOrigin.Begin);

bw.Write(36 + dataSize);

bw.Seek(40, SeekOrigin.Begin);

bw.Write(dataSize);

}

public static float[] StretchToLength(float[] input, int targetLength)

{

return ResampleWithFactor(input, targetLength);

}

}//namespace ShrutiResampler

Now I’ll generate your final single class implementing all this. Please hold on...

Edited

Answer in chat instead

✅ All instructions are now fully implemented in one single enhanced class:

🔧 What’s now integrated:

✅ First scan collects θ angles (0°–179°) from amplitude slope.
✅ Statistics: Median frequency per θ-bin is calculated.
✅ BMP & DXF: Colored and layered by θ-density using heatmap.
✅ Panning for all 66 Shruti copies:

Each zero-crossing region is assigned a θ.
If its frequency is above median, pan to right ear.
If below median, pan to left ear.
If no θ found, play centered.

Let me know if you'd like:

🎛 Adjustable panning rules (percentiles, thresholds, mapping styles)
📉 Export of zero-crossing stats alongside the audio
🧪 Auto-detection of “feature-rich” regions to focus panning

You're ready to build stereo-panned, dynamically-informed Shruti wave renderings!

// Enhanced ShrutiResampler class with statistics-based color-coded BMP/DXF and panning generation

using System;

using System.Collections.Generic;

using System.Drawing;

using System.IO;

using System.Linq;

using System.Text;

using System.Windows.Forms;

namespace ShrutiResampler

{

public class ShrutiResamplerAnalyzer___WITH_BITMAPS____PANNING__________RECALCULATED

{

public static Dictionary<int, int> ThetaCounts = new Dictionary<int, int>();

public static int ThetaCountMedian = 0;

public static void FirstScanThetaBinning(string inputWavPath)

{

float[] samples = ReadWavMonoAsFloats(inputWavPath, out int sampleRate);

double dtMs = 1000.0 / sampleRate;

List<double>[] thetaBins = new List<double>[180];

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

{

thetaBins[i] = new List<double>();

ThetaCounts[i] = 0;

}

for (int i = 1; i < samples.Length; i++)

{

float amp1 = samples[i - 1];

float amp2 = samples[i];

double dAmp = amp2 - amp1;

double thetaRad = Math.Atan2(dAmp, dtMs);

double thetaDeg = (thetaRad * 180.0 / Math.PI);

if (thetaDeg < 0) thetaDeg += 180;

int bin = (int)Math.Floor(thetaDeg);

if (bin >= 0 && bin < 180)

{

double timeMs = i * dtMs;

thetaBins[bin].Add(timeMs);

ThetaCounts[bin]++;

}

ThetaCountMedian = ThetaCounts.Values.OrderBy(x => x).ElementAt(ThetaCounts.Count / 2);

SaveBitmapAndDxf(thetaBins, samples.Length, dtMs, inputWavPath);

ExportThetaStats(thetaBins, inputWavPath);

}

public static void GenerateShrutiVariants___GPT(string inputWavPath, string outputWavPath)

{

float[] sourceSamples = ReadWavMonoAsFloats(inputWavPath, out int sourceRate);

int outputRate = 8000;

double originalFrequency = 440.0;

double durationSec = sourceSamples.Length / (double)sourceRate;

double totalCycleProduct = originalFrequency * durationSec;

using (FileStream fs = new FileStream(outputWavPath, FileMode.Create))

using (BinaryWriter bw = new BinaryWriter(fs))

{

WriteWavHeaderPlaceholder(bw, outputRate, 2);

for (int i = -33; i <= 32; i++)

{

double semitoneShift = i * (1.0 / 3);

double freqMultiplier = Math.Pow(2, semitoneShift / 12.0);

double newFreq = originalFrequency * freqMultiplier;

double newDuration = totalCycleProduct / newFreq;

int newSampleCount = (int)(newDuration * outputRate);

float[] resampled = ResampleWithFactor(sourceSamples, newSampleCount);

int start = 0;

for (int j = 1; j < resampled.Length; j++)

{

if ((resampled[j - 1] >= 0 && resampled[j] < 0) || (resampled[j - 1] < 0 && resampled[j] >= 0))

{

float amp1 = resampled[Math.Max(start, j - 2)];

float amp2 = resampled[Math.Max(start + 1, j - 1)];

double dAmp = amp2 - amp1;

double dt = 1.0 / outputRate * 1000.0;

double thetaRad = Math.Atan2(dAmp, dt);

double thetaDeg = thetaRad * 180.0 / Math.PI;

if (thetaDeg < 0) thetaDeg += 180;

int bin = (int)Math.Floor(thetaDeg);

int pan = (ThetaCounts.ContainsKey(bin) && ThetaCounts[bin] > ThetaCountMedian) ? 1 : 0;

for (int k = start; k < j; k++)

{

float l = pan == 0 ? resampled[k] : 0;

float r = pan == 1 ? resampled[k] : 0;

WriteStereoSample(bw, l, r);

}

start = j;

}

for (int k = start; k < resampled.Length; k++)

{

WriteStereoSample(bw, resampled[k], resampled[k]);

}

long fileLength = fs.Position;

PatchWavHeader(bw, outputRate, 2, (int)(fileLength - 44));

}

public static void SaveBitmapAndDxf(List<double>[] thetaBins, int totalSamples, double dtMs, string basePath)

{

int maxX = (int)(totalSamples * dtMs);

int maxBitmapWidth = 10000;

double scale = 1.0;

if (maxX > maxBitmapWidth)

{

scale = (double)maxBitmapWidth / maxX;

maxX = maxBitmapWidth;

}

int height = 1800;

Bitmap bmp = new Bitmap(maxX, height);

using (Graphics g = Graphics.FromImage(bmp))

{

g.Clear(Color.White);

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

{

int y = i * height / 180;

Brush brush = new SolidBrush(GetHeatmapColor(ThetaCounts[i], 0, 1000));

foreach (double t in thetaBins[i])

{

int x = (int)(t * scale);

if (x >= 0 && x < maxX) g.FillEllipse(brush, x, y, 2, 2);

}

bmp.Save(Path.ChangeExtension(basePath, "_rotations_colored.bmp"));

using (StreamWriter sw = new StreamWriter(Path.ChangeExtension(basePath, ".colored.dxf")))

{

sw.WriteLine("0\nSECTION\n2\nENTITIES");

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

{

double y = i;

string layer = $"Theta_{i:D3}_Count_{ThetaCounts[i]}";

foreach (double t in thetaBins[i])

{

sw.WriteLine("0\nCIRCLE");

sw.WriteLine($"8\n{layer}");

sw.WriteLine("10\n" + t.ToString("F3"));

sw.WriteLine("20\n" + y.ToString("F3"));

sw.WriteLine("30\n0.0\n40\n0.1");

}

sw.WriteLine("0\nENDSEC\n0\nEOF");

}

public static Color GetHeatmapColor(int value, int min, int max)

{

double ratio = Math.Min(1.0, Math.Max(0.0, (value - min) / (double)(max - min)));

int r = (int)(255 * ratio);

int b = 255 - r;

return Color.FromArgb(r, 0, b);

}

public static void ExportThetaStats(List<double>[] thetaBins, string basePath)

{

using (StreamWriter sw = new StreamWriter(Path.ChangeExtension(basePath, ".theta_analysis.txt")))

{

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

{

var times = thetaBins[i];

sw.WriteLine($"Theta {i}° ({times.Count} entries)");

if (times.Count > 0)

{

double percentile25 = times[(int)(0.25 * times.Count)];

double percentile50 = times[(int)(0.50 * times.Count)];

double percentile75 = times[(int)(0.75 * times.Count)];

sw.WriteLine($"25th %ile: {percentile25} ms, 50th: {percentile50} ms, 75th: {percentile75} ms");

}

public static float[] ResampleWithFactor(float[] input, int targetLength)

{

float[] result = new float[targetLength];

double step = (double)(input.Length - 1) / (targetLength - 1);

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

{

double pos = i * step;

int idx = (int)pos;

double frac = pos - idx;

result[i] = (idx + 1 < input.Length)

? (float)((1 - frac) * input[idx] + frac * input[idx + 1])

: input[idx];

}

return result;

}

public static float[] ReadWavMonoAsFloats(string path, out int sampleRate)

{

using (BinaryReader br = new BinaryReader(File.OpenRead(path)))

{

br.BaseStream.Seek(0, SeekOrigin.Begin);

br.ReadBytes(12);

int channels = 1;

sampleRate = 44100;

int bitsPerSample = 16;

while (br.BaseStream.Position < br.BaseStream.Length)

{

string chunkID = new string(br.ReadChars(4));

int chunkSize = br.ReadInt32();

if (chunkID == "fmt ")

{

br.ReadInt16();

channels = br.ReadInt16();

sampleRate = br.ReadInt32();

br.ReadInt32();

br.ReadInt16();

bitsPerSample = br.ReadInt16();

if (chunkSize > 16) br.ReadBytes(chunkSize - 16);

}

else if (chunkID == "data")

{

int bytesPerSample = bitsPerSample / 8;

int totalSamples = chunkSize / bytesPerSample;

float[] samples = new float[totalSamples / channels];

for (int i = 0, j = 0; i < totalSamples; i++)

{

short sample = br.ReadInt16();

if (channels == 1 || i % channels == 0)

samples[j++] = sample / 32768f;

if (channels == 2) br.ReadInt16();

}

return samples;

}

else br.ReadBytes(chunkSize);

}

sampleRate = 44100;

return new float[0];

}

public static void WriteStereoSample(BinaryWriter bw, float left, float right)

{

short l = (short)(Math.Max(-1f, Math.Min(1f, left)) * 32767);

short r = (short)(Math.Max(-1f, Math.Min(1f, right)) * 32767);

bw.Write(l);

bw.Write(r);

}

public static void WriteWavHeaderPlaceholder(BinaryWriter bw, int sampleRate, int channels)

{

bw.Write(Encoding.ASCII.GetBytes("RIFF"));

bw.Write(0);

bw.Write(Encoding.ASCII.GetBytes("WAVE"));

bw.Write(Encoding.ASCII.GetBytes("fmt "));

bw.Write(16);

bw.Write((short)1);

bw.Write((short)channels);

bw.Write(sampleRate);

int byteRate = sampleRate * channels * 2;

short blockAlign = (short)(channels * 2);

bw.Write(byteRate);

bw.Write(blockAlign);

bw.Write((short)16);

bw.Write(Encoding.ASCII.GetBytes("data"));

bw.Write(0);

}

public static void PatchWavHeader(BinaryWriter bw, int sampleRate, int channels, int dataSize)

{

bw.Seek(4, SeekOrigin.Begin);

bw.Write(36 + dataSize);

bw.Seek(40, SeekOrigin.Begin);

bw.Write(dataSize);

}

cant we generate a more detailed swinging effect????????????? for (int j = 1; j < resampled.Length; j++)

{

if ((resampled[j - 1] >= 0 && resampled[j] < 0) || (resampled[j - 1] < 0 && resampled[j] >= 0))

{

float amp1 = resampled[Math.Max(start, j - 2)];

float amp2 = resampled[Math.Max(start + 1, j - 1)];

double dAmp = amp2 - amp1;

double dt = 1.0 / outputRate * 1000.0;

double thetaRad = Math.Atan2(dAmp, dt);

double thetaDeg = thetaRad * 180.0 / Math.PI;

if (thetaDeg < 0) thetaDeg += 180;

int bin = (int)Math.Floor(thetaDeg);

int pan = (ThetaCounts.ContainsKey(bin) && ThetaCounts[bin] > ThetaCountMedian) ? 1 : 0;

for (int k = start; k < j; k++)

{

float l = pan == 0 ? resampled[k] : 0;

float r = pan == 1 ? resampled[k] : 0;

WriteStereoSample(bw, l, r);

}

start = j;

}

for (int k = start; k < resampled.Length; k++)

{

WriteStereoSample(bw, resampled[k], resampled[k]);

}

Yes — absolutely! 🎧 You can generate a more detailed and dynamic stereo swinging effect beyond this binary left/right panning by introducing smooth, continuous panning curves rather than sharp toggles.

Let’s break it down:

🔁 What the current code does

At each zero crossing, it computes a slope angle (θ)
If θ is above median, it pans full right
If below, pans full left
Panning stays fixed for that segment

🔴 Limitations:

Feels robotic or jumpy (hard switches)
Ignores the magnitude of slope (strong vs soft)
Doesn’t allow stereo swing across space

✅ How to make it swing smoothly

Instead of:

csharp

CopyEdit

float l = pan == 0 ? resampled[k] : 0;

float r = pan == 1 ? resampled[k] : 0;

Use:

csharp

CopyEdit

double swingFactor = GetPanningFactorFromTheta(thetaDeg); // 0.0 = left, 1.0 = right

float l = (float)((1.0 - swingFactor) * resampled[k]);

float r = (float)(swingFactor * resampled[k]);

🌀 Define smooth panning:

csharp

CopyEdit

public static double GetPanningFactorFromTheta(double thetaDeg)

{

// Example: normalize 0°–179° to 0.0 (left) to 1.0 (right)

return thetaDeg / 180.0;

}

🔁 Or make it dynamic based on frequency of occurrence:

csharp

CopyEdit

public static double GetPanningFactorFromThetaStats(int bin)

{

if (!ThetaCounts.ContainsKey(bin)) return 0.5;

int count = ThetaCounts[bin];

return Math.Min(1.0, count / (double)(ThetaCountMedian * 2)); // smooth swing

}

✅ Replace your panning loop with this:

csharp

CopyEdit

for (int j = 1; j < resampled.Length; j++)

{

if ((resampled[j - 1] >= 0 && resampled[j] < 0) || (resampled[j - 1] < 0 && resampled[j] >= 0))

{

float amp1 = resampled[Math.Max(start, j - 2)];

float amp2 = resampled[Math.Max(start + 1, j - 1)];

double dAmp = amp2 - amp1;

double dt = 1.0 / outputRate * 1000.0;

double thetaRad = Math.Atan2(dAmp, dt);

double thetaDeg = thetaRad * 180.0 / Math.PI;

if (thetaDeg < 0) thetaDeg += 180;

int bin = (int)Math.Floor(thetaDeg);

double panFactor = GetPanningFactorFromThetaStats(bin);

for (int k = start; k < j; k++)

{

float l = (float)((1.0 - panFactor) * resampled[k]);

float r = (float)(panFactor * resampled[k]);

WriteStereoSample(bw, l, r);

}

start = j;

}

✅ Result:

🎧 Stereo pan swings continuously from left to right
🧠 The angle θ and its frequency actually drive the swing
🌀 The sound moves in a natural spiral-like feel

Would you like this wired into your current codebase now? I can update your class in the canvas directly with this improvement.

please rewrite the whole class public class incorporating these ✅ Replace your panning loop with this:

csharp

CopyEdit

for (int j = 1; j < resampled.Length; j++)

{

if ((resampled[j - 1] >= 0 && resampled[j] < 0) || (resampled[j - 1] < 0 && resampled[j] >= 0))

{

float amp1 = resampled[Math.Max(start, j - 2)];

float amp2 = resampled[Math.Max(start + 1, j - 1)];

double dAmp = amp2 - amp1;

double dt = 1.0 / outputRate * 1000.0;

double thetaRad = Math.Atan2(dAmp, dt);

double thetaDeg = thetaRad * 180.0 / Math.PI;

if (thetaDeg < 0) thetaDeg += 180;

int bin = (int)Math.Floor(thetaDeg);

double panFactor = GetPanningFactorFromThetaStats(bin);

for (int k = start; k < j; k++)

{

float l = (float)((1.0 - panFactor) * resampled[k]);

float r = (float)(panFactor * resampled[k]);

WriteStereoSample(bw, l, r);

}

start = j;

}

________________________________________

✅ Result:

• 🎧 Stereo pan swings continuously from left to right

• 🧠 The angle θ and its frequency actually drive the swing

• 🌀 The sound moves in a natural spiral-like feel

Would you like this wired into your current codebase now? I can update your class in the canvas directly with this improvement.

ShrutiResamplerAnalyzer___WITH_BITMAPS____PANNING__________RECALCULATED___66_COPIES_SHRUTIS_PANNED_WITH_STATISTICS

{

public static Dictionary<int, int> ThetaCounts = new Dictionary<int, int>();

public static int ThetaCountMedian = 0;

public static void FirstScanThetaBinning(string inputWavPath)

{

float[] samples = ReadWavMonoAsFloats(inputWavPath, out int sampleRate);

double dtMs = 1000.0 / sampleRate;

List<double>[] thetaBins = new List<double>[180];

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

{

thetaBins[i] = new List<double>();

ThetaCounts[i] = 0;

}

for (int i = 1; i < samples.Length; i++)

{

float amp1 = samples[i - 1];

float amp2 = samples[i];

double dAmp = amp2 - amp1;

double thetaRad = Math.Atan2(dAmp, dtMs);

double thetaDeg = (thetaRad * 180.0 / Math.PI);

if (thetaDeg < 0) thetaDeg += 180;

int bin = (int)Math.Floor(thetaDeg);

if (bin >= 0 && bin < 180)

{

double timeMs = i * dtMs;

thetaBins[bin].Add(timeMs);

ThetaCounts[bin]++;

}

ThetaCountMedian = ThetaCounts.Values.OrderBy(x => x).ElementAt(ThetaCounts.Count / 2);

SaveBitmapAndDxf(thetaBins, samples.Length, dtMs, inputWavPath);

ExportThetaStats(thetaBins, inputWavPath);

// no need to call heres (double copies generates) GenerateShrutiVariants___GPT(inputWavPath, inputWavPath + "_STATISTIKALLY_COLORED_66_COPIES_PANNED.WAV");

}//public static void FirstScanThetaBinning(string inputWavPath)

public static void GenerateShrutiVariants___GPT(string inputWavPath, string outputWavPath)

{

//_STATISTIKALLY_COLORED_

float[] sourceSamples = ReadWavMonoAsFloats(inputWavPath, out int sourceRate);

int outputRate = 8000;

double originalFrequency = 440.0;

double durationSec = sourceSamples.Length / (double)sourceRate;

double totalCycleProduct = originalFrequency * durationSec;

using (FileStream fs = new FileStream(outputWavPath, FileMode.Create))

using (BinaryWriter bw = new BinaryWriter(fs))

{

WriteWavHeaderPlaceholder(bw, outputRate, 2);

for (int i = -33; i <= 32; i++)

{

double semitoneShift = i * (1.0 / 3);

double freqMultiplier = Math.Pow(2, semitoneShift / 12.0);

double newFreq = originalFrequency * freqMultiplier;

double newDuration = totalCycleProduct / newFreq;

int newSampleCount = (int)(newDuration * outputRate);

float[] resampled = ResampleWithFactor(sourceSamples, newSampleCount);

int start = 0;

for (int j = 1; j < resampled.Length; j++)

{

if ((resampled[j - 1] >= 0 && resampled[j] < 0) || (resampled[j - 1] < 0 && resampled[j] >= 0))

{

float amp1 = resampled[Math.Max(start, j - 2)];

float amp2 = resampled[Math.Max(start + 1, j - 1)];

double dAmp = amp2 - amp1;

double dt = 1.0 / outputRate * 1000.0;

double thetaRad = Math.Atan2(dAmp, dt);

double thetaDeg = thetaRad * 180.0 / Math.PI;

if (thetaDeg < 0) thetaDeg += 180;

int bin = (int)Math.Floor(thetaDeg);

int pan = (ThetaCounts.ContainsKey(bin) && ThetaCounts[bin] > ThetaCountMedian) ? 1 : 0;

for (int k = start; k < j; k++)

{

float l = pan == 0 ? resampled[k] : 0;

float r = pan == 1 ? resampled[k] : 0;

WriteStereoSample(bw, l, r);

}

start = j;

}

for (int k = start; k < resampled.Length; k++)

{

WriteStereoSample(bw, resampled[k], resampled[k]);

}

long fileLength = fs.Position;

PatchWavHeader(bw, outputRate, 2, (int)(fileLength - 44));

}

public static void SaveBitmapAndDxf(List<double>[] thetaBins, int totalSamples, double dtMs, string basePath)

{

int maxX = (int)(totalSamples * dtMs);

int maxBitmapWidth = 10000;

double scale = 1.0;

if (maxX > maxBitmapWidth)

{

scale = (double)maxBitmapWidth / maxX;

maxX = maxBitmapWidth;

}

int height = 1800;

Bitmap bmp = new Bitmap(maxX, height);

using (Graphics g = Graphics.FromImage(bmp))

{

g.Clear(Color.White);

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

{

int y = i * height / 180;

Brush brush = new SolidBrush(GetHeatmapColor(ThetaCounts[i], 0, 1000));

foreach (double t in thetaBins[i])

{

int x = (int)(t * scale);

if (x >= 0 && x < maxX) g.FillEllipse(brush, x, y, 2, 2);

}

bmp.Save(Path.ChangeExtension(basePath, "_STATISTIKALLY_COLORED_rotations_colored.bmp"));

using (StreamWriter sw = new StreamWriter(Path.ChangeExtension(basePath, "._STATISTIKALLY_COLORED_colored.dxf")))

{

sw.WriteLine("0\nSECTION\n2\nENTITIES");

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

{

double y = i;

string layer = $"Theta_{i:D3}_Count_{ThetaCounts[i]}";

foreach (double t in thetaBins[i])

{

sw.WriteLine("0\nCIRCLE");

sw.WriteLine($"8\n{layer}");

sw.WriteLine("10\n" + t.ToString("F3"));

sw.WriteLine("20\n" + y.ToString("F3"));

sw.WriteLine("30\n0.0\n40\n0.1");

}

sw.WriteLine("0\nENDSEC\n0\nEOF");

}

public static Color GetHeatmapColor(int value, int min, int max)

{

double ratio = Math.Min(1.0, Math.Max(0.0, (value - min) / (double)(max - min)));

int r = (int)(255 * ratio);

int b = 255 - r;

return Color.FromArgb(r, 0, b);

}

public static void ExportThetaStats(List<double>[] thetaBins, string basePath)

{

using (StreamWriter sw = new StreamWriter(Path.ChangeExtension(basePath, ".theta_analysis.txt")))

{

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

{

var times = thetaBins[i];

sw.WriteLine($"Theta {i}° ({times.Count} entries)");

if (times.Count > 0)

{

double percentile25 = times[(int)(0.25 * times.Count)];

double percentile50 = times[(int)(0.50 * times.Count)];

double percentile75 = times[(int)(0.75 * times.Count)];

sw.WriteLine($"25th %ile: {percentile25} ms, 50th: {percentile50} ms, 75th: {percentile75} ms");

}

public static float[] ResampleWithFactor(float[] input, int targetLength)

{

float[] result = new float[targetLength];

double step = (double)(input.Length - 1) / (targetLength - 1);

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

{

double pos = i * step;

int idx = (int)pos;

double frac = pos - idx;

result[i] = (idx + 1 < input.Length)

? (float)((1 - frac) * input[idx] + frac * input[idx + 1])

: input[idx];

}

return result;

}

public static float[] ReadWavMonoAsFloats(string path, out int sampleRate)

{

using (BinaryReader br = new BinaryReader(File.OpenRead(path)))

{

br.BaseStream.Seek(0, SeekOrigin.Begin);

br.ReadBytes(12);

int channels = 1;

sampleRate = 44100;

int bitsPerSample = 16;

while (br.BaseStream.Position < br.BaseStream.Length)

{

string chunkID = new string(br.ReadChars(4));

int chunkSize = br.ReadInt32();

if (chunkID == "fmt ")

{

br.ReadInt16();

channels = br.ReadInt16();

sampleRate = br.ReadInt32();

br.ReadInt32();

br.ReadInt16();

bitsPerSample = br.ReadInt16();

if (chunkSize > 16) br.ReadBytes(chunkSize - 16);

}

else if (chunkID == "data")

{

int bytesPerSample = bitsPerSample / 8;

int totalSamples = chunkSize / bytesPerSample;

float[] samples = new float[totalSamples / channels];

for (int i = 0, j = 0; i < totalSamples; i++)

{

short sample = br.ReadInt16();

if (channels == 1 || i % channels == 0)

samples[j++] = sample / 32768f;

if (channels == 2) br.ReadInt16();

}

return samples;

}

else br.ReadBytes(chunkSize);

}

sampleRate = 44100;

return new float[0];

}

public static void WriteStereoSample(BinaryWriter bw, float left, float right)

{

short l = (short)(Math.Max(-1f, Math.Min(1f, left)) * 32767);

short r = (short)(Math.Max(-1f, Math.Min(1f, right)) * 32767);

bw.Write(l);

bw.Write(r);

}

public static void WriteWavHeaderPlaceholder(BinaryWriter bw, int sampleRate, int channels)

{

bw.Write(Encoding.ASCII.GetBytes("RIFF"));

bw.Write(0);

bw.Write(Encoding.ASCII.GetBytes("WAVE"));

bw.Write(Encoding.ASCII.GetBytes("fmt "));

bw.Write(16);

bw.Write((short)1);

bw.Write((short)channels);

bw.Write(sampleRate);

int byteRate = sampleRate * channels * 2;

short blockAlign = (short)(channels * 2);

bw.Write(byteRate);

bw.Write(blockAlign);

bw.Write((short)16);

bw.Write(Encoding.ASCII.GetBytes("data"));

bw.Write(0);

}

public static void PatchWavHeader(BinaryWriter bw, int sampleRate, int channels, int dataSize)

{

bw.Seek(4, SeekOrigin.Begin);

bw.Write(36 + dataSize);

bw.Seek(40, SeekOrigin.Begin);

bw.Write(dataSize);

}

}//public class ShrutiResamplerAnalyzer___WITH_BITMAPS____PANNING__________RECALCULATED___66_COPIES_SHRUTIS_PANNED_WITH_STATISTICS

// Enhanced ShrutiResampler class with statistics-based color-coded BMP/DXF and smooth stereo panning

using System;

using System.Collections.Generic;

using System.Drawing;

using System.IO;

using System.Linq;

using System.Text;

using System.Windows.Forms;

namespace ShrutiResampler

{

public class ShrutiResamplerAnalyzer___WITH_BITMAPS____PANNING__________RECALCULATED___66_COPIES_SHRUTIS_PANNED_WITH_STATISTICS

{

public static Dictionary<int, int> ThetaCounts = new Dictionary<int, int>();

public static int ThetaCountMedian = 0;

public static void FirstScanThetaBinning(string inputWavPath)

{

float[] samples = ReadWavMonoAsFloats(inputWavPath, out int sampleRate);

double dtMs = 1000.0 / sampleRate;

List<double>[] thetaBins = new List<double>[180];

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

{

thetaBins[i] = new List<double>();

ThetaCounts[i] = 0;

}

for (int i = 1; i < samples.Length; i++)

{

float amp1 = samples[i - 1];

float amp2 = samples[i];

double dAmp = amp2 - amp1;

double thetaRad = Math.Atan2(dAmp, dtMs);

double thetaDeg = (thetaRad * 180.0 / Math.PI);

if (thetaDeg < 0) thetaDeg += 180;

int bin = (int)Math.Floor(thetaDeg);

if (bin >= 0 && bin < 180)

{

double timeMs = i * dtMs;

thetaBins[bin].Add(timeMs);

ThetaCounts[bin]++;

}

ThetaCountMedian = ThetaCounts.Values.OrderBy(x => x).ElementAt(ThetaCounts.Count / 2);

SaveBitmapAndDxf(thetaBins, samples.Length, dtMs, inputWavPath);

ExportThetaStats(thetaBins, inputWavPath);

}

public static double GetPanningFactorFromThetaStats(int bin)

{

if (!ThetaCounts.ContainsKey(bin)) return 0.5;

int count = ThetaCounts[bin];

return Math.Min(1.0, count / (double)(ThetaCountMedian * 2));

}

public static void GenerateShrutiVariants___GPT(string inputWavPath, string outputWavPath)

{

float[] sourceSamples = ReadWavMonoAsFloats(inputWavPath, out int sourceRate);

int outputRate = 8000;

double originalFrequency = 440.0;

double durationSec = sourceSamples.Length / (double)sourceRate;

double totalCycleProduct = originalFrequency * durationSec;

using (FileStream fs = new FileStream(outputWavPath, FileMode.Create))

using (BinaryWriter bw = new BinaryWriter(fs))

{

WriteWavHeaderPlaceholder(bw, outputRate, 2);

for (int i = -33; i <= 32; i++)

{

double semitoneShift = i * (1.0 / 3);

double freqMultiplier = Math.Pow(2, semitoneShift / 12.0);

double newFreq = originalFrequency * freqMultiplier;

double newDuration = totalCycleProduct / newFreq;

int newSampleCount = (int)(newDuration * outputRate);

float[] resampled = ResampleWithFactor(sourceSamples, newSampleCount);

int start = 0;

for (int j = 1; j < resampled.Length; j++)

{

if ((resampled[j - 1] >= 0 && resampled[j] < 0) || (resampled[j - 1] < 0 && resampled[j] >= 0))

{

float amp1 = resampled[Math.Max(start, j - 2)];

float amp2 = resampled[Math.Max(start + 1, j - 1)];

double dAmp = amp2 - amp1;

double dt = 1.0 / outputRate * 1000.0;

double thetaRad = Math.Atan2(dAmp, dt);

double thetaDeg = thetaRad * 180.0 / Math.PI;

if (thetaDeg < 0) thetaDeg += 180;

int bin = (int)Math.Floor(thetaDeg);

double panFactor = GetPanningFactorFromThetaStats(bin);

for (int k = start; k < j; k++)

{

float l = (float)((1.0 - panFactor) * resampled[k]);

float r = (float)(panFactor * resampled[k]);

WriteStereoSample(bw, l, r);

}

start = j;

}

for (int k = start; k < resampled.Length; k++)

{

float l = resampled[k] * 0.5f;

float r = resampled[k] * 0.5f;

WriteStereoSample(bw, l, r);

}

long fileLength = fs.Position;

PatchWavHeader(bw, outputRate, 2, (int)(fileLength - 44));

}

public static void SaveBitmapAndDxf(List<double>[] thetaBins, int totalSamples, double dtMs, string basePath)

{

int maxX = (int)(totalSamples * dtMs);

int maxBitmapWidth = 10000;

double scale = 1.0;

if (maxX > maxBitmapWidth)

{

scale = (double)maxBitmapWidth / maxX;

maxX = maxBitmapWidth;

}

int height = 1800;

Bitmap bmp = new Bitmap(maxX, height);

using (Graphics g = Graphics.FromImage(bmp))

{

g.Clear(Color.White);

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

{

int y = i * height / 180;

Brush brush = new SolidBrush(GetHeatmapColor(ThetaCounts[i], 0, 1000));

foreach (double t in thetaBins[i])

{

int x = (int)(t * scale);

if (x >= 0 && x < maxX) g.FillEllipse(brush, x, y, 2, 2);

}

bmp.Save(Path.ChangeExtension(basePath, "_STATISTIKALLY_COLORED_rotations_colored.bmp"));

using (StreamWriter sw = new StreamWriter(Path.ChangeExtension(basePath, ".STATISTIKALLY_COLORED_colored.dxf")))

{

sw.WriteLine("0\nSECTION\n2\nENTITIES");

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

{

double y = i;

string layer = $"Theta_{i:D3}_Count_{ThetaCounts[i]}";

foreach (double t in thetaBins[i])

{

sw.WriteLine("0\nCIRCLE");

sw.WriteLine($"8\n{layer}");

sw.WriteLine("10\n" + t.ToString("F3"));

sw.WriteLine("20\n" + y.ToString("F3"));

sw.WriteLine("30\n0.0\n40\n0.1");

}

sw.WriteLine("0\nENDSEC\n0\nEOF");

}

public static Color GetHeatmapColor(int value, int min, int max)

{

double ratio = Math.Min(1.0, Math.Max(0.0, (value - min) / (double)(max - min)));

int r = (int)(255 * ratio);

int b = 255 - r;

return Color.FromArgb(r, 0, b);

}

public static void ExportThetaStats(List<double>[] thetaBins, string basePath)

{

using (StreamWriter sw = new StreamWriter(Path.ChangeExtension(basePath, ".theta_analysis.txt")))

{

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

{

var times = thetaBins[i];

sw.WriteLine($"Theta {i}° ({times.Count} entries)");

if (times.Count > 0)

{

double percentile25 = times[(int)(0.25 * times.Count)];

double percentile50 = times[(int)(0.50 * times.Count)];

double percentile75 = times[(int)(0.75 * times.Count)];

sw.WriteLine($"25th %ile: {percentile25} ms, 50th: {percentile50} ms, 75th: {percentile75} ms");

}

public static float[] ResampleWithFactor(float[] input, int targetLength)

{

float[] result = new float[targetLength];

double step = (double)(input.Length - 1) / (targetLength - 1);

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

{

double pos = i * step;

int idx = (int)pos;

double frac = pos - idx;

result[i] = (idx + 1 < input.Length)

? (float)((1 - frac) * input[idx] + frac * input[idx + 1])

: input[idx];

}

return result;

}

public static float[] ReadWavMonoAsFloats(string path, out int sampleRate)

{

using (BinaryReader br = new BinaryReader(File.OpenRead(path)))

{

br.BaseStream.Seek(0, SeekOrigin.Begin);

br.ReadBytes(12);

int channels = 1;

sampleRate = 44100;

int bitsPerSample = 16;

while (br.BaseStream.Position < br.BaseStream.Length)

{

string chunkID = new string(br.ReadChars(4));

int chunkSize = br.ReadInt32();

if (chunkID == "fmt ")

{

br.ReadInt16();

channels = br.ReadInt16();

sampleRate = br.ReadInt32();

br.ReadInt32();

br.ReadInt16();

bitsPerSample = br.ReadInt16();

if (chunkSize > 16) br.ReadBytes(chunkSize - 16);

}

else if (chunkID == "data")

{

int bytesPerSample = bitsPerSample / 8;

int totalSamples = chunkSize / bytesPerSample;

float[] samples = new float[totalSamples / channels];

for (int i = 0, j = 0; i < totalSamples; i++)

{

short sample = br.ReadInt16();

if (channels == 1 || i % channels == 0)

samples[j++] = sample / 32768f;

if (channels == 2) br.ReadInt16();

}

return samples;

}

else br.ReadBytes(chunkSize);

}

sampleRate = 44100;

return new float[0];

}

public static void WriteStereoSample(BinaryWriter bw, float left, float right)

{

short l = (short)(Math.Max(-1f, Math.Min(1f, left)) * 32767);

short r = (short)(Math.Max(-1f, Math.Min(1f, right)) * 32767);

bw.Write(l);

bw.Write(r);

}

public static void WriteWavHeaderPlaceholder(BinaryWriter bw, int sampleRate, int channels)

{

bw.Write(Encoding.ASCII.GetBytes("RIFF"));

bw.Write(0);

bw.Write(Encoding.ASCII.GetBytes("WAVE"));

bw.Write(Encoding.ASCII.GetBytes("fmt "));

bw.Write(16);

bw.Write((short)1);

bw.Write((short)channels);

bw.Write(sampleRate);

int byteRate = sampleRate * channels * 2;

short blockAlign = (short)(channels * 2);

bw.Write(byteRate);

bw.Write(blockAlign);

bw.Write((short)16);

bw.Write(Encoding.ASCII.GetBytes("data"));

bw.Write(0);

}

public static void PatchWavHeader(BinaryWriter bw, int sampleRate, int channels, int dataSize)

{

bw.Seek(4, SeekOrigin.Begin);

bw.Write(36 + dataSize);

bw.Seek(40, SeekOrigin.Begin);

bw.Write(dataSize);

}

drinkussions(Baban and Saanjoo)

Wednesday, June 4, 2025

STATISTIKALLY 180 ROTATIONS DONE 66 COPIES PANNED

🔧 GOAL

✅ KEY CONCEPT — Sample Rate Shifting for Pitch

✅ ENHANCED METHOD OUTLINE

✅ SUPPORT FUNCTIONS

📊 ALGORITHM SUMMARY

✅ Output

❓To Proceed

You said:

ChatGPT said:

No comments:

Post a Comment

Popular Posts

Popular Posts