3pp-mirror/snapcast
1
0
Fork 0
mirror of https://github.com/badaix/snapcast.git synced 2025-05-29 17:06:18 +02:00
Code Issues Projects Releases Packages Wiki Activity

made "serialize" const

Browse source
This commit is contained in:
badaix 2015-07-26 13:06:21 +02:00
parent 56389ad202
commit b936bffeff
11 changed files with 104 additions and 73 deletions
Download patch file Download diff file Expand all files Collapse all files

6
message/ack.h
View file

@ -47,7 +47,7 @@ public:
stream.read(&message[0], size);
}
virtual uint32_t getSize()
virtual uint32_t getSize() const
{
return sizeof(int16_t) + message.size();
}
@ -55,10 +55,10 @@ public:
std::string message;
protected:
virtual void doserialize(std::ostream& stream)
virtual void doserialize(std::ostream& stream) const
{
int16_t size(message.size());
stream.write(reinterpret_cast<char *>(&size), sizeof(int16_t));
stream.write(reinterpret_cast<const char *>(&size), sizeof(int16_t));
stream.write(message.c_str(), size);
}
};

6
message/command.h
View file

@ -49,7 +49,7 @@ public:
stream.read(&command[0], size);
}
virtual uint32_t getSize()
virtual uint32_t getSize() const
{
return sizeof(int16_t) + command.size();
}
@ -57,10 +57,10 @@ public:
std::string command;
protected:
virtual void doserialize(std::ostream& stream)
virtual void doserialize(std::ostream& stream) const
{
int16_t size(command.size());
stream.write(reinterpret_cast<char *>(&size), sizeof(int16_t));
stream.write(reinterpret_cast<const char *>(&size), sizeof(int16_t));
stream.write(command.c_str(), size);
}
};

11
message/header.h
View file

@ -24,6 +24,9 @@
namespace msg
{
/**
* Codec dependend header of encoded data stream
*/
class Header : public BaseMessage
{
public:
@ -49,7 +52,7 @@ public:
stream.read(payload, payloadSize);
}
virtual uint32_t getSize()
virtual uint32_t getSize() const
{
return sizeof(int16_t) + codec.size() + sizeof(uint32_t) + payloadSize;
}
@ -59,12 +62,12 @@ public:
std::string codec;
protected:
virtual void doserialize(std::ostream& stream)
virtual void doserialize(std::ostream& stream) const
{
int16_t size(codec.size());
stream.write(reinterpret_cast<char *>(&size), sizeof(int16_t));
stream.write(reinterpret_cast<const char *>(&size), sizeof(int16_t));
stream.write(codec.c_str(), size);
stream.write(reinterpret_cast<char *>(&payloadSize), sizeof(uint32_t));
stream.write(reinterpret_cast<const char *>(&payloadSize), sizeof(uint32_t));
stream.write(payload, payloadSize);
}
};

58
message/message.h
View file

@ -75,16 +75,20 @@ struct tv
int32_t sec;
int32_t usec;
/*
5.3 - 6.2 = -0.9
-1
0.1
5.3 - 6.4 = -1.1
-1
-0.1
*/
//(timeMsg.received.sec - timeMsg.sent.sec) * 1000000 + (timeMsg.received.usec - timeMsg.sent.usec)
tv operator+(const tv& other)
{
tv result(*this);
result.sec += other.sec;
result.usec += other.usec;
if (result.usec > 1000000)
{
result.sec += result.usec / 1000000;
result.usec %= 1000000;
}
return result;
}
tv operator-(const tv& other)
{
tv result(*this);
@ -130,10 +134,10 @@ struct BaseMessage
stream.read(reinterpret_cast<char*>(&type), sizeof(uint16_t));
stream.read(reinterpret_cast<char*>(&id), sizeof(uint16_t));
stream.read(reinterpret_cast<char*>(&refersTo), sizeof(uint16_t));
stream.read(reinterpret_cast<char *>(&sent.sec), sizeof(int32_t));
stream.read(reinterpret_cast<char *>(&sent.usec), sizeof(int32_t));
stream.read(reinterpret_cast<char *>(&received.sec), sizeof(int32_t));
stream.read(reinterpret_cast<char *>(&received.usec), sizeof(int32_t));
stream.read(reinterpret_cast<char*>(&sent.sec), sizeof(int32_t));
stream.read(reinterpret_cast<char*>(&sent.usec), sizeof(int32_t));
stream.read(reinterpret_cast<char*>(&received.sec), sizeof(int32_t));
stream.read(reinterpret_cast<char*>(&received.usec), sizeof(int32_t));
stream.read(reinterpret_cast<char*>(&size), sizeof(uint32_t));
}
@ -157,34 +161,34 @@ struct BaseMessage
read(is);
}
virtual void serialize(std::ostream& stream)
virtual void serialize(std::ostream& stream) const
{
stream.write(reinterpret_cast<char*>(&type), sizeof(uint16_t));
stream.write(reinterpret_cast<char*>(&id), sizeof(uint16_t));
stream.write(reinterpret_cast<char*>(&refersTo), sizeof(uint16_t));
stream.write(reinterpret_cast<char *>(&sent.sec), sizeof(int32_t));
stream.write(reinterpret_cast<char *>(&sent.usec), sizeof(int32_t));
stream.write(reinterpret_cast<char *>(&received.sec), sizeof(int32_t));
stream.write(reinterpret_cast<char *>(&received.usec), sizeof(int32_t));
stream.write(reinterpret_cast<const char*>(&type), sizeof(uint16_t));
stream.write(reinterpret_cast<const char*>(&id), sizeof(uint16_t));
stream.write(reinterpret_cast<const char*>(&refersTo), sizeof(uint16_t));
stream.write(reinterpret_cast<const char *>(&sent.sec), sizeof(int32_t));
stream.write(reinterpret_cast<const char *>(&sent.usec), sizeof(int32_t));
stream.write(reinterpret_cast<const char *>(&received.sec), sizeof(int32_t));
stream.write(reinterpret_cast<const char *>(&received.usec), sizeof(int32_t));
size = getSize();
stream.write(reinterpret_cast<char*>(&size), sizeof(uint32_t));
stream.write(reinterpret_cast<const char*>(&size), sizeof(uint32_t));
doserialize(stream);
}
virtual uint32_t getSize()
virtual uint32_t getSize() const
{
return 3*sizeof(uint16_t) + 2*sizeof(tv) + sizeof(uint32_t);
};
uint16_t type;
uint16_t id;
mutable uint16_t id;
uint16_t refersTo;
tv sent;
tv received;
uint32_t size;
mutable tv sent;
mutable uint32_t size;
protected:
virtual void doserialize(std::ostream& stream)
virtual void doserialize(std::ostream& stream) const
{
};
};

5
message/pcmChunk.cpp
View file

@ -32,6 +32,11 @@ PcmChunk::PcmChunk(const SampleFormat& sampleFormat, size_t ms) : WireChunk(samp
}
PcmChunk::PcmChunk(const PcmChunk& pcmChunk) : WireChunk(pcmChunk), format(pcmChunk.format), idx(0)
{
}
PcmChunk::PcmChunk() : WireChunk(), idx(0)
{
}

9
message/pcmChunk.h
View file

@ -29,12 +29,18 @@
namespace msg
{
/**
* Piece of PCM data with SampleFormat information
* Has information about "when" recorded (start) and duration
* frames can be read with "readFrames", which will also change the start time
*/
class PcmChunk : public WireChunk
{
public:
PcmChunk(const SampleFormat& sampleFormat, size_t ms);
PcmChunk(const PcmChunk& pcmChunk);
PcmChunk();
~PcmChunk();
virtual ~PcmChunk();
int readFrames(void* outputBuffer, size_t frameCount);
int seek(int frames);
@ -83,7 +89,6 @@ public:
SampleFormat format;
private:
// SampleFormat format_;
uint32_t idx;
};

9
message/request.h
View file

@ -25,6 +25,9 @@
namespace msg
{
/**
* Request is sent from client to server. The answer is identified by a request id
*/
class Request : public BaseMessage
{
public:
@ -45,7 +48,7 @@ public:
stream.read(reinterpret_cast<char *>(&request), sizeof(int16_t));
}
virtual uint32_t getSize()
virtual uint32_t getSize() const
{
return sizeof(int16_t);
}
@ -53,9 +56,9 @@ public:
message_type request;
protected:
virtual void doserialize(std::ostream& stream)
virtual void doserialize(std::ostream& stream) const
{
stream.write(reinterpret_cast<char *>(&request), sizeof(int16_t));
stream.write(reinterpret_cast<const char *>(&request), sizeof(int16_t));
}
};

35
message/sampleFormat.h
View file

@ -25,16 +25,17 @@
namespace msg
{
// sample and frame as defined in alsa:
// http://www.alsa-project.org/main/index.php/FramesPeriods
// Say we want to work with a stereo, 16-bit, 44.1 KHz stream, one-way (meaning, either in playback or in capture direction). Then we have:
// 'stereo' = number of channels: 2
// 1 analog sample is represented with 16 bits = 2 bytes
// 1 frame represents 1 analog sample from all channels; here we have 2 channels, and so:
// 1 frame = (num_channels) * (1 sample in bytes) = (2 channels) * (2 bytes (16 bits) per sample) = 4 bytes (32 bits)
// To sustain 2x 44.1 KHz analog rate - the system must be capable of data transfer rate, in Bytes/sec:
// Bps_rate = (num_channels) * (1 sample in bytes) * (analog_rate) = (1 frame) * (analog_rate) = ( 2 channels ) * (2 bytes/sample) * (44100 samples/sec) = 2*2*44100 = 176400 Bytes/sec (link to formula img)
/**
* sample and frame as defined in alsa:
* http://www.alsa-project.org/main/index.php/FramesPeriods
* Say we want to work with a stereo, 16-bit, 44.1 KHz stream, one-way (meaning, either in playback or in capture direction). Then we have:
* 'stereo' = number of channels: 2
* 1 analog sample is represented with 16 bits = 2 bytes
* 1 frame represents 1 analog sample from all channels; here we have 2 channels, and so:
* 1 frame = (num_channels) * (1 sample in bytes) = (2 channels) * (2 bytes (16 bits) per sample) = 4 bytes (32 bits)
* To sustain 2x 44.1 KHz analog rate - the system must be capable of data transfer rate, in Bytes/sec:
* Bps_rate = (num_channels) * (1 sample in bytes) * (analog_rate) = (1 frame) * (analog_rate) = ( 2 channels ) * (2 bytes/sample) * (44100 samples/sec) = 2*2*44100 = 176400 Bytes/sec (link to formula img)
*/
class SampleFormat : public BaseMessage
{
public:
@ -79,19 +80,19 @@ public:
stream.read(reinterpret_cast<char *>(&frameSize), sizeof(uint16_t));
}
virtual uint32_t getSize()
virtual uint32_t getSize() const
{
return sizeof(int32_t) + 4*sizeof(int16_t);
}
protected:
virtual void doserialize(std::ostream& stream)
virtual void doserialize(std::ostream& stream) const
{
stream.write(reinterpret_cast<char *>(&rate), sizeof(uint32_t));
stream.write(reinterpret_cast<char *>(&bits), sizeof(uint16_t));
stream.write(reinterpret_cast<char *>(&channels), sizeof(uint16_t));
stream.write(reinterpret_cast<char *>(&sampleSize), sizeof(uint16_t));
stream.write(reinterpret_cast<char *>(&frameSize), sizeof(uint16_t));
stream.write(reinterpret_cast<const char *>(&rate), sizeof(uint32_t));
stream.write(reinterpret_cast<const char *>(&bits), sizeof(uint16_t));
stream.write(reinterpret_cast<const char *>(&channels), sizeof(uint16_t));
stream.write(reinterpret_cast<const char *>(&sampleSize), sizeof(uint16_t));
stream.write(reinterpret_cast<const char *>(&frameSize), sizeof(uint16_t));
}
};

6
message/serverSettings.h
View file

@ -41,7 +41,7 @@ public:
stream.read(reinterpret_cast<char *>(&bufferMs), sizeof(int32_t));
}
virtual uint32_t getSize()
virtual uint32_t getSize() const
{
return sizeof(int32_t);
}
@ -49,9 +49,9 @@ public:
int32_t bufferMs;
protected:
virtual void doserialize(std::ostream& stream)
virtual void doserialize(std::ostream& stream) const
{
stream.write(reinterpret_cast<char *>(&bufferMs), sizeof(int32_t));
stream.write(reinterpret_cast<const char *>(&bufferMs), sizeof(int32_t));
}
};

6
message/time.h
View file

@ -40,7 +40,7 @@ public:
stream.read(reinterpret_cast<char *>(&latency), sizeof(double));
}
virtual uint32_t getSize()
virtual uint32_t getSize() const
{
return sizeof(double);
}
@ -48,9 +48,9 @@ public:
double latency;
protected:
virtual void doserialize(std::ostream& stream)
virtual void doserialize(std::ostream& stream) const
{
stream.write(reinterpret_cast<char *>(&latency), sizeof(double));
stream.write(reinterpret_cast<const char *>(&latency), sizeof(double));
}
};

20
message/wireChunk.h
View file

@ -31,6 +31,10 @@
namespace msg
{
/**
* Piece of raw data
* Has information about "when" captured (timestamp)
*/
class WireChunk : public BaseMessage
{
public:
@ -39,6 +43,12 @@ public:
payload = (char*)malloc(size);
}
WireChunk(const WireChunk& wireChunk) : BaseMessage(message_type::kWireChunk), timestamp(wireChunk.timestamp), payloadSize(wireChunk.payloadSize)
{
payload = (char*)malloc(payloadSize);
memcpy(payload, wireChunk.payload, payloadSize);
}
virtual ~WireChunk()
{
free(payload);
@ -53,7 +63,7 @@ public:
stream.read(payload, payloadSize);
}
virtual uint32_t getSize()
virtual uint32_t getSize() const
{
return sizeof(int32_t) + sizeof(int32_t) + sizeof(uint32_t) + payloadSize;
}
@ -63,11 +73,11 @@ public:
char* payload;
protected:
virtual void doserialize(std::ostream& stream)
virtual void doserialize(std::ostream& stream) const
{
stream.write(reinterpret_cast<char *>(&timestamp.sec), sizeof(int32_t));
stream.write(reinterpret_cast<char *>(&timestamp.usec), sizeof(int32_t));
stream.write(reinterpret_cast<char *>(&payloadSize), sizeof(uint32_t));
stream.write(reinterpret_cast<const char *>(&timestamp.sec), sizeof(int32_t));
stream.write(reinterpret_cast<const char *>(&timestamp.usec), sizeof(int32_t));
stream.write(reinterpret_cast<const char *>(&payloadSize), sizeof(uint32_t));
stream.write(payload, payloadSize);
}
};