Improve logging output for DecoderBuffer and VideoFrame

media/base/video_frame.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 "media/base/video_frame.h"
 
 #include <algorithm>
 #include <climits>
 
 #include "base/bind.h"
@@ skipping 29 matching lines @@
                                   const VideoFrame::StorageType storage_type,
                                   const gfx::Size& coded_size,
                                   const gfx::Rect& visible_rect,
                                   const gfx::Size& natural_size) {
   return base::StringPrintf(
       "format:%s coded_size:%s visible_rect:%s natural_size:%s",
       VideoPixelFormatToString(format).c_str(), coded_size.ToString().c_str(),
       visible_rect.ToString().c_str(), natural_size.ToString().c_str());
 }
 
+static std::string StorageTypeToString(
+    const VideoFrame::StorageType storage_type) {
+  switch (storage_type) {
+    case VideoFrame::STORAGE_UNKNOWN:
+      return "UNKNOWN";
+    case VideoFrame::STORAGE_OPAQUE:
+      return "OPAQUE";
+    case VideoFrame::STORAGE_UNOWNED_MEMORY:
+      return "UNOWNED_MEMORY";
+    case VideoFrame::STORAGE_OWNED_MEMORY:
+      return "OWNED_MEMORY";
+    case VideoFrame::STORAGE_SHMEM:
+      return "SHMEM";
+#if defined(OS_LINUX)
+    case VideoFrame::STORAGE_DMABUFS:
+      return "DMABUFS";
+#endif
+#if defined(VIDEO_HOLE)
+    case VideoFrame::STORAGE_HOLE:
+      return "HOLE";
+#endif
+    case VideoFrame::STORAGE_GPU_MEMORY_BUFFERS:
+      return "GPU_MEMORY_BUFFERS";
+  }
+
+  NOTREACHED() << "Invalid StorageType provided: " << storage_type;
+  return "INVALID";
+}
+
 // Returns true if |plane| is a valid plane index for the given |format|.
 static bool IsValidPlane(size_t plane, VideoPixelFormat format) {
   DCHECK_LE(VideoFrame::NumPlanes(format),
             static_cast<size_t>(VideoFrame::kMaxPlanes));
   return (plane < VideoFrame::NumPlanes(format));
 }
 
 // Returns true if |frame| is accesible mapped in the VideoFrame memory space.
 // static
 static bool IsStorageTypeMappable(VideoFrame::StorageType storage_type) {
@@ skipping 759 matching lines @@
   DCHECK(HasTextures());
   base::AutoLock locker(release_sync_token_lock_);
   // Must wait on the previous sync point before inserting a new sync point so
   // that |mailbox_holders_release_cb_| guarantees the previous sync point
   // occurred when it waits on |release_sync_token_|.
   if (release_sync_token_.HasData())
     client->WaitSyncToken(release_sync_token_);
   client->GenerateSyncToken(&release_sync_token_);
 }
 
+std::string VideoFrame::AsHumanReadableString() {
+  if (metadata()->IsTrue(media::VideoFrameMetadata::END_OF_STREAM))
+    return "end of stream";
+
+  std::ostringstream s;
+  s << "format: " << VideoPixelFormatToString(format_)
+    << " storage_type: " << StorageTypeToString(storage_type_)
+    << " coded_size: " << coded_size_.ToString()
+    << " visible_rect: " << visible_rect_.ToString()
+    << " natural_size: " << natural_size_.ToString()
+    << " timestamp: " << timestamp_.InMicroseconds();
+  return s.str();
+}
+
 // static
 scoped_refptr<VideoFrame> VideoFrame::WrapExternalStorage(
     VideoPixelFormat format,
     StorageType storage_type,
     const gfx::Size& coded_size,
     const gfx::Rect& visible_rect,
     const gfx::Size& natural_size,
     uint8_t* data,
     size_t data_size,
     base::TimeDelta timestamp,
@@ skipping 180 matching lines @@
   if (zero_initialize_memory)
     memset(data, 0, data_size);
 
   for (size_t plane = 0; plane < NumPlanes(format_); ++plane)
     data_[plane] = data + offset[plane];
 
   AddDestructionObserver(base::Bind(&base::AlignedFree, data));
 }
 
 }  // namespace media