Integration of VP9 packetization.

webrtc/modules/video_coding/main/source/jitter_buffer.cc

 /*
  *  Copyright (c) 2012 The WebRTC project authors. All Rights Reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 #include "webrtc/modules/video_coding/main/source/jitter_buffer.h"
@@ skipping 107 matching lines @@
     : clock_(clock),
       running_(false),
       crit_sect_(CriticalSectionWrapper::CreateCriticalSection()),
       frame_event_(event.Pass()),
       max_number_of_frames_(kStartNumberOfFrames),
       free_frames_(),
       decodable_frames_(),
       incomplete_frames_(),
       last_decoded_state_(),
       first_packet_since_reset_(true),
+      last_gof_timestamp_(0),
+      last_gof_valid_(false),
       stats_callback_(NULL),
       incoming_frame_rate_(0),
       incoming_frame_count_(0),
       time_last_incoming_frame_count_(0),
       incoming_bit_count_(0),
       incoming_bit_rate_(0),
       num_consecutive_old_packets_(0),
       num_packets_(0),
       num_duplicated_packets_(0),
       num_discarded_packets_(0),
@@ skipping 75 matching lines @@
   num_discarded_packets_ = 0;
   time_first_packet_ms_ = 0;
 
   // Start in a non-signaled state.
   waiting_for_completion_.frame_size = 0;
   waiting_for_completion_.timestamp = 0;
   waiting_for_completion_.latest_packet_time = -1;
   first_packet_since_reset_ = true;
   rtt_ms_ = kDefaultRtt;
   last_decoded_state_.Reset();
+  last_gof_valid_ = false;
 }
 
 void VCMJitterBuffer::Stop() {
   crit_sect_->Enter();
   UpdateHistograms();
   running_ = false;
   last_decoded_state_.Reset();
+  last_gof_valid_ = false;
+
   // Make sure all frames are free and reset.
   for (FrameList::iterator it = decodable_frames_.begin();
        it != decodable_frames_.end(); ++it) {
     free_frames_.push_back(it->second);
   }
   for (FrameList::iterator it = incomplete_frames_.begin();
        it != incomplete_frames_.end(); ++it) {
     free_frames_.push_back(it->second);
   }
   for (UnorderedFrameList::iterator it = free_frames_.begin();
@@ skipping 10 matching lines @@
 bool VCMJitterBuffer::Running() const {
   CriticalSectionScoped cs(crit_sect_);
   return running_;
 }
 
 void VCMJitterBuffer::Flush() {
   CriticalSectionScoped cs(crit_sect_);
   decodable_frames_.Reset(&free_frames_);
   incomplete_frames_.Reset(&free_frames_);
   last_decoded_state_.Reset();  // TODO(mikhal): sync reset.
+  last_gof_valid_ = false;
   num_consecutive_old_packets_ = 0;
   // Also reset the jitter and delay estimates
   jitter_estimate_.Reset();
   inter_frame_delay_.Reset(clock_->TimeInMilliseconds());
   waiting_for_completion_.frame_size = 0;
   waiting_for_completion_.timestamp = 0;
   waiting_for_completion_.latest_packet_time = -1;
   first_packet_since_reset_ = true;
   missing_sequence_numbers_.clear();
 }
@@ skipping 344 matching lines @@
     } else if (waiting_for_completion_.latest_packet_time >= 0 &&
                waiting_for_completion_.latest_packet_time + 2000 <= now_ms) {
       // A packet should never be more than two seconds late
       UpdateJitterEstimate(waiting_for_completion_, true);
       waiting_for_completion_.latest_packet_time = -1;
       waiting_for_completion_.frame_size = 0;
       waiting_for_completion_.timestamp = 0;
     }
   }
 
+  if (packet.codec == kVideoCodecVP9) {
+    // TODO(asapersson): Move this code?
+    if (packet.codecSpecificHeader.codecHeader.VP9.ssDataAvailable) {
+      if (first_packet_since_reset_ ||
+          IsNewerTimestamp(packet.timestamp, last_gof_timestamp_)) {
+        last_gof_.CopyGofInfoVP9(
+            packet.codecSpecificHeader.codecHeader.VP9.gof);

[stefan-webrtc, 2015/07/09 14:49:00]

This gof info is necessary to know if a frame is decodable or not, so therefore
I think it should be stored in decoding_state.h, and should be necessary to use
by that class to figure out decodability.

Right now I don't think this code will be able to continue decoding if it loses
a packet in TL1 if it only has two layers, right? Or maybe GOF is only needed
for handling spatial layers and packet loss?

[åsapersson, 2015/07/29 12:10:13]

Decoding state looks at frame's TL, etc. Shouldn't the frame be updated with
correct values before inserted to frame buffer? Added a comment that this code
should be moved.

+        last_gof_timestamp_ = packet.timestamp;
+        last_gof_valid_ = true;
+      }
+    }
+    if (last_gof_valid_ &&
+        !packet.codecSpecificHeader.codecHeader.VP9.flexibleMode) {
+      uint8_t gof_idx = packet.codecSpecificHeader.codecHeader.VP9.gofIdx;
+      if (gof_idx != kNoGofIdx) {
+        if (gof_idx >= last_gof_.numFramesInGof) {
+          return kGeneralError;
+        }
+        RTPVideoTypeHeader* hdr = const_cast<RTPVideoTypeHeader*>(
+            &packet.codecSpecificHeader.codecHeader);
+        hdr->VP9.temporalIdx = last_gof_.temporalIdx[gof_idx];
+        hdr->VP9.temporalUpSwitch = last_gof_.temporalUpSwitch[gof_idx];
+      }
+    }
+    // TODO(asapersson): Handle out of order GOF.
+  }
+
   VCMFrameBufferStateEnum previous_state = frame->GetState();
   // Insert packet.
   FrameData frame_data;
   frame_data.rtt_ms = rtt_ms_;
   frame_data.rolling_average_packets_per_frame = average_packets_per_frame_;
   VCMFrameBufferEnum buffer_state =
       frame->InsertPacket(packet, now_ms, decode_error_mode_, frame_data);
 
   if (previous_state != kStateComplete) {
     TRACE_EVENT_ASYNC_BEGIN1("webrtc", "Video", frame->TimeStamp(),
@@ skipping 581 matching lines @@
   }
   // Evaluate if the RTT is higher than |high_rtt_nack_threshold_ms_|, and in
   // that case we don't wait for retransmissions.
   if (high_rtt_nack_threshold_ms_ >= 0 &&
       rtt_ms_ >= high_rtt_nack_threshold_ms_) {
     return false;
   }
   return true;
 }
 }  // namespace webrtc