V4L2VEA: Improve H264 stream header handling.

media/gpu/v4l2_video_encode_accelerator.h

 // Copyright 2014 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 MEDIA_GPU_V4L2_VIDEO_ENCODE_ACCELERATOR_H_
 #define MEDIA_GPU_V4L2_VIDEO_ENCODE_ACCELERATOR_H_
 
 #include <linux/videodev2.h>
 #include <stddef.h>
 #include <stdint.h>
 
-#include <list>
 #include <memory>
+#include <queue>
 #include <vector>
 
 #include "base/files/scoped_file.h"
 #include "base/macros.h"
-#include "base/memory/linked_ptr.h"
 #include "base/memory/weak_ptr.h"
 #include "base/threading/thread.h"
 #include "base/time/time.h"
 #include "media/gpu/media_gpu_export.h"
 #include "media/gpu/v4l2_device.h"
 #include "media/gpu/v4l2_image_processor.h"
 #include "media/video/video_encode_accelerator.h"
 #include "ui/gfx/geometry/size.h"
 
 namespace media {
@@ skipping 42 matching lines @@
     ~InputRecord();
     bool at_device;
     scoped_refptr<VideoFrame> frame;
   };
 
   // Record for output buffers.
   struct OutputRecord {
     OutputRecord();
     ~OutputRecord();
     bool at_device;
-    linked_ptr<BitstreamBufferRef> buffer_ref;
+    std::unique_ptr<BitstreamBufferRef> buffer_ref;
     void* address;
     size_t length;
   };
 
   struct ImageProcessorInputRecord {
     ImageProcessorInputRecord();
     ~ImageProcessorInputRecord();
     scoped_refptr<VideoFrame> frame;
     bool force_keyframe;
   };
@@ skipping 102 matching lines @@
   bool CreateInputBuffers();
   bool CreateOutputBuffers();
 
   // Destroy these buffers.
   void DestroyInputBuffers();
   void DestroyOutputBuffers();
 
   // Set controls in |ctrls| and return true if successful.
   bool SetExtCtrls(std::vector<struct v4l2_ext_control> ctrls);
 
+  // Return true if a V4L2 control of |ctrl_id| is supported by the device,
+  // false otherwise.
+  bool IsCtrlExposed(uint32_t ctrl_id);
+
   // Recycle output buffer of image processor with |output_buffer_index|.
   void ReuseImageProcessorOutputBuffer(int output_buffer_index);
 
+  // Copy encoded stream data from an output V4L2 buffer at |bitstream_data|
+  // of size |bitstream_size| into a BitstreamBuffer referenced by |buffer_ref|,
+  // injecting stream headers if required. Return the size in bytes of the
+  // resulting stream in the destination buffer.
+  size_t CopyIntoOutputBuffer(const uint8_t* bitstream_data,
+                              size_t bitstream_size,
+                              std::unique_ptr<BitstreamBufferRef> buffer_ref);
+
   // Our original calling task runner for the child thread.
   const scoped_refptr<base::SingleThreadTaskRunner> child_task_runner_;
 
   gfx::Size visible_size_;
   // Input allocated size required by the device.
   gfx::Size input_allocated_size_;
   size_t output_buffer_byte_size_;
 
   // Formats for input frames and the output stream.
   VideoPixelFormat device_input_format_;
   size_t input_planes_count_;
   uint32_t output_format_fourcc_;
 
   //
   // Encoder state, owned and operated by encoder_thread_.
   // Before encoder_thread_ has started, the encoder state is managed by
   // the child (main) thread.  After encoder_thread_ has started, the encoder
   // thread should be the only one managing these.
   //
 
   // Encoder state.
   State encoder_state_;
 
-  // We need to provide the stream header with every keyframe, to allow
-  // midstream decoding restarts.  Store it here.
-  std::unique_ptr<uint8_t[]> stream_header_;
-  size_t stream_header_size_;
+  // For H264, for resilience, we prepend each IDR with SPS and PPS. Some
+  // devices support this via the V4L2_CID_MPEG_VIDEO_H264_SPS_PPS_BEFORE_IDR
+  // control. For devices that don't, we cache the latest SPS and PPS and inject
+  // them into the stream before every IDR.
+  bool inject_sps_and_pps_ = false;
+  // Cached SPS (without H.264 start code).
+  std::vector<uint8_t> cached_sps_;
+  // Cached PPS (without H.264 start code).
+  std::vector<uint8_t> cached_pps_;
+  // Size in bytes required to inject cached SPS and PPS, including H.264
+  // start codes.
+  size_t cached_h264_header_size_ = 0;
 
   // Video frames ready to be encoded.
   std::queue<scoped_refptr<VideoFrame>> encoder_input_queue_;
 
   // Encoder device.
   scoped_refptr<V4L2Device> device_;
 
   // Input queue state.
   bool input_streamon_;
   // Input buffers enqueued to device.
   int input_buffer_queued_count_;
   // Input buffers ready to use; LIFO since we don't care about ordering.
   std::vector<int> free_input_buffers_;
   // Mapping of int index to input buffer record.
   std::vector<InputRecord> input_buffer_map_;
   v4l2_memory input_memory_type_;
 
   // Output queue state.
   bool output_streamon_;
   // Output buffers enqueued to device.
   int output_buffer_queued_count_;
   // Output buffers ready to use; LIFO since we don't care about ordering.
   std::vector<int> free_output_buffers_;
   // Mapping of int index to output buffer record.
   std::vector<OutputRecord> output_buffer_map_;
 
   // Bitstream buffers ready to be used to return encoded output, as a LIFO
   // since we don't care about ordering.
-  std::vector<linked_ptr<BitstreamBufferRef>> encoder_output_queue_;
+  std::vector<std::unique_ptr<BitstreamBufferRef>> encoder_output_queue_;
 
   // Image processor, if one is in use.
   std::unique_ptr<V4L2ImageProcessor> image_processor_;
   // Indexes of free image processor output buffers. Only accessed on child
   // thread.
   std::vector<int> free_image_processor_output_buffers_;
   // Video frames ready to be processed. Only accessed on child thread.
   std::queue<ImageProcessorInputRecord> image_processor_input_queue_;
   // Mapping of int index to fds of image processor output buffer.
   std::vector<std::vector<base::ScopedFD>> image_processor_output_buffer_map_;
@@ skipping 18 matching lines @@
   // as both threads will not outlive this object.
   base::WeakPtr<V4L2VideoEncodeAccelerator> weak_this_;
   base::WeakPtrFactory<V4L2VideoEncodeAccelerator> weak_this_ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(V4L2VideoEncodeAccelerator);
 };
 
 }  // namespace media
 
 #endif  // MEDIA_GPU_V4L2_VIDEO_ENCODE_ACCELERATOR_H_