EVDA: Add support for dynamic resolution change and MSE players.

content/common/gpu/media/exynos_video_decode_accelerator.h

 // Copyright (c) 2012 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 VideoDecoderAccelerator
 // that utilizes the hardware video decoder present on the Exynos SoC.
 
 #ifndef CONTENT_COMMON_GPU_MEDIA_EXYNOS_VIDEO_DECODE_ACCELERATOR_H_
 #define CONTENT_COMMON_GPU_MEDIA_EXYNOS_VIDEO_DECODE_ACCELERATOR_H_
 
@@ skipping 84 matching lines @@
     kDpbOutputBufferExtraCount = 3,
   };
 
   // Internal state of the decoder.
   enum State {
     kUninitialized,      // Initialize() not yet called.
     kInitialized,        // Initialize() returned true; ready to start decoding.
     kDecoding,           // DecodeBufferInitial() successful; decoding frames.
     kResetting,          // Presently resetting.
     kAfterReset,         // After Reset(), ready to start decoding again.
+    kChangingResolution, // Performing resolution change, all remaining
+                         // pre-change frames decoded and processed.
     kError,              // Error in kDecoding state.
   };
 
   enum BufferId {
     kFlushBufferId = -2  // Buffer id for flush buffer, queued by FlushTask().
   };
 
   // File descriptors we need to poll.
   enum PollFds {
     kPollMfc = (1 << 0),
@@ skipping 82 matching lines @@
   bool AppendToInputFrame(const void* data, size_t size);
   // Flush data for one decoded frame.
   bool FlushInputFrame();
 
   // Process an AssignPictureBuffers() API call.  After this, the
   // device_poll_thread_ can be started safely, since we have all our
   // buffers.
   void AssignPictureBuffersTask(scoped_ptr<PictureBufferArrayRef> pic_buffers);
 
   // Service I/O on the V4L2 devices.  This task should only be scheduled from
-  // DevicePollTask().
-  void ServiceDeviceTask();
+  // DevicePollTask().  If |mfc_event_pending| is true, one or more events
+  // on MFC file descriptor are pending.
+  void ServiceDeviceTask(bool mfc_event_pending);
   // Handle the various device queues.
   void EnqueueMfc();
   void DequeueMfc();
   void EnqueueGsc();
   void DequeueGsc();
+  // Handle incoming MFC events.
+  void DequeueMfcEvents();
   // Enqueue a buffer on the corresponding queue.
   bool EnqueueMfcInputRecord();
   bool EnqueueMfcOutputRecord();
   bool EnqueueGscInputRecord();
   bool EnqueueGscOutputRecord();
 
   // Process a ReusePictureBuffer() API call.  The API call create an EGLSync
   // object on the main (GPU process) thread; we will record this object so we
   // can wait on it before reusing the buffer.
   void ReusePictureBufferTask(int32 picture_buffer_id,
@@ skipping 14 matching lines @@
   void ResetTask();
   // ResetDoneTask() will set the decoder state back to kAfterReset, so
   // subsequent decoding can continue.
   void ResetDoneTask();
 
   // Device destruction task.
   void DestroyTask();
 
   // Attempt to start/stop device_poll_thread_.
   bool StartDevicePoll();
-  bool StopDevicePoll();
+  // If |keep_mfc_input_state| is true, don't reset MFC input state; used during
+  // resolution change.
+  bool StopDevicePoll(bool keep_mfc_input_state);
   // Set/clear the device poll interrupt (using device_poll_interrupt_fd_).
   bool SetDevicePollInterrupt();
   bool ClearDevicePollInterrupt();
 
+  void StartResolutionChangeIfNeeded();
+  void FinishResolutionChange();

[sheu, 2013/08/12 03:06:17]

I noted before that I'd like to see these moved to a child-thread section.  Now
that you have one an put it there, I don't think it should be a problem.

[Pawel Osciak, 2013/08/12 03:19:10]

These three are run on decoder thread. Only ResolutionChangeDestroyBuffers() is
run on child and I moved it to that section...

[sheu, 2013/08/12 04:49:20]

Sorry for the confusion -- I was replying to the old comments on the new CL to
keep the comments coming on this patch.  All ok now.

+  void ResumeAfterResolutionChange();
+
+  // Try to get output format from MFC, detected after parsing the beginning
+  // of the stream. Sets |again| to true if more parsing is needed.
+  bool GetFormatInfo(struct v4l2_format* format, bool* again);
+  // Create MFC output and GSC input and output buffers for the given |format|.
+  bool CreateBuffersForFormat(const struct v4l2_format& format);
+
   //
   // Device tasks, to be run on device_poll_thread_.
   //
 
   // The device task.
   void DevicePollTask(unsigned int poll_fds);
 
   //
   // Safe from any thread.
   //
@@ skipping 10 matching lines @@
   // decoder_thread_ is not yet started, in which case the child thread can call
   // these (e.g. in Initialize() or Destroy()).
   //
 
   // Create the buffers we need.
   bool CreateMfcInputBuffers();
   bool CreateMfcOutputBuffers();
   bool CreateGscInputBuffers();
   bool CreateGscOutputBuffers();
 
-  // Destroy these buffers.
+  //
+  // Methods run on child thread.
+  //
+
+  // Destroy buffers.
   void DestroyMfcInputBuffers();
   void DestroyMfcOutputBuffers();
   void DestroyGscInputBuffers();
   void DestroyGscOutputBuffers();
+  void ResolutionChangeDestroyBuffers();
 
   // Our original calling message loop for the child thread.
   scoped_refptr<base::MessageLoopProxy> child_message_loop_proxy_;
 
   // WeakPtr<> pointing to |this| for use in posting tasks from the decoder or
   // device worker threads back to the child thread.  Because the worker threads
   // are members of this class, any task running on those threads is guaranteed
   // that this object is still alive.  As a result, tasks posted from the child
   // thread to the decoder or device thread should use base::Unretained(this),
   // and tasks posted the other way should use |weak_this_|.
@@ skipping 26 matching lines @@
   // MFC 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_;
+  // Got a notification from driver that it reached resolution change point
+  // in the stream.
+  bool resolution_change_pending_;
+  // Got a reset request while we were performing resolution change.
+  bool resolution_change_reset_pending_;
   // Input queue for decoder_thread_: BitstreamBuffers in.
   std::list<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.
   scoped_ptr<content::H264Parser> decoder_h264_parser_;
   // Set if the decoder has a pending incomplete frame in an input buffer.
   bool decoder_partial_frame_pending_;
 
   //
   // Hardware state and associated queues.  Since decoder_thread_ services
@@ skipping 79 matching lines @@
 
   // The codec we'll be decoding for.
   media::VideoCodecProfile video_profile_;
 
   DISALLOW_COPY_AND_ASSIGN(ExynosVideoDecodeAccelerator);
 };
 
 }  // namespace content
 
 #endif  // CONTENT_COMMON_GPU_MEDIA_EXYNOS_VIDEO_DECODE_ACCELERATOR_H_