Live555源代碼解讀（11）

十二 、h264 rtp包的時間戳

此次咱們一塊兒來分析一下live555中是怎樣爲rtp包打時間戳的．就以h264爲例吧．

[cpp] view plaincopy

1. void H264VideoRTPSink::doSpecialFrameHandling(unsigned /*fragmentationOffset*/,  

2.         unsigned char* /*frameStart*/,  

3.         unsigned /*numBytesInFrame*/,  

4.         struct timeval framePresentationTime,  

5.         unsigned /*numRemainingBytes*/)  

6. {  

7.     // Set the RTP 'M' (marker) bit iff  

8.     // 1/ The most recently delivered fragment was the end of (or the only fragment of) an NAL unit, and  

9.     // 2/ This NAL unit was the last NAL unit of an 'access unit' (i.e. video frame).  

10.     if (fOurFragmenter != NULL) {  

11.         H264VideoStreamFramer* framerSource = (H264VideoStreamFramer*) (fOurFragmenter->inputSource());  

12.         // This relies on our fragmenter's source being a "H264VideoStreamFramer".  

13.         if (fOurFragmenter->lastFragmentCompletedNALUnit()  

14.                 && framerSource != NULL && framerSource->pictureEndMarker()) {  

15.             setMarkerBit();  

16.             framerSource->pictureEndMarker() = False;  

17.         }  

18.     }  

19.   

20.     setTimestamp(framePresentationTime);  

21. }  

函數中先檢測是不是一個幀的最後一個包，若是是，打上'M'標記．而後就設置時間戳．這個間戳是哪來的呢？需看函數doSpecialFrameHandling()是被誰調用的，經查找，是被MultiFramedRTPSink::afterGettingFrame1()調用的．MultiFramedRTPSink::afterGettingFrame1()的參數presentationTime傳給了doSpecialFrameHandling()．MultiFramedRTPSink::afterGettingFrame1()是在調用source的getNextFrame()時傳給了source．傳給哪一個source呢？傳給了H264FUAFragmenter,還記得暗渡陳倉那件事嗎？因此H264FUAFragmenter在獲取一個nal unit後調用了MultiFramedRTPSink::afterGettingFrame1()．也就是H264FUAFragmenter::afterGettingFrame1()調用了MultiFramedRTPSink::afterGettingFrame1()．
H264FUAFragmenter::afterGettingFrame1()是被它本身的source的afterGettingFrame1()調用的．H264FUAFragmenter的source是誰呢？是H264VideoStreamFramer，是在暗渡陳倉時傳給H264FUAFragmenter的構造函數的．
H264VideoStreamFramer的afterGettingFrame1()是沒有的，代替之的是MPEGVideoStreamFramer::continueReadProcessin()．它被MPEGVideoStreamParser暗中傳給了StreamParser的構造函數．因此StreamParser在分析完一幀（或nal unit)以後，調用的就是MPEGVideoStreamFramer::continueReadProcessin()．如下便是證實：(補充：如下函數並非在parser分析完一幀（或nal unit）以後調用，而是parser利用ByteStreamFileSuorce獲取到原始數據後調用，而後MPEGVideoStreamFramer再調用Parser的parser()函數分析原始數據)

[cpp] view plaincopy

1. void StreamParser::afterGettingBytes(void* clientData,  

2.         unsigned numBytesRead,  

3.         unsigned /*numTruncatedBytes*/,  

4.         struct timeval presentationTime,  

5.         unsigned /*durationInMicroseconds*/)  

6. {  

7.     StreamParser* parser = (StreamParser*) clientData;  

8.     if (parser != NULL)  

9.         parser->afterGettingBytes1(numBytesRead, presentationTime);  

10. }  

11.   

12. void StreamParser::afterGettingBytes1(unsigned numBytesRead,  

13.         struct timeval presentationTime)  

14. {  

15.     // Sanity check: Make sure we didn't get too many bytes for our bank:  

16.     if (fTotNumValidBytes + numBytesRead > BANK_SIZE) {  

17.         fInputSource->envir()  

18.                 << "StreamParser::afterGettingBytes() warning: read "  

19.                 << numBytesRead << " bytes; expected no more than "  

20.                 << BANK_SIZE - fTotNumValidBytes << "\n";  

21.     }  

22.   

23.     fLastSeenPresentationTime = presentationTime;  

24.   

25.     unsigned char* ptr = &curBank()[fTotNumValidBytes];  

26.     fTotNumValidBytes += numBytesRead;  

27.   

28.     // Continue our original calling source where it left off:  

29.     restoreSavedParserState();  

30.     // Sigh... this is a crock; things would have been a lot simpler  

31.     // here if we were using threads, with synchronous I/O...  

32.     fClientContinueFunc(fClientContinueClientData, ptr, numBytesRead,  

33.             presentationTime);  

34. }  

fClientContinueFunc就是MPEGVideoStreamFramer::continueReadProcessin()，並且咱們看到時間戳被傳入fClientContinueFunc．
然而，MPEGVideoStreamFramer::continueReadProcessin()中跟本就不理這個時間戳，由於這個時間戳是ByteStreamFileSource計算出來的，它跟本就不可能正確．

[cpp] view plaincopy

1. void MPEGVideoStreamFramer::continueReadProcessing(void* clientData,  

2.         unsigned char* /*ptr*/,  

3.         unsigned /*size*/,  

4.         struct timeval /*presentationTime*/)  

5. {  

6.     MPEGVideoStreamFramer* framer = (MPEGVideoStreamFramer*) clientData;  

7.     framer->continueReadProcessing();  

8. }  

看來真正的時間戳是在MPEGVideoStreamFramer中計算的，可是H264VideoStreamFramer並無用到MPEGVideoStreamFramer中那些計算時間戳的函數，而是另外計算，其實H264VideoStreamFramer也沒有本身去計算，而是利用H264VideoStreamParser計算的．是在哪一個函數中呢？在parser()中！

[cpp] view plaincopy

1. unsigned H264VideoStreamParser::parse()  

2. {  

3.     try {  

4.         // The stream must start with a 0x00000001:  

5.         if (!fHaveSeenFirstStartCode) {  

6.             // Skip over any input bytes that precede the first 0x00000001:  

7.             u_int32_t first4Bytes;  

8.             while ((first4Bytes = test4Bytes()) != 0x00000001) {  

9.                 get1Byte();  

10.                 setParseState(); // ensures that we progress over bad data  

11.             }  

12.             skipBytes(4); // skip this initial code  

13.   

14.             setParseState();  

15.             fHaveSeenFirstStartCode = True; // from now on  

16.         }  

17.   

18.         if (fOutputStartCodeSize > 0) {  

19.             // Include a start code in the output:  

20.             save4Bytes(0x00000001);  

21.         }  

22.   

23.         // Then save everything up until the next 0x00000001 (4 bytes) or 0x000001 (3 bytes), or we hit EOF.  

24.         // Also make note of the first byte, because it contains the "nal_unit_type":  

25.         u_int8_t firstByte;  

26.         if (haveSeenEOF()) {  

27.             // We hit EOF the last time that we tried to parse this data,  

28.             // so we know that the remaining unparsed data forms a complete NAL unit:  

29.             unsigned remainingDataSize = totNumValidBytes() - curOffset();  

30.             if (remainingDataSize == 0)  

31.                 (void) get1Byte(); // forces another read, which will cause EOF to get handled for real this time  

32.             if (remainingDataSize == 0)  

33.                 return 0;  

34.             firstByte = get1Byte();  

35.             saveByte(firstByte);  

36.   

37.             while (--remainingDataSize > 0) {  

38.                 saveByte(get1Byte());  

39.             }  

40.         } else {  

41.             u_int32_t next4Bytes = test4Bytes();  

42.             firstByte = next4Bytes >> 24;  

43.             while (next4Bytes != 0x00000001  

44.                     && (next4Bytes & 0xFFFFFF00) != 0x00000100) {  

45.                 // We save at least some of "next4Bytes".  

46.                 if ((unsigned) (next4Bytes & 0xFF) > 1) {  

47.                     // Common case: 0x00000001 or 0x000001 definitely doesn't begin anywhere in "next4Bytes", so we save all of it:  

48.                     save4Bytes(next4Bytes);  

49.                     skipBytes(4);  

50.                 } else {  

51.                     // Save the first byte, and continue testing the rest:  

52.                     saveByte(next4Bytes >> 24);  

53.                     skipBytes(1);  

54.                 }  

55.                 next4Bytes = test4Bytes();  

56.             }  

57.             // Assert: next4Bytes starts with 0x00000001 or 0x000001, and we've saved all previous bytes (forming a complete NAL unit).  

58.             // Skip over these remaining bytes, up until the start of the next NAL unit:  

59.             if (next4Bytes == 0x00000001) {  

60.                 skipBytes(4);  

61.             } else {  

62.                 skipBytes(3);  

63.             }  

64.         }  

65.   

66.         u_int8_t nal_ref_idc = (firstByte & 0x60) >> 5;  

67.         u_int8_t nal_unit_type = firstByte & 0x1F;  

68.   

69.         switch (nal_unit_type) {  

70.         case 6: { // Supplemental enhancement information (SEI)  

71.             analyze_sei_data();  

72.             // Later, perhaps adjust "fPresentationTime" if we saw a "pic_timing" SEI payload??? #####  

73.             break;  

74.         }  

75.         case 7: { // Sequence parameter set  

76.             // First, save a copy of this NAL unit, in case the downstream object wants to see it:  

77.             usingSource()->saveCopyOfSPS(fStartOfFrame + fOutputStartCodeSize,  

78.                     fTo - fStartOfFrame - fOutputStartCodeSize);  

79.   

80.             // Parse this NAL unit to check whether frame rate information is present:  

81.             unsigned num_units_in_tick, time_scale, fixed_frame_rate_flag;  

82.             analyze_seq_parameter_set_data(num_units_in_tick, time_scale,  

83.                     fixed_frame_rate_flag);  

84.             if (time_scale > 0 && num_units_in_tick > 0) {  

85.                 usingSource()->fFrameRate = time_scale  

86.                         / (2.0 * num_units_in_tick);  

87.             } else {  

88.             }  

89.             break;  

90.         }  

91.         case 8: { // Picture parameter set  

92.             // Save a copy of this NAL unit, in case the downstream object wants to see it:  

93.             usingSource()->saveCopyOfPPS(fStartOfFrame + fOutputStartCodeSize,  

94.                     fTo - fStartOfFrame - fOutputStartCodeSize);  

95.         }  

96.         }  

97.   

98.         //更新時間戳變量  

99.         usingSource()->setPresentationTime();  

100.   

101.         // If this NAL unit is a VCL NAL unit, we also scan the start of the next NAL unit, to determine whether this NAL unit  

102.         // ends the current 'access unit'.  We need this information to figure out when to increment "fPresentationTime".  

103.         // (RTP streamers also need to know this in order to figure out whether or not to set the "M" bit.)  

104.         Boolean thisNALUnitEndsAccessUnit = False; // until we learn otherwise  

105.         if (haveSeenEOF()) {  

106.             // There is no next NAL unit, so we assume that this one ends the current 'access unit':  

107.             thisNALUnitEndsAccessUnit = True;  

108.         } else {  

109.             Boolean const isVCL = nal_unit_type <= 5 && nal_unit_type > 0; // Would need to include type 20 for SVC and MVC #####  

110.             if (isVCL) {  

111.                 u_int32_t first4BytesOfNextNALUnit = test4Bytes();  

112.                 u_int8_t firstByteOfNextNALUnit = first4BytesOfNextNALUnit  

113.                         >> 24;  

114.                 u_int8_t next_nal_ref_idc = (firstByteOfNextNALUnit & 0x60)  

115.                         >> 5;  

116.                 u_int8_t next_nal_unit_type = firstByteOfNextNALUnit & 0x1F;  

117.                 if (next_nal_unit_type >= 6) {  

118.                     // The next NAL unit is not a VCL; therefore, we assume that this NAL unit ends the current 'access unit':  

119.                     thisNALUnitEndsAccessUnit = True;  

120.                 } else {  

121.                     // The next NAL unit is also a VLC.  We need to examine it a little to figure out if it's a different 'access unit'.  

122.                     // (We use many of the criteria described in section 7.4.1.2.4 of the H.264 specification.)  

123.                     Boolean IdrPicFlag = nal_unit_type == 5;  

124.                     Boolean next_IdrPicFlag = next_nal_unit_type == 5;  

125.                     if (next_IdrPicFlag != IdrPicFlag) {  

126.                         // IdrPicFlag differs in value  

127.                         thisNALUnitEndsAccessUnit = True;  

128.                     } else if (next_nal_ref_idc != nal_ref_idc  

129.                             && next_nal_ref_idc * nal_ref_idc == 0) {  

130.                         // nal_ref_idc differs in value with one of the nal_ref_idc values being equal to 0  

131.                         thisNALUnitEndsAccessUnit = True;  

132.                     } else if ((nal_unit_type == 1 || nal_unit_type == 2  

133.                             || nal_unit_type == 5)  

134.                             && (next_nal_unit_type == 1  

135.                                     || next_nal_unit_type == 2  

136.                                     || next_nal_unit_type == 5)) {  

137.                         // Both this and the next NAL units begin with a "slice_header".  

138.                         // Parse this (for each), to get parameters that we can compare:  

139.   

140.                         // Current NAL unit's "slice_header":  

141.                         unsigned frame_num, pic_parameter_set_id, idr_pic_id;  

142.                         Boolean field_pic_flag, bottom_field_flag;  

143.                         analyze_slice_header(  

144.                                 fStartOfFrame + fOutputStartCodeSize, fTo,  

145.                                 nal_unit_type, frame_num, pic_parameter_set_id,  

146.                                 idr_pic_id, field_pic_flag, bottom_field_flag);  

147.   

148.                         // Next NAL unit's "slice_header":  

149.                         u_int8_t next_slice_header[NUM_NEXT_SLICE_HEADER_BYTES_TO_ANALYZE];  

150.                         testBytes(next_slice_header, sizeof next_slice_header);  

151.                         unsigned next_frame_num, next_pic_parameter_set_id,  

152.                                 next_idr_pic_id;  

153.                         Boolean next_field_pic_flag, next_bottom_field_flag;  

154.                         analyze_slice_header(next_slice_header,  

155.                                 &next_slice_header[sizeof next_slice_header],  

156.                                 next_nal_unit_type, next_frame_num,  

157.                                 next_pic_parameter_set_id, next_idr_pic_id,  

158.                                 next_field_pic_flag, next_bottom_field_flag);  

159.   

160.                         if (next_frame_num != frame_num) {  

161.                             // frame_num differs in value  

162.                             thisNALUnitEndsAccessUnit = True;  

163.                         } else if (next_pic_parameter_set_id  

164.                                 != pic_parameter_set_id) {  

165.                             // pic_parameter_set_id differs in value  

166.                             thisNALUnitEndsAccessUnit = True;  

167.                         } else if (next_field_pic_flag != field_pic_flag) {  

168.                             // field_pic_flag differs in value  

169.                             thisNALUnitEndsAccessUnit = True;  

170.                         } else if (next_bottom_field_flag  

171.                                 != bottom_field_flag) {  

172.                             // bottom_field_flag differs in value  

173.                             thisNALUnitEndsAccessUnit = True;  

174.                         } else if (next_IdrPicFlag == 1  

175.                                 && next_idr_pic_id != idr_pic_id) {  

176.                             // IdrPicFlag is equal to 1 for both and idr_pic_id differs in value  

177.                             // Note: We already know that IdrPicFlag is the same for both.  

178.                             thisNALUnitEndsAccessUnit = True;  

179.                         }  

180.                     }  

181.                 }  

182.             }  

183.         }  

184.   

185.         //注意！注意！注意！此處計算時間戳！！  

186.         if (thisNALUnitEndsAccessUnit) {  

187.             usingSource()->fPictureEndMarker = True;  

188.             ++usingSource()->fPictureCount;  

189.   

190.             // Note that the presentation time for the next NAL unit will be different:  

191.             struct timeval& nextPT = usingSource()->fNextPresentationTime; // alias  

192.             nextPT = usingSource()->fPresentationTime;  

193.             double nextFraction = nextPT.tv_usec / 1000000.0  

194.                     + 1 / usingSource()->fFrameRate;  

195.             unsigned nextSecsIncrement = (long) nextFraction;  

196.             nextPT.tv_sec += (long) nextSecsIncrement;  

197.             nextPT.tv_usec = (long) ((nextFraction - nextSecsIncrement)  

198.                     * 1000000);  

199.         }  

200.         setParseState();  

201.   

202.         return curFrameSize();  

203.     } catch (int /*e*/) {  

204.         return 0; // the parsing got interrupted  

205.     }  

206. }  

每當開始一個新幀時，計算新的時間戳．時間戳保存在fNextPresentationTime中，在usingSource()->setPresentationTime()中傳給fPresentationTime.
哇，咱們看到live555的類之間調用關係曲折複雜，的確有點不易維護啊！同時我寫的也不夠清析，本身看着都暈，若是把你搞暈了，這很正常哦！

fPresentationTime是64位的時間，經convertToRTPTimestamp轉換爲32的rtp時間戳，見函數：

[cpp] view plaincopy

1. u_int32_t RTPSink::convertToRTPTimestamp(struct timeval tv)  

2. {  

3.     // Begin by converting from "struct timeval" units to RTP timestamp units:  

4.     u_int32_t timestampIncrement = (fTimestampFrequency * tv.tv_sec);  

5.     timestampIncrement += (u_int32_t)(  

6.             (2.0 * fTimestampFrequency * tv.tv_usec + 1000000.0) / 2000000);  

7.     // note: rounding  

8.   

9.     // Then add this to our 'timestamp base':  

10.     if (fNextTimestampHasBeenPreset) {  

11.         // Make the returned timestamp the same as the current "fTimestampBase",  

12.         // so that timestamps begin with the value that was previously preset:  

13.         fTimestampBase -= timestampIncrement;  

14.         fNextTimestampHasBeenPreset = False;  

15.     }  

16.   

17.     u_int32_t const rtpTimestamp = fTimestampBase + timestampIncrement;  

18.       

19.     return rtpTimestamp;  

20. }  

其實時間戳的轉換主要就是把以秒爲單位的時間，提高成按頻率爲單位的時間．也就是提高後，時間間隔不是以秒爲單位，而是以1/fTimestampFrequency爲單位，也就是1/9000秒。而後再強轉爲32。