Check H264 NALUs for frametype and insert SPS/PPS packets into the PacketBuffer.

webrtc/modules/video_coding/frame_object.cc

 /*
  *  Copyright (c) 2016 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/base/checks.h"
+#include "webrtc/common_video/h264/h264_common.h"
 #include "webrtc/modules/video_coding/frame_object.h"
 #include "webrtc/modules/video_coding/packet_buffer.h"
 
 namespace webrtc {
 namespace video_coding {
 
 FrameObject::FrameObject()
     : picture_id(0),
       spatial_layer(0),
       timestamp(0),
@@ skipping 36 matching lines @@
   // NOTE! EncodedImage::_size is the size of the buffer (think capacity of
   //       an std::vector) and EncodedImage::_length is the actual size of
   //       the bitstream (think size of an std::vector).
   if (codec_type_ == kVideoCodecH264)
     _size = frame_size + EncodedImage::kBufferPaddingBytesH264;
   else
     _size = frame_size;
 
   _buffer = new uint8_t[_size];
   _length = frame_size;
-  _frameType = first_packet->frameType;
+
+  // For H264 frames we can't determine the frame type by just looking at the
+  // first packet. Instead we consider the frame to be a keyframe if it
+  // contains an IDR NALU.
+  if (codec_type_ == kVideoCodecH264) {
+    _frameType = kVideoFrameDelta;
+    frame_type_ = kVideoFrameDelta;
+    for (uint16_t seq_num = first_seq_num;
+         seq_num != last_seq_num + 1 && _frameType == kVideoFrameDelta;
+         ++seq_num) {
+      VCMPacket* packet = packet_buffer_->GetPacket(seq_num);
+      RTC_DCHECK(packet);
+      const RTPVideoHeaderH264& header = packet->video_header.codecHeader.H264;
+      for (size_t i = 0; i < header.nalus_length; ++i) {
+        if (header.nalus[i].type == H264::NaluType::kIdr) {
+          _frameType = kVideoFrameKey;
+          frame_type_ = kVideoFrameKey;
+          break;
+        }
+      }
+    }
+  } else {
+    _frameType = first_packet->frameType;
+    frame_type_ = first_packet->frameType;
+  }
+
   GetBitstream(_buffer);
   _encodedWidth = first_packet->width;
   _encodedHeight = first_packet->height;
 
   // FrameObject members
   timestamp = first_packet->timestamp;
 
   VCMPacket* last_packet = packet_buffer_->GetPacket(last_seq_num);
   RTC_DCHECK(last_packet && last_packet->markerBit);
   // http://www.etsi.org/deliver/etsi_ts/126100_126199/126114/12.07.00_60/
@@ skipping 53 matching lines @@
 rtc::Optional<RTPVideoTypeHeader> RtpFrameObject::GetCodecHeader() const {
   rtc::CritScope lock(&packet_buffer_->crit_);
   VCMPacket* packet = packet_buffer_->GetPacket(first_seq_num_);
   if (!packet)
     return rtc::Optional<RTPVideoTypeHeader>();
   return rtc::Optional<RTPVideoTypeHeader>(packet->video_header.codecHeader);
 }
 
 }  // namespace video_coding
 }  // namespace webrtc