Context Navigation

← Previous Changeset
Next Changeset →

Changeset 195

Timestamp:

01/16/08 13:40:24 (4 years ago)

Author:

ath

Message:

New sync API.

Location:

fm_server/trunk/src

Files:

: 6 modified

fm_element.c (modified) (11 diffs)
fm_element.h (modified) (8 diffs)
fm_pipeline.c (modified) (4 diffs)
fm_pipeline.h (modified) (1 diff)
fm_sync.c (modified) (5 diffs)
fm_sync.h (modified) (6 diffs)

Legend:

: Unmodified
: Added
: Removed

fm_server/trunk/src/fm_element.c

r144	r195
50	50	GValue *value,
51	51	GParamSpec *pspec);
	52	static void fm_element_become_sync_ref (FmElement *element);
52	53
53	54	//static gpointer parent_class = NULL;
…	…
104	105	rgc_marshal_VOID__VOID,
105	106	0);
	107
	108	rgc_method_register ("become_sync_ref",
	109	FM_TYPE_ELEMENT,
	110	G_CALLBACK (fm_element_become_sync_ref),
	111	rgc_marshal_VOID__VOID,
	112	0);
	113
	114	rgc_method_register ("sync_ref_set_peer_master",
	115	FM_TYPE_ELEMENT,
	116	G_CALLBACK (fm_element_sync_ref_set_peer_master),
	117	rgc_marshal_VOID__ELEMENT,
	118	1, G_TYPE_STRING);
106	119	}
107	120
…	…
140	153	element->src_ports = NULL;
141	154	element->sink_ports = NULL;
	155	element->peer_sync_master = NULL;
142	156
143	157	element->active = FALSE;
…	…
145	159
146	160	element->pipeline = NULL;
	161	element->sync_ref = NULL;
	162	element->sync_master = FALSE;
147	163	}
148	164
…	…
205	221
206	222
207		gpointer
208		fm_element_pipeline_get_sync_info (FmElement *element)
209		{
210		g_return_val_if_fail (element->pipeline, NULL);
211
212		FmPipeline *pipe = FM_PIPELINE (element->pipeline);
213		return pipe->sync_info;
214		}
215
216
217		gboolean
218		fm_element_is_sync_master (FmElement *element)
219		{
220		g_return_val_if_fail (element->pipeline, FALSE);
221
222		FmPipeline *pipe = FM_PIPELINE (element->pipeline);
223
224		if (pipe->sync_info->master == element)
	223	inline gboolean
	224	fm_element_is_sync_ref (FmElement *element)
	225	{
	226	if (element->sync_ref)
225	227	return TRUE;
226	228	else
227	229	return FALSE;
	230	}
	231
	232
	233	inline gboolean
	234	fm_element_is_sync_master (FmElement *element)
	235	{
	236	return element->sync_master;
228	237	}
229	238
…	…
273	282	FmElementClass *klass = FM_ELEMENT_GET_CLASS (element);
274	283
275		g_print("fm_element_activate, %p\n", element);
	284	// g_print("fm_element_activate, %p\n", element);
276	285
277	286	g_return_val_if_fail (!element->active, FALSE);
…	…
330	339	void
331	340	fm_element_get_buffer (FmElement *element,
332		FmBuffer *buffer)
	341	FmBuffer *buffer,
	342	FmSync *sync)
333	343	{
334	344	g_return_if_fail (FM_IS_ELEMENT (element));
335		FmElementClass *class = FM_ELEMENT_GET_CLASS (element);
	345	FmElementClass *klass = FM_ELEMENT_GET_CLASS (element);
336	346
337	347	/* FIXME: Check if the element has sinks */
…	…
340	350
341	351	if (element->active) {
342		if (class->get_buffer)
343		(*~~class->get_buffer) (element, buffer~~);
	352	if (klass->get_buffer)
	353	(*klass->get_buffer) (element, buffer, sync);
344	354	else
345	355	g_print ("\"get_buffer\" method not defined for element \"%s\"!\n",
…	…
348	358	if (element->sink_ports) {
349	359	FmElementSinkPort *sink_port = element->src_ports->data;
350		fm_element_get_buffer(sink_port->owner, buffer);
	360	fm_element_get_buffer(sink_port->owner, buffer, sync);
351	361	} else {
352	362	fm_buffer_fill_with_silence(buffer);
…	…
382	392	void
383	393	fm_element_get_buffer_from_src (FmElement *element,
384		FmBuffer *buffer)
	394	FmBuffer *buffer,
	395	FmSync *sync)
385	396	{
386	397	g_return_if_fail (element->sink_ports);
…	…
390	401
391	402	if (peer_port)
392		fm_element_get_buffer(FM_ELEMENT(peer_port->owner), buffer);
	403	fm_element_get_buffer(FM_ELEMENT(peer_port->owner), buffer, sync);
393	404	else
394	405	fm_buffer_fill_with_silence(buffer);
395	406
396	407	}
	408
	409
	410	static void
	411	fm_element_become_sync_ref (FmElement *element)
	412	{
	413	g_print ("fm_element_become_sync_ref on %p!\n", element);
	414
	415	element->sync_ref = g_new0 (FmSync, 1);
	416	}
	417
	418
	419	void
	420	fm_element_sync_ref_set_peer_master (FmElement *reference,
	421	FmElement *peer_sync_master)
	422	{
	423	g_return_if_fail (reference->sync_ref);
	424	FmElementClass *klass = FM_ELEMENT_GET_CLASS (peer_sync_master);
	425	g_return_if_fail (klass->become_sync_master);
	426
	427	g_print ("new sync master is %p %s\n", peer_sync_master, peer_sync_master->name);
	428
	429	reference->peer_sync_master = peer_sync_master;
	430	peer_sync_master->sync_master = TRUE;
	431	(*klass->become_sync_master) (peer_sync_master, reference->sync_ref);
	432	}

fm_server/trunk/src/fm_element.h

r144	r195
35	35	#define FM_ELEMENT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), FM_TYPE_ELEMENT, FmElementClass))
36	36
37		~~typedef enum _FmElementPads FmElementPads;~~
38	37	typedef struct _FmElement FmElement;
39	38	typedef struct _FmElementClass FmElementClass;
40	39
41		~~enum _FmElementPads {~~
42		~~PAD_NONE,~~
43		~~PAD_SINGLE,~~
44		~~PAD_MULTIPLE~~
45		};
46	40
47	41	typedef struct _FmElementSrcPort FmElementSrcPort;
…	…
64	58
65	59
	60	typedef struct _FmSync FmSync;
	61	struct _FmSync {
	62	gboolean in_use;
	63
	64	FmElement *master;
	65
	66	/* written from fm_element_become_sync_master */
	67	gdouble bpm;
	68	gint beat_per_bar;
	69
	70	/* automatically generated */
	71	gdouble ns_per_beat;
	72
	73	/* updated on update_cycle() */
	74	gint bar;
	75	gint beat;
	76	gfloat beat_offset_ns;
	77
	78	gdouble bpm_new;
	79	guint played_ns_new;
	80	};
	81
66	82
67	83
…	…
71	87	gchar *name;
72	88
73		//FmElementPads src_pads;
74		/GList src_list;*/
75		GList *src_ports;
	89	GList *src_ports; // dove esce l'audio
76	90
77		//FmElementPads sink_pads;
78		/GList sink_list;*/
79		GList *sink_ports;
	91	GList *sink_ports; // dove entra l'audio
	92	FmElement *peer_sync_master;
80	93
81	94	gboolean active;
…	…
84	97	// yes, I know this is an hack
85	98	gpointer pipeline;
	99
	100	FmSync *sync_ref;
	101	gboolean sync_master;
86	102	};
87	103
…	…
95	111	gboolean (activate) (FmElement element);
96	112	gboolean (deactivate) (FmElement element);
97		void (become_sync_master) (FmElement element);
	113	void (become_sync_ref) (FmElement element,
	114	FmSync *sync);
	115	void (become_sync_master) (FmElement element,
	116	FmSync *sync);
98	117	void (get_buffer) (FmElement element,
99		FmBuffer *buffer);
	118	FmBuffer *buffer,
	119	FmSync *sync);
100	120	};
101	121
…	…
114	134	fm_element_get_name (FmElement *element);
115	135
116		gpointer
117		fm_element_~~pipeline_get_sync_info~~ (FmElement *element);
	136	inline gboolean
	137	fm_element_is_sync_ref (FmElement *element);
118	138
119		gboolean
	139	inline gboolean
120	140	fm_element_is_sync_master (FmElement *element);
121	141
…	…
138	158	void
139	159	fm_element_get_buffer (FmElement *element,
140		FmBuffer *buffer);
	160	FmBuffer *buffer,
	161	FmSync *sync);
141	162
142	163	void
…	…
148	169	void
149	170	fm_element_get_buffer_from_src (FmElement *element,
150		FmBuffer *buffer);
	171	FmBuffer *buffer,
	172	FmSync *sync);
	173
	174	void
	175	fm_element_sync_ref_set_peer_master (FmElement *reference,
	176	FmElement *peer_sync_master);

fm_server/trunk/src/fm_pipeline.c

r133	r195
23	23	*
24	24	*/
	25
25	26
26	27	#include <glib.h>
…	…
89	90	1, G_TYPE_STRING);
90	91
91		rgc_method_register ("set_sync_master",
	92	/* rgc_method_register ("set_sync_master",
92	93	FM_TYPE_PIPELINE,
93	94	G_CALLBACK (fm_pipeline_set_beat_master),
94	95	rgc_marshal_VOID__ELEMENT,
95		1, G_TYPE_STRING);
	96	1, G_TYPE_STRING);*/
96	97
97	98	rgc_method_register ("add_element",
…	…
191	192
192	193
193		void
	194	/*void
194	195	fm_pipeline_set_beat_master (FmPipeline *pipeline,
195	196	FmElement *element)
…	…
205	206	if (klass->become_sync_master)
206	207	(*klass->become_sync_master) (element);
207		}
	208	}*/
208	209
209	210

fm_server/trunk/src/fm_pipeline.h

r126	r195
76	76	FmElement *element);
77	77
78		void
	78	/*void
79	79	fm_pipeline_set_beat_master (FmPipeline *pipeline,
80		FmElement *element);
	80	FmElement element);/
81	81
82	82	void

fm_server/trunk/src/fm_sync.c

r143	r195
46	46	}
47	47
48		guint sample_rate = /* fm_pipeline_get_sample_rate() */ 44100;
49		sync->ns_per_sample = (1.0 / sample_rate) * NS_PER_SEC;
	48	// guint sample_rate = /* fm_pipeline_get_sample_rate() */ 44100;
	49	// sync->ns_per_sample = (1.0 / sample_rate) * NS_PER_SEC;
50	50	sync->ns_per_beat = NS_PER_SEC / (sync->bpm / 60.0);
51	51
52	52	// g_print ("ns_per_sample %lf ns_per_beat %lf\n", sync->ns_per_sample, sync->ns_per_beat);
53	53
54		sync->beat_offset_ns += sync->played_~~samples_new * sync->ns_per_sample~~;
	54	sync->beat_offset_ns += sync->played_ns_new;
55	55
56	56	//G_BREAKPOINT();
…	…
69	69
70	70	void
71		fm_sync_master_played_~~sample~~s (FmSync *sync,
72		guint ~~sample~~s)
	71	fm_sync_master_played_ns (FmSync *sync,
	72	guint ns)
73	73	{
74		sync->played_~~samples_new = sample~~s;
	74	sync->played_ns_new = ns;
75	75	}
76	76
…	…
83	83	}
84	84
	85	void
	86	fm_sync_set (FmSync *sync,
	87	guint64 offset,
	88	guint64 timestamp)
	89	{
	90	guint64 realstamp = timestamp - offset;
	91	guint beats = realstamp / sync->ns_per_beat;
	92	sync->bar = beats / sync->beat_per_bar;
	93	sync->beat = beats - (sync->bar * sync->beat_per_bar);
	94	sync->beat_offset_ns = realstamp - (beats * sync->ns_per_beat);
	95
	96	}
85	97
86	98	gdouble
…	…
88	100	{
89	101	return (sync->ns_per_beat - sync->beat_offset_ns);
90		}
91
92
93		~~gint~~
94		~~fm_sync_samples_to_next_beat (FmSync *sync)~~
95		{
96		~~return (fm_sync_ns_to_next_beat (sync) / sync->ns_per_sample);~~
97	102	}
98	103
…	…
108	113	return next_beat;
109	114	}
	115
	116	void
	117	fm_sync_show_pos (FmSync *sync)
	118	{
	119	g_print ("bpm: %lf pos: bar %d beat %d beat_offset_ns %f\n", sync->bpm, sync->bar, sync->beat, sync->beat_offset_ns);
	120	}

fm_server/trunk/src/fm_sync.h

r143	r195
24	24	typedef struct _FmBeatSection FmBeatSection;
25	25	typedef struct _FmBeatInfo FmBeatInfo;
26		~~typedef struct _FmSync FmSync;~~
27	26
28	27
…	…
38	37	};
39	38
	39	/*
	40	struct _FmBufferRequest {
	41	gboolean cont;
	42	guint64 pos;
	43	guint req_samples;
	44	};
40	45
41		struct _FmSync {
42		FmElement *master;
	46	enum FmBufferReturn {
	47	FM_BUFFER_RETURN_OK,
	48	FM_BUFFER_RETURN_DISCONT
43	49
44		/* written from fm_element_beacome_sync_master */
45		gdouble bpm;
46		gint beat_per_bar;
47
48		/* automatically generated */
49		gdouble ns_per_sample;
50		gdouble ns_per_beat;
51
52		/* automatically updated at the beginning of each cycle */
53		gint bar;
54		gint beat;
55		gfloat beat_offset_ns;
56
57		/* can be updated with the functions below */
58		gdouble bpm_new;
59		guint played_samples_new;
60		};
	50	};*/
61	51
62	52
…	…
64	54	fm_sync_new (void);
65	55
66		/* ~~Every output element must call this after get_buffer~~ */
	56	/* The sync reference has to call this after calling fm_get_buffer() on its peer_sync_master port */
67	57	void
68	58	fm_sync_update_cycle (FmSync *sync);
…	…
70	60	/* Callable from get_buffer, takes effect from next cycle */
71	61	void
72		fm_sync_master_played_~~sample~~s (FmSync *sync,
	62	fm_sync_master_played_ns (FmSync *sync,
73	63	guint samples);
74	64
…	…
78	68	gdouble bpm);
79	69
	70	void
	71	fm_sync_set (FmSync *sync,
	72	guint64 offset,
	73	guint64 timestamp);
	74
80	75	/* Callable from get_buffer */
81	76	gdouble
…	…
83	78
84	79	gint
85		fm_sync_~~samples_to_next_beat~~ (FmSync *sync);
	80	fm_sync_next_beat_is (FmSync *sync);
86	81
87		gint
88		fm_sync_~~next_beat_i~~s (FmSync *sync);
	82	void
	83	fm_sync_show_pos (FmSync *sync);

Download in other formats: