← Back to branch summary

~ubuntu-branches/ubuntu/saucy/xmms2/saucy-proposed

« back to all changes in this revision

Viewing changes to src/clients/cli/cmd_playback.c

  • Committer: Bazaar Package Importer
  • Author(s): Benjamin Drung
  • Date: 2011-10-22 23:53:00 UTC
  • mto: (38.1.2 sid)
  • mto: This revision was merged to the branch mainline in revision 43.
  • Revision ID: james.westby@ubuntu.com-20111022235300-u50pdo3g341jvk7q
Import upstream version 0.8+dfsg

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/clients/cli/cmd_playback.c
1
 
/*  XMMS2 - X Music Multiplexer System
2
 
 *  Copyright (C) 2003-2009 XMMS2 Team
3
 
 *
4
 
 *  PLUGINS ARE NOT CONSIDERED TO BE DERIVED WORK !!!
5
 
 *
6
 
 *  This library is free software; you can redistribute it and/or
7
 
 *  modify it under the terms of the GNU Lesser General Public
8
 
 *  License as published by the Free Software Foundation; either
9
 
 *  version 2.1 of the License, or (at your option) any later version.
10
 
 *
11
 
 *  This library is distributed in the hope that it will be useful,
12
 
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
13
 
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
14
 
 *  Lesser General Public License for more details.
15
 
 */
16
 
 
17
 
#include "cmd_playback.h"
18
 
#include "common.h"
19
 
 
20
 
 
21
 
static void
22
 
do_reljump (xmmsc_connection_t *conn, gint where)
23
 
{
24
 
        xmmsc_result_t *res;
25
 
        xmmsv_t *val;
26
 
        const char *errmsg;
27
 
 
28
 
        res = xmmsc_playlist_set_next_rel (conn, where);
29
 
        xmmsc_result_wait (res);
30
 
 
31
 
        val = xmmsc_result_get_value (res);
32
 
        if (xmmsv_get_error (val, &errmsg)) {
33
 
                print_error ("Couldn't advance in playlist: %s", errmsg);
34
 
        }
35
 
        xmmsc_result_unref (res);
36
 
 
37
 
        res = xmmsc_playback_tickle (conn);
38
 
        xmmsc_result_wait (res);
39
 
 
40
 
        val = xmmsc_result_get_value (res);
41
 
        if (xmmsv_get_error (val, &errmsg)) {
42
 
                print_error ("%s", errmsg);
43
 
        }
44
 
        xmmsc_result_unref (res);
45
 
}
46
 
 
47
 
 
48
 
void
49
 
cmd_toggleplay (xmmsc_connection_t *conn, gint argc, gchar **argv)
50
 
{
51
 
        int32_t status;
52
 
        xmmsc_result_t *res;
53
 
        xmmsv_t *val;
54
 
        const char *errmsg;
55
 
 
56
 
        res = xmmsc_playback_status (conn);
57
 
        xmmsc_result_wait (res);
58
 
        val = xmmsc_result_get_value (res);
59
 
 
60
 
        if (xmmsv_get_error (val, &errmsg)) {
61
 
                print_error ("Couldn't get playback status: %s", errmsg);
62
 
        }
63
 
 
64
 
        if (!xmmsv_get_int (val, &status)) {
65
 
                print_error ("Broken resultset");
66
 
        }
67
 
 
68
 
        if (status == XMMS_PLAYBACK_STATUS_PLAY) {
69
 
                cmd_pause (conn, argc, argv);
70
 
        } else {
71
 
                cmd_play (conn, argc, argv);
72
 
        }
73
 
 
74
 
        xmmsc_result_unref (res);
75
 
}
76
 
 
77
 
 
78
 
void
79
 
cmd_play (xmmsc_connection_t *conn, gint argc, gchar **argv)
80
 
{
81
 
        xmmsc_result_t *res;
82
 
        xmmsv_t *val;
83
 
        const char *errmsg;
84
 
 
85
 
        res = xmmsc_playback_start (conn);
86
 
        xmmsc_result_wait (res);
87
 
 
88
 
        val = xmmsc_result_get_value (res);
89
 
        if (xmmsv_get_error (val, &errmsg)) {
90
 
                print_error ("Couldn't start playback: %s", errmsg);
91
 
        }
92
 
        xmmsc_result_unref (res);
93
 
}
94
 
 
95
 
void
96
 
cmd_stop (xmmsc_connection_t *conn, gint argc, gchar **argv)
97
 
{
98
 
        xmmsc_result_t *res;
99
 
        xmmsv_t *val;
100
 
        const char *errmsg;
101
 
 
102
 
        res = xmmsc_playback_stop (conn);
103
 
        xmmsc_result_wait (res);
104
 
 
105
 
        val = xmmsc_result_get_value (res);
106
 
        if (xmmsv_get_error (val, &errmsg)) {
107
 
                print_error ("Couldn't stop playback: %s", errmsg);
108
 
        }
109
 
        xmmsc_result_unref (res);
110
 
}
111
 
 
112
 
 
113
 
void
114
 
cmd_pause (xmmsc_connection_t *conn, gint argc, gchar **argv)
115
 
{
116
 
        xmmsc_result_t *res;
117
 
        xmmsv_t *val;
118
 
        const char *errmsg;
119
 
 
120
 
        res = xmmsc_playback_pause (conn);
121
 
        xmmsc_result_wait (res);
122
 
 
123
 
        val = xmmsc_result_get_value (res);
124
 
        if (xmmsv_get_error (val, &errmsg)) {
125
 
                print_error ("Couldn't pause playback: %s", errmsg);
126
 
        }
127
 
        xmmsc_result_unref (res);
128
 
}
129
 
 
130
 
 
131
 
void
132
 
cmd_next (xmmsc_connection_t *conn, gint argc, gchar **argv)
133
 
{
134
 
        do_reljump (conn, 1);
135
 
}
136
 
 
137
 
 
138
 
void
139
 
cmd_prev (xmmsc_connection_t *conn, gint argc, gchar **argv)
140
 
{
141
 
        do_reljump (conn, -1);
142
 
}
143
 
 
144
 
 
145
 
void
146
 
cmd_seek (xmmsc_connection_t *conn, gint argc, gchar **argv)
147
 
{
148
 
        xmmsc_result_t *res;
149
 
        xmmsv_t *val;
150
 
        const char *errmsg;
151
 
        long arg;
152
 
        gchar *endptr = NULL;
153
 
 
154
 
        if (argc < 3) {
155
 
                print_error ("You need to specify a number of seconds. Usage:\n"
156
 
                             "xmms2 seek n  - seek to absolute position in song\n"
157
 
                             "xmms2 seek +n - seek n seconds forward in song\n"
158
 
                             "xmms2 seek -n - seek n seconds backwards");
159
 
        }
160
 
 
161
 
        /* parse the movement argument */
162
 
        arg = strtol (argv[2], &endptr, 10) * 1000;
163
 
 
164
 
        if (endptr == argv[2]) {
165
 
                print_error ("invalid argument");
166
 
        }
167
 
 
168
 
        if (argv[2][0] == '+' || argv[2][0] == '-') {
169
 
                /* do we need to seek at all? */
170
 
                if (!arg) {
171
 
                        return;
172
 
                }
173
 
                res = xmmsc_playback_seek_ms (conn, arg, XMMS_PLAYBACK_SEEK_CUR);
174
 
        } else {
175
 
                res = xmmsc_playback_seek_ms (conn, arg, XMMS_PLAYBACK_SEEK_SET);
176
 
        }
177
 
 
178
 
        xmmsc_result_wait (res);
179
 
        val = xmmsc_result_get_value (res);
180
 
        if (xmmsv_get_error (val, &errmsg)) {
181
 
                print_error ("Couldn't seek to %d arg: %s", arg, errmsg);
182
 
        }
183
 
        xmmsc_result_unref (res);
184
 
}
185
 
 
186
 
 
187
 
void
188
 
cmd_jump (xmmsc_connection_t *conn, gint argc, gchar **argv)
189
 
{
190
 
        xmmsc_result_t *res;
191
 
        xmmsv_t *val;
192
 
        const char *errmsg;
193
 
 
194
 
        if (argc < 3) {
195
 
                print_error ("You'll need to specify a position to jump to. Usage:\n"
196
 
                             "xmms2 jump n  - jump to absolute position n\n"
197
 
                             "xmms2 jump +n - advance n positions\n"
198
 
                             "xmms2 jump -n - jump n positions backwards\n");
199
 
        }
200
 
 
201
 
        if (argv[2][0] == '-' || argv[2][0] == '+') {
202
 
                res = xmmsc_playlist_set_next_rel (conn, strtol (argv[2], NULL, 10));
203
 
        } else {
204
 
                res = xmmsc_playlist_set_next (conn, strtol (argv[2], NULL, 10));
205
 
        }
206
 
        xmmsc_result_wait (res);
207
 
 
208
 
        val = xmmsc_result_get_value (res);
209
 
        if (xmmsv_get_error (val, &errmsg)) {
210
 
                print_error ("Couldn't jump to that song: %s", errmsg);
211
 
        }
212
 
        xmmsc_result_unref (res);
213
 
 
214
 
        res = xmmsc_playback_tickle (conn);
215
 
        xmmsc_result_wait (res);
216
 
 
217
 
        val = xmmsc_result_get_value (res);
218
 
        if (xmmsv_get_error (val, &errmsg)) {
219
 
                print_error ("Couldn't go to next song: %s", errmsg);
220
 
        }
221
 
        xmmsc_result_unref (res);
222
 
}