Implement a chromoting client using X11

media/base/video_frame.cc

 // Copyright (c) 2010 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"
 
 namespace media {
 
 // static
 void VideoFrame::CreateFrame(VideoFrame::Format format,
@@ skipping 29 matching lines @@
         break;
       default:
         NOTREACHED();
         alloc_worked = false;
         break;
     }
   }
   *frame_out = alloc_worked ? frame : NULL;
 }
 
+void VideoFrame::CreateFrameExternal(VideoFrame::Format format,
+                                     size_t width,
+                                     size_t height,
+                                     uint8* const data[kMaxPlanes],
+                                     const int32 strides[kMaxPlanes],
+                                     base::TimeDelta timestamp,
+                                     base::TimeDelta duration,
+                                     scoped_refptr<VideoFrame>* frame_out) {
+  DCHECK(frame_out);
+  scoped_refptr<VideoFrame> frame =
+      new VideoFrame(VideoFrame::TYPE_SYSTEM_MEMORY, format, width, height);
+  if (frame) {
+    frame->SetTimestamp(timestamp);
+    frame->SetDuration(duration);
+    frame->external_memory_ = true;
+    for (size_t i = 0; i < kMaxPlanes; ++i) {
+      frame->data_[i] = data[i];
+      frame->strides_[i] = strides[i];
+    }
+  }
+  *frame_out = frame;
+}
+
 // static
 void VideoFrame::CreateEmptyFrame(scoped_refptr<VideoFrame>* frame_out) {
   *frame_out = new VideoFrame(VideoFrame::TYPE_SYSTEM_MEMORY,
                               VideoFrame::EMPTY, 0, 0);
 }
 
 // static
 void VideoFrame::CreateBlackFrame(int width, int height,
                                   scoped_refptr<VideoFrame>* frame_out) {
   DCHECK_GT(width, 0);
@@ skipping 112 matching lines @@
                        VideoFrame::Format format,
                        size_t width,
                        size_t height) {
   type_ = type;
   format_ = format;
   width_ = width;
   height_ = height;
   planes_ = 0;
   memset(&strides_, 0, sizeof(strides_));
   memset(&data_, 0, sizeof(data_));
+  external_memory_ = false;
   private_buffer_ = NULL;
 }
 
 VideoFrame::~VideoFrame() {
   // In multi-plane allocations, only a single block of memory is allocated
   // on the heap, and other |data| pointers point inside the same, single block
   // so just delete index 0.
-  delete[] data_[0];
+  if (!external_memory_)
+    delete[] data_[0];
 }
 
 bool VideoFrame::IsEndOfStream() const {
   return format_ == VideoFrame::EMPTY;
 }
 
 }  // namespace media