Remove redundant buffer count in ExynosVDA

content/common/gpu/media/exynos_video_decode_accelerator.cc

 // 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.
 
 #include <dlfcn.h>
 #include <errno.h>
 #include <fcntl.h>
 #include <linux/videodev2.h>
 #include <poll.h>
 #include <sys/eventfd.h>
@@ skipping 197 matching lines @@
       decoder_thread_("ExynosDecoderThread"),
       decoder_state_(kUninitialized),
       decoder_current_bitstream_buffer_(NULL),
       decoder_delay_bitstream_buffer_id_(-1),
       decoder_current_input_buffer_(-1),
       decoder_decode_buffer_tasks_scheduled_(0),
       decoder_frames_at_client_(0),
       decoder_flushing_(false),
       mfc_fd_(-1),
       mfc_input_streamon_(false),
-      mfc_input_buffer_count_(0),
       mfc_input_buffer_queued_count_(0),
       mfc_output_streamon_(false),
-      mfc_output_buffer_count_(0),
       mfc_output_buffer_queued_count_(0),
       mfc_output_buffer_pixelformat_(0),
       gsc_fd_(-1),
       gsc_input_streamon_(false),
-      gsc_input_buffer_count_(0),
       gsc_input_buffer_queued_count_(0),
       gsc_output_streamon_(false),
-      gsc_output_buffer_count_(0),
       gsc_output_buffer_queued_count_(0),
       device_poll_thread_("ExynosDevicePollThread"),
       device_poll_interrupt_fd_(-1),
       make_context_current_(make_context_current),
       egl_display_(egl_display),
       egl_context_(egl_context),
       video_profile_(media::VIDEO_CODEC_PROFILE_UNKNOWN) {
 }
 
 ExynosVideoDecodeAccelerator::~ExynosVideoDecodeAccelerator() {
@@ skipping 189 matching lines @@
   decoder_thread_.message_loop()->PostTask(FROM_HERE, base::Bind(
       &ExynosVideoDecodeAccelerator::DecodeTask, base::Unretained(this),
       base::Passed(&bitstream_record)));
 }
 
 void ExynosVideoDecodeAccelerator::AssignPictureBuffers(
     const std::vector<media::PictureBuffer>& buffers) {
   DVLOG(3) << "AssignPictureBuffers(): buffer_count=" << buffers.size();
   DCHECK(child_message_loop_proxy_->BelongsToCurrentThread());
 
-  if (static_cast<int>(buffers.size()) != gsc_output_buffer_count_) {
+  if (buffers.size() != gsc_output_buffer_map_.size()) {
     DLOG(ERROR) << "AssignPictureBuffers(): invalid buffer_count";
     NOTIFY_ERROR(INVALID_ARGUMENT);
     return;
   }
 
   if (!make_context_current_.Run()) {
     DLOG(ERROR) << "AssignPictureBuffers(): could not make context current";
     NOTIFY_ERROR(PLATFORM_FAILURE);
     return;
   }
@@ skipping 636 matching lines @@
   device_poll_thread_.message_loop()->PostTask(FROM_HERE, base::Bind(
       &ExynosVideoDecodeAccelerator::DevicePollTask,
       base::Unretained(this),
       poll_fds));
 
   DVLOG(1) << "ServiceDeviceTask(): buffer counts: DEC["
            << decoder_input_queue_.size() << "->"
            << mfc_input_ready_queue_.size() << "] => MFC["
            << mfc_free_input_buffers_.size() << "+"
            << mfc_input_buffer_queued_count_ << "/"
-           << mfc_input_buffer_count_ << "->"
+           << mfc_input_buffer_map_.size() << "->"
            << mfc_free_output_buffers_.size() << "+"
            << mfc_output_buffer_queued_count_ << "/"
-           << mfc_output_buffer_count_ << "] => "
+           << mfc_output_buffer_map_.size() << "] => "
            << mfc_output_gsc_input_queue_.size() << " => GSC["
            << gsc_free_input_buffers_.size() << "+"
            << gsc_input_buffer_queued_count_ << "/"
-           << gsc_input_buffer_count_ << "->"
+           << gsc_input_buffer_map_.size() << "->"
            << gsc_free_output_buffers_.size() << "+"
            << gsc_output_buffer_queued_count_ << "/"
-           << gsc_output_buffer_count_ << "] => VDA["
+           << gsc_output_buffer_map_.size()  << "] => VDA["
            << decoder_frames_at_client_ << "]";
 
   ScheduleDecodeBufferTaskIfNeeded();
 }
 
 void ExynosVideoDecodeAccelerator::EnqueueMfc() {
   DVLOG(3) << "EnqueueMfc()";
   DCHECK_EQ(decoder_thread_.message_loop(), MessageLoop::current());
   DCHECK_NE(decoder_state_, kUninitialized);
   TRACE_EVENT0("Video Decoder", "EVDA::EnqueueMfc");
@@ skipping 599 matching lines @@
   gsc_input_streamon_ = false;
   if (gsc_output_streamon_) {
     __u32 type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;
     IOCTL_OR_ERROR_RETURN_FALSE(gsc_fd_, VIDIOC_STREAMOFF, &type);
   }
   gsc_output_streamon_ = false;
 
   // Reset all our accounting info.
   mfc_input_ready_queue_.clear();
   mfc_free_input_buffers_.clear();
-  DCHECK_EQ(mfc_input_buffer_count_,
-      static_cast<int>(mfc_input_buffer_map_.size()));
   for (size_t i = 0; i < mfc_input_buffer_map_.size(); ++i) {
     mfc_free_input_buffers_.push_back(i);
     mfc_input_buffer_map_[i].at_device = false;
     mfc_input_buffer_map_[i].bytes_used = 0;
     mfc_input_buffer_map_[i].input_id = -1;
   }
   mfc_input_buffer_queued_count_ = 0;
   mfc_free_output_buffers_.clear();
-  DCHECK_EQ(mfc_output_buffer_count_,
-     static_cast<int>(mfc_output_buffer_map_.size()));
   for (size_t i = 0; i < mfc_output_buffer_map_.size(); ++i) {
     mfc_free_output_buffers_.push_back(i);
     mfc_output_buffer_map_[i].at_device = false;
     mfc_output_buffer_map_[i].input_id = -1;
   }
   mfc_output_buffer_queued_count_ = 0;
   mfc_output_gsc_input_queue_.clear();
   gsc_free_input_buffers_.clear();
-  DCHECK_EQ(gsc_input_buffer_count_,
-      static_cast<int>(gsc_input_buffer_map_.size()));
   for (size_t i = 0; i < gsc_input_buffer_map_.size(); ++i) {
     gsc_free_input_buffers_.push_back(i);
     gsc_input_buffer_map_[i].at_device = false;
     gsc_input_buffer_map_[i].mfc_output = -1;
   }
   gsc_input_buffer_queued_count_ = 0;
   gsc_free_output_buffers_.clear();
-  DCHECK_EQ(gsc_output_buffer_count_,
-      static_cast<int>(gsc_output_buffer_map_.size()));
   for (size_t i = 0; i < gsc_output_buffer_map_.size(); ++i) {
     // Only mark those free that aren't being held by the VDA.
     if (!gsc_output_buffer_map_[i].at_client) {
       gsc_free_output_buffers_.push_back(i);
       gsc_output_buffer_map_[i].at_device = false;
     }
   }
   gsc_output_buffer_queued_count_ = 0;
 
   DVLOG(3) << "StopDevicePoll(): device poll stopped";
@@ skipping 86 matching lines @@
     return;
   }
 
   if (client_) {
     client_->NotifyError(error);
     client_ptr_factory_.InvalidateWeakPtrs();
   }
 }
 
 void ExynosVideoDecodeAccelerator::SetDecoderState(State state) {
-  DVLOG(3) << "SetDecoderState(): state=%d" << state;
+  DVLOG(3) << "SetDecoderState(): state=" << state;
 
   // We can touch decoder_state_ only if this is the decoder thread or the
   // decoder thread isn't running.
   if (decoder_thread_.message_loop() != NULL &&
       decoder_thread_.message_loop() != MessageLoop::current()) {
     decoder_thread_.message_loop()->PostTask(FROM_HERE, base::Bind(
         &ExynosVideoDecodeAccelerator::SetDecoderState,
         base::Unretained(this), state));
   } else {
     decoder_state_ = state;
   }
 }
 
 bool ExynosVideoDecodeAccelerator::CreateMfcInputBuffers() {
   DVLOG(3) << "CreateMfcInputBuffers()";
   // We always run this as we prepare to initialize.
   DCHECK_EQ(decoder_state_, kUninitialized);
   DCHECK(!mfc_input_streamon_);
-  DCHECK_EQ(mfc_input_buffer_count_, 0);
+  DCHECK(mfc_input_buffer_map_.empty());
 
   __u32 pixelformat = 0;
   if (video_profile_ >= media::H264PROFILE_MIN &&
       video_profile_ <= media::H264PROFILE_MAX) {
     pixelformat = V4L2_PIX_FMT_H264;
   } else if (video_profile_ >= media::VP8PROFILE_MIN &&
              video_profile_ <= media::VP8PROFILE_MAX) {
     pixelformat = V4L2_PIX_FMT_VP8;
   } else {
     NOTREACHED();
   }
 
   struct v4l2_format format;
   memset(&format, 0, sizeof(format));
   format.type                              = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE;
   format.fmt.pix_mp.pixelformat            = pixelformat;
   format.fmt.pix_mp.plane_fmt[0].sizeimage = kMfcInputBufferMaxSize;
   format.fmt.pix_mp.num_planes             = 1;
   IOCTL_OR_ERROR_RETURN_FALSE(mfc_fd_, VIDIOC_S_FMT, &format);
 
   struct v4l2_requestbuffers reqbufs;
   memset(&reqbufs, 0, sizeof(reqbufs));
   reqbufs.count  = kMfcInputBufferCount;
   reqbufs.type   = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE;
   reqbufs.memory = V4L2_MEMORY_MMAP;
   IOCTL_OR_ERROR_RETURN_FALSE(mfc_fd_, VIDIOC_REQBUFS, &reqbufs);
-  mfc_input_buffer_count_ = reqbufs.count;
-  mfc_input_buffer_map_.resize(mfc_input_buffer_count_);
-  for (int i = 0; i < mfc_input_buffer_count_; ++i) {
+  mfc_input_buffer_map_.resize(reqbufs.count);
+  for (size_t i = 0; i < mfc_input_buffer_map_.size(); ++i) {
     mfc_free_input_buffers_.push_back(i);
 
     // Query for the MEMORY_MMAP pointer.
     struct v4l2_plane planes[1];
     struct v4l2_buffer buffer;
     memset(&buffer, 0, sizeof(buffer));
     memset(planes, 0, sizeof(planes));
     buffer.index    = i;
     buffer.type     = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE;
     buffer.memory   = V4L2_MEMORY_MMAP;
@@ skipping 11 matching lines @@
     mfc_input_buffer_map_[i].length = buffer.m.planes[0].length;
   }
 
   return true;
 }
 
 bool ExynosVideoDecodeAccelerator::CreateMfcOutputBuffers() {
   DVLOG(3) << "CreateMfcOutputBuffers()";
   DCHECK_EQ(decoder_state_, kInitialized);
   DCHECK(!mfc_output_streamon_);
-  DCHECK_EQ(mfc_output_buffer_count_, 0);
+  DCHECK(mfc_output_buffer_map_.empty());
 
   // Number of MFC output buffers we need.
   struct v4l2_control ctrl;
   memset(&ctrl, 0, sizeof(ctrl));
   ctrl.id = V4L2_CID_MIN_BUFFERS_FOR_CAPTURE;
   IOCTL_OR_ERROR_RETURN_FALSE(mfc_fd_, VIDIOC_G_CTRL, &ctrl);
 
   // Output format setup in Initialize().
 
   // Allocate the output buffers.
   struct v4l2_requestbuffers reqbufs;
   memset(&reqbufs, 0, sizeof(reqbufs));
   reqbufs.count  = ctrl.value + kMfcOutputBufferExtraCount;
   reqbufs.type   = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;
   reqbufs.memory = V4L2_MEMORY_MMAP;
   IOCTL_OR_ERROR_RETURN_FALSE(mfc_fd_, VIDIOC_REQBUFS, &reqbufs);
 
   // Fill our free-buffers list, and create DMABUFs from them.
-  mfc_output_buffer_count_ = reqbufs.count;
-  mfc_output_buffer_map_.resize(mfc_output_buffer_count_);
-  for (int i = 0; i < mfc_output_buffer_count_; ++i) {
+  mfc_output_buffer_map_.resize(reqbufs.count);
+  for (size_t i = 0; i < mfc_output_buffer_map_.size(); ++i) {
     mfc_free_output_buffers_.push_back(i);
 
     // Query for the MEMORY_MMAP pointer.
     struct v4l2_plane planes[2];
     struct v4l2_buffer buffer;
     memset(&buffer, 0, sizeof(buffer));
     memset(planes, 0, sizeof(planes));
     buffer.index    = i;
     buffer.type     = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;
     buffer.memory   = V4L2_MEMORY_MMAP;
@@ skipping 15 matching lines @@
     }
   }
 
   return true;
 }
 
 bool ExynosVideoDecodeAccelerator::CreateGscInputBuffers() {
   DVLOG(3) << "CreateGscInputBuffers()";
   DCHECK_EQ(decoder_state_, kInitialized);
   DCHECK(!gsc_input_streamon_);
-  DCHECK_EQ(gsc_input_buffer_count_, 0);
+  DCHECK(gsc_input_buffer_map_.empty());
 
   struct v4l2_format format;
   memset(&format, 0, sizeof(format));
   format.type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE;
   format.fmt.pix_mp.width  = frame_buffer_size_.width();
   format.fmt.pix_mp.height = frame_buffer_size_.height();
   format.fmt.pix_mp.pixelformat = mfc_output_buffer_pixelformat_;
   format.fmt.pix_mp.plane_fmt[0].sizeimage = mfc_output_buffer_size_[0];
   format.fmt.pix_mp.plane_fmt[1].sizeimage = mfc_output_buffer_size_[1];
   // NV12MT_16X16 is a tiled format for which bytesperline doesn't make too much
@@ skipping 24 matching lines @@
   control.value = 255;
   IOCTL_OR_ERROR_RETURN_FALSE(gsc_fd_, VIDIOC_S_CTRL, &control);
 
   struct v4l2_requestbuffers reqbufs;
   memset(&reqbufs, 0, sizeof(reqbufs));
   reqbufs.count = kGscInputBufferCount;
   reqbufs.type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE;
   reqbufs.memory = V4L2_MEMORY_USERPTR;
   IOCTL_OR_ERROR_RETURN_FALSE(gsc_fd_, VIDIOC_REQBUFS, &reqbufs);
 
-  gsc_input_buffer_count_ = reqbufs.count;
-  gsc_input_buffer_map_.resize(gsc_input_buffer_count_);
-  for (int i = 0; i < gsc_input_buffer_count_; ++i) {
+  gsc_input_buffer_map_.resize(reqbufs.count);
+  for (size_t i = 0; i < gsc_input_buffer_map_.size(); ++i) {
     gsc_free_input_buffers_.push_back(i);
     gsc_input_buffer_map_[i].mfc_output = -1;
   }
 
   return true;
 }
 
 bool ExynosVideoDecodeAccelerator::CreateGscOutputBuffers() {
   DVLOG(3) << "CreateGscOutputBuffers()";
   DCHECK_EQ(decoder_state_, kInitialized);
   DCHECK(!gsc_output_streamon_);
-  DCHECK_EQ(gsc_output_buffer_count_, 0);
+  DCHECK(gsc_output_buffer_map_.empty());
 
   // GSC outputs into the EGLImages we create from the textures we are
   // assigned.  Assume RGBA8888 format.
   struct v4l2_format format;
   memset(&format, 0, sizeof(format));
   format.type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;
   format.fmt.pix_mp.width  = frame_buffer_size_.width();
   format.fmt.pix_mp.height = frame_buffer_size_.height();
   format.fmt.pix_mp.pixelformat = V4L2_PIX_FMT_RGB32;
   format.fmt.pix_mp.plane_fmt[0].sizeimage =
       frame_buffer_size_.width() * frame_buffer_size_.height() * 4;
   format.fmt.pix_mp.plane_fmt[0].bytesperline = frame_buffer_size_.width() * 4;
   format.fmt.pix_mp.num_planes = 1;
   IOCTL_OR_ERROR_RETURN_FALSE(gsc_fd_, VIDIOC_S_FMT, &format);
 
   struct v4l2_requestbuffers reqbufs;
   memset(&reqbufs, 0, sizeof(reqbufs));
   reqbufs.count = kGscOutputBufferCount;
   reqbufs.type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;
   reqbufs.memory = V4L2_MEMORY_DMABUF;
   IOCTL_OR_ERROR_RETURN_FALSE(gsc_fd_, VIDIOC_REQBUFS, &reqbufs);
 
   // We don't actually fill in the freelist or the map here.  That happens once
   // we have actual usable buffers, after AssignPictureBuffers();
-  gsc_output_buffer_count_ = reqbufs.count;
-  gsc_output_buffer_map_.resize(gsc_output_buffer_count_);
+  gsc_output_buffer_map_.resize(reqbufs.count);
 
   DVLOG(3) << "CreateGscOutputBuffers(): ProvidePictureBuffers(): "
-           << "buffer_count=" << gsc_output_buffer_count_
+           << "buffer_count=" << gsc_output_buffer_map_.size()
            << ", width=" << frame_buffer_size_.width()
            << ", height=" << frame_buffer_size_.height();
   child_message_loop_proxy_->PostTask(FROM_HERE, base::Bind(
-      &Client::ProvidePictureBuffers, client_, gsc_output_buffer_count_,
+      &Client::ProvidePictureBuffers, client_, gsc_output_buffer_map_.size(),
       gfx::Size(frame_buffer_size_.width(), frame_buffer_size_.height()),
       GL_TEXTURE_2D));
 
   return true;
 }
 
 void ExynosVideoDecodeAccelerator::DestroyMfcInputBuffers() {
   DVLOG(3) << "DestroyMfcInputBuffers()";
   DCHECK(child_message_loop_proxy_->BelongsToCurrentThread());
   DCHECK(!mfc_input_streamon_);
 
   for (size_t i = 0; i < mfc_input_buffer_map_.size(); ++i) {
     if (mfc_input_buffer_map_[i].address != NULL) {
       munmap(mfc_input_buffer_map_[i].address,
           mfc_input_buffer_map_[i].length);
     }
   }
 
   struct v4l2_requestbuffers reqbufs;
   memset(&reqbufs, 0, sizeof(reqbufs));
   reqbufs.count = 0;
   reqbufs.type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE;
   reqbufs.memory = V4L2_MEMORY_MMAP;
   if (ioctl(mfc_fd_, VIDIOC_REQBUFS, &reqbufs) != 0)
     DPLOG(ERROR) << "DestroyMfcInputBuffers(): ioctl() failed: VIDIOC_REQBUFS";
 
   mfc_input_buffer_map_.clear();
   mfc_free_input_buffers_.clear();
-  mfc_input_buffer_count_ = 0;
 }
 
 void ExynosVideoDecodeAccelerator::DestroyMfcOutputBuffers() {
   DVLOG(3) << "DestroyMfcOutputBuffers()";
   DCHECK(child_message_loop_proxy_->BelongsToCurrentThread());
   DCHECK(!mfc_output_streamon_);
 
   for (size_t i = 0; i < mfc_output_buffer_map_.size(); ++i) {
     if (mfc_output_buffer_map_[i].address[0] != NULL)
       munmap(mfc_output_buffer_map_[i].address[0],
           mfc_output_buffer_map_[i].length[0]);
     if (mfc_output_buffer_map_[i].address[1] != NULL)
       munmap(mfc_output_buffer_map_[i].address[1],
           mfc_output_buffer_map_[i].length[1]);
   }
 
   struct v4l2_requestbuffers reqbufs;
   memset(&reqbufs, 0, sizeof(reqbufs));
   reqbufs.count = 0;
   reqbufs.type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;
   reqbufs.memory = V4L2_MEMORY_MMAP;
   if (ioctl(mfc_fd_, VIDIOC_REQBUFS, &reqbufs) != 0)
     DPLOG(ERROR) << "DestroyMfcOutputBuffers() ioctl() failed: VIDIOC_REQBUFS";
 
   mfc_output_buffer_map_.clear();
   mfc_free_output_buffers_.clear();
-  mfc_output_buffer_count_ = 0;
 }
 
 void ExynosVideoDecodeAccelerator::DestroyGscInputBuffers() {
   DVLOG(3) << "DestroyGscInputBuffers()";
   DCHECK(child_message_loop_proxy_->BelongsToCurrentThread());
   DCHECK(!gsc_input_streamon_);
 
   struct v4l2_requestbuffers reqbufs;
   memset(&reqbufs, 0, sizeof(reqbufs));
   reqbufs.count = 0;
   reqbufs.type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE;
   reqbufs.memory = V4L2_MEMORY_DMABUF;
   if (ioctl(gsc_fd_, VIDIOC_REQBUFS, &reqbufs) != 0)
     DPLOG(ERROR) << "DestroyGscInputBuffers(): ioctl() failed: VIDIOC_REQBUFS";
 
   gsc_input_buffer_map_.clear();
   gsc_free_input_buffers_.clear();
-  gsc_input_buffer_count_ = 0;
 }
 
 void ExynosVideoDecodeAccelerator::DestroyGscOutputBuffers() {
   DVLOG(3) << "DestroyGscOutputBuffers()";
   DCHECK(child_message_loop_proxy_->BelongsToCurrentThread());
   DCHECK(!gsc_output_streamon_);
 
   if (gsc_output_buffer_map_.size() != 0) {
     if (!make_context_current_.Run())
       DLOG(ERROR) << "DestroyGscOutputBuffers(): "
@@ skipping 17 matching lines @@
   struct v4l2_requestbuffers reqbufs;
   memset(&reqbufs, 0, sizeof(reqbufs));
   reqbufs.count = 0;
   reqbufs.type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;
   reqbufs.memory = V4L2_MEMORY_DMABUF;
   if (ioctl(gsc_fd_, VIDIOC_REQBUFS, &reqbufs) != 0)
     DPLOG(ERROR) << "DestroyGscOutputBuffers(): ioctl() failed: VIDIOC_REQBUFS";
 
   gsc_output_buffer_map_.clear();
   gsc_free_output_buffers_.clear();
-  gsc_output_buffer_count_ = 0;
 }
 
 }  // namespace content