static int
create_signal_thread(pthread_t *id)
{
int err;
sigset_t oldmask;
sigemptyset(&mask);
sigaddset(&mask, SIGINT);
sigaddset(&mask, SIGQUIT);
err = pthread_sigmask(SIG_BLOCK, &mask, &oldmask);
if (err != 0) {
err_pthread_sigmask(errno);
return err;
}
err = create_joinable_thread(id, signal_handler, 0);
if (err < 0) {
err_create_joinable_thread(errno);
err_msg("error[create_signal_thread]: Unable to create signal thread.");
return err;
}
return err;
}
int x11c_initialise(X11Common* x11Common, int reviewDuration, OnScreenDisplay* osd, X11WindowInfo* windowInfo)
{
memset(x11Common, 0, sizeof(x11Common));
x11Common->reviewDuration = reviewDuration;
x11Common->osd = osd;
x11Common->progressBarInput.data = x11Common;
x11Common->progressBarInput.set_listener = x11c_set_pbar_listener;
x11Common->progressBarInput.unset_listener = x11c_unset_pbar_listener;
x11Common->progressBarInput.close = x11c_close_pbar;
x11Common->keyboardInput.data = x11Common;
x11Common->keyboardInput.set_listener = x11c_set_keyboard_listener;
x11Common->keyboardInput.unset_listener = x11c_unset_keyboard_listener;
x11Common->keyboardInput.close = x11c_close_keyboard;
x11Common->mouseInput.data = x11Common;
x11Common->mouseInput.set_listener = x11c_set_mouse_listener;
x11Common->mouseInput.unset_listener = x11c_unset_mouse_listener;
x11Common->mouseInput.close = x11c_close_mouse;
if (windowInfo)
{
x11Common->windowInfo = *windowInfo;
}
CHK_ORET(XInitThreads() != 0);
CHK_ORET(init_mutex(&x11Common->eventMutex));
CHK_ORET(create_joinable_thread(&x11Common->processEventThreadId, process_event_thread, x11Common));
return 1;
}
int hac_create_http_access(MediaPlayer* player, int port, HTTPAccess** access)
{
HTTPAccess* newAccess;
CALLOC_ORET(newAccess, HTTPAccess, 1);
CHK_OFAIL(har_create_resources(&newAccess->resources));
newAccess->control = ply_get_media_control(player);
if (newAccess->control == NULL)
{
fprintf(stderr, "Media player has no control\n");
goto fail;
}
newAccess->playerListener.data = newAccess;
newAccess->playerListener.frame_displayed_event = hac_frame_displayed_event;
newAccess->playerListener.frame_dropped_event = hac_frame_dropped_event;
newAccess->playerListener.state_change_event = hac_state_change_event;
newAccess->playerListener.end_of_source_event = hac_end_of_source_event;
newAccess->playerListener.start_of_source_event = hac_start_of_source_event;
newAccess->playerListener.player_closed = hac_player_closed;
if (!ply_register_player_listener(player, &newAccess->playerListener))
{
fprintf(stderr, "Failed to register http access as player listener\n");
goto fail;
}
CHK_OFAIL((newAccess->ctx = shttpd_init(NULL, "document_root", "/dev/null", NULL)) != NULL);
shttpd_register_uri(newAccess->ctx, "/", &http_player_page, newAccess);
shttpd_register_uri(newAccess->ctx, "/player.html", &http_player_page, newAccess);
shttpd_register_uri(newAccess->ctx, "/index.html", &http_player_page, newAccess);
shttpd_register_uri(newAccess->ctx, "/resources/*", &http_static_content, newAccess);
shttpd_register_uri(newAccess->ctx, "/player/state.xml", &http_player_state_xml, newAccess);
shttpd_register_uri(newAccess->ctx, "/player/state.txt", &http_player_state_txt, newAccess);
shttpd_register_uri(newAccess->ctx, "/player/control/*", &http_player_control, newAccess);
CHK_OFAIL(shttpd_listen(newAccess->ctx, port, 0));
CHK_OFAIL(init_mutex(&newAccess->playerStateMutex));
CHK_OFAIL(create_joinable_thread(&newAccess->httpThreadId, http_thread, newAccess));
*access = newAccess;
return 1;
fail:
hac_free_http_access(&newAccess);
return 0;
}
int
create_iwatch_thread(pthread_t *id, int fd, queue_t q)
{
int err;
struct watch_data_t *wdata;
wdata = malloc(sizeof(struct watch_data_t));
if (wdata == NULL) {
err_malloc(errno);
err_msg("error[create_iwatch_thread]: Unable to malloc watch data.\n");
return -1;
}
wdata->fd = fd;
wdata->q = q;
err = create_joinable_thread(id, watch, wdata);
if (err < 0)
err_create_joinable_thread(errno);
return err;
}
int create_dv_connect(MediaSink* sink, int sinkStreamId, int sourceStreamId,
const StreamInfo* streamInfo, int numFFMPEGThreads, int useWorkerThread, StreamConnect** connect)
{
DVDecodeStreamConnect* newConnect;
StreamInfo decodedStreamInfo;
int result;
/* register stream with sink */
if (streamInfo->format == DV25_YUV420_FORMAT)
{
decodedStreamInfo = *streamInfo;
decodedStreamInfo.format = YUV420_FORMAT;
result = msk_accept_stream(sink, &decodedStreamInfo);
}
else if (streamInfo->format == DV25_YUV411_FORMAT)
{
decodedStreamInfo = *streamInfo;
decodedStreamInfo.format = YUV411_FORMAT;
result = msk_accept_stream(sink, &decodedStreamInfo);
}
else /* streamInfo->format == DV50_FORMAT || streamInfo->format == DV100_FORMAT */
{
decodedStreamInfo = *streamInfo;
decodedStreamInfo.format = YUV422_FORMAT;
result = msk_accept_stream(sink, &decodedStreamInfo);
}
/* try UYVY if default format is not accepted */
if (!result)
{
decodedStreamInfo = *streamInfo;
decodedStreamInfo.format = UYVY_FORMAT;
result = msk_accept_stream(sink, &decodedStreamInfo);
}
if (!result)
{
/* shouldn't be here because a call to dv_connect_accept() should've returned false already */
ml_log_error("Failed to create DV connector because format is not accepted\n");
return 0;
}
if (!msk_register_stream(sink, sinkStreamId, &decodedStreamInfo))
{
/* could have failed if max streams exceeded for example */
return 0;
}
CALLOC_ORET(newConnect, DVDecodeStreamConnect, 1);
newConnect->useWorkerThread = useWorkerThread;
newConnect->decodedFormat = decodedStreamInfo.format;
if (streamInfo->format == DV25_YUV420_FORMAT || streamInfo->format == DV25_YUV411_FORMAT)
{
newConnect->dvDataSize = (stream_is_pal_frame_rate(streamInfo) ? 144000 : 120000);
}
else if (streamInfo->format == DV50_FORMAT)
{
newConnect->dvDataSize = (stream_is_pal_frame_rate(streamInfo) ? 288000 : 240000);
}
else /* streamInfo->format == DV100_FORMAT */
{
newConnect->dvDataSize = 576000;
}
if ((newConnect->dvData = (unsigned char*)calloc(
newConnect->dvDataSize + FF_INPUT_BUFFER_PADDING_SIZE /* FFMPEG for some reason needs the extra space */,
sizeof(unsigned char))) == NULL)
{
ml_log_error("Failed to allocate memory\n");
goto fail;
}
newConnect->sink = sink;
newConnect->sourceStreamId = sourceStreamId;
newConnect->sinkStreamId = sinkStreamId;
newConnect->streamInfo = *streamInfo;
if (decodedStreamInfo.format == UYVY_FORMAT)
{
newConnect->sinkBufferSize = streamInfo->width * streamInfo->height * 2;
}
else if (decodedStreamInfo.format == YUV422_FORMAT)
{
newConnect->sinkBufferSize = streamInfo->width * streamInfo->height * 2;
}
else /* YUV420 / YUV411 */
{
newConnect->sinkBufferSize = streamInfo->width * streamInfo->height * 3 / 2;
}
newConnect->streamConnect.data = newConnect;
newConnect->streamConnect.get_source_listener = ddc_get_source_listener;
newConnect->streamConnect.sync = ddc_sync;
newConnect->streamConnect.close = ddc_close;
newConnect->sourceListener.data = newConnect;
newConnect->sourceListener.accept_frame = ddc_accept_frame;
newConnect->sourceListener.allocate_buffer = ddc_allocate_buffer;
newConnect->sourceListener.deallocate_buffer = ddc_deallocate_buffer;
newConnect->sourceListener.receive_frame = ddc_receive_frame;
newConnect->sourceListener.receive_frame_const = ddc_receive_frame_const;
/* create DV decoder */
CHK_OFAIL(init_dv_decoder_resources());
CHK_OFAIL(create_dv_decoder(streamInfo->format, streamInfo->width, streamInfo->height,
numFFMPEGThreads, &newConnect->decoder));
/* create worker thread */
if (useWorkerThread)
{
CHK_OFAIL(init_mutex(&newConnect->workerMutex));
CHK_OFAIL(init_cond_var(&newConnect->frameIsReadyCond));
CHK_OFAIL(init_cond_var(&newConnect->workerIsBusyCond));
CHK_OFAIL(create_joinable_thread(&newConnect->workerThreadId, worker_thread, newConnect));
}
*connect = &newConnect->streamConnect;
return 1;
fail:
ddc_close(newConnect);
return 0;
}
int main(int argc, char **argv)
{
int c, help, version, recursive, err, i;
struct galaxy_t galaxy;
struct galaxy_event_t *gevent;
help = version = recursive = err = 0;
while ((c = getopt(argc, argv, "hp:rv")) != -1) {
switch (c) {
case 'h':
usage(stdout);
exit(0);
break;
case 'p':
break;
case 'r':
recursive = 1;
break;
case 'v':
version = 1;
break;
case '?':
err = 1;
break;
}
}
/* Check if any invalid parameters were passed into this program. */
if (err) {
usage(stderr);
exit(1);
}
/* Iterate over all remaining lone arguments. Each argument is assumed
* to be a directory that needs to be added as a top-level galaxy
* watch. */
printf("argc = %d\n", argc);
if (argc <= 1) {
err_msg("Usage: %s <Regular expression to match file with>", argv[0]);
exit(-1);
}
err = galaxy_connect(&galaxy);
if (err < 0) {
err_msg("error: Unable to connect to server.");
err_msg("err = %d", err);
return 1;
}
/* galaxy_watch (galaxy_t, regexp to match, Inotify mask) */
//galaxy_ignore_mask(&galaxy, IN_OPEN);
/*
galaxy_ignore_watch(&galaxy, IN_ALL_EVENTS, "^/proc");
galaxy_ignore_watch(&galaxy, IN_ALL_EVENTS, "^/sys");
galaxy_ignore_watch(&galaxy, IN_ALL_EVENTS, "^/media");
galaxy_ignore_watch(&galaxy, IN_ALL_EVENTS, "^/tmp");
galaxy_ignore_watch(&galaxy, IN_ALL_EVENTS, "^/root");
galaxy_ignore_watch(&galaxy, IN_ALL_EVENTS, "^/home");
galaxy_ignore_watch(&galaxy, IN_ALL_EVENTS, "^/mnt");
galaxy_ignore_watch(&galaxy, IN_ALL_EVENTS, "^/dev");
galaxy_ignore_watch(&galaxy, IN_ALL_EVENTS, "^/var");
galaxy_ignore_watch(&galaxy, IN_ALL_EVENTS, "^/usr/src");
galaxy_ignore_watch(&galaxy, IN_ALL_EVENTS, "^/usr/tmp");
galaxy_ignore_watch(&galaxy, IN_ALL_EVENTS, "^/usr/var");
galaxy_ignore_watch(&galaxy, IN_ALL_EVENTS, "^/usr/misc");
galaxy_ignore_watch(&galaxy, IN_ALL_EVENTS, "^/sources");
galaxy_ignore_watch(&galaxy, IN_ALL_EVENTS, "^/tools");
*/
galaxy_watch(&galaxy, IN_CREATE | IN_DELETE | IN_MODIFY, argv[1]);
galaxy_watch(&galaxy, IN_ALL_EVENTS, ".*");
//galaxy_ignore_watch(&galaxy, IN_CLOSE, argv[1]);
create_signal_thread(&signal_thread);
//err = pthread_create(&galaxy_reciever, NULL, receive_notifications, &galaxy);
err = create_joinable_thread(&galaxy_reciever, receive_notifications, &galaxy);
if (err < 0) {
err_create_joinable_thread(errno);
err_msg("error: Unable to create thread.");
galaxy_close(&galaxy);
return 1;
}
pthread_join(galaxy_reciever, NULL);
pthread_join(signal_thread, NULL);
galaxy_close(&galaxy);
return 0;
}
