Add support for Tegra V4L2 VDA

content/common/gpu/media/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 CONTENT_COMMON_GPU_MEDIA_V4L2_VIDEO_DECODE_ACCELERATOR_H_
 #define CONTENT_COMMON_GPU_MEDIA_V4L2_VIDEO_DECODE_ACCELERATOR_H_
@@ skipping 137 matching lines @@
     off_t bytes_used;       // bytes filled in the mmap() segment.
     int32 input_id;         // triggering input_id as given to Decode().
   };
 
   // Record for output buffers.
   struct OutputRecord {
     OutputRecord();
     ~OutputRecord();
     bool at_device;         // held by device.
     bool at_client;         // held by client.
-    int fds[2];             // file descriptors for each plane.
     EGLImageKHR egl_image;  // EGLImageKHR for the output buffer.
     EGLSyncKHR egl_sync;    // sync the compositor's use of the EGLImage.
     int32 picture_id;       // picture buffer id as returned to PictureReady().
     bool cleared;           // Whether the texture is cleared and safe to render
                             // from. See TextureManager for details.
   };
 
   //
   // Decoding tasks, to be run on decode_thread_.
   //
@@ skipping 118 matching lines @@
   // caller can error out on resolution change.
   bool DestroyOutputBuffers();
   void ResolutionChangeDestroyBuffers();
 
   // Send decoded pictures to PictureReady.
   void SendPictureReady();
 
   // Callback that indicates a picture has been cleared.
   void PictureCleared();
 
+  // This method determines whether a resolution change event processing
+  // is indeed required by returning true iff:
+  // - width or height of the new format is different than previous format; or
+  // - V4L2_CID_MIN_BUFFERS_FOR_CAPTURE has changed.
+  bool IsResolutionChangeNecessary();
+
   // Our original calling message loop for the child thread.
   scoped_refptr<base::MessageLoopProxy> child_message_loop_proxy_;
 
   // Message loop of the IO thread.
   scoped_refptr<base::MessageLoopProxy> io_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
@@ skipping 50 matching lines @@
   // We'll need to parse the stream.
   scoped_ptr<media::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
   // the hardware, decoder_thread_ owns these too.
   // output_buffer_map_ and free_output_buffers_ are an exception during the
   // buffer (re)allocation sequence, when the decoder_thread_ is blocked briefly
   // while the Child thread manipulates them.

[Ami GONE FROM CHROMIUM, 2014/03/28 19:33:40]

This comment is talking about vars that are normally read/written on the decoder
thread but which are accessed on the child thread during known-safe times.  That
seems to match output_planes_count_ to me.

[shivdasp, 2014/03/28 20:39:26]

Done.

   //
 
   // Completed decode buffers.
   std::queue<int> input_ready_queue_;
 
   // Input buffer state.
   bool input_streamon_;
   // Input buffers enqueued to device.
   int input_buffer_queued_count_;
   // Input buffers ready to use, as a 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_;
 
   // Output buffer state.
   bool output_streamon_;
   // Output buffers enqueued to device.
   int output_buffer_queued_count_;
   // Output buffers ready to use, as a FIFO since we want oldest-first to hide
   // synchronization latency with GL.
   std::queue<int> free_output_buffers_;
   // Mapping of int index to output buffer record.
   std::vector<OutputRecord> output_buffer_map_;
   // Output pixel format.
   uint32 output_buffer_pixelformat_;
   // Required size of DPB for decoding.
   int output_dpb_size_;
+  // Stores the number of planes (i.e. separate memory buffers) for output.
+  size_t output_planes_count_;
 
   // Pictures that are ready but not sent to PictureReady yet.
   std::queue<PictureRecord> pending_picture_ready_;
 
   // The number of pictures that are sent to PictureReady and will be cleared.
   int picture_clearing_count_;
 
   // Used by the decoder thread to wait for AssignPictureBuffers to arrive
   // to avoid races with potential Reset requests.
   base::WaitableEvent pictures_assigned_;
@@ skipping 20 matching lines @@
 
   // The codec we'll be decoding for.
   media::VideoCodecProfile video_profile_;
 
   DISALLOW_COPY_AND_ASSIGN(V4L2VideoDecodeAccelerator);
 };
 
 }  // namespace content
 
 #endif  // CONTENT_COMMON_GPU_MEDIA_V4L2_VIDEO_DECODE_ACCELERATOR_H_