size_t NtripStream::write(const uint8_t* buffer, size_t length) {
if (!_tcp_stream) {
return 0;
}
std::unique_lock<std::mutex> lock(_internal_mutex, std::defer_lock);
if (!lock.try_lock()) {
ROS_INFO("Try lock failed.");
return 0;
}
if (_tcp_stream->get_status() != Stream::Status::CONNECTED) {
return 0;
}
std::string data(reinterpret_cast<const char*>(buffer), length);
data = _write_data_prefix + data;
size_t ret = _tcp_stream->write(reinterpret_cast<const uint8_t*>(data.data()),
data.size());
if (ret != data.size()) {
ROS_ERROR_STREAM("Send ntrip data size " << data.size() << ", return "
<< ret);
_status = Stream::Status::ERROR;
return 0;
}
return length;
}
void
storebatch (batch const& batch)
{
hyperleveldb::writebatch wb;
encodedblob encoded;
for (auto const& e : batch)
{
encoded.prepare (e);
wb.put (
hyperleveldb::slice (reinterpret_cast <char const*> (
encoded.getkey ()), m_keybytes),
hyperleveldb::slice (reinterpret_cast <char const*> (
encoded.getdata ()), encoded.getsize ()));
}
hyperleveldb::writeoptions const options;
auto ret = m_db->write (options, &wb);
if (!ret.ok ())
throw std::runtime_error ("storebatch failed: " + ret.tostring());
}
void runTest(std::unique_ptr<VideoFrameWriter> writer)
{
writer->open();
ptime timestamp = microsec_clock::universal_time();
vector<unsigned char> buffer(width * width * 3);
for (int i = 0; i < frames; i++){
for (int r = 0, p = 0; r < width; r++){
for (int c = 0; c < width; c++, p += 3){
buffer[p] = width - c;
buffer[p + 2] = r;
}
}
int boxPos = (i * (width - box_size)) / frames;
for (int r = 0; r < box_size; r++){
for (int c = 0; c < box_size; c++){
int p = (boxPos + r) * width * 3 + (boxPos + c) * 3;
buffer[p] = 255;
buffer[p + 1] = i < 5 ? 0 : 255;
buffer[p + 2] = i < 5 ? 0 : 255;
}
}
TimestampedUnsignedCharVector message(timestamp, buffer);
writer->write(TimestampedVideoFrame(width, width, 3, message));
timestamp += milliseconds(frame_length);
}
writer->close();
}
std::unique_ptr<Image> ImageType_VGA_Planar_RawBase::create(
std::unique_ptr<stream::inout> content, SuppData& suppData) const
{
content->truncate(64000);
char buf[64];
memset(buf, 0, 64);
for (int i = 0; i < 1000; i++) content->write(buf, 64);
return this->open(std::move(content), suppData);
}
/// \brief Write a block of data, and get the offset that it starts at.
/// \param Bytes the array of bytes to be written.
/// \return the offset that this block was written at.
///
offset_uint write(llvm::ArrayRef<char> Bytes) {
// If the stream doesn't exist, silently ignore the write request.
if (!Out)
return noOffset();
auto const Size = Bytes.size();
Out->write(Bytes.data(), Size);
// Update the current offset and return the original value.
auto const WrittenAt = Offset;
Offset += Size;
return WrittenAt;
}
void operator()() {
osmium::thread::set_thread_name("_osmium_write");
try {
while (true) {
std::string data = m_queue.pop();
if (at_end_of_data(data)) {
break;
}
m_compressor->write(data);
}
m_compressor->close();
m_promise.set_value(true);
} catch (...) {
m_promise.set_exception(std::current_exception());
m_queue.drain();
}
}
void AttachmentReaderTest::testMultipleReads(bool closeWriterBeforeReading) {
init();
auto numWritten = m_writer->write(m_testPattern.data(), m_testPattern.size());
ASSERT_EQ(numWritten, static_cast<ssize_t>(m_testPattern.size()));
AttachmentReader::ReadStatus terminalStatus = AttachmentReader::ReadStatus::OK_WOULDBLOCK;
if (closeWriterBeforeReading) {
m_writer->close();
terminalStatus = AttachmentReader::ReadStatus::CLOSED;
}
std::vector<uint8_t> result(TEST_SDS_PARTIAL_READ_AMOUNT_IN_BYTES);
auto readStatus = InProcessAttachmentReader::ReadStatus::OK;
int totalBytesRead = 0;
bool done = false;
int iterations = 0;
int iterationsMax = 10;
while (!done && iterations < iterationsMax) {
auto bytesRead = m_reader->read(result.data(), result.size(), &readStatus);
if (terminalStatus == readStatus) {
done = true;
}
for (size_t i = 0; i < bytesRead; ++i) {
EXPECT_EQ(result[i], m_testPattern[i + totalBytesRead]);
}
totalBytesRead += bytesRead;
iterations++;
}
// Not only was all the data read, but the reader remained open.
ASSERT_NE(iterations, iterationsMax);
ASSERT_EQ(readStatus, terminalStatus);
ASSERT_EQ(totalBytesRead, static_cast<ssize_t>(m_testPattern.size()));
}
int Plugin_Write(char *buf, int len)
{
auto result = forwarder->Write(buf, len);
if (pan_factor != 0)
{
int lenght = len / num_channels;
if (bits_per_sample == 16)
{
auto stereo = reinterpret_cast<short *>(buf);
int i = pan_factor < 0 ? 1 : 0;
float abs_pan = 1.0f - abs(pan_factor);
for(; i<lenght; i+=num_channels)
stereo[i] = static_cast<short>(stereo[i] * abs_pan);
}
}
return streamManager->write((PBYTE)buf, len) ? 0 : 1;
}
void HTTP2StreamTest::SetUp() {
AlexaClientSDKInit::initialize(std::vector<std::shared_ptr<std::istream>>());
m_testableConsumer = std::make_shared<TestableConsumer>();
m_testString = createRandomAlphabetString(TEST_EXCEPTION_STRING_LENGTH);
m_dataBegin = const_cast<char*>(m_testString.c_str());
/// Create a SDS buffer and using a @c Writer, write a string into the buffer
size_t bufferSize = InProcessSDS::calculateBufferSize(SDS_WORDS, SDS_WORDSIZE, SDS_MAXREADERS);
auto buffer = std::make_shared<avsCommon::utils::sds::InProcessSDS::Buffer>(bufferSize);
std::shared_ptr<InProcessSDS> stream = InProcessSDS::create(buffer, SDS_WORDSIZE, SDS_MAXREADERS);
ASSERT_NE(stream, nullptr);
m_writer = stream->createWriter(InProcessSDS::Writer::Policy::NONBLOCKABLE);
ASSERT_NE(m_writer, nullptr);
ASSERT_EQ(TEST_EXCEPTION_STRING_LENGTH, m_writer->write(m_dataBegin, TEST_EXCEPTION_STRING_LENGTH));
/// Create an attachment Reader for @c m_MessageRequest
m_attachmentReader = InProcessAttachmentReader::create(InProcessSDS::Reader::Policy::NONBLOCKING, stream);
m_MessageRequest = std::make_shared<MessageRequest>("");
m_MessageRequest->addAttachmentReader(AUDIO_ATTACHMENT_FIELD_NAME, m_attachmentReader);
m_MessageRequest->addAttachmentReader(KWD_METADATA_ATTACHMENT_FIELD_NAME, m_attachmentReader);
ASSERT_NE(m_MessageRequest, nullptr);
m_mockMessageRequest = std::make_shared<MockMessageRequest>();
ASSERT_NE(m_mockMessageRequest, nullptr);
m_attachmentManager = std::make_shared<AttachmentManager>(AttachmentManager::AttachmentType::IN_PROCESS);
m_testableStream = std::make_shared<HTTP2Stream>(m_testableConsumer, m_attachmentManager);
ASSERT_NE(m_testableStream, nullptr);
ASSERT_TRUE(m_testableStream->initPost(LIBCURL_TEST_URL, LIBCURL_TEST_AUTH_STRING, m_mockMessageRequest));
m_readTestableStream = std::make_shared<HTTP2Stream>(m_testableConsumer, m_attachmentManager);
ASSERT_NE(m_readTestableStream, nullptr);
ASSERT_TRUE(m_readTestableStream->initPost(LIBCURL_TEST_URL, LIBCURL_TEST_AUTH_STRING, m_MessageRequest));
}
bool NtripStream::connect() {
if (_is_login) {
return true;
}
if (!_tcp_stream) {
ROS_ERROR("New tcp stream failed.");
return true;
}
if (!_tcp_stream->connect()) {
_status = Stream::Status::DISCONNECTED;
ROS_ERROR("Tcp connect failed.");
return false;
}
uint8_t buffer[2048];
size_t size = 0;
size_t try_times = 0;
size = _tcp_stream->write(
reinterpret_cast<const uint8_t*>(_login_data.data()), _login_data.size());
if (size != _login_data.size()) {
_tcp_stream->disconnect();
_status = Stream::Status::ERROR;
ROS_ERROR("Send ntrip request failed.");
return false;
}
bzero(buffer, sizeof(buffer));
ROS_INFO("Read ntrip response.");
size = _tcp_stream->read(buffer, sizeof(buffer) - 1);
while ((size == 0) && (try_times < 3)) {
sleep(1);
size = _tcp_stream->read(buffer, sizeof(buffer) - 1);
++try_times;
}
if (!size) {
_tcp_stream->disconnect();
_status = Stream::Status::DISCONNECTED;
ROS_ERROR("No response from ntripcaster.");
return false;
}
if (std::strstr(reinterpret_cast<char*>(buffer), "ICY 200 OK\r\n")) {
_status = Stream::Status::CONNECTED;
_is_login = true;
ROS_INFO("Ntrip login successfully.");
return true;
}
if (std::strstr(reinterpret_cast<char*>(buffer), "SOURCETABLE 200 OK\r\n")) {
ROS_ERROR_STREAM("Mountpoint " << _mountpoint << " not exist.");
}
if (std::strstr(reinterpret_cast<char*>(buffer), "HTTP/")) {
ROS_ERROR("Authentication failed.");
}
ROS_INFO_STREAM("No expect data.");
ROS_INFO_STREAM("Recv data length: " << size);
// ROS_INFO_STREAM("Data from server: " << reinterpret_cast<char*>(buffer));
_tcp_stream->disconnect();
_status = Stream::Status::ERROR;
return false;
}
void OutputStream_WriteCallback(int raw_data_count, char * buffer, int lenght)
{
streamManager->write((PBYTE)buffer, lenght);
}
