admin/webrtc_m130
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Nuke webrtc/common_video/plane.*.

Browse Source 
Unused code that is unreferenced from build files.

BUG=webrtc:2617
TBR=stefan@webrtc.org

Review URL: https://codereview.webrtc.org/1486103002 .

Cr-Commit-Position: refs/heads/master@{#10856}
This commit is contained in:
Peter Boström 2015-12-01 14:10:29 +01:00
parent dfbb3a4bfc
commit f94abf720d
2 changed files with 0 additions and 155 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

80
webrtc/common_video/plane.cc
View File

@ -1,80 +0,0 @@
/*
* Copyright (c) 2012 The WebRTC project authors. All Rights Reserved.
*
* Use of this source code is governed by a BSD-style license
* that can be found in the LICENSE file in the root of the source
* tree. An additional intellectual property rights grant can be found
* in the file PATENTS. All contributing project authors may
* be found in the AUTHORS file in the root of the source tree.
*/
#include "webrtc/common_video/plane.h"
#include <string.h> // memcpy
#include <algorithm> // swap
namespace webrtc {
// Aligning pointer to 64 bytes for improved performance, e.g. use SIMD.
static const int kBufferAlignment = 64;
Plane::Plane()
: allocated_size_(0),
plane_size_(0),
stride_(0) {}
Plane::~Plane() {}
int Plane::CreateEmptyPlane(int allocated_size, int stride, int plane_size) {
if (allocated_size < 1 || stride < 1 || plane_size < 1)
return -1;
stride_ = stride;
if (MaybeResize(allocated_size) < 0)
return -1;
plane_size_ = plane_size;
return 0;
}
int Plane::MaybeResize(int new_size) {
if (new_size <= 0)
return -1;
if (new_size <= allocated_size_)
return 0;
rtc::scoped_ptr<uint8_t, AlignedFreeDeleter> new_buffer(
static_cast<uint8_t*>(AlignedMalloc(new_size, kBufferAlignment)));
if (buffer_.get()) {
memcpy(new_buffer.get(), buffer_.get(), plane_size_);
}
buffer_.reset(new_buffer.release());
allocated_size_ = new_size;
return 0;
}
int Plane::Copy(const Plane& plane) {
if (MaybeResize(plane.allocated_size_) < 0)
return -1;
if (plane.buffer_.get())
memcpy(buffer_.get(), plane.buffer_.get(), plane.plane_size_);
stride_ = plane.stride_;
plane_size_ = plane.plane_size_;
return 0;
}
int Plane::Copy(int size, int stride, const uint8_t* buffer) {
if (MaybeResize(size) < 0)
return -1;
memcpy(buffer_.get(), buffer, size);
plane_size_ = size;
stride_ = stride;
return 0;
}
void Plane::Swap(Plane& plane) {
std::swap(stride_, plane.stride_);
std::swap(allocated_size_, plane.allocated_size_);
std::swap(plane_size_, plane.plane_size_);
buffer_.swap(plane.buffer_);
}
} // namespace webrtc

75
webrtc/common_video/plane.h
View File

@ -1,75 +0,0 @@
/*
* Copyright (c) 2012 The WebRTC project authors. All Rights Reserved.
*
* Use of this source code is governed by a BSD-style license
* that can be found in the LICENSE file in the root of the source
* tree. An additional intellectual property rights grant can be found
* in the file PATENTS. All contributing project authors may
* be found in the AUTHORS file in the root of the source tree.
*/
#ifndef COMMON_VIDEO_PLANE_H
#define COMMON_VIDEO_PLANE_H
#include "webrtc/base/scoped_ptr.h"
#include "webrtc/system_wrappers/include/aligned_malloc.h"
#include "webrtc/typedefs.h"
namespace webrtc {
// Helper class for VideoFrame: Store plane data and perform basic plane
// operations.
class Plane {
public:
Plane();
~Plane();
// CreateEmptyPlane - set allocated size, actual plane size and stride:
// If current size is smaller than current size, then a buffer of sufficient
// size will be allocated.
// Return value: 0 on success ,-1 on error.
int CreateEmptyPlane(int allocated_size, int stride, int plane_size);
// Copy the entire plane data.
// Return value: 0 on success ,-1 on error.
int Copy(const Plane& plane);
// Copy buffer: If current size is smaller
// than current size, then a buffer of sufficient size will be allocated.
// Return value: 0 on success ,-1 on error.
int Copy(int size, int stride, const uint8_t* buffer);
// Swap plane data.
void Swap(Plane& plane);
// Get allocated size.
int allocated_size() const {return allocated_size_;}
// Set actual size.
void ResetSize() {plane_size_ = 0;}
// Return true is plane size is zero, false if not.
bool IsZeroSize() const {return plane_size_ == 0;}
// Get stride value.
int stride() const {return stride_;}
// Return data pointer.
const uint8_t* buffer() const {return buffer_.get();}
// Overloading with non-const.
uint8_t* buffer() {return buffer_.get();}
private:
// Resize when needed: If current allocated size is less than new_size, buffer
// will be updated. Old data will be copied to new buffer.
// Return value: 0 on success ,-1 on error.
int MaybeResize(int new_size);
rtc::scoped_ptr<uint8_t, AlignedFreeDeleter> buffer_;
int allocated_size_;
int plane_size_;
int stride_;
}; // Plane
} // namespace webrtc
#endif // COMMON_VIDEO_PLANE_H