yuri_decoders.cpp File Reference

#include "audio/utils.h"
#include "rtp/rtp.h"
#include "rtp/rtp_callback.h"
#include "rtp/pbuf.h"
#include "rtp/audio_decoders.h"
#include "rtp/yuri_decoders.h"
#include "rtp/video_decoders.h"
#include "yuri/core/frame/RawAudioFrame.h"
#include "yuri/core/frame/CompressedVideoFrame.h"
#include "yuri/core/frame/RawVideoFrame.h"
#include "modules/ultragrid/YuriUltragrid.h"

Include dependency graph for yuri_decoders.cpp:

Go to the source code of this file.

Functions
static int	decode_yuri_audio_frame (struct coded_data *cdata, yuri_decoder_data *s)
int	decode_yuri_frame (struct coded_data *cdata, void *decoder_data)
static int	decode_yuri_video_frame (struct coded_data *cdata, yuri_decoder_data *s)

Detailed Description

Author

Martin Pulec pulec.nosp@m.@ces.nosp@m.net.c.nosp@m.z

Definition in file yuri_decoders.cpp.

Function Documentation

decode_yuri_audio_frame()

static int decode_yuri_audio_frame ( struct coded_data * cdata, yuri_decoder_data * s )

static

Definition at line 59 of file yuri_decoders.cpp.

{
        rtp_packet *pckt = NULL;
        uint32_t *hdr;
        int buffer_length;
        struct audio_desc network_desc;
        char *received_data = NULL;
 
        pckt = cdata->data;
        hdr = (uint32_t *)(void *) pckt->data;
        parse_audio_hdr(hdr, &network_desc);
        buffer_length = ntohl(hdr[2]);
 
        if (network_desc.codec != AC_PCM) {
                s->log[yuri::log::warning] << "Compressed audio is not yet supported!";
                return FALSE;
        }
 
        yuri::core::pRawAudioFrame frame = yuri::core::RawAudioFrame::create_empty(
                        yuri::ultragrid::audio_uv_to_yuri(network_desc.bps * 8), network_desc.ch_count,
                        network_desc.sample_rate, yuri::uvector<uint8_t>(buffer_length * network_desc.ch_count));
        received_data = reinterpret_cast<char *>(frame->data());
        s->yuri_frame = frame;
        if (!s->yuri_frame) {
                return FALSE;
        }
 
        while (cdata != NULL) {
                uint32_t *hdr;
                uint32_t substream;
                char *data;
                uint32_t data_pos;
                int len;
 
                pckt = cdata->data;
 
                hdr = (uint32_t *)(void *) pckt->data;
                data_pos = ntohl(hdr[1]);
                substream = ntohl(hdr[0]) >> 22;
 
                len = pckt->data_len - sizeof(audio_payload_hdr_t);
                data = (char *) hdr + sizeof(audio_payload_hdr_t);
 
                mux_channel(received_data + data_pos * network_desc.ch_count, data, network_desc.bps,
                                len, network_desc.ch_count, substream, 1.0);
 
                cdata = cdata->nxt;
        }
 
        return TRUE;
}

References AC_PCM, audio_desc::bps, audio_desc::ch_count, audio_desc::codec, coded_data::data, FALSE, frame, len, yuri_decoder_data::log, mux_channel(), coded_data::nxt, parse_audio_hdr(), rtp_packet, audio_desc::sample_rate, TRUE, and yuri_decoder_data::yuri_frame.

Referenced by decode_yuri_frame().

Here is the call graph for this function:

decode_yuri_frame()

int decode_yuri_frame	(	struct coded_data *	cdata,
		void *	decoder_data )

Definition at line 168 of file yuri_decoders.cpp.

{
        yuri_decoder_data *s = (yuri_decoder_data *) decoder_data;
        if (cdata->data->pt == PT_VIDEO) {
                return decode_yuri_video_frame(cdata, s);
        } else if (cdata->data ->pt == PT_AUDIO) {
                return decode_yuri_audio_frame(cdata, s);
        } else {
                s->log[yuri::log::warning] << "Unsupported UltraGrid pt " << cdata->data->pt << "!";
                return FALSE;
        }
}

References coded_data::data, decode_yuri_audio_frame(), decode_yuri_video_frame(), FALSE, yuri_decoder_data::log, PT_AUDIO, and PT_VIDEO.

Here is the call graph for this function:

decode_yuri_video_frame()

static int decode_yuri_video_frame ( struct coded_data * cdata, yuri_decoder_data * s )

static

Definition at line 111 of file yuri_decoders.cpp.

{
        char *received_data = NULL;
 
        rtp_packet *pckt = NULL;
        int buffer_length;
        uint32_t *hdr;
        struct video_desc network_desc;
 
        pckt = cdata->data;
        hdr = (uint32_t *)(void *) pckt->data;
        parse_video_hdr(hdr, &network_desc);
        buffer_length = ntohl(hdr[2]);
 
        s->yuri_frame = yuri::ultragrid::create_yuri_from_uv_desc(&network_desc, buffer_length, s->log);
        if (!s->yuri_frame) {
                return FALSE;
        }
 
        auto raw = dynamic_pointer_cast<yuri::core::RawVideoFrame>(s->yuri_frame);
        if (raw) {
                received_data = reinterpret_cast<char *>(PLANE_RAW_DATA(raw, 0));
        } else {
                auto compressed = dynamic_pointer_cast<yuri::core::CompressedVideoFrame>(s->yuri_frame);
                if (compressed) {
                        received_data = reinterpret_cast<char *>(compressed->begin());
                }
        }
 
        while (cdata != NULL) {
                char *data;
                uint32_t data_pos;
                int len;
                uint32_t *hdr;
                uint32_t substream;
                pckt = cdata->data;
 
                hdr = (uint32_t *)(void *) pckt->data;
                data_pos = ntohl(hdr[1]);
                substream = ntohl(hdr[0]) >> 22;
 
                if (substream > 0) {
                        s->log[yuri::log::warning] << "Multiple substreams for video yet supported!";
                        return FALSE;
                }
 
                len = pckt->data_len - sizeof(video_payload_hdr_t);
                data = (char *) hdr + sizeof(video_payload_hdr_t);
 
                memcpy(received_data + data_pos, (unsigned char*) data, len);
 
                cdata = cdata->nxt;
        }
 
        return TRUE;
}

References coded_data::data, FALSE, len, yuri_decoder_data::log, coded_data::nxt, parse_video_hdr(), rtp_packet, TRUE, and yuri_decoder_data::yuri_frame.

Referenced by decode_yuri_frame().

Here is the call graph for this function: