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<AudioPacket>> mAudioPacketListeners = new CopyOnWriteArrayList<>();
private List<Listener<Message>> mMessageListeners = new CopyOnWriteArrayList<>(); private List<Listener<Message>> mMessageListeners = new CopyOnWriteArrayList<>();
private ChannelModel mChannelModel; private ChannelModel mChannelModel;
private ChannelMapModel mChannelMapModel; private ChannelMapModel mChannelMapModel;
private AliasModel mAliasModel; private AliasModel mAliasModel;
private EventLogManager mEventLogManager; private EventLogManager mEventLogManager;
private RecorderManager mRecorderManager; private RecorderManager mRecorderManager;
private SourceManager mSourceManager; private SourceManager mSourceManager;
public ChannelProcessingManager( ChannelModel channelModel, public ChannelProcessingManager(ChannelModel channelModel,
ChannelMapModel channelMapModel, ChannelMapModel channelMapModel,
AliasModel aliasModel, AliasModel aliasModel,
EventLogManager eventLogManager, EventLogManager eventLogManager,
RecorderManager recorderManager, RecorderManager recorderManager,
SourceManager sourceManager ) SourceManager sourceManager)
{ {
mChannelModel = channelModel; mChannelModel = channelModel;
mChannelMapModel = channelMapModel; mChannelMapModel = channelMapModel;
mAliasModel = aliasModel; mAliasModel = aliasModel;
mEventLogManager = eventLogManager; mEventLogManager = eventLogManager;
mRecorderManager = recorderManager; mRecorderManager = recorderManager;
mSourceManager = sourceManager; mSourceManager = sourceManager;
} }
/** /**
* Indicates if a processing chain is constructed for the channel and that * Indicates if a processing chain is constructed for the channel and that
* the processing chain is currently processing. * the processing chain is currently processing.
*/ */
public boolean isProcessing( Channel channel ) private boolean isProcessing(Channel channel)
{ {
if( mProcessingChains.containsKey( channel.getChannelID() ) ) return mProcessingChains.containsKey(channel.getChannelID()) &&
{ mProcessingChains.get(channel.getChannelID()).isProcessing();
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
* Returns the current processing chain associated with the channel, or public synchronized void channelChanged(ChannelEvent event)
* null if a processing chain is not currently setup for the channel {
*/ Channel channel = event.getChannel();
public ProcessingChain getProcessingChain( Channel channel )
{
return mProcessingChains.get( channel.getChannelID() );
}
@Override switch (event.getEvent())
public synchronized void channelChanged( ChannelEvent event ) {
{ case REQUEST_ENABLE:
Channel channel = event.getChannel(); 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;
}
}
switch( event.getEvent() ) private void startProcessing(ChannelEvent event)
{ {
case REQUEST_ENABLE: Channel channel = event.getChannel();
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 );
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 ) ProcessingChain processingChain = mProcessingChains.get(channel.getChannelID());
{
Channel channel = event.getChannel();
ProcessingChain processingChain = mProcessingChains.get( channel.getChannelID() ); //If we're already processing, ignore the request
if (processingChain != null && processingChain.isProcessing())
{
return;
}
//If we're already processing, ignore the request //Ensure that we can get a source before we construct a new processing chain
if( processingChain != null && processingChain.isProcessing() ) Source source = null;
{
return;
}
//Ensure that we can get a source before we construct a new processing chain try
Source source = null; {
source = mSourceManager.getSource(channel.getSourceConfiguration(),
channel.getDecodeConfiguration().getDecoderType().getChannelBandwidth());
}
catch (SourceException se)
{
mLog.debug("Error obtaining source for channel [" + channel.getName() + "]", se);
}
try if (source == null)
{ {
source = mSourceManager.getSource( channel.getSourceConfiguration(), channel.setEnabled(false);
channel.getDecodeConfiguration().getDecoderType().getChannelBandwidth() );
}
catch( SourceException se )
{
mLog.debug( "Error obtaining source for channel [" + channel.getName() + "]", se );
}
if( source == null ) mChannelModel.broadcast(
{ new ChannelEvent(channel, Event.NOTIFICATION_ENABLE_REJECTED));
channel.setEnabled( false );
mChannelModel.broadcast( return;
new ChannelEvent( channel, Event.NOTIFICATION_ENABLE_REJECTED ) ); }
return; if (processingChain == null)
} {
processingChain = new ProcessingChain(channel.getName(),
if( processingChain == null ) channel.getChannelType());
{
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 ); processingChain.setSource(source);
if( event instanceof TrafficChannelEvent ) if (event instanceof TrafficChannelEvent)
{ {
TrafficChannelEvent trafficChannelEvent = (TrafficChannelEvent)event; TrafficChannelEvent trafficChannelEvent = (TrafficChannelEvent) event;
processingChain.getChannelState().configureAsTrafficChannel( processingChain.getChannelState().configureAsTrafficChannel(
trafficChannelEvent.getTrafficChannelManager(), trafficChannelEvent.getTrafficChannelManager(),
trafficChannelEvent.getCallEvent() ); trafficChannelEvent.getCallEvent());
} }
processingChain.start(); processingChain.start();
channel.setEnabled( true ); channel.setEnabled(true);
mProcessingChains.put( channel.getChannelID(), processingChain ); mProcessingChains.put(channel.getChannelID(), processingChain);
mChannelModel.broadcast( mChannelModel.broadcast(
new ChannelEvent( channel, Event.NOTIFICATION_PROCESSING_START ) ); new ChannelEvent(channel, Event.NOTIFICATION_PROCESSING_START));
} }
private void stopProcessing( Channel channel, boolean remove ) private void stopProcessing(Channel channel, boolean remove)
{ {
channel.setEnabled( false ); channel.setEnabled(false);
if( mProcessingChains.containsKey( channel.getChannelID() ) ) if (mProcessingChains.containsKey(channel.getChannelID()))
{ {
ProcessingChain chain = mProcessingChains.get( channel.getChannelID() ); ProcessingChain chain = mProcessingChains.get(channel.getChannelID());
chain.stop(); chain.stop();
mChannelModel.broadcast( new ChannelEvent( channel, Event.NOTIFICATION_PROCESSING_STOP ) ); mChannelModel.broadcast(new ChannelEvent(channel, Event.NOTIFICATION_PROCESSING_STOP));
if( remove ) if (remove)
{ {
mProcessingChains.remove( channel.getChannelID() ); mProcessingChains.remove(channel.getChannelID());
chain.dispose(); chain.dispose();
} }
} }
} }
/** /**
* Adds a message listener that will be added to all channels to receive * Adds a message listener that will be added to all channels to receive
* any messages. * any messages.
*/ */
public void addAudioPacketListener( Listener<AudioPacket> listener ) public void addAudioPacketListener(Listener<AudioPacket> listener)
{ {
mAudioPacketListeners.add( listener ); mAudioPacketListeners.add(listener);
} }
/** /**
* Removes a message listener. * Removes a message listener.
*/ */
public void removeAudioPacketListener( Listener<AudioPacket> listener ) public void removeAudioPacketListener(Listener<AudioPacket> listener)
{ {
mAudioPacketListeners.remove( listener ); mAudioPacketListeners.remove(listener);
} }
/** /**
* Adds a message listener that will be added to all channels to receive * Adds a message listener that will be added to all channels to receive
* any messages. * any messages.
*/ */
public void addMessageListener( Listener<Message> listener ) public void addMessageListener(Listener<Message> listener)
{ {
mMessageListeners.add( listener ); mMessageListeners.add(listener);
} }
/** /**
* Removes a message listener. * Removes a message listener.
*/ */
public void removeMessageListener( Listener<Message> listener ) public void removeMessageListener(Listener<Message> listener)
{ {
mMessageListeners.remove( listener ); mMessageListeners.remove(listener);
} }
} }