media/gpu/v4l2vd: manage bitstream ids in a dedicated class

In the V4L2SVD, the allocation of bitstream ids was performed in the
client thread by a method and member counter. Move this into a
dedicated internal class that keeps things localized and ensures
thread-safety. This also makes it easier to split the stateless part of
the V4L2SVD into a separate backend.

Bug: 1003223
Test: video_decode_accelerator_tests passing on Kevin.

Change-Id: I507dc48ac3d2b016e569b6c8d288fe6e7bced78e
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/1840033
Commit-Queue: Alexandre Courbot <acourbot@chromium.org>
Auto-Submit: Alexandre Courbot <acourbot@chromium.org>
Reviewed-by: Hirokazu Honda <hiroh@chromium.org>
Cr-Commit-Position: refs/heads/master@{#703207}

media/gpu/v4l2/v4l2_slice_video_decoder.cc

@@ -631,24 +631,29 @@ void V4L2SliceVideoDecoder::Decode(scoped_refptr<DecoderBuffer> buffer,
   decoder_task_runner_->PostTask(
       FROM_HERE,
       base::BindOnce(&V4L2SliceVideoDecoder::EnqueueDecodeTask, weak_this_,
-                     DecodeRequest(std::move(buffer), std::move(decode_cb),
-                                   GetNextBitstreamId())));
+                     std::move(buffer), std::move(decode_cb)));
 }
 
-void V4L2SliceVideoDecoder::EnqueueDecodeTask(DecodeRequest request) {
+void V4L2SliceVideoDecoder::EnqueueDecodeTask(
+    scoped_refptr<DecoderBuffer> buffer,
+    V4L2SliceVideoDecoder::DecodeCB decode_cb) {
   DCHECK_CALLED_ON_VALID_SEQUENCE(decoder_sequence_checker_);
   DCHECK_NE(state_, State::kUninitialized);
 
   if (state_ == State::kError) {
-    std::move(request.decode_cb).Run(DecodeStatus::DECODE_ERROR);
+    std::move(decode_cb).Run(DecodeStatus::DECODE_ERROR);
     return;
   }
 
-  if (!request.buffer->end_of_stream()) {
-    bitstream_id_to_timestamp_.Put(request.bitstream_id,
-                                   request.buffer->timestamp());
+  const int32_t bitstream_id = bitstream_id_generator_.GetNextBitstreamId();
+
+  if (!buffer->end_of_stream()) {
+    bitstream_id_to_timestamp_.Put(bitstream_id, buffer->timestamp());
   }
-  decode_request_queue_.push(std::move(request));
+
+  decode_request_queue_.push(
+      DecodeRequest(std::move(buffer), std::move(decode_cb), bitstream_id));
+
   // If we are already decoding, then we don't need to pump again.
   if (!current_decode_request_)
     PumpDecodeTask();
@@ -1082,13 +1087,6 @@ void V4L2SliceVideoDecoder::ServiceDeviceTask(bool /* event */) {
   }
 }
 
-int32_t V4L2SliceVideoDecoder::GetNextBitstreamId() {
-  DCHECK_CALLED_ON_VALID_SEQUENCE(client_sequence_checker_);
-
-  next_bitstream_buffer_id_ = (next_bitstream_buffer_id_ + 1) & 0x7FFFFFFF;
-  return next_bitstream_buffer_id_;
-}
-
 void V4L2SliceVideoDecoder::RunDecodeCB(DecodeCB cb, DecodeStatus status) {
   DCHECK_CALLED_ON_VALID_SEQUENCE(decoder_sequence_checker_);
 

media/gpu/v4l2/v4l2_slice_video_decoder.h

@@ -140,6 +140,20 @@ class MEDIA_GPU_EXPORT V4L2SliceVideoDecoder : public VideoDecoder,
     kWaitSubFrameDecoded,
   };
 
+  class BitstreamIdGenerator {
+   public:
+    BitstreamIdGenerator() { DETACH_FROM_SEQUENCE(sequence_checker_); }
+    int32_t GetNextBitstreamId() {
+      DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
+      next_bitstream_buffer_id_ = (next_bitstream_buffer_id_ + 1) & 0x7FFFFFFF;
+      return next_bitstream_buffer_id_;
+    }
+
+   private:
+    int32_t next_bitstream_buffer_id_ = 0;
+    SEQUENCE_CHECKER(sequence_checker_);
+  };
+
   // Initialize on decoder thread.
   void InitializeTask(const VideoDecoderConfig& config,
                       InitCB init_cb,
@@ -173,7 +187,8 @@ class MEDIA_GPU_EXPORT V4L2SliceVideoDecoder : public VideoDecoder,
 
   // Enqueue |request| to the pending decode request queue, and try to decode
   // from the queue.
-  void EnqueueDecodeTask(DecodeRequest request);
+  void EnqueueDecodeTask(scoped_refptr<DecoderBuffer> buffer,
+                         V4L2SliceVideoDecoder::DecodeCB decode_cb);
   // Try to decode buffer from the pending decode request queue.
   // This method stops decoding when:
   // - Run out of surface
@@ -199,8 +214,6 @@ class MEDIA_GPU_EXPORT V4L2SliceVideoDecoder : public VideoDecoder,
   // Try to dequeue input and output buffers from device.
   void ServiceDeviceTask(bool event);
 
-  // Get the next bitsream ID.
-  int32_t GetNextBitstreamId();
   // Convert the frame and call the output callback.
   void RunOutputCB(scoped_refptr<VideoFrame> frame,
                    const gfx::Rect& visible_rect,
@@ -267,8 +280,8 @@ class MEDIA_GPU_EXPORT V4L2SliceVideoDecoder : public VideoDecoder,
 
   // True if the decoder needs bitstream conversion before decoding.
   bool needs_bitstream_conversion_ = false;
-  // Next bitstream ID.
-  int32_t next_bitstream_buffer_id_ = 0;
+
+  BitstreamIdGenerator bitstream_id_generator_;
 
   // Set to true by CreateInputBuffers() if the codec driver supports requests.
   bool supports_requests_ = false;