Line data    Source code

       1             : /*
       2             :  *  Copyright (c) 2013 The WebRTC project authors. All Rights Reserved.
       3             :  *
       4             :  *  Use of this source code is governed by a BSD-style license
       5             :  *  that can be found in the LICENSE file in the root of the source
       6             :  *  tree. An additional intellectual property rights grant can be found
       7             :  *  in the file PATENTS.  All contributing project authors may
       8             :  *  be found in the AUTHORS file in the root of the source tree.
       9             :  */
      10             : 
      11             : #include "webrtc/modules/desktop_capture/desktop_frame.h"
      12             : 
      13             : #include <utility>
      14             : 
      15             : #include <string.h>
      16             : 
      17             : #include "webrtc/base/checks.h"
      18             : 
      19             : namespace webrtc {
      20             : 
      21           0 : DesktopFrame::DesktopFrame(DesktopSize size,
      22             :                            int stride,
      23             :                            uint8_t* data,
      24           0 :                            SharedMemory* shared_memory)
      25             :     : data_(data),
      26             :       shared_memory_(shared_memory),
      27             :       size_(size),
      28             :       stride_(stride),
      29           0 :       capture_time_ms_(0) {
      30           0 : }
      31             : 
      32           0 : DesktopFrame::~DesktopFrame() {}
      33             : 
      34           0 : void DesktopFrame::CopyPixelsFrom(const uint8_t* src_buffer, int src_stride,
      35             :                                   const DesktopRect& dest_rect) {
      36           0 :   RTC_CHECK(DesktopRect::MakeSize(size()).ContainsRect(dest_rect));
      37             : 
      38           0 :   uint8_t* dest = GetFrameDataAtPos(dest_rect.top_left());
      39           0 :   for (int y = 0; y < dest_rect.height(); ++y) {
      40           0 :     memcpy(dest, src_buffer, DesktopFrame::kBytesPerPixel * dest_rect.width());
      41           0 :     src_buffer += src_stride;
      42           0 :     dest += stride();
      43             :   }
      44           0 : }
      45             : 
      46           0 : void DesktopFrame::CopyPixelsFrom(const DesktopFrame& src_frame,
      47             :                                   const DesktopVector& src_pos,
      48             :                                   const DesktopRect& dest_rect) {
      49           0 :   RTC_CHECK(DesktopRect::MakeSize(src_frame.size()).ContainsRect(
      50           0 :       DesktopRect::MakeOriginSize(src_pos, dest_rect.size())));
      51             : 
      52           0 :   CopyPixelsFrom(src_frame.GetFrameDataAtPos(src_pos),
      53           0 :                  src_frame.stride(), dest_rect);
      54           0 : }
      55             : 
      56           0 : uint8_t* DesktopFrame::GetFrameDataAtPos(const DesktopVector& pos) const {
      57           0 :   return data() + stride() * pos.y() + DesktopFrame::kBytesPerPixel * pos.x();
      58             : }
      59             : 
      60           0 : BasicDesktopFrame::BasicDesktopFrame(DesktopSize size)
      61           0 :     : DesktopFrame(size, kBytesPerPixel * size.width(),
      62           0 :                    new uint8_t[kBytesPerPixel * size.width() * size.height()],
      63           0 :                    NULL) {
      64           0 : }
      65             : 
      66           0 : BasicDesktopFrame::~BasicDesktopFrame() {
      67           0 :   delete[] data_;
      68           0 : }
      69             : 
      70           0 : DesktopFrame* BasicDesktopFrame::CopyOf(const DesktopFrame& frame) {
      71           0 :   DesktopFrame* result = new BasicDesktopFrame(frame.size());
      72           0 :   for (int y = 0; y < frame.size().height(); ++y) {
      73           0 :     memcpy(result->data() + y * result->stride(),
      74           0 :            frame.data() + y * frame.stride(),
      75           0 :            frame.size().width() * kBytesPerPixel);
      76             :   }
      77           0 :   result->set_dpi(frame.dpi());
      78           0 :   result->set_capture_time_ms(frame.capture_time_ms());
      79           0 :   *result->mutable_updated_region() = frame.updated_region();
      80           0 :   return result;
      81             : }
      82             : 
      83             : // static
      84           0 : std::unique_ptr<DesktopFrame> SharedMemoryDesktopFrame::Create(
      85             :     DesktopSize size,
      86             :     SharedMemoryFactory* shared_memory_factory) {
      87           0 :   size_t buffer_size = size.height() * size.width() * kBytesPerPixel;
      88             :   std::unique_ptr<SharedMemory> shared_memory =
      89           0 :       shared_memory_factory->CreateSharedMemory(buffer_size);
      90           0 :   if (!shared_memory)
      91           0 :     return nullptr;
      92             : 
      93           0 :   return Create(size, std::move(shared_memory));
      94             : }
      95             : 
      96             : // static
      97           0 : std::unique_ptr<DesktopFrame> SharedMemoryDesktopFrame::Create(
      98             :     DesktopSize size,
      99             :     std::unique_ptr<SharedMemory> shared_memory) {
     100           0 :   RTC_DCHECK(shared_memory);
     101           0 :   int stride = size.width() * kBytesPerPixel;
     102             :   return std::unique_ptr<DesktopFrame>(new SharedMemoryDesktopFrame(
     103           0 :       size, stride, shared_memory.release()));
     104             : }
     105             : 
     106           0 : SharedMemoryDesktopFrame::SharedMemoryDesktopFrame(DesktopSize size,
     107             :                                                    int stride,
     108           0 :                                                    SharedMemory* shared_memory)
     109             :     : DesktopFrame(size,
     110             :                    stride,
     111           0 :                    reinterpret_cast<uint8_t*>(shared_memory->data()),
     112           0 :                    shared_memory) {}
     113             : 
     114           0 : SharedMemoryDesktopFrame::~SharedMemoryDesktopFrame() {
     115           0 :   delete shared_memory_;
     116           0 : }
     117             : 
     118             : }  // namespace webrtc