namespace SAAN_FRESH___RAW_NON_APIS_WAVES_TO_SHRUTIES_COPIER_GPTS
{
public class SAANS_NO_3RD_PARTY_GPT_STYLES_WAV_FILES_READER_TO_GENERATE_8000_HZ_16_BIT_PCMS_GTAMPS
{
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
}
// 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);
}
amplitudes = resampled;
}
// 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}");
// 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
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
/// <summary>
/// /////////////////////////////////////////////////////////////////////////////////////
/// </summary>
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
No comments:
Post a Comment