mirror of
https://github.com/obsproject/obs-studio.git
synced 2024-07-14 23:34:08 +00:00
a0f679bc40
API functions added: ----------------------------------------------- obs_output_set_preferred_size obs_output_get_width obs_output_get_height obs_encoder_set_scaled_size obs_encoder_get_width obs_encoder_get_height These functions allow for easier means of setting a custom resolution on an output or encoder. If an output uses an encoder and you set the preferred width/height using the output, then the output will attempt to set the scaled width/height for the encoder it's currently using. Outputs and encoders now should use these functions to determine the width/height of the raw frame data instead of using the video-io functions.
742 lines
19 KiB
C
742 lines
19 KiB
C
/******************************************************************************
|
|
Copyright (C) 2013-2014 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/>.
|
|
******************************************************************************/
|
|
|
|
#include "obs.h"
|
|
#include "obs-internal.h"
|
|
|
|
struct obs_encoder_info *find_encoder(const char *id)
|
|
{
|
|
for (size_t i = 0; i < obs->encoder_types.num; i++) {
|
|
struct obs_encoder_info *info = obs->encoder_types.array+i;
|
|
|
|
if (strcmp(info->id, id) == 0)
|
|
return info;
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
const char *obs_encoder_get_display_name(const char *id)
|
|
{
|
|
struct obs_encoder_info *ei = find_encoder(id);
|
|
return ei ? ei->get_name() : NULL;
|
|
}
|
|
|
|
static bool init_encoder(struct obs_encoder *encoder, const char *name,
|
|
obs_data_t settings)
|
|
{
|
|
pthread_mutex_init_value(&encoder->callbacks_mutex);
|
|
pthread_mutex_init_value(&encoder->outputs_mutex);
|
|
|
|
if (!obs_context_data_init(&encoder->context, settings, name))
|
|
return false;
|
|
if (pthread_mutex_init(&encoder->callbacks_mutex, NULL) != 0)
|
|
return false;
|
|
if (pthread_mutex_init(&encoder->outputs_mutex, NULL) != 0)
|
|
return false;
|
|
|
|
if (encoder->info.get_defaults)
|
|
encoder->info.get_defaults(encoder->context.settings);
|
|
|
|
return true;
|
|
}
|
|
|
|
static struct obs_encoder *create_encoder(const char *id,
|
|
enum obs_encoder_type type, const char *name,
|
|
obs_data_t settings)
|
|
{
|
|
struct obs_encoder *encoder;
|
|
struct obs_encoder_info *ei = find_encoder(id);
|
|
bool success;
|
|
|
|
if (!ei || ei->type != type)
|
|
return NULL;
|
|
|
|
encoder = bzalloc(sizeof(struct obs_encoder));
|
|
encoder->info = *ei;
|
|
|
|
success = init_encoder(encoder, name, settings);
|
|
if (!success) {
|
|
obs_encoder_destroy(encoder);
|
|
encoder = NULL;
|
|
}
|
|
|
|
obs_context_data_insert(&encoder->context,
|
|
&obs->data.encoders_mutex,
|
|
&obs->data.first_encoder);
|
|
|
|
blog(LOG_INFO, "encoder '%s' (%s) created", name, id);
|
|
return encoder;
|
|
}
|
|
|
|
obs_encoder_t obs_video_encoder_create(const char *id, const char *name,
|
|
obs_data_t settings)
|
|
{
|
|
if (!name || !id) return NULL;
|
|
return create_encoder(id, OBS_ENCODER_VIDEO, name, settings);
|
|
}
|
|
|
|
obs_encoder_t obs_audio_encoder_create(const char *id, const char *name,
|
|
obs_data_t settings)
|
|
{
|
|
if (!name || !id) return NULL;
|
|
return create_encoder(id, OBS_ENCODER_AUDIO, name, settings);
|
|
}
|
|
|
|
static void receive_video(void *param, struct video_data *frame);
|
|
static void receive_audio(void *param, struct audio_data *data);
|
|
|
|
static inline struct audio_convert_info *get_audio_info(
|
|
struct obs_encoder *encoder, struct audio_convert_info *info)
|
|
{
|
|
const struct audio_output_info *aoi;
|
|
aoi = audio_output_get_info(encoder->media);
|
|
memset(info, 0, sizeof(struct audio_convert_info));
|
|
|
|
if (encoder->info.get_audio_info)
|
|
encoder->info.get_audio_info(encoder->context.data, info);
|
|
|
|
if (info->format == AUDIO_FORMAT_UNKNOWN)
|
|
info->format = aoi->format;
|
|
if (!info->samples_per_sec)
|
|
info->samples_per_sec = aoi->samples_per_sec;
|
|
if (info->speakers == SPEAKERS_UNKNOWN)
|
|
info->speakers = aoi->speakers;
|
|
|
|
return info;
|
|
}
|
|
|
|
static inline struct video_scale_info *get_video_info(
|
|
struct obs_encoder *encoder, struct video_scale_info *info)
|
|
{
|
|
if (encoder->info.get_video_info)
|
|
if (encoder->info.get_video_info(encoder->context.data, info))
|
|
return info;
|
|
|
|
return NULL;
|
|
}
|
|
|
|
static inline bool has_scaling(struct obs_encoder *encoder)
|
|
{
|
|
uint32_t video_width = video_output_get_width(encoder->media);
|
|
uint32_t video_height = video_output_get_height(encoder->media);
|
|
|
|
return encoder->scaled_width && encoder->scaled_height &&
|
|
(video_width != encoder->scaled_width ||
|
|
video_height != encoder->scaled_height);
|
|
}
|
|
|
|
static void add_connection(struct obs_encoder *encoder)
|
|
{
|
|
struct audio_convert_info audio_info = {0};
|
|
struct video_scale_info video_info = {0};
|
|
|
|
if (encoder->info.type == OBS_ENCODER_AUDIO) {
|
|
get_audio_info(encoder, &audio_info);
|
|
audio_output_connect(encoder->media, &audio_info, receive_audio,
|
|
encoder);
|
|
} else {
|
|
struct video_scale_info *info =
|
|
get_video_info(encoder, &video_info);
|
|
|
|
if (!info && has_scaling(encoder)) {
|
|
info = &video_info;
|
|
info->format = video_output_get_format(encoder->media);
|
|
info->colorspace = VIDEO_CS_DEFAULT;
|
|
info->range = VIDEO_RANGE_DEFAULT;
|
|
}
|
|
|
|
if (info && (!info->width || !info->height)) {
|
|
info->width = obs_encoder_get_width(encoder);
|
|
info->height = obs_encoder_get_height(encoder);
|
|
}
|
|
|
|
video_output_connect(encoder->media, info, receive_video,
|
|
encoder);
|
|
}
|
|
|
|
encoder->active = true;
|
|
}
|
|
|
|
static void remove_connection(struct obs_encoder *encoder)
|
|
{
|
|
if (encoder->info.type == OBS_ENCODER_AUDIO)
|
|
audio_output_disconnect(encoder->media, receive_audio,
|
|
encoder);
|
|
else
|
|
video_output_disconnect(encoder->media, receive_video,
|
|
encoder);
|
|
|
|
encoder->active = false;
|
|
}
|
|
|
|
static inline void free_audio_buffers(struct obs_encoder *encoder)
|
|
{
|
|
for (size_t i = 0; i < MAX_AV_PLANES; i++) {
|
|
circlebuf_free(&encoder->audio_input_buffer[i]);
|
|
bfree(encoder->audio_output_buffer[i]);
|
|
encoder->audio_output_buffer[i] = NULL;
|
|
}
|
|
}
|
|
|
|
static void obs_encoder_actually_destroy(obs_encoder_t encoder)
|
|
{
|
|
if (encoder) {
|
|
pthread_mutex_lock(&encoder->outputs_mutex);
|
|
for (size_t i = 0; i < encoder->outputs.num; i++) {
|
|
struct obs_output *output = encoder->outputs.array[i];
|
|
obs_output_remove_encoder(output, encoder);
|
|
}
|
|
da_free(encoder->outputs);
|
|
pthread_mutex_unlock(&encoder->outputs_mutex);
|
|
|
|
blog(LOG_INFO, "encoder '%s' destroyed", encoder->context.name);
|
|
|
|
free_audio_buffers(encoder);
|
|
|
|
if (encoder->context.data)
|
|
encoder->info.destroy(encoder->context.data);
|
|
da_free(encoder->callbacks);
|
|
pthread_mutex_destroy(&encoder->callbacks_mutex);
|
|
pthread_mutex_destroy(&encoder->outputs_mutex);
|
|
obs_context_data_free(&encoder->context);
|
|
bfree(encoder);
|
|
}
|
|
}
|
|
|
|
/* does not actually destroy the encoder until all connections to it have been
|
|
* removed. (full reference counting really would have been superfluous) */
|
|
void obs_encoder_destroy(obs_encoder_t encoder)
|
|
{
|
|
if (encoder) {
|
|
bool destroy;
|
|
|
|
obs_context_data_remove(&encoder->context);
|
|
|
|
pthread_mutex_lock(&encoder->callbacks_mutex);
|
|
destroy = encoder->callbacks.num == 0;
|
|
if (!destroy)
|
|
encoder->destroy_on_stop = true;
|
|
pthread_mutex_unlock(&encoder->callbacks_mutex);
|
|
|
|
if (destroy)
|
|
obs_encoder_actually_destroy(encoder);
|
|
}
|
|
}
|
|
|
|
const char *obs_encoder_get_name(obs_encoder_t encoder)
|
|
{
|
|
return encoder ? encoder->context.name : NULL;
|
|
}
|
|
|
|
static inline obs_data_t get_defaults(const struct obs_encoder_info *info)
|
|
{
|
|
obs_data_t settings = obs_data_create();
|
|
if (info->get_defaults)
|
|
info->get_defaults(settings);
|
|
return settings;
|
|
}
|
|
|
|
obs_data_t obs_encoder_defaults(const char *id)
|
|
{
|
|
const struct obs_encoder_info *info = find_encoder(id);
|
|
return (info) ? get_defaults(info) : NULL;
|
|
}
|
|
|
|
obs_properties_t obs_get_encoder_properties(const char *id)
|
|
{
|
|
const struct obs_encoder_info *ei = find_encoder(id);
|
|
if (ei && ei->get_properties) {
|
|
obs_data_t defaults = get_defaults(ei);
|
|
obs_properties_t properties;
|
|
|
|
properties = ei->get_properties();
|
|
obs_properties_apply_settings(properties, defaults);
|
|
obs_data_release(defaults);
|
|
return properties;
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
obs_properties_t obs_encoder_properties(obs_encoder_t encoder)
|
|
{
|
|
if (encoder && encoder->info.get_properties) {
|
|
obs_properties_t props;
|
|
props = encoder->info.get_properties();
|
|
obs_properties_apply_settings(props, encoder->context.settings);
|
|
return props;
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
void obs_encoder_update(obs_encoder_t encoder, obs_data_t settings)
|
|
{
|
|
if (!encoder) return;
|
|
|
|
obs_data_apply(encoder->context.settings, settings);
|
|
|
|
if (encoder->info.update && encoder->context.data)
|
|
encoder->info.update(encoder->context.data,
|
|
encoder->context.settings);
|
|
}
|
|
|
|
bool obs_encoder_get_extra_data(obs_encoder_t encoder, uint8_t **extra_data,
|
|
size_t *size)
|
|
{
|
|
if (encoder && encoder->info.get_extra_data && encoder->context.data)
|
|
return encoder->info.get_extra_data(encoder->context.data,
|
|
extra_data, size);
|
|
|
|
return false;
|
|
}
|
|
|
|
obs_data_t obs_encoder_get_settings(obs_encoder_t encoder)
|
|
{
|
|
if (!encoder) return NULL;
|
|
|
|
obs_data_addref(encoder->context.settings);
|
|
return encoder->context.settings;
|
|
}
|
|
|
|
static inline void reset_audio_buffers(struct obs_encoder *encoder)
|
|
{
|
|
free_audio_buffers(encoder);
|
|
|
|
for (size_t i = 0; i < encoder->planes; i++)
|
|
encoder->audio_output_buffer[i] =
|
|
bmalloc(encoder->framesize_bytes);
|
|
}
|
|
|
|
static void intitialize_audio_encoder(struct obs_encoder *encoder)
|
|
{
|
|
struct audio_convert_info info;
|
|
get_audio_info(encoder, &info);
|
|
|
|
encoder->samplerate = info.samples_per_sec;
|
|
encoder->planes = get_audio_planes(info.format, info.speakers);
|
|
encoder->blocksize = get_audio_size(info.format, info.speakers, 1);
|
|
encoder->framesize = encoder->info.get_frame_size(
|
|
encoder->context.data);
|
|
|
|
encoder->framesize_bytes = encoder->blocksize * encoder->framesize;
|
|
reset_audio_buffers(encoder);
|
|
}
|
|
|
|
bool obs_encoder_initialize(obs_encoder_t encoder)
|
|
{
|
|
if (!encoder) return false;
|
|
|
|
if (encoder->active)
|
|
return true;
|
|
|
|
if (encoder->context.data)
|
|
encoder->info.destroy(encoder->context.data);
|
|
|
|
encoder->context.data = encoder->info.create(encoder->context.settings,
|
|
encoder);
|
|
if (!encoder->context.data)
|
|
return false;
|
|
|
|
encoder->paired_encoder = NULL;
|
|
encoder->start_ts = 0;
|
|
|
|
if (encoder->info.type == OBS_ENCODER_AUDIO)
|
|
intitialize_audio_encoder(encoder);
|
|
|
|
return true;
|
|
}
|
|
|
|
static inline size_t get_callback_idx(
|
|
struct obs_encoder *encoder,
|
|
void (*new_packet)(void *param, struct encoder_packet *packet),
|
|
void *param)
|
|
{
|
|
for (size_t i = 0; i < encoder->callbacks.num; i++) {
|
|
struct encoder_callback *cb = encoder->callbacks.array+i;
|
|
|
|
if (cb->new_packet == new_packet && cb->param == param)
|
|
return i;
|
|
}
|
|
|
|
return DARRAY_INVALID;
|
|
}
|
|
|
|
void obs_encoder_start(obs_encoder_t encoder,
|
|
void (*new_packet)(void *param, struct encoder_packet *packet),
|
|
void *param)
|
|
{
|
|
struct encoder_callback cb = {false, new_packet, param};
|
|
bool first = false;
|
|
|
|
if (!encoder || !new_packet || !encoder->context.data) return;
|
|
|
|
pthread_mutex_lock(&encoder->callbacks_mutex);
|
|
|
|
first = (encoder->callbacks.num == 0);
|
|
|
|
size_t idx = get_callback_idx(encoder, new_packet, param);
|
|
if (idx == DARRAY_INVALID)
|
|
da_push_back(encoder->callbacks, &cb);
|
|
|
|
pthread_mutex_unlock(&encoder->callbacks_mutex);
|
|
|
|
if (first) {
|
|
encoder->cur_pts = 0;
|
|
add_connection(encoder);
|
|
}
|
|
}
|
|
|
|
void obs_encoder_stop(obs_encoder_t encoder,
|
|
void (*new_packet)(void *param, struct encoder_packet *packet),
|
|
void *param)
|
|
{
|
|
bool last = false;
|
|
size_t idx;
|
|
|
|
if (!encoder) return;
|
|
|
|
pthread_mutex_lock(&encoder->callbacks_mutex);
|
|
|
|
idx = get_callback_idx(encoder, new_packet, param);
|
|
if (idx != DARRAY_INVALID) {
|
|
da_erase(encoder->callbacks, idx);
|
|
last = (encoder->callbacks.num == 0);
|
|
}
|
|
|
|
pthread_mutex_unlock(&encoder->callbacks_mutex);
|
|
|
|
if (last) {
|
|
remove_connection(encoder);
|
|
|
|
if (encoder->destroy_on_stop)
|
|
obs_encoder_actually_destroy(encoder);
|
|
}
|
|
}
|
|
|
|
const char *obs_encoder_get_codec(obs_encoder_t encoder)
|
|
{
|
|
return encoder ? encoder->info.codec : NULL;
|
|
}
|
|
|
|
void obs_encoder_set_scaled_size(obs_encoder_t encoder, uint32_t width,
|
|
uint32_t height)
|
|
{
|
|
if (!encoder || encoder->info.type != OBS_ENCODER_VIDEO)
|
|
return;
|
|
|
|
if (encoder->active) {
|
|
blog(LOG_WARNING, "encoder '%s': Cannot set the scaled "
|
|
"resolution while the encoder is active",
|
|
obs_encoder_get_name(encoder));
|
|
return;
|
|
}
|
|
|
|
encoder->scaled_width = width;
|
|
encoder->scaled_height = height;
|
|
}
|
|
|
|
uint32_t obs_encoder_get_width(obs_encoder_t encoder)
|
|
{
|
|
if (!encoder || !encoder->media ||
|
|
encoder->info.type != OBS_ENCODER_VIDEO)
|
|
return 0;
|
|
|
|
return encoder->scaled_width != 0 ?
|
|
encoder->scaled_width :
|
|
video_output_get_width(encoder->media);
|
|
}
|
|
|
|
uint32_t obs_encoder_get_height(obs_encoder_t encoder)
|
|
{
|
|
if (!encoder || !encoder->media ||
|
|
encoder->info.type != OBS_ENCODER_VIDEO)
|
|
return 0;
|
|
|
|
return encoder->scaled_width != 0 ?
|
|
encoder->scaled_height :
|
|
video_output_get_height(encoder->media);
|
|
}
|
|
|
|
void obs_encoder_set_video(obs_encoder_t encoder, video_t video)
|
|
{
|
|
const struct video_output_info *voi;
|
|
|
|
if (!video || !encoder || encoder->info.type != OBS_ENCODER_VIDEO)
|
|
return;
|
|
|
|
voi = video_output_get_info(video);
|
|
|
|
encoder->media = video;
|
|
encoder->timebase_num = voi->fps_den;
|
|
encoder->timebase_den = voi->fps_num;
|
|
}
|
|
|
|
void obs_encoder_set_audio(obs_encoder_t encoder, audio_t audio)
|
|
{
|
|
if (!audio || !encoder || encoder->info.type != OBS_ENCODER_AUDIO)
|
|
return;
|
|
|
|
encoder->media = audio;
|
|
encoder->timebase_num = 1;
|
|
encoder->timebase_den = audio_output_get_sample_rate(audio);
|
|
}
|
|
|
|
video_t obs_encoder_video(obs_encoder_t encoder)
|
|
{
|
|
return (encoder && encoder->info.type == OBS_ENCODER_VIDEO) ?
|
|
encoder->media : NULL;
|
|
}
|
|
|
|
audio_t obs_encoder_audio(obs_encoder_t encoder)
|
|
{
|
|
return (encoder && encoder->info.type == OBS_ENCODER_AUDIO) ?
|
|
encoder->media : NULL;
|
|
}
|
|
|
|
bool obs_encoder_active(obs_encoder_t encoder)
|
|
{
|
|
return encoder ? encoder->active : false;
|
|
}
|
|
|
|
static inline bool get_sei(struct obs_encoder *encoder,
|
|
uint8_t **sei, size_t *size)
|
|
{
|
|
if (encoder->info.get_sei_data)
|
|
return encoder->info.get_sei_data(encoder->context.data, sei,
|
|
size);
|
|
return false;
|
|
}
|
|
|
|
static void send_first_video_packet(struct obs_encoder *encoder,
|
|
struct encoder_callback *cb, struct encoder_packet *packet)
|
|
{
|
|
struct encoder_packet first_packet;
|
|
DARRAY(uint8_t) data;
|
|
uint8_t *sei;
|
|
size_t size;
|
|
|
|
/* always wait for first keyframe */
|
|
if (!packet->keyframe)
|
|
return;
|
|
|
|
da_init(data);
|
|
|
|
if (!get_sei(encoder, &sei, &size)) {
|
|
cb->new_packet(cb->param, packet);
|
|
return;
|
|
}
|
|
|
|
da_push_back_array(data, sei, size);
|
|
da_push_back_array(data, packet->data, packet->size);
|
|
|
|
first_packet = *packet;
|
|
first_packet.data = data.array;
|
|
first_packet.size = data.num;
|
|
|
|
cb->new_packet(cb->param, &first_packet);
|
|
cb->sent_first_packet = true;
|
|
|
|
da_free(data);
|
|
}
|
|
|
|
static inline void send_packet(struct obs_encoder *encoder,
|
|
struct encoder_callback *cb, struct encoder_packet *packet)
|
|
{
|
|
/* include SEI in first video packet */
|
|
if (encoder->info.type == OBS_ENCODER_VIDEO && !cb->sent_first_packet)
|
|
send_first_video_packet(encoder, cb, packet);
|
|
else
|
|
cb->new_packet(cb->param, packet);
|
|
}
|
|
|
|
static void full_stop(struct obs_encoder *encoder)
|
|
{
|
|
if (encoder) {
|
|
pthread_mutex_lock(&encoder->callbacks_mutex);
|
|
da_free(encoder->callbacks);
|
|
remove_connection(encoder);
|
|
pthread_mutex_unlock(&encoder->callbacks_mutex);
|
|
}
|
|
}
|
|
|
|
static inline void do_encode(struct obs_encoder *encoder,
|
|
struct encoder_frame *frame)
|
|
{
|
|
struct encoder_packet pkt = {0};
|
|
bool received = false;
|
|
bool success;
|
|
|
|
pkt.timebase_num = encoder->timebase_num;
|
|
pkt.timebase_den = encoder->timebase_den;
|
|
|
|
success = encoder->info.encode(encoder->context.data, frame, &pkt,
|
|
&received);
|
|
if (!success) {
|
|
full_stop(encoder);
|
|
blog(LOG_ERROR, "Error encoding with encoder '%s'",
|
|
encoder->context.name);
|
|
return;
|
|
}
|
|
|
|
if (received) {
|
|
/* we use system time here to ensure sync with other encoders,
|
|
* you do not want to use relative timestamps here */
|
|
pkt.dts_usec = encoder->start_ts / 1000 + packet_dts_usec(&pkt);
|
|
|
|
pthread_mutex_lock(&encoder->callbacks_mutex);
|
|
|
|
for (size_t i = 0; i < encoder->callbacks.num; i++) {
|
|
struct encoder_callback *cb;
|
|
cb = encoder->callbacks.array+i;
|
|
send_packet(encoder, cb, &pkt);
|
|
}
|
|
|
|
pthread_mutex_unlock(&encoder->callbacks_mutex);
|
|
}
|
|
}
|
|
|
|
static void receive_video(void *param, struct video_data *frame)
|
|
{
|
|
struct obs_encoder *encoder = param;
|
|
struct encoder_frame enc_frame;
|
|
|
|
memset(&enc_frame, 0, sizeof(struct encoder_frame));
|
|
|
|
for (size_t i = 0; i < MAX_AV_PLANES; i++) {
|
|
enc_frame.data[i] = frame->data[i];
|
|
enc_frame.linesize[i] = frame->linesize[i];
|
|
}
|
|
|
|
if (!encoder->start_ts)
|
|
encoder->start_ts = frame->timestamp;
|
|
|
|
enc_frame.frames = 1;
|
|
enc_frame.pts = encoder->cur_pts;
|
|
|
|
do_encode(encoder, &enc_frame);
|
|
|
|
encoder->cur_pts += encoder->timebase_num;
|
|
}
|
|
|
|
static bool buffer_audio(struct obs_encoder *encoder, struct audio_data *data)
|
|
{
|
|
size_t samplerate = encoder->samplerate;
|
|
size_t size = data->frames * encoder->blocksize;
|
|
size_t offset_size = 0;
|
|
|
|
if (encoder->paired_encoder && !encoder->start_ts) {
|
|
uint64_t end_ts = data->timestamp;
|
|
uint64_t v_start_ts = encoder->paired_encoder->start_ts;
|
|
|
|
/* no video yet, so don't start audio */
|
|
if (!v_start_ts)
|
|
return false;
|
|
|
|
/* audio starting point still not synced with video starting
|
|
* point, so don't start audio */
|
|
end_ts += (uint64_t)data->frames * 1000000000ULL / samplerate;
|
|
if (end_ts <= v_start_ts)
|
|
return false;
|
|
|
|
/* ready to start audio, truncate if necessary */
|
|
if (data->timestamp < v_start_ts) {
|
|
uint64_t offset = v_start_ts - data->timestamp;
|
|
offset = (int)(offset * samplerate / 1000000000);
|
|
offset_size = (size_t)offset * encoder->blocksize;
|
|
}
|
|
|
|
encoder->start_ts = v_start_ts;
|
|
}
|
|
|
|
size -= offset_size;
|
|
|
|
/* push in to the circular buffer */
|
|
if (size)
|
|
for (size_t i = 0; i < encoder->planes; i++)
|
|
circlebuf_push_back(&encoder->audio_input_buffer[i],
|
|
data->data[i] + offset_size, size);
|
|
|
|
return true;
|
|
}
|
|
|
|
static void send_audio_data(struct obs_encoder *encoder)
|
|
{
|
|
struct encoder_frame enc_frame;
|
|
|
|
memset(&enc_frame, 0, sizeof(struct encoder_frame));
|
|
|
|
for (size_t i = 0; i < encoder->planes; i++) {
|
|
circlebuf_pop_front(&encoder->audio_input_buffer[i],
|
|
encoder->audio_output_buffer[i],
|
|
encoder->framesize_bytes);
|
|
|
|
enc_frame.data[i] = encoder->audio_output_buffer[i];
|
|
enc_frame.linesize[i] = (uint32_t)encoder->framesize_bytes;
|
|
}
|
|
|
|
enc_frame.frames = (uint32_t)encoder->framesize;
|
|
enc_frame.pts = encoder->cur_pts;
|
|
|
|
do_encode(encoder, &enc_frame);
|
|
|
|
encoder->cur_pts += encoder->framesize;
|
|
}
|
|
|
|
static void receive_audio(void *param, struct audio_data *data)
|
|
{
|
|
struct obs_encoder *encoder = param;
|
|
|
|
if (!buffer_audio(encoder, data))
|
|
return;
|
|
|
|
while (encoder->audio_input_buffer[0].size >= encoder->framesize_bytes)
|
|
send_audio_data(encoder);
|
|
}
|
|
|
|
void obs_encoder_add_output(struct obs_encoder *encoder,
|
|
struct obs_output *output)
|
|
{
|
|
if (!encoder) return;
|
|
|
|
pthread_mutex_lock(&encoder->outputs_mutex);
|
|
da_push_back(encoder->outputs, &output);
|
|
pthread_mutex_unlock(&encoder->outputs_mutex);
|
|
}
|
|
|
|
void obs_encoder_remove_output(struct obs_encoder *encoder,
|
|
struct obs_output *output)
|
|
{
|
|
if (!encoder) return;
|
|
|
|
pthread_mutex_lock(&encoder->outputs_mutex);
|
|
da_erase_item(encoder->outputs, &output);
|
|
pthread_mutex_unlock(&encoder->outputs_mutex);
|
|
}
|
|
|
|
void obs_duplicate_encoder_packet(struct encoder_packet *dst,
|
|
const struct encoder_packet *src)
|
|
{
|
|
*dst = *src;
|
|
dst->data = bmemdup(src->data, src->size);
|
|
}
|
|
|
|
void obs_free_encoder_packet(struct encoder_packet *packet)
|
|
{
|
|
bfree(packet->data);
|
|
memset(packet, 0, sizeof(struct encoder_packet));
|
|
}
|