codec.h File Reference

#include "audio/types.h"
#include <string>
#include <tuple>

Include dependency graph for codec.h:

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

Go to the source code of this file.

Classes
struct	audio_codec_info_t
struct	audio_codec_params
struct	audio_compress_info

Macros
#define	AUDIO_COMPRESS_ABI_VERSION   4

Enumerations
enum	audio_codec_direction_t { AUDIO_CODER , AUDIO_DECODER }

Functions
audio_frame2	audio_codec_compress (struct audio_codec_state *, const audio_frame2 *)
audio_frame2	audio_codec_decompress (struct audio_codec_state *, audio_frame2 *)
void	audio_codec_done (struct audio_codec_state *)
const int *	audio_codec_get_supported_samplerates (struct audio_codec_state *)
struct audio_codec_state *	audio_codec_init (audio_codec_t audio_codec, audio_codec_direction_t)
struct audio_codec_state *	audio_codec_init_cfg (const char *audio_codec_cfg, audio_codec_direction_t)
struct audio_codec_state *	audio_codec_reconfigure (struct audio_codec_state *old, audio_codec_t audio_codec, audio_codec_direction_t)
std::vector< std::tuple< audio_codec_info_t, bool, std::string > >	get_audio_codec_list ()
audio_codec_t	get_audio_codec_to_tag (uint32_t audio_tag)
uint32_t	get_audio_tag (audio_codec_t codec)
const char *	get_name_to_audio_codec (audio_codec_t codec)
void	list_audio_codecs (void)
struct audio_codec_params	parse_audio_codec_params (const char *ccfg)

Detailed Description

Author

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

Definition in file codec.h.

Macro Definition Documentation

AUDIO_COMPRESS_ABI_VERSION

#define AUDIO_COMPRESS_ABI_VERSION   4

Definition at line 43 of file codec.h.

Referenced by audio_codec_init_real().

Enumeration Type Documentation

audio_codec_direction_t

enum audio_codec_direction_t

Enumerator
AUDIO_CODER
AUDIO_DECODER

Definition at line 45 of file codec.h.

             {
        AUDIO_CODER,
        AUDIO_DECODER
} audio_codec_direction_t;

Function Documentation

audio_codec_compress()

audio_frame2 audio_codec_compress	(	struct audio_codec_state *	s,
		const audio_frame2 *	frame )

Audio_codec_compress compresses given audio frame.

This function has to be called iterativelly, in first iteration with frame, the others with NULL

Parameters

s	state
frame	in first iteration audio frame to be compressed, in following NULL

Return values

pointer	pointing to data
NULL	indicating that there are no data left

Definition at line 245 of file codec.cpp.

{
        audio_frame2 res;
 
        if (frame != nullptr) {
                if (s->state_count < frame->get_channel_count()) {
                        s->state = (void **) realloc(s->state, sizeof(void *) * frame->get_channel_count());
                        for (int i = s->state_count; i < frame->get_channel_count(); ++i) {
                                s->state[i] = s->funcs->init(s->desc.codec, s->direction, false, s->bitrate);
                                if (s->state[i] == nullptr) {
                                        LOG(LOG_LEVEL_ERROR) << MOD_NAME << "Error: initialization of audio codec failed!\n";
                                        return {};
                                }
                        }
                        s->state_count = frame->get_channel_count();
                }
 
                s->desc.ch_count = frame->get_channel_count();
                s->desc.bps = frame->get_bps();
                s->desc.sample_rate = frame->get_sample_rate();
                res.set_timestamp(frame->get_timestamp());
        }
 
        audio_channel channel;
        channel.timestamp = frame == nullptr ? -1 : frame->get_timestamp();
        int nonzero_channels = 0;
        for (int i = 0; i < s->desc.ch_count; ++i) {
                audio_channel *encode_channel = NULL;
                if(frame) {
                        audio_channel_demux(frame, i, &channel);
                        encode_channel = &channel;
                }
                audio_channel *out = s->funcs->compress(s->state[i], encode_channel);
                if (out == nullptr) {
                        continue;
                }
                if (!res) {
                        res.init(s->desc.ch_count, out->codec, out->bps, out->sample_rate);
                        res.set_duration(out->duration);
                } else {
                        assert(out->bps == res.get_bps()
                                        && out->sample_rate == res.get_sample_rate());
                }
                res.append(i, out->data, out->data_len);
                res.set_timestamp(out->timestamp);
                nonzero_channels += 1;
        }
 
        if (nonzero_channels == 0) {
                return {};
        }
        return res;
}

References audio_frame2::append(), audio_channel_demux(), audio_codec_state::bitrate, audio_channel::bps, audio_desc::bps, audio_desc::ch_count, audio_channel::codec, audio_desc::codec, audio_compress_info::compress, audio_channel::data, audio_channel::data_len, audio_codec_state::desc, audio_codec_state::direction, audio_channel::duration, frame, audio_codec_state::funcs, audio_frame2::get_bps(), audio_frame2::get_sample_rate(), audio_compress_info::init, audio_frame2::init(), LOG, LOG_LEVEL_ERROR, MOD_NAME, audio_channel::sample_rate, audio_desc::sample_rate, audio_frame2::set_duration(), audio_frame2::set_timestamp(), audio_codec_state::state, audio_codec_state::state_count, and audio_channel::timestamp.

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

Here is the call graph for this function:

audio_codec_decompress()

audio_frame2 audio_codec_decompress	(	struct audio_codec_state *	s,
		audio_frame2 *	frame )

Definition at line 299 of file codec.cpp.

{
        if (s->state_count < frame->get_channel_count()) {
                s->state = (void **) realloc(s->state, sizeof(void *) * frame->get_channel_count());
                for(int i = s->state_count; i < frame->get_channel_count(); ++i) {
                        s->state[i] = s->funcs->init(s->desc.codec, s->direction, false, 0);
                        if(s->state[i] == NULL) {
                                log_msg(LOG_LEVEL_ERROR,
                                        "Error: initialization of audio codec "
                                        "failed!\n");
                                return {};
                        }
                }
                s->state_count = frame->get_channel_count();
        }
 
#if 0
        if (s->out->ch_count != frame->ch_count) {
                s->out->ch_count = frame->ch_count;
        }
#endif
 
        audio_frame2 ret;
        audio_channel channel;
        int nonzero_channels = 0;
        bool out_frame_initialized = false;
        for (int i = 0; i < frame->get_channel_count(); ++i) {
                audio_channel_demux(frame, i, &channel);
                if (channel.data_len == 0) {
                        continue;
                }
                audio_channel *out = s->funcs->decompress(s->state[i], &channel);
                if (out) {
                        if (!out_frame_initialized) {
                                ret.init(frame->get_channel_count(), AC_PCM, out->bps, out->sample_rate);
                                ret.set_timestamp(frame->get_timestamp());
                                out_frame_initialized = true;
                        } else {
                                assert(out->bps == ret.get_bps()
                                                && out->sample_rate == ret.get_sample_rate());
                        }
                        ret.append(i, out->data, out->data_len);
                        nonzero_channels += 1;
                }
        }
 
        if (nonzero_channels != frame->get_channel_count()) {
                log_msg(LOG_LEVEL_WARNING,
                        "[Audio decompress] %d empty channel(s) returned!\n",
                        frame->get_channel_count() - nonzero_channels);
                return {};
        }
        int max_len = 0;
        for(int i = 0; i < frame->get_channel_count(); ++i) {
                max_len = max<int>(max_len, ret.get_data_len(i));
        }
        for(int i = 0; i < frame->get_channel_count(); ++i) {
                int len = ret.get_data_len(i);
                if (len != max_len) {
                        LOG(LOG_LEVEL_WARNING) << "[Audio decompress] Inequal channel length detected (" << ret.get_data_len(i) << " vs " << max_len << ")!\n",
                        ret.resize(i, max_len);
                        memset(ret.get_data(i) + len, 0, max_len - len);
                }
        }
 
        return ret;
}

References AC_PCM, audio_frame2::append(), audio_channel_demux(), audio_channel::bps, audio_desc::codec, audio_channel::data, audio_channel::data_len, audio_compress_info::decompress, audio_codec_state::desc, audio_codec_state::direction, frame, audio_codec_state::funcs, audio_frame2::get_bps(), audio_frame2::get_data(), audio_frame2::get_data_len(), audio_frame2::get_sample_rate(), audio_compress_info::init, audio_frame2::init(), len, LOG, LOG_LEVEL_ERROR, LOG_LEVEL_WARNING, log_msg(), max, audio_frame2::resize(), audio_channel::sample_rate, audio_frame2::set_timestamp(), audio_codec_state::state, and audio_codec_state::state_count.

Referenced by decode_audio_frame().

Here is the call graph for this function:

audio_codec_done()

void audio_codec_done

(

struct audio_codec_state *

s

)

Definition at line 372 of file codec.cpp.

{
        if(!s)
                return;
        for(int i = 0; i < s->state_count; ++i) {
                s->funcs->done(s->state[i]);
        }
        free(s->state);
 
        free(s);
}

References audio_compress_info::done, audio_codec_state::funcs, audio_codec_state::state, and audio_codec_state::state_count.

Referenced by state_audio_mixer::state_audio_mixer(), am_participant::~am_participant(), audio_codec_reconfigure(), audio_decoder_destroy(), audio_done(), audio_init(), and get_audio_codec_list().

audio_codec_get_supported_samplerates()

const int * audio_codec_get_supported_samplerates

(

struct audio_codec_state *

s

)

Definition at line 367 of file codec.cpp.

{
        return s->funcs->get_samplerates(s->state[0]);
}

References audio_codec_state::funcs, audio_compress_info::get_samplerates, and audio_codec_state::state.

Referenced by audio_sender_thread().

audio_codec_init()

struct audio_codec_state * audio_codec_init	(	audio_codec_t	audio_codec,
		audio_codec_direction_t	direction )

Definition at line 160 of file codec.cpp.

                                                   {
        return audio_codec_init_real(get_name_to_audio_codec(audio_codec), direction, false);
}

References audio_codec_init_real(), audio_codec_state::direction, and get_name_to_audio_codec().

Referenced by audio_codec_reconfigure().

Here is the call graph for this function:

audio_codec_init_cfg()

struct audio_codec_state * audio_codec_init_cfg	(	const char *	audio_codec_cfg,
		audio_codec_direction_t	direction )

Definition at line 165 of file codec.cpp.

                                                   {
        return audio_codec_init_real(audio_codec_cfg, direction, false);
}

References audio_codec_init_real(), and audio_codec_state::direction.

Referenced by am_participant::am_participant(), state_audio_mixer::state_audio_mixer(), and audio_init().

Here is the call graph for this function:

audio_codec_reconfigure()

struct audio_codec_state * audio_codec_reconfigure	(	struct audio_codec_state *	old,
		audio_codec_t	audio_codec,
		audio_codec_direction_t	direction )

Definition at line 225 of file codec.cpp.

{
        if (old != nullptr && old->desc.codec == audio_codec) {
                return old;
        }
        audio_codec_done(old);
        return audio_codec_init(audio_codec, direction);
}

References audio_codec_done(), audio_codec_init(), audio_desc::codec, audio_codec_state::desc, and audio_codec_state::direction.

Referenced by audio_decoder_reconfigure().

Here is the call graph for this function:

get_audio_codec_list()

std::vector< std::tuple< audio_codec_info_t, bool, std::string > > get_audio_codec_list

(

)

Definition at line 109 of file codec.cpp.

{
        vector<tuple<audio_codec_info_t, bool, string>> ret;
 
        for (auto const &it : audio_codec_info) {
                if(it.first != AC_NONE) {
                        struct audio_codec_state *st = (struct audio_codec_state *)
                                audio_codec_init_real(get_name_to_audio_codec(it.first),
                                                AUDIO_CODER, true);
                        bool available = false;
                        string desc;
                        if(st){
                                available = true;
                                desc = get_codec_desc(st);
                                audio_codec_done(st);
                        }
                        ret.emplace_back(it.second, available, desc);
                }
        }
 
        return ret;
}

References AC_NONE, audio_codec_done(), audio_codec_info, audio_codec_init_real(), AUDIO_CODER, desc, get_codec_desc(), and get_name_to_audio_codec().

Referenced by list_audio_codecs(), and print_capabilities().

Here is the call graph for this function:

get_audio_codec_to_tag()

audio_codec_t get_audio_codec_to_tag

(

uint32_t

audio_tag

)

Definition at line 460 of file codec.cpp.

{
        for (auto const &it : audio_codec_info) {
                if(it.second.tag == tag) {
                        return it.first;
                }
        }
        return AC_NONE;
}

References AC_NONE, and audio_codec_info.

Referenced by audio_decoder_reconfigure(), audio_fec_decode(), decode_audio_frame(), and parse_audio_hdr().

get_audio_tag()

uint32_t get_audio_tag

(

audio_codec_t

codec

)

Definition at line 455 of file codec.cpp.

{
        return audio_codec_info.at(codec).tag;
}

References audio_codec_info.

Referenced by format_audio_header().

get_name_to_audio_codec()

const char * get_name_to_audio_codec

(

audio_codec_t

codec

)

Definition at line 450 of file codec.cpp.

{
        return audio_codec_info.at(codec).name;
}

References audio_codec_info.

Referenced by audio_codec_init(), audio_codec_init_real(), audio_decoder_reconfigure(), get_audio_codec_list(), libavcodec_init(), main(), operator<<(), BasicRTSPOnlySubsession::setSDPLines(), and validate_std_audio().

list_audio_codecs()

void list_audio_codecs

(

void

)

Definition at line 132 of file codec.cpp.

                             {
        printf("Syntax:\n");
        col() << SBOLD(
            SRED("\t-A <codec_name>")
            << "[:sample_rate=<sampling_rate>][:bitrate=<bitrate>]\n");
        col() << "\nwhere\n";
        col() << "\t" << SBOLD("codec_name ") << " - one of the list below\n";
        col() << "\t" << SBOLD("sample_rate")
              << " - sample rate that will the codec used (may differ from\n"
              << "\t\t      captured)\n";
        col() << "\t" << SBOLD("bitrate    ") << " - codec bitrate "
              << SBOLD("per channel") << " (with optional k/M suffix)\n";
        col() << "\n";
        printf("Supported audio codecs:\n");
        for (auto const &it : get_audio_codec_list()) {
                string notes;
                if (!get<1>(it)) {
                        notes += " " TRED("unavailable");
                } else {
                        notes = get<2>(it);
                }
                col() << SBOLD("\t" << get<0>(it).name)
                      << (notes.empty() ? "" : " - ") << notes << "\n";
        }
        col() << "\nCodecs marked as \"deprecated\" may be removed in future.\n"
                 "Codec coder marked with '*' is default.\n";
}

References get_audio_codec_list(), name, SBOLD, SRED, and TRED.

Referenced by parse_options_internal().

Here is the call graph for this function:

parse_audio_codec_params()

struct audio_codec_params parse_audio_codec_params

(

const char *

ccfg

)

Definition at line 402 of file codec.cpp.

{
        char *cfg      = strdupa(ccfg);
        char *save_ptr = nullptr;
        char *tmp      = cfg;
        char *item     = nullptr;
 
        struct audio_codec_params params {
        };
        while ((item = strtok_r(tmp, ":", &save_ptr)) != nullptr) {
                tmp = nullptr;
                if (params.codec == AC_NONE) {
                        params.codec = get_audio_codec(item);
                        if (params.codec == AC_NONE) {
                                MSG(ERROR,
                                    "Unknown audio codec \"%s\" given!\n",
                                    item);
                                return {};
                        }
                        continue;
                }
                if (IS_KEY_PREFIX(item, "sample_rate")) {
                        params.sample_rate = stoi(strchr(item, '=') + 1);
                        if (params.sample_rate < 0) {
                                MSG(ERROR,
                                    "Sample rate cannot be negative! given "
                                    "%d\n",
                                    params.sample_rate);
                                return {};
                        }
                } else if (IS_KEY_PREFIX(item, "bitrate")) {
                        const char *val = strchr(item, '=') + 1;
                        const char *endptr = nullptr;
                        long long   rate = unit_evaluate(val, &endptr);
                        if (rate <= 0 || rate > INT_MAX || endptr[0] != '\0') {
                                LOG(LOG_LEVEL_ERROR)
                                    << "Wrong bitrate: " << val << "\n";
                                return {};
                        }
                        params.bitrate = (int) rate;
                } else {
                        MSG(ERROR, "Unknown audio option: %s\n", item);
                        return {};
                }
        }
        return params;
}

References AC_NONE, get_audio_codec(), IS_KEY_PREFIX, LOG, LOG_LEVEL_ERROR, MSG, params, strdupa, unit_evaluate(), and val.

Referenced by audio_codec_init_real(), audio_init(), and main().

Here is the call graph for this function: