Live555源代碼解讀（2）

3、消息循環

     看服端的主體：live555MediaServer.cpp中的main()函數，可見其建立一個RTSPServer類實例後，即進入一個函數env->taskScheduler().doEventLoop()中，看名字很明顯是一個消息循壞，執行到裏面後不停地轉圈，生名不息，轉圈不止。那麼在這我的生的圈圈中如何實現RTSP服務和RTP傳輸呢？別想那麼遠了，仍是先看這個圈圈中實現了什麼功能吧。

[cpp] view plaincopy

1. void BasicTaskScheduler0::doEventLoop(char* watchVariable) {  

2.     // Repeatedly loop, handling readble sockets and timed events:  

3.     while (1) {  

4.         if (watchVariable != NULL && *watchVariable != 0)  

5.             break;  

6.         SingleStep();  

7.     }  

8. }  

BasicTaskScheduler0從TaskScheduler派生，因此仍是一個任務調度對象，因此依然說明任務調度對象是整個程序的發動機。

循環中每次走一步：SingleStep()。這走一步中都作些什麼呢？

總結爲如下四步：

１爲全部須要操做的socket執行select。

２找出第一個應執行的socket任務(handler)並執行之。

３找到第一個應響應的事件，並執行之。

４找到第一個應執行的延遲任務並執行之。

可見，每一步中只執行三個任務隊列中的一項。下面詳細分析函數SingleStep()：

[cpp] view plaincopy

1. //循壞中主要執行的函數  

2. void BasicTaskScheduler::SingleStep(unsigned maxDelayTime) {  

3.     fd_set readSet = fReadSet; // make a copy for this select() call  

4.     fd_set writeSet = fWriteSet; // ditto  

5.     fd_set exceptionSet = fExceptionSet; // ditto  

6.   

7.     //計算select socket們時的超時時間。  

8.     DelayInterval const& timeToDelay = fDelayQueue.timeToNextAlarm();  

9.     struct timeval tv_timeToDelay;  

10.     tv_timeToDelay.tv_sec = timeToDelay.seconds();  

11.     tv_timeToDelay.tv_usec = timeToDelay.useconds();  

12.     // Very large "tv_sec" values cause select() to fail.  

13.     // Don't make it any larger than 1 million seconds (11.5 days)  

14.     const long MAX_TV_SEC = MILLION;  

15.     if (tv_timeToDelay.tv_sec > MAX_TV_SEC) {  

16.         tv_timeToDelay.tv_sec = MAX_TV_SEC;  

17.     }  

18.     // Also check our "maxDelayTime" parameter (if it's > 0):  

19.     if (maxDelayTime > 0  

20.             && (tv_timeToDelay.tv_sec > (long) maxDelayTime / MILLION  

21.                     || (tv_timeToDelay.tv_sec == (long) maxDelayTime / MILLION  

22.                             && tv_timeToDelay.tv_usec  

23.                                     > (long) maxDelayTime % MILLION))) {  

24.         tv_timeToDelay.tv_sec = maxDelayTime / MILLION;  

25.         tv_timeToDelay.tv_usec = maxDelayTime % MILLION;  

26.     }  

27.   

28.     //先執行socket的select操做，以肯定哪些socket任務（handler）須要執行。  

29.     int selectResult = select(fMaxNumSockets,  

30.             &readSet, &writeSet,&exceptionSet,  

31.             &tv_timeToDelay);  

32.   

33.     if (selectResult < 0) {  

34. //#if defined(__WIN32__) || defined(_WIN32)  

35.         int err = WSAGetLastError();  

36.         // For some unknown reason, select() in Windoze sometimes fails with WSAEINVAL if  

37.         // it was called with no entries set in "readSet".  If this happens, ignore it:  

38.         if (err == WSAEINVAL && readSet.fd_count == 0) {  

39.             err = EINTR;  

40.             // To stop this from happening again, create a dummy socket:  

41.             int dummySocketNum = socket(AF_INET, SOCK_DGRAM, 0);  

42.             FD_SET((unsigned) dummySocketNum, &fReadSet);  

43.         }  

44.         if (err != EINTR) {  

45. //#else  

46. //      if (errno != EINTR && errno != EAGAIN) {  

47. //#endif  

48.             // Unexpected error - treat this as fatal:  

49. //#if !defined(_WIN32_WCE)  

50. //          perror("BasicTaskScheduler::SingleStep(): select() fails");  

51. //#endif  

52.             internalError();  

53.         }  

54.     }  

55.   

56.     // Call the handler function for one readable socket:  

57.     HandlerIterator iter(*fHandlers);  

58.     HandlerDescriptor* handler;  

59.     // To ensure forward progress through the handlers, begin past the last  

60.     // socket number that we handled:  

61.     if (fLastHandledSocketNum >= 0) {  

62.         //找到上次執行的socket handler的下一個  

63.         while ((handler = iter.next()) != NULL) {  

64.             if (handler->socketNum == fLastHandledSocketNum)  

65.                 break;  

66.         }  

67.         if (handler == NULL) {  

68.             fLastHandledSocketNum = -1;  

69.             iter.reset(); // start from the beginning instead  

70.         }  

71.     }  

72.   

73.     //從找到的handler開始，找一個能夠執行的handler，不論其狀態是可讀，可寫，仍是出錯，執行之。  

74.     while ((handler = iter.next()) != NULL) {  

75.         int sock = handler->socketNum; // alias  

76.         int resultConditionSet = 0;  

77.         if (FD_ISSET(sock, &readSet)  

78.                 && FD_ISSET(sock, &fReadSet)/*sanity check*/)  

79.             resultConditionSet |= SOCKET_READABLE;  

80.         if (FD_ISSET(sock, &writeSet)  

81.                 && FD_ISSET(sock, &fWriteSet)/*sanity check*/)  

82.             resultConditionSet |= SOCKET_WRITABLE;  

83.         if (FD_ISSET(sock, &exceptionSet)  

84.                 && FD_ISSET(sock, &fExceptionSet)/*sanity check*/)  

85.             resultConditionSet |= SOCKET_EXCEPTION;  

86.         if ((resultConditionSet & handler->conditionSet)  

87.                 != 0 && handler->handlerProc != NULL) {  

88.             fLastHandledSocketNum = sock;  

89.             // Note: we set "fLastHandledSocketNum" before calling the handler,  

90.             // in case the handler calls "doEventLoop()" reentrantly.  

91.             (*handler->handlerProc)(handler->clientData, resultConditionSet);  

92.             break;  

93.         }  

94.     }  

95.   

96.     //若是尋找完了依然沒有執行任何handle，則從頭再找。  

97.     if (handler == NULL && fLastHandledSocketNum >= 0) {  

98.         // We didn't call a handler, but we didn't get to check all of them,  

99.         // so try again from the beginning:  

100.         iter.reset();  

101.         while ((handler = iter.next()) != NULL) {  

102.             int sock = handler->socketNum; // alias  

103.             int resultConditionSet = 0;  

104.             if (FD_ISSET(sock, &readSet)&& FD_ISSET(sock, &fReadSet)/*sanity check*/)  

105.                 resultConditionSet |= SOCKET_READABLE;  

106.             if (FD_ISSET(sock, &writeSet)&& FD_ISSET(sock, &fWriteSet)/*sanity check*/)  

107.                 resultConditionSet |= SOCKET_WRITABLE;  

108.             if (FD_ISSET(sock, &exceptionSet)   && FD_ISSET(sock, &fExceptionSet)/*sanity check*/)  

109.                 resultConditionSet |= SOCKET_EXCEPTION;  

110.             if ((resultConditionSet & handler->conditionSet)  

111.                     != 0 && handler->handlerProc != NULL) {  

112.                 fLastHandledSocketNum = sock;  

113.                 // Note: we set "fLastHandledSocketNum" before calling the handler,  

114.                 // in case the handler calls "doEventLoop()" reentrantly.  

115.                 (*handler->handlerProc)(handler->clientData, resultConditionSet);  

116.                 break;  

117.             }  

118.         }  

119.   

120.         //依然沒有找到可執行的handler。  

121.         if (handler == NULL)  

122.             fLastHandledSocketNum = -1; //because we didn't call a handler  

123.     }  

124.   

125.     //響應事件  

126.     // Also handle any newly-triggered event  

127.     // (Note that we do this *after* calling a socket handler,  

128.     // in case the triggered event handler modifies The set of readable sockets.)  

129.     if (fTriggersAwaitingHandling != 0) {  

130.         if (fTriggersAwaitingHandling == fLastUsedTriggerMask) {  

131.             // Common-case optimization for a single event trigger:  

132.             fTriggersAwaitingHandling = 0;  

133.             if (fTriggeredEventHandlers[fLastUsedTriggerNum] != NULL) {  

134.                 //執行一個事件處理函數  

135.                 (*fTriggeredEventHandlers[fLastUsedTriggerNum])(fTriggeredEventClientDatas[fLastUsedTriggerNum]);  

136.             }  

137.         } else {  

138.             // Look for an event trigger that needs handling  

139.             // (making sure that we make forward progress through all possible triggers):  

140.             unsigned i = fLastUsedTriggerNum;  

141.             EventTriggerId mask = fLastUsedTriggerMask;  

142.   

143.             do {  

144.                 i = (i + 1) % MAX_NUM_EVENT_TRIGGERS;  

145.                 mask >>= 1;  

146.                 if (mask == 0)  

147.                     mask = 0x80000000;  

148.   

149.                 if ((fTriggersAwaitingHandling & mask) != 0) {  

150.                     //執行一個事件響應  

151.                     fTriggersAwaitingHandling &= ~mask;  

152.                     if (fTriggeredEventHandlers[i] != NULL) {  

153.                         (*fTriggeredEventHandlers[i])(fTriggeredEventClientDatas[i]);  

154.                     }  

155.   

156.                     fLastUsedTriggerMask = mask;  

157.                     fLastUsedTriggerNum = i;  

158.                     break;  

159.                 }  

160.             } while (i != fLastUsedTriggerNum);  

161.         }  

162.     }  

163.   

164.     //執行一個最迫切的延遲任務。  

165.     // Also handle any delayed event that may have come due.  

166.     fDelayQueue.handleAlarm();  

167. }