2016-02-23 23:16:51 +00:00
|
|
|
/******************************************************************************
|
|
|
|
Copyright (C) 2013 by Hugh Bailey <obs.jim@gmail.com>
|
|
|
|
|
|
|
|
This program is free software: you can redistribute it and/or modify
|
|
|
|
it under the terms of the GNU General Public License as published by
|
|
|
|
the Free Software Foundation, either version 2 of the License, or
|
|
|
|
(at your option) any later version.
|
|
|
|
|
|
|
|
This program is distributed in the hope that it will be useful,
|
|
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
|
GNU General Public License for more details.
|
|
|
|
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
|
|
along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
******************************************************************************/
|
|
|
|
|
|
|
|
#pragma once
|
|
|
|
|
|
|
|
#include "media-io-defs.h"
|
|
|
|
#include "../util/c99defs.h"
|
|
|
|
#include "../util/util_uint128.h"
|
|
|
|
|
|
|
|
#ifdef __cplusplus
|
|
|
|
extern "C" {
|
|
|
|
#endif
|
|
|
|
|
2019-09-22 21:19:10 +00:00
|
|
|
#define MAX_AUDIO_MIXES 6
|
|
|
|
#define MAX_AUDIO_CHANNELS 8
|
2016-02-23 23:16:51 +00:00
|
|
|
#define AUDIO_OUTPUT_FRAMES 1024
|
|
|
|
|
2019-09-22 21:19:10 +00:00
|
|
|
#define TOTAL_AUDIO_SIZE \
|
|
|
|
(MAX_AUDIO_MIXES * MAX_AUDIO_CHANNELS * AUDIO_OUTPUT_FRAMES * \
|
|
|
|
sizeof(float))
|
2018-02-19 19:54:37 +00:00
|
|
|
|
2016-02-23 23:16:51 +00:00
|
|
|
/*
|
|
|
|
* Base audio output component. Use this to create an audio output track
|
|
|
|
* for the media.
|
|
|
|
*/
|
|
|
|
|
|
|
|
struct audio_output;
|
|
|
|
typedef struct audio_output audio_t;
|
|
|
|
|
|
|
|
enum audio_format {
|
|
|
|
AUDIO_FORMAT_UNKNOWN,
|
|
|
|
|
|
|
|
AUDIO_FORMAT_U8BIT,
|
|
|
|
AUDIO_FORMAT_16BIT,
|
|
|
|
AUDIO_FORMAT_32BIT,
|
|
|
|
AUDIO_FORMAT_FLOAT,
|
|
|
|
|
|
|
|
AUDIO_FORMAT_U8BIT_PLANAR,
|
|
|
|
AUDIO_FORMAT_16BIT_PLANAR,
|
|
|
|
AUDIO_FORMAT_32BIT_PLANAR,
|
|
|
|
AUDIO_FORMAT_FLOAT_PLANAR,
|
|
|
|
};
|
|
|
|
|
2018-02-19 19:54:37 +00:00
|
|
|
/**
|
|
|
|
* The speaker layout describes where the speakers are located in the room.
|
|
|
|
* For OBS it dictates:
|
|
|
|
* * how many channels are available and
|
|
|
|
* * which channels are used for which speakers.
|
|
|
|
*
|
|
|
|
* Standard channel layouts where retrieved from ffmpeg documentation at:
|
|
|
|
* https://trac.ffmpeg.org/wiki/AudioChannelManipulation
|
|
|
|
*/
|
2016-02-23 23:16:51 +00:00
|
|
|
enum speaker_layout {
|
2019-09-22 21:19:10 +00:00
|
|
|
SPEAKERS_UNKNOWN, /**< Unknown setting, fallback is stereo. */
|
|
|
|
SPEAKERS_MONO, /**< Channels: MONO */
|
|
|
|
SPEAKERS_STEREO, /**< Channels: FL, FR */
|
|
|
|
SPEAKERS_2POINT1, /**< Channels: FL, FR, LFE */
|
|
|
|
SPEAKERS_4POINT0, /**< Channels: FL, FR, FC, RC */
|
|
|
|
SPEAKERS_4POINT1, /**< Channels: FL, FR, FC, LFE, RC */
|
|
|
|
SPEAKERS_5POINT1, /**< Channels: FL, FR, FC, LFE, RL, RR */
|
|
|
|
SPEAKERS_7POINT1 = 8, /**< Channels: FL, FR, FC, LFE, RL, RR, SL, SR */
|
2016-02-23 23:16:51 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
struct audio_data {
|
2019-09-22 21:19:10 +00:00
|
|
|
uint8_t *data[MAX_AV_PLANES];
|
|
|
|
uint32_t frames;
|
|
|
|
uint64_t timestamp;
|
2016-02-23 23:16:51 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
struct audio_output_data {
|
2019-09-22 21:19:10 +00:00
|
|
|
float *data[MAX_AUDIO_CHANNELS];
|
2016-02-23 23:16:51 +00:00
|
|
|
};
|
|
|
|
|
2019-09-22 21:19:10 +00:00
|
|
|
typedef bool (*audio_input_callback_t)(void *param, uint64_t start_ts,
|
|
|
|
uint64_t end_ts, uint64_t *new_ts,
|
|
|
|
uint32_t active_mixers,
|
|
|
|
struct audio_output_data *mixes);
|
2016-02-23 23:16:51 +00:00
|
|
|
|
|
|
|
struct audio_output_info {
|
2019-09-22 21:19:10 +00:00
|
|
|
const char *name;
|
2016-02-23 23:16:51 +00:00
|
|
|
|
2019-09-22 21:19:10 +00:00
|
|
|
uint32_t samples_per_sec;
|
|
|
|
enum audio_format format;
|
2016-02-23 23:16:51 +00:00
|
|
|
enum speaker_layout speakers;
|
|
|
|
|
|
|
|
audio_input_callback_t input_callback;
|
2019-09-22 21:19:10 +00:00
|
|
|
void *input_param;
|
2016-02-23 23:16:51 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
struct audio_convert_info {
|
2019-09-22 21:19:10 +00:00
|
|
|
uint32_t samples_per_sec;
|
|
|
|
enum audio_format format;
|
2016-02-23 23:16:51 +00:00
|
|
|
enum speaker_layout speakers;
|
|
|
|
};
|
|
|
|
|
|
|
|
static inline uint32_t get_audio_channels(enum speaker_layout speakers)
|
|
|
|
{
|
|
|
|
switch (speakers) {
|
2019-09-22 21:19:10 +00:00
|
|
|
case SPEAKERS_MONO:
|
|
|
|
return 1;
|
|
|
|
case SPEAKERS_STEREO:
|
|
|
|
return 2;
|
|
|
|
case SPEAKERS_2POINT1:
|
|
|
|
return 3;
|
|
|
|
case SPEAKERS_4POINT0:
|
|
|
|
return 4;
|
|
|
|
case SPEAKERS_4POINT1:
|
|
|
|
return 5;
|
|
|
|
case SPEAKERS_5POINT1:
|
|
|
|
return 6;
|
|
|
|
case SPEAKERS_7POINT1:
|
|
|
|
return 8;
|
|
|
|
case SPEAKERS_UNKNOWN:
|
|
|
|
return 0;
|
2016-02-23 23:16:51 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline size_t get_audio_bytes_per_channel(enum audio_format format)
|
|
|
|
{
|
|
|
|
switch (format) {
|
|
|
|
case AUDIO_FORMAT_U8BIT:
|
|
|
|
case AUDIO_FORMAT_U8BIT_PLANAR:
|
|
|
|
return 1;
|
|
|
|
|
|
|
|
case AUDIO_FORMAT_16BIT:
|
|
|
|
case AUDIO_FORMAT_16BIT_PLANAR:
|
|
|
|
return 2;
|
|
|
|
|
|
|
|
case AUDIO_FORMAT_FLOAT:
|
|
|
|
case AUDIO_FORMAT_FLOAT_PLANAR:
|
|
|
|
case AUDIO_FORMAT_32BIT:
|
|
|
|
case AUDIO_FORMAT_32BIT_PLANAR:
|
|
|
|
return 4;
|
|
|
|
|
|
|
|
case AUDIO_FORMAT_UNKNOWN:
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline bool is_audio_planar(enum audio_format format)
|
|
|
|
{
|
|
|
|
switch (format) {
|
|
|
|
case AUDIO_FORMAT_U8BIT:
|
|
|
|
case AUDIO_FORMAT_16BIT:
|
|
|
|
case AUDIO_FORMAT_32BIT:
|
|
|
|
case AUDIO_FORMAT_FLOAT:
|
|
|
|
return false;
|
|
|
|
|
|
|
|
case AUDIO_FORMAT_U8BIT_PLANAR:
|
|
|
|
case AUDIO_FORMAT_FLOAT_PLANAR:
|
|
|
|
case AUDIO_FORMAT_16BIT_PLANAR:
|
|
|
|
case AUDIO_FORMAT_32BIT_PLANAR:
|
|
|
|
return true;
|
|
|
|
|
|
|
|
case AUDIO_FORMAT_UNKNOWN:
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline size_t get_audio_planes(enum audio_format format,
|
2019-09-22 21:19:10 +00:00
|
|
|
enum speaker_layout speakers)
|
2016-02-23 23:16:51 +00:00
|
|
|
{
|
|
|
|
return (is_audio_planar(format) ? get_audio_channels(speakers) : 1);
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline size_t get_audio_size(enum audio_format format,
|
2019-09-22 21:19:10 +00:00
|
|
|
enum speaker_layout speakers,
|
|
|
|
uint32_t frames)
|
2016-02-23 23:16:51 +00:00
|
|
|
{
|
|
|
|
bool planar = is_audio_planar(format);
|
|
|
|
|
|
|
|
return (planar ? 1 : get_audio_channels(speakers)) *
|
2019-09-22 21:19:10 +00:00
|
|
|
get_audio_bytes_per_channel(format) * frames;
|
2016-02-23 23:16:51 +00:00
|
|
|
}
|
|
|
|
|
2019-09-22 21:19:10 +00:00
|
|
|
static inline uint64_t audio_frames_to_ns(size_t sample_rate, uint64_t frames)
|
2016-02-23 23:16:51 +00:00
|
|
|
{
|
|
|
|
util_uint128_t val;
|
|
|
|
val = util_mul64_64(frames, 1000000000ULL);
|
|
|
|
val = util_div128_32(val, (uint32_t)sample_rate);
|
|
|
|
return val.low;
|
|
|
|
}
|
|
|
|
|
2019-09-22 21:19:10 +00:00
|
|
|
static inline uint64_t ns_to_audio_frames(size_t sample_rate, uint64_t frames)
|
2016-02-23 23:16:51 +00:00
|
|
|
{
|
|
|
|
util_uint128_t val;
|
|
|
|
val = util_mul64_64(frames, sample_rate);
|
|
|
|
val = util_div128_32(val, 1000000000);
|
|
|
|
return val.low;
|
|
|
|
}
|
|
|
|
|
2019-09-22 21:19:10 +00:00
|
|
|
#define AUDIO_OUTPUT_SUCCESS 0
|
2016-02-23 23:16:51 +00:00
|
|
|
#define AUDIO_OUTPUT_INVALIDPARAM -1
|
2019-09-22 21:19:10 +00:00
|
|
|
#define AUDIO_OUTPUT_FAIL -2
|
2016-02-23 23:16:51 +00:00
|
|
|
|
|
|
|
EXPORT int audio_output_open(audio_t **audio, struct audio_output_info *info);
|
|
|
|
EXPORT void audio_output_close(audio_t *audio);
|
|
|
|
|
|
|
|
typedef void (*audio_output_callback_t)(void *param, size_t mix_idx,
|
2019-09-22 21:19:10 +00:00
|
|
|
struct audio_data *data);
|
2016-02-23 23:16:51 +00:00
|
|
|
|
|
|
|
EXPORT bool audio_output_connect(audio_t *video, size_t mix_idx,
|
2019-09-22 21:19:10 +00:00
|
|
|
const struct audio_convert_info *conversion,
|
|
|
|
audio_output_callback_t callback, void *param);
|
2016-02-23 23:16:51 +00:00
|
|
|
EXPORT void audio_output_disconnect(audio_t *video, size_t mix_idx,
|
2019-09-22 21:19:10 +00:00
|
|
|
audio_output_callback_t callback,
|
|
|
|
void *param);
|
2016-02-23 23:16:51 +00:00
|
|
|
|
|
|
|
EXPORT bool audio_output_active(const audio_t *audio);
|
|
|
|
|
|
|
|
EXPORT size_t audio_output_get_block_size(const audio_t *audio);
|
|
|
|
EXPORT size_t audio_output_get_planes(const audio_t *audio);
|
|
|
|
EXPORT size_t audio_output_get_channels(const audio_t *audio);
|
|
|
|
EXPORT uint32_t audio_output_get_sample_rate(const audio_t *audio);
|
2019-09-22 21:19:10 +00:00
|
|
|
EXPORT const struct audio_output_info *
|
|
|
|
audio_output_get_info(const audio_t *audio);
|
2016-02-23 23:16:51 +00:00
|
|
|
|
|
|
|
#ifdef __cplusplus
|
|
|
|
}
|
|
|
|
#endif
|