Revamp API again and start implementing C and Java wrapper shells.

This commit is contained in:
Peter Johnson
2016-08-25 23:13:48 -07:00
parent c25c62e0af
commit aec16a934f
13 changed files with 1720 additions and 273 deletions

View File

@@ -11,213 +11,337 @@
using namespace cs;
bool Property::GetBoolean() const {
namespace cs {
//
// Property Functions
//
CS_PropertyType GetPropertyType(CS_Property property, CS_Status* status) {
return CS_PROP_NONE; // TODO
}
bool GetBooleanProperty(CS_Property property, CS_Status* status) {
return false; // TODO
}
void Property::SetBoolean(bool value) {
void SetBooleanProperty(CS_Property property, bool value, CS_Status* status) {
// TODO
}
double Property::GetDouble() const {
return 0; // TODO
double GetDoubleProperty(CS_Property property, CS_Status* status) {
return 0.0; // TODO
}
void Property::SetDouble(double value) {
void SetDoubleProperty(CS_Property property, double value, CS_Status* status) {
// TODO
}
double Property::GetMin() const {
return std::numeric_limits<double>::min(); // TODO
double GetDoublePropertyMin(CS_Property property, CS_Status* status) {
return 0.0; // TODO
}
double Property::GetMax() const {
return std::numeric_limits<double>::max(); // TODO
double GetDoublePropertyMax(CS_Property property, CS_Status* status) {
return 0.0; // TODO
}
std::string Property::GetString() const {
std::string GetStringProperty(CS_Property property, CS_Status* status) {
return ""; // TODO
}
void Property::SetString(llvm::StringRef value) {
void GetStringProperty(CS_Property property, llvm::SmallVectorImpl<char>& value,
CS_Status* status) {
// TODO
}
int Property::GetEnum() const {
void SetStringProperty(CS_Property property, llvm::StringRef value,
CS_Status* status) {
// TODO
}
int GetEnumProperty(CS_Property property, CS_Status* status) {
return 0; // TODO
}
void Property::SetEnum(int value) {
void SetEnumProperty(CS_Property property, int value, CS_Status* status) {
// TODO
}
std::vector<std::string> Property::GetChoices() const {
return std::vector<std::string>(); // TODO
std::vector<std::string> GetEnumPropertyChoices(CS_Property property,
CS_Status* status) {
return std::vector<std::string>{}; // TODO
}
VideoSource::~VideoSource() {
// TODO
//
// Source/Sink Functions
//
CS_Property GetSourceProperty(CS_Source handle, llvm::StringRef name,
CS_Status* status) {
return 0; // TODO
}
std::string VideoSource::GetDescription() const {
//
// Source Creation Functions
//
CS_Source CreateUSBSourceDev(llvm::StringRef name, int dev, CS_Status* status) {
return 0; // TODO
}
CS_Source CreateUSBSourcePath(llvm::StringRef name, llvm::StringRef path,
CS_Status* status) {
return 0; // TODO
}
CS_Source CreateHTTPSource(llvm::StringRef name, llvm::StringRef url,
CS_Status* status) {
return 0; // TODO
}
CS_Source CreateCvSource(llvm::StringRef name, int numChannels,
CS_Status* status) {
return 0; // TODO
}
//
// Source Functions
//
std::string GetSourceName(CS_Source source, CS_Status* status) {
return ""; // TODO
}
uint64_t VideoSource::GetLastFrameTime() const {
void GetSourceName(CS_Source sink, llvm::SmallVectorImpl<char>& name,
CS_Status* status) {
// TODO
}
std::string GetSourceDescription(CS_Source source, CS_Status* status) {
return ""; // TODO
}
void GetSourceDescription(CS_Source source, llvm::SmallVectorImpl<char>& desc,
CS_Status* status) {
// TODO
}
uint64_t GetSourceLastFrameTime(CS_Source source, CS_Status* status) {
return 0; // TODO
}
int VideoSource::GetNumChannels() const {
int GetSourceNumChannels(CS_Source source, CS_Status* status) {
return 0; // TODO
}
bool VideoSource::IsConnected() const {
bool IsSourceConnected(CS_Source source, CS_Status* status) {
return false; // TODO
}
Property VideoSource::GetProperty(llvm::StringRef name) {
return Property(); // TODO
CS_Source CopySource(CS_Source source, CS_Status* status) {
return source; // TODO
}
std::vector<std::shared_ptr<VideoSource>> VideoSource::EnumerateSources() {
return std::vector<std::shared_ptr<VideoSource>>(); // TODO
}
std::shared_ptr<CameraSource> CameraSource::CreateUSB(llvm::StringRef name,
int dev) {
return nullptr; // TODO
}
std::shared_ptr<CameraSource> CameraSource::CreateUSB(llvm::StringRef name,
llvm::StringRef path) {
return nullptr; // TODO
}
std::shared_ptr<CameraSource> CameraSource::CreateHTTP(llvm::StringRef name,
llvm::StringRef url) {
return nullptr; // TODO
}
std::vector<USBCameraInfo> CameraSource::EnumerateUSBCameras() {
return std::vector<USBCameraInfo>(); // TODO
}
void CvSource::PutImage(int channel, cv::Mat* image) {
void ReleaseSource(CS_Source source, CS_Status* status) {
// TODO
}
void CvSource::NotifyFrame() {
//
// OpenCV Source Functions
//
void PutSourceImage(CS_Source source, int channel, cv::Mat* image,
CS_Status* status) {
// TODO
}
void CvSource::PutFrame(cv::Mat* image) {
PutImage(0, image);
NotifyFrame();
}
void CvSource::NotifyError(llvm::StringRef msg) {
void NotifySourceFrame(CS_Source source, CS_Status* status) {
// TODO
}
void CvSource::SetConnected(bool connected) {
void PutSourceFrame(CS_Source source, cv::Mat* image, CS_Status* status) {
// TODO
}
Property CvSource::CreateProperty(llvm::StringRef name, Property::Type type) {
return Property(); // TODO
}
Property CvSource::CreateProperty(
llvm::StringRef name, Property::Type type,
std::function<void(llvm::StringRef)> onChange) {
return Property(); // TODO
}
void CvSource::RemoveProperty(llvm::StringRef name) {
void NotifySourceError(CS_Source source, llvm::StringRef msg,
CS_Status* status) {
// TODO
}
std::shared_ptr<CvSource> CvSource::Create(llvm::StringRef name,
int nChannels) {
return nullptr; // TODO
}
VideoSink::~VideoSink() {
void SetSourceConnected(CS_Source source, bool connected, CS_Status* status) {
// TODO
}
std::string VideoSink::GetDescription() const {
return ""; // TODO
}
void VideoSink::SetSource(std::shared_ptr<VideoSource> source) {
// TODO
}
Property VideoSink::GetSourceProperty(llvm::StringRef name) {
return Property(); // TODO
}
std::vector<std::shared_ptr<VideoSink>> VideoSink::EnumerateSinks() {
return std::vector<std::shared_ptr<VideoSink>>(); // TODO
}
void ServerSink::SetSourceChannel(int channel) {
// TODO
}
std::shared_ptr<ServerSink> ServerSink::CreateHTTP(
llvm::StringRef name, llvm::StringRef listenAddress, int port) {
return nullptr; // TODO
}
uint64_t CvSink::WaitForFrame() const {
CS_Property CreateSourceProperty(CS_Source source, llvm::StringRef name,
CS_PropertyType type, CS_Status* status) {
return 0; // TODO
}
bool CvSink::GetImage(int channel, cv::Mat* image) const {
return false; // TODO
}
uint64_t CvSink::FrameGrab(cv::Mat* image) const {
CS_Property CreateSourcePropertyCallback(
CS_Source source, llvm::StringRef name, CS_PropertyType type,
std::function<void(llvm::StringRef name, CS_Property property)> onChange,
CS_Status* status) {
return 0; // TODO
}
std::string CvSink::GetError() const {
void RemoveSourceProperty(CS_Source source, llvm::StringRef name,
CS_Status* status) {
// TODO
}
//
// Sink Creation Functions
//
CS_Sink CreateHTTPSink(llvm::StringRef name, llvm::StringRef listenAddress,
int port, CS_Status* status) {
return 0; // TODO
}
CS_Sink CreateCvSink(llvm::StringRef name, CS_Status* status) {
return 0; // TODO
}
CS_Sink CreateCvSinkCallback(llvm::StringRef name,
std::function<void(uint64_t time)> processFrame,
CS_Status* status) {
return 0; // TODO
}
//
// Sink Functions
//
std::string GetSinkName(CS_Sink sink, CS_Status* status) {
return ""; // TODO
}
void CvSink::SetEnabled(bool enabled) {
void GetSinkName(CS_Sink sink, llvm::SmallVectorImpl<char>& name,
CS_Status* status) {
// TODO
}
std::shared_ptr<CvSink> CvSink::Create(llvm::StringRef name) {
return nullptr; // TODO
std::string GetSinkDescription(CS_Sink sink, CS_Status* status) {
return ""; // TODO
}
std::shared_ptr<CvSink> CvSink::Create(
llvm::StringRef name, std::function<void(uint64_t time)> processFrame) {
return nullptr; // TODO
void GetSinkDescription(CS_Sink sink, llvm::SmallVectorImpl<char>& desc,
CS_Status* status) {
// TODO
}
int cs::AddSourceListener(
std::function<void(llvm::StringRef name, std::shared_ptr<VideoSource>, int)>
void SetSinkSource(CS_Sink sink, CS_Source source, CS_Status* status) {
// TODO
}
CS_Source GetSinkSource(CS_Sink sink, CS_Status* status) {
return 0; // TODO
}
CS_Sink CopySink(CS_Sink sink, CS_Status* status) {
return sink; // TODO
}
void ReleaseSink(CS_Sink sink, CS_Status* status) {
// TODO
}
//
// Server Sink (e.g. HTTP) Functions
//
void SetSinkSourceChannel(CS_Sink sink, int channel, CS_Status* status) {
// TODO
}
//
// OpenCV Sink Functions
//
uint64_t SinkWaitForFrame(CS_Sink sink, CS_Status* status) {
return 0; // TODO
}
bool GetSinkImage(CS_Sink sink, int channel, cv::Mat* image,
CS_Status* status) {
return false; // TODO
}
uint64_t GrabSinkFrame(CS_Sink sink, cv::Mat* image, CS_Status* status) {
return 0; // TODO
}
std::string GetSinkError(CS_Sink sink, CS_Status* status) {
return ""; // TODO
}
void GetSinkError(CS_Sink sink, llvm::SmallVectorImpl<char> msg,
CS_Status* status) {
// TODO
}
void SetSinkEnabled(CS_Sink sink, bool enabled, CS_Status* status) {
// TODO
}
//
// Listener Functions
//
CS_Listener AddSourceListener(
std::function<void(llvm::StringRef name, CS_Source source, int event)>
callback,
int eventMask) {
int eventMask, CS_Status* status) {
return 0; // TODO
}
void cs::RemoveSourceListener(int handle) {
void RemoveSourceListener(CS_Listener handle, CS_Status* status) {
// TODO
}
int cs::AddSinkListener(
std::function<void(llvm::StringRef name, std::shared_ptr<VideoSink>, int)>
callback,
int eventMask) {
CS_Listener AddSinkListener(
std::function<void(llvm::StringRef name, CS_Sink sink, int event)> callback,
int eventMask, CS_Status* status) {
return 0; // TODO
}
void cs::RemoveSinkListener(int handle) {
void RemoveSinkListener(CS_Listener handle, CS_Status* status) {
// TODO
}
//
// Utility Functions
//
void EnumerateSourceHandles(llvm::SmallVectorImpl<CS_Source>& handles,
CS_Status* status) {
// TODO
}
void EnumerateSinkHandles(llvm::SmallVectorImpl<CS_Sink>& handles,
CS_Status* status) {
// TODO
}
std::vector<VideoSource> VideoSource::EnumerateSources() {
std::vector<VideoSource> sources;
llvm::SmallVector<int, 16> handles;
CS_Status status = 0;
EnumerateSourceHandles(handles, &status);
sources.reserve(handles.size());
for (int handle : handles)
sources.emplace_back(VideoSource{handle});
return sources;
}
std::vector<VideoSink> VideoSink::EnumerateSinks() {
std::vector<VideoSink> sinks;
llvm::SmallVector<int, 16> handles;
CS_Status status = 0;
EnumerateSinkHandles(handles, &status);
sinks.reserve(handles.size());
for (int handle : handles)
sinks.emplace_back(VideoSink{handle});
return sinks;
}
} // namespace cs