ViewVC Help

View File | Revision Log | Show Annotations | Download File | View Changeset | Root Listing

root/truck/DashInterface/Display.cpp

Comparing:
Audacious/Audacious.cpp (file contents), Revision 22 by douglas, 2008-02-08T06:19:12-08:00 vs.
DashInterface/Display.cpp (file contents), Revision 31 by douglas, 2008-02-28T22:06:06-08:00

#	Line 1 | Line 1
1	<	// Beep Remote
1	>	// Display (Crystalfontz CFA-635 USB LCD)
2		//
3		// Douglas Thrift
4		//
5		// $Id$
6
7	<	#include <audacious/beepctrl.h>
7	>	#include <foreach.hpp>
8
9	<	#include "Audacious.hpp"
9	>	#include <iomanip>
10	>	#include <iostream>
11
12	<	void Audacious::Playlist(char **list, int size, bool enqueue)
13	<	{
13	<	::xmms_remote_playlist(session, list, size, enqueue);
14	<	}
15	<
16	<	int Audacious::GetVersion() const
17	<	{
18	<	return ::xmms_remote_get_version(session);
19	<	}
20	<
21	<	void Audacious::PlaylistAdd(::GList *list)
22	<	{
23	<	::xmms_remote_playlist_add(session, list);
24	<	}
25	<
26	<	void Audacious::PlaylistDelete(int position)
27	<	{
28	<	::xmms_remote_playlist_delete(session, position);
29	<	}
30	<
31	<	void Audacious::Play()
32	<	{
33	<	::xmms_remote_play(session);
34	<	}
35	<
36	<	void Audacious::Pause()
37	<	{
38	<	::xmms_remote_pause(session);
39	<	}
40	<
41	<	void Audacious::Stop()
42	<	{
43	<	::xmms_remote_stop(session);
44	<	}
45	<
46	<	bool Audacious::IsPlaying() const
47	<	{
48	<	return ::xmms_remote_is_playing(session);
49	<	}
50	<
51	<	bool Audacious::IsPaused() const
52	<	{
53	<	return ::xmms_remote_is_paused(session);
54	<	}
55	<
56	<	int Audacious::GetPlaylistPosition() const
57	<	{
58	<	return ::xmms_remote_get_playlist_pos(session);
59	<	}
60	<
61	<	void Audacious::SetPlaylistPosition(int position)
62	<	{
63	<	::xmms_remote_set_playlist_pos(session, position);
64	<	}
65	<
66	<	int Audacious::GetPlaylistLength() const
67	<	{
68	<	return ::xmms_remote_get_playlist_length(session);
69	<	}
70	<
71	<	void Audacious::PlaylistClear()
72	<	{
73	<	return ::xmms_remote_playlist_clear(session);
74	<	}
75	<
76	<	int Audacious::GetOutputTime() const
77	<	{
78	<	return ::xmms_remote_get_output_time(session);
79	<	}
80	<
81	<	void Audacious::JumpToTime(int position)
82	<	{
83	<	::xmms_remote_jump_to_time(session, position);
84	<	}
85	<
86	<	void Audacious::GetVolume(int& left, int& right) const
87	<	{
88	<	::xmms_remote_get_volume(session, &left, &right);
89	<	}
12	>	#include <fcntl.h>
13	>	#include <termios.h>
14
15	<	int Audacious::GetMainVolume() const
92	<	{
93	<	return ::xmms_remote_get_main_volume(session);
94	<	}
15	>	#include "Display.hpp"
16
17	<	int Audacious::GetBalance() const
97	<	{
98	<	return ::xmms_remote_get_balance(session);
99	<	}
17	>	extern bool debug;
18
19	<	void Audacious::SetVolume(int left, int right)
19	>	static uint16_t GetCRC(uint8_t *buffer, size_t length)
20		{
21	<	::xmms_remote_set_volume(session, left, right);
22	<	}
21	>	static const uint16_t table[256] = {
22	>	0x00000, 0x01189, 0x02312, 0x0329b, 0x04624, 0x057ad, 0x06536, 0x074bf,
23	>	0x08C48, 0x09DC1, 0x0AF5A, 0x0BED3, 0x0CA6C, 0x0DBE5, 0x0E97E, 0x0F8F7,
24	>	0x01081, 0x00108, 0x03393, 0x0221a, 0x056a5, 0x0472c, 0x075b7, 0x0643e,
25	>	0x09CC9, 0x08D40, 0x0BFDB, 0x0AE52, 0x0DAED, 0x0CB64, 0x0F9FF, 0x0E876,
26	>	0x02102, 0x0308b, 0x00210, 0x01399, 0x06726, 0x076af, 0x04434, 0x055bd,
27	>	0x0AD4A, 0x0BCC3, 0x08E58, 0x09FD1, 0x0EB6E, 0x0FAE7, 0x0C87C, 0x0D9F5,
28	>	0x03183, 0x0200a, 0x01291, 0x00318, 0x077a7, 0x0662e, 0x054b5, 0x0453c,
29	>	0x0BDCB, 0x0AC42, 0x09ED9, 0x08F50, 0x0FBEF, 0x0EA66, 0x0D8FD, 0x0C974,
30	>	0x04204, 0x0538d, 0x06116, 0x0709f, 0x00420, 0x015a9, 0x02732, 0x036bb,
31	>	0x0ce4c, 0x0dfc5, 0x0ed5e, 0x0fcd7, 0x08868, 0x099e1, 0x0ab7a, 0x0baf3,
32	>	0x05285, 0x0430c, 0x07197, 0x0601e, 0x014a1, 0x00528, 0x037b3, 0x0263a,
33	>	0x0decd, 0x0cf44, 0x0fddf, 0x0ec56, 0x098e9, 0x08960, 0x0bbfb, 0x0aa72,
34	>	0x06306, 0x0728f, 0x04014, 0x0519d, 0x02522, 0x034ab, 0x00630, 0x017b9,
35	>	0x0EF4E, 0x0FEC7, 0x0CC5C, 0x0DDD5, 0x0A96A, 0x0B8E3, 0x08A78, 0x09BF1,
36	>	0x07387, 0x0620e, 0x05095, 0x0411c, 0x035a3, 0x0242a, 0x016b1, 0x00738,
37	>	0x0FFCF, 0x0EE46, 0x0DCDD, 0x0CD54, 0x0B9EB, 0x0A862, 0x09AF9, 0x08B70,
38	>	0x08408, 0x09581, 0x0a71a, 0x0b693, 0x0c22c, 0x0d3a5, 0x0e13e, 0x0f0b7,
39	>	0x00840, 0x019c9, 0x02b52, 0x03adb, 0x04e64, 0x05fed, 0x06d76, 0x07cff,
40	>	0x09489, 0x08500, 0x0b79b, 0x0a612, 0x0d2ad, 0x0c324, 0x0f1bf, 0x0e036,
41	>	0x018c1, 0x00948, 0x03bd3, 0x02a5a, 0x05ee5, 0x04f6c, 0x07df7, 0x06c7e,
42	>	0x0a50a, 0x0b483, 0x08618, 0x09791, 0x0e32e, 0x0f2a7, 0x0c03c, 0x0d1b5,
43	>	0x02942, 0x038cb, 0x00a50, 0x01bd9, 0x06f66, 0x07eef, 0x04c74, 0x05dfd,
44	>	0x0b58b, 0x0a402, 0x09699, 0x08710, 0x0f3af, 0x0e226, 0x0d0bd, 0x0c134,
45	>	0x039C3, 0x0284A, 0x01AD1, 0x00B58, 0x07FE7, 0x06E6E, 0x05CF5, 0x04D7C,
46	>	0x0c60c, 0x0d785, 0x0e51e, 0x0f497, 0x08028, 0x091a1, 0x0a33a, 0x0b2b3,
47	>	0x04a44, 0x05bcd, 0x06956, 0x078df, 0x00c60, 0x01de9, 0x02f72, 0x03efb,
48	>	0x0d68d, 0x0c704, 0x0f59f, 0x0e416, 0x090a9, 0x08120, 0x0b3bb, 0x0a232,
49	>	0x05AC5, 0x04B4C, 0x079D7, 0x0685E, 0x01CE1, 0x00D68, 0x03FF3, 0x02E7A,
50	>	0x0e70e, 0x0f687, 0x0c41c, 0x0d595, 0x0a12a, 0x0b0a3, 0x08238, 0x093b1,
51	>	0x06b46, 0x07acf, 0x04854, 0x059dd, 0x02d62, 0x03ceb, 0x00e70, 0x01ff9,
52	>	0x0f78f, 0x0e606, 0x0d49d, 0x0c514, 0x0b1ab, 0x0a022, 0x092b9, 0x08330,
53	>	0x07BC7, 0x06A4E, 0x058D5, 0x0495C, 0x03DE3, 0x02C6A, 0x01EF1, 0x00F78,
54	>	};
55	>	register uint16_t crc(0xffff);
56
57	<	void Audacious::SetMainVolume(int volume)
58	<	{
108	<	::xmms_remote_set_main_volume(session, volume);
109	<	}
57	>	while (length--)
58	>	crc = (crc >> 8) ^ table[(crc ^ *buffer++) & 0xff];
59
60	<	void Audacious::SetBalance(int balance)
112	<	{
113	<	::xmms_remote_set_balance(session, balance);
60	>	return ~crc;
61		}
62
63	<	std::string Audacious::GetSkin() const
63	>	Display::Packet::Packet(Display::Packet::Command command, uint8_t length, const uint8_t *data) : command(command), length(length)
64		{
65	<	return ::xmms_remote_get_skin(session);
66	<	}
65	>	if (length > sizeof (this->data))
66	>	throw;
67
68	<	void Audacious::SetSkin(const std::string &skin)
122	<	{
123	<	::xmms_remote_set_skin(session, const_cast<char*>(skin.c_str()));
124	<	}
68	>	::memcpy(this->data, data, length);
69
70	<	std::string Audacious::GetPlaylistFile(int position) const
127	<	{
128	<	return ::xmms_remote_get_playlist_file(session, position);
70	>	crc = GetCRC(reinterpret_cast<uint8_t *>(this), length + 2);
71		}
72
73	<	std::string Audacious::GetPlaylistTitle(int position) const
73	>	std::ostream &operator<<(std::ostream &output, const Display::Packet &packet)
74		{
75	<	return ::xmms_remote_get_playlist_title(session, position);
75	>	return output << _B("0x") << std::hex << std::setw(2) << std::setfill('0') << unsigned(packet.command) << std::dec << std::setw(0) << std::setfill(' ') << _B(" [") << packet.GetData() << ']';
76		}
77
78	<	int Audacious::GetPlaylistTime(int position) const
78	>	void operator<<(int fd, const Display::Packet &packet)
79		{
80	<	return ::xmms_remote_get_playlist_time(session, position);
81	<	}
80	>	if (packet.length != sizeof (packet.data))
81	>	::memcpy(const_cast<uint8_t *>(packet.data) + packet.length, &packet.crc, 2);
82
83	<	void Audacious::GetInfo(int &rate, int &frequency, int &channels) const
84	<	{
143	<	::xmms_remote_get_info(session, &rate, &frequency, &channels);
144	<	}
83	>	if (debug)
84	>	std::cerr << _B("<< ") << packet << std::endl;
85
86	<	void Audacious::MainWindowToggle(bool show)
147	<	{
148	<	::xmms_remote_main_win_toggle(session, show);
86	>	Posix::Write(fd, &packet, packet.length + 4);
87		}
88
89	<	void Audacious::PlaylistWindowToggle(bool show)
89	>	void operator>>(int fd, Display::Packet &packet)
90		{
91	<	::xmms_remote_pl_win_toggle(session, show);
92	<	}
91	>	Posix::Read(fd, &packet, 2);
92	>	Posix::Read(fd, packet.data, packet.length);
93	>	Posix::Read(fd, &packet.crc, 2);
94
95	<	void Audacious::EqualizerWindowToggle(bool show)
96	<	{
158	<	::xmms_remote_eq_win_toggle(session, show);
95	>	if (debug)
96	>	std::cerr << _B(">> ") << packet << std::endl;
97		}
98
99	<	bool Audacious::IsMainWindow() const
99	>	void Communicate(Display *display)
100		{
163	–	return ::xmms_remote_is_main_win(session);
101		}
102
103	<	bool Audacious::IsPlaylistWindow() const
103	>	Display::Display(const std::string &device) : ucom(Posix::Open(device, O_RDWR | O_NOCTTY)), thread(reinterpret_cast<void *(*)(void *)>(::Communicate))
104		{
105	<	return ::xmms_remote_is_pl_win(session);
169	<	}
105	>	::termios state;
106
107	<	bool Audacious::IsEqualizerWindow() const
108	<	{
109	<	return ::xmms_remote_is_eq_win(session);
174	<	}
107	>	Posix::CheckError(::tcgetattr(ucom, &state));
108	>	Posix::CheckError(::cfsetospeed(&state, B115200));
109	>	Posix::CheckError(::cfsetispeed(&state, B115200));
110
111	<	void Audacious::ShowPreferencesBox()
112	<	{
113	<	::xmms_remote_show_prefs_box(session);
114	<	}
111	>	state.c_iflag &= ~(IGNBRK | BRKINT | PARMRK | INPCK | ISTRIP | INLCR | IGNCR | ICRNL | IXON | IXOFF);
112	>	state.c_iflag |= IGNPAR;
113	>	state.c_oflag &= ~(OPOST | ONLCR | ONOCR | ONLRET);
114	>	state.c_cflag &= ~(CSIZE | PARENB | PARODD | HUPCL | CRTSCTS);
115	>	state.c_cflag |= CREAD | CS8 | CSTOPB | CLOCAL;
116	>	state.c_lflag &= ~(ISIG | ICANON | IEXTEN | ECHO);
117	>	state.c_lflag |= NOFLSH;
118
119	<	void Audacious::ToggleAlwaysOnTop(bool always)
182	<	{
183	<	::xmms_remote_toggle_aot(session, always);
119	>	Posix::CheckError(::tcsetattr(ucom, TCSANOW, &state));
120		}
121
122	<	void Audacious::Eject()
122	>	Display::Packet Display::Communicate_(Display::Packet::Command command, uint8_t length, const uint8_t *data)
123		{
124	<	::xmms_remote_eject(session);
189	<	}
124	>	Packet packet(command, length, data), response;
125
126	<	void Audacious::PlaylistPrevious()
192	<	{
193	<	::xmms_remote_playlist_prev(session);
194	<	}
126	>	ucom << packet;
127
128	<	void Audacious::PlaylistNext()
129	<	{
130	<	::xmms_remote_playlist_next(session);
199	<	}
128	>	_forever
129	>	{
130	>	ucom >> response;
131
132	<	void Audacious::PlaylistAddUrl(const std::string &url)
133	<	{
203	<	::xmms_remote_playlist_add_url_string(session, const_cast<char*>(url.c_str()));
204	<	}
132	>	if (packet.command | Packet::Response == response.command)
133	>	return response;
134
135	<	bool Audacious::IsRunning() const
136	<	{
137	<	return ::xmms_remote_is_running(session);
138	<	}
135	>	switch (response.command)
136	>	{
137	>	case Packet::KeyActivity:
138	>	keyActivity.push(response);
139
140	<	void Audacious::ToggleRepeat()
141	<	{
142	<	::xmms_remote_toggle_repeat(session);
143	<	}
144	<
145	<	void Audacious::ToggleShuffle()
217	<	{
218	<	::xmms_remote_toggle_shuffle(session);
219	<	}
220	<
221	<	bool Audacious::IsRepeat() const
222	<	{
223	<	return ::xmms_remote_is_repeat(session);
224	<	}
225	<
226	<	bool Audacious::IsShuffle() const
227	<	{
228	<	return ::xmms_remote_is_shuffle(session);
229	<	}
230	<
231	<	void Audacious::GetEqualizer(float& preamp, float bands[10]) const
232	<	{
233	<	float* bands_;
234	<
235	<	::xmms_remote_get_eq(session, &preamp, &bands_);
236	<
237	<	_forall (uint8_t, index, 0, 10)
238	<	bands[index] = bands[index];
239	<
240	<	::g_free(bands_);
241	<	}
242	<
243	<	float Audacious::GetEqualizerPreamp() const
244	<	{
245	<	return ::xmms_remote_get_eq_preamp(session);
246	<	}
247	<
248	<	float Audacious::GetEqualizerBand(int band) const
249	<	{
250	<	return ::xmms_remote_get_eq_band(session, band);
251	<	}
252	<
253	<	void Audacious::SetEqualizer(float preamp, float bands[10])
254	<	{
255	<	::xmms_remote_set_eq(session, preamp, bands);
256	<	}
257	<
258	<	void Audacious::SetEqualizerPreamp(float preamp)
259	<	{
260	<	::xmms_remote_set_eq_preamp(session, preamp);
261	<	}
262	<
263	<	void Audacious::SetEqualizerBand(int band, float value)
264	<	{
265	<	::xmms_remote_set_eq_band(session, band, value);
266	<	}
267	<
268	<	// XMMS 1.2.1
269	<	void Audacious::Quit()
270	<	{
271	<	::xmms_remote_quit(session);
272	<	}
273	<
274	<	// XMMS 1.2.6
275	<	void Audacious::PlayPause()
276	<	{
277	<	::xmms_remote_play_pause(session);
278	<	}
279	<
280	<	void Audacious::PlaylistInsertUrl(const std::string &url, int position)
281	<	{
282	<	::xmms_remote_playlist_ins_url_string(session, const_cast<char*>(url.c_str()), position);
283	<	}
284	<
285	<	// XMMS 1.2.11
286	<	void Audacious::PlayqueueAdd(int position)
287	<	{
288	<	::xmms_remote_playqueue_add(session, position);
289	<	}
290	<
291	<	void Audacious::PlayqueueRemove(int position)
292	<	{
293	<	::xmms_remote_playqueue_remove(session, position);
294	<	}
295	<
296	<	int Audacious::GetPlayqueueLength() const
297	<	{
298	<	return ::xmms_remote_get_playqueue_length(session);
299	<	}
300	<
301	<	void Audacious::ToggleAdvance()
302	<	{
303	<	::xmms_remote_toggle_advance(session);
304	<	}
305	<
306	<	bool Audacious::IsAdvance() const
307	<	{
308	<	return ::xmms_remote_is_advance(session);
309	<	}
310	<
311	<	// BMP 0.9.7
312	<	void Audacious::Activate()
313	<	{
314	<	::xmms_remote_activate(session);
315	<	}
316	<
317	<	// Audacious 1.1
318	<	void Audacious::ShowJumpToFileBox()
319	<	{
320	<	::xmms_remote_show_jtf_box(session);
321	<	}
322	<
323	<	void Audacious::PlayqueueClear()
324	<	{
325	<	::xmms_remote_playqueue_clear(session);
326	<	}
327	<
328	<	bool Audacious::PlayqueueIsQueued(int position) const
329	<	{
330	<	return ::xmms_remote_playqueue_is_queued(session, position);
331	<	}
332	<
333	<	int Audacious::GetPlayqueuePosition(int position) const
334	<	{
335	<	return ::xmms_remote_get_playqueue_position(session, position);
336	<	}
337	<
338	<	int Audacious::GetPlayqueueQueuePosition(int position) const
339	<	{
340	<	return ::xmms_remote_get_playqueue_queue_position(session, position);
341	<	}
342	<
343	<	// Audacious 1.2
344	<	void Audacious::SetSessionUri(const std::string &uri)
345	<	{
346	<	::audacious_set_session_uri(const_cast<char *>(uri.c_str()));
347	<	}
348	<
349	<	std::string Audacious::GetSessionUri() const
350	<	{
351	<	return ::audacious_get_session_uri(session);
140	>	break;
141	>	case Packet::FanSpeedReport:
142	>	case Packet::TemperatureSensorReport:
143	>	break;
144	>	}
145	>	}
146		}
147
148	<	void Audacious::SetSessionType(Type type)
148	>	bool Display::Ping(const std::string &data)
149		{
150	<	::audacious_set_session_type(type);
150	>	return data == Communicate<const std::string &>(Packet::PingCommand, data).GetData();
151		}
152
153	<	// Audacious 1.3
360	<	void Audacious::PlaylistEnqueueToTemp(const std::string &string)
153	>	std::string Display::Version()
154		{
155	<	::xmms_remote_playlist_enqueue_to_temp(session, const_cast<char *>(string.c_str()));
155	>	return Communicate(Packet::GetHardwareAndFirmwareVersion).GetData();
156		}
157
158	<	std::string Audacious::GetTupleFieldData(const std::string &field, int position)
158	>	void Display::Set(uint8_t column, uint8_t row, const std::string &data)
159		{
160	<	return ::audacious_get_tuple_field_data(session, const_cast<char *>(field.c_str()), position);
160	>	Communicate(Packet::SendDataToLCD, column, row, data);
161		}

Diff Legend

–	Removed lines
+	Added lines
<	Changed lines
>	Changed lines