Close bitstream buffer shared memory handles on Android.

media/gpu/android_video_decode_accelerator.cc

 // Copyright (c) 2013 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 "media/gpu/android_video_decode_accelerator.h"
 
 #include <stddef.h>
 
 #include <memory>
 
@@ skipping 350 matching lines @@
   DISALLOW_COPY_AND_ASSIGN(AVDATimerManager);
 };
 
 static base::LazyInstance<AVDATimerManager>::Leaky g_avda_timer =
     LAZY_INSTANCE_INITIALIZER;
 
 AndroidVideoDecodeAccelerator::CodecConfig::CodecConfig() {}
 
 AndroidVideoDecodeAccelerator::CodecConfig::~CodecConfig() {}
 
+AndroidVideoDecodeAccelerator::BitstreamRecord::BitstreamRecord(
+    const media::BitstreamBuffer& bitstream_buffer)
+    : buffer(bitstream_buffer) {
+  if (buffer.id() != -1)
+    memory.reset(new SharedMemoryRegion(buffer, true));
+}
+
+AndroidVideoDecodeAccelerator::BitstreamRecord::BitstreamRecord(
+    BitstreamRecord&& other)
+    : buffer(std::move(other.buffer)), memory(std::move(other.memory)) {}
+
+AndroidVideoDecodeAccelerator::BitstreamRecord::~BitstreamRecord() {}
+
 AndroidVideoDecodeAccelerator::AndroidVideoDecodeAccelerator(
     const MakeGLContextCurrentCallback& make_context_current_cb,
     const GetGLES2DecoderCallback& get_gles2_decoder_cb)
     : client_(NULL),
       make_context_current_cb_(make_context_current_cb),
       get_gles2_decoder_cb_(get_gles2_decoder_cb),
       state_(NO_ERROR),
       picturebuffers_requested_(false),
       drain_type_(DRAIN_TYPE_NONE),
       media_drm_bridge_cdm_context_(nullptr),
@@ skipping 184 matching lines @@
 
   ManageTimer(did_work || start_timer);
 }
 
 bool AndroidVideoDecodeAccelerator::QueueInput() {
   DCHECK(thread_checker_.CalledOnValidThread());
   TRACE_EVENT0("media", "AVDA::QueueInput");
   base::AutoReset<bool> auto_reset(&defer_errors_, true);
   if (bitstreams_notified_in_advance_.size() > kMaxBitstreamsNotifiedInAdvance)
     return false;
-  if (pending_bitstream_buffers_.empty())
+  if (pending_bitstream_records_.empty())
     return false;
   if (state_ == WAITING_FOR_KEY)
     return false;
 
   int input_buf_index = pending_input_buf_index_;
 
   // Do not dequeue a new input buffer if we failed with MEDIA_CODEC_NO_KEY.
   // That status does not return this buffer back to the pool of
   // available input buffers. We have to reuse it in QueueSecureInputBuffer().
   if (input_buf_index == -1) {
     media::MediaCodecStatus status =
         media_codec_->DequeueInputBuffer(NoWaitTimeOut(), &input_buf_index);
     switch (status) {
       case media::MEDIA_CODEC_DEQUEUE_INPUT_AGAIN_LATER:
         return false;
       case media::MEDIA_CODEC_ERROR:
         POST_ERROR(PLATFORM_FAILURE, "Failed to DequeueInputBuffer");
         return false;
       case media::MEDIA_CODEC_OK:
         break;
       default:
         NOTREACHED() << "Unknown DequeueInputBuffer status " << status;
         return false;
     }
   }
 
   DCHECK_NE(input_buf_index, -1);
 
-  media::BitstreamBuffer bitstream_buffer = pending_bitstream_buffers_.front();
+  media::BitstreamBuffer bitstream_buffer =
+      pending_bitstream_records_.front().buffer;
 
   if (bitstream_buffer.id() == -1) {
-    pending_bitstream_buffers_.pop();
+    pending_bitstream_records_.pop();
     TRACE_COUNTER1("media", "AVDA::PendingBitstreamBufferCount",
-                   pending_bitstream_buffers_.size());
+                   pending_bitstream_records_.size());
 
     media_codec_->QueueEOS(input_buf_index);
     return true;
   }
 
   std::unique_ptr<SharedMemoryRegion> shm;
 
   if (pending_input_buf_index_ == -1) {
     // When |pending_input_buf_index_| is not -1, the buffer is already dequeued
     // from MediaCodec, filled with data and bitstream_buffer.handle() is
     // closed.
-    shm.reset(new SharedMemoryRegion(bitstream_buffer, true));
+    shm = std::move(pending_bitstream_records_.front().memory);
 
     if (!shm->Map()) {
       POST_ERROR(UNREADABLE_INPUT, "Failed to SharedMemoryRegion::Map()");
       return false;
     }
   }
 
   const base::TimeDelta presentation_timestamp =
       bitstream_buffer.presentation_timestamp();
   DCHECK(presentation_timestamp != media::kNoTimestamp())
@@ skipping 34 matching lines @@
   if (status == media::MEDIA_CODEC_NO_KEY) {
     // Keep trying to enqueue the same input buffer.
     // The buffer is owned by us (not the MediaCodec) and is filled with data.
     DVLOG(1) << "QueueSecureInputBuffer failed: NO_KEY";
     pending_input_buf_index_ = input_buf_index;
     state_ = WAITING_FOR_KEY;
     return false;
   }
 
   pending_input_buf_index_ = -1;
-  pending_bitstream_buffers_.pop();
+  pending_bitstream_records_.pop();
   TRACE_COUNTER1("media", "AVDA::PendingBitstreamBufferCount",
-                 pending_bitstream_buffers_.size());
+                 pending_bitstream_records_.size());
   // We should call NotifyEndOfBitstreamBuffer(), when no more decoded output
   // will be returned from the bitstream buffer. However, MediaCodec API is
   // not enough to guarantee it.
   // So, here, we calls NotifyEndOfBitstreamBuffer() in advance in order to
   // keep getting more bitstreams from the client, and throttle them by using
   // |bitstreams_notified_in_advance_|.
   // TODO(dwkang): check if there is a way to remove this workaround.
   base::MessageLoop::current()->PostTask(
       FROM_HERE,
       base::Bind(&AndroidVideoDecodeAccelerator::NotifyEndOfBitstreamBuffer,
@@ skipping 225 matching lines @@
   } else {
     base::MessageLoop::current()->PostTask(
         FROM_HERE,
         base::Bind(&AndroidVideoDecodeAccelerator::NotifyEndOfBitstreamBuffer,
                    weak_this_factory_.GetWeakPtr(), bitstream_buffer.id()));
   }
 }
 
 void AndroidVideoDecodeAccelerator::DecodeBuffer(
     const media::BitstreamBuffer& bitstream_buffer) {
-  pending_bitstream_buffers_.push(bitstream_buffer);
+  pending_bitstream_records_.push(BitstreamRecord(bitstream_buffer));
   TRACE_COUNTER1("media", "AVDA::PendingBitstreamBufferCount",
-                 pending_bitstream_buffers_.size());
+                 pending_bitstream_records_.size());
 
   DoIOTask(true);
 }
 
 void AndroidVideoDecodeAccelerator::RequestPictureBuffers() {
   if (client_) {
     client_->ProvidePictureBuffers(kNumPictureBuffers, 1,
                                    strategy_->GetPictureBufferSize(),
                                    strategy_->GetTextureTarget());
   }
@@ skipping 226 matching lines @@
     if (!done_cb.is_null())
       done_cb.Run();
     return;
   }
 
   bitstream_buffers_in_decoder_.clear();
 
   if (pending_input_buf_index_ != -1) {
     // The data for that index exists in the input buffer, but corresponding
     // shm block been deleted. Check that it is safe to flush the coec, i.e.
-    // |pending_bitstream_buffers_| is empty.
+    // |pending_bitstream_records_| is empty.
     // TODO(timav): keep shm block for that buffer and remove this restriction.
-    DCHECK(pending_bitstream_buffers_.empty());
+    DCHECK(pending_bitstream_records_.empty());
     pending_input_buf_index_ = -1;
   }
 
   const bool did_codec_error_happen = state_ == ERROR;
   state_ = NO_ERROR;
 
   // We might increment error_sequence_token here to cancel any delayed errors,
   // but right now it's unclear that it's safe to do so.  If we are in an error
   // state because of a codec error, then it would be okay.  Otherwise, it's
   // less obvious that we are exiting the error state.  Since deferred errors
@@ skipping 24 matching lines @@
 
   if (!done_cb.is_null())
     done_cb.Run();
 }
 
 void AndroidVideoDecodeAccelerator::Reset() {
   DVLOG(1) << __FUNCTION__;
   DCHECK(thread_checker_.CalledOnValidThread());
   TRACE_EVENT0("media", "AVDA::Reset");
 
-  while (!pending_bitstream_buffers_.empty()) {
-    int32_t bitstream_buffer_id = pending_bitstream_buffers_.front().id();
-    pending_bitstream_buffers_.pop();
+  while (!pending_bitstream_records_.empty()) {
+    int32_t bitstream_buffer_id =
+        pending_bitstream_records_.front().buffer.id();
+    pending_bitstream_records_.pop();
 
     if (bitstream_buffer_id != -1) {
       base::MessageLoop::current()->PostTask(
           FROM_HERE,
           base::Bind(&AndroidVideoDecodeAccelerator::NotifyEndOfBitstreamBuffer,
                      weak_this_factory_.GetWeakPtr(), bitstream_buffer_id));
     }
   }
   TRACE_COUNTER1("media", "AVDA::PendingBitstreamBufferCount", 0);
   bitstreams_notified_in_advance_.clear();
@@ skipping 31 matching lines @@
   if (on_frame_available_handler_) {
     on_frame_available_handler_->ClearOwner();
     on_frame_available_handler_ = nullptr;
   }
 
   client_ = nullptr;
 
   // Some VP8 files require complete MediaCodec drain before we can call
   // MediaCodec.flush() or MediaCodec.reset(). http://crbug.com/598963.
   if (media_codec_ && codec_config_->codec_ == media::kCodecVP8) {
-    // Clear pending_bitstream_buffers_.
-    while (!pending_bitstream_buffers_.empty())
-      pending_bitstream_buffers_.pop();
+    // Clear pending_bitstream_records_.
+    while (!pending_bitstream_records_.empty())
+      pending_bitstream_records_.pop();
 
     // Postpone ActualDestroy after the drain.
     StartCodecDrain(DRAIN_FOR_DESTROY);
   } else {
     ActualDestroy();
   }
 }
 
 void AndroidVideoDecodeAccelerator::ActualDestroy() {
   DVLOG(1) << __FUNCTION__;
@@ skipping 307 matching lines @@
     if (media::MediaCodecUtil::IsSurfaceViewOutputSupported()) {
       capabilities.flags |= media::VideoDecodeAccelerator::Capabilities::
           SUPPORTS_EXTERNAL_OUTPUT_SURFACE;
     }
   }
 
   return capabilities;
 }
 
 }  // namespace media