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

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

MOTU: Fixed false "missed rx cycle" report following xrun recovery.
Ensure iso rx/tx contexts are deallocated during shutdown/xrun recovery by explicitly deleting IsoHandlers? in IsoHandlerManager::pruneHandlers(). If they aren't deleted here they never get deleted because the reference is lost.
IsoHandler? destructor should only call stop() if the handle is valid.
IsoXmitHandler?'s destructor sets the handle NULL to prevent double-free by the inherited IsoHandler? destructor.
Don't call raw1394_iso_shutdown() from our code. libraw1394 1.2.1 has a bug whereby raw1394_new_handle() fails to initialise the iso_packet_infos field. The bug hits us particularly in IsoRecvHandler::prepare(). It's also not really necessary to call raw1394_iso_shutdown() since raw1394_destroy_handle() will do any cleanups we happen to need.
MOTU: the receive stream no longer falsely complains of buffer problems during device shutdown.
MOTU: fixed a false "missed cycle" detection immediately after the stream was enabled.

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 until 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         debugOutput( DEBUG_LEVEL_VERBOSE, " Transmit processors...\n");
521         for ( StreamProcessorVectorIterator it = m_TransmitProcessors.begin();
522                 it != m_TransmitProcessors.end();
523                 ++it ) {
524                         if (!m_isoManager->unregisterStream(*it)) {
525                                 debugOutput(DEBUG_LEVEL_VERBOSE,"Could not unregister transmit stream processor (%p) from the Iso manager\n",*it);
526                                 return false;
527                         }
528                        
529                 }
530        
531         return true;
532        
533 }
534
535 bool StreamProcessorManager::waitForPeriod() {
536
537         debugOutput( DEBUG_LEVEL_VERY_VERBOSE, "enter...\n");
538
539         // Wait for packetizer thread to signal a period completion
540         sem_wait(&m_period_semaphore);
541        
542         if(m_xrun_happened) {
543            debugWarning("Detected underrun\n");
544            dumpInfo();
545            return false;
546         }
547        
548         return true;
549
550 }
551
552 bool StreamProcessorManager::handleXrun() {
553
554         debugOutput( DEBUG_LEVEL_VERBOSE, "Handling Xrun ...\n");
555
556         /*
557          * Reset means:
558          * 1) Stopping the packetizer thread
559          * 2) Bringing all buffers & streamprocessors into a know state
560          *    - Clear all capture buffers
561          *    - Put nb_periods*period_size of null frames into the playback buffers
562          * 3) Restarting the packetizer thread
563          */
564         debugOutput( DEBUG_LEVEL_VERBOSE, "Stopping processormanager...\n");
565         if(!stop()) {
566            debugFatal("Could not stop.\n");
567            return false;
568         }
569
570         debugOutput( DEBUG_LEVEL_VERBOSE, "Resetting Processors...\n");
571        
572         // now we reset the frame counters
573         for ( StreamProcessorVectorIterator it = m_ReceiveProcessors.begin();
574                 it != m_ReceiveProcessors.end();
575                 ++it ) {
576                
577                 if(getDebugLevel()>=DEBUG_LEVEL_VERBOSE) {
578                         (*it)->dumpInfo();
579                 }
580                
581                 (*it)->reset();
582                
583                 if(getDebugLevel()>=DEBUG_LEVEL_VERBOSE) {
584                         (*it)->dumpInfo();
585                 }
586                
587         }
588        
589         for ( StreamProcessorVectorIterator it = m_TransmitProcessors.begin();
590                 it != m_TransmitProcessors.end();
591                 ++it ) {
592                
593                 if(getDebugLevel()>=DEBUG_LEVEL_VERBOSE) {
594                         (*it)->dumpInfo();
595                 }
596                
597                 (*it)->reset();
598                
599                 if(getDebugLevel()>=DEBUG_LEVEL_VERBOSE) {
600                         (*it)->dumpInfo();
601                 }
602         }
603
604         debugOutput( DEBUG_LEVEL_VERBOSE, "Starting processormanager...\n");
605
606         if(!start()) {
607            debugFatal("Could not start.\n");
608            return false;
609         }
610
611
612         debugOutput( DEBUG_LEVEL_VERBOSE, "Xrun handled...\n");
613        
614        
615         return true;
616 }
617
618 bool StreamProcessorManager::transfer() {
619
620         debugOutput( DEBUG_LEVEL_VERBOSE, "Transferring period...\n");
621
622         // a static cast could make sure that there is no performance
623         // penalty for the virtual functions (to be checked)
624
625         for ( StreamProcessorVectorIterator it = m_ReceiveProcessors.begin();
626                 it != m_ReceiveProcessors.end();
627                 ++it ) {
628                 if(!(*it)->transfer()) {
629                         debugFatal("could not transfer() stream processor (%p)",*it);
630                         return false;
631                 }
632         }
633
634         for ( StreamProcessorVectorIterator it = m_TransmitProcessors.begin();
635                 it != m_TransmitProcessors.end();
636                 ++it ) {
637                 if(!(*it)->transfer()) {
638                         debugFatal("could not transfer() stream processor (%p)",*it);
639                         return false;
640                 }
641         }
642
643         return true;
644 }
645
646 bool StreamProcessorManager::transfer(enum StreamProcessor::EProcessorType t) {
647
648         debugOutput( DEBUG_LEVEL_VERY_VERBOSE, "Transferring period...\n");
649
650         // a static cast could make sure that there is no performance
651         // penalty for the virtual functions (to be checked)
652         if (t==StreamProcessor::E_Receive) {
653                 for ( StreamProcessorVectorIterator it = m_ReceiveProcessors.begin();
654                         it != m_ReceiveProcessors.end();
655                         ++it ) {
656                         if(!(*it)->transfer()) {
657                                 debugFatal("could not transfer() stream processor (%p)",*it);
658                                 return false;
659                         }
660                 }
661         } else {
662                 for ( StreamProcessorVectorIterator it = m_TransmitProcessors.begin();
663                         it != m_TransmitProcessors.end();
664                         ++it ) {
665                         if(!(*it)->transfer()) {
666                                 debugFatal("could not transfer() stream processor (%p)",*it);
667                                 return false;
668                         }
669                 }
670         }
671
672         return true;
673 }
674
675 void StreamProcessorManager::dumpInfo() {
676         debugOutputShort( DEBUG_LEVEL_NORMAL, "----------------------------------------------------\n");
677         debugOutputShort( DEBUG_LEVEL_NORMAL, "Dumping StreamProcessorManager information...\n");
678         debugOutputShort( DEBUG_LEVEL_NORMAL, "Period count: %d\n", m_nbperiods);
679
680         debugOutputShort( DEBUG_LEVEL_NORMAL, " Receive processors...\n");
681         for ( StreamProcessorVectorIterator it = m_ReceiveProcessors.begin();
682                 it != m_ReceiveProcessors.end();
683                 ++it ) {
684                 (*it)->dumpInfo();
685         }
686
687         debugOutputShort( DEBUG_LEVEL_NORMAL, " Transmit processors...\n");
688         for ( StreamProcessorVectorIterator it = m_TransmitProcessors.begin();
689                 it != m_TransmitProcessors.end();
690                 ++it ) {
691                 (*it)->dumpInfo();
692         }
693
694         debugOutputShort( DEBUG_LEVEL_NORMAL, "Iso handler info:\n");
695         m_isoManager->dumpInfo();
696         debugOutputShort( DEBUG_LEVEL_NORMAL, "----------------------------------------------------\n");
697
698 }
699
700 void StreamProcessorManager::setVerboseLevel(int l) {
701         setDebugLevel(l);
702
703         if (m_isoManager) m_isoManager->setVerboseLevel(l);
704
705         debugOutput( DEBUG_LEVEL_VERBOSE, " Receive processors...\n");
706         for ( StreamProcessorVectorIterator it = m_ReceiveProcessors.begin();
707                 it != m_ReceiveProcessors.end();
708                 ++it ) {
709                 (*it)->setVerboseLevel(l);
710         }
711
712         debugOutput( DEBUG_LEVEL_VERBOSE, " Transmit processors...\n");
713         for ( StreamProcessorVectorIterator it = m_TransmitProcessors.begin();
714                 it != m_TransmitProcessors.end();
715                 ++it ) {
716                 (*it)->setVerboseLevel(l);
717         }
718 }
719
720
721 int StreamProcessorManager::getPortCount(enum Port::E_PortType type, enum Port::E_Direction direction) {
722         int count=0;
723
724         if (direction == Port::E_Capture) {
725                 for ( StreamProcessorVectorIterator it = m_ReceiveProcessors.begin();
726                         it != m_ReceiveProcessors.end();
727                         ++it ) {
728                         count += (*it)->getPortCount(type);
729                 }
730         } else {
731                 for ( StreamProcessorVectorIterator it = m_TransmitProcessors.begin();
732                         it != m_TransmitProcessors.end();
733                         ++it ) {
734                         count += (*it)->getPortCount(type);
735                 }
736         }
737         return count;
738 }
739
740 int StreamProcessorManager::getPortCount(enum Port::E_Direction direction) {
741         int count=0;
742
743         if (direction == Port::E_Capture) {
744                 for ( StreamProcessorVectorIterator it = m_ReceiveProcessors.begin();
745                         it != m_ReceiveProcessors.end();
746                         ++it ) {
747                         count += (*it)->getPortCount();
748                 }
749         } else {
750                 for ( StreamProcessorVectorIterator it = m_TransmitProcessors.begin();
751                         it != m_TransmitProcessors.end();
752                         ++it ) {
753                         count += (*it)->getPortCount();
754                 }
755         }
756         return count;
757 }
758
759 // TODO: implement a port map here, instead of the loop
760
761 Port* StreamProcessorManager::getPortByIndex(int idx, enum Port::E_Direction direction) {
762         int count=0;
763         int prevcount=0;
764
765         if (direction == Port::E_Capture) {
766                 for ( StreamProcessorVectorIterator it = m_ReceiveProcessors.begin();
767                         it != m_ReceiveProcessors.end();
768                         ++it ) {
769                         count += (*it)->getPortCount();
770                         if (count > idx) {
771                                 return (*it)->getPortAtIdx(idx-prevcount);
772                         }
773                         prevcount=count;
774                 }
775         } else {
776                 for ( StreamProcessorVectorIterator it = m_TransmitProcessors.begin();
777                         it != m_TransmitProcessors.end();
778                         ++it ) {
779                         count += (*it)->getPortCount();
780                         if (count > idx) {
781                                 return (*it)->getPortAtIdx(idx-prevcount);
782                         }
783                         prevcount=count;
784                 }
785         }
786         return NULL;
787 }
788
789 bool StreamProcessorManager::setThreadParameters(bool rt, int priority) {
790     m_thread_realtime=rt;
791     m_thread_priority=priority;
792     return true;
793 }
794
795
796 } // end of namespace
Note: See TracBrowser for help on using the browser.