/** * @brief Send an interleaved RTCP packet down to the RTCP handler * * @param rtsp The RTSP client where the handler can be found * @param channel The channel index where the package arrived * @param data The pointer to the data to send * @param len The length of the data to send * * This function is used to send data down to the actual RTCP handler * after it has been received from an interleaved transport (TCP or * SCTP alike). */ void interleaved_rtcp_send(RTSP_Client *rtsp, int channel, void *data, size_t len) { RTSP_interleaved *intlvd = NULL; GSList *intlvd_iter = g_slist_find_custom(rtsp->interleaved, GINT_TO_POINTER(channel), interleaved_rtcp_find_compare); /* We have to check if the value returned by g_slist_find_custom * is valid before derefencing it. */ if ( intlvd_iter == NULL ) { fnc_log(FNC_LOG_DEBUG, "Interleaved RTCP packet arrived for unknown channel (%d)... discarding.\n", channel); return; } intlvd = (RTSP_interleaved *)intlvd_iter->data; /* We should be pretty sure this is not NULL */ g_assert(intlvd != NULL); /* Write the actual data */ Sock_write(intlvd->rtcp.local, data, len, NULL, MSG_DONTWAIT | MSG_EOR); }
static __inline__ gint __rtp_pkt_send(RTP_session *session, RTP_transport *transport, RTP_packet *packet, gsize packet_size) { switch (transport->trans_mode) { case RTP_OVER_UDP: return Sock_write(transport->rtp_sock, packet, packet_size, NULL, MSG_DONTWAIT | MSG_EOR); case RTP_OVER_TCP: return __rtp_pkt_send_rot(session, transport, packet, packet_size); case RTP_OVER_RTSP: return __rtp_pkt_send_ror(session, transport, packet, packet_size); } return -1; }
void in_Rsockwrite(int *sockp, char **buf, int *start, int *end, int *len) { ssize_t n; if (*end > *len) *end = *len; if (*start < 0) *start = 0; if (*end < *start) { *len = -1; return; } check_init(); #ifdef DEBUG printf("writing %s to %d", *buf, *sockp); #endif perr.error = 0; n = Sock_write(*sockp, *buf + *start, *end - *start, &perr); *len = (int) n; if(perr.error) REprintf("socket error: %s\n", strerror(perr.error)); }
/** * @brief Send the actual buffer as an RTP packet to the client * * @param session The RTP session to send the packet for * @param buffer The data for the packet to be sent * * @return The number of frames sent to the client. * @retval -1 Error during writing. */ static void rtp_packet_send(RTP_session *session, MParserBuffer *buffer) { const size_t packet_size = sizeof(RTP_packet) + buffer->data_size; RTP_packet *packet = g_malloc0(packet_size); Track *tr = session->track; const uint32_t timestamp = RTP_calc_rtptime(session, tr->properties.clock_rate, buffer); packet->version = 2; packet->padding = 0; packet->extension = 0; packet->csrc_len = 0; packet->marker = buffer->marker & 0x1; packet->payload = tr->properties.payload_type & 0x7f; packet->seq_no = htons(++session->seq_no); packet->timestamp = htonl(timestamp); packet->ssrc = htonl(session->ssrc); fnc_log(FNC_LOG_VERBOSE, "[RTP] Timestamp: %u", ntohl(timestamp)); memcpy(packet->data, buffer->data, buffer->data_size); if (Sock_write(session->transport.rtp_sock, packet, packet_size, NULL, MSG_DONTWAIT | MSG_EOR) < 0) { fnc_log(FNC_LOG_DEBUG, "RTP Packet Lost\n"); } else { session->last_timestamp = buffer->timestamp; session->pkt_count++; session->octet_count += buffer->data_size; session->last_packet_send_time = time(NULL); } g_free(packet); }