// Constructor for reading
public SuperWAV(string path)
{
openMode = OpenMode.OPEN_FOR_READ;
fs = new FileStream(path, FileMode.Open, FileAccess.Read, FileShare.Read);
br = new BinaryReader(fs);
wavFormat = detectWavFormat();
if (wavFormat != WavFormat.WAVE && wavFormat != WavFormat.WAVE64 && wavFormat != WavFormat.RF64)
{
throw new Exception("Only normal WAV and WAVE64 and RF64 is supported so far, not anything else.");
}
wavInfo = readWavInfo();
if (wavInfo.audioFormat != AudioFormat.LPCM && wavInfo.audioFormat != AudioFormat.FLOAT)
{
throw new Exception("Only uncompressed WAV currently supported.");
}
// Sanity checks
if (wavInfo.bitsPerSample * wavInfo.channelCount / 8 != wavInfo.bytesPerTick)
{
throw new Exception("Uhm what?");
}
else if (wavInfo.byteRate != wavInfo.sampleRate * wavInfo.bytesPerTick)
{
throw new Exception("Uhm what?");
}
bytesPerSample = (UInt16)(wavInfo.bitsPerSample / 8U);
dataLengthInTicks = wavInfo.dataLength / wavInfo.bytesPerTick;
}
private string tempStr = ""; // temporary directory to store the converted audio file
private void StartRecognize(string apiRecord)
{
WavInfo wav = ClassUtils.GetWavInfo(apiRecord);
//数据量 = (采样频率 × 采样位数 × 声道数 × 时间) / 8
//if ((double)(wav.datasize * 8) / (wav.dwsamplespersec * wav.wbitspersample * wav.wchannels) > 60)
//{
// labelInfo.ForeColor = Color.HotPink;
// labelInfo.Text = "Error: The audio file is too large!";
//}
// 非8k/16k, 16bit 位深, 单声道的，进行格式转换
if (apiRecord.EndsWith(".mp3", StringComparison.CurrentCultureIgnoreCase) ||
int.Parse(wav.dwsamplespersec.ToString()) != 16000 ||
int.Parse(wav.wbitspersample.ToString()) != 16 ||
int.Parse(wav.wchannels.ToString()) != 1)
{
apiRecord = ClassUtils.Convert2Wav(apiRecord); // convert audio file to 16k，16bit wav
tempStr = apiRecord;
}
labelInfo.ForeColor = Color.SpringGreen;
labelInfo.Text = "Recognizing...";
KeyValuePair <string, string> keyVal = (KeyValuePair <string, string>)comboBoxLan.SelectedItem;
speechModel.APILanguage = keyVal.Value; // fetch the value in comboBox
if (backgroundWorker.IsBusy != true)
{
this.backgroundWorker.RunWorkerAsync(); // do the time consuming task
}
}
public bool GetWavInfo(string strpath)
{
WavInfo wavInfo = new WavInfo();
FileInfo fi = new FileInfo(strpath);
FileStream fs = fi.OpenRead();
if (fs.Length >= 44)
{
byte[] bInfo = new byte[44];
fs.Read(bInfo, 0, 44);
wavInfo.groupid = Encoding.Default.GetString(bInfo, 0, 4);
wavInfo.filesize = BitConverter.ToInt32(bInfo, 4);
wavInfo.rifftype = Encoding.Default.GetString(bInfo, 8, 4);
wavInfo.chunkid = Encoding.Default.GetString(bInfo, 12, 4);
if (wavInfo.groupid == "RIFF" && wavInfo.rifftype == "WAVE" && wavInfo.chunkid == "fmt ")
{
wavInfo.chunksize = BitConverter.ToInt32(bInfo, 16);
wavInfo.wformattag = BitConverter.ToInt16(bInfo, 20);
wavInfo.wchannels = BitConverter.ToUInt16(bInfo, 22);
wavInfo.dwsamplespersec = BitConverter.ToUInt32(bInfo, 24);
wavInfo.dwavgbytespersec = BitConverter.ToUInt32(bInfo, 28);
wavInfo.wblockalign = BitConverter.ToUInt16(bInfo, 32);
wavInfo.wbitspersample = BitConverter.ToUInt16(bInfo, 34);
wavInfo.datachunkid = Encoding.Default.GetString(bInfo, 36, 4);
wavInfo.datasize = BitConverter.ToInt32(bInfo, 40);
// 读取音频数据
int readBytes = 44, bufBytes = 0, buffSize = 0;
int dataSize = (int)wavInfo.datasize;
byte[] fileBuf = new byte[G722_WAVE_FRAME_SIZE];
_wav_buffer = new sbyte[G722_WAVE_FRAME_SIZE];
_dec_buffer = new sbyte[G722_VOICE_FRAME_SIZE];
//fs.Read(_buffer, 44, wavInfo.datasize);
while (readBytes < dataSize)
{
bufBytes = dataSize - readBytes;
if (bufBytes > G722_WAVE_FRAME_SIZE)
{
bufBytes = G722_WAVE_FRAME_SIZE;
}
buffSize = fs.Read(fileBuf, 0, bufBytes);
for (int i = 0; i < bufBytes; i++)
{
if (fileBuf[i] > 127)
{
_wav_buffer[i] = (sbyte)(fileBuf[i] - 256);
}
else
{
_wav_buffer[i] = (sbyte)fileBuf[i];
}
}
HCNetSDK.NET_DVR_EncodeG722Frame(_dec_handle, _wav_buffer, _dec_buffer);
readBytes += buffSize;
}
return(true);
}
}
return(false);
}
/// <summary>
/// 取出WAV头信息
/// </summary>
/// <param name="filePath"></param>
/// <returns></returns>
public static WavInfo GetWavInfo(string filePath)
{
WavInfo wavInfo = new WavInfo();
FileInfo fi = new FileInfo(filePath);
using (System.IO.FileStream fs = fi.OpenRead())
{
if (fs.Length >= 44)
{
byte[] bInfo = new byte[44];
fs.Read(bInfo, 0, 44);
System.Text.Encoding.Default.GetString(bInfo, 0, 4);
if (System.Text.Encoding.Default.GetString(bInfo, 0, 4) == "RIFF" && System.Text.Encoding.Default.GetString(bInfo, 8, 4) == "WAVE" && System.Text.Encoding.Default.GetString(bInfo, 12, 4) == "fmt ")
{
wavInfo.groupid = System.Text.Encoding.Default.GetString(bInfo, 0, 4);
System.BitConverter.ToInt32(bInfo, 4);
wavInfo.filesize = System.BitConverter.ToInt32(bInfo, 4);
//wavInfo.filesize = Convert.ToInt64(System.Text.Encoding.Default.GetString(bInfo,4,4));
wavInfo.rifftype = System.Text.Encoding.Default.GetString(bInfo, 8, 4);
wavInfo.chunkid = System.Text.Encoding.Default.GetString(bInfo, 12, 4);
wavInfo.chunksize = System.BitConverter.ToInt32(bInfo, 16);
wavInfo.wformattag = System.BitConverter.ToInt16(bInfo, 20);
wavInfo.wchannels = System.BitConverter.ToUInt16(bInfo, 22);
wavInfo.dwsamplespersec = System.BitConverter.ToUInt32(bInfo, 24);
wavInfo.dwavgbytespersec = System.BitConverter.ToUInt32(bInfo, 28);
wavInfo.wblockalign = System.BitConverter.ToUInt16(bInfo, 32);
wavInfo.wbitspersample = System.BitConverter.ToUInt16(bInfo, 34);
wavInfo.datachunkid = System.Text.Encoding.Default.GetString(bInfo, 36, 4);
wavInfo.datasize = System.BitConverter.ToInt32(bInfo, 40);
}
}
}
return(wavInfo);
}
public static WavInfo GetWavInfo(string fileName)
{
WavInfo wavInfo = new WavInfo();
FileInfo fi = new FileInfo(fileName);
using (FileStream fs = new FileStream(fileName, FileMode.Open, FileAccess.Read, FileShare.ReadWrite))
{
if (fs.Length >= 44)
{
byte[] bInfo = new byte[44];
fs.Read(bInfo, 0, 44);
Encoding.Default.GetString(bInfo, 0, 4);
if (Encoding.Default.GetString(bInfo, 0, 4) == "RIFF" && Encoding.Default.GetString(bInfo, 8, 4) == "WAVE" && Encoding.Default.GetString(bInfo, 12, 4) == "fmt ")
{
wavInfo.groupid = Encoding.Default.GetString(bInfo, 0, 4);
System.BitConverter.ToInt32(bInfo, 4);
wavInfo.filesize = System.BitConverter.ToInt32(bInfo, 4);
wavInfo.rifftype = Encoding.Default.GetString(bInfo, 8, 4);
wavInfo.chunkid = Encoding.Default.GetString(bInfo, 12, 4);
wavInfo.chunksize = System.BitConverter.ToInt32(bInfo, 16);
wavInfo.wformattag = System.BitConverter.ToInt16(bInfo, 20);
wavInfo.wchannels = System.BitConverter.ToUInt16(bInfo, 22);
wavInfo.dwsamplespersec = System.BitConverter.ToUInt32(bInfo, 24);
wavInfo.dwavgbytespersec = System.BitConverter.ToUInt32(bInfo, 28);
wavInfo.wblockalign = System.BitConverter.ToUInt16(bInfo, 32);
wavInfo.wbitspersample = System.BitConverter.ToUInt16(bInfo, 34);
wavInfo.datachunkid = Encoding.Default.GetString(bInfo, 36, 4);
wavInfo.datasize = System.BitConverter.ToInt32(bInfo, 40);
}
}
}
return(wavInfo);
}
public void SendWavFile(object strpath)
{
WavInfo wavInfo = new WavInfo();
FileInfo fi = new FileInfo((string)strpath);
FileStream fs = fi.OpenRead();
bool ret = false;
if (fs.Length >= 44)
{
byte[] bInfo = new byte[44];
fs.Read(bInfo, 0, 44);
wavInfo.groupid = Encoding.Default.GetString(bInfo, 0, 4);
wavInfo.filesize = BitConverter.ToInt32(bInfo, 4);
wavInfo.rifftype = Encoding.Default.GetString(bInfo, 8, 4);
wavInfo.chunkid = Encoding.Default.GetString(bInfo, 12, 4);
if (wavInfo.groupid == "RIFF" && wavInfo.rifftype == "WAVE" && wavInfo.chunkid == "fmt ")
{
wavInfo.chunksize = BitConverter.ToInt32(bInfo, 16);
wavInfo.wformattag = BitConverter.ToInt16(bInfo, 20);
wavInfo.wchannels = BitConverter.ToUInt16(bInfo, 22);
wavInfo.dwsamplespersec = BitConverter.ToUInt32(bInfo, 24);
wavInfo.dwavgbytespersec = BitConverter.ToUInt32(bInfo, 28);
wavInfo.wblockalign = BitConverter.ToUInt16(bInfo, 32);
wavInfo.wbitspersample = BitConverter.ToUInt16(bInfo, 34);
wavInfo.datachunkid = Encoding.Default.GetString(bInfo, 36, 4);
wavInfo.datasize = BitConverter.ToInt32(bInfo, 40);
// 读取音频数据
int readBytes = 0, bufBytes = 0, buffSize = 0;
int dataSize = (int)wavInfo.datasize;
byte[] fileBuf = new byte[G722_WAVE_FRAME_SIZE];
byte[] _wav_buffer = new byte[G722_WAVE_FRAME_SIZE];
byte[] _dec_buffer = new byte[G722_VOICE_FRAME_SIZE];
//fs.Read(_buffer, 44, wavInfo.datasize);
while (readBytes < dataSize)
{
bufBytes = dataSize - readBytes;
if (bufBytes > G722_WAVE_FRAME_SIZE)
{
bufBytes = G722_WAVE_FRAME_SIZE;
}
buffSize = fs.Read(fileBuf, 0, bufBytes);
if (buffSize == 0)
{
break;
}
ret = HCNetSDK.NET_DVR_EncodeG722Frame(_dec_handle, fileBuf, _dec_buffer);
ret = HCNetSDK.NET_DVR_VoiceComSendData(_voice_handle, _dec_buffer, G722_VOICE_FRAME_SIZE);
readBytes += buffSize;
Thread.Sleep(40);
}
StopTalk();
//return true;
}
}
// return false;
}
public static WavInfo GetInfo(Stream stream)
{
ReadHeaders(stream, out FmtHeader fmtHeader, out DataHeader dataHeader, out long _);
WavInfo result = default(WavInfo);
result.ChannelsCount = fmtHeader.ChannelsCount;
result.SamplingFrequency = fmtHeader.SamplingFrequency;
result.BytesCount = dataHeader.DataSize;
return(result);
}
public static string checkAudio(string fileName)
{
WavInfo wav = ClassUtils.GetWavInfo(fileName);
//数据量 = (采样频率 × 采样位数 × 声道数 × 时间) / 8
// 非8k/16k, 16bit 位深, 单声道的，进行格式转换
if (fileName.EndsWith(".mp3", StringComparison.CurrentCultureIgnoreCase) ||
int.Parse(wav.dwsamplespersec.ToString()) != 16000 ||
int.Parse(wav.wbitspersample.ToString()) != 16 ||
int.Parse(wav.wchannels.ToString()) != 1)
{
fileName = ClassUtils.Convert2Wav(fileName); // convert audio file to 16k，16bit wav
}
return(fileName);
}
private WavInfo readWavInfo()
{
checkClosed();
WavInfo retVal = new WavInfo();
if (wavFormat == WavFormat.WAVE)
{
UInt64 fmtChunkLength = 0;
// find fmt chunk
ChunkInfo chunk = new ChunkInfo();
UInt64 currentPosition = 12;
UInt64 resultPosition;
do
{
chunk = readChunk32(currentPosition); // TODO gracefully handle error if no data chunk exists. Currently would crash.
resultPosition = currentPosition;
currentPosition += 8 + chunk.size;
} while (chunk.name != "FMT ");
fmtChunkLength = chunk.size;
br.BaseStream.Seek((Int64)(resultPosition + (UInt64)8), SeekOrigin.Begin);
retVal.audioFormat = (AudioFormat)br.ReadUInt16();
retVal.channelCount = br.ReadUInt16();
retVal.sampleRate = br.ReadUInt32();
retVal.byteRate = br.ReadUInt32();
retVal.bytesPerTick = br.ReadUInt16();
retVal.bitsPerSample = br.ReadUInt16();
// WAVE Extensible handling
if (retVal.audioFormat == AudioFormat.WAVE_FORMAT_EXTENSIBLE)
{
if (fmtChunkLength > 16)
{
UInt16 restChunkLength = br.ReadUInt16(); // This is a guess!
if (restChunkLength >= 8)
{
_ = br.ReadUInt16(); // This appears to be once again bits per sample.
_ = br.ReadUInt32(); // Channel mask. Irrelevant for us.
retVal.audioFormat = (AudioFormat)br.ReadUInt16(); // Here we go.
// The rest of the fmt chunk is a GUID thingie, not interesting.
}
else
{
throw new Exception("Weird fmt chunk");
}
}
else
{
throw new Exception("Weird fmt chunk");
}
}
// find data chunk
currentPosition = 12;
do
{
chunk = readChunk32(currentPosition); // TODO gracefully handle error if no data chunk exists. Currently would crash.
resultPosition = currentPosition;
currentPosition += 8 + chunk.size;
} while (chunk.name != "DATA");
retVal.dataOffset = resultPosition + 8;
retVal.dataLength = chunk.size;
}
else if (wavFormat == WavFormat.WAVE64) // Todo: respect 8 byte boundaries.
{
// find fmt chunk
ChunkInfo chunk = new ChunkInfo();
UInt64 currentPosition = 40;
UInt64 resultPosition;
do
{
if (currentPosition % 8 != 0)
{
currentPosition = ((currentPosition / 8) + 1) * 8; // Need to remember that wave64 stuff always needs to be aligned on 8 byte boundaries!
}
chunk = readChunkWave64(currentPosition); // TODO gracefully handle error if no data chunk exists. Currently would crash.
resultPosition = currentPosition;
currentPosition += 24 + chunk.size;
} while (chunk.name != "FMT " || !chunk.isValidWave64LegacyRIFFCode);
br.BaseStream.Seek((Int64)(resultPosition + (UInt64)24), SeekOrigin.Begin);
//br.BaseStream.Seek(64, SeekOrigin.Begin);
retVal.audioFormat = (AudioFormat)br.ReadUInt16();
retVal.channelCount = br.ReadUInt16();
retVal.sampleRate = br.ReadUInt32();
retVal.byteRate = br.ReadUInt32();
retVal.bytesPerTick = br.ReadUInt16();
retVal.bitsPerSample = br.ReadUInt16();
// find data chunk
currentPosition = 40;
do
{
if (currentPosition % 8 != 0)
{
currentPosition = ((currentPosition / 8) + 1) * 8; // Need to remember that wave64 stuff always needs to be aligned on 8 byte boundaries!
}
chunk = readChunkWave64(currentPosition); // TODO gracefully handle error if no data chunk exists. Currently would crash.
resultPosition = currentPosition;
currentPosition += 24 + chunk.size;
} while (chunk.name != "DATA" || !chunk.isValidWave64LegacyRIFFCode);
retVal.dataOffset = resultPosition + 24;
retVal.dataLength = chunk.size;
}
else if (wavFormat == WavFormat.RF64)
{
br.BaseStream.Seek(20, SeekOrigin.Begin);
UInt64 ds64_riffSize = br.ReadUInt64();
UInt64 ds64_dataSize = br.ReadUInt64();
UInt64 fmtChunkLength = 0;
// find fmt chunk
ChunkInfo chunk = new ChunkInfo();
UInt64 currentPosition = 12;
UInt64 resultPosition;
do
{
chunk = readChunk32(currentPosition); // TODO gracefully handle error if no data chunk exists. Currently would crash.
resultPosition = currentPosition;
currentPosition += 8 + chunk.size;
} while (chunk.name != "FMT ");
fmtChunkLength = chunk.size;
br.BaseStream.Seek((Int64)(resultPosition + (UInt64)8), SeekOrigin.Begin);
// read fmt chunk data, as usual
retVal.audioFormat = (AudioFormat)br.ReadUInt16();
retVal.channelCount = br.ReadUInt16();
retVal.sampleRate = br.ReadUInt32();
retVal.byteRate = br.ReadUInt32();
retVal.bytesPerTick = br.ReadUInt16();
retVal.bitsPerSample = br.ReadUInt16();
// WAVE Extensible handling
if (retVal.audioFormat == AudioFormat.WAVE_FORMAT_EXTENSIBLE)
{
if (fmtChunkLength > 16)
{
UInt16 restChunkLength = br.ReadUInt16(); // This is a guess!
if (restChunkLength >= 8)
{
_ = br.ReadUInt16(); // This appears to be once again bits per sample.
_ = br.ReadUInt32(); // Channel mask. Irrelevant for us.
retVal.audioFormat = (AudioFormat)br.ReadUInt16(); // Here we go.
// The rest of the fmt chunk is a GUID thingie, not interesting.
}
else
{
throw new Exception("Weird fmt chunk");
}
}
else
{
throw new Exception("Weird fmt chunk");
}
}
// find data chunk
currentPosition = 12;
do
{
chunk = readChunk32(currentPosition); // TODO gracefully handle error if no data chunk exists. Currently would crash.
resultPosition = currentPosition;
currentPosition += 8 + chunk.size;
} while (chunk.name != "DATA");
retVal.dataOffset = resultPosition + 8;
retVal.dataLength = chunk.size == RF64_MINUS1_VALUE ? ds64_dataSize : chunk.size; // According to specification, we must read the size from this chunk unless it's FFFFFFFF (or -1 if interpreted as signed Int32)
}
else
{
// Not supported (yet)
}
return(retVal);
}
// Write the bare minimum for a working file.
private void writeFileHusk(WavFormat wavFormatA, ref WavInfo wavInfoA)
{
checkClosed();
if (openMode == OpenMode.CREATE_FOR_READ_WRITE)
{
if (wavFormatA == WavFormat.WAVE)
{
bw.Seek(0, SeekOrigin.Begin);
bw.Write("RIFF".ToCharArray());
bw.Write((UInt32)0);
bw.Write("WAVE".ToCharArray());
bw.Write("fmt ".ToCharArray());
bw.Write((UInt32)16);
bw.Write((UInt16)wavInfoA.audioFormat);
bw.Write((UInt16)wavInfoA.channelCount);
bw.Write((UInt32)wavInfoA.sampleRate);
bw.Write((UInt32)wavInfoA.byteRate);
bw.Write((UInt16)wavInfoA.bytesPerTick);
bw.Write((UInt16)wavInfoA.bitsPerSample);
bw.Write("data".ToCharArray());
bw.Write((UInt32)wavInfoA.dataLength);
wavInfoA.dataOffset = (UInt64)bw.BaseStream.Position;
bw.BaseStream.Seek((Int64)wavInfoA.dataLength /*-1*/, SeekOrigin.Current);
bw.Write((byte)0);
Int64 currentPosition = bw.BaseStream.Position;
bw.Seek(4, SeekOrigin.Begin);
bw.Write((UInt32)currentPosition - 8); // TODO Check if -8 is actually correct
}
else if (wavFormat == WavFormat.WAVE64)
{
bw.Seek(0, SeekOrigin.Begin);
bw.Write("riff".ToCharArray());
bw.Write(WAVE64_GUIDFOURCC_RIFF_LAST12);
bw.Write((UInt64)0);
bw.Write("wave".ToCharArray());
bw.Write(WAVE64_GUIDFOURCC_LAST12);
bw.Write("fmt ".ToCharArray());
bw.Write(WAVE64_GUIDFOURCC_LAST12);
bw.Write((UInt64)(16 + WAVE64_SIZE_DIFFERENCE));
bw.Write((UInt16)wavInfoA.audioFormat);
bw.Write((UInt16)wavInfoA.channelCount);
bw.Write((UInt32)wavInfoA.sampleRate);
bw.Write((UInt32)wavInfoA.byteRate);
bw.Write((UInt16)wavInfoA.bytesPerTick);
bw.Write((UInt16)wavInfoA.bitsPerSample);
bw.Write("data".ToCharArray());
bw.Write(WAVE64_GUIDFOURCC_LAST12);
bw.Write((UInt64)wavInfoA.dataLength + WAVE64_SIZE_DIFFERENCE);
wavInfoA.dataOffset = (UInt64)bw.BaseStream.Position;
bw.BaseStream.Seek((Int64)wavInfoA.dataLength /*-1*/, SeekOrigin.Current);
bw.Write((byte)0);
Int64 currentPosition = bw.BaseStream.Position;
bw.Seek(4 + 12, SeekOrigin.Begin);
bw.Write((UInt64)currentPosition);
}
else if (wavFormat == WavFormat.RF64)
{
throw new Exception("Writing RF64 is not yet implemented.");
}
else
{
throw new Exception("Whut? " + wavFormat + "? What do you mean by " + wavFormat + "?");
}
}
else
{
throw new Exception("Trying to initialize an already existing file! Don't do that!");
}
}
public static WavInfo GetWavInfo(string strpath)
{
WavInfo wavInfo = new WavInfo();
FileInfo fi = new FileInfo(strpath);
using (System.IO.FileStream fs = fi.OpenRead())
{
if (fs.Length >= 44)
{
byte[] bInfo = new byte[44];
fs.Read(bInfo, 0, 44);
wavInfo.Header = bInfo;
System.Text.Encoding.Default.GetString(bInfo, 0, 4);
if (System.Text.Encoding.Default.GetString(bInfo, 0, 4) == "RIFF" &&
System.Text.Encoding.Default.GetString(bInfo, 8, 4) == "WAVE" &&
System.Text.Encoding.Default.GetString(bInfo, 12, 4) == "fmt ")
{
wavInfo.ChunkID = System.Text.Encoding.Default.GetString(bInfo, 0, 4);
wavInfo.ChunkSize = System.BitConverter.ToInt32(bInfo, 4);
//wavInfo.filesize = Convert.ToInt64(System.Text.Encoding.Default.GetString(bInfo,4,4));
wavInfo.Format = System.Text.Encoding.Default.GetString(bInfo, 8, 4);
wavInfo.Subchunk1ID = System.Text.Encoding.Default.GetString(bInfo, 12, 4);
wavInfo.Subchunk1Size = System.BitConverter.ToInt32(bInfo, 16);
wavInfo.AudioFormat = System.BitConverter.ToInt16(bInfo, 20);
wavInfo.NumChannels = System.BitConverter.ToUInt16(bInfo, 22);
wavInfo.SampleRate = System.BitConverter.ToUInt32(bInfo, 24);
wavInfo.ByteRate = System.BitConverter.ToUInt32(bInfo, 28);
wavInfo.BlockAlign = System.BitConverter.ToUInt16(bInfo, 32);
wavInfo.BitesPerSample = System.BitConverter.ToUInt16(bInfo, 34);
wavInfo.Subchunk2ID = System.Text.Encoding.Default.GetString(bInfo, 36, 4);
wavInfo.Subchunk2Size = System.BitConverter.ToInt32(bInfo, 40);
//System.Console.WriteLine("NumChannels:" + wavInfo.NumChannels);
//System.Console.WriteLine("SampleRate:" + wavInfo.SampleRate);
//System.Console.WriteLine("file real size:" + (wavInfo.Subchunk2Size + 44) + " bytes");
//System.Console.WriteLine("ChunkID:" + wavInfo.ChunkID);
//System.Console.WriteLine("ChunkSize:" + wavInfo.ChunkSize);
////System.Console.WriteLine("file real size:" + (wavInfo.ChunkSize + 8)); // TODO error
//System.Console.WriteLine("Format:" + wavInfo.Format);
//System.Console.WriteLine("Subchunk1ID:" + wavInfo.Subchunk1ID);
//System.Console.WriteLine("Subchunk1Size:" + wavInfo.Subchunk1Size);
//System.Console.WriteLine("AudioFormat:" + wavInfo.AudioFormat);
//System.Console.WriteLine("ByteRate:" + wavInfo.ByteRate);
//System.Console.WriteLine("BlockAlign:" + wavInfo.BlockAlign);
//System.Console.WriteLine("BitesPerSample:" + wavInfo.BitesPerSample);
//System.Console.WriteLine("Subchunk2ID:" + wavInfo.Subchunk2ID);
//System.Console.WriteLine("Subchunk2Size:" + wavInfo.Subchunk2Size + " bytes");
return(wavInfo);
}
}
}
return(new WavInfo());
}
public void SendWavFile(object strpath)
{
WavInfo wavInfo = new WavInfo();
FileInfo fi = new FileInfo((string)strpath);
FileStream fs = fi.OpenRead();
bool ret = false;
if (fs.Length >= 44)
{
byte[] bInfo = new byte[44];
fs.Read(bInfo, 0, 44);
wavInfo.groupid = Encoding.Default.GetString(bInfo, 0, 4);
wavInfo.filesize = BitConverter.ToInt32(bInfo, 4);
wavInfo.rifftype = Encoding.Default.GetString(bInfo, 8, 4);
wavInfo.chunkid = Encoding.Default.GetString(bInfo, 12, 4);
if (wavInfo.groupid == "RIFF" && wavInfo.rifftype == "WAVE" && wavInfo.chunkid == "fmt ")
{
wavInfo.chunksize = BitConverter.ToInt32(bInfo, 16);
wavInfo.wformattag = BitConverter.ToInt16(bInfo, 20);
wavInfo.wchannels = BitConverter.ToUInt16(bInfo, 22);
wavInfo.dwsamplespersec = BitConverter.ToUInt32(bInfo, 24);
wavInfo.dwavgbytespersec = BitConverter.ToUInt32(bInfo, 28);
wavInfo.wblockalign = BitConverter.ToUInt16(bInfo, 32);
wavInfo.wbitspersample = BitConverter.ToUInt16(bInfo, 34);
wavInfo.datachunkid = Encoding.Default.GetString(bInfo, 36, 4);
wavInfo.datasize = BitConverter.ToInt32(bInfo, 40);
// 读取音频数据
int readBytes = 0, bufBytes = 0, buffSize = 0;
int dataSize = (int)wavInfo.datasize;
byte[] fileBuf = new byte[G722_WAVE_FRAME_SIZE];
byte[] _wav_buffer = new byte[G722_WAVE_FRAME_SIZE];
byte[] _dec_buffer = new byte[G722_VOICE_FRAME_SIZE];
//fs.Read(_buffer, 44, wavInfo.datasize);
while (readBytes < dataSize)
{
bufBytes = dataSize - readBytes;
if (bufBytes > G722_WAVE_FRAME_SIZE) bufBytes = G722_WAVE_FRAME_SIZE;
buffSize = fs.Read(fileBuf, 0, bufBytes);
if (buffSize == 0) break;
ret = HCNetSDK.NET_DVR_EncodeG722Frame(_dec_handle, fileBuf, _dec_buffer);
ret = HCNetSDK.NET_DVR_VoiceComSendData(_voice_handle, _dec_buffer, G722_VOICE_FRAME_SIZE);
readBytes += buffSize;
Thread.Sleep(40);
}
StopTalk();
//return true;
}
}
// return false;
}
public bool GetWavInfo(string strpath)
{
WavInfo wavInfo = new WavInfo();
FileInfo fi = new FileInfo(strpath);
FileStream fs = fi.OpenRead();
if (fs.Length >= 44)
{
byte[] bInfo = new byte[44];
fs.Read(bInfo, 0, 44);
wavInfo.groupid = Encoding.Default.GetString(bInfo, 0, 4);
wavInfo.filesize = BitConverter.ToInt32(bInfo, 4);
wavInfo.rifftype = Encoding.Default.GetString(bInfo, 8, 4);
wavInfo.chunkid = Encoding.Default.GetString(bInfo, 12, 4);
if (wavInfo.groupid == "RIFF" && wavInfo.rifftype == "WAVE" && wavInfo.chunkid == "fmt ")
{
wavInfo.chunksize = BitConverter.ToInt32(bInfo, 16);
wavInfo.wformattag = BitConverter.ToInt16(bInfo, 20);
wavInfo.wchannels = BitConverter.ToUInt16(bInfo, 22);
wavInfo.dwsamplespersec = BitConverter.ToUInt32(bInfo, 24);
wavInfo.dwavgbytespersec = BitConverter.ToUInt32(bInfo, 28);
wavInfo.wblockalign = BitConverter.ToUInt16(bInfo, 32);
wavInfo.wbitspersample = BitConverter.ToUInt16(bInfo, 34);
wavInfo.datachunkid = Encoding.Default.GetString(bInfo, 36, 4);
wavInfo.datasize = BitConverter.ToInt32(bInfo, 40);
// 读取音频数据
int readBytes = 44, bufBytes = 0, buffSize = 0;
int dataSize = (int)wavInfo.datasize;
byte[] fileBuf = new byte[G722_WAVE_FRAME_SIZE];
_wav_buffer = new sbyte[G722_WAVE_FRAME_SIZE];
_dec_buffer = new sbyte[G722_VOICE_FRAME_SIZE];
//fs.Read(_buffer, 44, wavInfo.datasize);
while (readBytes < dataSize)
{
bufBytes = dataSize - readBytes;
if (bufBytes > G722_WAVE_FRAME_SIZE) bufBytes = G722_WAVE_FRAME_SIZE;
buffSize = fs.Read(fileBuf, 0, bufBytes);
for (int i = 0; i < bufBytes; i++)
{
if (fileBuf[i] > 127)
{
_wav_buffer[i] = (sbyte)(fileBuf[i] - 256);
}
else
{
_wav_buffer[i] = (sbyte)fileBuf[i];
}
}
HCNetSDK.NET_DVR_EncodeG722Frame(_dec_handle, _wav_buffer, _dec_buffer);
readBytes += buffSize;
}
return true;
}
}
return false;
}
