Adding traces to OmxVideoDecodeAccelerator

content/common/gpu/media/omx_video_decode_accelerator.cc

 // Copyright (c) 2011 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 "content/common/gpu/media/omx_video_decode_accelerator.h"
 
+#include "base/debug/trace_event.h"
 #include "base/stl_util.h"
 #include "base/string_util.h"
 #include "content/common/gpu/gpu_channel.h"
 #include "content/common/gpu/media/gles2_texture_to_egl_image_translator.h"
 #include "media/base/bitstream_buffer.h"
 #include "media/video/picture.h"
 
 // Helper typedef for input buffers.  This is used as the pAppPrivate field of
 // OMX_BUFFERHEADERTYPEs of input buffers, to point to the data associated with
 // them.
@@ skipping 253 matching lines @@
     buffer->nTimeStamp = -1;
     buffer->nOutputPortIndex = output_port_;
     CHECK(fake_output_buffers_.insert(buffer).second);
   }
 
   return true;
 }
 
 void OmxVideoDecodeAccelerator::Decode(
     const media::BitstreamBuffer& bitstream_buffer) {
+  TRACE_EVENT1("Video Decoder", "OVDA::Decode",
+               "Buffer id", bitstream_buffer.id());
   DCHECK_EQ(message_loop_, MessageLoop::current());
   DCHECK(!free_input_buffers_.empty());
 
   if (current_state_change_ == RESETTING ||
       !queued_bitstream_buffers_.empty()) {
     queued_bitstream_buffers_.push_back(bitstream_buffer);
     return;
   }
 
   RETURN_ON_FAILURE(current_state_change_ == NO_TRANSITION &&
@@ skipping 56 matching lines @@
   DCHECK_EQ(pictures_.size(), kNumPictureBuffers);
 
   // These do their own RETURN_ON_FAILURE dances.
   if (!AllocateOutputBuffers())
     return;
   if (!SendCommandToPort(OMX_CommandPortEnable, output_port_))
     return;
 }
 
 void OmxVideoDecodeAccelerator::ReusePictureBuffer(int32 picture_buffer_id) {
+  TRACE_EVENT1("Video Decoder", "OVDA::ReusePictureBuffer",
+               "Picture id", picture_buffer_id);
   DCHECK_EQ(message_loop_, MessageLoop::current());
   RETURN_ON_FAILURE(CanFillBuffer(), "Can't fill buffer", ILLEGAL_STATE,);
 
   OutputPictureById::iterator it = pictures_.find(picture_buffer_id);
   RETURN_ON_FAILURE(it != pictures_.end(),
                     "Missing picture buffer id: " << picture_buffer_id,
                     INVALID_ARGUMENT,);
   OutputPicture& output_picture = it->second;
 
   ++output_buffers_at_component_;
@@ skipping 363 matching lines @@
     omx_buffer->nOutputPortIndex = output_port_;
     ++output_buffers_at_component_;
     OMX_ERRORTYPE result = OMX_FillThisBuffer(component_handle_, omx_buffer);
     RETURN_ON_OMX_FAILURE(result, "OMX_FillThisBuffer() failed",
                           PLATFORM_FAILURE,);
   }
 }
 
 void OmxVideoDecodeAccelerator::FillBufferDoneTask(
     OMX_BUFFERHEADERTYPE* buffer) {
+  media::Picture* picture =
+      reinterpret_cast<media::Picture*>(buffer->pAppPrivate);
+  int picture_buffer_id = picture ? picture->picture_buffer_id() : -1;
+  TRACE_EVENT2("Video Decoder", "OVDA::FillBufferDoneTask",
+               "Buffer id", buffer->nTimeStamp,
+               "Picture id", picture_buffer_id);
   DCHECK_EQ(message_loop_, MessageLoop::current());
   DCHECK_GT(output_buffers_at_component_, 0);
   --output_buffers_at_component_;
 
   if (fake_output_buffers_.size() && fake_output_buffers_.count(buffer)) {
     CHECK_EQ(fake_output_buffers_.erase(buffer), 1U);
     OMX_ERRORTYPE result =
         OMX_FreeBuffer(component_handle_, output_port_, buffer);
     RETURN_ON_OMX_FAILURE(result, "OMX_FreeBuffer failed", PLATFORM_FAILURE,);
     return;
   }
   CHECK(!fake_output_buffers_.size());
 
   if (current_state_change_ == FLUSHING &&
       buffer->nFlags & OMX_BUFFERFLAG_EOS) {
     DCHECK(!saw_eos_during_flush_);
     saw_eos_during_flush_ = true;
   }
 
-  DCHECK(buffer->pAppPrivate);
-  media::Picture* picture =
-      reinterpret_cast<media::Picture*>(buffer->pAppPrivate);
-  int picture_buffer_id = picture->picture_buffer_id();
-
   // During the transition from Executing to Idle, and during port-flushing, all
   // pictures are sent back through here.  Avoid giving them to the client.
   // Also avoid sending the (fake) EOS buffer to the client.
   if ((current_state_change_ != NO_TRANSITION &&
        current_state_change_ != FLUSHING) ||
       saw_eos_during_flush_) {
     if (current_state_change_ == RESETTING)
       queued_picture_buffer_ids_.push_back(picture_buffer_id);
     return;
   }
 
+  DCHECK(picture);
   // See Decode() for an explanation of this abuse of nTimeStamp.
   picture->set_bitstream_buffer_id(buffer->nTimeStamp);
   if (client_)
     client_->PictureReady(*picture);
 }
 
 void OmxVideoDecodeAccelerator::EmptyBufferDoneTask(
     OMX_BUFFERHEADERTYPE* buffer) {
+  TRACE_EVENT1("Video Decoder", "OVDA::EmptyBufferDoneTask",
+               "Buffer id", buffer->nTimeStamp);
   DCHECK_EQ(message_loop_, MessageLoop::current());
   DCHECK_GT(input_buffers_at_component_, 0);
   free_input_buffers_.push(buffer);
   input_buffers_at_component_--;
   if (buffer->nFlags & OMX_BUFFERFLAG_EOS)
     return;
 
   // Retrieve the corresponding BitstreamBuffer's id and notify the client of
   // its completion.
   SharedMemoryAndId* input_buffer_details =
@@ skipping 170 matching lines @@
           decoder, &OmxVideoDecodeAccelerator::EventHandlerCompleteTask,
           event, data1, data2));
   return OMX_ErrorNone;
 }
 
 // static
 OMX_ERRORTYPE OmxVideoDecodeAccelerator::EmptyBufferCallback(
     OMX_HANDLETYPE component,
     OMX_PTR priv_data,
     OMX_BUFFERHEADERTYPE* buffer) {
+  TRACE_EVENT1("Video Decoder", "OVDA::EmptyBufferCallback",
+               "Buffer id", buffer->nTimeStamp);
   // Called on the OMX thread.
   OmxVideoDecodeAccelerator* decoder =
       static_cast<OmxVideoDecodeAccelerator*>(priv_data);
   DCHECK_EQ(component, decoder->component_handle_);
   decoder->message_loop_->PostTask(
       FROM_HERE,
       NewRunnableMethod(decoder,
                         &OmxVideoDecodeAccelerator::EmptyBufferDoneTask,
                         buffer));
   return OMX_ErrorNone;
 }
 
 // static
 OMX_ERRORTYPE OmxVideoDecodeAccelerator::FillBufferCallback(
     OMX_HANDLETYPE component,
     OMX_PTR priv_data,
     OMX_BUFFERHEADERTYPE* buffer) {
+  media::Picture* picture =
+      reinterpret_cast<media::Picture*>(buffer->pAppPrivate);
+  int picture_buffer_id = picture ? picture->picture_buffer_id() : -1;
+  TRACE_EVENT2("Video Decoder", "OVDA::FillBufferCallback",
+               "Buffer id", buffer->nTimeStamp,
+               "Picture id", picture_buffer_id);
   // Called on the OMX thread.
   OmxVideoDecodeAccelerator* decoder =
       static_cast<OmxVideoDecodeAccelerator*>(priv_data);
   DCHECK_EQ(component, decoder->component_handle_);
   decoder->message_loop_->PostTask(
       FROM_HERE,
       NewRunnableMethod(decoder,
                         &OmxVideoDecodeAccelerator::FillBufferDoneTask,
                         buffer));
   return OMX_ErrorNone;
@@ skipping 12 matching lines @@
 
 bool OmxVideoDecodeAccelerator::SendCommandToPort(
     OMX_COMMANDTYPE cmd, int port_index) {
   DCHECK_EQ(message_loop_, MessageLoop::current());
   OMX_ERRORTYPE result = OMX_SendCommand(component_handle_,
                                          cmd, port_index, 0);
   RETURN_ON_OMX_FAILURE(result, "SendCommand() failed" << cmd,
                         PLATFORM_FAILURE, false);
   return true;
 }