transmit.h File Reference

#include "audio/types.h"
#include "rtp/rtpenc_h264.h"
#include "types.h"
#include <cstdint>

Include dependency graph for transmit.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Functions
void	audio_tx_send (struct tx *tx_session, struct rtp *rtp_session, const audio_frame2 *buffer)
void	audio_tx_send_standard (struct tx *tx, struct rtp *rtp_session, const audio_frame2 *buffer)
void	format_audio_header (const class audio_frame2 *frame, int channel, int buffer_idx, uint32_t *audio_hdr)
void	format_video_header (struct video_frame *frame, int tile_idx, int buffer_idx, uint32_t *hdr)
int	tx_get_buffer_id (struct tx *tx_session)
struct tx *	tx_init (struct module *parent, unsigned mtu, enum tx_media_type media_type, const char *fec, const char *encryption, long long bitrate)
void	tx_send (struct tx *tx_session, struct video_frame *frame, struct rtp *rtp_session)
void	tx_send_h264 (struct tx *tx_session, struct video_frame *frame, struct rtp *rtp_session)
void	tx_send_jpeg (struct tx *tx_session, struct video_frame *frame, struct rtp *rtp_session)

Function Documentation

audio_tx_send()

void audio_tx_send	(	struct tx *	tx_session,
		struct rtp *	rtp_session,
		const audio_frame2 *	buffer )

Definition at line 799 of file transmit.cpp.

{
        if (!rtp_has_receiver(rtp_session)) {
                return;
        }
 
        fec_check_messages(tx);
 
        const uint32_t timestamp =
            buffer->get_timestamp() == -1
                ? get_local_mediatime()
                : get_local_mediatime_offset() + buffer->get_timestamp();
 
        for (int iter = 0; iter < tx->mult_count; ++iter) {
                for (int chan = 0; chan < buffer->get_channel_count(); ++chan) {
                        bool send_m = iter == tx->mult_count - 1 &&
                                      chan == buffer->get_channel_count() - 1;
                        audio_tx_send_chan(tx, rtp_session, timestamp, buffer,
                                           chan, send_m);
                }
        }
 
        tx->buffer++;
}

References audio_tx_send_chan(), tx::buffer, fec_check_messages(), audio_frame2::get_channel_count(), get_local_mediatime(), get_local_mediatime_offset(), audio_frame2::get_timestamp(), tx::mult_count, and rtp_has_receiver().

Referenced by audio_sender_thread(), and state_audio_mixer::worker().

Here is the call graph for this function:

audio_tx_send_standard()

void audio_tx_send_standard	(	struct tx *	tx,
		struct rtp *	rtp_session,
		const audio_frame2 *	buffer )

audio_tx_send_standard - Send interleaved channels from the audio_frame2, as the mulaw and A-law standards (dynamic or std PT).

Definition at line 958 of file transmit.cpp.

                                             {
        //TODO to be more abstract in order to accept A-law too and other supported standards with such implementation
        assert(buffer->get_codec() == AC_MULAW ||
               buffer->get_codec() == AC_ALAW ||
               buffer->get_codec() == AC_MP3 ||
               buffer->get_codec() == AC_OPUS);
 
        uint32_t ts;
        static uint32_t ts_prev = 0;
 
        enum {
                PCMA_U_BPS = 1, // data BPS - get_bps() is 2 to expand to 16-bit
                                // format on the receiver. The semantic of 2 is
                                // the same as for other codecs like Opus to
                                // asses the decmopressed sample size.
        };
        const bool is_pcma_u =
            buffer->get_codec() == AC_MULAW || buffer->get_codec() == AC_ALAW;
        // Configure the right Payload type,
        // 8000 Hz, 1 channel PCMU/A is the ITU-T G.711 standard
        // Other channels or Hz goes to DynRTP-Type97
        int pt = PT_DynRTP_Type97;
        if (is_pcma_u && buffer->get_channel_count() == 1 &&
            buffer->get_sample_rate() == kHz8) {
                pt = buffer->get_codec() == AC_MULAW ? PT_ITU_T_G711_PCMU
                                                     : PT_ITU_T_G711_PCMA;
        }
        if (buffer->get_codec() == AC_MP3) {
                pt = PT_MPA;
        }
 
        int data_len = buffer->get_data_len(0);         /* Number of samples to send                    */
        int payload_size = tx->mtu - 40 - 8 - 12; /* Max size of an RTP payload field (minus IPv6, UDP and RTP header lengths) */
 
        if (is_pcma_u) { // we may split the data into more packets, compute
                         //  chunk size
                const int frame_size = buffer->get_channel_count() * PCMA_U_BPS;
                payload_size = payload_size / frame_size * frame_size; // align to frame size
                // The sizes for the different channels must be the same.
                for (int i = 1; i < buffer->get_channel_count(); i++) {
                        assert(buffer->get_data_len(0) ==
                               buffer->get_data_len(i));
                }
                data_len *= buffer->get_channel_count();
        } else if (pt == PT_MPA) {
                payload_size -= sizeof(mpa_hdr_t);
        }
 
        if (!validate_std_audio(buffer, payload_size)) {
                return;
        }
 
        int pos = 0;
        do {
                int pkt_len = std::min(payload_size, data_len - pos);
 
                if (buffer->get_codec() == AC_OPUS) {
                        memcpy(tx->tmp_packet, buffer->get_data(0), pkt_len);
                } else if (buffer->get_codec() == AC_MP3) {
                        memset(tx->tmp_packet, 0, 2);
                        const uint16_t offset = htons(pos);
                        memcpy(tx->tmp_packet + 2, &offset, sizeof offset);
                        pkt_len += sizeof(mpa_hdr_t);
                        memcpy(tx->tmp_packet + 4, buffer->get_data(0), pkt_len);
                } else { // interleave
                        for (int ch = 0; ch < buffer->get_channel_count(); ch++) {
                                remux_channel(
                                    tx->tmp_packet,
                                    buffer->get_data(ch) +
                                        pos / buffer->get_channel_count(),
                                    PCMA_U_BPS,
                                    pkt_len / buffer->get_channel_count(), 1,
                                    buffer->get_channel_count(), 0, ch);
                        }
                }
 
                // Update first sample timestamp
                if (buffer->get_codec() == AC_OPUS) {
                        /* OPUS packet will be the whole contained in one packet
                         * according to RFC 7587. For PCMA/PCMU there may be more
                         * packets so we cannot use the whole frame duration. */
                        ts = get_std_audio_local_mediatime(buffer->get_duration(), 48000);
                } else {
                        ts = get_std_audio_local_mediatime((double) pkt_len / (double) buffer->get_channel_count() / (double) buffer->get_sample_rate(), buffer->get_sample_rate());
                }
                rtp_send_ctrl(rtp_session, ts_prev, 0, get_time_in_ns()); //send RTCP SR
                ts_prev = ts;
                // Send the packet
                rtp_send_data(rtp_session, ts, pt, 0, 0, /* contributing sources                */
                                0,                                                                                              /* contributing sources length  */
                                tx->tmp_packet, pkt_len, 0, 0, 0);
                pos += pkt_len;
        } while (pos < data_len);
}

References AC_ALAW, AC_MP3, AC_MULAW, AC_OPUS, audio_frame2::get_channel_count(), audio_frame2::get_codec(), audio_frame2::get_data(), audio_frame2::get_data_len(), audio_frame2::get_duration(), audio_frame2::get_sample_rate(), get_std_audio_local_mediatime(), get_time_in_ns(), kHz8, tx::mtu, offset, PT_DynRTP_Type97, PT_ITU_T_G711_PCMA, PT_ITU_T_G711_PCMU, PT_MPA, remux_channel(), rtp_send_ctrl(), rtp_send_data(), tx::tmp_packet, ts, and validate_std_audio().

Referenced by audio_sender_thread().

Here is the call graph for this function:

format_audio_header()

void format_audio_header	(	const class audio_frame2 *	frame,
		int	channel,
		int	buffer_idx,
		uint32_t *	audio_hdr )

format_video_header()

void format_video_header	(	struct video_frame *	frame,
		int	tile_idx,
		int	buffer_idx,
		uint32_t *	hdr )

Definition at line 445 of file transmit.cpp.

{
        uint32_t tmp;
 
        video_hdr[3] = htonl(frame->tiles[tile_idx].width << 16 | frame->tiles[tile_idx].height);
        video_hdr[4] = get_fourcc(frame->color_spec);
        video_hdr[2] = htonl(frame->tiles[tile_idx].data_len);
        tmp = tile_idx << 22;
        tmp |= 0x3fffff & buffer_idx;
        video_hdr[0] = htonl(tmp);
 
        /* word 6 */
        video_hdr[5] = format_interl_fps_hdr_row(frame->interlacing, frame->fps);
}

References video_frame::color_spec, tile::data_len, format_interl_fps_hdr_row(), video_frame::fps, frame, get_fourcc(), tile::height, video_frame::interlacing, video_frame::tiles, and tile::width.

Referenced by rs::encode(), and tx_send_base().

Here is the call graph for this function:

tx_get_buffer_id()

int tx_get_buffer_id

(

struct tx *

tx_session

)

Returns buffer ID to be sent with next tx_send() call

Definition at line 1240 of file transmit.cpp.

{
        return tx->buffer;
 
}

References tx::buffer.

tx_init()

struct tx * tx_init	(	struct module *	parent,
		unsigned	mtu,
		enum tx_media_type	media_type,
		const char *	fec,
		const char *	encryption,
		long long	bitrate )

tx_send()

void tx_send	(	struct tx *	tx_session,
		struct video_frame *	frame,
		struct rtp *	rtp_session )

Definition at line 407 of file transmit.cpp.

{
        unsigned int i;
 
        assert(!frame->fragment || tx->fec_scheme == FEC_NONE); // currently no support for FEC with fragments
        assert(!frame->fragment || frame->tile_count); // multiple tile are not currently supported for fragmented send
        fec_check_messages(tx);
 
        uint32_t ts =
            (frame->flags & TIMESTAMP_VALID) == 0
                ? get_local_mediatime()
                : get_local_mediatime_offset() + frame->timestamp;
        if(frame->fragment &&
                        tx->last_frame_fragment_id == frame->frame_fragment_id) {
                ts = tx->last_ts;
        } else {
                tx->last_frame_fragment_id = frame->frame_fragment_id;
                tx->last_ts = ts;
        }
 
        for(i = 0; i < frame->tile_count; ++i)
        {
                int last = FALSE;
                int fragment_offset = 0;
                
                if (i == frame->tile_count - 1) {
                        if(!frame->fragment || frame->last_fragment)
                                last = TRUE;
                }
                if(frame->fragment)
                        fragment_offset = vf_get_tile(frame, i)->offset;
 
                tx_send_base(tx, frame, rtp_session, ts, last,
                                i, fragment_offset);
        }
        tx->buffer++;
}

References tx::buffer, FALSE, fec_check_messages(), FEC_NONE, tx::fec_scheme, video_frame::flags, video_frame::fragment, frame, video_frame::frame_fragment_id, get_local_mediatime(), get_local_mediatime_offset(), video_frame::last_fragment, tx::last_frame_fragment_id, tx::last_ts, tile::offset, video_frame::tile_count, video_frame::timestamp, TIMESTAMP_VALID, TRUE, ts, tx_send_base(), and vf_get_tile().

Referenced by ultragrid_rtp_video_rxtx::send_frame_async().

Here is the call graph for this function:

tx_send_h264()

void tx_send_h264	(	struct tx *	tx,
		struct video_frame *	frame,
		struct rtp *	rtp_session )

H.264 standard transmission

Definition at line 1057 of file transmit.cpp.

                                         {
        assert(frame->tile_count == 1); // std transmit doesn't handle more than one tile
        assert(!frame->fragment || tx->fec_scheme == FEC_NONE); // currently no support for FEC with fragments
        assert(!frame->fragment || frame->tile_count); // multiple tiles are not currently supported for fragmented send
        uint32_t ts = get_std_video_local_mediatime();
        struct tile *tile = &frame->tiles[0];
 
        char pt =  PT_DynRTP_Type96;
        unsigned char hdr[2];
        int cc = 0;
        uint32_t csrc = 0;
        int m = 0;
        char *extn = 0;
        uint16_t extn_len = 0;
        uint16_t extn_type = 0;
        const uint8_t *start = (uint8_t *) tile->data;
        int data_len = tile->data_len;
        unsigned maxPacketSize = tx->mtu - 40;
 
        const unsigned char *endptr = 0;
        const unsigned char *nal = start;
 
        while ((nal = rtpenc_get_next_nal(nal, data_len - (nal - start), &endptr))) {
                unsigned int nalsize = endptr - nal;
                bool eof = endptr == start + data_len;
                bool lastNALUnitFragment = false; // by default
                unsigned curNALOffset = 0;
                char *nalc = const_cast<char *>(reinterpret_cast<const char *>(nal));
 
                while(!lastNALUnitFragment){
                        // We have NAL unit data in the buffer.  There are three cases to consider:
                        // 1. There is a new NAL unit in the buffer, and it's small enough to deliver
                        //    to the RTP sink (as is).
                        // 2. There is a new NAL unit in the buffer, but it's too large to deliver to
                        //    the RTP sink in its entirety.  Deliver the first fragment of this data,
                        //    as a FU packet, with one extra preceding header byte (for the "FU header").
                        // 3. There is a NAL unit in the buffer, and we've already delivered some
                        //    fragment(s) of this.  Deliver the next fragment of this data,
                        //    as a FU packet, with two (H.264) extra preceding header bytes
                        //    (for the "NAL header" and the "FU header").
                        if (curNALOffset == 0) { // case 1 or 2
                                if (nalsize     <= maxPacketSize) { // case 1
 
                                        if (eof) m = 1;
                                        if (rtp_send_data(rtp_session, ts, pt, m, cc, &csrc,
                                                        nalc, nalsize,
                                                        extn, extn_len, extn_type) < 0) {
                                                error_msg("There was a problem sending the RTP packet\n");
                                        }
                                        lastNALUnitFragment = true;
                                } else { // case 2
                                        // We need to send the NAL unit data as FU packets.  Deliver the first
                                        // packet now.  Note that we add "NAL header" and "FU header" bytes to the front
                                        // of the packet (overwriting the existing "NAL header").
                                        hdr[0] = (nal[0] & 0xE0) | 28; //FU indicator
                                        hdr[1] = 0x80 | (nal[0] & 0x1F); // FU header (with S bit)
 
                                        if (rtp_send_data_hdr(rtp_session, ts, pt, m, cc, &csrc,
                                                                        (char *) hdr, 2,
                                                                        nalc + 1, maxPacketSize - 2,
                                                                        extn, extn_len, extn_type) < 0) {
                                                                                error_msg("There was a problem sending the RTP packet\n");
                                        }
                                        curNALOffset += maxPacketSize - 1;
                                        lastNALUnitFragment = false;
                                        nalsize -= maxPacketSize - 1;
                                }
                        } else { // case 3
                                // We are sending this NAL unit data as FU packets.  We've already sent the
                                // first packet (fragment).  Now, send the next fragment.  Note that we add
                                // "NAL header" and "FU header" bytes to the front.  (We reuse these bytes that
                                // we already sent for the first fragment, but clear the S bit, and add the E
                                // bit if this is the last fragment.)
                                hdr[1] = hdr[1] & ~0x80;// FU header (no S bit)
 
                                if (nalsize + 1 > maxPacketSize) {
                                        // We can't send all of the remaining data this time:
                                        if (rtp_send_data_hdr(rtp_session, ts, pt, m, cc, &csrc,
                                                        (char *) hdr, 2,
                                                        nalc + curNALOffset,
                                                        maxPacketSize - 2, extn, extn_len,
                                                        extn_type) < 0) {
                                                                error_msg("There was a problem sending the RTP packet\n");
                                        }
                                        curNALOffset += maxPacketSize - 2;
                                        lastNALUnitFragment = false;
                                        nalsize -= maxPacketSize - 2;
 
                                } else {
                                        // This is the last fragment:
                                        if (eof) m = 1;
 
                                        hdr[1] |= 0x40;// set the E bit in the FU header
 
                                        if (rtp_send_data_hdr(rtp_session, ts, pt, m, cc, &csrc,
                                                                        (char *) hdr, 2,
                                                                        nalc + curNALOffset,
                                                                        nalsize, extn, extn_len, extn_type) < 0) {
                                                                                error_msg("There was a problem sending the RTP packet\n");
                                        }
                                        lastNALUnitFragment = true;
                                }
                        }
                }
        }
        if (endptr != start + data_len) {
                error_msg("No NAL found!\n");
        }
}

References tile::data, tile::data_len, error_msg, FEC_NONE, tx::fec_scheme, video_frame::fragment, frame, get_std_video_local_mediatime(), tx::mtu, PT_DynRTP_Type96, rtp_send_data(), rtp_send_data_hdr(), rtpenc_get_next_nal(), start(), video_frame::tile_count, video_frame::tiles, and ts.

Referenced by h264_rtp_video_rxtx::configure_rtsp_server_video(), and h264_sdp_video_rxtx::send_frame().

Here is the call graph for this function:

tx_send_jpeg()

void tx_send_jpeg	(	struct tx *	tx_session,
		struct video_frame *	frame,
		struct rtp *	rtp_session )

Definition at line 1168 of file transmit.cpp.

                                        {
        uint32_t ts = 0;
 
        assert(frame->tile_count == 1); // std transmit doesn't handle more than one tile
        assert(!frame->fragment || tx->fec_scheme == FEC_NONE); // currently no support for FEC with fragments
        assert(!frame->fragment || frame->tile_count); // multiple tiles are not currently supported for fragmented send
 
        ts = get_std_video_local_mediatime();
 
        struct tile *tile = &frame->tiles[0];
        char pt = PT_JPEG;
        struct jpeg_rtp_data d;
 
        if (!jpeg_get_rtp_hdr_data((uint8_t *) frame->tiles[0].data, frame->tiles[0].data_len, &d)) {
                exit_uv(1);
                return;
        }
 
        uint32_t jpeg_hdr[2 /* JPEG hdr */ + 1 /* RM hdr */ + 129 /* QT hdr */];
        int hdr_off = 0;
        unsigned int type_spec = 0u;
        jpeg_hdr[hdr_off++] = htonl(type_spec << 24u);
        jpeg_hdr[hdr_off++] = htonl(d.type << 24u | d.q << 16u | d.width / 8u << 8u | d.height / 8u);
        if (d.restart_interval != 0) {
                // we do not align restart interval on packet boundaries yet
                jpeg_hdr[hdr_off++] = htonl(d.restart_interval << 16u | 1u << 15u | 1u << 14u | 0x3fffu);
        }
        // quantization headers
        if (d.q == 255u) { // we must include the tables
                unsigned int mbz = 0u; // must be zero
                unsigned int precision = 0u;
                unsigned int qt_len = 2 * 64u;
                jpeg_hdr[hdr_off++] = htonl(mbz << 24u | precision << 16u | qt_len);
                memcpy(&jpeg_hdr[hdr_off], d.quantization_tables[0], 64);
                hdr_off += 64 / sizeof(uint32_t);
                memcpy(&jpeg_hdr[hdr_off], d.quantization_tables[1], 64);
                hdr_off += 64 / sizeof(uint32_t);
        }
 
        char *data = (char *) d.data;
        int bytes_left = tile->data_len - ((char *) d.data - tile->data);
        int max_mtu = tx->mtu - ((rtp_is_ipv6(rtp_session) ? 40 : 20) + 8 + 12); // IP hdr size + UDP hdr size + RTP hdr size
 
        int fragment_offset = 0;
        do {
                int hdr_len;
                if (fragment_offset == 0) { // include quantization header only in 1st pkt
                        hdr_len = hdr_off * sizeof(uint32_t);
                } else {
                        hdr_len = 8 + (d.restart_interval > 0 ? 4 : 0);
                }
                int data_len = max_mtu - hdr_len;
                int m = 0;
                if (bytes_left <= data_len) {
                        data_len = bytes_left;
                        m = 1;
                }
                jpeg_hdr[0] = htonl(type_spec << 24u | fragment_offset);
 
                int ret = rtp_send_data_hdr(rtp_session, ts, pt, m, 0, 0,
                                (char *) &jpeg_hdr, hdr_len,
                                data, data_len, 0, 0, 0);
                if (ret < 0) {
                        log_msg(LOG_LEVEL_ERROR, "Error sending RTP/JPEG packet!\n");
                }
                data += data_len;
                bytes_left -= data_len;
                fragment_offset += data_len;
        } while (bytes_left > 0);
}

References jpeg_rtp_data::data, tile::data, tile::data_len, exit_uv(), FEC_NONE, tx::fec_scheme, video_frame::fragment, frame, get_std_video_local_mediatime(), jpeg_rtp_data::height, jpeg_get_rtp_hdr_data(), LOG_LEVEL_ERROR, log_msg(), tx::mtu, PT_JPEG, jpeg_rtp_data::q, jpeg_rtp_data::quantization_tables, jpeg_rtp_data::restart_interval, rtp_is_ipv6(), rtp_send_data_hdr(), video_frame::tile_count, video_frame::tiles, ts, jpeg_rtp_data::type, and jpeg_rtp_data::width.

Referenced by h264_rtp_video_rxtx::configure_rtsp_server_video(), and h264_sdp_video_rxtx::send_frame().

Here is the call graph for this function: