#
set(Compile.linux.sources
+ source/platform/linux/alsa.cpp
+ source/platform/linux/audio_out_alsa.cpp
+ source/platform/linux/audio_in_alsa.cpp
source/platform/linux/scheduler.cpp
+ source/platform/linux/privilege.cpp
+)
+set(Compile.linux.libraries
+ asound
)
# FIX: Add other platforms.
if(Platform.name STREQUAL Linux)
set(Compile.platform.sources ${Compile.linux.sources})
+ set(Compile.platform.libraries ${Compile.linux.libraries})
endif(Platform.name STREQUAL Linux)
set(Compile.sources
${Compile.platform.sources}
source/audio_device.cpp
+ source/audio_in_default.cpp
source/audio_input.cpp
+ source/audio_out_default.cpp
source/audio_output.cpp
source/audio_sink.cpp
source/base.cpp
source/driver_manager.cpp
source/event_handler.cpp
source/fifo.cpp
+ source/framer.cpp
+ source/framer_noop.cpp
source/interfaces.cpp
source/io_device.cpp
source/keying.cpp
message(FATAL_ERROR "Can't find Codec2 library.")
endif( Codec2.lib AND Codec2.include )
+target_link_libraries(freedv-server ${Compile.platform.libraries})
+target_link_libraries(freedv-gtest ${Compile.platform.libraries})
+
install(TARGETS freedv-server RUNTIME DESTINATION bin)
--g -pedantic
+-g -pedantic -Wall -Wextra
--std=c++11 -g -pedantic -DDEBUG
+-std=c++11 -g -pedantic -Wall -Wextra -DDEBUG
// Write audio into the "short" type.
std::size_t
- AudioSink::write16(const std::int16_t * array, std::size_t length)
+ AudioSink::write16(const std::int16_t *, std::size_t length)
{
return length;
}
delete parameters;
}
- bool const
+ bool
Base::captive() const
{
return false;
" [options]\n"
"\nWhere options are these flags:\n\n"
"--codec or -c\t\tSelect the voice codec.\n"
+ "--config or -c\t\tPrint the configuration.\n"
"--drivers or -d\t\tPrint a list of the available device drivers.\n"
"--framer or -f\t\tSelect the communications protocol framer.\n"
- "--gui or -g\t\tSelect the graphical user interface.\n"
"--help or -h\t\tPrint this message.\n"
"--interface or -i\tSelect the user-interface (graphical or otherwise).\n"
"--keying or -k\t\tSelect the transmitter keying interface.\n"
{ "codec", required_argument, 0, 'c' },
{ "config", no_argument, 0, 'C' },
{ "drivers", no_argument, 0, 'd' },
- { "default", no_argument, 0, 'D' },
{ "framer", required_argument, 0, 'f' },
{ "help", no_argument, 0, 'h' },
{ "interface", required_argument, 0, 'i' },
int
main(int argc, char * * argv)
{
- int command;
Interfaces i;
- const char * driver;
- const char * parameter;
const DriverManager * const m = driver_manager();
i.fill_in();
if ( argc > 1 ) {
- while ((command = getopt_long(argc, argv, "c:dhi:k:l:m:M:n:p:r:t:x:", options, NULL)) != -1) {
- switch (command) {
- case 'f':
- case 'i':
- case 'k':
- case 'l':
- case 'm':
- case 'p':
- case 'P':
- case 'r':
- case 't':
- case 'x':
- char * const colon(index(optarg, ':'));
-
- if ( colon == 0 || colon[0] != ':' || colon[1] == 0 ) {
- cerr << argv[optind - 1] << ": Missing colon. Argument must be of the form \"<driver>:<parameter>\"" << endl;
- exit(1);
- }
-
- *colon = 0;
- driver = optarg;
- parameter = &colon[1];
- }
-
- Base * set = (Base *)1;
+ int command;
+ while ((command = getopt_long(argc, argv, "c:Cdf:hi:k:l:m:M:p:P:r:t:x:", options, NULL)) != -1 ) {
switch (command) {
case 'c':
- set = i.codec = m->codec(driver, parameter);
- break;
- case 'd':
- drivers();
- exit(0);
- case 'D':
- break;
case 'f':
- set = i.framer = m->framer(driver, parameter);
- break;
- default:
- case 'h':
- help(argv[0]);
- exit(1);
case 'i':
- set = i.user_interface = m->user_interface(driver, parameter, &i);
- break;
case 'k':
- set = i.keying_output = m->keying_output(driver, parameter);
- break;
case 'l':
- set = i.loudspeaker = m->audio_output(driver, parameter);
- break;
case 'm':
- set = i.microphone = m->audio_input(driver, parameter);
- break;
case 'M':
- set = i.modem = m->modem(driver, parameter);
- break;
case 'p':
- set = i.ptt_input_digital = m->ptt_input(driver, parameter);
- break;
case 'P':
- set = i.ptt_input_ssb = m->ptt_input(driver, parameter);
- break;
case 'r':
- set = i.receiver = m->audio_input(driver, parameter);
- break;
case 't':
- set = i.transmitter = m->audio_output(driver, parameter);
- break;
case 'x':
- set = i.text_input = m->text_input(driver, parameter);
- break;
- case 'C':
- // FIX: Operator overload doesn't work here.
- i.print(cout) << endl;
- exit(0);
- case 0:
- break;
+ const char * const driver = optarg;
+ char * const colon = index(optarg, ':');
+ const char * parameter = "";
+
+ if ( colon ) {
+ *colon = 0;
+ parameter = colon + 1;
+ }
+
+ Base * set = (Base *)1;
+
+ switch (command) {
+ case 'c':
+ set = i.codec = m->codec(driver, parameter);
+ break;
+ case 'd':
+ drivers();
+ exit(0);
+ case 'f':
+ set = i.framer = m->framer(driver, parameter);
+ break;
+ default:
+ case 'h':
+ help(argv[0]);
+ exit(1);
+ case 'i':
+ set = i.user_interface = m->user_interface(driver, parameter, &i);
+ break;
+ case 'k':
+ set = i.keying_output = m->keying_output(driver, parameter);
+ break;
+ case 'l':
+ set = i.loudspeaker = m->audio_output(driver, parameter);
+ break;
+ case 'm':
+ set = i.microphone = m->audio_input(driver, parameter);
+ break;
+ case 'M':
+ set = i.modem = m->modem(driver, parameter);
+ break;
+ case 'p':
+ set = i.ptt_input_digital = m->ptt_input(driver, parameter);
+ break;
+ case 'P':
+ set = i.ptt_input_ssb = m->ptt_input(driver, parameter);
+ break;
+ case 'r':
+ set = i.receiver = m->audio_input(driver, parameter);
+ break;
+ case 't':
+ set = i.transmitter = m->audio_output(driver, parameter);
+ break;
+ case 'x':
+ set = i.text_input = m->text_input(driver, parameter);
+ break;
+ case 'C':
+ // FIX: Operator overload doesn't work here.
+ i.print(cout) << endl;
+ exit(0);
+ case 0:
+ break;
+ }
+ if ( set == 0 )
+ exit(1);
}
- if ( set == 0 )
- exit(1);
}
}
else { // argc <= 1
/// Data Bytes provided to decode16 and encode16 must be a multiple
/// of this value. The result is invariant.
/// \return The number of data bytes necessary to store a codec frame.
- virtual std::size_t const
+ virtual std::size_t
bytes_per_frame() const;
/// Decode from data bytes to audio samples.
/// Return the duration of a frame in milliseconds.
/// \return The duration of a frame in milliseconds.
- virtual int const
+ virtual int
frame_duration() const;
/// Return the number of audio samples expected to create a codec
/// a given SampleRate.
/// \return The number of audio samples expected to create a codec
/// frame.
- virtual std::size_t const
+ virtual std::size_t
samples_per_frame() const;
};
{
}
- std::size_t const
+ std::size_t
CodecNoOp::bytes_per_frame() const
{
return sizeof(std::int16_t);
std::size_t
CodecNoOp::decode16(const std::uint8_t * i, std::int16_t * o, std::size_t * data_length, std::size_t sample_length)
{
- const std::size_t length = std::min(*data_length / 2, sample_length);
+ const std::size_t length = min(*data_length / 2, sample_length);
memcpy(o, i, length * 2);
*data_length = length * 2;
return length;
return length;
}
- int const
+ int
CodecNoOp::frame_duration() const
{
return 1;
}
- std::size_t const
+ std::size_t
CodecNoOp::samples_per_frame() const
{
return 1;
}
static FreeDV::Base *
- pick(const char * key, const char * type, const char * const parameters, const DriverList * list)
+ pick(const char * key, const char * type, const char * const parameters, const DriverList * list, Interfaces * interfaces = 0)
{
while ( list->key ) {
if ( strcmp(key, list->key) == 0 ) {
try {
- return (*(list->creator))(parameters);
+ if ( interfaces )
+ return (*(list->creator_i))(parameters, interfaces);
+ else
+ return (*(list->creator))(parameters);
}
catch(std::exception & e) {
std::cerr << "Open " << type << " \"" << key << "\": " << e.what() << std::endl;
UserInterface *
DriverManager::user_interface(const char * key, const char * parameter, Interfaces * interfaces) const
{
- return (UserInterface *)pick(key, "user interface", parameter, user_interface_drivers);
+ return (UserInterface *)pick(key, "user interface", parameter, user_interface_drivers, interfaces);
}
void
place(key, (base_creator)creator, enumerator, &user_interface_drivers);
}
- DriverManager * const
+ DriverManager *
driver_manager()
{
static DriverManager * const d(new DriverManager());
/// FreeDV driver interface definitions.
#include <cstdint>
#include <iostream>
+#include <assert.h>
/// Namespace used for all code in this program.
namespace FreeDV {
uint8_t * in;
const uint8_t * out;
- void out_overrun(std::size_t length) const;
- uint8_t * reorder(std::size_t length);
+ void out_overrun() const;
+ uint8_t * reorder(std::size_t length);
public:
/// Create the FIFO object.
/// Returns the amount of space available for incoming data.
/// \return The amount of space, in bytes, available for incoming data.
inline std::size_t incoming_available() const {
- return buffer_end - in + out - buffer;
+ return (buffer_end) - in + (out - buffer);
}
/// Return the address of an incoming data buffer of the requested size.
/// smaller than or equal to the length passed to incoming_buffer().
inline void incoming_done(std::size_t length) {
in += length;
+ assert(in >= buffer && in <= buffer_end);
}
/// Returns the amount of data available to read.
/// than or equal to the amount returned by outgoing_available().
/// \return The address of the data to be read.
inline const uint8_t * outgoing_buffer(std::size_t length) {
- if ( length > in - out )
- out_overrun(length);
+ if ( length > (std::size_t)(in - out) )
+ out_overrun();
return out;
}
/// outgoing_buffer().
inline void outgoing_done(std::size_t length) {
out += length;
+ assert(out >= buffer && out <= buffer_end);
}
/// Discard any buffered data.
/// The name of the driver. This must be the same as the name it
/// is registered under. It's expected to be from a per-class static
/// string and thus should not be deleted.
- const char * const
+ const char *
name;
/// The parameters to this instance of the driver. They are
/// copied here so that we can print them later in operator<<() .
/// the copy is deleted when in the ~Base() destructor.
- const char * const
+ const char *
parameters;
/// Constructor for the virtual base class.
/// should not be destroyed separately.
/// The result is invariant for a particular object (or possibly
/// class).
- virtual bool const
+ virtual bool
captive() const;
/// Write the driver information onto a stream, for debugging and
/// Data Bytes provided to decode16 and encode16 must be a multiple
/// of this value. The result is invariant for a particular configuration.
/// \return The number of data bytes necessary to store a codec frame.
- virtual std::size_t const
+ virtual std::size_t
bytes_per_frame() const = 0;
/// Decode from data bytes to audio samples.
/// Return the duration of a frame in milliseconds.
/// \return The duration of a frame in milliseconds.
- virtual int const
+ virtual int
frame_duration() const = 0;
/// Return the number of audio samples expected to create a codec
/// data because of the potential for clock skew between stations.
/// \return The number of audio samples expected to create a codec
/// frame.
- virtual std::size_t const
+ virtual std::size_t
samples_per_frame() const = 0;
};
/// \return The maximum number of data bytes expected to store the unwrapped
/// codec data.
/// frame.
- virtual std::size_t const
+ virtual std::size_t
max_unwrapped_bytes_per_frame() const = 0;
/// Return the minimum number of data bytes expected to store the unwrapped
/// \return The minimum number of data bytes expected to store the unwrapped
/// codec data.
/// frame.
- virtual std::size_t const
+ virtual std::size_t
min_unwrapped_bytes_per_frame() const = 0;
/// Wrap codec data bytes in a protocol for transmission through the modem.
/// \return The maximum number of data bytes expected to store a wrapped
/// protocol frame.
/// frame.
- virtual std::size_t const
+ virtual std::size_t
max_wrapped_bytes_per_frame() const = 0;
/// Return the minimum number of data bytes expected to store a wrapped
/// \return The minimum number of data bytes expected to store a wrapped
/// protocol frame.
/// frame.
- virtual std::size_t const
+ virtual std::size_t
min_wrapped_bytes_per_frame() const = 0;
};
/// The data buffer provided to demodulate16 must be a multiple of
/// this value. The result is invariant.
/// \return The number of data bytes necessary to store a modem frame.
- virtual std::size_t const
+ virtual std::size_t
bytes_per_frame() const = 0;
/// Demodulate from audio samples to data.
/// Return the duration of a frame in milliseconds.
/// \return The duration of a frame in milliseconds.
- virtual int const
+ virtual int
frame_duration() const = 0;
/// Return the number of audio samples expected to create a modem
/// data due to the potential for clock skew between stations.
/// \return The number of audio samples expected to create a codec
/// frame.
- virtual std::size_t const
+ virtual std::size_t
samples_per_frame() const = 0;
};
class Interfaces {
public:
Interfaces() : codec(0), event_handler(0),
- keying_output(0), loudspeaker(0), microphone(0),
- modem(0), ptt_input_digital(0), ptt_input_ssb(0),
- receiver(0), text_input(0), transmitter(0),
- user_interface(0)
+ framer(0), keying_output(0), loudspeaker(0),
+ microphone(0), modem(0), ptt_input_digital(0),
+ ptt_input_ssb(0), receiver(0), text_input(0),
+ transmitter(0), user_interface(0)
{
}
+ virtual ~Interfaces() final;
+
/// The voice codec in use.
Codec * codec;
/// The event loop handler. This is specific to a GUI, or POSIX.
PTTInput * ptt_input_digital;
/// The PTT input that indicates the transmission is to be SSB.
PTTInput * ptt_input_ssb;
+ /// The audio input from the receiver.
+ AudioInput * receiver;
/// The text to be transmitted in our text side-channel.
TextInput * text_input;
/// The audio output that drives the transmitter.
AudioOutput * transmitter;
- /// The audio input from the receiver.
- AudioInput * receiver;
/// The user interface driver. Used for GUIs.
UserInterface * user_interface;
virtual std::ostream &
print(std::ostream & stream) const;
};
+
/// Write the driver information from the Interfaces object onto a stream,
/// for debugging and dumping the configuration information.
/// \param stream A reference to an instance of ostream upon which the
inline std::size_t
min(std::size_t a, std::size_t b)
{
- a < b ? a : b;
+ return a < b ? a : b;
}
struct DriverList {
const char * key;
- FreeDV::Base * (*creator)(const char *);
+ union {
+ FreeDV::Base * (*creator)(const char *);
+ FreeDV::Base * (*creator_i)(const char *, Interfaces *);
+ };
std::ostream & (*enumerator)(std::ostream &);
};
}
/// Global reference to the driver manager.
- extern DriverManager * const driver_manager();
+ extern DriverManager * driver_manager();
}
}
void
- FIFO::out_overrun(std::size_t size) const
+ FIFO::out_overrun() const
{
throw std::runtime_error("FIFO outgoing data overrun.");
}
// memmove() is specified to handle overlap properly.
memmove(buffer, out, bytes);
#ifdef DEBUG
- std::cerr << "FIFO reorder with copy." << std::endl;
+ std::cerr << "FIFO reorder with copy. Size = " << size
+ << ", buffer = " << (void *)buffer << ", buffer_end = "
+ << (void *)buffer_end << ", in = " << (void *)in
+ << ", out = " << (void *)out
+ << std::endl;
#endif
}
out = buffer;
in = buffer + bytes;
- if ( size > buffer_end - in )
+ if ( size > (std::size_t)(buffer_end - in) )
throw std::runtime_error("FIFO incoming data overrun.");
return in;
/// \return The maximum number of data bytes expected to store a wrapped
/// protocol frame.
/// frame.
- virtual std::size_t const
+ virtual std::size_t
max_wrapped_bytes_per_frame() const;
/// Return the maximum number of data bytes expected to store the unwrapped
/// \return The maximum number of data bytes expected to store the unwrapped
/// codec data.
/// frame.
- virtual std::size_t const
+ virtual std::size_t
max_unwrapped_bytes_per_frame() const;
/// Return the minimum number of data bytes expected to store the unwrapped
/// \return The minimum number of data bytes expected to store the unwrapped
/// codec data.
/// frame.
- virtual std::size_t const
+ virtual std::size_t
min_unwrapped_bytes_per_frame() const;
/// Return the minimum number of data bytes expected to store a wrapped
/// \return The minimum number of data bytes expected to store a wrapped
/// protocol frame.
/// frame.
- virtual std::size_t const
+ virtual std::size_t
min_wrapped_bytes_per_frame() const;
/// Decode from modem data to codec frames, removing the wrapping protocol.
{
}
- std::size_t const
+ std::size_t
FramerNoOp::max_wrapped_bytes_per_frame() const
{
return 1;
}
- std::size_t const
+ std::size_t
FramerNoOp::max_unwrapped_bytes_per_frame() const
{
return 1;
}
- std::size_t const
+ std::size_t
FramerNoOp::min_unwrapped_bytes_per_frame() const
{
return 1;
}
- std::size_t const
+ std::size_t
FramerNoOp::min_wrapped_bytes_per_frame() const
{
return 1;
std::size_t * input_length,
std::size_t output_length)
{
- const std::size_t length = std::min(*input_length, output_length);
+ const std::size_t length = min(*input_length, output_length);
memcpy(o, i, length);
*input_length = length;
return length;
std::size_t * input_length,
std::size_t output_length)
{
- const std::size_t length = std::min(*input_length, output_length);
+ const std::size_t length = min(*input_length, output_length);
memcpy(o, i, length);
*input_length = length;
return length;
static const char empty[1] = { '\0' };
namespace FreeDV {
+ Interfaces::~Interfaces()
+ {
+ }
+
void
Interfaces::fill_in()
{
loudspeaker = Driver::AudioOutDefault();
if ( !microphone )
- microphone = Driver::Tone(empty);
+ microphone = Driver::AudioInDefault();
if ( !modem )
modem = Driver::ModemNoOp(empty);
}
void
- LibEvent::monitor(int fd, unsigned int type, void * private_data,
- void (*event)(int fd, unsigned int type, void * private_data))
+ LibEvent::monitor(int, unsigned int, void *,
+ void (*)(int, unsigned int, void *))
{
}
void
- LibEvent::unmonitor(int fd)
+ LibEvent::unmonitor(int)
{
}
/// The data buffer provided to demodulate16 must be a multiple of
/// this value. The result is invariant.
/// \return The number of data bytes necessary to store a modem frame.
- virtual std::size_t const
+ virtual std::size_t
bytes_per_frame() const;
/// Demodulate from audio samples to data.
/// Return the duration of a frame in milliseconds.
/// \return The duration of a frame in milliseconds.
- virtual int const
+ virtual int
frame_duration() const;
/// Return the number of audio samples expected to create a codec
/// invariant for a given SampleRate.
/// \return The number of audio samples expected to create a codec
/// frame.
- virtual std::size_t const
+ virtual std::size_t
samples_per_frame() const;
};
{
}
- std::size_t const
+ std::size_t
ModemNoOp::bytes_per_frame() const
{
return sizeof(std::int16_t);
std::size_t * sample_length,
std::size_t data_length)
{
- const std::size_t length = std::min(data_length / 2, *sample_length);
+ const std::size_t length = min(data_length / 2, *sample_length);
memcpy(o, i, length * 2);
- *sample_length = length * 2;
+ *sample_length = length;
return length;
}
return length / 2;
}
- int const
+ int
ModemNoOp::frame_duration() const
{
return 1;
}
- std::size_t const
+ std::size_t
ModemNoOp::samples_per_frame() const
{
return 1;
std::size_t
AudioInALSA::read16(std::int16_t * array, std::size_t length)
{
- return length;
+ const int result = snd_pcm_writei(handle, array, length);
+ if ( result >= 0 )
+ return result;
+ else {
+ // FIX: do_throw(result, "Write");
+ return 0; // do_throw doesn't return.
+ }
}
AudioInput *
char * const parameters;
snd_pcm_t * handle;
- volatile void
+ void
do_throw(const int error, const char * message = 0)
{
std::ostringstream str;
const int result = snd_pcm_writei(handle, array, length);
if ( result >= 0 )
return result;
- else
+ else {
do_throw(result, "Write");
+ return 0; // do_throw doesn't return.
+ }
}
AudioOutput *
if ( (available = snd_pcm_avail(handle)) >= 0 )
return available;
- else
+ else {
do_throw(available, "Get Available Frames");
+ return 0; // do_throw doesn't return.
+ }
}
static bool
private:
const std::size_t TempSize = 2048;
Interfaces * const i;
- bool begin_transmit;
bool begin_receive;
- FIFO input_fifo;
+ bool begin_transmit;
FIFO codec_fifo;
+ FIFO input_fifo;
FIFO output_fifo;
bool ptt_digital;
bool ptt_ssb;
void transmit_digital();
void transmit_ssb();
public:
- int run();
-
Run(Interfaces *);
~Run();
+
+ void run();
};
Run::Run(Interfaces * interfaces)
- : begin_receive(true), begin_transmit(false), i(interfaces),
- ptt_digital(false), ptt_ssb(false),
- input_fifo(TempSize * 2), codec_fifo(TempSize * 2), output_fifo(TempSize * 2)
+ : i(interfaces), begin_receive(true), begin_transmit(false),
+ codec_fifo(TempSize * 2), input_fifo(TempSize * 2),
+ output_fifo(TempSize * 2), ptt_digital(false), ptt_ssb(false)
{
}
output_fifo.reset();
}
- int
- Run::run()
- {
- while ( true ) {
- if ( i->ptt_input_digital->ready() ) {
- bool state = i->ptt_input_digital->state();
- if ( state && !ptt_digital && !ptt_ssb ) {
- ptt_digital = true;
- begin_transmit = true;
- }
- else if ( !state && ptt_digital ) {
- begin_receive = true;
- ptt_digital = false;
- }
- }
- if ( i->ptt_input_ssb->ready() ) {
- bool state = i->ptt_input_ssb->state();
- if ( state && !ptt_digital && !ptt_ssb ) {
- ptt_ssb = true;
- begin_transmit = true;
- }
- else if ( !state && ptt_ssb ) {
- begin_receive = true;
- ptt_ssb = false;
- }
- }
- if ( begin_transmit ) {
- reset_fifos();
- key_down();
- }
- else if ( begin_receive ) {
- reset_fifos();
- key_up();
- }
- else if ( ptt_digital ) {
- transmit_digital();
- }
- else if ( ptt_ssb ) {
- transmit_ssb();
- }
- else {
- receive();
- }
- usleep(20100);
- }
- }
-
void
Run::key_down() {
if ( i->keying_output->ready() ) {
Run::receive()
{
// Drain any data that the loudspeaker can take.
- const std::size_t output_samples = std::min(
+ const std::size_t output_samples = min(
i->loudspeaker->ready(),
(output_fifo.outgoing_available() / 2));
if ( output_samples ) {
const std::size_t result = i->loudspeaker->write16(
- (std::int16_t *)output_fifo.outgoing_buffer
- (output_samples * 2),
+ (std::int16_t *)output_fifo.outgoing_buffer(
+ output_samples * 2),
output_samples);
if ( result > 0 )
}
// Fill any data that the receiver can provide.
- const std::size_t input_samples = std::min(
+ const std::size_t input_samples = min(
i->receiver->ready(),
(input_fifo.incoming_available() / 2));
input_samples);
if ( result > 0 )
- output_fifo.outgoing_done(result * 2);
+ input_fifo.incoming_done(result * 2);
else
std::cerr << "Loudspeaker I/O error: " << strerror(errno) << std::endl;
}
input_fifo.outgoing_done(samples_to_demodulate * 2);
if ( result > 0 )
- output_fifo.incoming_done(result * i->modem->bytes_per_frame());
+ codec_fifo.incoming_done(result);
}
const std::size_t frames_to_decode =
}
}
+ void
+ Run::run()
+ {
+ while ( true ) {
+ receive();
+ }
+ }
+
void
Run::transmit_digital()
{
run(Interfaces * i)
{
Run * r = new Run(i);
- return r->run();
+ r->run();
+ return 0;
}
}
};
TEST_F(BlankPanelTest, NeverReady) {
- EXPECT_EQ(0, u->ready());
+ EXPECT_EQ(0U, u->ready());
}
};
TEST_F(FIFOTest, CanFillAndDrain) {
- ASSERT_EQ(100, f->incoming_available());
+ ASSERT_EQ(100U, f->incoming_available());
memset(f->incoming_buffer(100), 255, 100);
- ASSERT_EQ(0, f->outgoing_available());
+ ASSERT_EQ(0U, f->outgoing_available());
f->incoming_done(100);
- ASSERT_EQ(100, f->outgoing_available());
- ASSERT_EQ(0, f->incoming_available());
+ ASSERT_EQ(100U, f->outgoing_available());
+ ASSERT_EQ(0U, f->incoming_available());
EXPECT_THROW(f->incoming_buffer(1), std::runtime_error);
- ASSERT_EQ(100, f->outgoing_available());
+ ASSERT_EQ(100U, f->outgoing_available());
ASSERT_NE((uint8_t *)0, f->outgoing_buffer(100));
f->outgoing_done(100);
- ASSERT_EQ(0, f->outgoing_available());
- ASSERT_EQ(100, f->incoming_available());
- ASSERT_EQ(100, f->incoming_available());
+ ASSERT_EQ(0U, f->outgoing_available());
+ ASSERT_EQ(100U, f->incoming_available());
+ ASSERT_EQ(100U, f->incoming_available());
memset(f->incoming_buffer(100), 255, 100);
- ASSERT_EQ(0, f->outgoing_available());
+ ASSERT_EQ(0U, f->outgoing_available());
f->incoming_done(100);
- ASSERT_EQ(100, f->outgoing_available());
- ASSERT_EQ(0, f->incoming_available());
+ ASSERT_EQ(100U, f->outgoing_available());
+ ASSERT_EQ(0U, f->incoming_available());
}
TEST_F(FIFOTest, Reorder) {
uint8_t * b;
const uint8_t * r;
- ASSERT_EQ(100, f->incoming_available());
+ ASSERT_EQ(100U, f->incoming_available());
ASSERT_NE((uint8_t *)0, b = f->incoming_buffer(99));
memset(b, 0, 98);
b[98] = 'b';
f->incoming_done(99);
- ASSERT_EQ(1, f->incoming_available());
- ASSERT_EQ(99, f->outgoing_available());
+ ASSERT_EQ(1U, f->incoming_available());
+ ASSERT_EQ(99U, f->outgoing_available());
ASSERT_NE((uint8_t *)0, f->outgoing_buffer(98));
f->outgoing_done(98);
- ASSERT_EQ(1, f->outgoing_available());
- ASSERT_EQ(99, f->incoming_available());
+ ASSERT_EQ(1U, f->outgoing_available());
+ ASSERT_EQ(99U, f->incoming_available());
// This should cause reorder().
ASSERT_NE((uint8_t *)0, b = f->incoming_buffer(2));
f->incoming_done(0);
- ASSERT_EQ(99, f->incoming_available());
- ASSERT_EQ(1, f->outgoing_available());
+ ASSERT_EQ(99U, f->incoming_available());
+ ASSERT_EQ(1U, f->outgoing_available());
ASSERT_NE((uint8_t *)0, r = f->outgoing_buffer(1));
ASSERT_EQ('b', *r);
f->outgoing_done(1);
}
TEST_F(FIFOTest, CanReset) {
- ASSERT_EQ(100, f->incoming_available());
- ASSERT_EQ(0, f->outgoing_available());
+ ASSERT_EQ(100U, f->incoming_available());
+ ASSERT_EQ(0U, f->outgoing_available());
f->incoming_done(100);
- ASSERT_EQ(100, f->outgoing_available());
- ASSERT_EQ(0, f->incoming_available());
+ ASSERT_EQ(100U, f->outgoing_available());
+ ASSERT_EQ(0U, f->incoming_available());
f->reset();
- ASSERT_EQ(0, f->outgoing_available());
- ASSERT_EQ(100, f->incoming_available());
+ ASSERT_EQ(0U, f->outgoing_available());
+ ASSERT_EQ(100U, f->incoming_available());
}
};
TEST_F(PTTInputTransmitTest, ReadyAndRead) {
- EXPECT_EQ(1, i->ready());
- EXPECT_EQ(1, i->ready());
+ EXPECT_EQ(1U, i->ready());
+ EXPECT_EQ(1U, i->ready());
EXPECT_TRUE(i->state());
- EXPECT_EQ(0, i->ready());
- EXPECT_EQ(0, i->ready());
+ EXPECT_EQ(0U, i->ready());
+ EXPECT_EQ(0U, i->ready());
EXPECT_THROW(i->state(), std::runtime_error);
}
TEST_F(PTTInputReceiveTest, ReadyAndRead) {
- EXPECT_EQ(1, i->ready());
- EXPECT_EQ(1, i->ready());
+ EXPECT_EQ(1U, i->ready());
+ EXPECT_EQ(1U, i->ready());
EXPECT_FALSE(i->state());
- EXPECT_EQ(0, i->ready());
- EXPECT_EQ(0, i->ready());
+ EXPECT_EQ(0U, i->ready());
+ EXPECT_EQ(0U, i->ready());
EXPECT_THROW(i->state(), std::runtime_error);
}
char buffer[1024];
EXPECT_EQ(sizeof(text) - 1, i->ready());
- EXPECT_EQ(10, i->read(buffer, 10));
+ EXPECT_EQ(10U, i->read(buffer, 10));
EXPECT_EQ(sizeof(text) - 1 - 10, i->ready());
- EXPECT_EQ(0, i->read(buffer, 0));
+ EXPECT_EQ(0U, i->read(buffer, 0));
EXPECT_EQ(sizeof(text) - 1 - 10, i->ready());
EXPECT_EQ(sizeof(text) - 1 - 10, i->read(buffer, sizeof(buffer)));
- EXPECT_EQ(0, i->ready());
+ EXPECT_EQ(0U, i->ready());
EXPECT_THROW(i->read(buffer, sizeof(buffer)), std::runtime_error);
}
/// This driver provides constant text.
class TextConstant : public TextInput {
private:
- const std::size_t length;
std::size_t index;
+ const std::size_t length;
public:
/// Instantiate the constant text driver.
array[i] = (std::int16_t)rint(value * master_amplitude * ((1 << 15) - 1));
}
clock = (clock + length) % SampleRate;
+
+ return length;
}
std::size_t
#include "drivers.h"
namespace FreeDV {
- UserInterface::UserInterface(const char * name, const char * parameters, Interfaces * interfaces)
+ UserInterface::UserInterface(const char * name, const char * parameters, Interfaces *)
: IODevice(name, parameters)
{
}
projects / freetel-svn-tracking.git / commitdiff