| /* | |
| * Copyright 2004 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. | |
| */ | |
| #if defined(WEBRTC_POSIX) | |
| #include <sys/file.h> | |
| #endif // WEBRTC_POSIX | |
| #include <sys/types.h> | |
| #include <sys/stat.h> | |
| #include <errno.h> | |
| #include <algorithm> | |
| #include <string> | |
| #include "webrtc/base/basictypes.h" | |
| #include "webrtc/base/common.h" | |
| #include "webrtc/base/logging.h" | |
| #include "webrtc/base/messagequeue.h" | |
| #include "webrtc/base/stream.h" | |
| #include "webrtc/base/stringencode.h" | |
| #include "webrtc/base/stringutils.h" | |
| #include "webrtc/base/thread.h" | |
| #include "webrtc/base/timeutils.h" | |
| #if defined(WEBRTC_WIN) | |
| #include "webrtc/base/win32.h" | |
| #define fileno _fileno | |
| #endif | |
| namespace rtc { | |
| /////////////////////////////////////////////////////////////////////////////// | |
| // StreamInterface | |
| /////////////////////////////////////////////////////////////////////////////// | |
| StreamInterface::~StreamInterface() { | |
| } | |
| StreamResult StreamInterface::WriteAll(const void* data, size_t data_len, | |
| size_t* written, int* error) { | |
| StreamResult result = SR_SUCCESS; | |
| size_t total_written = 0, current_written; | |
| while (total_written < data_len) { | |
| result = Write(static_cast<const char*>(data) + total_written, | |
| data_len - total_written, ¤t_written, error); | |
| if (result != SR_SUCCESS) | |
| break; | |
| total_written += current_written; | |
| } | |
| if (written) | |
| *written = total_written; | |
| return result; | |
| } | |
| StreamResult StreamInterface::ReadAll(void* buffer, size_t buffer_len, | |
| size_t* read, int* error) { | |
| StreamResult result = SR_SUCCESS; | |
| size_t total_read = 0, current_read; | |
| while (total_read < buffer_len) { | |
| result = Read(static_cast<char*>(buffer) + total_read, | |
| buffer_len - total_read, ¤t_read, error); | |
| if (result != SR_SUCCESS) | |
| break; | |
| total_read += current_read; | |
| } | |
| if (read) | |
| *read = total_read; | |
| return result; | |
| } | |
| StreamResult StreamInterface::ReadLine(std::string* line) { | |
| line->clear(); | |
| StreamResult result = SR_SUCCESS; | |
| while (true) { | |
| char ch; | |
| result = Read(&ch, sizeof(ch), NULL, NULL); | |
| if (result != SR_SUCCESS) { | |
| break; | |
| } | |
| if (ch == '\n') { | |
| break; | |
| } | |
| line->push_back(ch); | |
| } | |
| if (!line->empty()) { // give back the line we've collected so far with | |
| result = SR_SUCCESS; // a success code. Otherwise return the last code | |
| } | |
| return result; | |
| } | |
| void StreamInterface::PostEvent(Thread* t, int events, int err) { | |
| t->Post(RTC_FROM_HERE, this, MSG_POST_EVENT, | |
| new StreamEventData(events, err)); | |
| } | |
| void StreamInterface::PostEvent(int events, int err) { | |
| PostEvent(Thread::Current(), events, err); | |
| } | |
| const void* StreamInterface::GetReadData(size_t* data_len) { | |
| return NULL; | |
| } | |
| void* StreamInterface::GetWriteBuffer(size_t* buf_len) { | |
| return NULL; | |
| } | |
| bool StreamInterface::SetPosition(size_t position) { | |
| return false; | |
| } | |
| bool StreamInterface::GetPosition(size_t* position) const { | |
| return false; | |
| } | |
| bool StreamInterface::GetSize(size_t* size) const { | |
| return false; | |
| } | |
| bool StreamInterface::GetAvailable(size_t* size) const { | |
| return false; | |
| } | |
| bool StreamInterface::GetWriteRemaining(size_t* size) const { | |
| return false; | |
| } | |
| bool StreamInterface::Flush() { | |
| return false; | |
| } | |
| bool StreamInterface::ReserveSize(size_t size) { | |
| return true; | |
| } | |
| StreamInterface::StreamInterface() { | |
| } | |
| void StreamInterface::OnMessage(Message* msg) { | |
| if (MSG_POST_EVENT == msg->message_id) { | |
| StreamEventData* pe = static_cast<StreamEventData*>(msg->pdata); | |
| SignalEvent(this, pe->events, pe->error); | |
| delete msg->pdata; | |
| } | |
| } | |
| /////////////////////////////////////////////////////////////////////////////// | |
| // StreamAdapterInterface | |
| /////////////////////////////////////////////////////////////////////////////// | |
| StreamAdapterInterface::StreamAdapterInterface(StreamInterface* stream, | |
| bool owned) | |
| : stream_(stream), owned_(owned) { | |
| if (NULL != stream_) | |
| stream_->SignalEvent.connect(this, &StreamAdapterInterface::OnEvent); | |
| } | |
| StreamState StreamAdapterInterface::GetState() const { | |
| return stream_->GetState(); | |
| } | |
| StreamResult StreamAdapterInterface::Read(void* buffer, | |
| size_t buffer_len, | |
| size_t* read, | |
| int* error) { | |
| return stream_->Read(buffer, buffer_len, read, error); | |
| } | |
| StreamResult StreamAdapterInterface::Write(const void* data, | |
| size_t data_len, | |
| size_t* written, | |
| int* error) { | |
| return stream_->Write(data, data_len, written, error); | |
| } | |
| void StreamAdapterInterface::Close() { | |
| stream_->Close(); | |
| } | |
| bool StreamAdapterInterface::SetPosition(size_t position) { | |
| return stream_->SetPosition(position); | |
| } | |
| bool StreamAdapterInterface::GetPosition(size_t* position) const { | |
| return stream_->GetPosition(position); | |
| } | |
| bool StreamAdapterInterface::GetSize(size_t* size) const { | |
| return stream_->GetSize(size); | |
| } | |
| bool StreamAdapterInterface::GetAvailable(size_t* size) const { | |
| return stream_->GetAvailable(size); | |
| } | |
| bool StreamAdapterInterface::GetWriteRemaining(size_t* size) const { | |
| return stream_->GetWriteRemaining(size); | |
| } | |
| bool StreamAdapterInterface::ReserveSize(size_t size) { | |
| return stream_->ReserveSize(size); | |
| } | |
| bool StreamAdapterInterface::Flush() { | |
| return stream_->Flush(); | |
| } | |
| void StreamAdapterInterface::Attach(StreamInterface* stream, bool owned) { | |
| if (NULL != stream_) | |
| stream_->SignalEvent.disconnect(this); | |
| if (owned_) | |
| delete stream_; | |
| stream_ = stream; | |
| owned_ = owned; | |
| if (NULL != stream_) | |
| stream_->SignalEvent.connect(this, &StreamAdapterInterface::OnEvent); | |
| } | |
| StreamInterface* StreamAdapterInterface::Detach() { | |
| if (NULL != stream_) | |
| stream_->SignalEvent.disconnect(this); | |
| StreamInterface* stream = stream_; | |
| stream_ = NULL; | |
| return stream; | |
| } | |
| StreamAdapterInterface::~StreamAdapterInterface() { | |
| if (owned_) | |
| delete stream_; | |
| } | |
| void StreamAdapterInterface::OnEvent(StreamInterface* stream, | |
| int events, | |
| int err) { | |
| SignalEvent(this, events, err); | |
| } | |
| /////////////////////////////////////////////////////////////////////////////// | |
| // StreamTap | |
| /////////////////////////////////////////////////////////////////////////////// | |
| StreamTap::StreamTap(StreamInterface* stream, StreamInterface* tap) | |
| : StreamAdapterInterface(stream), tap_(), tap_result_(SR_SUCCESS), | |
| tap_error_(0) { | |
| AttachTap(tap); | |
| } | |
| StreamTap::~StreamTap() = default; | |
| void StreamTap::AttachTap(StreamInterface* tap) { | |
| tap_.reset(tap); | |
| } | |
| StreamInterface* StreamTap::DetachTap() { | |
| return tap_.release(); | |
| } | |
| StreamResult StreamTap::GetTapResult(int* error) { | |
| if (error) { | |
| *error = tap_error_; | |
| } | |
| return tap_result_; | |
| } | |
| StreamResult StreamTap::Read(void* buffer, size_t buffer_len, | |
| size_t* read, int* error) { | |
| size_t backup_read; | |
| if (!read) { | |
| read = &backup_read; | |
| } | |
| StreamResult res = StreamAdapterInterface::Read(buffer, buffer_len, | |
| read, error); | |
| if ((res == SR_SUCCESS) && (tap_result_ == SR_SUCCESS)) { | |
| tap_result_ = tap_->WriteAll(buffer, *read, NULL, &tap_error_); | |
| } | |
| return res; | |
| } | |
| StreamResult StreamTap::Write(const void* data, size_t data_len, | |
| size_t* written, int* error) { | |
| size_t backup_written; | |
| if (!written) { | |
| written = &backup_written; | |
| } | |
| StreamResult res = StreamAdapterInterface::Write(data, data_len, | |
| written, error); | |
| if ((res == SR_SUCCESS) && (tap_result_ == SR_SUCCESS)) { | |
| tap_result_ = tap_->WriteAll(data, *written, NULL, &tap_error_); | |
| } | |
| return res; | |
| } | |
| /////////////////////////////////////////////////////////////////////////////// | |
| // NullStream | |
| /////////////////////////////////////////////////////////////////////////////// | |
| NullStream::NullStream() { | |
| } | |
| NullStream::~NullStream() { | |
| } | |
| StreamState NullStream::GetState() const { | |
| return SS_OPEN; | |
| } | |
| StreamResult NullStream::Read(void* buffer, size_t buffer_len, | |
| size_t* read, int* error) { | |
| if (error) *error = -1; | |
| return SR_ERROR; | |
| } | |
| StreamResult NullStream::Write(const void* data, size_t data_len, | |
| size_t* written, int* error) { | |
| if (written) *written = data_len; | |
| return SR_SUCCESS; | |
| } | |
| void NullStream::Close() { | |
| } | |
| /////////////////////////////////////////////////////////////////////////////// | |
| // FileStream | |
| /////////////////////////////////////////////////////////////////////////////// | |
| FileStream::FileStream() : file_(NULL) { | |
| } | |
| FileStream::~FileStream() { | |
| FileStream::Close(); | |
| } | |
| bool FileStream::Open(const std::string& filename, const char* mode, | |
| int* error) { | |
| Close(); | |
| #if defined(WEBRTC_WIN) | |
| std::wstring wfilename; | |
| if (Utf8ToWindowsFilename(filename, &wfilename)) { | |
| file_ = _wfopen(wfilename.c_str(), ToUtf16(mode).c_str()); | |
| } else { | |
| if (error) { | |
| *error = -1; | |
| return false; | |
| } | |
| } | |
| #else | |
| file_ = fopen(filename.c_str(), mode); | |
| #endif | |
| if (!file_ && error) { | |
| *error = errno; | |
| } | |
| return (file_ != NULL); | |
| } | |
| bool FileStream::OpenShare(const std::string& filename, const char* mode, | |
| int shflag, int* error) { | |
| Close(); | |
| #if defined(WEBRTC_WIN) | |
| std::wstring wfilename; | |
| if (Utf8ToWindowsFilename(filename, &wfilename)) { | |
| file_ = _wfsopen(wfilename.c_str(), ToUtf16(mode).c_str(), shflag); | |
| if (!file_ && error) { | |
| *error = errno; | |
| return false; | |
| } | |
| return file_ != NULL; | |
| } else { | |
| if (error) { | |
| *error = -1; | |
| } | |
| return false; | |
| } | |
| #else | |
| return Open(filename, mode, error); | |
| #endif | |
| } | |
| bool FileStream::DisableBuffering() { | |
| if (!file_) | |
| return false; | |
| return (setvbuf(file_, NULL, _IONBF, 0) == 0); | |
| } | |
| StreamState FileStream::GetState() const { | |
| return (file_ == NULL) ? SS_CLOSED : SS_OPEN; | |
| } | |
| StreamResult FileStream::Read(void* buffer, size_t buffer_len, | |
| size_t* read, int* error) { | |
| if (!file_) | |
| return SR_EOS; | |
| size_t result = fread(buffer, 1, buffer_len, file_); | |
| if ((result == 0) && (buffer_len > 0)) { | |
| if (feof(file_)) | |
| return SR_EOS; | |
| if (error) | |
| *error = errno; | |
| return SR_ERROR; | |
| } | |
| if (read) | |
| *read = result; | |
| return SR_SUCCESS; | |
| } | |
| StreamResult FileStream::Write(const void* data, size_t data_len, | |
| size_t* written, int* error) { | |
| if (!file_) | |
| return SR_EOS; | |
| size_t result = fwrite(data, 1, data_len, file_); | |
| if ((result == 0) && (data_len > 0)) { | |
| if (error) | |
| *error = errno; | |
| return SR_ERROR; | |
| } | |
| if (written) | |
| *written = result; | |
| return SR_SUCCESS; | |
| } | |
| void FileStream::Close() { | |
| if (file_) { | |
| DoClose(); | |
| file_ = NULL; | |
| } | |
| } | |
| bool FileStream::SetPosition(size_t position) { | |
| if (!file_) | |
| return false; | |
| return (fseek(file_, static_cast<int>(position), SEEK_SET) == 0); | |
| } | |
| bool FileStream::GetPosition(size_t* position) const { | |
| ASSERT(NULL != position); | |
| if (!file_) | |
| return false; | |
| long result = ftell(file_); | |
| if (result < 0) | |
| return false; | |
| if (position) | |
| *position = result; | |
| return true; | |
| } | |
| bool FileStream::GetSize(size_t* size) const { | |
| ASSERT(NULL != size); | |
| if (!file_) | |
| return false; | |
| struct stat file_stats; | |
| if (fstat(fileno(file_), &file_stats) != 0) | |
| return false; | |
| if (size) | |
| *size = file_stats.st_size; | |
| return true; | |
| } | |
| bool FileStream::GetAvailable(size_t* size) const { | |
| ASSERT(NULL != size); | |
| if (!GetSize(size)) | |
| return false; | |
| long result = ftell(file_); | |
| if (result < 0) | |
| return false; | |
| if (size) | |
| *size -= result; | |
| return true; | |
| } | |
| bool FileStream::ReserveSize(size_t size) { | |
| // TODO: extend the file to the proper length | |
| return true; | |
| } | |
| bool FileStream::GetSize(const std::string& filename, size_t* size) { | |
| struct stat file_stats; | |
| if (stat(filename.c_str(), &file_stats) != 0) | |
| return false; | |
| *size = file_stats.st_size; | |
| return true; | |
| } | |
| bool FileStream::Flush() { | |
| if (file_) { | |
| return (0 == fflush(file_)); | |
| } | |
| // try to flush empty file? | |
| ASSERT(false); | |
| return false; | |
| } | |
| #if defined(WEBRTC_POSIX) && !defined(__native_client__) | |
| bool FileStream::TryLock() { | |
| if (file_ == NULL) { | |
| // Stream not open. | |
| ASSERT(false); | |
| return false; | |
| } | |
| return flock(fileno(file_), LOCK_EX|LOCK_NB) == 0; | |
| } | |
| bool FileStream::Unlock() { | |
| if (file_ == NULL) { | |
| // Stream not open. | |
| ASSERT(false); | |
| return false; | |
| } | |
| return flock(fileno(file_), LOCK_UN) == 0; | |
| } | |
| #endif | |
| void FileStream::DoClose() { | |
| fclose(file_); | |
| } | |
| /////////////////////////////////////////////////////////////////////////////// | |
| // MemoryStream | |
| /////////////////////////////////////////////////////////////////////////////// | |
| MemoryStreamBase::MemoryStreamBase() | |
| : buffer_(NULL), buffer_length_(0), data_length_(0), | |
| seek_position_(0) { | |
| } | |
| StreamState MemoryStreamBase::GetState() const { | |
| return SS_OPEN; | |
| } | |
| StreamResult MemoryStreamBase::Read(void* buffer, size_t bytes, | |
| size_t* bytes_read, int* error) { | |
| if (seek_position_ >= data_length_) { | |
| return SR_EOS; | |
| } | |
| size_t available = data_length_ - seek_position_; | |
| if (bytes > available) { | |
| // Read partial buffer | |
| bytes = available; | |
| } | |
| memcpy(buffer, &buffer_[seek_position_], bytes); | |
| seek_position_ += bytes; | |
| if (bytes_read) { | |
| *bytes_read = bytes; | |
| } | |
| return SR_SUCCESS; | |
| } | |
| StreamResult MemoryStreamBase::Write(const void* buffer, size_t bytes, | |
| size_t* bytes_written, int* error) { | |
| size_t available = buffer_length_ - seek_position_; | |
| if (0 == available) { | |
| // Increase buffer size to the larger of: | |
| // a) new position rounded up to next 256 bytes | |
| // b) double the previous length | |
| size_t new_buffer_length = | |
| std::max(((seek_position_ + bytes) | 0xFF) + 1, buffer_length_ * 2); | |
| StreamResult result = DoReserve(new_buffer_length, error); | |
| if (SR_SUCCESS != result) { | |
| return result; | |
| } | |
| ASSERT(buffer_length_ >= new_buffer_length); | |
| available = buffer_length_ - seek_position_; | |
| } | |
| if (bytes > available) { | |
| bytes = available; | |
| } | |
| memcpy(&buffer_[seek_position_], buffer, bytes); | |
| seek_position_ += bytes; | |
| if (data_length_ < seek_position_) { | |
| data_length_ = seek_position_; | |
| } | |
| if (bytes_written) { | |
| *bytes_written = bytes; | |
| } | |
| return SR_SUCCESS; | |
| } | |
| void MemoryStreamBase::Close() { | |
| // nothing to do | |
| } | |
| bool MemoryStreamBase::SetPosition(size_t position) { | |
| if (position > data_length_) | |
| return false; | |
| seek_position_ = position; | |
| return true; | |
| } | |
| bool MemoryStreamBase::GetPosition(size_t* position) const { | |
| if (position) | |
| *position = seek_position_; | |
| return true; | |
| } | |
| bool MemoryStreamBase::GetSize(size_t* size) const { | |
| if (size) | |
| *size = data_length_; | |
| return true; | |
| } | |
| bool MemoryStreamBase::GetAvailable(size_t* size) const { | |
| if (size) | |
| *size = data_length_ - seek_position_; | |
| return true; | |
| } | |
| bool MemoryStreamBase::ReserveSize(size_t size) { | |
| return (SR_SUCCESS == DoReserve(size, NULL)); | |
| } | |
| StreamResult MemoryStreamBase::DoReserve(size_t size, int* error) { | |
| return (buffer_length_ >= size) ? SR_SUCCESS : SR_EOS; | |
| } | |
| /////////////////////////////////////////////////////////////////////////////// | |
| MemoryStream::MemoryStream() | |
| : buffer_alloc_(NULL) { | |
| } | |
| MemoryStream::MemoryStream(const char* data) | |
| : buffer_alloc_(NULL) { | |
| SetData(data, strlen(data)); | |
| } | |
| MemoryStream::MemoryStream(const void* data, size_t length) | |
| : buffer_alloc_(NULL) { | |
| SetData(data, length); | |
| } | |
| MemoryStream::~MemoryStream() { | |
| delete [] buffer_alloc_; | |
| } | |
| void MemoryStream::SetData(const void* data, size_t length) { | |
| data_length_ = buffer_length_ = length; | |
| delete [] buffer_alloc_; | |
| buffer_alloc_ = new char[buffer_length_ + kAlignment]; | |
| buffer_ = reinterpret_cast<char*>(ALIGNP(buffer_alloc_, kAlignment)); | |
| memcpy(buffer_, data, data_length_); | |
| seek_position_ = 0; | |
| } | |
| StreamResult MemoryStream::DoReserve(size_t size, int* error) { | |
| if (buffer_length_ >= size) | |
| return SR_SUCCESS; | |
| if (char* new_buffer_alloc = new char[size + kAlignment]) { | |
| char* new_buffer = reinterpret_cast<char*>( | |
| ALIGNP(new_buffer_alloc, kAlignment)); | |
| memcpy(new_buffer, buffer_, data_length_); | |
| delete [] buffer_alloc_; | |
| buffer_alloc_ = new_buffer_alloc; | |
| buffer_ = new_buffer; | |
| buffer_length_ = size; | |
| return SR_SUCCESS; | |
| } | |
| if (error) { | |
| *error = ENOMEM; | |
| } | |
| return SR_ERROR; | |
| } | |
| /////////////////////////////////////////////////////////////////////////////// | |
| ExternalMemoryStream::ExternalMemoryStream() { | |
| } | |
| ExternalMemoryStream::ExternalMemoryStream(void* data, size_t length) { | |
| SetData(data, length); | |
| } | |
| ExternalMemoryStream::~ExternalMemoryStream() { | |
| } | |
| void ExternalMemoryStream::SetData(void* data, size_t length) { | |
| data_length_ = buffer_length_ = length; | |
| buffer_ = static_cast<char*>(data); | |
| seek_position_ = 0; | |
| } | |
| /////////////////////////////////////////////////////////////////////////////// | |
| // FifoBuffer | |
| /////////////////////////////////////////////////////////////////////////////// | |
| FifoBuffer::FifoBuffer(size_t size) | |
| : state_(SS_OPEN), buffer_(new char[size]), buffer_length_(size), | |
| data_length_(0), read_position_(0), owner_(Thread::Current()) { | |
| // all events are done on the owner_ thread | |
| } | |
| FifoBuffer::FifoBuffer(size_t size, Thread* owner) | |
| : state_(SS_OPEN), buffer_(new char[size]), buffer_length_(size), | |
| data_length_(0), read_position_(0), owner_(owner) { | |
| // all events are done on the owner_ thread | |
| } | |
| FifoBuffer::~FifoBuffer() { | |
| } | |
| bool FifoBuffer::GetBuffered(size_t* size) const { | |
| CritScope cs(&crit_); | |
| *size = data_length_; | |
| return true; | |
| } | |
| bool FifoBuffer::SetCapacity(size_t size) { | |
| CritScope cs(&crit_); | |
| if (data_length_ > size) { | |
| return false; | |
| } | |
| if (size != buffer_length_) { | |
| char* buffer = new char[size]; | |
| const size_t copy = data_length_; | |
| const size_t tail_copy = std::min(copy, buffer_length_ - read_position_); | |
| memcpy(buffer, &buffer_[read_position_], tail_copy); | |
| memcpy(buffer + tail_copy, &buffer_[0], copy - tail_copy); | |
| buffer_.reset(buffer); | |
| read_position_ = 0; | |
| buffer_length_ = size; | |
| } | |
| return true; | |
| } | |
| StreamResult FifoBuffer::ReadOffset(void* buffer, size_t bytes, | |
| size_t offset, size_t* bytes_read) { | |
| CritScope cs(&crit_); | |
| return ReadOffsetLocked(buffer, bytes, offset, bytes_read); | |
| } | |
| StreamResult FifoBuffer::WriteOffset(const void* buffer, size_t bytes, | |
| size_t offset, size_t* bytes_written) { | |
| CritScope cs(&crit_); | |
| return WriteOffsetLocked(buffer, bytes, offset, bytes_written); | |
| } | |
| StreamState FifoBuffer::GetState() const { | |
| CritScope cs(&crit_); | |
| return state_; | |
| } | |
| StreamResult FifoBuffer::Read(void* buffer, size_t bytes, | |
| size_t* bytes_read, int* error) { | |
| CritScope cs(&crit_); | |
| const bool was_writable = data_length_ < buffer_length_; | |
| size_t copy = 0; | |
| StreamResult result = ReadOffsetLocked(buffer, bytes, 0, ©); | |
| if (result == SR_SUCCESS) { | |
| // If read was successful then adjust the read position and number of | |
| // bytes buffered. | |
| read_position_ = (read_position_ + copy) % buffer_length_; | |
| data_length_ -= copy; | |
| if (bytes_read) { | |
| *bytes_read = copy; | |
| } | |
| // if we were full before, and now we're not, post an event | |
| if (!was_writable && copy > 0) { | |
| PostEvent(owner_, SE_WRITE, 0); | |
| } | |
| } | |
| return result; | |
| } | |
| StreamResult FifoBuffer::Write(const void* buffer, size_t bytes, | |
| size_t* bytes_written, int* error) { | |
| CritScope cs(&crit_); | |
| const bool was_readable = (data_length_ > 0); | |
| size_t copy = 0; | |
| StreamResult result = WriteOffsetLocked(buffer, bytes, 0, ©); | |
| if (result == SR_SUCCESS) { | |
| // If write was successful then adjust the number of readable bytes. | |
| data_length_ += copy; | |
| if (bytes_written) { | |
| *bytes_written = copy; | |
| } | |
| // if we didn't have any data to read before, and now we do, post an event | |
| if (!was_readable && copy > 0) { | |
| PostEvent(owner_, SE_READ, 0); | |
| } | |
| } | |
| return result; | |
| } | |
| void FifoBuffer::Close() { | |
| CritScope cs(&crit_); | |
| state_ = SS_CLOSED; | |
| } | |
| const void* FifoBuffer::GetReadData(size_t* size) { | |
| CritScope cs(&crit_); | |
| *size = (read_position_ + data_length_ <= buffer_length_) ? | |
| data_length_ : buffer_length_ - read_position_; | |
| return &buffer_[read_position_]; | |
| } | |
| void FifoBuffer::ConsumeReadData(size_t size) { | |
| CritScope cs(&crit_); | |
| ASSERT(size <= data_length_); | |
| const bool was_writable = data_length_ < buffer_length_; | |
| read_position_ = (read_position_ + size) % buffer_length_; | |
| data_length_ -= size; | |
| if (!was_writable && size > 0) { | |
| PostEvent(owner_, SE_WRITE, 0); | |
| } | |
| } | |
| void* FifoBuffer::GetWriteBuffer(size_t* size) { | |
| CritScope cs(&crit_); | |
| if (state_ == SS_CLOSED) { | |
| return NULL; | |
| } | |
| // if empty, reset the write position to the beginning, so we can get | |
| // the biggest possible block | |
| if (data_length_ == 0) { | |
| read_position_ = 0; | |
| } | |
| const size_t write_position = (read_position_ + data_length_) | |
| % buffer_length_; | |
| *size = (write_position > read_position_ || data_length_ == 0) ? | |
| buffer_length_ - write_position : read_position_ - write_position; | |
| return &buffer_[write_position]; | |
| } | |
| void FifoBuffer::ConsumeWriteBuffer(size_t size) { | |
| CritScope cs(&crit_); | |
| ASSERT(size <= buffer_length_ - data_length_); | |
| const bool was_readable = (data_length_ > 0); | |
| data_length_ += size; | |
| if (!was_readable && size > 0) { | |
| PostEvent(owner_, SE_READ, 0); | |
| } | |
| } | |
| bool FifoBuffer::GetWriteRemaining(size_t* size) const { | |
| CritScope cs(&crit_); | |
| *size = buffer_length_ - data_length_; | |
| return true; | |
| } | |
| StreamResult FifoBuffer::ReadOffsetLocked(void* buffer, | |
| size_t bytes, | |
| size_t offset, | |
| size_t* bytes_read) { | |
| if (offset >= data_length_) { | |
| return (state_ != SS_CLOSED) ? SR_BLOCK : SR_EOS; | |
| } | |
| const size_t available = data_length_ - offset; | |
| const size_t read_position = (read_position_ + offset) % buffer_length_; | |
| const size_t copy = std::min(bytes, available); | |
| const size_t tail_copy = std::min(copy, buffer_length_ - read_position); | |
| char* const p = static_cast<char*>(buffer); | |
| memcpy(p, &buffer_[read_position], tail_copy); | |
| memcpy(p + tail_copy, &buffer_[0], copy - tail_copy); | |
| if (bytes_read) { | |
| *bytes_read = copy; | |
| } | |
| return SR_SUCCESS; | |
| } | |
| StreamResult FifoBuffer::WriteOffsetLocked(const void* buffer, | |
| size_t bytes, | |
| size_t offset, | |
| size_t* bytes_written) { | |
| if (state_ == SS_CLOSED) { | |
| return SR_EOS; | |
| } | |
| if (data_length_ + offset >= buffer_length_) { | |
| return SR_BLOCK; | |
| } | |
| const size_t available = buffer_length_ - data_length_ - offset; | |
| const size_t write_position = (read_position_ + data_length_ + offset) | |
| % buffer_length_; | |
| const size_t copy = std::min(bytes, available); | |
| const size_t tail_copy = std::min(copy, buffer_length_ - write_position); | |
| const char* const p = static_cast<const char*>(buffer); | |
| memcpy(&buffer_[write_position], p, tail_copy); | |
| memcpy(&buffer_[0], p + tail_copy, copy - tail_copy); | |
| if (bytes_written) { | |
| *bytes_written = copy; | |
| } | |
| return SR_SUCCESS; | |
| } | |
| /////////////////////////////////////////////////////////////////////////////// | |
| // LoggingAdapter | |
| /////////////////////////////////////////////////////////////////////////////// | |
| LoggingAdapter::LoggingAdapter(StreamInterface* stream, LoggingSeverity level, | |
| const std::string& label, bool hex_mode) | |
| : StreamAdapterInterface(stream), level_(level), hex_mode_(hex_mode) { | |
| set_label(label); | |
| } | |
| void LoggingAdapter::set_label(const std::string& label) { | |
| label_.assign("["); | |
| label_.append(label); | |
| label_.append("]"); | |
| } | |
| StreamResult LoggingAdapter::Read(void* buffer, size_t buffer_len, | |
| size_t* read, int* error) { | |
| size_t local_read; if (!read) read = &local_read; | |
| StreamResult result = StreamAdapterInterface::Read(buffer, buffer_len, read, | |
| error); | |
| if (result == SR_SUCCESS) { | |
| LogMultiline(level_, label_.c_str(), true, buffer, *read, hex_mode_, &lms_); | |
| } | |
| return result; | |
| } | |
| StreamResult LoggingAdapter::Write(const void* data, size_t data_len, | |
| size_t* written, int* error) { | |
| size_t local_written; | |
| if (!written) written = &local_written; | |
| StreamResult result = StreamAdapterInterface::Write(data, data_len, written, | |
| error); | |
| if (result == SR_SUCCESS) { | |
| LogMultiline(level_, label_.c_str(), false, data, *written, hex_mode_, | |
| &lms_); | |
| } | |
| return result; | |
| } | |
| void LoggingAdapter::Close() { | |
| LogMultiline(level_, label_.c_str(), false, NULL, 0, hex_mode_, &lms_); | |
| LogMultiline(level_, label_.c_str(), true, NULL, 0, hex_mode_, &lms_); | |
| LOG_V(level_) << label_ << " Closed locally"; | |
| StreamAdapterInterface::Close(); | |
| } | |
| void LoggingAdapter::OnEvent(StreamInterface* stream, int events, int err) { | |
| if (events & SE_OPEN) { | |
| LOG_V(level_) << label_ << " Open"; | |
| } else if (events & SE_CLOSE) { | |
| LogMultiline(level_, label_.c_str(), false, NULL, 0, hex_mode_, &lms_); | |
| LogMultiline(level_, label_.c_str(), true, NULL, 0, hex_mode_, &lms_); | |
| LOG_V(level_) << label_ << " Closed with error: " << err; | |
| } | |
| StreamAdapterInterface::OnEvent(stream, events, err); | |
| } | |
| /////////////////////////////////////////////////////////////////////////////// | |
| // StringStream - Reads/Writes to an external std::string | |
| /////////////////////////////////////////////////////////////////////////////// | |
| StringStream::StringStream(std::string* str) | |
| : str_(*str), read_pos_(0), read_only_(false) { | |
| } | |
| StringStream::StringStream(const std::string& str) | |
| : str_(const_cast<std::string&>(str)), read_pos_(0), read_only_(true) { | |
| } | |
| StreamState StringStream::GetState() const { | |
| return SS_OPEN; | |
| } | |
| StreamResult StringStream::Read(void* buffer, size_t buffer_len, | |
| size_t* read, int* error) { | |
| size_t available = std::min(buffer_len, str_.size() - read_pos_); | |
| if (!available) | |
| return SR_EOS; | |
| memcpy(buffer, str_.data() + read_pos_, available); | |
| read_pos_ += available; | |
| if (read) | |
| *read = available; | |
| return SR_SUCCESS; | |
| } | |
| StreamResult StringStream::Write(const void* data, size_t data_len, | |
| size_t* written, int* error) { | |
| if (read_only_) { | |
| if (error) { | |
| *error = -1; | |
| } | |
| return SR_ERROR; | |
| } | |
| str_.append(static_cast<const char*>(data), | |
| static_cast<const char*>(data) + data_len); | |
| if (written) | |
| *written = data_len; | |
| return SR_SUCCESS; | |
| } | |
| void StringStream::Close() { | |
| } | |
| bool StringStream::SetPosition(size_t position) { | |
| if (position > str_.size()) | |
| return false; | |
| read_pos_ = position; | |
| return true; | |
| } | |
| bool StringStream::GetPosition(size_t* position) const { | |
| if (position) | |
| *position = read_pos_; | |
| return true; | |
| } | |
| bool StringStream::GetSize(size_t* size) const { | |
| if (size) | |
| *size = str_.size(); | |
| return true; | |
| } | |
| bool StringStream::GetAvailable(size_t* size) const { | |
| if (size) | |
| *size = str_.size() - read_pos_; | |
| return true; | |
| } | |
| bool StringStream::ReserveSize(size_t size) { | |
| if (read_only_) | |
| return false; | |
| str_.reserve(size); | |
| return true; | |
| } | |
| /////////////////////////////////////////////////////////////////////////////// | |
| // StreamReference | |
| /////////////////////////////////////////////////////////////////////////////// | |
| StreamReference::StreamReference(StreamInterface* stream) | |
| : StreamAdapterInterface(stream, false) { | |
| // owner set to false so the destructor does not free the stream. | |
| stream_ref_count_ = new StreamRefCount(stream); | |
| } | |
| StreamInterface* StreamReference::NewReference() { | |
| stream_ref_count_->AddReference(); | |
| return new StreamReference(stream_ref_count_, stream()); | |
| } | |
| StreamReference::~StreamReference() { | |
| stream_ref_count_->Release(); | |
| } | |
| StreamReference::StreamReference(StreamRefCount* stream_ref_count, | |
| StreamInterface* stream) | |
| : StreamAdapterInterface(stream, false), | |
| stream_ref_count_(stream_ref_count) { | |
| } | |
| /////////////////////////////////////////////////////////////////////////////// | |
| StreamResult Flow(StreamInterface* source, | |
| char* buffer, size_t buffer_len, | |
| StreamInterface* sink, | |
| size_t* data_len /* = NULL */) { | |
| ASSERT(buffer_len > 0); | |
| StreamResult result; | |
| size_t count, read_pos, write_pos; | |
| if (data_len) { | |
| read_pos = *data_len; | |
| } else { | |
| read_pos = 0; | |
| } | |
| bool end_of_stream = false; | |
| do { | |
| // Read until buffer is full, end of stream, or error | |
| while (!end_of_stream && (read_pos < buffer_len)) { | |
| result = source->Read(buffer + read_pos, buffer_len - read_pos, | |
| &count, NULL); | |
| if (result == SR_EOS) { | |
| end_of_stream = true; | |
| } else if (result != SR_SUCCESS) { | |
| if (data_len) { | |
| *data_len = read_pos; | |
| } | |
| return result; | |
| } else { | |
| read_pos += count; | |
| } | |
| } | |
| // Write until buffer is empty, or error (including end of stream) | |
| write_pos = 0; | |
| while (write_pos < read_pos) { | |
| result = sink->Write(buffer + write_pos, read_pos - write_pos, | |
| &count, NULL); | |
| if (result != SR_SUCCESS) { | |
| if (data_len) { | |
| *data_len = read_pos - write_pos; | |
| if (write_pos > 0) { | |
| memmove(buffer, buffer + write_pos, *data_len); | |
| } | |
| } | |
| return result; | |
| } | |
| write_pos += count; | |
| } | |
| read_pos = 0; | |
| } while (!end_of_stream); | |
| if (data_len) { | |
| *data_len = 0; | |
| } | |
| return SR_SUCCESS; | |
| } | |
| /////////////////////////////////////////////////////////////////////////////// | |
| } // namespace rtc |