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_SESSION_INFO_H_ 12 #define WEBRTC_MODULES_VIDEO_CODING_SESSION_INFO_H_ 13 14 #include <list> 15 16 #include "webrtc/modules/include/module_common_types.h" 17 #include "webrtc/modules/video_coding/include/video_coding.h" 18 #include "webrtc/modules/video_coding/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; FrameType()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, PacketIterator packetIterator); 120 size_t Insert(const uint8_t* buffer, 121 size_t length, 122 bool insert_start_code, 123 uint8_t* frame_buffer); 124 void ShiftSubsequentPackets(PacketIterator it, int steps_to_shift); 125 PacketIterator FindNaluEnd(PacketIterator packet_iter) const; 126 // Deletes the data of all packets between |start| and |end|, inclusively. 127 // Note that this function doesn't delete the actual packets. 128 size_t DeletePacketData(PacketIterator start, PacketIterator end); 129 void UpdateCompleteSession(); 130 131 // When enabled, determine if session is decodable, i.e. incomplete but 132 // would be sent to the decoder. 133 // Note: definition assumes random loss. 134 // A frame is defined to be decodable when: 135 // Round trip time is higher than threshold 136 // It is not a key frame 137 // It has the first packet: In VP8 the first packet contains all or part of 138 // the first partition, which consists of the most relevant information for 139 // decoding. 140 // Either more than the upper threshold of the average number of packets per 141 // frame is present 142 // or less than the lower threshold of the average number of packets per 143 // frame is present: suggests a small frame. Such a frame is unlikely 144 // to contain many motion vectors, so having the first packet will 145 // likely suffice. Once we have more than the lower threshold of the 146 // frame, we know that the frame is medium or large-sized. 147 void UpdateDecodableSession(const FrameData& frame_data); 148 149 // If this session has been NACKed by the jitter buffer. 150 bool session_nack_; 151 bool complete_; 152 bool decodable_; 153 webrtc::FrameType frame_type_; 154 // Packets in this frame. 155 PacketList packets_; 156 int empty_seq_num_low_; 157 int empty_seq_num_high_; 158 159 // The following two variables correspond to the first and last media packets 160 // in a session defined by the first packet flag and the marker bit. 161 // They are not necessarily equal to the front and back packets, as packets 162 // may enter out of order. 163 // TODO(mikhal): Refactor the list to use a map. 164 int first_packet_seq_num_; 165 int last_packet_seq_num_; 166 }; 167 168 } // namespace webrtc 169 170 #endif // WEBRTC_MODULES_VIDEO_CODING_SESSION_INFO_H_ 171