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 83 matching lines @@
   // 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();
+  void ServiceDeviceTask(bool event_pending);
   // Handle the various device queues.
   void EnqueueMfc();
   void DequeueMfc();
   void EnqueueGsc();
   void DequeueGsc();
+  void DequeueEvents();
   // 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();
+  // |keep_mfc_input| if true, don't reset MFC input state, used during
+  // resolution change.
+  bool StopDevicePoll(bool keep_mfc_input);
   // Set/clear the device poll interrupt (using device_poll_interrupt_fd_).
   bool SetDevicePollInterrupt();
   bool ClearDevicePollInterrupt();
 
+  void StartResolutionChangeIfNeeded();
+  bool GetFormatInfo(struct v4l2_format* format, bool* again);
+  void ResolutionChangeDestroyBuffers();

[sheu, 2013/08/09 10:41:49]

If you're not removing this just yet it would be nice to call it
XXXOnChildThread or something similarly obvious

[Pawel Osciak, 2013/08/09 11:42:36]

Done.

+  void FinishResolutionChangeTask();
+  void ResumeAfterResolutionChangeTask();
+
   //
   // Device tasks, to be run on device_poll_thread_.
   //
 
   // The device task.
   void DevicePollTask(unsigned int poll_fds);
 
   //
   // Safe from any thread.
   //
 
   // Error notification (using PostTask() to child thread, if necessary).
   void NotifyError(Error error);
 
   // Set the decoder_thread_ state (using PostTask to decoder thread, if
   // necessary).
   void SetDecoderState(State state);
 
   //
   // Other utility functions.  Called on decoder_thread_, unless
   // 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 CreateBuffersForFormat(const struct v4l2_format& format);

[sheu, 2013/08/09 10:41:49]

Also: I kept the function definitions and declarations in the same order.  Style
guide seems to have a preference for it, though you may not personally be as
OCD.

[Pawel Osciak, 2013/08/09 11:42:36]

Done.

   bool CreateMfcInputBuffers();
   bool CreateMfcOutputBuffers();
   bool CreateGscInputBuffers();
   bool CreateGscOutputBuffers();
 
   // Destroy these buffers.
   void DestroyMfcInputBuffers();
   void DestroyMfcOutputBuffers();
   void DestroyGscInputBuffers();
   void DestroyGscOutputBuffers();
@@ skipping 36 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_;
   // 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_