void FinishStream()
{
if(inited)
{
if(!started)
{
StartStream();
}
ASSERT(inited && started);
FLAC__stream_encoder_finish(encoder);
FLAC__stream_encoder_delete(encoder);
encoder = nullptr;
if(flac_metadata[0])
{
FLAC__metadata_object_delete(flac_metadata[0]);
flac_metadata[0] = nullptr;
}
started = false;
inited = false;
}
ASSERT(!inited && !started);
}
/// <summary>
/// Set chooser mode
/// </summary>
/// <param name="mode">Chooser mode to be set</param>
void NuiSkeletonStream::SetChooserMode(ChooserMode mode)
{
if (m_chooserMode != mode)
{
m_chooserMode = mode;
StartStream(); // Restart stream with new parameter value
}
}
/// <summary>
/// Set seated mode
/// </summary>
/// <param name="seated">True to enable seated mode. False to disable</param>
void NuiSkeletonStream::SetSeatedMode(bool seated)
{
if (m_seated != seated)
{
m_seated = seated;
StartStream(); // Restart stream with new parameter value
}
}
/// <summary>
/// Set near mode
/// </summary>
/// <param name="nearMode">True to enable near mode. False to disable</param>
void NuiSkeletonStream::SetNearMode(bool nearMode)
{
if (m_near != nearMode)
{
m_near = nearMode;
StartStream(); // Restart stream with new parameter value
}
}
/// <summary>
/// Pause or resume stream processing
/// </summary>
/// <param name="pause">True to pause the stream and false to resume</param>
void NuiSkeletonStream::PauseStream(bool pause)
{
if (m_paused != pause)
{
m_paused = pause;
StartStream();
}
}
void
AudioCallbackDriver::Init()
{
cubeb_stream_params params;
uint32_t latency;
MOZ_ASSERT(!NS_IsMainThread(),
"This is blocking and should never run on the main thread.");
mSampleRate = params.rate = CubebUtils::PreferredSampleRate();
#if defined(__ANDROID__)
#if defined(MOZ_B2G)
params.stream_type = CubebUtils::ConvertChannelToCubebType(mAudioChannel);
#else
params.stream_type = CUBEB_STREAM_TYPE_MUSIC;
#endif
if (params.stream_type == CUBEB_STREAM_TYPE_MAX) {
NS_WARNING("Bad stream type");
return;
}
#else
(void)mAudioChannel;
#endif
params.channels = mGraphImpl->AudioChannelCount();
if (AUDIO_OUTPUT_FORMAT == AUDIO_FORMAT_S16) {
params.format = CUBEB_SAMPLE_S16NE;
} else {
params.format = CUBEB_SAMPLE_FLOAT32NE;
}
if (cubeb_get_min_latency(CubebUtils::GetCubebContext(), params, &latency) != CUBEB_OK) {
NS_WARNING("Could not get minimal latency from cubeb.");
return;
}
cubeb_stream* stream;
if (cubeb_stream_init(CubebUtils::GetCubebContext(), &stream,
"AudioCallbackDriver", params, latency,
DataCallback_s, StateCallback_s, this) == CUBEB_OK) {
mAudioStream.own(stream);
} else {
NS_WARNING("Could not create a cubeb stream for MediaStreamGraph.");
return;
}
cubeb_stream_register_device_changed_callback(mAudioStream,
AudioCallbackDriver::DeviceChangedCallback_s);
StartStream();
STREAM_LOG(PR_LOG_DEBUG, ("AudioCallbackDriver started."));
}
virtual void WriteInterleavedConverted(size_t frameCount, const char *data)
{
ASSERT(inited);
if(!started)
{
StartStream();
}
ASSERT(inited && started);
fileWAV->WriteBuffer(data, frameCount * formatInfo.Channels * (formatInfo.Sampleformat.GetBitsPerSample()/8));
}
virtual void WriteInterleavedConverted(size_t frameCount, const char *data)
{
ASSERT(inited);
if(!started)
{
StartStream();
}
ASSERT(inited && started);
sampleBuf.resize(frameCount * formatInfo.Channels);
switch(formatInfo.Sampleformat.GetBitsPerSample()/8)
{
case 1:
{
const uint8 *p = reinterpret_cast<const uint8*>(data);
for(std::size_t frame = 0; frame < frameCount; ++frame)
{
for(int channel = 0; channel < formatInfo.Channels; ++channel)
{
sampleBuf[frame * formatInfo.Channels + channel] = *p - 0x80;
p++;
}
}
}
break;
case 2:
{
const int16 *p = reinterpret_cast<const int16*>(data);
for(std::size_t frame = 0; frame < frameCount; ++frame)
{
for(int channel = 0; channel < formatInfo.Channels; ++channel)
{
sampleBuf[frame * formatInfo.Channels + channel] = *p;
p++;
}
}
}
break;
case 3:
{
const int24 *p = reinterpret_cast<const int24*>(data);
for(std::size_t frame = 0; frame < frameCount; ++frame)
{
for(int channel = 0; channel < formatInfo.Channels; ++channel)
{
sampleBuf[frame * formatInfo.Channels + channel] = *p;
p++;
}
}
}
break;
}
FLAC__stream_encoder_process_interleaved(encoder, &sampleBuf[0], frameCount);
}
void FinishStream()
{
if(inited)
{
if(!started)
{
StartStream();
}
ASSERT(inited && started);
fileWAV->Finalize();
delete fileWAV;
started = false;
inited = false;
}
ASSERT(!inited && !started);
}
void Scanner::ScanNextToken() {
if (m_endedStream) {
return;
}
if (!m_startedStream) {
return StartStream();
}
// get rid of whitespace, etc. (in between tokens it should be irrelevent)
ScanToNextToken();
// maybe need to end some blocks
PopIndentToHere();
// *****
// And now branch based on the next few characters!
// *****
// end of stream
if (!INPUT) {
return EndStream();
}
if (INPUT.column() == 0 && INPUT.peek() == Keys::Directive) {
return ScanDirective();
}
// document token
if (INPUT.column() == 0 && Exp::DocStart().Matches(INPUT)) {
return ScanDocStart();
}
if (INPUT.column() == 0 && Exp::DocEnd().Matches(INPUT)) {
return ScanDocEnd();
}
// flow start/end/entry
if (INPUT.peek() == Keys::FlowSeqStart ||
INPUT.peek() == Keys::FlowMapStart) {
return ScanFlowStart();
}
if (INPUT.peek() == Keys::FlowSeqEnd || INPUT.peek() == Keys::FlowMapEnd) {
return ScanFlowEnd();
}
if (INPUT.peek() == Keys::FlowEntry) {
return ScanFlowEntry();
}
// block/map stuff
if (Exp::BlockEntry().Matches(INPUT)) {
return ScanBlockEntry();
}
if ((InBlockContext() ? Exp::Key() : Exp::KeyInFlow()).Matches(INPUT)) {
return ScanKey();
}
if (GetValueRegex().Matches(INPUT)) {
return ScanValue();
}
// alias/anchor
if (INPUT.peek() == Keys::Alias || INPUT.peek() == Keys::Anchor) {
return ScanAnchorOrAlias();
}
// tag
if (INPUT.peek() == Keys::Tag) {
return ScanTag();
}
// special scalars
if (InBlockContext() && (INPUT.peek() == Keys::LiteralScalar ||
INPUT.peek() == Keys::FoldedScalar)) {
return ScanBlockScalar();
}
if (INPUT.peek() == '\'' || INPUT.peek() == '\"') {
return ScanQuotedScalar();
}
// plain scalars
if ((InBlockContext() ? Exp::PlainScalar() : Exp::PlainScalarInFlow())
.Matches(INPUT)) {
return ScanPlainScalar();
}
// don't know what it is!
throw ParserException(INPUT.mark(), ErrorMsg::UNKNOWN_TOKEN);
}
void
AudioCallbackDriver::Init()
{
cubeb_stream_params params;
uint32_t latency;
MOZ_ASSERT(!NS_IsMainThread(),
"This is blocking and should never run on the main thread.");
mSampleRate = params.rate = CubebUtils::PreferredSampleRate();
#if defined(__ANDROID__)
#if defined(MOZ_B2G)
params.stream_type = CubebUtils::ConvertChannelToCubebType(mAudioChannel);
#else
params.stream_type = CUBEB_STREAM_TYPE_MUSIC;
#endif
if (params.stream_type == CUBEB_STREAM_TYPE_MAX) {
NS_WARNING("Bad stream type");
return;
}
#else
(void)mAudioChannel;
#endif
params.channels = mGraphImpl->AudioChannelCount();
if (AUDIO_OUTPUT_FORMAT == AUDIO_FORMAT_S16) {
params.format = CUBEB_SAMPLE_S16NE;
} else {
params.format = CUBEB_SAMPLE_FLOAT32NE;
}
if (cubeb_get_min_latency(CubebUtils::GetCubebContext(), params, &latency) != CUBEB_OK) {
NS_WARNING("Could not get minimal latency from cubeb.");
return;
}
cubeb_stream* stream;
if (cubeb_stream_init(CubebUtils::GetCubebContext(), &stream,
"AudioCallbackDriver", params, latency,
DataCallback_s, StateCallback_s, this) == CUBEB_OK) {
mAudioStream.own(stream);
} else {
NS_WARNING("Could not create a cubeb stream for MediaStreamGraph, falling back to a SystemClockDriver");
// Fall back to a driver using a normal thread.
mNextDriver = new SystemClockDriver(GraphImpl());
mNextDriver->SetGraphTime(this, mIterationStart, mIterationEnd);
mGraphImpl->SetCurrentDriver(mNextDriver);
DebugOnly<bool> found = mGraphImpl->RemoveMixerCallback(this);
NS_WARN_IF_FALSE(!found, "Mixer callback not added when switching?");
mNextDriver->Start();
return;
}
cubeb_stream_register_device_changed_callback(mAudioStream,
AudioCallbackDriver::DeviceChangedCallback_s);
StartStream();
STREAM_LOG(LogLevel::Debug, ("AudioCallbackDriver started."));
}
STDMETHODIMP CSampleMSPStream::SelectTerminal(
IN ITTerminal * pTerminal
)
{
LOG((MSP_TRACE, "CSampleMSPStream::SelectTerminal - enter"));
//
// We are going to access the terminal list -- grab the lock
//
CLock lock(m_lock);
//
// Reject if we already have a terminal selected.
//
if ( 0 != m_Terminals.GetSize() )
{
LOG((MSP_ERROR, "CSampleMSPStream::SelectTerminal - "
"exit TAPI_E_MAXTERMINALS"));
return TAPI_E_MAXTERMINALS;
}
//
// Use base class method to add it to our list of terminals.
//
HRESULT hr = CMSPStream::SelectTerminal(pTerminal);
if ( FAILED(hr) )
{
LOG((MSP_ERROR, "CSampleMSPStream::SelectTerminal - "
"base class method failed - exit 0x%08x", hr));
return hr;
}
//
// Re-pause or re-start the stream if needed.
//
if ( m_DesiredGraphState == State_Paused )
{
hr = PauseStream();
}
else if ( m_DesiredGraphState == State_Running )
{
hr = StartStream();
}
else
{
_ASSERTE( m_DesiredGraphState == State_Stopped );
hr = S_OK;
}
if ( FAILED(hr) )
{
LOG((MSP_TRACE, "CSampleMSPStream::SelectTerminal - "
"can't regain old graph state - unselecting terminal - "
"exit 0x%08x", hr));
//
// Unselect it to undo all of the above.
//
UnselectTerminal(pTerminal);
return hr;
}
LOG((MSP_TRACE, "CSampleMSPStream::SelectTerminal - exit S_OK"));
return S_OK;
}
// ScanNextToken
// . The main scanning function; here we branch out and
// scan whatever the next token should be.
void Scanner::ScanNextToken()
{
if(m_endedStream)
return;
if(!m_startedStream)
return StartStream();
// get rid of whitespace, etc. (in between tokens it should be irrelevent)
ScanToNextToken();
// check the latest simple key
VerifySimpleKey();
// maybe need to end some blocks
PopIndentTo(INPUT.column);
// *****
// And now branch based on the next few characters!
// *****
// end of stream
if(INPUT.peek() == EOF)
return EndStream();
if(INPUT.column == 0 && INPUT.peek() == Keys::Directive)
return ScanDirective();
// document token
if(INPUT.column == 0 && Exp::DocStart.Matches(INPUT))
return ScanDocStart();
if(INPUT.column == 0 && Exp::DocEnd.Matches(INPUT))
return ScanDocEnd();
// flow start/end/entry
if(INPUT.peek() == Keys::FlowSeqStart || INPUT.peek() == Keys::FlowMapStart)
return ScanFlowStart();
if(INPUT.peek() == Keys::FlowSeqEnd || INPUT.peek() == Keys::FlowMapEnd)
return ScanFlowEnd();
if(INPUT.peek() == Keys::FlowEntry)
return ScanFlowEntry();
// block/map stuff
if(Exp::BlockEntry.Matches(INPUT))
return ScanBlockEntry();
if((m_flowLevel == 0 ? Exp::Key : Exp::KeyInFlow).Matches(INPUT))
return ScanKey();
if((m_flowLevel == 0 ? Exp::Value : Exp::ValueInFlow).Matches(INPUT))
return ScanValue();
// alias/anchor
if(INPUT.peek() == Keys::Alias || INPUT.peek() == Keys::Anchor)
return ScanAnchorOrAlias();
// tag
if(INPUT.peek() == Keys::Tag)
return ScanTag();
// special scalars
if(m_flowLevel == 0 && (INPUT.peek() == Keys::LiteralScalar || INPUT.peek() == Keys::FoldedScalar))
return ScanBlockScalar();
if(INPUT.peek() == '\'' || INPUT.peek() == '\"')
return ScanQuotedScalar();
// plain scalars
if((m_flowLevel == 0 ? Exp::PlainScalar : Exp::PlainScalarInFlow).Matches(INPUT))
return ScanPlainScalar();
// don't know what it is!
throw ParserException(INPUT.line, INPUT.column, ErrorMsg::UNKNOWN_TOKEN);
}
