Resolves issue #69 with double audio recordings

This commit is contained in:
Denny
2016-05-30 07:25:50 -04:00
parent d520f43265
commit 90324404b2

View File

@@ -1,19 +1,19 @@
/******************************************************************************* /*******************************************************************************
* SDR Trunk * SDR Trunk
* Copyright (C) 2014-2016 Dennis Sheirer * Copyright (C) 2014-2016 Dennis Sheirer
* *
* This program is free software: you can redistribute it and/or modify * This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by * it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or * the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version. * (at your option) any later version.
* *
* This program is distributed in the hope that it will be useful, * This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of * but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details. * GNU General Public License for more details.
* *
* You should have received a copy of the GNU General Public License * You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/> * along with this program. If not, see <http://www.gnu.org/licenses/>
******************************************************************************/ ******************************************************************************/
package controller.channel; package controller.channel;
@@ -49,286 +49,278 @@ import filter.FilterSet;
public class ChannelProcessingManager implements ChannelEventListener public class ChannelProcessingManager implements ChannelEventListener
{ {
private final static Logger mLog = LoggerFactory.getLogger( ChannelProcessingManager.class ); private final static Logger mLog = LoggerFactory.getLogger(ChannelProcessingManager.class);
private Map<Integer,ProcessingChain> mProcessingChains = new HashMap<>(); private Map<Integer, ProcessingChain> mProcessingChains = new HashMap<>();
private List<Listener<AudioPacket>> mAudioPacketListeners = new CopyOnWriteArrayList<>();
private List<Listener<Message>> mMessageListeners = new CopyOnWriteArrayList<>();
private ChannelModel mChannelModel; private List<Listener<AudioPacket>> mAudioPacketListeners = new CopyOnWriteArrayList<>();
private ChannelMapModel mChannelMapModel; private List<Listener<Message>> mMessageListeners = new CopyOnWriteArrayList<>();
private AliasModel mAliasModel;
private EventLogManager mEventLogManager;
private RecorderManager mRecorderManager;
private SourceManager mSourceManager;
public ChannelProcessingManager( ChannelModel channelModel,
ChannelMapModel channelMapModel,
AliasModel aliasModel,
EventLogManager eventLogManager,
RecorderManager recorderManager,
SourceManager sourceManager )
{
mChannelModel = channelModel;
mChannelMapModel = channelMapModel;
mAliasModel = aliasModel;
mEventLogManager = eventLogManager;
mRecorderManager = recorderManager;
mSourceManager = sourceManager;
}
/** private ChannelModel mChannelModel;
* Indicates if a processing chain is constructed for the channel and that private ChannelMapModel mChannelMapModel;
* the processing chain is currently processing. private AliasModel mAliasModel;
*/ private EventLogManager mEventLogManager;
public boolean isProcessing( Channel channel ) private RecorderManager mRecorderManager;
{ private SourceManager mSourceManager;
if( mProcessingChains.containsKey( channel.getChannelID() ) )
{
return mProcessingChains.get( channel.getChannelID() ).isProcessing();
}
return false;
}
/**
* Returns the current processing chain associated with the channel, or
* null if a processing chain is not currently setup for the channel
*/
public ProcessingChain getProcessingChain( Channel channel )
{
return mProcessingChains.get( channel.getChannelID() );
}
@Override public ChannelProcessingManager(ChannelModel channelModel,
public synchronized void channelChanged( ChannelEvent event ) ChannelMapModel channelMapModel,
{ AliasModel aliasModel,
Channel channel = event.getChannel(); EventLogManager eventLogManager,
RecorderManager recorderManager,
switch( event.getEvent() ) SourceManager sourceManager)
{ {
case REQUEST_ENABLE: mChannelModel = channelModel;
if( !mProcessingChains.containsKey( channel.getChannelID() ) || mChannelMapModel = channelMapModel;
!mProcessingChains.get( channel.getChannelID() ).isProcessing() ) mAliasModel = aliasModel;
{ mEventLogManager = eventLogManager;
startProcessing( event ); mRecorderManager = recorderManager;
} mSourceManager = sourceManager;
break; }
case REQUEST_DISABLE:
if( channel.getEnabled() )
{
switch( channel.getChannelType() )
{
case STANDARD:
stopProcessing( channel, true );
break;
case TRAFFIC:
//Don't remove traffic channel processing chains
//until explicitly deleted, so that we can reuse them
stopProcessing( channel, false );
default:
break;
}
}
case NOTIFICATION_DELETE:
if( channel.getEnabled() )
{
stopProcessing( channel, true );
}
break;
case NOTIFICATION_CONFIGURATION_CHANGE:
if( isProcessing( channel ) )
{
stopProcessing( channel, false );
startProcessing( event );
}
break;
default:
break;
}
}
private void startProcessing( ChannelEvent event )
{
Channel channel = event.getChannel();
ProcessingChain processingChain = mProcessingChains.get( channel.getChannelID() );
//If we're already processing, ignore the request /**
if( processingChain != null && processingChain.isProcessing() ) * Indicates if a processing chain is constructed for the channel and that
{ * the processing chain is currently processing.
return; */
} private boolean isProcessing(Channel channel)
{
//Ensure that we can get a source before we construct a new processing chain return mProcessingChains.containsKey(channel.getChannelID()) &&
Source source = null; mProcessingChains.get(channel.getChannelID()).isProcessing();
}
try /**
{ * Returns the current processing chain associated with the channel, or
source = mSourceManager.getSource( channel.getSourceConfiguration(), * null if a processing chain is not currently setup for the channel
channel.getDecodeConfiguration().getDecoderType().getChannelBandwidth() ); */
} public ProcessingChain getProcessingChain(Channel channel)
catch( SourceException se ) {
{ return mProcessingChains.get(channel.getChannelID());
mLog.debug( "Error obtaining source for channel [" + channel.getName() + "]", se ); }
}
@Override
public synchronized void channelChanged(ChannelEvent event)
{
Channel channel = event.getChannel();
switch (event.getEvent())
{
case REQUEST_ENABLE:
if (!mProcessingChains.containsKey(channel.getChannelID()) ||
!mProcessingChains.get(channel.getChannelID()).isProcessing())
{
startProcessing(event);
}
break;
case REQUEST_DISABLE:
if (channel.getEnabled())
{
switch (channel.getChannelType())
{
case STANDARD:
stopProcessing(channel, true);
break;
case TRAFFIC:
//Don't remove traffic channel processing chains
//until explicitly deleted, so that we can reuse them
stopProcessing(channel, false);
break;
default:
break;
}
}
case NOTIFICATION_DELETE:
if (channel.getEnabled())
{
stopProcessing(channel, true);
}
break;
case NOTIFICATION_CONFIGURATION_CHANGE:
if (isProcessing(channel))
{
stopProcessing(channel, false);
startProcessing(event);
}
break;
default:
break;
}
}
private void startProcessing(ChannelEvent event)
{
Channel channel = event.getChannel();
ProcessingChain processingChain = mProcessingChains.get(channel.getChannelID());
//If we're already processing, ignore the request
if (processingChain != null && processingChain.isProcessing())
{
return;
}
//Ensure that we can get a source before we construct a new processing chain
Source source = null;
try
{
source = mSourceManager.getSource(channel.getSourceConfiguration(),
channel.getDecodeConfiguration().getDecoderType().getChannelBandwidth());
}
catch (SourceException se)
{
mLog.debug("Error obtaining source for channel [" + channel.getName() + "]", se);
}
if (source == null)
{
channel.setEnabled(false);
mChannelModel.broadcast(
new ChannelEvent(channel, Event.NOTIFICATION_ENABLE_REJECTED));
return;
}
if (processingChain == null)
{
processingChain = new ProcessingChain(channel.getName(),
channel.getChannelType());
if( source == null )
{
channel.setEnabled( false );
mChannelModel.broadcast(
new ChannelEvent( channel, Event.NOTIFICATION_ENABLE_REJECTED ) );
return;
}
if( processingChain == null )
{
processingChain = new ProcessingChain( channel.getName(),
channel.getChannelType() );
/* Register global listeners */ /* Register global listeners */
for( Listener<AudioPacket> listener: mAudioPacketListeners ) for (Listener<AudioPacket> listener : mAudioPacketListeners)
{ {
processingChain.addAudioPacketListener( listener ); processingChain.addAudioPacketListener(listener);
} }
for( Listener<Message> listener: mMessageListeners ) for (Listener<Message> listener : mMessageListeners)
{ {
processingChain.addMessageListener( listener ); processingChain.addMessageListener(listener);
} }
/* Processing Modules */ /* Processing Modules */
List<Module> modules = DecoderFactory.getModules( mChannelModel, List<Module> modules = DecoderFactory.getModules(mChannelModel,
mChannelMapModel, this, mAliasModel, channel ); mChannelMapModel, this, mAliasModel, channel);
processingChain.addModules( modules ); processingChain.addModules(modules);
/* Setup message activity model with filtering */ /* Setup message activity model with filtering */
FilterSet<Message> messageFilter = DecoderFactory.getMessageFilters( modules ); FilterSet<Message> messageFilter = DecoderFactory.getMessageFilters(modules);
MessageActivityModel messageModel = new MessageActivityModel( messageFilter ); MessageActivityModel messageModel = new MessageActivityModel(messageFilter);
processingChain.setMessageActivityModel( messageModel ); processingChain.setMessageActivityModel(messageModel);
/* Setup event logging */ /* Setup event logging */
List<Module> loggers = mEventLogManager.getLoggers( List<Module> loggers = mEventLogManager.getLoggers(
channel.getEventLogConfiguration(), channel.getName() ); channel.getEventLogConfiguration(), channel.getName());
if( !loggers.isEmpty() ) if (!loggers.isEmpty())
{ {
processingChain.addModules( loggers ); processingChain.addModules(loggers);
} }
/* Setup recorders */ /* Setup recorders */
List<RecorderType> recorders = channel.getRecordConfiguration().getRecorders(); List<RecorderType> recorders = channel.getRecordConfiguration().getRecorders();
if( !recorders.isEmpty() )
{
if( recorders.contains( RecorderType.AUDIO ) )
{
processingChain.addAudioPacketListener( mRecorderManager );
}
if (!recorders.isEmpty())
{
/* Add baseband recorder */ /* Add baseband recorder */
if( ( recorders.contains( RecorderType.BASEBAND ) && if ((recorders.contains(RecorderType.BASEBAND) &&
channel.getChannelType() == ChannelType.STANDARD ) ) channel.getChannelType() == ChannelType.STANDARD))
{ {
processingChain.addModule( mRecorderManager.getBasebandRecorder( processingChain.addModule(mRecorderManager.getBasebandRecorder(
channel.toString() ) ); channel.toString()));
} }
/* Add traffic channel baseband recorder */ /* Add traffic channel baseband recorder */
if( recorders.contains( RecorderType.TRAFFIC_BASEBAND ) && if (recorders.contains(RecorderType.TRAFFIC_BASEBAND) &&
channel.getChannelType() == ChannelType.TRAFFIC ) channel.getChannelType() == ChannelType.TRAFFIC)
{ {
processingChain.addModule( mRecorderManager processingChain.addModule(mRecorderManager
.getBasebandRecorder( channel.toString() ) ); .getBasebandRecorder(channel.toString()));
} }
} }
/* Inject channel metadata that will be inserted into audio packets /* Inject channel metadata that will be inserted into audio packets
* for the recorder manager and streaming */ * for the recorder manager and streaming */
processingChain.broadcast( processingChain.broadcast(
new Metadata( MetadataType.SYSTEM, channel.getSystem() ) ); new Metadata(MetadataType.SYSTEM, channel.getSystem()));
processingChain.broadcast( processingChain.broadcast(
new Metadata( MetadataType.SITE_ID, channel.getSite() ) ); new Metadata(MetadataType.SITE_ID, channel.getSite()));
processingChain.broadcast( processingChain.broadcast(
new Metadata( MetadataType.CHANNEL_NAME, channel.getName() ) ); new Metadata(MetadataType.CHANNEL_NAME, channel.getName()));
} }
processingChain.setSource( source );
if( event instanceof TrafficChannelEvent ) processingChain.setSource(source);
{
TrafficChannelEvent trafficChannelEvent = (TrafficChannelEvent)event;
processingChain.getChannelState().configureAsTrafficChannel(
trafficChannelEvent.getTrafficChannelManager(),
trafficChannelEvent.getCallEvent() );
}
processingChain.start(); if (event instanceof TrafficChannelEvent)
{
channel.setEnabled( true ); TrafficChannelEvent trafficChannelEvent = (TrafficChannelEvent) event;
mProcessingChains.put( channel.getChannelID(), processingChain );
mChannelModel.broadcast(
new ChannelEvent( channel, Event.NOTIFICATION_PROCESSING_START ) );
}
private void stopProcessing( Channel channel, boolean remove )
{
channel.setEnabled( false );
if( mProcessingChains.containsKey( channel.getChannelID() ) )
{
ProcessingChain chain = mProcessingChains.get( channel.getChannelID() );
chain.stop();
mChannelModel.broadcast( new ChannelEvent( channel, Event.NOTIFICATION_PROCESSING_STOP ) ); processingChain.getChannelState().configureAsTrafficChannel(
trafficChannelEvent.getTrafficChannelManager(),
if( remove ) trafficChannelEvent.getCallEvent());
{ }
mProcessingChains.remove( channel.getChannelID() );
chain.dispose();
}
}
}
/**
* Adds a message listener that will be added to all channels to receive
* any messages.
*/
public void addAudioPacketListener( Listener<AudioPacket> listener )
{
mAudioPacketListeners.add( listener );
}
/** processingChain.start();
* Removes a message listener.
*/
public void removeAudioPacketListener( Listener<AudioPacket> listener )
{
mAudioPacketListeners.remove( listener );
}
/**
* Adds a message listener that will be added to all channels to receive
* any messages.
*/
public void addMessageListener( Listener<Message> listener )
{
mMessageListeners.add( listener );
}
/** channel.setEnabled(true);
* Removes a message listener.
*/ mProcessingChains.put(channel.getChannelID(), processingChain);
public void removeMessageListener( Listener<Message> listener )
{ mChannelModel.broadcast(
mMessageListeners.remove( listener ); new ChannelEvent(channel, Event.NOTIFICATION_PROCESSING_START));
} }
private void stopProcessing(Channel channel, boolean remove)
{
channel.setEnabled(false);
if (mProcessingChains.containsKey(channel.getChannelID()))
{
ProcessingChain chain = mProcessingChains.get(channel.getChannelID());
chain.stop();
mChannelModel.broadcast(new ChannelEvent(channel, Event.NOTIFICATION_PROCESSING_STOP));
if (remove)
{
mProcessingChains.remove(channel.getChannelID());
chain.dispose();
}
}
}
/**
* Adds a message listener that will be added to all channels to receive
* any messages.
*/
public void addAudioPacketListener(Listener<AudioPacket> listener)
{
mAudioPacketListeners.add(listener);
}
/**
* Removes a message listener.
*/
public void removeAudioPacketListener(Listener<AudioPacket> listener)
{
mAudioPacketListeners.remove(listener);
}
/**
* Adds a message listener that will be added to all channels to receive
* any messages.
*/
public void addMessageListener(Listener<Message> listener)
{
mMessageListeners.add(listener);
}
/**
* Removes a message listener.
*/
public void removeMessageListener(Listener<Message> listener)
{
mMessageListeners.remove(listener);
}
} }