int opengl_push_message(glc_message_header_t *hdr, void *message, size_t message_size)
{
ps_packet_t packet;
int ret = 0;
ps_buffer_t *to;
if (!lib.running)
return EAGAIN;
if (opengl.unscaled)
to = opengl.unscaled;
else
to = opengl.buffer;
if ((ret = ps_packet_init(&packet, to)))
goto finish;
if ((ret = ps_packet_open(&packet, PS_PACKET_WRITE)))
goto finish;
if ((ret = ps_packet_write(&packet, hdr, sizeof(glc_message_header_t))))
goto finish;
if ((ret = ps_packet_write(&packet, message, message_size)))
goto finish;
if ((ret = ps_packet_close(&packet)))
goto finish;
if ((ret = ps_packet_destroy(&packet)))
goto finish;
finish:
return ret;
}
int gl_capture_destroy(gl_capture_t gl_capture)
{
struct gl_capture_video_stream_s *del;
while (gl_capture->video != NULL) {
del = gl_capture->video;
gl_capture->video = gl_capture->video->next;
glc_log(gl_capture->glc, GLC_PERF, "gl_capture",
"captured %u frames in %llu nsec",
del->num_frames, del->capture_time_ns);
/* we might be in wrong thread */
if (del->indicator_list)
glDeleteLists(del->indicator_list, 1);
if (del->pbo)
gl_capture_destroy_pbo(gl_capture, del);
ps_packet_destroy(&del->packet);
free(del);
}
pthread_rwlock_destroy(&gl_capture->videolist_lock);
pthread_mutex_destroy(&gl_capture->init_pbo_mutex);
if (gl_capture->libGL_handle)
dlclose(gl_capture->libGL_handle);
free(gl_capture);
return 0;
}
int alsa_hook_destroy(alsa_hook_t alsa_hook)
{
struct alsa_hook_stream_s *del;
if (unlikely(alsa_hook == NULL))
return EINVAL;
while (alsa_hook->stream != NULL) {
del = alsa_hook->stream;
alsa_hook->stream = alsa_hook->stream->next;
alsa_hook_stream_wait(del);
sem_destroy(&del->capture_full);
sem_destroy(&del->capture_empty);
pthread_mutex_destroy(&del->write_mutex);
pthread_spin_destroy(&del->write_spinlock);
if (del->capture_data)
free(del->capture_data);
if (del->initialized)
ps_packet_destroy(&del->packet);
free(del);
}
free(alsa_hook);
return 0;
}
int audio_capture_destroy(audio_capture_t audio_capture)
{
if (audio_capture->target)
ps_packet_destroy(&audio_capture->packet);
free(audio_capture);
return 0;
}
int alsa_hook_stream_init(alsa_hook_t alsa_hook,
struct alsa_hook_stream_s *stream)
{
int ret;
glc_message_header_t msg_hdr;
glc_audio_format_message_t fmt_msg;
if (unlikely(!stream->fmt))
return EINVAL;
/* we need proper id for the stream */
if (stream->id < 1)
glc_state_audio_new(alsa_hook->glc, &stream->id,
&stream->state_audio);
glc_log(alsa_hook->glc, GLC_INFO, "alsa_hook",
"%p: initializing stream %d", stream->pcm, stream->id);
/* init packet */
if (stream->initialized)
ps_packet_destroy(&stream->packet);
ps_packet_init(&stream->packet, alsa_hook->to);
/* prepare audio format message */
msg_hdr.type = GLC_MESSAGE_AUDIO_FORMAT;
fmt_msg.id = stream->id;
fmt_msg.flags = stream->flags;
fmt_msg.rate = stream->rate;
fmt_msg.channels = stream->channels;
fmt_msg.format = stream->format;
ps_packet_open(&stream->packet, PS_PACKET_WRITE);
ps_packet_write(&stream->packet, &msg_hdr,
sizeof(glc_message_header_t));
ps_packet_write(&stream->packet, &fmt_msg,
sizeof(glc_audio_format_message_t));
ps_packet_close(&stream->packet);
alsa_hook_stream_wait(stream);
ret = glc_simple_thread_create(alsa_hook->glc, &stream->thread,
alsa_hook_thread, stream);
stream->initialized = 1;
return ret;
}
int glc_util_write_end_of_stream(glc_t *glc, ps_buffer_t *to)
{
int ret = 0;
ps_packet_t packet;
glc_message_header_t header;
header.type = GLC_MESSAGE_CLOSE;
if (unlikely((ret = ps_packet_init(&packet, to))))
goto finish;
if (unlikely((ret = ps_packet_open(&packet, PS_PACKET_WRITE))))
goto finish;
if (unlikely((ret = ps_packet_write(&packet,
&header, sizeof(glc_message_header_t)))))
goto finish;
if (unlikely((ret = ps_packet_close(&packet))))
goto finish;
if (unlikely((ret = ps_packet_destroy(&packet))))
goto finish;
finish:
return ret;
}
