OLD | NEW |
| (Empty) |
1 /* | |
2 * Copyright (c) 2011 The WebRTC project authors. All Rights Reserved. | |
3 * | |
4 * Use of this source code is governed by a BSD-style license | |
5 * that can be found in the LICENSE file in the root of the source | |
6 * tree. An additional intellectual property rights grant can be found | |
7 * in the file PATENTS. All contributing project authors may | |
8 * be found in the AUTHORS file in the root of the source tree. | |
9 */ | |
10 | |
11 #ifndef WEBRTC_MODULES_VIDEO_CODING_MAIN_SOURCE_SESSION_INFO_H_ | |
12 #define WEBRTC_MODULES_VIDEO_CODING_MAIN_SOURCE_SESSION_INFO_H_ | |
13 | |
14 #include <list> | |
15 | |
16 #include "webrtc/modules/include/module_common_types.h" | |
17 #include "webrtc/modules/video_coding/main/interface/video_coding.h" | |
18 #include "webrtc/modules/video_coding/main/source/packet.h" | |
19 #include "webrtc/typedefs.h" | |
20 | |
21 namespace webrtc { | |
22 // Used to pass data from jitter buffer to session info. | |
23 // This data is then used in determining whether a frame is decodable. | |
24 struct FrameData { | |
25 int64_t rtt_ms; | |
26 float rolling_average_packets_per_frame; | |
27 }; | |
28 | |
29 class VCMSessionInfo { | |
30 public: | |
31 VCMSessionInfo(); | |
32 | |
33 void UpdateDataPointers(const uint8_t* old_base_ptr, | |
34 const uint8_t* new_base_ptr); | |
35 // NACK - Building the NACK lists. | |
36 // Build hard NACK list: Zero out all entries in list up to and including | |
37 // _lowSeqNum. | |
38 int BuildHardNackList(int* seq_num_list, | |
39 int seq_num_list_length, | |
40 int nack_seq_nums_index); | |
41 | |
42 // Build soft NACK list: Zero out only a subset of the packets, discard | |
43 // empty packets. | |
44 int BuildSoftNackList(int* seq_num_list, | |
45 int seq_num_list_length, | |
46 int nack_seq_nums_index, | |
47 int rtt_ms); | |
48 void Reset(); | |
49 int InsertPacket(const VCMPacket& packet, | |
50 uint8_t* frame_buffer, | |
51 VCMDecodeErrorMode enable_decodable_state, | |
52 const FrameData& frame_data); | |
53 bool complete() const; | |
54 bool decodable() const; | |
55 | |
56 // Builds fragmentation headers for VP8, each fragment being a decodable | |
57 // VP8 partition. Returns the total number of bytes which are decodable. Is | |
58 // used instead of MakeDecodable for VP8. | |
59 size_t BuildVP8FragmentationHeader(uint8_t* frame_buffer, | |
60 size_t frame_buffer_length, | |
61 RTPFragmentationHeader* fragmentation); | |
62 | |
63 // Makes the frame decodable. I.e., only contain decodable NALUs. All | |
64 // non-decodable NALUs will be deleted and packets will be moved to in | |
65 // memory to remove any empty space. | |
66 // Returns the number of bytes deleted from the session. | |
67 size_t MakeDecodable(); | |
68 | |
69 // Sets decodable_ to false. | |
70 // Used by the dual decoder. After the mode is changed to kNoErrors from | |
71 // kWithErrors or kSelective errors, any states that have been marked | |
72 // decodable and are not complete are marked as non-decodable. | |
73 void SetNotDecodableIfIncomplete(); | |
74 | |
75 size_t SessionLength() const; | |
76 int NumPackets() const; | |
77 bool HaveFirstPacket() const; | |
78 bool HaveLastPacket() const; | |
79 bool session_nack() const; | |
80 webrtc::FrameType FrameType() const { return frame_type_; } | |
81 int LowSequenceNumber() const; | |
82 | |
83 // Returns highest sequence number, media or empty. | |
84 int HighSequenceNumber() const; | |
85 int PictureId() const; | |
86 int TemporalId() const; | |
87 bool LayerSync() const; | |
88 int Tl0PicId() const; | |
89 bool NonReference() const; | |
90 | |
91 void SetGofInfo(const GofInfoVP9& gof_info, size_t idx); | |
92 | |
93 // The number of packets discarded because the decoder can't make use of | |
94 // them. | |
95 int packets_not_decodable() const; | |
96 | |
97 private: | |
98 enum { kMaxVP8Partitions = 9 }; | |
99 | |
100 typedef std::list<VCMPacket> PacketList; | |
101 typedef PacketList::iterator PacketIterator; | |
102 typedef PacketList::const_iterator PacketIteratorConst; | |
103 typedef PacketList::reverse_iterator ReversePacketIterator; | |
104 | |
105 void InformOfEmptyPacket(uint16_t seq_num); | |
106 | |
107 // Finds the packet of the beginning of the next VP8 partition. If | |
108 // none is found the returned iterator points to |packets_.end()|. | |
109 // |it| is expected to point to the last packet of the previous partition, | |
110 // or to the first packet of the frame. |packets_skipped| is incremented | |
111 // for each packet found which doesn't have the beginning bit set. | |
112 PacketIterator FindNextPartitionBeginning(PacketIterator it) const; | |
113 | |
114 // Returns an iterator pointing to the last packet of the partition pointed to | |
115 // by |it|. | |
116 PacketIterator FindPartitionEnd(PacketIterator it) const; | |
117 static bool InSequence(const PacketIterator& it, | |
118 const PacketIterator& prev_it); | |
119 size_t InsertBuffer(uint8_t* frame_buffer, | |
120 PacketIterator packetIterator); | |
121 size_t Insert(const uint8_t* buffer, | |
122 size_t length, | |
123 bool insert_start_code, | |
124 uint8_t* frame_buffer); | |
125 void ShiftSubsequentPackets(PacketIterator it, int steps_to_shift); | |
126 PacketIterator FindNaluEnd(PacketIterator packet_iter) const; | |
127 // Deletes the data of all packets between |start| and |end|, inclusively. | |
128 // Note that this function doesn't delete the actual packets. | |
129 size_t DeletePacketData(PacketIterator start, | |
130 PacketIterator end); | |
131 void UpdateCompleteSession(); | |
132 | |
133 // When enabled, determine if session is decodable, i.e. incomplete but | |
134 // would be sent to the decoder. | |
135 // Note: definition assumes random loss. | |
136 // A frame is defined to be decodable when: | |
137 // Round trip time is higher than threshold | |
138 // It is not a key frame | |
139 // It has the first packet: In VP8 the first packet contains all or part of | |
140 // the first partition, which consists of the most relevant information for | |
141 // decoding. | |
142 // Either more than the upper threshold of the average number of packets per | |
143 // frame is present | |
144 // or less than the lower threshold of the average number of packets per | |
145 // frame is present: suggests a small frame. Such a frame is unlikely | |
146 // to contain many motion vectors, so having the first packet will | |
147 // likely suffice. Once we have more than the lower threshold of the | |
148 // frame, we know that the frame is medium or large-sized. | |
149 void UpdateDecodableSession(const FrameData& frame_data); | |
150 | |
151 // If this session has been NACKed by the jitter buffer. | |
152 bool session_nack_; | |
153 bool complete_; | |
154 bool decodable_; | |
155 webrtc::FrameType frame_type_; | |
156 // Packets in this frame. | |
157 PacketList packets_; | |
158 int empty_seq_num_low_; | |
159 int empty_seq_num_high_; | |
160 | |
161 // The following two variables correspond to the first and last media packets | |
162 // in a session defined by the first packet flag and the marker bit. | |
163 // They are not necessarily equal to the front and back packets, as packets | |
164 // may enter out of order. | |
165 // TODO(mikhal): Refactor the list to use a map. | |
166 int first_packet_seq_num_; | |
167 int last_packet_seq_num_; | |
168 }; | |
169 | |
170 } // namespace webrtc | |
171 | |
172 #endif // WEBRTC_MODULES_VIDEO_CODING_MAIN_SOURCE_SESSION_INFO_H_ | |
OLD | NEW |