codec.cpp File Reference

#include "config_unix.h"
#include "config_win32.h"
#include <algorithm>
#include <cassert>
#include <climits>
#include <string>
#include <unordered_map>
#include "audio/codec.h"
#include "audio/utils.h"
#include "compat/strings.h"
#include "debug.h"
#include "lib_common.h"
#include "utils/macros.h"
#include "utils/misc.h"

Include dependency graph for codec.cpp:

Go to the source code of this file.

Classes
struct	audio_codec_state

Macros
#define	MOD_NAME   "[acodec] "

Functions
audio_frame2	audio_codec_compress (struct audio_codec_state *s, const audio_frame2 *frame)
audio_frame2	audio_codec_decompress (struct audio_codec_state *s, audio_frame2 *frame)
void	audio_codec_done (struct audio_codec_state *s)
const int *	audio_codec_get_supported_samplerates (struct audio_codec_state *s)
struct audio_codec_state *	audio_codec_init (audio_codec_t audio_codec, audio_codec_direction_t direction)
struct audio_codec_state *	audio_codec_init_cfg (const char *audio_codec_cfg, audio_codec_direction_t direction)
static struct audio_codec_state *	audio_codec_init_real (const char *audio_codec_cfg, audio_codec_direction_t direction, bool try_init)
struct audio_codec_state *	audio_codec_reconfigure (struct audio_codec_state *old, audio_codec_t audio_codec, audio_codec_direction_t direction)
static audio_codec_t	get_audio_codec (const char *codec)
vector< tuple< audio_codec_info_t, bool, string > >	get_audio_codec_list ()
audio_codec_t	get_audio_codec_to_tag (uint32_t tag)
uint32_t	get_audio_tag (audio_codec_t codec)
static string	get_codec_desc (struct audio_codec_state *st)
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)

Variables
static const unordered_map< audio_codec_t, audio_codec_info_t, hash< int > >	audio_codec_info

Detailed Description

Author

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

Definition in file codec.cpp.

Macro Definition Documentation

MOD_NAME

#define MOD_NAME   "[acodec] "

Definition at line 55 of file codec.cpp.

Referenced by audio_codec_compress().

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_init_real()

static struct audio_codec_state * audio_codec_init_real ( const char * audio_codec_cfg, audio_codec_direction_t direction, bool try_init )

static

Definition at line 171 of file codec.cpp.

                                                                {
        const struct audio_codec_params params =
            parse_audio_codec_params(audio_codec_cfg);
        if (params.codec == AC_NONE) {
                return nullptr;
        }
        void *state = NULL;
        const struct audio_compress_info *aci = nullptr;
 
        auto audio_compressions = get_libraries_for_class(LIBRARY_CLASS_AUDIO_COMPRESS, AUDIO_COMPRESS_ABI_VERSION);
 
        for (auto const &it : audio_compressions) {
                aci = static_cast<const struct audio_compress_info *>(it.second);
                for (unsigned int j = 0; aci->supported_codecs[j] != AC_NONE; ++j) {
                        if (aci->supported_codecs[j] == params.codec) {
                                state = aci->init(params.codec, direction,
                                                  silent, params.bitrate);
                                if (state) {
                                        break;
                                }
                                if (!silent) {
                                        log_msg(LOG_LEVEL_ERROR,
                                                "Error: initialization of "
                                                "audio codec failed!\n");
                                }
                        }
                }
                if(state)
                        break;
        }
 
        if(!state) {
                if (!silent) {
                        log_msg(LOG_LEVEL_ERROR,
                                "Unable to find encoder for audio codec '%s'\n",
                                get_name_to_audio_codec(params.codec));
                }
                return NULL;
        }
 
        struct audio_codec_state *s = (struct audio_codec_state *) calloc(1, sizeof(struct audio_codec_state));
 
        s->state = (void **) calloc(1, sizeof(void*));
        s->state[0] = state;
        s->state_count = 1;
        s->funcs = aci;
        s->desc.codec = params.codec;
        s->direction = direction;
        s->bitrate = params.bitrate;
 
        return s;
}

References AC_NONE, AUDIO_COMPRESS_ABI_VERSION, audio_codec_state::bitrate, audio_desc::codec, audio_codec_state::desc, audio_codec_state::direction, audio_codec_state::funcs, get_libraries_for_class(), get_name_to_audio_codec(), audio_compress_info::init, LIBRARY_CLASS_AUDIO_COMPRESS, LOG_LEVEL_ERROR, log_msg(), parse_audio_codec_params(), audio_codec_state::state, state, audio_codec_state::state_count, and audio_compress_info::supported_codecs.

Referenced by audio_codec_init(), audio_codec_init_cfg(), and get_audio_codec_list().

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()

static audio_codec_t get_audio_codec ( const char * codec )

static

Definition at line 385 of file codec.cpp.

{
        for (auto const &it : audio_codec_info) {
                if (strcasecmp(it.second.name, codec) == 0) {
                        return it.first;
                }
        }
        if (strcasecmp(codec, "PCMA") == 0) {
                return AC_ALAW;
        }
        if (strcasecmp(codec, "PCMU") == 0) {
                return AC_MULAW;
        }
        return AC_NONE;
}

References AC_ALAW, AC_MULAW, AC_NONE, and audio_codec_info.

Referenced by parse_audio_codec_params().

get_audio_codec_list()

vector< tuple< audio_codec_info_t, bool, 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

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_codec_desc()

static string get_codec_desc ( struct audio_codec_state * st )

static

Definition at line 94 of file codec.cpp.

{
        if (st->funcs->get_codec_info == nullptr) {
                return {};
        }
        char buf[STR_LEN];
        const char *ret =
            st->funcs->get_codec_info(st->state[0], sizeof buf, buf);
        if (ret == nullptr) {
                return {};
        }
        return ret;
}

References audio_codec_state::funcs, audio_compress_info::get_codec_info, audio_codec_state::state, and STR_LEN.

Referenced by get_audio_codec_list().

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:

Variable Documentation

audio_codec_info

const unordered_map<audio_codec_t, audio_codec_info_t, hash<int> > audio_codec_info

static

Initial value:

= {
            {AC_NONE,   { "(none)", 0 }                   },
            { AC_PCM,   { "PCM", 0x0001 }                 },
            { AC_ALAW,  { "A-law", 0x0006 }               },
            { AC_MULAW, { "u-law", 0x0007 }               },
            { AC_SPEEX, { "speex", 0xA109 }               },
            { AC_OPUS,  
              { "Opus", 0x7375704F }},
            { AC_G722,  { "G.722", 0x028F }               },
            { AC_MP3,   { "MP3", 0x0055 }                 },
            { AC_AAC,   { "AAC", 0x00FF }                 },
            { AC_FLAC,  { "FLAC", 0xF1AC }                },
}

Definition at line 67 of file codec.cpp.

                       {
            {AC_NONE,   { "(none)", 0 }                   },
            { AC_PCM,   { "PCM", 0x0001 }                 },
            { AC_ALAW,  { "A-law", 0x0006 }               },
            { AC_MULAW, { "u-law", 0x0007 }               },
            { AC_SPEEX, { "speex", 0xA109 }               },
            { AC_OPUS,  // fcc is "Opus", the TwoCC isn't defined
              { "Opus", 0x7375704F }},
            { AC_G722,  { "G.722", 0x028F }               },
            { AC_MP3,   { "MP3", 0x0055 }                 },
            { AC_AAC,   { "AAC", 0x00FF }                 },
            { AC_FLAC,  { "FLAC", 0xF1AC }                },
};

Referenced by get_audio_codec(), get_audio_codec_list(), get_audio_codec_to_tag(), get_audio_tag(), and get_name_to_audio_codec().