Adjustments for the new client

native/serverconnection/src/connection/ProtocolHandler.cpp

@@ -444,7 +444,7 @@ bool ProtocolHandler::create_datagram_packets(std::vector<pipes::buffer> &result
 		} else {
 			packet->applyPacketId(this->_packet_id_manager);
 		}
-		log_trace(category::connection, tr("Packet {} got packet id {}"), packet->type().name(), packet->packetId());
+		//log_trace(category::connection, tr("Packet {} got packet id {}"), packet->type().name(), packet->packetId());
 	}
 	if(!this->crypt_handler.progressPacketOut(packet.get(), error, false)) {
 		log_error(category::connection, tr("Failed to encrypt packet: {}"), error);

native/serverconnection/src/connection/ProtocolHandler.h

@@ -75,6 +75,8 @@ namespace tc {
 
 				ecc_key& get_identity_key() { return this->crypto.identity; }
 
+				inline std::chrono::microseconds current_ping() { return this->ping.value; }
+
 				connection_state::value connection_state = connection_state::INITIALIZING;
 				server_type::value server_type = server_type::TEASPEAK;
 			private:

native/serverconnection/src/connection/ProtocolHandlerPackets.cpp

@@ -60,29 +60,6 @@ void ProtocolHandler::handlePacketCommand(const std::shared_ptr<ts::protocol::Se
 
 void ProtocolHandler::handlePacketVoice(const std::shared_ptr<ts::protocol::ServerPacket> &packet) {
 	this->handle->voice_connection->process_packet(packet);
-
-	/*
-	if(packet->type() == PacketTypeInfo::Voice) {
-		if(packet->data().length() < 5) {
-			//TODO log invalid voice packet
-			return;
-		}
-		auto container = make_unique<ServerConnection::VoicePacket>();
-		container->packet_id = be2le16(&packet->data()[0]);
-		container->client_id = be2le16(&packet->data()[2]);
-		container->codec_id = (uint8_t) packet->data()[4];
-		container->flag_head = packet->hasFlag(PacketFlag::Compressed);
-		container->voice_data = packet->data().length() > 5 ? packet->data().range(5) : pipes::buffer{};
-
-		{
-			lock_guard lock(this->handle->pending_voice_lock);
-			this->handle->pending_voice.push_back(move(container));
-		}
-		this->handle->execute_pending_voice.call(true);
-	} else {
-		//TODO implement whisper
-	}
-	 */
 }
 
 void ProtocolHandler::handlePacketPing(const std::shared_ptr<ts::protocol::ServerPacket> &packet) {

native/serverconnection/src/connection/ServerConnection.cpp

@@ -58,6 +58,7 @@ NAN_MODULE_INIT(ServerConnection::Init) {
 	Nan::SetPrototypeMethod(klass, "send_command", ServerConnection::_send_command);
 	Nan::SetPrototypeMethod(klass, "send_voice_data", ServerConnection::_send_voice_data);
 	Nan::SetPrototypeMethod(klass, "send_voice_data_raw", ServerConnection::_send_voice_data_raw);
+	Nan::SetPrototypeMethod(klass, "current_ping", ServerConnection::_current_ping);
 
 	constructor().Reset(Nan::GetFunction(klass).ToLocalChecked());
 }
@@ -641,4 +642,13 @@ void ServerConnection::_execute_callback_disconnect(const std::string &reason) {
 	arguments[0] = Nan::New<v8::String>(reason).ToLocalChecked();
 	callback->Call(Nan::GetCurrentContext(), Nan::Undefined(), 1, arguments);
 
+}
+
+NAN_METHOD(ServerConnection::_current_ping) {
+	auto connection = ObjectWrap::Unwrap<ServerConnection>(info.Holder());
+	auto& phandler = connection->protocol_handler;
+	if(phandler)
+		info.GetReturnValue().Set((uint32_t) chrono::floor<microseconds>(phandler->current_ping()).count());
+	else
+		info.GetReturnValue().Set(-1);
 }

native/serverconnection/src/connection/ServerConnection.h

@@ -85,6 +85,7 @@ namespace tc {
 				static NAN_METHOD(_send_voice_data);
 				static NAN_METHOD(_send_voice_data_raw);
 				static NAN_METHOD(_error_message);
+				static NAN_METHOD(_current_ping);
 
 				std::unique_ptr<Nan::Callback> callback_connect;
 				std::unique_ptr<Nan::Callback> callback_disconnect;

native/serverconnection/src/connection/audio/VoiceClient.cpp

@@ -208,12 +208,27 @@ VoiceClientWrap::~VoiceClientWrap() {}
 
 VoiceClient::VoiceClient(const std::shared_ptr<VoiceConnection>&, uint16_t client_id) : _client_id(client_id) {
 	this->output_source = global_audio_output->create_source();
-	this->output_source->overflow_strategy = audio::overflow_strategy::discard_buffer_half;
-	this->output_source->max_latency = (size_t) ceil(this->output_source->sample_rate * 0.12);
+	this->output_source->overflow_strategy = audio::overflow_strategy::ignore;
+	this->output_source->max_latency = (size_t) ceil(this->output_source->sample_rate * 1);
 	this->output_source->min_buffer = (size_t) ceil(this->output_source->sample_rate * 0.025);
 
 	this->output_source->on_underflow = [&]{
-		this->set_state(state::stopped);
+		if(this->_state == state::stopping)
+			this->set_state(state::stopped);
+		else if(this->_state != state::stopped) {
+			if(this->_last_received_packet + chrono::seconds(1) < chrono::system_clock::now()) {
+				this->set_state(state::stopped);
+				log_warn(category::audio, tr("Client {} has a audio buffer underflow and not received any data for one second. Stopping replay."), this->_client_id);
+			} else {
+				if(this->_state != state::buffering) {
+					log_warn(category::audio, tr("Client {} has a audio buffer underflow. Buffer again."), this->_client_id);
+					this->set_state(state::buffering);
+				}
+			}
+		}
+	};
+	this->output_source->on_overflow = [&](size_t count){
+		log_warn(category::audio, tr("Client {} has a audio buffer overflow of {}."), this->_client_id, count);
 	};
 }
 
@@ -265,6 +280,7 @@ void VoiceClient::process_packet(uint16_t packet_id, const pipes::buffer_view& b
 	encoded_buffer->buffer = buffer.own_buffer();
 	encoded_buffer->head = head;
 
+	this->_last_received_packet = encoded_buffer->receive_timestamp;
 	{
 		lock_guard lock(this->audio_decode_queue_lock);
 		this->audio_decode_queue.push_back(move(encoded_buffer));
@@ -356,7 +372,7 @@ void VoiceClient::process_encoded_buffer(const std::unique_ptr<EncodedBuffer> &b
 		diff = buffer->packet_id - codec_data->last_packet_id;
 	}
 
-	if(codec_data->last_packet_timestamp + chrono::seconds(1) < buffer->receive_timestamp)
+	if(codec_data->last_packet_timestamp + chrono::seconds(1) < buffer->receive_timestamp || this->_state >= state::stopping)
 		diff = 0xFFFF;
 
 	const auto old_packet_id = codec_data->last_packet_id;
@@ -427,6 +443,7 @@ void VoiceClient::process_encoded_buffer(const std::unique_ptr<EncodedBuffer> &b
 	}
 
 	auto enqueued = this->output_source->enqueue_samples(target_buffer, resampled_samples);
+	if(enqueued != resampled_samples)
+		log_warn(category::voice_connection, tr("Failed to enqueue all samples for client {}. Enqueued {} of {}"), this->_client_id, enqueued, resampled_samples);
 	this->set_state(state::playing);
-	//cout << "Enqueued " << enqueued << " samples" << endl;
 }

native/serverconnection/src/connection/audio/VoiceClient.h

@@ -112,6 +112,7 @@ namespace tc {
 				uint16_t _client_id;
 				float _volume = 1.f;
 
+				std::chrono::system_clock::time_point _last_received_packet;
 				state::value _state = state::stopped;
 				inline void set_state(state::value value) {
 					if(value == this->_state)

native/serverconnection/src/connection/audio/VoiceConnection.cpp

@@ -299,6 +299,7 @@ void VoiceConnection::process_packet(const std::shared_ptr<ts::protocol::ServerP
 		auto flag_head = packet->has_flag(PacketFlag::Compressed);
 		//container->voice_data = packet->data().length() > 5 ? packet->data().range(5) : pipes::buffer{};
 
+		//log_info(category::voice_connection, tr("Received voice packet from {}. Packet ID: {}"), client_id, packet_id);
 		auto client = this->find_client(client_id);
 		if(!client) {
 			log_warn(category::voice_connection, tr("Received voice packet from unknown client {}. Dropping packet!"), client_id);