Fix VideoToolbox backgrounding issues

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.
  *
  */
@@ skipping 143 matching lines @@
   CFRelease(contiguous_buffer);
   return true;
 }
 
 bool H264AnnexBBufferToCMSampleBuffer(const uint8_t* annexb_buffer,
                                       size_t annexb_buffer_size,
                                       CMVideoFormatDescriptionRef video_format,
                                       CMSampleBufferRef* out_sample_buffer) {
   RTC_DCHECK(annexb_buffer);
   RTC_DCHECK(out_sample_buffer);
+  RTC_DCHECK(video_format);
   *out_sample_buffer = nullptr;
 
-  // 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;
-
   AnnexBBufferReader reader(annexb_buffer, annexb_buffer_size);
-  CMVideoFormatDescriptionRef description = nullptr;
-  OSStatus status = noErr;
-  if (is_first_nalu_type_sps) {
-    // Parse the SPS and PPS into a CMVideoFormatDescription.
-    const uint8_t* param_set_ptrs[2] = {};
-    size_t param_set_sizes[2] = {};
-    if (!reader.ReadNalu(&param_set_ptrs[0], &param_set_sizes[0])) {
+  if (H264AnnexBBufferHasVideoFormatDescription(annexb_buffer,
+                                                annexb_buffer_size)) {
+    // Advance past the SPS and PPS.
+    const uint8_t* data = nullptr;
+    size_t data_len = 0;
+    if (!reader.ReadNalu(&data, &data_len)) {
       LOG(LS_ERROR) << "Failed to read SPS";
       return false;
     }
-    if (!reader.ReadNalu(&param_set_ptrs[1], &param_set_sizes[1])) {
+    if (!reader.ReadNalu(&data, &data_len)) {
       LOG(LS_ERROR) << "Failed to read PPS";
       return false;
     }
-    status = CMVideoFormatDescriptionCreateFromH264ParameterSets(
-        kCFAllocatorDefault, 2, param_set_ptrs, param_set_sizes, 4,
-        &description);
-    if (status != noErr) {
-      LOG(LS_ERROR) << "Failed to create video format description.";
-      return false;
-    }
-  } else {
-    RTC_DCHECK(video_format);
-    description = video_format;
-    // We don't need to retain, but it makes logic easier since we are creating
-    // in the other block.
-    CFRetain(description);
   }
 
   // Allocate memory as a block buffer.
   // TODO(tkchin): figure out how to use a pool.
   CMBlockBufferRef block_buffer = nullptr;
-  status = CMBlockBufferCreateWithMemoryBlock(
+  OSStatus status = CMBlockBufferCreateWithMemoryBlock(
       nullptr, nullptr, reader.BytesRemaining(), nullptr, nullptr, 0,
       reader.BytesRemaining(), kCMBlockBufferAssureMemoryNowFlag,
       &block_buffer);
   if (status != kCMBlockBufferNoErr) {
     LOG(LS_ERROR) << "Failed to create block buffer.";
-    CFRelease(description);
     return false;
   }
 
   // Make sure block buffer is contiguous.
   CMBlockBufferRef contiguous_buffer = nullptr;
   if (!CMBlockBufferIsRangeContiguous(block_buffer, 0, 0)) {
     status = CMBlockBufferCreateContiguous(
         nullptr, block_buffer, nullptr, nullptr, 0, 0, 0, &contiguous_buffer);
     if (status != noErr) {
       LOG(LS_ERROR) << "Failed to flatten non-contiguous block buffer: "
                     << status;
-      CFRelease(description);
       CFRelease(block_buffer);
       return false;
     }
   } else {
     contiguous_buffer = block_buffer;
     block_buffer = nullptr;
   }
 
   // Get a raw pointer into allocated memory.
   size_t block_buffer_size = 0;
   char* data_ptr = nullptr;
   status = CMBlockBufferGetDataPointer(contiguous_buffer, 0, nullptr,
                                        &block_buffer_size, &data_ptr);
   if (status != kCMBlockBufferNoErr) {
     LOG(LS_ERROR) << "Failed to get block buffer data pointer.";
-    CFRelease(description);
     CFRelease(contiguous_buffer);
     return false;
   }
   RTC_DCHECK(block_buffer_size == reader.BytesRemaining());
 
   // Write Avcc NALUs into block buffer memory.
   AvccBufferWriter writer(reinterpret_cast<uint8_t*>(data_ptr),
                           block_buffer_size);
   while (reader.BytesRemaining() > 0) {
     const uint8_t* nalu_data_ptr = nullptr;
     size_t nalu_data_size = 0;
     if (reader.ReadNalu(&nalu_data_ptr, &nalu_data_size)) {
       writer.WriteNalu(nalu_data_ptr, nalu_data_size);
     }
   }
 
   // Create sample buffer.
   status = CMSampleBufferCreate(nullptr, contiguous_buffer, true, nullptr,
-                                nullptr, description, 1, 0, nullptr, 0, nullptr,
-                                out_sample_buffer);
+                                nullptr, video_format, 1, 0, nullptr, 0,
+                                nullptr, out_sample_buffer);
   if (status != noErr) {
     LOG(LS_ERROR) << "Failed to create sample buffer.";
-    CFRelease(description);
     CFRelease(contiguous_buffer);
     return false;
   }
-  CFRelease(description);
   CFRelease(contiguous_buffer);
   return true;
 }
 
+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;
+}
+
+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] = {};
+  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,
+      &description);
+  if (status != noErr) {
+    LOG(LS_ERROR) << "Failed to create video format description.";
+    return nullptr;
+  }
+  return description;
+}
+
 AnnexBBufferReader::AnnexBBufferReader(const uint8_t* annexb_buffer,
                                        size_t length)
     : start_(annexb_buffer), offset_(0), next_offset_(0), length_(length) {
   RTC_DCHECK(annexb_buffer);
   offset_ = FindNextNaluHeader(start_, length_, 0);
   next_offset_ =
       FindNextNaluHeader(start_, length_, offset_ + sizeof(kAnnexBHeaderBytes));
 }
 
 bool AnnexBBufferReader::ReadNalu(const uint8_t** out_nalu,
@@ skipping 65 matching lines @@
   return true;
 }
 
 size_t AvccBufferWriter::BytesRemaining() const {
   return length_ - offset_;
 }
 
 }  // namespace webrtc
 
 #endif  // defined(WEBRTC_VIDEO_TOOLBOX_SUPPORTED)