public void CanGetNextSample()
{
IWMSyncReader reader = OpenWmaFile();
INSSBuffer buffer;
long sampleTime;
long duration;
uint flags;
uint outputNum;
ushort streamNum;
uint hresult = reader.GetNextSample(0, out buffer, out sampleTime, out duration, out flags, out outputNum, out streamNum);
Assert.AreEqual(0, hresult);
//byte[] theBuffer;
//buffer.GetBuffer(out theBuffer);
hresult = reader.Close();
Assert.AreEqual(0, hresult);
Marshal.ReleaseComObject(reader);
/*
* //char[] nameBuffer = new char[256];
* ushort length = 256;
* string name = new string(' ', 256);
* props.GetConnectionName(name, ref length);
* //string name = new string(nameBuffer, 0, length);
* Assert.IsFalse(String.IsNullOrEmpty(name));*/
}
private void TestSample()
{
int iSize;
m_read.GetMaxOutputSampleSize(0, out iSize);
Debug.Assert(iSize > 0);
INSSBuffer pSamp;
long l;
long d;
SampleFlag f;
int i;
short s;
m_read.GetNextSample(1, out pSamp, out l, out d, out f, out i, out s);
Debug.Assert(pSamp != null);
Debug.Assert(d > 0);
Debug.Assert(s == 1);
int iMax;
m_read.GetMaxStreamSampleSize(1, out iMax);
Debug.Assert(iMax > 0);
}
/// <summary>
/// Write the PCM audio data to a stream
/// </summary>
public void WriteTo(Stream stream)
{
_asfMemoryStream = new AsfIStream(_asfStream);
WMUtils.WMCreateSyncReader(IntPtr.Zero, Rights.Playback, out _syncReader);
_syncReader.OpenStream(_asfMemoryStream);
short audioStreamNum = (short)_asfStream.Configuration.AsfAudioStreamId;
_syncReader.SetReadStreamSamples(audioStreamNum, false);
long cnsSampleTime;
long cnsSampleDuration;
SampleFlag dwFlags;
INSSBuffer pSample;
int dwOutputNum = 0;
short dwStreamNum = 0;
try
{
while (true)
{
_syncReader.GetNextSample(audioStreamNum, out pSample, out cnsSampleTime, out cnsSampleDuration, out dwFlags, out dwOutputNum, out dwStreamNum);
IntPtr pBuffer;
int bufferLength;
pSample.GetBufferAndLength(out pBuffer, out bufferLength);
byte[] sampleData = new byte[bufferLength];
Marshal.Copy(pBuffer, sampleData, 0, bufferLength);
Marshal.FinalReleaseComObject(pSample);
stream.Write(sampleData, 0, sampleData.Length);
}
}
catch (COMException) // no more samples or corrupted content
{
}
}
private bool ReadNextSample(out INSSBuffer buffer, out long duration,
out SampleFlag sampleFlag)
{
try
{
long sampleTime;
int outputNum;
short streamNum;
syncReader.GetNextSample(0, out buffer, out sampleTime, out duration, out sampleFlag,
out outputNum, out streamNum);
}
catch (Exception)
{
buffer = null;
duration = 0;
sampleFlag = 0;
return(false);
}
return(true);
}
public int Read(AudioBuffer buff, int maxLength)
{
buff.Prepare(this, maxLength);
int buff_offset = 0;
int buff_size = buff.ByteLength;
while (m_pSampleSize < buff_size)
{
if (m_pSampleSize > 0)
{
IntPtr pdwBuffer;
m_pSample.GetBuffer(out pdwBuffer);
Marshal.Copy((IntPtr)(pdwBuffer.ToInt64() + m_pSampleOffset), buff.Bytes, buff_offset, m_pSampleSize);
buff_size -= m_pSampleSize;
buff_offset += m_pSampleSize;
m_sampleOffset += m_pSampleSize;
m_pSampleSize = 0;
Marshal.ReleaseComObject(m_pSample);
m_pSample = null;
}
long cnsSampleTime;
long cnsDuration;
SampleFlag flags;
int dwOutputNum;
short wStreamNum;
try
{
m_syncReader.GetNextSample(m_wStreamNum, out m_pSample, out cnsSampleTime, out cnsDuration, out flags, out dwOutputNum, out wStreamNum);
}
catch (COMException ex)
{
// EOF
if (ex.ErrorCode == NSResults.E_NO_MORE_SAMPLES)
{
if ((m_sampleOffset % PCM.BlockAlign) != 0)
{
throw new Exception("(m_sampleOffset % PCM.BlockAlign) != 0");
}
m_sampleCount = m_sampleOffset / PCM.BlockAlign;
if ((buff_offset % PCM.BlockAlign) != 0)
{
throw new Exception("(buff_offset % PCM.BlockAlign) != 0");
}
return(buff.Length = buff_offset / PCM.BlockAlign);
}
throw ex;
}
//if (dwOutputNum != m_dwAudioOutputNum || wStreamNum != m_wStreamNum)
//{
//}
m_pSampleOffset = 0;
m_pSample.GetLength(out m_pSampleSize);
}
if (buff_size > 0)
{
IntPtr pdwBuffer;
m_pSample.GetBuffer(out pdwBuffer);
Marshal.Copy((IntPtr)(pdwBuffer.ToInt64() + m_pSampleOffset), buff.Bytes, buff_offset, buff_size);
m_pSampleOffset += buff_size;
m_pSampleSize -= buff_size;
m_sampleOffset += buff_size;
buff_offset += buff_size;
buff_size = 0;
}
if ((buff_offset % PCM.BlockAlign) != 0)
{
throw new Exception("(buff_offset % PCM.BlockAlign) != 0");
}
return(buff.Length = buff_offset / PCM.BlockAlign);
}
public override int Read(byte[] buffer, int offset, int count)
{
if (m_Reader != null)
{
int read = 0;
if ((m_Length > 0) && ((m_Length - m_Position) < count))
{
count = (int)(m_Length - m_Position);
}
if (m_BufferReader != null)
{
while ((m_BufferReader.Position < m_BufferReader.Length) && (read < count))
{
read += m_BufferReader.Read(buffer, offset, count);
}
}
while (read < count)
{
INSSBuffer sample = null;
ulong SampleTime = 0;
ulong Duration = 0;
uint Flags = 0;
try {
m_Reader.GetNextSample(m_OuputStream, out sample, out SampleTime, out Duration, out Flags, out m_OutputNumber, out m_OuputStream);
} catch (COMException e) {
if (e.ErrorCode == WM.NS_E_NO_MORE_SAMPLES)
{
//No more samples
if (m_OutputFormat.wBitsPerSample == 8)
{
while (read < count)
{
buffer[offset + read] = 0x80;
read++;
}
}
else
{
Array.Clear(buffer, offset + read, count - read);
read = count;
}
break;
}
else
{
throw(e);
}
}
m_BufferReader = new NSSBuffer(sample);
read += m_BufferReader.Read(buffer, offset + read, count - read);
}
if ((m_BufferReader != null) && (m_BufferReader.Position >= m_BufferReader.Length))
{
m_BufferReader = null;
}
m_Position += read;
return(read);
}
else
{
throw new ObjectDisposedException(this.ToString());
}
}
public static void CopyWmv(string inputFilePath, string outputFilePath, ulong startTime, long duration)
{
IWMWriterAdvanced writerAdvanced = null;
IWMProfile profile = null;
IWMStreamConfig streamConfig = null;
uint streamCount = 0;
uint inputCount = 0;
ushort[] streamNumbers = null;
WMT_STREAM_SELECTION[] streamSelections = null;
ulong sampleTime, sampleDuration;
uint flags, outputNum;
ushort streamNum;
INSSBuffer sample = null;
IWMSyncReader reader = Helpers.CreateSyncReader(WMT_RIGHTS.WMT_RIGHT_NO_DRM);
IWMWriter writer = Helpers.CreateWriter();
try
{
reader.Open(inputFilePath);
Logger.WriteLogMessage("Opened file [" + inputFilePath + "] for reading.");
profile = (IWMProfile)reader;
profile.GetStreamCount(out streamCount);
streamNumbers = new ushort[streamCount];
streamSelections = new WMT_STREAM_SELECTION[streamCount];
for (uint i = 0; i < streamCount; i++)
{
profile.GetStream(i, out streamConfig);
streamConfig.GetStreamNumber(out streamNumbers[i]);
streamSelections[i] = WMT_STREAM_SELECTION.WMT_ON;
//
// Read compressed samples
//
reader.SetReadStreamSamples(streamNumbers[i], true);
}
//
// select all streams
//
reader.SetStreamsSelected((ushort)streamCount, streamNumbers, streamSelections);
writer.SetProfile(profile);
writer.GetInputCount(out inputCount);
for (uint i = 0; i < inputCount; i++)
{
writer.SetInputProps(i, null); // write compressed samples
}
writer.SetOutputFilename(outputFilePath);
Logger.WriteLogMessage("Set output filename [" + outputFilePath + "] for writing.");
writerAdvanced = (IWMWriterAdvanced)writer;
// Copy attributes avoided
// Copy Codec Info avoided
// Copy all scripts in the header avoided
writer.BeginWriting();
//
// startTime, duration are in 100-nsec ticks
//
reader.SetRange(startTime, duration); // seek
Logger.WriteLogMessage("Set range on reader, startTime [" + startTime + "], duration [" + duration + "].");
for (uint streamsRead = 0; streamsRead < streamCount;)
{
try
{
streamNum = 0;
reader.GetNextSample(0, out sample, out sampleTime, out sampleDuration, out flags, out outputNum, out streamNum);
Logger.WriteLogMessage("Grabbed next video sample, sampleTime [" + sampleTime + "], duration [" + sampleDuration + "], flags [" + flags + "], outputNum [" + outputNum + "], streamNum [" + streamNum + "].");
writerAdvanced.WriteStreamSample(streamNum, sampleTime, 0, sampleDuration, flags, sample);
Logger.WriteLogMessage("Wrote sample, sampleTime [" + sampleTime + "], duration [" + sampleDuration + "], flags [" + flags + "], outputNum [" + outputNum + "], streamNum [" + streamNum + "].");
}
catch (COMException e)
{
if (e.ErrorCode == Constants.NS_E_NO_MORE_SAMPLES)
{
streamsRead++;
}
else
{
throw;
}
}
}
writer.EndWriting();
}
finally
{
reader.Close();
}
}
