NekoCWD/libcamera
NekoCWD/libcamera
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages 7 Wiki Activity Actions

test: v4l2_videodevice: Switch to FrameBuffer interface

Browse source 
The V4L2VideoDevice class can now operate using a FrameBuffer interface,
switch all test cases to use it.

Signed-off-by: Niklas Söderlund <niklas.soderlund@ragnatech.se>
Reviewed-by: Laurent Pinchart <laurent.pinchart@ideasonboard.com>
This commit is contained in:
Niklas Söderlund 2019-12-18 18:47:45 +01:00
parent cadae67e45
commit f0d928b56e
6 changed files with 48 additions and 65 deletions
Download patch file Download diff file Expand all files Collapse all files

28
test/v4l2_videodevice/buffer_sharing.cpp
View file

@ -73,16 +73,14 @@ protected:
return TestFail; return TestFail;
} }
pool_.createBuffers(bufferCount); ret = capture_->exportBuffers(bufferCount, &buffers_);
if (ret < 0) {
ret = capture_->exportBuffers(&pool_); std::cout << "Failed to allocate buffers" << std::endl;
if (ret) {
std::cout << "Failed to export buffers" << std::endl;
return TestFail; return TestFail;
} }
ret = output_->importBuffers(&pool_); ret = output_->importBuffers(bufferCount);
if (ret) { if (ret < 0) {
std::cout << "Failed to import buffers" << std::endl; std::cout << "Failed to import buffers" << std::endl;
return TestFail; return TestFail;
} }
@ -90,7 +88,7 @@ protected:
return 0; return 0;
} }
void captureBufferReady(Buffer *buffer) void captureBufferReady(FrameBuffer *buffer)
{ {
const FrameMetadata &metadata = buffer->metadata(); const FrameMetadata &metadata = buffer->metadata();
@ -103,7 +101,7 @@ protected:
framesCaptured_++; framesCaptured_++;
} }
void outputBufferReady(Buffer *buffer) void outputBufferReady(FrameBuffer *buffer)
{ {
const FrameMetadata &metadata = buffer->metadata(); const FrameMetadata &metadata = buffer->metadata();
@ -122,13 +120,15 @@ protected:
Timer timeout; Timer timeout;
int ret; int ret;
capture_->bufferReady.connect(this, &BufferSharingTest::captureBufferReady); capture_->frameBufferReady.connect(this, &BufferSharingTest::captureBufferReady);
output_->bufferReady.connect(this, &BufferSharingTest::outputBufferReady); output_->frameBufferReady.connect(this, &BufferSharingTest::outputBufferReady);
std::vector<std::unique_ptr<Buffer>> buffers; for (const std::unique_ptr<FrameBuffer> &buffer : buffers_) {
buffers = capture_->queueAllBuffers(); if (capture_->queueBuffer(buffer.get())) {
if (buffers.empty()) std::cout << "Failed to queue buffer" << std::endl;
return TestFail; return TestFail;
}
}
ret = capture_->streamOn(); ret = capture_->streamOn();
if (ret) { if (ret) {

18
test/v4l2_videodevice/capture_async.cpp
View file

@ -20,7 +20,7 @@ public:
CaptureAsyncTest() CaptureAsyncTest()
: V4L2VideoDeviceTest("vimc", "Raw Capture 0"), frames(0) {} : V4L2VideoDeviceTest("vimc", "Raw Capture 0"), frames(0) {}
void receiveBuffer(Buffer *buffer) void receiveBuffer(FrameBuffer *buffer)
{ {
std::cout << "Buffer received" << std::endl; std::cout << "Buffer received" << std::endl;
frames++; frames++;
@ -38,18 +38,18 @@ protected:
Timer timeout; Timer timeout;
int ret; int ret;
pool_.createBuffers(bufferCount); ret = capture_->exportBuffers(bufferCount, &buffers_);
if (ret < 0)
ret = capture_->exportBuffers(&pool_);
if (ret)
return TestFail; return TestFail;
capture_->bufferReady.connect(this, &CaptureAsyncTest::receiveBuffer); capture_->frameBufferReady.connect(this, &CaptureAsyncTest::receiveBuffer);
std::vector<std::unique_ptr<Buffer>> buffers; for (const std::unique_ptr<FrameBuffer> &buffer : buffers_) {
buffers = capture_->queueAllBuffers(); if (capture_->queueBuffer(buffer.get())) {
if (buffers.empty()) std::cout << "Failed to queue buffer" << std::endl;
return TestFail; return TestFail;
}
}
ret = capture_->streamOn(); ret = capture_->streamOn();
if (ret) if (ret)

11
test/v4l2_videodevice/request_buffers.cpp
View file

@ -16,17 +16,10 @@ public:
protected: protected:
int run() int run()
{ {
/*
* TODO:
* Test invalid requests
* Test different buffer allocations
*/
const unsigned int bufferCount = 8; const unsigned int bufferCount = 8;
pool_.createBuffers(bufferCount); int ret = capture_->exportBuffers(bufferCount, &buffers_);
if (ret != bufferCount)
int ret = capture_->exportBuffers(&pool_);
if (ret)
return TestFail; return TestFail;
return TestPass; return TestPass;

6
test/v4l2_videodevice/stream_on_off.cpp
View file

@ -17,10 +17,8 @@ protected:
{ {
const unsigned int bufferCount = 8; const unsigned int bufferCount = 8;
pool_.createBuffers(bufferCount); int ret = capture_->exportBuffers(bufferCount, &buffers_);
if (ret < 0)
int ret = capture_->exportBuffers(&pool_);
if (ret)
return TestFail; return TestFail;
ret = capture_->streamOn(); ret = capture_->streamOn();

42
test/v4l2_videodevice/v4l2_m2mdevice.cpp
View file

@ -29,7 +29,7 @@ public:
{ {
} }
void outputBufferComplete(Buffer *buffer) void outputBufferComplete(FrameBuffer *buffer)
{ {
cout << "Received output buffer" << endl; cout << "Received output buffer" << endl;
@ -39,7 +39,7 @@ public:
vim2m_->output()->queueBuffer(buffer); vim2m_->output()->queueBuffer(buffer);
} }
void receiveCaptureBuffer(Buffer *buffer) void receiveCaptureBuffer(FrameBuffer *buffer)
{ {
cout << "Received capture buffer" << endl; cout << "Received capture buffer" << endl;
@ -112,39 +112,31 @@ protected:
return TestFail; return TestFail;
} }
capturePool_.createBuffers(bufferCount); ret = capture->exportBuffers(bufferCount, &captureBuffers_);
outputPool_.createBuffers(bufferCount); if (ret < 0) {
ret = capture->exportBuffers(&capturePool_);
if (ret) {
cerr << "Failed to export Capture Buffers" << endl; cerr << "Failed to export Capture Buffers" << endl;
return TestFail; return TestFail;
} }
ret = output->exportBuffers(&outputPool_); ret = output->exportBuffers(bufferCount, &outputBuffers_);
if (ret) { if (ret < 0) {
cerr << "Failed to export Output Buffers" << endl; cerr << "Failed to export Output Buffers" << endl;
return TestFail; return TestFail;
} }
capture->bufferReady.connect(this, &V4L2M2MDeviceTest::receiveCaptureBuffer); capture->frameBufferReady.connect(this, &V4L2M2MDeviceTest::receiveCaptureBuffer);
output->bufferReady.connect(this, &V4L2M2MDeviceTest::outputBufferComplete); output->frameBufferReady.connect(this, &V4L2M2MDeviceTest::outputBufferComplete);
std::vector<std::unique_ptr<Buffer>> captureBuffers; for (const std::unique_ptr<FrameBuffer> &buffer : captureBuffers_) {
captureBuffers = capture->queueAllBuffers(); if (capture->queueBuffer(buffer.get())) {
if (captureBuffers.empty()) { std::cout << "Failed to queue capture buffer" << std::endl;
cerr << "Failed to queue all Capture Buffers" << endl;
return TestFail; return TestFail;
} }
}
/* We can't "queueAllBuffers()" on an output device, so we do it manually */ for (const std::unique_ptr<FrameBuffer> &buffer : outputBuffers_) {
std::vector<std::unique_ptr<Buffer>> outputBuffers; if (output->queueBuffer(buffer.get())) {
for (unsigned int i = 0; i < outputPool_.count(); ++i) { std::cout << "Failed to queue output buffer" << std::endl;
Buffer *buffer = new Buffer(i);
outputBuffers.emplace_back(buffer);
ret = output->queueBuffer(buffer);
if (ret) {
cerr << "Failed to queue output buffer" << i << endl;
return TestFail; return TestFail;
} }
} }
@ -202,8 +194,8 @@ private:
std::shared_ptr<MediaDevice> media_; std::shared_ptr<MediaDevice> media_;
V4L2M2MDevice *vim2m_; V4L2M2MDevice *vim2m_;
BufferPool capturePool_; std::vector<std::unique_ptr<FrameBuffer>> captureBuffers_;
BufferPool outputPool_; std::vector<std::unique_ptr<FrameBuffer>> outputBuffers_;
unsigned int outputFrames_; unsigned int outputFrames_;
unsigned int captureFrames_; unsigned int captureFrames_;

2
test/v4l2_videodevice/v4l2_videodevice_test.h
View file

@ -41,7 +41,7 @@ protected:
CameraSensor *sensor_; CameraSensor *sensor_;
V4L2Subdevice *debayer_; V4L2Subdevice *debayer_;
V4L2VideoDevice *capture_; V4L2VideoDevice *capture_;
BufferPool pool_; std::vector<std::unique_ptr<FrameBuffer>> buffers_;
}; };
#endif /* __LIBCAMERA_V4L2_DEVICE_TEST_H_ */ #endif /* __LIBCAMERA_V4L2_DEVICE_TEST_H_ */