Skip AUD while extracting SPS and PPS on iOS.

webrtc/modules/video_coding/codecs/h264/h264_video_toolbox_nalu.cc

 /*
  *  Copyright (c) 2015 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/codecs/h264/h264_video_toolbox_nalu.h"
 
 #if defined(WEBRTC_VIDEO_TOOLBOX_SUPPORTED)
 
 #include <CoreFoundation/CoreFoundation.h>
 #include <memory>
 #include <vector>
 
 #include "webrtc/base/checks.h"
 #include "webrtc/base/logging.h"
+#include "webrtc/common_video/h264/h264_common.h"
 
 namespace webrtc {
 
+using H264::NaluType;
+using H264::kAud;
+using H264::kSps;
+using H264::ParseNaluType;
+
 const char kAnnexBHeaderBytes[4] = {0, 0, 0, 1};
 const size_t kAvccHeaderByteSize = sizeof(uint32_t);
 
 bool H264CMSampleBufferToAnnexBBuffer(
     CMSampleBufferRef avcc_sample_buffer,
     bool is_keyframe,
     rtc::Buffer* annexb_buffer,
     webrtc::RTPFragmentationHeader** out_header) {
   RTC_DCHECK(avcc_sample_buffer);
   RTC_DCHECK(out_header);
@@ skipping 211 matching lines @@
 
 bool H264AnnexBBufferHasVideoFormatDescription(const uint8_t* annexb_buffer,
                                                size_t annexb_buffer_size) {
   RTC_DCHECK(annexb_buffer);
   RTC_DCHECK_GT(annexb_buffer_size, 4u);
 
   // The buffer we receive via RTP has 00 00 00 01 start code artifically
   // embedded by the RTP depacketizer. Extract NALU information.
   // TODO(tkchin): handle potential case where sps and pps are delivered
   // separately.
-  uint8_t first_nalu_type = annexb_buffer[4] & 0x1f;
-  bool is_first_nalu_type_sps = first_nalu_type == 0x7;
-  return is_first_nalu_type_sps;
+  NaluType first_nalu_type = ParseNaluType(annexb_buffer[4]);
+  bool is_first_nalu_type_sps = first_nalu_type == kSps;
+  if (is_first_nalu_type_sps)
+    return true;
+  bool is_first_nalu_type_aud = first_nalu_type == kAud;
+  // Start code + access unit delimiter + start code = 4 + 2 + 4 = 10.
+  if (!is_first_nalu_type_aud || annexb_buffer_size <= 10u)
+    return false;
+  NaluType second_nalu_type = ParseNaluType(annexb_buffer[10]);
+  bool is_second_nalu_type_sps = second_nalu_type == kSps;
+  return is_second_nalu_type_sps;
 }
 
 CMVideoFormatDescriptionRef CreateVideoFormatDescription(
     const uint8_t* annexb_buffer,
     size_t annexb_buffer_size) {
   if (!H264AnnexBBufferHasVideoFormatDescription(annexb_buffer,
                                                  annexb_buffer_size)) {
     return nullptr;
   }
   AnnexBBufferReader reader(annexb_buffer, annexb_buffer_size);
   CMVideoFormatDescriptionRef description = nullptr;
   OSStatus status = noErr;
   // Parse the SPS and PPS into a CMVideoFormatDescription.
   const uint8_t* param_set_ptrs[2] = {};
   size_t param_set_sizes[2] = {};
+  // Skip AUD.
+  if (ParseNaluType(annexb_buffer[4]) == kAud) {
+    if (!reader.ReadNalu(&param_set_ptrs[0], &param_set_sizes[0])) {
+      LOG(LS_ERROR) << "Failed to read AUD";
+      return nullptr;
+    }
+  }
   if (!reader.ReadNalu(&param_set_ptrs[0], &param_set_sizes[0])) {
     LOG(LS_ERROR) << "Failed to read SPS";
     return nullptr;
   }
   if (!reader.ReadNalu(&param_set_ptrs[1], &param_set_sizes[1])) {
     LOG(LS_ERROR) << "Failed to read PPS";
     return nullptr;
   }
   status = CMVideoFormatDescriptionCreateFromH264ParameterSets(
       kCFAllocatorDefault, 2, param_set_ptrs, param_set_sizes, 4,
@@ skipping 83 matching lines @@
   return true;
 }
 
 size_t AvccBufferWriter::BytesRemaining() const {
   return length_ - offset_;
 }
 
 }  // namespace webrtc
 
 #endif  // defined(WEBRTC_VIDEO_TOOLBOX_SUPPORTED)