gstdspbase.h

/*
 * Copyright (C) 2009-2010 Felipe Contreras
 *
 * Author: Felipe Contreras <felipe.contreras@gmail.com>
 *
 * This file may be used under the terms of the GNU Lesser General Public
 * License version 2.1, a copy of which is found in LICENSE included in the
 * packaging of this file.
 */

#ifndef GST_DSP_BASE_H
#define GST_DSP_BASE_H

#include <gst/gst.h>

G_BEGIN_DECLS

#define GST_DSP_BASE(obj) (GstDspBase *)(obj)
#define GST_DSP_BASE_TYPE (gst_dsp_base_get_type())
#define GST_DSP_BASE_CLASS(obj) (GstDspBaseClass *)(obj)
#define GST_DSP_BASE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS((obj), GST_DSP_BASE_TYPE, GstDspBaseClass))

/* #define TS_COUNT */

typedef struct _GstDspBase GstDspBase;
typedef struct _GstDspBaseClass GstDspBaseClass;

typedef struct du_port_t du_port_t;

#include "dmm_buffer.h"
#include "sem.h"
#include "async_queue.h"

struct td_buffer;

typedef void (*port_buffer_cb_t) (GstDspBase *base, struct td_buffer *tb);

struct td_buffer {
	struct du_port_t *port;
	dmm_buffer_t *data;
	dmm_buffer_t *comm;
	dmm_buffer_t *params;
	void *user_data;
	bool keyframe;
	bool pinned;
	bool clean;
};

struct du_port_t {
	int id;
	struct td_buffer *buffers;
	guint num_buffers;
	AsyncQueue *queue;
	port_buffer_cb_t send_cb;
	port_buffer_cb_t recv_cb;
	int dir;
};

struct td_codec {
	const struct dsp_uuid *uuid;
	const char *filename;
	void (*setup_params)(GstDspBase *base);
	void (*create_args)(GstDspBase *base, unsigned *profile_id, void **arg_data);
	bool (*handle_extra_data)(GstDspBase *base, GstBuffer *buf);
	void (*flush_buffer)(GstDspBase *base);
	void (*send_params)(GstDspBase *base, struct dsp_node *node);
	void (*update_params) (GstDspBase *base, struct dsp_node *node, uint32_t msg);
	unsigned (*get_latency)(GstDspBase *base, unsigned frame_duration);
};

struct ts_item {
	GstClockTime time;
	GstClockTime duration;
	GstEvent *event;
};

struct _GstDspBase {
	GstElement element;

	GstPad *sinkpad, *srcpad;

	struct td_codec *codec;
	int dsp_handle;
	void *proc;
	struct dsp_node *node;
	struct dsp_notification *events[3];

	GstFlowReturn status;
	unsigned long input_buffer_size;
	unsigned long output_buffer_size;
	GThread *dsp_thread, *out_thread;
	gboolean done;
	int deferred_eos;
	int eos;

	du_port_t *ports[2];
	dmm_buffer_t *alg_ctrl;
	struct ts_item ts_array[20];
	guint ts_in_pos, ts_out_pos, ts_push_pos;
	GMutex *ts_mutex;
	gulong ts_count;
	GstClockTime default_duration;
	GSem *flush;
	guint alg;

	gboolean use_pad_alloc; /**< Use pad_alloc for output buffers. */
	gboolean use_pinned; /**< Reuse output buffers. */
	guint dsp_error;

	void *(*create_node)(GstDspBase *base);
	bool (*parse_func)(GstDspBase *base, GstBuffer *buf);
	void (*pre_process_buffer)(GstDspBase *base, GstBuffer *buf);
	void (*reset)(GstDspBase *base);
	void (*flush_buffer)(GstDspBase *base);
	void (*got_message)(GstDspBase *self, struct dsp_msg *msg);
	bool (*send_buffer)(GstDspBase *self, struct td_buffer *tb);
	bool (*send_play_message)(GstDspBase *self);
	bool (*send_stop_message)(GstDspBase *self);
	GstCaps *tmp_caps;

	struct timespec eos_start;
	gint eos_timeout; /* how much to wait for the EOS from DSP (ms) */

	GstBuffer *codec_data;
	bool parsed;

	/* hacks */
	guint skip_hack; /* don't push x number of buffers */
	guint skip_hack_2; /* don't process x number of buffers */
};

struct _GstDspBaseClass {
	GstElementClass parent_class;

	gboolean (*sink_event)(GstDspBase *base, GstEvent *event);
	gboolean (*src_event)(GstDspBase *base, GstEvent *event);
};

GType gst_dsp_base_get_type(void);

du_port_t *du_port_new(int id, int dir);
void du_port_free(du_port_t *p);
void du_port_alloc_buffers(du_port_t *p, guint num_buffers);

gboolean gstdsp_start(GstDspBase *self);
gboolean gstdsp_send_codec_data(GstDspBase *self, GstBuffer *buf);
gboolean gstdsp_set_codec_data_caps(GstDspBase *base, GstBuffer *buf);
gboolean gstdsp_reinit(GstDspBase *base);
void gstdsp_got_error(GstDspBase *self, guint id, const char *message);
void gstdsp_post_error(GstDspBase *self, const char *message);
void gstdsp_send_alg_ctrl(GstDspBase *self, struct dsp_node *node, dmm_buffer_t *b);
void gstdsp_base_flush_buffer(GstDspBase *self);

typedef void (*gstdsp_setup_params_func)(GstDspBase *base, dmm_buffer_t *b);

static inline void gstdsp_port_setup_params(GstDspBase *self,
					    du_port_t *p,
					    size_t size,
					    gstdsp_setup_params_func func)
{
	unsigned i;
	for (i = 0; i < p->num_buffers; i++) {
		dmm_buffer_t *b;
		b = dmm_buffer_calloc(self->dsp_handle,
				      self->proc, size, DMA_BIDIRECTIONAL);
		if (func)
			func(self, b);
		dmm_buffer_map(b);
		p->buffers[i].params = b;
	}
}

/* this is saner than gst_pad_set_caps() */
static inline bool gst_pad_take_caps(GstPad *pad, GstCaps *caps)
{
	bool ret;
	ret = gst_pad_set_caps(pad, caps);
	gst_caps_unref(caps);
	return ret;
}

extern struct td_codec td_mp4vdec_codec;
extern struct td_codec td_h264dec_codec;
extern struct td_codec td_wmvdec_codec;
extern struct td_codec td_jpegdec_codec;

extern struct td_codec td_mp4venc_codec;
extern struct td_codec td_jpegenc_codec;
extern struct td_codec td_h264enc_codec;

extern struct td_codec td_vpp_codec;
extern struct td_codec td_aacdec_codec;

G_END_DECLS

#endif /* GST_DSP_BASE_H */