Fixed compilation warnings

examples/streamer/helpers.cpp

@@ -44,8 +44,8 @@ int gettimeofday(struct timeval *tv, struct timezone *tz)
         x.LowPart =  filetime.dwLowDateTime;
         x.HighPart = filetime.dwHighDateTime;
         usec = x.QuadPart / 10  -  epoch_offset_us;
-        tv->tv_sec  = (time_t)(usec / 1000000ULL);
-        tv->tv_usec = (long)(usec % 1000000ULL);
+        tv->tv_sec  = time_t(usec / 1000000ULL);
+        tv->tv_usec = long(usec % 1000000ULL);
     }
     if (tz) {
         TIME_ZONE_INFORMATION timezone;

src/impl/tcpserver.cpp

@@ -142,7 +142,7 @@ void TcpServer::listen(uint16_t port) {
 			throw std::runtime_error("Failed to set socket non-blocking mode");
 
 		// Bind socket
-		if (::bind(mSock, ai->ai_addr, ai->ai_addrlen) < 0) {
+		if (::bind(mSock, ai->ai_addr, socklen_t(ai->ai_addrlen)) < 0) {
 			PLOG_WARNING << "TCP server socket binding on port " << port
 			             << " failed, errno=" << sockerrno;
 			throw std::runtime_error("TCP server socket binding failed");

src/impl/tcptransport.cpp

@@ -211,7 +211,7 @@ void TcpTransport::connect(const sockaddr *addr, socklen_t addrlen) {
 
 		do {
 			auto timeout = std::max(clock::duration::zero(), end - clock::now());
-			ret = ::poll(pfd, 1, duration_cast<milliseconds>(timeout).count());
+			ret = ::poll(pfd, 1, int(duration_cast<milliseconds>(timeout).count()));
 
 		} while (ret < 0 && (sockerrno == SEINTR || sockerrno == SEAGAIN));
 
@@ -336,7 +336,7 @@ void TcpTransport::runLoop() {
 			lock.unlock();
 			do {
 				auto timeout = std::max(clock::duration::zero(), end - clock::now());
-				ret = ::poll(pfd, 2, duration_cast<milliseconds>(timeout).count());
+				ret = ::poll(pfd, 2, int(duration_cast<milliseconds>(timeout).count()));
 
 			} while (ret < 0 && (sockerrno == SEINTR || sockerrno == SEAGAIN));
 			lock.lock();

src/impl/tls.cpp

@@ -141,12 +141,12 @@ BIO *BIO_new_from_file(const string &filename) {
 		char buffer[bufferSize];
 		while (ifs.good()) {
 			ifs.read(buffer, bufferSize);
-			BIO_write(bio, buffer, ifs.gcount());
+			BIO_write(bio, buffer, int(ifs.gcount()));
 		}
 		ifs.close();
 		return bio;
 
-	} catch (const std::exception &e) {
+	} catch (const std::exception &) {
 		BIO_free(bio);
 		return nullptr;
 	}

src/nalunit.cpp

@@ -40,12 +40,8 @@ NalUnitFragmentA::NalUnitFragmentA(FragmentType type, bool forbiddenBit, uint8_t
 std::vector<shared_ptr<NalUnitFragmentA>>
 NalUnitFragmentA::fragmentsFrom(shared_ptr<NalUnit> nalu, uint16_t maximumFragmentSize) {
 	assert(nalu->size() > maximumFragmentSize);
-	if (nalu->size() <= maximumFragmentSize) {
-		// we need to change `maximum_fragment_size` to have at least two fragments
-		maximumFragmentSize = nalu->size() / 2;
-	}
 	auto fragments_count = ceil(double(nalu->size()) / maximumFragmentSize);
-	maximumFragmentSize = ceil(nalu->size() / fragments_count);
+	maximumFragmentSize = uint16_t(int(ceil(nalu->size() / fragments_count)));
 
 	// 2 bytes for FU indicator and FU header
 	maximumFragmentSize -= 2;
@@ -64,7 +60,7 @@ NalUnitFragmentA::fragmentsFrom(shared_ptr<NalUnit> nalu, uint16_t maximumFragme
 			fragmentType = FragmentType::Middle;
 		} else {
 			if (offset + maximumFragmentSize > payload.size()) {
-				maximumFragmentSize = payload.size() - offset;
+				maximumFragmentSize = uint16_t(payload.size() - offset);
 			}
 			fragmentType = FragmentType::End;
 		}

src/rtcpnackresponder.cpp

@@ -30,7 +30,7 @@ RtcpNackResponder::Storage::Element::Element(binary_ptr packet, uint16_t sequenc
                                              shared_ptr<Element> next)
     : packet(packet), sequenceNumber(sequenceNumber), next(next) {}
 
-unsigned RtcpNackResponder::Storage::size() { return storage.size(); }
+unsigned RtcpNackResponder::Storage::size() { return unsigned(storage.size()); }
 
 RtcpNackResponder::Storage::Storage(unsigned _maximumSize) : maximumSize(_maximumSize) {
 	assert(maximumSize > 0);
@@ -80,10 +80,10 @@ RtcpNackResponder::processIncomingControlMessage(message_ptr message) {
 	optional<ChainedOutgoingProduct> optPackets = ChainedOutgoingProduct(nullptr);
 	auto packets = make_chained_messages_product();
 
-	unsigned int i = 0;
-	while (i < message->size()) {
-		auto nack = reinterpret_cast<RTCP_NACK *>(message->data() + i);
-		i += nack->header.header.lengthInBytes();
+	size_t p = 0;
+	while (p < message->size()) {
+		auto nack = reinterpret_cast<RTCP_NACK *>(message->data() + p);
+		p += nack->header.header.lengthInBytes();
 		// check if rtcp is nack
 		if (nack->header.header.payloadType() != 205 || nack->header.header.reportCount() != 1) {
 			continue;

src/rtcpsrreporter.cpp

@@ -39,7 +39,7 @@ ChainedOutgoingProduct RtcpSrReporter::processOutgoingBinaryMessage(ChainedMessa
 	}
 	for (auto message : *messages) {
 		auto rtp = reinterpret_cast<RTP *>(message->data());
-		addToReport(rtp, message->size());
+		addToReport(rtp, uint32_t(message->size()));
 	}
 	return {messages, control};
 }
@@ -52,14 +52,14 @@ void RtcpSrReporter::startRecording() {
 void RtcpSrReporter::addToReport(RTP *rtp, uint32_t rtpSize) {
 	packetCount += 1;
 	assert(!rtp->padding());
-	payloadOctets += rtpSize - rtp->getSize();
+	payloadOctets += rtpSize - uint32_t(rtp->getSize());
 }
 
 RtcpSrReporter::RtcpSrReporter(shared_ptr<RtpPacketizationConfig> rtpConfig)
     : MediaHandlerElement(), rtpConfig(rtpConfig) {}
 
 uint64_t RtcpSrReporter::secondsToNTP(double seconds) {
-	return std::round(seconds * double(uint64_t(1) << 32));
+	return uint64_t(std::round(seconds * double(uint64_t(1) << 32)));
 }
 
 void RtcpSrReporter::setNeedsToReport() { needsToReport = true; }