H264 HW encode using VideoToolbox

media/base/mac/videotoolbox_helpers.h

 // Copyright 2016 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#ifndef IOS_CHROME_BROWSER_UI_WEBUI_HISTORY_METRICS_HANDLER_H_
-#define IOS_CHROME_BROWSER_UI_WEBUI_HISTORY_METRICS_HANDLER_H_
+#ifndef MEDIA_BASE_MAC_VIDEOTOOLBOX_HELPERS_H_
+#define MEDIA_BASE_MAC_VIDEOTOOLBOX_HELPERS_H_
 
-#include "base/compiler_specific.h"
-#include "base/macros.h"
-#include "ios/public/provider/web/web_ui_ios_message_handler.h"
+#include "base/mac/scoped_cftyperef.h"
+#include "media/base/mac/videotoolbox_glue.h"
+#include "media/base/media_export.h"
 
-///////////////////////////////////////////////////////////////////////////////
-// MetricsHandler
+namespace media {
 
-// Let the page contents record UMA actions. Only use when you can't do it from
-// C++. For example, we currently use it to let the NTP log the position of the
-// Most Visited or Bookmark the user clicked on, as we don't get that
-// information through RequestOpenURL. You will need to update the metrics
-// dashboard with the action names you use, as our processor won't catch that
-// information (treat it as RecordComputedMetrics)
+namespace video_toolbox {
 
-namespace base {
-class ListValue;
-}
+// Create a CFDictionaryRef with the given keys and values.
+MEDIA_EXPORT base::ScopedCFTypeRef<CFDictionaryRef>
+DictionaryWithKeysAndValues(CFTypeRef* keys, CFTypeRef* values, size_t size);
 
-class MetricsHandler : public web::WebUIIOSMessageHandler {
+// Create a CFDictionaryRef with the given key and value.
+MEDIA_EXPORT base::ScopedCFTypeRef<CFDictionaryRef> DictionaryWithKeyValue(
+    CFTypeRef key,
+    CFTypeRef value);
+
+// Create a CFArrayRef with the given array of integers.
+MEDIA_EXPORT base::ScopedCFTypeRef<CFArrayRef> ArrayWithIntegers(const int* v,
+                                                                 size_t size);
+
+// Copy a H.264 frame stored in a CM sample buffer to an Annex B buffer. Copies
+// parameter sets for keyframes before the frame data as well.
+MEDIA_EXPORT bool CopySampleBufferToAnnexBBuffer(

[miu, 2016/02/09 23:29:22]

For simplicity, you should delete the version of this function that takes a
std::string output.  Client code can just pre-allocate the string and truncate
it afterwards, like so:

  std::string annexb_buffer(kMaxAnnexBSize, '\0');
  size_t used_size = 0;
  CopySampleBufferToAnnex(sbuf,
                          reinterpret_cast<uint8_t*>(annexb_buffer.data()),
                          kMaxAnnexBSize,
                          keyframe,
                          &used_size);
  annexb_buffer.resize(used_size);

Then, you don't need that extra implementation in the .cc file to handle both
string and uint8_t* output buffer cases.

[emircan, 2016/02/10 05:21:53]

But wouldn't it be costly to do "std::string annexb_buffer(kMaxAnnexBSize,
'\0')" before each time? Also, I am not sure what to set a kMaxAnnexBSize in
cast code that is always big enough. We are expecting to lose some frames in
VTVEA when BitstreamBuffer size isn't big enough.

[miu, 2016/02/10 21:04:56]

In terms of run-time cost: No, because it's still just one allocation of a chunk
of memory.  In terms of space efficiency: It should be no less efficient than
what client code has to do to pre-allocate a chunk of memory for the raw pointer
version of this function.

Whoops, maybe not kMaxAnnexBSize for the size.  jfroy@, do you know?

[jfroy, 2016/02/10 23:15:34]

My personal opinion on this is that I would only deal with raw buffers (or a
suitable "buffer byte type") and use a stateful converter initialized with a
CMSampleBuffer to calculate the capacity on construction. That way, a client
would be able to allocate, reserve or check capacity as needed, obtain a
contiguous memory pointer as appropriate and convert.

The original implementation of this code used std::string because that's what
media/cast used. I consider std::string to be a terrible byte buffer type.

+    CoreMediaGlue::CMSampleBufferRef sbuf,
+    std::string* annexb_buffer,
+    bool keyframe);
+MEDIA_EXPORT bool CopySampleBufferToAnnexBBuffer(
+    CoreMediaGlue::CMSampleBufferRef sbuf,
+    uint8_t* annexb_buffer,

[miu, 2016/02/09 23:29:22]

style: output arguments go last

+    size_t annexb_buffer_size,
+    bool keyframe,
+    size_t* used_buffer_size);
+
+// Helper class to add session properties to a VTCompressionSessionRef.
+class MEDIA_EXPORT SessionPropertySetter {
  public:
-  MetricsHandler();
-  ~MetricsHandler() override;
+  SessionPropertySetter(
+      base::ScopedCFTypeRef<VideoToolboxGlue::VTCompressionSessionRef> session,
+      const VideoToolboxGlue* const glue);
+  ~SessionPropertySetter();
 
-  // WebUIIOSMessageHandler implementation.
-  void RegisterMessages() override;
-
-  // Callback for the "metricsHandler:recordAction" message. This records a
-  // user action.
-  void HandleRecordAction(const base::ListValue* args);
-
-  // TODO(dbeam): http://crbug.com/104338
-
-  // Callback for the "metricsHandler:recordInHistogram" message. This records
-  // into a histogram. |args| contains the histogram name, the value to record,
-  // and the maximum allowed value, which can be at most 4000. The histogram
-  // will use at most 100 buckets, one for each 1, 10, or 100 different values,
-  // depending on the maximum value.
-  void HandleRecordInHistogram(const base::ListValue* args);
+  bool SetSessionProperty(CFStringRef key, int32_t value);
+  bool SetSessionProperty(CFStringRef key, bool value);
+  bool SetSessionProperty(CFStringRef key, CFStringRef value);
 
  private:
-  DISALLOW_COPY_AND_ASSIGN(MetricsHandler);
+  const base::ScopedCFTypeRef<VideoToolboxGlue::VTCompressionSessionRef>
+      session_;
+  const VideoToolboxGlue* const glue_;
 };
 
-#endif  // IOS_CHROME_BROWSER_UI_WEBUI_HISTORY_METRICS_HANDLER_H_
+}  // namespace video_toolbox
+
+}  // namespace media
+
+#endif  // MEDIA_BASE_MAC_VIDEOTOOLBOX_HELPERS_H_