#include <cstdint>
#include <cstddef>
#include "audio/types.h"

Include dependency graph for utils.h:

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

Classes
struct	channel_map

Macros
#define	STORE_I32_SAMPLE(ptr, val, out_bps)
	stores given int32_t sample at required out_bps

Functions
bool	append_audio_frame (struct audio_frame frame, char data, size_t data_len)

void	audio_channel_demux (const audio_frame2 , int, audio_channel )

bool	audio_desc_eq (struct audio_desc, struct audio_desc)

struct audio_desc	audio_desc_from_audio_channel (const audio_channel *)

struct audio_desc	audio_desc_from_frame (const struct audio_frame *frame)

const char *	audio_desc_to_cstring (struct audio_desc desc)

struct audio_frame *	audio_frame_copy (const struct audio_frame *src, bool keep_size)

void	audio_frame_multiply_channel (struct audio_frame *frame, int new_channel_count)

void	audio_frame_write_desc (struct audio_frame *f, struct audio_desc desc)

double	calculate_rms (audio_frame frame, int channel, double peak)

double	calculate_rms (audio_frame2 frame, int channel, double peak)
	Calculates mean and peak RMS from audio samples.

void	change_bps (char out, int out_bps, const char in, int in_bps, int in_len)

void	change_bps2 (char out, int out_bps, const char in, int in_bps, int in_len, bool dither)
	changes bps with option to specify whether or not do the dithering

void	copy_channel (char out, const char in, int bps, int in_len, int out_channel_count)

void	demux_channel (char out, char in, int bps, int in_len, int in_stream_channels, int pos_in_stream)

int32_t	downshift_with_dither (int32_t val, int shift)

void	float2int (char out, const char in, int len)

void	format_audio_channel_volume (int chan_idx, double rms, double peak, const char format_color, char volume_start, char volume_end)
	format per channel incrementally volume string (eg. "[0] -18.00/-14.99, [1] -18.00/-14.99")

double	get_avg_volume (char *data, int bps, int in_len, int stream_channels, int chan_pos_stream)

void	int2float (char out, const char in, int len)

void	interleaved2noninterleaved (char out, const char in, int bps, int in_len, int channel_count)

void	interleaved2noninterleaved2 (char *out, const char in, int bps, int in_len, int channel_count)

void	interleaved2noninterleaved_float (char *out, const char in, int in_bps, int in_len, int channel_count)

void	mux_and_mix_channel (char out, const char in, int bps, int in_len, int out_stream_channels, int chan_pos_stream, double scale)

void	mux_channel (char out, const char in, int bps, int in_len, int out_stream_channels, int chan_pos_stream, double scale)

int	parse_audio_format (const char str, struct audio_desc ret)

bool	parse_channel_map_cfg (struct channel_map channel_map, const char cfg)

void	remux_and_mix_channel (char out, const char in, int bps, int frames, int in_stream_channels, int out_stream_channels, int in_channel, int out_channel, double scale)

void	remux_channel (char out, const char in, int bps, int in_len, int in_stream_channels, int out_stream_channels, int pos_in_stream, int pos_out_stream)

void	signed2unsigned (char out, const char in, int in_len)

Detailed Description

Author: Martin Pulec marti.nosp@m.n.pu.nosp@m.lec@c.nosp@m.esne.nosp@m.t.cz; Martin Piatka piatk.nosp@m.a@ce.nosp@m.snet..nosp@m.cz

Definition in file utils.h.

Macro Definition Documentation

◆ STORE_I32_SAMPLE

#define STORE_I32_SAMPLE	(	ptr,
		val,
		out_bps )

Value:

memcpy((ptr), ((const char *) &(val)) + 4 - (out_bps), (out_bps))

val

int void * val

Definition aja_win32_stub.cpp:69

stores given int32_t sample at required out_bps

Definition at line 143 of file utils.h.

143#define STORE_I32_SAMPLE(ptr, val, out_bps) \

144 memcpy((ptr), ((const char *) &(val)) + 4 - (out_bps), (out_bps))

Referenced by generate_audio_sine(), and get_ebu_signal().

Function Documentation

◆ append_audio_frame()

bool append_audio_frame	(	struct audio_frame *	frame,
		char *	data,
		size_t	data_len )

Appends data to audio frame

Returns: whether all data has been written

Definition at line 620 of file utils.cpp.

                                                                                {
        bool ret = true;
        if (frame->data_len + data_len > (size_t) frame->max_size) {
                log_msg(LOG_LEVEL_WARNING, "Audio frame overrun, discarding some data.\n");
                data_len = frame->max_size - frame->data_len;
                ret = false;
        }
        memcpy(frame->data + frame->data_len, data, data_len);
        frame->data_len += data_len;
 
        return ret;
}

References frame, LOG_LEVEL_WARNING, and log_msg().

Referenced by display_pipe_get_audio().

Here is the call graph for this function:

◆ audio_channel_demux()

void audio_channel_demux	(	const audio_frame2 *	frame,
		int	index,
		audio_channel *	channel )

Definition at line 528 of file utils.cpp.

{
        channel->data = frame->get_data(index);
        channel->data_len = frame->get_data_len(index);
        channel->codec = frame->get_codec();
        channel->bps = frame->get_bps();
        channel->sample_rate = frame->get_sample_rate();
}

References audio_channel::bps, audio_channel::codec, audio_channel::data, audio_channel::data_len, frame, and audio_channel::sample_rate.

Referenced by audio_codec_compress(), and audio_codec_decompress().

◆ audio_desc_eq()

bool audio_desc_eq	(	struct audio_desc	a1,
		struct audio_desc	a2 )

Definition at line 189 of file utils.cpp.

                                                               {
        return a1.bps == a2.bps &&
                a1.sample_rate == a2.sample_rate &&
                a1.ch_count == a2.ch_count &&
                a1.codec == a2.codec;
}

References audio_desc::bps, audio_desc::ch_count, audio_desc::codec, and audio_desc::sample_rate.

Referenced by audio_append_pcm(), audio_export(), audio_receiver_thread(), check_reconf(), display_pipe_get_audio(), libavcodec_decompress(), and process_input().

◆ audio_desc_from_audio_channel()

struct audio_desc audio_desc_from_audio_channel ( const audio_channel * channel )

Definition at line 205 of file utils.cpp.

{
        return audio_desc { channel->bps,
                channel->sample_rate,
                1,
                channel->codec
        };
}

Referenced by libavcodec_decompress(), and process_input().

◆ audio_desc_from_frame()

struct audio_desc audio_desc_from_frame ( const struct audio_frame * frame )

Definition at line 196 of file utils.cpp.

                                                                         {
        return audio_desc { frame->bps,
                frame->sample_rate,
                frame->ch_count,
                AC_PCM
        };
}

References AC_PCM, and frame.

Referenced by audio_append_pcm(), audio_export(), audio_receiver_thread(), display_file_put_audio_frame(), display_pipe_get_audio(), generate_signal(), setup_audio(), vidcap_state_aja::SetupAudio(), and wait_for_channel().

◆ audio_desc_to_cstring()

const char * audio_desc_to_cstring ( struct audio_desc desc )

Definition at line 644 of file utils.cpp.

                                                          {
        thread_local string str = desc;
        return str.c_str();
}

References desc.

Referenced by generate_signal(), set_audio_spec_to_vrxtx(), and vidcap_file_init().

◆ audio_frame_copy()

struct audio_frame * audio_frame_copy	(	const struct audio_frame *	src,
		bool	keep_size )

Creates a deep copy of src. Both struct and audio_frame::data is malloc'd.

Parameters

keep_size allocate exactly same storage (audio_frame::max_size) as original frame. If false, the storage may be shorter.

Definition at line 633 of file utils.cpp.

                                                                                    {
        struct audio_frame *ret = (struct audio_frame *) malloc(sizeof(struct audio_frame));
        memcpy(ret, src, sizeof *ret);
        if (!keep_size) {
                ret->max_size = src->data_len;
        }
        ret->data = (char *) malloc(ret->max_size);
        memcpy(ret->data, src->data, src->data_len);
        return ret;
}

References audio_frame::data, audio_frame::data_len, and audio_frame::max_size.

Referenced by display_pipe_put_audio_frame().

◆ audio_frame_multiply_channel()

void audio_frame_multiply_channel	(	struct audio_frame *	frame,
		int	new_channel_count )

Makes n copies of first channel (interleaved).

Definition at line 328 of file utils.cpp.

                                                                                    {
        assert((unsigned int) frame->max_size >= (unsigned int) frame->data_len * new_channel_count / frame->ch_count);
 
        copy_channel(frame->data, frame->data, frame->bps, frame->data_len, new_channel_count);
}

References copy_channel(), and frame.

Here is the call graph for this function:

◆ audio_frame_write_desc()

void audio_frame_write_desc	(	struct audio_frame *	f,
		struct audio_desc	desc )

Copies desc from desc to f.

Note: Doesn't clear/set other members of f, thus caller needs to do that first if needed.

Definition at line 220 of file utils.cpp.

{
        f->bps = desc.bps;
        f->sample_rate = desc.sample_rate;
        f->ch_count = desc.ch_count;
}

References audio_frame::bps, audio_frame::ch_count, desc, and audio_frame::sample_rate.

Referenced by display_pipe_get_audio(), and get_audio().

◆ calculate_rms() [1/2]

double calculate_rms	(	audio_frame *	frame,
		int	channel,
		double *	peak )

Definition at line 169 of file utils.cpp.

{
        assert(channel < frame->ch_count);
        char *data = frame->data + channel * frame->bps;
        int sample_count = frame->data_len / frame->bps / frame->ch_count;
        switch (frame->bps) {
        case 1:
                return calculate_rms_helper<1>(data, sample_count, peak, frame->ch_count);
        case 2:
                return calculate_rms_helper<2>(data, sample_count, peak, frame->ch_count);
        case 3:
                return calculate_rms_helper<3>(data, sample_count, peak, frame->ch_count);
        case 4:
                return calculate_rms_helper<4>(data, sample_count, peak, frame->ch_count);
        default:
                LOG(LOG_LEVEL_FATAL) << "Wrong BPS " << frame->bps << "\n";
                abort();
        }
}

References calculate_rms_helper(), frame, LOG, and LOG_LEVEL_FATAL.

Here is the call graph for this function:

◆ calculate_rms() [2/2]

double calculate_rms	(	audio_frame2 *	frame,
		int	channel,
		double *	peak )

Calculates mean and peak RMS from audio samples.

Parameters

[in]	frame	audio frame
[in]	channel	channel index to calculate RMS to
[out]	peak	peak RMS

Returns: mean RMS

Definition at line 150 of file utils.cpp.

{
        assert(frame->get_codec() == AC_PCM);
        int sample_count = frame->get_data_len(channel) / frame->get_bps();
        switch (frame->get_bps()) {
                case 1:
                        return calculate_rms_helper<1>(frame->get_data(channel), sample_count, peak);
                case 2:
                        return calculate_rms_helper<2>(frame->get_data(channel), sample_count, peak);
                case 3:
                        return calculate_rms_helper<3>(frame->get_data(channel), sample_count, peak);
                case 4:
                        return calculate_rms_helper<4>(frame->get_data(channel), sample_count, peak);
                default:
                        LOG(LOG_LEVEL_FATAL) << "Wrong BPS " << frame->get_bps() << "\n";
                        abort();
        }
}

References AC_PCM, calculate_rms_helper(), frame, LOG, and LOG_LEVEL_FATAL.

Referenced by adec_compute_and_print_stats(), asend_compute_and_print_stats(), decode_audio_frame(), and filter().

Here is the call graph for this function:

◆ change_bps()

void change_bps	(	char *	out,
		int	out_bps,
		const char *	in,
		int	in_bps,
		int	in_len )

Changes bps for everey sample.

The memory areas shouldn't (supposedly) overlap.

Definition at line 258 of file utils.cpp.

                                                                                  {
        static const bool dither = commandline_params.find(NO_DITHER_PARAM) == commandline_params.end();
        change_bps2(out, out_bps, in, in_bps, in_len, dither);
}

References change_bps2(), commandline_params, and NO_DITHER_PARAM.

Referenced by audio_testcard_read_wav(), display_sdl_put_audio_frame(), echo_cancel(), echo_play(), and process_input().

Here is the call graph for this function:

◆ change_bps2()

void change_bps2	(	char *	out,
		int	out_bps,
		const char *	in,
		int	in_bps,
		int	in_len,
		bool	dither )

changes bps with option to specify whether or not do the dithering

Definition at line 263 of file utils.cpp.

{
        assert ((unsigned int) out_bps <= sizeof(int32_t));
        static_assert(-2>>1 == -1, "Implementation-defined behavior doesn't work as expected by the implementation.");
 
        if (in_bps == out_bps ) {
                memcpy(out, in, in_len);
                return;
        }
 
        if (in_bps < out_bps ) {
                for (int i = 0; i < in_len / in_bps; i++) {
                        int32_t in_value = format_from_in_bps(in, in_bps);
                        int32_t out_value = in_value << (out_bps * 8 - in_bps * 8);
                        format_to_out_bps(out, out_bps, out_value);
                        in += in_bps;
                        out += out_bps;
                }
                return;
        }
 
        // downsampling
        if (dither) {
                const int downshift = in_bps * 8 - out_bps * 8;
                for (int i = 0; i < in_len / in_bps; i++) {
                        int32_t in_value = format_from_in_bps(in, in_bps);
                        int32_t out_value = downshift_with_dither(in_value, downshift);
                        format_to_out_bps(out, out_bps, out_value);
                        in += in_bps;
                        out += out_bps;
                }
                return;
        }
        // no dithering
        for (int i = 0; i < in_len / in_bps; i++) {
                int32_t in_value = format_from_in_bps(in, in_bps);
                int32_t out_value = in_value >> (in_bps * 8 - out_bps * 8);
                format_to_out_bps(out, out_bps, out_value);
                in += in_bps;
                out += out_bps;
        }
}

References downshift_with_dither(), format_from_in_bps(), and format_to_out_bps().

Referenced by change_bps(), and get_sine_signal().

Here is the call graph for this function:

◆ copy_channel()

void copy_channel	(	char *	out,
		const char *	in,
		int	bps,
		int	in_len,
		int	out_channel_count )

Definition at line 306 of file utils.cpp.

{
        int samples = in_len / bps;
        int i;
        
        assert(out_channel_count > 0);
        assert(bps > 0);
        assert(in_len >= 0);
        
        in += in_len;
        out += in_len * out_channel_count;
        for (i = samples; i > 0 ; --i) {
                int j;
                
                in -= bps;
                for  (j = out_channel_count + 0; j > 0; --j) {
                        out -= bps;
                        memmove(out, in, bps);
                }
        }
}

References audio_desc::bps.

Referenced by audio_frame_multiply_channel().

◆ demux_channel()

void demux_channel	(	char *	out,
		char *	in,
		int	bps,
		int	in_len,
		int	in_stream_channels,
		int	pos_in_stream )

Definition at line 334 of file utils.cpp.

{
        int samples = in_len / (in_stream_channels * bps);
        int i;
 
        assert (bps <= 4);
 
        in += pos_in_stream * bps;
 
        for (i = 0; i < samples; ++i) {
                memcpy(out, in, bps);
 
                out += bps;
                in += in_stream_channels * bps;
 
        }
}

References audio_desc::bps.

Referenced by audio_frame2::audio_frame2(), audio_cap_alsa_read(), display_deltacast_put_audio_frame(), jack_process_callback(), process_new_audio_packets(), and vidcap_dvs_grab_thread().

◆ downshift_with_dither()

int32_t downshift_with_dither	(	int32_t	val,
		int	shift )

Bit-shifts val down by shift bits with a triangular dither noise.

By reducing bit-depth of audio, quantization noise is introduced. If the bit depth is reduced by consistent rounding (either always down, always up, or always to nearest) the quantization noise is correlated with the input signal and percieved as distortion. Adding a small amount of noise to the input signal before reducing the bit-depth causes random rounding, which makes the noise uncorrelated and uniformly spread through the whole spectrum.

Definition at line 227 of file utils.cpp.

                                                     {
        static thread_local uint32_t last_rand = 0;
 
        //Quick and dirty random number generation (ranqd1)
        //Numerical Recipes in C, page 284
        last_rand = (last_rand * 1664525) + 1013904223L;
        int triangle_dither = last_rand >> (32 - shift);
        last_rand = (last_rand * 1664525) + 1013904223L;
        triangle_dither -= last_rand >> (32 - shift); //triangle probability distribution
 
        /* Prevent over/underflow when val is big.
         *
         * abs(val) could cause problems if val is INT32_MIN, but integer
         * 32-bit pcm is rare and should not contain the value INT32_MIN
         * anyway because of symmetry, as specified by AES17 and IEC 61606-3
         */
        if(INT32_MAX - abs(val) < (1 << shift) - 1 + (1 << (shift - 1)))
                return val / (1 << shift);
 
        if(val > 0)
                val += 1 << (shift - 1);
        else
                val -= 1 << (shift - 1);
 
        return (val + triangle_dither) / (1 << shift);
}

References abs(), and val.

Referenced by change_bps2().

Here is the call graph for this function:

◆ float2int()

void float2int	(	char *	out,
		const char *	in,
		int	len )

This fuction converts from normalized float to int32_t representation Input and output data may overlap.

Parameters

[out]	out	4-byte aligned output buffer
[in]	in	4-byte aligned input buffer

Can be used in situ.

Definition at line 482 of file utils.cpp.

{
        const float *inf = (const float *)(const void *) in;
        int32_t *outi = (int32_t *)(void *) out;
        int items = len / sizeof(int32_t);
 
        while(items-- > 0) {
                float sample = *inf++;
                if(sample > 1.0) sample = 1.0;
                if(sample < -1.0) sample = -1.0;
                *outi++ = sample * INT_MAX_FLT;
        }
}

References INT_MAX_FLT, and len.

Referenced by audio_cap_jack_read(), libavcodec_decompress(), and vidcap_file_write_audio().

◆ format_audio_channel_volume()

void format_audio_channel_volume	(	int	chan_idx,
		double	rms,
		double	peak,
		const char *	format_color,
		char **	volume_start,
		char *	volume_end )

format per channel incrementally volume string (eg. "[0] -18.00/-14.99, [1] -18.00/-14.99")

Parameters

	rms	volume RMS in range [0,1]
	peak	value of sample with maximal absolute value in range [0,1]
[in,out]	volume_start	string to be wwritten to, after function exit will to point after just written data

Definition at line 828 of file utils.cpp.

{
        if (chan_idx > 0) {
                *volume_start +=
                    snprintf(*volume_start, volume_end - *volume_start, ", ");
        }
        const double rms_dbfs  = 20.0 * log(rms) / log(10.0);
        const double peak_dbfs = 20.0 * log(peak) / log(10.0);
        *volume_start +=
            snprintf(*volume_start, volume_end - *volume_start,
                     "[%d] %s%.2f" TERM_RESET "/%s%.2f" TERM_RESET, chan_idx,
                     format_color, rms_dbfs, format_color, peak_dbfs);
}

References TERM_RESET.

Referenced by adec_compute_and_print_stats(), and asend_compute_and_print_stats().

◆ get_avg_volume()

double get_avg_volume	(	char *	data,
		int	bps,
		int	in_len,
		int	stream_channels,
		int	chan_pos_stream )

Definition at line 461 of file utils.cpp.

                                                                                                     {
        switch (bps) {
                case 1:
                        return get_avg_volume_helper<1>(data, sample_count, stream_channels, pos_in_stream);
                case 2:
                        return get_avg_volume_helper<2>(data, sample_count, stream_channels, pos_in_stream);
                case 3:
                        return get_avg_volume_helper<3>(data, sample_count, stream_channels, pos_in_stream);
                case 4:
                        return get_avg_volume_helper<4>(data, sample_count, stream_channels, pos_in_stream);
                default:
                        LOG(LOG_LEVEL_FATAL) << "Wrong BPS " << bps << "\n";
                        abort();
        }
}

References audio_desc::bps, get_avg_volume_helper(), LOG, and LOG_LEVEL_FATAL.

Referenced by decode_audio_frame().

Here is the call graph for this function:

◆ int2float()

void int2float	(	char *	out,
		const char *	in,
		int	len )

This fuction converts from int32_t to normalized float Input and output data may overlap.

Parameters

[out]	out	4-byte aligned output buffer
[in]	in	4-byte aligned input buffer

Definition at line 496 of file utils.cpp.

{
        const int32_t *ini = (const int32_t *)(const void *) in;
        float *outf = (float *)(void *) out;
        int items = len / sizeof(int32_t);
 
        while(items-- > 0) {
                *outf++ = (float) *ini++ / (float) INT_MAX;
        }
}

References len.

Referenced by audio_play_jack_put_frame(), and process_input().

◆ interleaved2noninterleaved()

void interleaved2noninterleaved	(	char *	out,
		const char *	in,
		int	bps,
		int	in_len,
		int	channel_count )

Definition at line 610 of file utils.cpp.

{
        vector<char *> out_ch(channel_count);
        for (int i = 0; i < channel_count; ++i) {
                out_ch[i] = out + (ptrdiff_t) in_len / channel_count * i;
        }
        interleaved2noninterleaved2(out_ch.data(), in, bps, in_len, channel_count);
}

References audio_desc::bps, and interleaved2noninterleaved2().

Referenced by write_samples().

Here is the call graph for this function:

◆ interleaved2noninterleaved2()

void interleaved2noninterleaved2	(	char **	out,
		const char *	in,
		int	bps,
		int	in_len,
		int	channel_count )

Definition at line 566 of file utils.cpp.

{
        for (int i = 0; i < in_len / channel_count / bps; ++i) {
                for (int ch = 0; ch < channel_count; ++ch) {
                        memcpy(out_ch[ch] + (ptrdiff_t) i * bps, in, bps);
                        in += bps;
                }
        }
}

References audio_desc::bps.

Referenced by file_append_audio_frame(), and interleaved2noninterleaved().

◆ interleaved2noninterleaved_float()

void interleaved2noninterleaved_float	(	char **	out,
		const char *	in,
		int	in_bps,
		int	in_len,
		int	channel_count )

Definition at line 578 of file utils.cpp.

{
        for (int ch = 0; ch < channel_count; ++ch) {
                assert((uintptr_t) out_ch[ch] % 4 == 0);
        }
        if (in_bps == 1) { // bps 1 is unsigned
                for (int i = 0; i < in_len / channel_count; ++i) {
                        for (int ch = 0; ch < channel_count; ++ch) {
                                const int val =
                                    INT8_MIN + *(const uint8_t *) in;
                                *(float *) (void *) (out_ch[ch] +
                                                     (ptrdiff_t) i * 4) =
                                    (float) val / -INT8_MIN;
                                in++;;
                        }
                }
        } else {
                for (int i = 0; i < in_len / channel_count / in_bps; ++i) {
                        for (int ch = 0; ch < channel_count; ++ch) {
                                int32_t val = 0;
                                memcpy((char *) &val + 4 - in_bps, in, in_bps);
                                *(float *) (void *) (out_ch[ch] +
                                                     (ptrdiff_t) i * 4) =
                                    (float) val / (-1.0F * INT32_MIN);
                                in += in_bps;
                        }
                }
        }
}

References val.

Referenced by file_append_audio_frame().

◆ mux_and_mix_channel()

void mux_and_mix_channel	(	char *	out,
		const char *	in,
		int	bps,
		int	in_len,
		int	out_stream_channels,
		int	chan_pos_stream,
		double	scale )

Definition at line 402 of file utils.cpp.

{
        int i;
 
        assert (bps <= 4);
 
        out += pos_in_stream * bps;
 
        for(i = 0; i < in_len / bps; i++) {
                int32_t in_value = format_from_in_bps(in, bps);
                int32_t out_value = format_from_in_bps(out, bps);
 
                int32_t new_value = (double)in_value * scale + out_value;
 
                format_to_out_bps(out, bps, new_value);
 
                in += bps;
                out += out_stream_channels * bps;
        }
}

References audio_desc::bps, format_from_in_bps(), and format_to_out_bps().

Referenced by decode_audio_frame().

Here is the call graph for this function:

◆ mux_channel()

void mux_channel	(	char *	out,
		const char *	in,
		int	bps,
		int	in_len,
		int	out_stream_channels,
		int	chan_pos_stream,
		double	scale )

Definition at line 371 of file utils.cpp.

{
        int samples = in_len / bps;
        int i;
        
        assert (bps <= 4);
 
        out += pos_in_stream * bps;
 
        if(scale == 1.0) {
                for (i = 0; i < samples; ++i) {
                        memcpy(out, in, bps);
 
                        in += bps;
                        out += out_stream_channels * bps;
 
                }
        } else {
                for (i = 0; i < samples; ++i) {
                        int32_t in_value = format_from_in_bps(in, bps);
 
                        in_value *= scale;
 
                        format_to_out_bps(out, bps, in_value);
 
                        in += bps;
                        out += out_stream_channels * bps;
                }
        }
}

References audio_desc::bps, format_from_in_bps(), and format_to_out_bps().

Referenced by decode_yuri_audio_frame(), InputProc(), jack_process_callback(), and vidcap_file_write_audio().

Here is the call graph for this function:

◆ parse_audio_format()

int parse_audio_format	(	const char *	str,
		struct audio_desc *	ret )

Parses configuration string for audio format.

Only members that are specified explicitly by the config string are changed in returned audio desc, the remaining members are left untouched!

Definition at line 655 of file utils.cpp.

                                                                {
        if (strcmp(str, "help") == 0) {
                color_printf(TBOLD("Audio format") " syntax:\n");
                color_printf(TBOLD("\t{channels=<num>|bps=<bits_per_sample>|sample_rate=<rate>}*\n"));
                color_printf("\t\tmultiple options can be separated by a colon\n");
                return 1;
        }
 
        unique_ptr<char[]> arg_copy(new char[strlen(str) + 1]);
        char *arg = arg_copy.get();
        strcpy(arg, str);
 
        char *save_ptr = nullptr;
        char *tmp = arg;
 
        while (char *item = strtok_r(tmp, ",:", &save_ptr)) {
                const char *const val    = strchr(item, '=') + 1;
                if (IS_KEY_PREFIX(item, "channels")) {
                        ret->ch_count = stoi(val);
                        if (ret->ch_count < 1 ||
                            ret->ch_count > MAX_AUD_CH_COUNT) {
                                log_msg(LOG_LEVEL_ERROR,
                                        "Invalid number of channels %s! Valid "
                                        "range 1-%d.\n",
                                        val, MAX_AUD_CH_COUNT);
                                return -1;
                        }
                } else if (IS_KEY_PREFIX(item, "bps")) {
                        const int bps = stoi(val);
                        if (bps % 8 != 0 || bps <= 0 || bps > 32) {
                                log_msg(LOG_LEVEL_ERROR, "Invalid bps %s!\n",
                                        val);
                                if (bps % 8 != 0) {
                                        LOG(LOG_LEVEL_WARNING) << "bps is in bits per sample but a value not divisible by 8 was given.\n";
                                }
                                log_msg(LOG_LEVEL_ERROR, "Supported values are 8, 16, 24, or 32 bits.\n");
                                return -1;
                        }
                        ret->bps = bps / 8;
                } else if (IS_KEY_PREFIX(item, "sample_rate")) {
                        const long long rate = unit_evaluate(val, nullptr);
                        if (rate <= 0 || rate > MAX_AUD_SAMPLE_RATE) {
                                LOG(LOG_LEVEL_ERROR)
                                    << "Invalid sample_rate " << rate
                                    << "! Valid range 1-"
                                    << MAX_AUD_SAMPLE_RATE << ".\n";
                                return -1;
                        }
                        ret->sample_rate = (int) rate;
                } else {
                        LOG(LOG_LEVEL_ERROR) << "Unkonwn option \"" << item << "\" for audio format!\n";
                        LOG(LOG_LEVEL_INFO) << "Use \"help\" keyword for syntax.!\n";
                        return -1;
                }
 
                tmp = nullptr;
        }
        return 0;
}

References audio_desc::bps, audio_frame::bps, audio_desc::ch_count, color_printf(), IS_KEY_PREFIX, LOG, LOG_LEVEL_ERROR, LOG_LEVEL_INFO, LOG_LEVEL_WARNING, log_msg(), MAX_AUD_CH_COUNT, MAX_AUD_SAMPLE_RATE, audio_desc::sample_rate, TBOLD, unit_evaluate(), and val.

Referenced by audio_decoder_reconfigure(), and set_audio_capture_format().

Here is the call graph for this function:

◆ parse_channel_map_cfg()

bool parse_channel_map_cfg	(	struct channel_map *	channel_map,
		const char *	cfg )

Definition at line 716 of file utils.cpp.

                                                                            {
        char *save_ptr = NULL;
        char *item;
        char *ptr;
        char *tmp = ptr = strdup(cfg);
 
        channel_map->size = 0;
        while((item = strtok_r(ptr, ",", &save_ptr))) {
                ptr = NULL;
                // item is in format x1:y1
                if(isdigit(item[0])) {
                        channel_map->size = std::max(channel_map->size, atoi(item) + 1);
                }
        }
 
        channel_map->map = (int **) malloc(channel_map->size * sizeof(int *));
        channel_map->sizes = (int *) malloc(channel_map->size * sizeof(int));
 
        /* default value, do not process */
        for(int i = 0; i < channel_map->size; ++i) {
                channel_map->map[i] = NULL;
                channel_map->sizes[i] = 0;
        }
 
        free (tmp);
        tmp = ptr = strdup(cfg);
 
        while((item = strtok_r(ptr, ",", &save_ptr))) {
                ptr = NULL;
 
                assert(strchr(item, ':') != NULL);
                int src;
                if(isdigit(item[0])) {
                        src = atoi(item);
                } else {
                        src = -1;
                }
                if(!isdigit(strchr(item, ':')[1])) {
                        log_msg(LOG_LEVEL_ERROR, "Audio destination channel not entered!\n");
                        free(tmp);
                        return false;
                }
                int dst = atoi(strchr(item, ':') + 1);
                if(src >= 0) {
                        channel_map->sizes[src] += 1;
                        if(channel_map->map[src] == NULL) {
                                channel_map->map[src] = (int *) malloc(1 * sizeof(int));
                        } else {
                                channel_map->map[src] = (int *) realloc(channel_map->map[src], channel_map->sizes[src] * sizeof(int));
                        }
                        channel_map->map[src][channel_map->sizes[src] - 1] = dst;
                }
        }
 
        free(tmp);
        tmp = NULL;
 
        if (!channel_map->validate()) {
                log_msg(LOG_LEVEL_ERROR, "Wrong audio mapping.\n");
                return false;
        }
        channel_map->compute_contributors();
 
        return true;
}

References channel_map::compute_contributors(), LOG_LEVEL_ERROR, log_msg(), channel_map::map, channel_map::size, channel_map::sizes, and channel_map::validate().

Referenced by audio_decoder_init(), and init().

Here is the call graph for this function:

◆ remux_and_mix_channel()

void remux_and_mix_channel	(	char *	out,
		const char *	in,
		int	bps,
		int	frames,
		int	in_stream_channels,
		int	out_stream_channels,
		int	in_channel,
		int	out_channel,
		double	scale )

Definition at line 423 of file utils.cpp.

{
        int i;
 
        assert (bps <= 4);
 
        out += out_channel * bps;
        in += in_channel * bps;
 
        for(i = 0; i < frames; i++) {
                int32_t in_value = format_from_in_bps(in, bps);
                int32_t out_value = format_from_in_bps(out, bps);
 
                int32_t new_value = (double)in_value * scale + out_value;
 
                format_to_out_bps(out, bps, new_value);
 
                in += in_stream_channels * bps;
                out += out_stream_channels * bps;
        }
}

References audio_desc::bps, format_from_in_bps(), and format_to_out_bps().

Referenced by filter().

Here is the call graph for this function:

◆ remux_channel()

void remux_channel	(	char *	out,
		const char *	in,
		int	bps,
		int	in_len,
		int	in_stream_channels,
		int	out_stream_channels,
		int	pos_in_stream,
		int	pos_out_stream )

Definition at line 352 of file utils.cpp.

{
        int samples = in_len / (in_stream_channels * bps);
        int i;
 
        assert (bps <= 4);
 
        in += pos_in_stream * bps;
        out += pos_out_stream * bps;
 
        for (i = 0; i < samples; ++i) {
                memcpy(out, in, bps);
 
                out += bps * out_stream_channels;
                in += bps * in_stream_channels;
 
        }
}

References audio_desc::bps.

Referenced by audio_tx_send_standard(), and vidcap_state_aja::grab().

◆ signed2unsigned()

void signed2unsigned	(	char *	out,
		const char *	in,
		int	in_len )

Converts int8_t samples to uint8_t by adding 128 (standard shifted zero unsigned samples).

Works also in the opposite direction!

Can be used in situ.

Definition at line 515 of file utils.cpp.

{
        const auto *inch = reinterpret_cast<const int8_t *>(in);
        uint8_t *outch = (uint8_t *) out;
        int items = in_len / sizeof(int8_t);
 
        while(items-- > 0) {
                int8_t in_value = *inch++;
                uint8_t out_value = (int) 128 + in_value;
                *outch++ = out_value;
        }
}

Referenced by audio_cap_alsa_read(), libavcodec_compress(), libavcodec_decompress(), wav_read(), wav_writer_write(), and write_samples().

Classes

Macros

Functions

Detailed Description

Macro Definition Documentation

◆ STORE_I32_SAMPLE

Function Documentation

◆ append_audio_frame()

◆ audio_channel_demux()

◆ audio_desc_eq()

◆ audio_desc_from_audio_channel()

◆ audio_desc_from_frame()

◆ audio_desc_to_cstring()

◆ audio_frame_copy()

◆ audio_frame_multiply_channel()

◆ audio_frame_write_desc()

◆ calculate_rms() [1/2]

◆ calculate_rms() [2/2]

◆ change_bps()

◆ change_bps2()

◆ copy_channel()

◆ demux_channel()

◆ downshift_with_dither()

◆ float2int()

◆ format_audio_channel_volume()

◆ get_avg_volume()

◆ int2float()

◆ interleaved2noninterleaved()

◆ interleaved2noninterleaved2()

◆ interleaved2noninterleaved_float()

◆ mux_and_mix_channel()

◆ mux_channel()

◆ parse_audio_format()

◆ parse_channel_map_cfg()

◆ remux_and_mix_channel()

◆ remux_channel()

◆ signed2unsigned()