← Back to branch summary

~ubuntu-branches/debian/jessie/betaradio/jessie

« back to all changes in this revision

Viewing changes to src/gst_player.c

  • Committer: Package Import Robot
  • Author(s): Shih-Yuan Lee (FourDollars)
  • Date: 2012-01-14 20:58:32 UTC
  • mfrom: (1.1.2)
  • Revision ID: package-import@ubuntu.com-20120114205832-j58rskmjowwgcv37
Tags: 1.4-1
* New upstream release.
* debian/patches/00_dont_install_header: Don't install header file into the
  system.

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/gst_player.c
1
 
/* gst_player.c generated by valac 0.12.0, the Vala compiler
 
1
/* gst_player.c generated by valac 0.14.0, the Vala compiler
2
2
 * generated from gst_player.vala, do not modify */
3
3
 
4
4
/* -*- coding: utf-8; indent-tabs-mode: nil; tab-width: 4; c-basic-offset: 4; -*- */
70
70
 
71
71
static GstPlayer* gst_player_construct (GType object_type, const gchar* name) {
72
72
        GstPlayer * self = NULL;
73
 
        GstElement* _tmp0_ = NULL;
74
 
        GstBus* _tmp1_ = NULL;
75
 
        GstBus* _tmp2_;
 
73
        const gchar* _tmp0_;
 
74
        GstElement* _tmp1_ = NULL;
 
75
        GstElement* _tmp2_;
 
76
        GstBus* _tmp3_ = NULL;
 
77
        GstBus* _tmp4_;
76
78
        g_return_val_if_fail (name != NULL, NULL);
77
79
        self = (GstPlayer*) g_object_new (object_type, NULL);
78
 
        _tmp0_ = gst_element_factory_make ("playbin2", name);
 
80
        _tmp0_ = name;
 
81
        _tmp1_ = gst_element_factory_make ("playbin2", _tmp0_);
79
82
        _gst_object_unref0 (self->priv->player);
80
 
        self->priv->player = _tmp0_;
81
 
        _tmp1_ = gst_element_get_bus (self->priv->player);
82
 
        _tmp2_ = _tmp1_;
83
 
        gst_bus_add_watch_full (_tmp2_, G_PRIORITY_DEFAULT, _gst_player_bus_callback_gst_bus_func, g_object_ref (self), g_object_unref);
84
 
        _gst_object_unref0 (_tmp2_);
 
83
        self->priv->player = _tmp1_;
 
84
        _tmp2_ = self->priv->player;
 
85
        _tmp3_ = gst_element_get_bus (_tmp2_);
 
86
        _tmp4_ = _tmp3_;
 
87
        gst_bus_add_watch_full (_tmp4_, G_PRIORITY_DEFAULT, _gst_player_bus_callback_gst_bus_func, g_object_ref (self), g_object_unref);
 
88
        _gst_object_unref0 (_tmp4_);
85
89
        return self;
86
90
}
87
91
 
98
102
 
99
103
GstPlayer* gst_player_get_instance (void) {
100
104
        GstPlayer* result = NULL;
101
 
        GstPlayer* _tmp1_;
102
 
        if (gst_player_instance == NULL) {
103
 
                GstPlayer* _tmp0_ = NULL;
104
 
                _tmp0_ = gst_player_new ("BetaRadio");
 
105
        GstPlayer* _tmp0_;
 
106
        GstPlayer* _tmp2_;
 
107
        GstPlayer* _tmp3_;
 
108
        _tmp0_ = gst_player_instance;
 
109
        if (_tmp0_ == NULL) {
 
110
                GstPlayer* _tmp1_;
 
111
                _tmp1_ = gst_player_new ("BetaRadio");
105
112
                _g_object_unref0 (gst_player_instance);
106
 
                gst_player_instance = _tmp0_;
 
113
                gst_player_instance = _tmp1_;
107
114
        }
108
 
        _tmp1_ = _g_object_ref0 (gst_player_instance);
109
 
        result = _tmp1_;
 
115
        _tmp2_ = gst_player_instance;
 
116
        _tmp3_ = _g_object_ref0 (_tmp2_);
 
117
        result = _tmp3_;
110
118
        return result;
111
119
}
112
120
 
119
127
void gst_player_play (GstPlayer* self, const gchar* url) {
120
128
        GstState state = 0;
121
129
        GstState pending = 0;
 
130
        GstState _tmp8_;
 
131
        GstElement* _tmp10_;
 
132
        const gchar* _tmp11_;
 
133
        GstElement* _tmp20_;
122
134
        g_return_if_fail (self != NULL);
123
135
        g_return_if_fail (url != NULL);
124
136
        while (TRUE) {
125
 
                GstState _tmp0_;
126
 
                GstState _tmp1_;
127
 
                GstStateChangeReturn _tmp2_;
128
 
                const gchar* _tmp3_ = NULL;
129
 
                const gchar* _tmp4_ = NULL;
130
 
                _tmp2_ = gst_element_get_state (self->priv->player, &_tmp0_, &_tmp1_, (GstClockTime) 2000);
131
 
                state = _tmp0_;
132
 
                pending = _tmp1_;
133
 
                if (!(_tmp2_ != GST_STATE_CHANGE_SUCCESS)) {
134
 
                        break;
135
 
                }
136
 
                _tmp3_ = gst_element_state_get_name (state);
137
 
                _tmp4_ = gst_element_state_get_name (pending);
138
 
                g_message ("gst_player.vala:48: state: %s, pending: %s", _tmp3_, _tmp4_);
139
 
        }
140
 
        if (state != GST_STATE_READY) {
141
 
                gst_element_set_state (self->priv->player, GST_STATE_READY);
142
 
        }
143
 
        _dynamic_set_uri0 (self->priv->player, url);
144
 
        while (TRUE) {
145
 
                GstState _tmp5_;
 
137
                GstElement* _tmp0_;
 
138
                GstState _tmp1_ = 0;
 
139
                GstState _tmp2_ = 0;
 
140
                GstStateChangeReturn _tmp3_ = 0;
 
141
                GstState _tmp4_;
 
142
                const gchar* _tmp5_ = NULL;
146
143
                GstState _tmp6_;
147
 
                GstStateChangeReturn _tmp7_;
148
 
                const gchar* _tmp8_ = NULL;
149
 
                const gchar* _tmp9_ = NULL;
150
 
                _tmp7_ = gst_element_get_state (self->priv->player, &_tmp5_, &_tmp6_, (GstClockTime) 2000);
151
 
                state = _tmp5_;
152
 
                pending = _tmp6_;
153
 
                if (!(_tmp7_ != GST_STATE_CHANGE_SUCCESS)) {
154
 
                        break;
155
 
                }
156
 
                _tmp8_ = gst_element_state_get_name (state);
157
 
                _tmp9_ = gst_element_state_get_name (pending);
158
 
                g_message ("gst_player.vala:58: state: %s, pending: %s", _tmp8_, _tmp9_);
159
 
        }
160
 
        gst_element_set_state (self->priv->player, GST_STATE_PLAYING);
 
144
                const gchar* _tmp7_ = NULL;
 
145
                _tmp0_ = self->priv->player;
 
146
                _tmp3_ = gst_element_get_state (_tmp0_, &_tmp1_, &_tmp2_, (GstClockTime) 2000);
 
147
                state = _tmp1_;
 
148
                pending = _tmp2_;
 
149
                if (!(_tmp3_ != GST_STATE_CHANGE_SUCCESS)) {
 
150
                        break;
 
151
                }
 
152
                _tmp4_ = state;
 
153
                _tmp5_ = gst_element_state_get_name (_tmp4_);
 
154
                _tmp6_ = pending;
 
155
                _tmp7_ = gst_element_state_get_name (_tmp6_);
 
156
                g_message ("gst_player.vala:48: state: %s, pending: %s", _tmp5_, _tmp7_);
 
157
        }
 
158
        _tmp8_ = state;
 
159
        if (_tmp8_ != GST_STATE_READY) {
 
160
                GstElement* _tmp9_;
 
161
                _tmp9_ = self->priv->player;
 
162
                gst_element_set_state (_tmp9_, GST_STATE_READY);
 
163
        }
 
164
        _tmp10_ = self->priv->player;
 
165
        _tmp11_ = url;
 
166
        _dynamic_set_uri0 (_tmp10_, _tmp11_);
 
167
        while (TRUE) {
 
168
                GstElement* _tmp12_;
 
169
                GstState _tmp13_ = 0;
 
170
                GstState _tmp14_ = 0;
 
171
                GstStateChangeReturn _tmp15_ = 0;
 
172
                GstState _tmp16_;
 
173
                const gchar* _tmp17_ = NULL;
 
174
                GstState _tmp18_;
 
175
                const gchar* _tmp19_ = NULL;
 
176
                _tmp12_ = self->priv->player;
 
177
                _tmp15_ = gst_element_get_state (_tmp12_, &_tmp13_, &_tmp14_, (GstClockTime) 2000);
 
178
                state = _tmp13_;
 
179
                pending = _tmp14_;
 
180
                if (!(_tmp15_ != GST_STATE_CHANGE_SUCCESS)) {
 
181
                        break;
 
182
                }
 
183
                _tmp16_ = state;
 
184
                _tmp17_ = gst_element_state_get_name (_tmp16_);
 
185
                _tmp18_ = pending;
 
186
                _tmp19_ = gst_element_state_get_name (_tmp18_);
 
187
                g_message ("gst_player.vala:58: state: %s, pending: %s", _tmp17_, _tmp19_);
 
188
        }
 
189
        _tmp20_ = self->priv->player;
 
190
        gst_element_set_state (_tmp20_, GST_STATE_PLAYING);
161
191
}
162
192
 
163
193
 
164
194
void gst_player_stop (GstPlayer* self) {
165
195
        GstState state = 0;
166
196
        GstState pending = 0;
 
197
        GstState _tmp8_;
167
198
        g_return_if_fail (self != NULL);
168
199
        while (TRUE) {
169
 
                GstState _tmp0_;
170
 
                GstState _tmp1_;
171
 
                GstStateChangeReturn _tmp2_;
172
 
                const gchar* _tmp3_ = NULL;
173
 
                const gchar* _tmp4_ = NULL;
174
 
                _tmp2_ = gst_element_get_state (self->priv->player, &_tmp0_, &_tmp1_, (GstClockTime) 2000);
175
 
                state = _tmp0_;
176
 
                pending = _tmp1_;
177
 
                if (!(_tmp2_ != GST_STATE_CHANGE_SUCCESS)) {
 
200
                GstElement* _tmp0_;
 
201
                GstState _tmp1_ = 0;
 
202
                GstState _tmp2_ = 0;
 
203
                GstStateChangeReturn _tmp3_ = 0;
 
204
                GstState _tmp4_;
 
205
                const gchar* _tmp5_ = NULL;
 
206
                GstState _tmp6_;
 
207
                const gchar* _tmp7_ = NULL;
 
208
                _tmp0_ = self->priv->player;
 
209
                _tmp3_ = gst_element_get_state (_tmp0_, &_tmp1_, &_tmp2_, (GstClockTime) 2000);
 
210
                state = _tmp1_;
 
211
                pending = _tmp2_;
 
212
                if (!(_tmp3_ != GST_STATE_CHANGE_SUCCESS)) {
178
213
                        break;
179
214
                }
180
 
                _tmp3_ = gst_element_state_get_name (state);
181
 
                _tmp4_ = gst_element_state_get_name (pending);
182
 
                g_message ("gst_player.vala:69: state: %s, pending: %s", _tmp3_, _tmp4_);
 
215
                _tmp4_ = state;
 
216
                _tmp5_ = gst_element_state_get_name (_tmp4_);
 
217
                _tmp6_ = pending;
 
218
                _tmp7_ = gst_element_state_get_name (_tmp6_);
 
219
                g_message ("gst_player.vala:69: state: %s, pending: %s", _tmp5_, _tmp7_);
183
220
        }
184
 
        if (state != GST_STATE_READY) {
185
 
                gst_element_set_state (self->priv->player, GST_STATE_READY);
 
221
        _tmp8_ = state;
 
222
        if (_tmp8_ != GST_STATE_READY) {
 
223
                GstElement* _tmp9_;
 
224
                _tmp9_ = self->priv->player;
 
225
                gst_element_set_state (_tmp9_, GST_STATE_READY);
186
226
        }
187
227
}
188
228
 
189
229
 
190
230
static gboolean gst_player_bus_callback (GstPlayer* self, GstBus* bus, GstMessage* msg) {
191
231
        gboolean result = FALSE;
 
232
        GstMessage* _tmp0_;
 
233
        GstMessageType _tmp1_;
192
234
        g_return_val_if_fail (self != NULL, FALSE);
193
235
        g_return_val_if_fail (bus != NULL, FALSE);
194
236
        g_return_val_if_fail (msg != NULL, FALSE);
195
 
        switch (msg->type) {
 
237
        _tmp0_ = msg;
 
238
        _tmp1_ = _tmp0_->type;
 
239
        switch (_tmp1_) {
196
240
                case GST_MESSAGE_ERROR:
197
241
                {
198
242
                        GError* err = NULL;
199
243
                        gchar* debug = NULL;
200
 
                        GError* _tmp0_ = NULL;
201
 
                        gchar* _tmp1_ = NULL;
202
 
                        gst_message_parse_error (msg, &_tmp0_, &_tmp1_);
 
244
                        GstMessage* _tmp2_;
 
245
                        GError* _tmp3_ = NULL;
 
246
                        gchar* _tmp4_ = NULL;
 
247
                        GError* _tmp5_;
 
248
                        const gchar* _tmp6_;
 
249
                        GstElement* _tmp7_;
 
250
                        _tmp2_ = msg;
 
251
                        gst_message_parse_error (_tmp2_, &_tmp3_, &_tmp4_);
203
252
                        _g_error_free0 (err);
204
 
                        err = _tmp0_;
 
253
                        err = _tmp3_;
205
254
                        _g_free0 (debug);
206
 
                        debug = _tmp1_;
207
 
                        g_warning ("gst_player.vala:83: Error: %s\n", err->message);
208
 
                        gst_element_set_state (self->priv->player, GST_STATE_NULL);
 
255
                        debug = _tmp4_;
 
256
                        _tmp5_ = err;
 
257
                        _tmp6_ = _tmp5_->message;
 
258
                        g_warning ("gst_player.vala:83: Error: %s\n", _tmp6_);
 
259
                        _tmp7_ = self->priv->player;
 
260
                        gst_element_set_state (_tmp7_, GST_STATE_NULL);
209
261
                        _g_free0 (debug);
210
262
                        _g_error_free0 (err);
211
263
                        break;
220
272
                        GstState oldstate = 0;
221
273
                        GstState newstate = 0;
222
274
                        GstState pending = 0;
223
 
                        GstState _tmp2_;
224
 
                        GstState _tmp3_;
225
 
                        GstState _tmp4_;
226
 
                        const gchar* _tmp5_ = NULL;
227
 
                        const gchar* _tmp6_ = NULL;
228
 
                        const gchar* _tmp7_ = NULL;
229
 
                        gst_message_parse_state_changed (msg, &_tmp2_, &_tmp3_, &_tmp4_);
230
 
                        oldstate = _tmp2_;
231
 
                        newstate = _tmp3_;
232
 
                        pending = _tmp4_;
233
 
                        _tmp5_ = gst_element_state_get_name (oldstate);
234
 
                        _tmp6_ = gst_element_state_get_name (newstate);
235
 
                        _tmp7_ = gst_element_state_get_name (pending);
236
 
                        fprintf (stdout, "state changed: %s->%s:%s\n", _tmp5_, _tmp6_, _tmp7_);
 
275
                        GstMessage* _tmp8_;
 
276
                        GstState _tmp9_ = 0;
 
277
                        GstState _tmp10_ = 0;
 
278
                        GstState _tmp11_ = 0;
 
279
                        FILE* _tmp12_;
 
280
                        GstState _tmp13_;
 
281
                        const gchar* _tmp14_ = NULL;
 
282
                        GstState _tmp15_;
 
283
                        const gchar* _tmp16_ = NULL;
 
284
                        GstState _tmp17_;
 
285
                        const gchar* _tmp18_ = NULL;
 
286
                        _tmp8_ = msg;
 
287
                        gst_message_parse_state_changed (_tmp8_, &_tmp9_, &_tmp10_, &_tmp11_);
 
288
                        oldstate = _tmp9_;
 
289
                        newstate = _tmp10_;
 
290
                        pending = _tmp11_;
 
291
                        _tmp12_ = stdout;
 
292
                        _tmp13_ = oldstate;
 
293
                        _tmp14_ = gst_element_state_get_name (_tmp13_);
 
294
                        _tmp15_ = newstate;
 
295
                        _tmp16_ = gst_element_state_get_name (_tmp15_);
 
296
                        _tmp17_ = pending;
 
297
                        _tmp18_ = gst_element_state_get_name (_tmp17_);
 
298
                        fprintf (_tmp12_, "state changed: %s->%s:%s\n", _tmp14_, _tmp16_, _tmp18_);
237
299
                        break;
238
300
                }
239
301
                case GST_MESSAGE_BUFFERING:
242
304
                }
243
305
                default:
244
306
                {
245
 
                        const gchar* _tmp8_ = NULL;
246
 
                        _tmp8_ = gst_message_type_get_name (msg->type);
247
 
                        g_message ("gst_player.vala:103: message type: %s", _tmp8_);
 
307
                        GstMessage* _tmp19_;
 
308
                        GstMessageType _tmp20_;
 
309
                        const gchar* _tmp21_ = NULL;
 
310
                        _tmp19_ = msg;
 
311
                        _tmp20_ = _tmp19_->type;
 
312
                        _tmp21_ = gst_message_type_get_name (_tmp20_);
 
313
                        g_message ("gst_player.vala:103: message type: %s", _tmp21_);
248
314
                        break;
249
315
                }
250
316
        }