// construct STOMP frame (command & header) from a streambuf
// --------------------------------------------------
Frame::Frame(boost::asio::streambuf& stomp_response, const stomp_server_command_map_t& cmd_map)
// --------------------------------------------------
{
string _str;
try {
// STEP 1: find the next STOMP command line in stomp_response.
// Chomp unknown lines till the buffer is empty, in which case an exception is raised
//debug_print(boost::format("Frame parser phase 1, stomp_response.size()==%1%") % stomp_response.size());
//hexdump(boost::asio::buffer_cast<const char*>(stomp_response.data()), stomp_response.size());
while (stomp_response.size() > 0) {
mygetline(stomp_response, _str);
//hexdump(_str.c_str(), _str.length());
stomp_response.consume(_str.size() + 1); // plus one for the newline
if (cmd_map.find(_str) != cmd_map.end()) {
//debug_print(boost::format("phase 1: COMMAND==%1%, sb.size==%2%") % _str % stomp_response.size());
m_command = _str;
break;
}
}
// if after all this trouble m_command is not set, and there's no more data in stomp_response
// (which shouldn't happen since we do async_read_until the double newline), then throw an exception
if (m_command == "") throw(NoMoreFrames());
// STEP 2: parse all headers
//debug_print("Frame parser phase 2");
vector< string > header_parts;
while (stomp_response.size() > 0) {
mygetline(stomp_response, _str);
stomp_response.consume(_str.size()+1);
boost::algorithm::split(header_parts, _str, is_any_of(":"));
if (header_parts.size() > 1) {
string& key = decode_header_token(header_parts[0]);
string& val = decode_header_token(header_parts[1]);
//debug_print(boost::format("phase 2: HEADER[%1%]==%2%") % key % val);
m_headers[key] = val;
//
} else {
// no valid header line detected, on to the body scanner
break;
}
}
//
} catch(NoMoreFrames& e) {
//debug_print("-- Frame parser ended (no more frames)");
throw(e);
}
};
//===========================================================================
void CHttpClient::DoReadHeaders (const boost::system::error_code & err) {
if (err) {
printf("%s\n", __FUNCTION__);
cout<<"Error: "<<err.message()<<endl;
return;
}
istream responseStream(&m_response);
string header;
while (getline(responseStream, header) && header != "\r")
cout<<header<<endl;
cout<<endl;
if (m_response.size() > 0)
cout<<&m_response;
auto handler = boost::bind(
&CHttpClient::DoReadContent,
this,
boost::asio::placeholders::error
);
boost::asio::async_read(
m_socket,
m_response,
boost::asio::transfer_at_least(1),
handler
);
}
static std::string to_string(boost::asio::streambuf& buffer)
{
boost::asio::streambuf::const_buffers_type bufs = buffer.data();
std::string data(
boost::asio::buffers_begin(bufs),
boost::asio::buffers_begin(bufs) + buffer.size());
return std::move(data);
}
void MkvTransfer::stream_header(
StreamInfo const & info,
boost::asio::streambuf & buf)
{
//每添加一个流需要添加一个track_entry
MkvTrackEntry track_entry;
track_entry.TrackNumber = info.index + 1;
std::vector<boost::uint8_t> tem(4, (boost::uint8_t)(info.index + 1));
track_entry.TrackUID = tem;
track_entry.Language = "eng";
if (info.type == MEDIA_TYPE_VIDE) {
track_entry.TrackType = MkvTrackType::VIDEO;
track_entry.CodecID = "V_MPEG4/ISO/AVC";
track_entry.CodecPrivate = info.format_data;
track_entry.Video.PixelWidth = info.video_format.width;
track_entry.Video.PixelHeight = info.video_format.height;
track_entry.Video.Size = track_entry.Video.data_size();
} else if (info.type == MEDIA_TYPE_AUDI) {
track_entry.TrackType = MkvTrackType::AUDIO;
track_entry.CodecID = "A_AAC";
track_entry.CodecPrivate = info.format_data;
track_entry.Audio.SamplingFrequency =
(float)info.audio_format.sample_rate;
track_entry.Audio.Channels =
info.audio_format.channel_count;
//track_entry.Audio.BitDepth =
// mediainfoex.audio_format.sample_size * 8;
track_entry.Audio.Size = track_entry.Audio.data_size();
} else {
track_entry.TrackType = MkvTrackType::SUBTITLE;
track_entry.CodecID = "S_TEXT/UTF-8";
}
EBML_DataSizeArchive dsa;
dsa >> track_entry;
size_t old_size = buf.size();
util::archive::BigEndianBinaryOArchive<> oa(buf);
oa << track_entry;
assert(old_size + track_entry.byte_size() == buf.size());
}
void StreamDemuxer::Push(boost::asio::streambuf& stream)
{
while (stream.size()) {
if (_packet->Fill(stream)) {
if (_packet->IsFull()) {
_downStream->Push(_packet);
_packet = std::make_shared<LiveViewPacket>();
}
}
}
}
bool EmptyData::Fill(boost::asio::streambuf& buf)
{
assert(Size() != UNDEFINED_SIZE);
uint32_t pos = Pos();
const uint32_t copyBytes = std::min(buf.size(), Size() - pos);
buf.consume(copyBytes);
SetPos(pos + copyBytes);
return true;
}
void Dump(boost::asio::streambuf& buf)
{
std::ofstream ofs("out.dat", std::ios::binary | std::ios::trunc);
if (!ofs) {
cout << "dump failed" << endl;
return;
}
cout << "content size:" << buf.size() << endl;
ofs << &buf;
}
void on_recv_(const boost::system::error_code& error, size_t bytes_transferred)
{
if(error && error != boost::asio::error::eof) {
std::cout << "receive failed: " << error.message() << std::endl;
} else {
const char* data = asio::buffer_cast<const char*>(recv_.data());
std::cout << "response(" << bytes_transferred << "): ";
std::cout << data << std::endl;
recv_.consume(recv_.size());
read_trg_ = true;
}
}
// my own version of getline for an asio streambuf
inline void mygetline (boost::asio::streambuf& sb, string& _str, char delim = '\n') {
const char* line = boost::asio::buffer_cast<const char*>(sb.data());
char _c;
size_t i;
_str.clear();
for( i = 0;
((i < sb.size()) && ((_c = line[i]) != delim));
i++
) _str += _c;
//debug_print( boost::format("mygetline: i=%1%, sb.size()==%2%") % i % sb.size() );
//hexdump(_str.c_str(), _str.size());
}
void run_event_loop_until_frame_received()
{
using boost::bind;
have_frame = false;
buffer.consume(buffer.size());
last_error = boost::system::error_code();
boost::asio::async_read_until(socket,
buffer,
"END\r\n",
bind(&TimedSessionBase::handle_frame_reception,
this,
boost::asio::placeholders::error,
boost::asio::placeholders::bytes_transferred));
service.reset();
while (!last_error && !have_frame) {
service.poll();
service.reset();
check_if_timed_out();
}
}
size_t size() {
return streambuf.size();
}