DVB streams

#include "xine_checker.h"
#include "log.h"

#include <stdio.h>

enum { stream_state_unknown = 0, stream_state_finished, stream_state_ok };

struct stream_context
{
	struct xine_checker *checker;
	const char *uri;
	#if 0
	xine_stream_t *st;
	#endif
	int state;
};

static inline struct log *xine_checker_log(const struct xine_checker *checker)
{
	return (struct log *)checker->log;
}

static inline struct log *stream_context_log(const struct stream_context *ctx)
{
	return xine_checker_log(ctx->checker);
}

static inline int stream_context_init(struct stream_context *ctx, struct xine_checker *checker, const char *uri)
{
	ctx->checker = checker;
	ctx->uri = uri;

	#if 0
	ctx->st = xine_stream_new(checker->xine, checker->ao, checker->vo);
	if (ctx->st == NULL)
	{
		log_error(xine_checker_log(checker), "failed to create xine stream object, error code %d", xine_get_error(NULL));
		return 0;
	}
	#endif

	ctx->state = stream_state_unknown;

	return 1;
}

static inline void stream_context_deinit(struct stream_context *ctx)
{
	#if 0
	xine_dispose(ctx->st);
	#endif
}

static inline xine_stream_t *stream_context_get_stream(struct stream_context *ctx)
{
	return ctx->checker->st;
}

static void xine_event_cb(void *user_data, const xine_event_t *event)
{
	struct stream_context *ctx = user_data;
	uint32_t has_audio, audio_flag;
	uint32_t has_video, video_flag;

	switch (event->type)
	{
	case XINE_EVENT_UI_PLAYBACK_FINISHED:
		if (ctx->state == stream_state_unknown)
			ctx->state = stream_state_finished;
		break;
	case XINE_EVENT_UI_CHANNELS_CHANGED:
		has_audio = xine_get_stream_info(stream_context_get_stream(ctx), XINE_STREAM_INFO_HAS_AUDIO);
		audio_flag = xine_get_stream_info(stream_context_get_stream(ctx), XINE_STREAM_INFO_AUDIO_CHANNELS);

		has_video = xine_get_stream_info(stream_context_get_stream(ctx), XINE_STREAM_INFO_HAS_VIDEO);
		video_flag = xine_get_stream_info(stream_context_get_stream(ctx), XINE_STREAM_INFO_VIDEO_RATIO);

		log_xtreme(xine_checker_log(ctx->checker), "%s: %u/%u, %u/%u", ctx->uri,
			has_audio, audio_flag, has_video, video_flag);
		if ((!has_audio || audio_flag != 0) && (!has_video || video_flag != 0))
			ctx->state = stream_state_ok;
		break;
	}
}

static inline int stream_context_check(struct stream_context *ctx, double timeout)
{
	xine_event_queue_t *queue;
	time_t start_time;

	ctx->state = stream_state_unknown;

	queue = xine_event_new_queue(stream_context_get_stream(ctx));
	if (queue != NULL)
	{
		xine_event_create_listener_thread(queue, xine_event_cb, ctx);

		if (!xine_open(stream_context_get_stream(ctx), ctx->uri))
			log_error(stream_context_log(ctx), "failed to open uri %s, error code %d",
				ctx->uri, xine_get_error(stream_context_get_stream(ctx)));
		else
		{
			if (!xine_play(stream_context_get_stream(ctx), 0, 0))
				log_error(stream_context_log(ctx), "failed to play uri %s, error code %d",
					ctx->uri, xine_get_error(stream_context_get_stream(ctx)));
			else
			{
				log_xtreme(stream_context_log(ctx), "%s: check timeout %.2lf", ctx->uri, timeout);
				start_time = time(NULL);
				while (ctx->state == stream_state_unknown && difftime(time(NULL), start_time) < timeout)
					usleep(100);
				log_xtreme(stream_context_log(ctx), "%s: check result %d", ctx->uri, ctx->state);
			}
			xine_close(stream_context_get_stream(ctx));
		}

		xine_event_dispose_queue(queue);
	}

	return ctx->state == stream_state_ok;
}

int xine_checker_init(struct xine_checker *checker, struct log *log)
{
	checker->log = log;

	checker->xine = xine_new();
	if (checker->xine == NULL)
		log_error(log, "failed to create xine object");
	else
	{
		xine_init(checker->xine);
		checker->ao = xine_open_audio_driver(checker->xine, "none", NULL);
		if (checker->ao == NULL)
			log_error(log, "failed to create audio driver object");
		else
		{
			checker->vo = xine_open_video_driver(checker->xine, "none", XINE_VISUAL_TYPE_NONE, NULL);
			if (checker->vo == NULL)
				log_error(log, "failed to create video driver object");
			else
			{
				checker->st = xine_stream_new(checker->xine, checker->ao, checker->vo);
				if (checker->st != NULL)
					return 1;
				log_error(log, "failed to create xine stream object, error code %d", xine_get_error(NULL));
				xine_close_video_driver(checker->xine, checker->vo);
			}
			xine_close_audio_driver(checker->xine, checker->ao);
		}
		xine_exit(checker->xine);
	}

	return 0;
}

void xine_checker_deinit(struct xine_checker *checker)
{
	xine_dispose(checker->st);
	xine_close_video_driver(checker->xine, checker->vo);
	xine_close_audio_driver(checker->xine, checker->ao);
	xine_exit(checker->xine);
}

int xine_checker_check_uri(struct xine_checker *checker, const char *uri, double timeout)
{
	struct stream_context ctx;
	int result = 0;

	if (timeout <= 0.0)
	{
		log_error(xine_checker_log(checker), "failed to check uri %s: invalid timeout %.2lf", uri, timeout);
		return 0;
	}

	if (stream_context_init(&ctx, checker, uri))
	{
		result = stream_context_check(&ctx, timeout);
		stream_context_deinit(&ctx);
	}

	return result;
}

#ifndef _XINE_CHECKER_H_
#define _XINE_CHECKER_H_

#include <xine.h>

struct log;

struct xine_checker
{
	struct log *log;

	xine_t *xine;
	xine_audio_port_t *ao;
	xine_video_port_t *vo;
	xine_stream_t *st;
};

int xine_checker_init(struct xine_checker *checker, struct log *log);
void xine_checker_deinit(struct xine_checker *checker);

int xine_checker_check_uri(struct xine_checker *checker, const char *uri, double timeout);

#endif