root/branches/libfreebob-2.0/src/libstreaming/StreamProcessorManager.cpp

Revision 291, 21.0 kB (checked in by jwoithe, 16 years ago)

Seed the SPH cycle DLL when the receive stream is running but disabled; this
means the DLL has a sensible figure when the transmit stream is enabled.
More testing to work out why device resync (as distinct from rx/tx sync)
doesn't seem to work.

Line 
1 /* $Id$ */
2
3 /*
4  *   FreeBob Streaming API
5  *   FreeBob = Firewire (pro-)audio for linux
6  *
7  *   http://freebob.sf.net
8  *
9  *   Copyright (C) 2005,2006 Pieter Palmers <pieterpalmers@users.sourceforge.net>
10  *
11  *   This program is free software {} you can redistribute it and/or modify
12  *   it under the terms of the GNU General Public License as published by
13  *   the Free Software Foundation {} either version 2 of the License, or
14  *   (at your option) any later version.
15  *
16  *   This program is distributed in the hope that it will be useful,
17  *   but WITHOUT ANY WARRANTY {} without even the implied warranty of
18  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
19  *   GNU General Public License for more details.
20  *
21  *   You should have received a copy of the GNU General Public License
22  *   along with this program {} if not, write to the Free Software
23  *   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
24  *
25  *
26  *
27  */
28
29 #include "StreamProcessorManager.h"
30 #include "StreamProcessor.h"
31 #include "Port.h"
32 #include <errno.h>
33 #include <assert.h>
34
35
36 namespace FreebobStreaming {
37
38 IMPL_DEBUG_MODULE( StreamProcessorManager, StreamProcessorManager, DEBUG_LEVEL_NORMAL );
39
40 StreamProcessorManager::StreamProcessorManager(unsigned int period, unsigned int nb_buffers)
41         : m_nb_buffers(nb_buffers), m_period(period), m_xruns(0), m_isoManager(0), m_nbperiods(0) {
42
43 }
44
45 StreamProcessorManager::~StreamProcessorManager() {
46         if (m_isoManager) delete m_isoManager;
47        
48 }
49
50 /**
51  * Registers \ref processor with this manager.
52  *
53  * also registers it with the isohandlermanager
54  *
55  * be sure to call isohandlermanager->init() first!
56  * and be sure that the processors are also ->init()'ed
57  *
58  * @param processor
59  * @return true if successfull
60  */
61 bool StreamProcessorManager::registerProcessor(StreamProcessor *processor)
62 {
63         debugOutput( DEBUG_LEVEL_VERBOSE, "Registering processor (%p)\n",processor);
64         assert(processor);
65         assert(m_isoManager);
66
67         if (processor->getType()==StreamProcessor::E_Receive) {
68                 processor->setVerboseLevel(getDebugLevel()); // inherit debug level
69                
70                 m_ReceiveProcessors.push_back(processor);
71                
72                 processor->setManager(this);
73                                
74                 return true;
75         }
76        
77         if (processor->getType()==StreamProcessor::E_Transmit) {
78                 processor->setVerboseLevel(getDebugLevel()); // inherit debug level
79                
80                 m_TransmitProcessors.push_back(processor);
81                
82                 processor->setManager(this);
83                
84                 return true;
85         }
86
87         debugFatal("Unsupported processor type!\n");
88        
89         return false;
90 }
91
92 bool StreamProcessorManager::unregisterProcessor(StreamProcessor *processor)
93 {
94         debugOutput( DEBUG_LEVEL_VERBOSE, "Unregistering processor (%p)\n",processor);
95         assert(processor);
96
97         if (processor->getType()==StreamProcessor::E_Receive) {
98
99                 for ( StreamProcessorVectorIterator it = m_ReceiveProcessors.begin();
100                         it != m_ReceiveProcessors.end();
101                         ++it ) {
102
103                         if ( *it == processor ) {
104                                         m_ReceiveProcessors.erase(it);
105                                        
106                                         processor->clearManager();
107                                        
108                                         if(!m_isoManager->unregisterStream(processor)) {
109                                                 debugOutput(DEBUG_LEVEL_VERBOSE,"Could not unregister receive stream processor from the Iso manager\n");
110                                                
111                                                 return false;
112                                                
113                                         }
114                                        
115                                         return true;
116                                 }
117                 }
118         }
119
120         if (processor->getType()==StreamProcessor::E_Transmit) {
121                 for ( StreamProcessorVectorIterator it = m_TransmitProcessors.begin();
122                         it != m_TransmitProcessors.end();
123                         ++it ) {
124
125                         if ( *it == processor ) {
126                                         m_TransmitProcessors.erase(it);
127                                        
128                                         processor->clearManager();
129                                        
130                                         if(!m_isoManager->unregisterStream(processor)) {
131                                                 debugOutput(DEBUG_LEVEL_VERBOSE,"Could not unregister transmit stream processor from the Iso manager\n");
132                                                
133                                                 return false;
134                                                
135                                         }
136                                        
137                                         return true;
138                                 }
139                 }
140         }
141        
142         debugFatal("Processor (%p) not found!\n",processor);
143
144         return false; //not found
145
146 }
147
148 bool StreamProcessorManager::init()
149 {
150         debugOutput( DEBUG_LEVEL_VERBOSE, "enter...\n");
151
152         // and the tread that runs the runner
153         m_streamingThread=new FreebobUtil::PosixThread(this, m_thread_realtime, m_thread_priority, PTHREAD_CANCEL_DEFERRED);
154         if(!m_streamingThread) {
155                 debugFatal("Could not create streaming thread\n");
156                 return false;
157         }
158        
159         m_isoManager=new IsoHandlerManager();
160        
161         if(!m_isoManager) {
162                 debugFatal("Could not create IsoHandlerManager\n");
163                 return false;
164         }
165        
166         m_isoManager->setVerboseLevel(getDebugLevel());
167        
168         if(!m_isoManager->Init()) {
169                 debugFatal("Could not init IsoHandlerManager\n");
170                 return false;
171         }
172
173         return true;
174 }
175
176 bool StreamProcessorManager::Init()
177 {
178         debugOutput( DEBUG_LEVEL_VERBOSE, "Initializing runner...\n");
179        
180         // no xrun has occurred (yet)
181         m_xrun_happened=false;
182
183         if(sem_init(&m_period_semaphore, 0, 0)) {
184                 debugFatal( "Cannot init packet transfer semaphore\n");
185                 debugFatal( " Error: %s\n",strerror(errno));
186                 return false;
187     }
188  
189         return true;
190 }
191
192 bool StreamProcessorManager::prepare() {
193
194         debugOutput( DEBUG_LEVEL_VERBOSE, "Preparing...\n");
195         debugOutput( DEBUG_LEVEL_VERBOSE, " Receive processors...\n");
196         for ( StreamProcessorVectorIterator it = m_ReceiveProcessors.begin();
197                 it != m_ReceiveProcessors.end();
198                 ++it ) {
199                         if(!(*it)->prepare()) {
200                                 debugFatal(  " could not prepare (%p)...\n",(*it));
201                                 return false;
202                                
203                         }
204                 }
205
206         debugOutput( DEBUG_LEVEL_VERBOSE, " Transmit processors...\n");
207         for ( StreamProcessorVectorIterator it = m_TransmitProcessors.begin();
208                 it != m_TransmitProcessors.end();
209                 ++it ) {
210                         if(!(*it)->prepare()) {
211                                 debugFatal( " could not prepare (%p)...\n",(*it));
212                                 return false;
213                        
214                         }
215                        
216                 }
217
218         return true;
219 }
220
221 bool StreamProcessorManager::Execute()
222 {
223
224         bool period_ready=true;
225     bool xrun_has_occured=false;
226         bool this_period_ready;
227        
228         unsigned long tstamp_enter=debugGetCurrentTSC();
229        
230 //      debugOutput( DEBUG_LEVEL_VERY_VERBOSE, "------------- EXECUTE -----------\n");
231        
232         if(!m_isoManager->Execute()) {
233                 debugFatal("Could not execute isoManager\n");
234                 return false;
235         }
236        
237         unsigned long tstamp_iso=debugGetCurrentTSC();
238        
239         debugOutput( DEBUG_LEVEL_VERY_VERBOSE, " RCV PROC: ");
240         for ( StreamProcessorVectorIterator it = m_ReceiveProcessors.begin();
241                 it != m_ReceiveProcessors.end();
242                 ++it ) {
243                
244                 this_period_ready = (*it)->isOnePeriodReady();
245                 period_ready = period_ready && this_period_ready;
246 //              if (this_period_ready) {
247 //                  m_isoManager->disablePolling(*it);
248 //              }
249 //             
250                 xrun_has_occured = xrun_has_occured || (*it)->xrunOccurred();
251                 debugOutputShort( DEBUG_LEVEL_VERY_VERBOSE, "(%d/%d/%d) ", period_ready, xrun_has_occured,(*it)->m_framecounter);
252         }
253         debugOutputShort( DEBUG_LEVEL_VERY_VERBOSE, "\n");
254
255         debugOutput( DEBUG_LEVEL_VERY_VERBOSE, " XMIT PROC: ");
256         for ( StreamProcessorVectorIterator it = m_TransmitProcessors.begin();
257                 it != m_TransmitProcessors.end();
258                 ++it ) {
259                 this_period_ready = (*it)->isOnePeriodReady();
260                 period_ready = period_ready && this_period_ready;
261 //              if (this_period_ready) {
262 //                  m_isoManager->disablePolling(*it);
263 //              }
264                 xrun_has_occured = xrun_has_occured || (*it)->xrunOccurred();
265                 debugOutputShort( DEBUG_LEVEL_VERY_VERBOSE, "(%d/%d/%d) ", period_ready, xrun_has_occured,(*it)->m_framecounter);
266         }
267         debugOutputShort( DEBUG_LEVEL_VERY_VERBOSE, "\n");
268        
269         unsigned long tstamp_periodcheck=debugGetCurrentTSC();
270
271         if(xrun_has_occured) {
272                 // do xrun signaling/handling
273                 debugWarning("Streaming thread detected xrun\n");
274                 m_xruns++;
275                 m_xrun_happened=true;
276                 sem_post(&m_period_semaphore);
277                 return false; // stop thread
278         }
279
280         if(period_ready) {
281                 // signal the waiting thread(s?) that a period is ready
282                 sem_post(&m_period_semaphore);
283                 debugOutputShort( DEBUG_LEVEL_VERY_VERBOSE, "Period done...\n");
284
285                 for ( StreamProcessorVectorIterator it = m_ReceiveProcessors.begin();
286                         it != m_ReceiveProcessors.end();
287                         ++it ) {
288                         (*it)->decrementFrameCounter();
289 //                      m_isoManager->enablePolling(*it);
290                        
291                 }
292        
293                 for ( StreamProcessorVectorIterator it = m_TransmitProcessors.begin();
294                         it != m_TransmitProcessors.end();
295                         ++it ) {
296                         (*it)->decrementFrameCounter();
297 //                      m_isoManager->enablePolling(*it);
298                 }
299                
300                 m_nbperiods++;
301         }
302        
303         unsigned long tstamp_exit=debugGetCurrentTSC();
304        
305 //      debugOutput( DEBUG_LEVEL_VERBOSE, "EXECUTE TIME: ISO: %6d | PeriodCheck: %6d | FrameCounter: %6d \n",
306 //         tstamp_iso-tstamp_enter, tstamp_periodcheck-tstamp_iso, tstamp_exit-tstamp_periodcheck
307 //         );
308
309         return true;
310
311 }
312
313 bool StreamProcessorManager::start() {
314         debugOutput( DEBUG_LEVEL_VERBOSE, "Starting Processors...\n");
315         assert(m_isoManager);
316        
317         debugOutput( DEBUG_LEVEL_VERBOSE, "Creating handlers for the StreamProcessors...\n");
318         debugOutput( DEBUG_LEVEL_VERBOSE, " Receive processors...\n");
319         for ( StreamProcessorVectorIterator it = m_ReceiveProcessors.begin();
320                 it != m_ReceiveProcessors.end();
321                 ++it ) {
322                         if (!m_isoManager->registerStream(*it)) {
323                                 debugOutput(DEBUG_LEVEL_VERBOSE,"Could not register receive stream processor (%p) with the Iso manager\n",*it);
324                                 return false;
325                         }
326                        
327                        
328                 }
329
330         debugOutput( DEBUG_LEVEL_VERBOSE, " Transmit processors...\n");
331         for ( StreamProcessorVectorIterator it = m_TransmitProcessors.begin();
332                 it != m_TransmitProcessors.end();
333                 ++it ) {
334                         if (!m_isoManager->registerStream(*it)) {
335                                 debugOutput(DEBUG_LEVEL_VERBOSE,"Could not register transmit stream processor (%p) with the Iso manager\n",*it);
336                                 return false;
337                         }
338                        
339                 }
340
341         debugOutput( DEBUG_LEVEL_VERBOSE, "Preparing IsoHandlerManager...\n");
342         if (!m_isoManager->prepare()) {
343                 debugFatal("Could not prepare isoManager\n");
344                 return false;
345         }
346
347         debugOutput( DEBUG_LEVEL_VERBOSE, "Starting IsoHandler...\n");
348         if (!m_isoManager->startHandlers(0)) {
349                 debugFatal("Could not start handlers...\n");
350                 return false;
351         }
352        
353         debugOutput( DEBUG_LEVEL_VERBOSE, "Starting streaming thread...\n");
354        
355         // start the runner thread
356         m_streamingThread->Start();
357        
358         debugOutput( DEBUG_LEVEL_VERBOSE, "Waiting for all StreamProcessors to start running...\n");
359         // we have to wait untill all streamprocessors indicate that they are running
360         // i.e. that there is actually some data stream flowing
361         int wait_cycles=2000; // two seconds
362         bool notRunning=true;
363         while (notRunning && wait_cycles) {
364                 wait_cycles--;
365                 notRunning=false;
366                
367                 for ( StreamProcessorVectorIterator it = m_ReceiveProcessors.begin();
368                         it != m_ReceiveProcessors.end();
369                         ++it ) {
370                         if(!(*it)->isRunning()) notRunning=true;
371                 }
372        
373                 for ( StreamProcessorVectorIterator it = m_TransmitProcessors.begin();
374                         it != m_TransmitProcessors.end();
375                         ++it ) {
376                         if(!(*it)->isRunning()) notRunning=true;
377                 }
378                 usleep(1000);
379         }
380        
381         if(!wait_cycles) { // timout has occurred
382                 debugFatal("One or more streams are not starting up (timeout):\n");
383                            
384                 for ( StreamProcessorVectorIterator it = m_ReceiveProcessors.begin();
385                         it != m_ReceiveProcessors.end();
386                         ++it ) {
387                         if(!(*it)->isRunning()) {
388                                 debugFatal(" receive stream %p not running\n",*it);
389                         } else {       
390                                 debugFatal(" receive stream %p running\n",*it);
391                         }
392                 }
393        
394                 for ( StreamProcessorVectorIterator it = m_TransmitProcessors.begin();
395                         it != m_TransmitProcessors.end();
396                         ++it ) {
397                         if(!(*it)->isRunning()) {
398                                 debugFatal(" transmit stream %p not running\n",*it);
399                         } else {       
400                                 debugFatal(" transmit stream %p running\n",*it);
401                         }
402                 }
403                 return false;
404         }
405
406         debugOutput( DEBUG_LEVEL_VERBOSE, "StreamProcessors running...\n");
407         debugOutput( DEBUG_LEVEL_VERBOSE, "Resetting frame counters...\n");
408        
409         // now we reset the frame counters
410         // FIXME: check how we are going to do sync
411         for ( StreamProcessorVectorIterator it = m_ReceiveProcessors.begin();
412                 it != m_ReceiveProcessors.end();
413                 ++it ) {
414                
415                 if(getDebugLevel()>=DEBUG_LEVEL_VERBOSE) {
416                         (*it)->dumpInfo();
417                 }
418
419                 (*it)->reset();
420
421                 if(getDebugLevel()>=DEBUG_LEVEL_VERBOSE) {
422                         (*it)->dumpInfo();
423                 }
424                
425         }
426        
427         for ( StreamProcessorVectorIterator it = m_TransmitProcessors.begin();
428                 it != m_TransmitProcessors.end();
429                 ++it ) {
430                
431                 if(getDebugLevel()>=DEBUG_LEVEL_VERBOSE) {
432                         (*it)->dumpInfo();
433                 }
434                
435                 (*it)->reset();
436                
437                 if(getDebugLevel()>=DEBUG_LEVEL_VERBOSE) {
438                         (*it)->dumpInfo();
439                 }
440         }
441        
442         debugOutput( DEBUG_LEVEL_VERBOSE, "Enabling StreamProcessors...\n");
443         // and we enable the streamprocessors
444         for ( StreamProcessorVectorIterator it = m_ReceiveProcessors.begin();
445                 it != m_ReceiveProcessors.end();
446                 ++it ) {               
447                 (*it)->enable();
448                 m_isoManager->enablePolling(*it);
449         }
450
451         for ( StreamProcessorVectorIterator it = m_TransmitProcessors.begin();
452                 it != m_TransmitProcessors.end();
453                 ++it ) {
454                 (*it)->enable();
455                 m_isoManager->enablePolling(*it);
456         }
457        
458         // dump the iso stream information when in verbose mode
459         if(getDebugLevel()>=DEBUG_LEVEL_VERBOSE) {
460                 m_isoManager->dumpInfo();
461         }
462        
463         return true;
464        
465 }
466
467 bool StreamProcessorManager::stop() {
468         debugOutput( DEBUG_LEVEL_VERBOSE, "Stopping...\n");
469         assert(m_isoManager);
470         assert(m_streamingThread);
471
472         debugOutput( DEBUG_LEVEL_VERBOSE, "Waiting for all StreamProcessors to prepare to stop...\n");
473         // Most stream processors can just stop without special treatment.  However, some
474         // (like the MOTU) need to do a few things before it's safe to turn off the iso
475         // handling.
476         int wait_cycles=2000; // two seconds ought to be sufficient
477         bool allReady = false;
478         while (!allReady && wait_cycles) {
479                 wait_cycles--;
480                 allReady = true;
481                
482                 for ( StreamProcessorVectorIterator it = m_ReceiveProcessors.begin();
483                         it != m_ReceiveProcessors.end();
484                         ++it ) {
485                         if(!(*it)->preparedForStop()) allReady = false;
486                 }
487        
488                 for ( StreamProcessorVectorIterator it = m_TransmitProcessors.begin();
489                         it != m_TransmitProcessors.end();
490                         ++it ) {
491                         if(!(*it)->preparedForStop()) allReady = false;
492                 }
493                 usleep(1000);
494         }
495
496
497         debugOutput( DEBUG_LEVEL_VERBOSE, "Stopping thread...\n");
498        
499         m_streamingThread->Stop();
500        
501         debugOutput( DEBUG_LEVEL_VERBOSE, "Stopping handlers...\n");
502         if(!m_isoManager->stopHandlers()) {
503            debugFatal("Could not stop ISO handlers\n");
504            return false;
505         }
506        
507         debugOutput( DEBUG_LEVEL_VERBOSE, "Unregistering processors from handlers...\n");
508     // now unregister all streams from iso manager
509         debugOutput( DEBUG_LEVEL_VERBOSE, " Receive processors...\n");
510         for ( StreamProcessorVectorIterator it = m_ReceiveProcessors.begin();
511                 it != m_ReceiveProcessors.end();
512                 ++it ) {
513                         if (!m_isoManager->unregisterStream(*it)) {
514                                 debugOutput(DEBUG_LEVEL_VERBOSE,"Could not unregister receive stream processor (%p) from the Iso manager\n",*it);
515                                 return false;
516                         }
517                        
518                        
519                 }
520
521         debugOutput( DEBUG_LEVEL_VERBOSE, " Transmit processors...\n");
522         for ( StreamProcessorVectorIterator it = m_TransmitProcessors.begin();
523                 it != m_TransmitProcessors.end();
524                 ++it ) {
525                         if (!m_isoManager->unregisterStream(*it)) {
526                                 debugOutput(DEBUG_LEVEL_VERBOSE,"Could not unregister transmit stream processor (%p) from the Iso manager\n",*it);
527                                 return false;
528                         }
529                        
530                 }
531    
532        
533         return true;
534        
535 }
536
537 bool StreamProcessorManager::waitForPeriod() {
538
539         debugOutput( DEBUG_LEVEL_VERY_VERBOSE, "enter...\n");
540
541         // Wait for packetizer thread to signal a period completion
542         sem_wait(&m_period_semaphore);
543        
544         if(m_xrun_happened) {
545            debugWarning("Detected underrun\n");
546            dumpInfo();
547            return false;
548         }
549        
550         return true;
551
552 }
553
554 bool StreamProcessorManager::handleXrun() {
555
556         debugOutput( DEBUG_LEVEL_VERBOSE, "Handling Xrun ...\n");
557
558         /*
559          * Reset means:
560          * 1) Stopping the packetizer thread
561          * 2) Bringing all buffers & streamprocessors into a know state
562          *    - Clear all capture buffers
563          *    - Put nb_periods*period_size of null frames into the playback buffers
564          * 3) Restarting the packetizer thread
565          */
566         debugOutput( DEBUG_LEVEL_VERBOSE, "Stopping processormanager...\n");
567         if(!stop()) {
568            debugFatal("Could not stop.\n");
569            return false;
570         }
571
572         debugOutput( DEBUG_LEVEL_VERBOSE, "Resetting Processors...\n");
573        
574         // now we reset the frame counters
575         for ( StreamProcessorVectorIterator it = m_ReceiveProcessors.begin();
576                 it != m_ReceiveProcessors.end();
577                 ++it ) {
578                
579                 if(getDebugLevel()>=DEBUG_LEVEL_VERBOSE) {
580                         (*it)->dumpInfo();
581                 }
582                
583                 (*it)->reset();
584                
585                 if(getDebugLevel()>=DEBUG_LEVEL_VERBOSE) {
586                         (*it)->dumpInfo();
587                 }
588                
589         }
590        
591         for ( StreamProcessorVectorIterator it = m_TransmitProcessors.begin();
592                 it != m_TransmitProcessors.end();
593                 ++it ) {
594                
595                 if(getDebugLevel()>=DEBUG_LEVEL_VERBOSE) {
596                         (*it)->dumpInfo();
597                 }
598                
599                 (*it)->reset();
600                
601                 if(getDebugLevel()>=DEBUG_LEVEL_VERBOSE) {
602                         (*it)->dumpInfo();
603                 }
604         }
605
606         debugOutput( DEBUG_LEVEL_VERBOSE, "Starting processormanager...\n");
607
608         if(!start()) {
609            debugFatal("Could not start.\n");
610            return false;
611         }
612
613
614         debugOutput( DEBUG_LEVEL_VERBOSE, "Xrun handled...\n");
615        
616        
617         return true;
618 }
619
620 bool StreamProcessorManager::transfer() {
621
622         debugOutput( DEBUG_LEVEL_VERBOSE, "Transferring period...\n");
623
624         // a static cast could make sure that there is no performance
625         // penalty for the virtual functions (to be checked)
626
627         for ( StreamProcessorVectorIterator it = m_ReceiveProcessors.begin();
628                 it != m_ReceiveProcessors.end();
629                 ++it ) {
630                 if(!(*it)->transfer()) {
631                         debugFatal("could not transfer() stream processor (%p)",*it);
632                         return false;
633                 }
634         }
635
636         for ( StreamProcessorVectorIterator it = m_TransmitProcessors.begin();
637                 it != m_TransmitProcessors.end();
638                 ++it ) {
639                 if(!(*it)->transfer()) {
640                         debugFatal("could not transfer() stream processor (%p)",*it);
641                         return false;
642                 }
643         }
644
645         return true;
646 }
647
648 bool StreamProcessorManager::transfer(enum StreamProcessor::EProcessorType t) {
649
650         debugOutput( DEBUG_LEVEL_VERY_VERBOSE, "Transferring period...\n");
651
652         // a static cast could make sure that there is no performance
653         // penalty for the virtual functions (to be checked)
654         if (t==StreamProcessor::E_Receive) {
655                 for ( StreamProcessorVectorIterator it = m_ReceiveProcessors.begin();
656                         it != m_ReceiveProcessors.end();
657                         ++it ) {
658                         if(!(*it)->transfer()) {
659                                 debugFatal("could not transfer() stream processor (%p)",*it);
660                                 return false;
661                         }
662                 }
663         } else {
664                 for ( StreamProcessorVectorIterator it = m_TransmitProcessors.begin();
665                         it != m_TransmitProcessors.end();
666                         ++it ) {
667                         if(!(*it)->transfer()) {
668                                 debugFatal("could not transfer() stream processor (%p)",*it);
669                                 return false;
670                         }
671                 }
672         }
673
674         return true;
675 }
676
677 void StreamProcessorManager::dumpInfo() {
678         debugOutputShort( DEBUG_LEVEL_NORMAL, "----------------------------------------------------\n");
679         debugOutputShort( DEBUG_LEVEL_NORMAL, "Dumping StreamProcessorManager information...\n");
680         debugOutputShort( DEBUG_LEVEL_NORMAL, "Period count: %d\n", m_nbperiods);
681
682         debugOutputShort( DEBUG_LEVEL_NORMAL, " Receive processors...\n");
683         for ( StreamProcessorVectorIterator it = m_ReceiveProcessors.begin();
684                 it != m_ReceiveProcessors.end();
685                 ++it ) {
686                 (*it)->dumpInfo();
687         }
688
689         debugOutputShort( DEBUG_LEVEL_NORMAL, " Transmit processors...\n");
690         for ( StreamProcessorVectorIterator it = m_TransmitProcessors.begin();
691                 it != m_TransmitProcessors.end();
692                 ++it ) {
693                 (*it)->dumpInfo();
694         }
695
696         debugOutputShort( DEBUG_LEVEL_NORMAL, "Iso handler info:\n");
697         m_isoManager->dumpInfo();
698         debugOutputShort( DEBUG_LEVEL_NORMAL, "----------------------------------------------------\n");
699
700 }
701
702 void StreamProcessorManager::setVerboseLevel(int l) {
703         setDebugLevel(l);
704
705         if (m_isoManager) m_isoManager->setVerboseLevel(l);
706
707         debugOutput( DEBUG_LEVEL_VERBOSE, " Receive processors...\n");
708         for ( StreamProcessorVectorIterator it = m_ReceiveProcessors.begin();
709                 it != m_ReceiveProcessors.end();
710                 ++it ) {
711                 (*it)->setVerboseLevel(l);
712         }
713
714         debugOutput( DEBUG_LEVEL_VERBOSE, " Transmit processors...\n");
715         for ( StreamProcessorVectorIterator it = m_TransmitProcessors.begin();
716                 it != m_TransmitProcessors.end();
717                 ++it ) {
718                 (*it)->setVerboseLevel(l);
719         }
720 }
721
722
723 int StreamProcessorManager::getPortCount(enum Port::E_PortType type, enum Port::E_Direction direction) {
724         int count=0;
725
726         if (direction == Port::E_Capture) {
727                 for ( StreamProcessorVectorIterator it = m_ReceiveProcessors.begin();
728                         it != m_ReceiveProcessors.end();
729                         ++it ) {
730                         count += (*it)->getPortCount(type);
731                 }
732         } else {
733                 for ( StreamProcessorVectorIterator it = m_TransmitProcessors.begin();
734                         it != m_TransmitProcessors.end();
735                         ++it ) {
736                         count += (*it)->getPortCount(type);
737                 }
738         }
739         return count;
740 }
741
742 int StreamProcessorManager::getPortCount(enum Port::E_Direction direction) {
743         int count=0;
744
745         if (direction == Port::E_Capture) {
746                 for ( StreamProcessorVectorIterator it = m_ReceiveProcessors.begin();
747                         it != m_ReceiveProcessors.end();
748                         ++it ) {
749                         count += (*it)->getPortCount();
750                 }
751         } else {
752                 for ( StreamProcessorVectorIterator it = m_TransmitProcessors.begin();
753                         it != m_TransmitProcessors.end();
754                         ++it ) {
755                         count += (*it)->getPortCount();
756                 }
757         }
758         return count;
759 }
760
761 // TODO: implement a port map here, instead of the loop
762
763 Port* StreamProcessorManager::getPortByIndex(int idx, enum Port::E_Direction direction) {
764         int count=0;
765         int prevcount=0;
766
767         if (direction == Port::E_Capture) {
768                 for ( StreamProcessorVectorIterator it = m_ReceiveProcessors.begin();
769                         it != m_ReceiveProcessors.end();
770                         ++it ) {
771                         count += (*it)->getPortCount();
772                         if (count > idx) {
773                                 return (*it)->getPortAtIdx(idx-prevcount);
774                         }
775                         prevcount=count;
776                 }
777         } else {
778                 for ( StreamProcessorVectorIterator it = m_TransmitProcessors.begin();
779                         it != m_TransmitProcessors.end();
780                         ++it ) {
781                         count += (*it)->getPortCount();
782                         if (count > idx) {
783                                 return (*it)->getPortAtIdx(idx-prevcount);
784                         }
785                         prevcount=count;
786                 }
787         }
788         return NULL;
789 }
790
791 bool StreamProcessorManager::setThreadParameters(bool rt, int priority) {
792     m_thread_realtime=rt;
793     m_thread_priority=priority;
794     return true;
795 }
796
797
798 } // end of namespace
Note: See TracBrowser for help on using the browser.