V4L2VideoDecodeAccelerator: implement flush by VIDIOC_DECODER_CMD.

media/gpu/v4l2_video_decode_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.
 //
 // This file contains an implementation of VideoDecodeAccelerator
 // that utilizes hardware video decoders, which expose Video4Linux 2 API
 // (http://linuxtv.org/downloads/v4l-dvb-apis/).
 
 #ifndef MEDIA_GPU_V4L2_VIDEO_DECODE_ACCELERATOR_H_
 #define MEDIA_GPU_V4L2_VIDEO_DECODE_ACCELERATOR_H_
@@ skipping 272 matching lines @@
                               std::unique_ptr<EGLSyncKHRRef> egl_sync_ref);
 
   // Flush() task.  Child thread should not submit any more buffers until it
   // receives the NotifyFlushDone callback.  This task will schedule an empty
   // BitstreamBufferRef (with input_id == kFlushBufferId) to perform the flush.
   void FlushTask();
   // Notify the client of a flush completion, if required.  This should be
   // called any time a relevant queue could potentially be emptied: see
   // function definition.
   void NotifyFlushDoneIfNeeded();
+  // Returns true if VIDIOC_DECODER_CMD is supported.
+  bool IsDecoderCmdSupported();
+  // Send V4L2_DEC_CMD_START to the driver. Return true if success.
+  bool SendDecoderCmdStop();
 
   // Reset() task.  Drop all input buffers. If V4L2VDA is not doing resolution
   // change or waiting picture buffers, call FinishReset.
   void ResetTask();
   // This will schedule a ResetDoneTask() that will send the NotifyResetDone
   // callback, then set the decoder state to kResetting so that all intervening
   // tasks will drain.
   void FinishReset();
   void ResetDoneTask();
 
@@ skipping 139 matching lines @@
   // delay these buffers until after the flush or reset completes.
   int decoder_delay_bitstream_buffer_id_;
   // Input buffer we're presently filling.
   int decoder_current_input_buffer_;
   // We track the number of buffer decode tasks we have scheduled, since each
   // task execution should complete one buffer.  If we fall behind (due to
   // resource backpressure, etc.), we'll have to schedule more to catch up.
   int decoder_decode_buffer_tasks_scheduled_;
   // Picture buffers held by the client.
   int decoder_frames_at_client_;
+
   // Are we flushing?
   bool decoder_flushing_;
+  // True if VIDIOC_DECODER_CMD is supported.
+  bool decoder_cmd_supported_;
+  // True if flushing is waiting for last output buffer. After
+  // VIDIOC_DECODER_CMD is sent to the driver, this flag will be set to true to
+  // wait for the last output buffer. When this flag is true, flush done will
+  // not be sent. After an output buffer that has the flag V4L2_BUF_FLAG_LAST is
+  // received, this is set to false.
+  bool flush_awaiting_last_output_buffer_;
+
   // Got a reset request while we were performing resolution change or waiting
   // picture buffers.
   bool reset_pending_;
   // Input queue for decoder_thread_: BitstreamBuffers in.
   std::queue<linked_ptr<BitstreamBufferRef>> decoder_input_queue_;
   // For H264 decode, hardware requires that we send it frame-sized chunks.
   // We'll need to parse the stream.
   std::unique_ptr<H264Parser> decoder_h264_parser_;
   // Set if the decoder has a pending incomplete frame in an input buffer.
   bool decoder_partial_frame_pending_;
@@ skipping 94 matching lines @@
 
   // The WeakPtrFactory for |weak_this_|.
   base::WeakPtrFactory<V4L2VideoDecodeAccelerator> weak_this_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(V4L2VideoDecodeAccelerator);
 };
 
 }  // namespace media
 
 #endif  // MEDIA_GPU_V4L2_VIDEO_DECODE_ACCELERATOR_H_