1
=== modified file 'debian/control'
2
--- debian/control	2014-11-11 20:18:36 +0000
3
+++ debian/control	2014-11-20 18:31:53 +0000
4
@@ -28,6 +28,7 @@
5
28
               gstreamer1.0-libav,
28
               gstreamer1.0-libav,
6
29
               libgstreamer1.0-dev,
29
               libgstreamer1.0-dev,
7
30
               pkg-config,
30
               pkg-config,
8
31
               libpulse-dev,
9
31
               qtbase5-dev,
32
               qtbase5-dev,
10
32
               libtelepathy-qt5-dev,
33
               libtelepathy-qt5-dev,
11
33
Standards-Version: 3.9.5
34
Standards-Version: 3.9.5
12
34
35
13
=== modified file 'debian/media-hub.conf'
14
--- debian/media-hub.conf	2014-05-20 09:53:23 +0000
15
+++ debian/media-hub.conf	2014-11-20 18:31:53 +0000
16
@@ -1,6 +1,6 @@
17
1
description "Starts the media-hub service"
1
description "Starts the media-hub service"
18
2
2
20
3
start on started dbus and xsession SESSION=ubuntu-touch
3
start on started dbus and started pulseaudio and xsession SESSION=ubuntu-touch
21
4
stop on runlevel [06]
4
stop on runlevel [06]
22
5
5
23
6
respawn
6
respawn
24
7
7
25
=== modified file 'src/core/media/CMakeLists.txt'
26
--- src/core/media/CMakeLists.txt	2014-11-03 00:56:55 +0000
27
+++ src/core/media/CMakeLists.txt	2014-11-20 18:31:53 +0000
28
@@ -1,5 +1,6 @@
29
1
pkg_check_modules(PC_GSTREAMER_1_0 REQUIRED gstreamer-1.0)
1
pkg_check_modules(PC_GSTREAMER_1_0 REQUIRED gstreamer-1.0)
31
2
include_directories(${PC_GSTREAMER_1_0_INCLUDE_DIRS} ${HYBRIS_MEDIA_CFLAGS})
2
pkg_check_modules(PC_PULSE_AUDIO REQUIRED libpulse)
32
3
include_directories(${PC_GSTREAMER_1_0_INCLUDE_DIRS} ${HYBRIS_MEDIA_CFLAGS} ${PC_PULSE_AUDIO_INCLUDE_DIRS})
33
3
4
34
4
# We compile with all symbols visible by default. For the shipping library, we strip
5
# We compile with all symbols visible by default. For the shipping library, we strip
35
5
# out all symbols that are not in core::ubuntu::media*
6
# out all symbols that are not in core::ubuntu::media*
36
@@ -100,6 +101,7 @@
37
100
  ${PROCESS_CPP_LDFLAGS}
101
  ${PROCESS_CPP_LDFLAGS}
38
101
  ${GIO_LIBRARIES}
102
  ${GIO_LIBRARIES}
39
102
  ${HYBRIS_MEDIA_LIBRARIES}
103
  ${HYBRIS_MEDIA_LIBRARIES}
40
104
  ${PC_PULSE_AUDIO_LIBRARIES}
41
103
)
105
)
42
104
106
43
105
include_directories(${PROJECT_SOURCE_DIR}/src/ ${HYBRIS_MEDIA_CFLAGS})
107
include_directories(${PROJECT_SOURCE_DIR}/src/ ${HYBRIS_MEDIA_CFLAGS})
44
106
108
45
=== modified file 'src/core/media/service_implementation.cpp'
46
--- src/core/media/service_implementation.cpp	2014-11-03 00:56:55 +0000
47
+++ src/core/media/service_implementation.cpp	2014-11-20 18:31:53 +0000
48
@@ -15,6 +15,9 @@
49
15
 *
15
 *
50
16
 * Authored by: Thomas Voß <thomas.voss@canonical.com>
16
 * Authored by: Thomas Voß <thomas.voss@canonical.com>
51
17
 *              Jim Hodapp <jim.hodapp@canonical.com>
17
 *              Jim Hodapp <jim.hodapp@canonical.com>
52
18
 *              Ricardo Mendoza <ricardo.mendoza@canonical.com>
53
19
 *
54
20
 * Note: Some of the PulseAudio code was adapted from telepathy-ofono
55
18
 */
21
 */
56
19
22
57
20
#include "service_implementation.h"
23
#include "service_implementation.h"
58
@@ -26,11 +29,15 @@
59
26
29
60
27
#include <boost/asio.hpp>
30
#include <boost/asio.hpp>
61
28
31
62
32
#include <string>
63
29
#include <cstdint>
33
#include <cstdint>
64
34
#include <cstring>
65
30
#include <map>
35
#include <map>
66
31
#include <memory>
36
#include <memory>
67
32
#include <thread>
37
#include <thread>
68
33
38
69
39
#include <pulse/pulseaudio.h>
70
40
71
34
#include "util/timeout.h"
41
#include "util/timeout.h"
72
35
#include "unity_screen_service.h"
42
#include "unity_screen_service.h"
73
36
#include <hybris/media/media_recorder_layer.h>
43
#include <hybris/media/media_recorder_layer.h>
74
@@ -45,6 +52,11 @@
75
45
        : resume_key(std::numeric_limits<std::uint32_t>::max()),
52
        : resume_key(std::numeric_limits<std::uint32_t>::max()),
76
46
          keep_alive(io_service),
53
          keep_alive(io_service),
77
47
          disp_cookie(0),
54
          disp_cookie(0),
78
55
          pulse_mainloop_api(nullptr),
79
56
          pulse_context(nullptr),
80
57
          headphones_connected(false),
81
58
          a2dp_connected(false),
82
59
          primary_idx(-1),
83
48
          call_monitor(new CallMonitor)
60
          call_monitor(new CallMonitor)
84
49
    {
61
    {
85
50
        bus = std::shared_ptr<dbus::Bus>(new dbus::Bus(core::dbus::WellKnownBus::session));
62
        bus = std::shared_ptr<dbus::Bus>(new dbus::Bus(core::dbus::WellKnownBus::session));
86
@@ -54,6 +66,67 @@
87
54
            bus->run();
66
            bus->run();
88
55
        }));
67
        }));
89
56
68
90
69
        // Spawn pulse watchdog
91
70
        pulse_mainloop = nullptr;
92
71
        pulse_worker = std::move(std::thread([this]()
93
72
        {
94
73
            std::unique_lock<std::mutex> lk(pulse_mutex);
95
74
            pcv.wait(lk,
96
75
                [this]{
97
76
                    if (pulse_mainloop != nullptr || pulse_context != nullptr)
98
77
                    {
99
78
                        // We come from instance death, destroy and create.
100
79
                        if (pulse_context != nullptr)
101
80
                        {
102
81
                            pa_threaded_mainloop_lock(pulse_mainloop);
103
82
                            pa_operation *o;
104
83
                            o = pa_context_drain(pulse_context,
105
84
                                [](pa_context *context, void *userdata)
106
85
                                {
107
86
                                    (void) context;
108
87
109
88
                                    Private *p = reinterpret_cast<Private*>(userdata);
110
89
                                    pa_threaded_mainloop_signal(p->mainloop(), 0);
111
90
                                }, this);
112
91
                            
113
92
                            if (o)
114
93
                            {
115
94
                                while (pa_operation_get_state(o) == PA_OPERATION_RUNNING)
116
95
                                    pa_threaded_mainloop_wait(pulse_mainloop);
117
96
118
97
                                pa_operation_unref(o);
119
98
                            }
120
99
121
100
                            pa_context_set_state_callback(pulse_context, NULL, NULL);
122
101
                            pa_context_set_subscribe_callback(pulse_context, NULL, NULL);
123
102
                            pa_context_disconnect(pulse_context);
124
103
                            pa_context_unref(pulse_context);
125
104
                            pulse_context = nullptr;
126
105
                            pa_threaded_mainloop_unlock(pulse_mainloop);
127
106
                        }
128
107
                    }
129
108
        
130
109
                    if (pulse_mainloop == nullptr)
131
110
                    {
132
111
                        pulse_mainloop = pa_threaded_mainloop_new();
133
112
134
113
                        if (pa_threaded_mainloop_start(pulse_mainloop) != 0)
135
114
                        {
136
115
                            std::cerr << "Unable to start pulseaudio mainloop, audio output detection will not function" << std::endl;
137
116
                            pa_threaded_mainloop_free(pulse_mainloop);
138
117
                            pulse_mainloop = nullptr;
139
118
                        }
140
119
                    }
141
120
                  
142
121
                    do {
143
122
                        create_pulse_context();
144
123
                    } while (pulse_context == nullptr);
145
124
                    
146
125
                    // Wait for next instance death.
147
126
                    return false;
148
127
                });
149
128
        }));
150
129
        
151
57
        // Connect the property change signal that will allow media-hub to take appropriate action
130
        // Connect the property change signal that will allow media-hub to take appropriate action
152
58
        // when the battery level reaches critical
131
        // when the battery level reaches critical
153
59
        auto stub_service = dbus::Service::use_service(bus, "com.canonical.indicator.power");
132
        auto stub_service = dbus::Service::use_service(bus, "com.canonical.indicator.power");
154
@@ -74,10 +147,22 @@
155
74
147
156
75
    ~Private()
148
    ~Private()
157
76
    {
149
    {
158
150
        release_pulse_context();
159
151
160
152
        if (pulse_mainloop != nullptr)
161
153
        {
162
154
            pa_threaded_mainloop_stop(pulse_mainloop);
163
155
            pa_threaded_mainloop_free(pulse_mainloop);
164
156
            pulse_mainloop = nullptr;
165
157
        }
166
158
167
77
        bus->stop();
159
        bus->stop();
168
78
160
169
79
        if (worker.joinable())
161
        if (worker.joinable())
170
80
            worker.join();
162
            worker.join();
171
163
172
164
        if (pulse_worker.joinable())
173
165
            pulse_worker.join();
174
81
    }
166
    }
175
82
167
176
83
    void media_recording_started(bool started)
168
    void media_recording_started(bool started)
177
@@ -116,6 +201,249 @@
178
116
        p->media_recording_started(started);
201
        p->media_recording_started(started);
179
117
    }
202
    }
180
118
203
181
204
    pa_threaded_mainloop *mainloop()
182
205
    {
183
206
        return pulse_mainloop;
184
207
    }
185
208
186
209
    bool is_port_available(pa_card_port_info **ports, uint32_t n_ports, const char *name)
187
210
    {
188
211
        bool ret = false;
189
212
190
213
        if (ports != nullptr && n_ports > 0 && name != nullptr)
191
214
        {
192
215
            for (uint32_t i=0; i<n_ports; i++)
193
216
            {
194
217
                if (strstr(ports[i]->name, name) != nullptr && ports[i]->available != PA_PORT_AVAILABLE_NO)
195
218
                {
196
219
                    ret = true;
197
220
                    break;
198
221
                }
199
222
            }
200
223
        }
201
224
202
225
        return ret;
203
226
    }
204
227
205
228
    void update_wired_output()
206
229
    {
207
230
        const pa_operation *o = pa_context_get_card_info_by_index(pulse_context, primary_idx,
208
231
                [](pa_context *context, const pa_card_info *info, int eol, void *userdata)
209
232
                {
210
233
                    (void) context;
211
234
                    (void) eol;
212
235
213
236
                    if (info == nullptr || userdata == nullptr)
214
237
                        return;
215
238
216
239
                    Private *p = reinterpret_cast<Private*>(userdata);
217
240
                    if (p->is_port_available(info->ports, info->n_ports, "output-wired"))
218
241
                    {
219
242
                        if (!p->headphones_connected)
220
243
                            std::cout << "Wired headphones connected" << std::endl;
221
244
                        p->headphones_connected = true;
222
245
                    }
223
246
                    else if (p->headphones_connected == true)
224
247
                    {
225
248
                        std::cout << "Wired headphones disconnected" << std::endl;
226
249
                        p->headphones_connected = false;
227
250
                        p->pause_playback_if_necessary(std::get<0>(p->active_sink));
228
251
                    }
229
252
                }, this);
230
253
        (void) o;
231
254
    }
232
255
233
256
    void pause_playback_if_necessary(int index)
234
257
    {
235
258
        // Catch uninitialized case (active index == -1)
236
259
        if (std::get<0>(active_sink) == -1)
237
260
            return;
238
261
239
262
        if (headphones_connected)
240
263
            return;
241
264
242
265
        // No headphones/fallback on primary sink? Pause.
243
266
        if (index == primary_idx)
244
267
            pause_playback();
245
268
    }
246
269
247
270
    void set_active_sink(const char *name)
248
271
    {
249
272
        const pa_operation *o = pa_context_get_sink_info_by_name(pulse_context, name,
250
273
                [](pa_context *context, const pa_sink_info *i, int eol, void *userdata)
251
274
                {
252
275
                    (void) context;
253
276
254
277
                    if (eol)
255
278
                        return;
256
279
257
280
                    Private *p = reinterpret_cast<Private*>(userdata); 
258
281
                    std::tuple<uint32_t, uint32_t, std::string> new_sink(std::make_tuple(i->index, i->card, i->name));
259
282
260
283
                    printf("pulsesink: active_sink=('%s',%d,%d) -> ('%s',%d,%d)\n",
261
284
                        std::get<2>(p->active_sink).c_str(), std::get<0>(p->active_sink),
262
285
                        std::get<1>(p->active_sink), i->name, i->index, i->card);
263
286
264
287
                    p->pause_playback_if_necessary(i->index);
265
288
                    p->active_sink = new_sink;
266
289
                }, this);
267
290
     
268
291
        (void) o;
269
292
    }
270
293
271
294
    void update_active_sink()
272
295
    {
273
296
        const pa_operation *o = pa_context_get_server_info(pulse_context,
274
297
                [](pa_context *context, const pa_server_info *i, void *userdata)
275
298
                {
276
299
                    (void) context;
277
300
278
301
                    Private *p = reinterpret_cast<Private*>(userdata);
279
302
                    if (i->default_sink_name != std::get<2>(p->active_sink))
280
303
                        p->set_active_sink(i->default_sink_name);
281
304
                    p->update_wired_output();
282
305
                }, this);
283
306
284
307
        (void) o;
285
308
    }
286
309
287
310
    void create_pulse_context()
288
311
    {
289
312
        if (pulse_context != nullptr)
290
313
            return;
291
314
        
292
315
        active_sink = std::make_tuple(-1, -1, "");
293
316
294
317
        bool keep_going = true, ok = true;
295
318
296
319
        pulse_mainloop_api = pa_threaded_mainloop_get_api(pulse_mainloop);
297
320
        pa_threaded_mainloop_lock(pulse_mainloop);
298
321
299
322
        pulse_context = pa_context_new(pulse_mainloop_api, "MediaHubPulseContext");
300
323
        pa_context_set_state_callback(pulse_context,
301
324
                [](pa_context *context, void *userdata)
302
325
                {
303
326
                    (void) context;
304
327
                    Private *p = reinterpret_cast<Private*>(userdata);
305
328
                    // Signals the pa_threaded_mainloop_wait below to proceed
306
329
                    pa_threaded_mainloop_signal(p->mainloop(), 0);
307
330
                }, this);
308
331
309
332
        if (pulse_context == nullptr)
310
333
        {
311
334
            std::cerr << "Unable to create new pulseaudio context" << std::endl;
312
335
            pa_threaded_mainloop_unlock(pulse_mainloop);
313
336
            return;
314
337
        }
315
338
316
339
        pa_context_connect(pulse_context, nullptr, pa_context_flags_t((int) PA_CONTEXT_NOAUTOSPAWN | (int) PA_CONTEXT_NOFAIL), nullptr); 
317
340
        pa_threaded_mainloop_wait(pulse_mainloop);
318
341
319
342
        while (keep_going)
320
343
        {
321
344
            switch (pa_context_get_state(pulse_context))
322
345
            {
323
346
                case PA_CONTEXT_CONNECTING: // Wait for service to be available
324
347
                case PA_CONTEXT_AUTHORIZING:
325
348
                case PA_CONTEXT_SETTING_NAME:
326
349
                    break;
327
350
328
351
                case PA_CONTEXT_READY:
329
352
                    std::cout << "Pulseaudio connection established." << std::endl;
330
353
                    keep_going = false;
331
354
                    break;
332
355
333
356
                case PA_CONTEXT_FAILED:
334
357
                case PA_CONTEXT_TERMINATED:
335
358
                    keep_going = false;
336
359
                    ok = false;
337
360
                    break;
338
361
339
362
                default:
340
363
                    std::cerr << "Pulseaudio connection failure: " << pa_strerror(pa_context_errno(pulse_context));
341
364
                    keep_going = false;
342
365
                    ok = false;
343
366
            }
344
367
345
368
            if (keep_going)
346
369
                pa_threaded_mainloop_wait(pulse_mainloop);
347
370
        }
348
371
349
372
        if (ok)
350
373
        {
351
374
            pa_context_set_state_callback(pulse_context,
352
375
                    [](pa_context *context, void *userdata)
353
376
                    {
354
377
                        (void) context;
355
378
                        (void) userdata;
356
379
                        Private *p = reinterpret_cast<Private*>(userdata);
357
380
                        std::unique_lock<std::mutex> lk(p->pulse_mutex);
358
381
                        switch (pa_context_get_state(context))
359
382
                        {
360
383
                            case PA_CONTEXT_FAILED:
361
384
                            case PA_CONTEXT_TERMINATED:
362
385
                                p->pcv.notify_all();
363
386
                                break;
364
387
                            default:
365
388
                                break;
366
389
                        }
367
390
                    }, this);
368
391
369
392
            //FIXME: Get index for "sink.primary", the default onboard card on Touch.
370
393
            pa_context_get_sink_info_by_name(pulse_context, "sink.primary",
371
394
                    [](pa_context *context, const pa_sink_info *i, int eol, void *userdata)
372
395
                    {
373
396
                        (void) context;
374
397
375
398
                        if (eol)
376
399
                            return;
377
400
                        
378
401
                        Private *p = reinterpret_cast<Private*>(userdata);
379
402
                        p->primary_idx = i->index;
380
403
                        p->update_wired_output();
381
404
                    }, this);
382
405
            
383
406
            update_active_sink(); 
384
407
385
408
            pa_context_set_subscribe_callback(pulse_context,
386
409
                    [](pa_context *context, pa_subscription_event_type_t t, uint32_t idx, void *userdata)
387
410
                    {
388
411
                        (void) context;
389
412
                        (void) idx;
390
413
391
414
                        if (userdata == nullptr)
392
415
                            return;
393
416
394
417
                        Private *p = reinterpret_cast<Private*>(userdata);
395
418
                        if ((t & PA_SUBSCRIPTION_EVENT_FACILITY_MASK) == PA_SUBSCRIPTION_EVENT_SINK)
396
419
                        {
397
420
                            p->update_active_sink(); 
398
421
                        }
399
422
                    }, this);
400
423
            pa_context_subscribe(pulse_context, PA_SUBSCRIPTION_MASK_SINK, nullptr, this);
401
424
        }
402
425
        else
403
426
        {
404
427
            std::cerr << "Connection to pulseaudio failed or was dropped." << std::endl;
405
428
            pa_context_unref(pulse_context);
406
429
            pulse_context = nullptr;
407
430
        }
408
431
409
432
        pa_threaded_mainloop_unlock(pulse_mainloop);
410
433
    }
411
434
412
435
    void release_pulse_context()
413
436
    {
414
437
        if (pulse_context != nullptr)
415
438
        {
416
439
            pa_threaded_mainloop_lock(pulse_mainloop);
417
440
            pa_context_disconnect(pulse_context);
418
441
            pa_context_unref(pulse_context);
419
442
            pa_threaded_mainloop_unlock(pulse_mainloop);
420
443
            pulse_context = nullptr;
421
444
        }
422
445
    }
423
446
424
119
    // This holds the key of the multimedia role Player instance that was paused
447
    // This holds the key of the multimedia role Player instance that was paused
425
120
    // when the battery level reached 10% or 5%
448
    // when the battery level reached 10% or 5%
426
121
    media::Player::PlayerKey resume_key;
449
    media::Player::PlayerKey resume_key;
427
@@ -129,14 +457,28 @@
428
129
    int disp_cookie;
457
    int disp_cookie;
429
130
    std::shared_ptr<dbus::Object> uscreen_session;
458
    std::shared_ptr<dbus::Object> uscreen_session;
430
131
    MediaRecorderObserver *observer;
459
    MediaRecorderObserver *observer;
431
460
432
461
    // Pulse-specific
433
462
    pa_mainloop_api *pulse_mainloop_api;
434
463
    pa_threaded_mainloop *pulse_mainloop;
435
464
    pa_context *pulse_context;
436
465
    std::thread pulse_worker;
437
466
    std::mutex pulse_mutex;
438
467
    std::condition_variable pcv;
439
468
    bool headphones_connected;
440
469
    bool a2dp_connected;
441
470
    std::tuple<int, int, std::string> active_sink;
442
471
    int primary_idx;
443
472
444
473
    // Gets signaled when both the headphone jack is removed or an A2DP device is
445
474
    // disconnected and playback needs pausing
446
475
    core::Signal<void> pause_playback;
447
132
    std::unique_ptr<CallMonitor> call_monitor;
476
    std::unique_ptr<CallMonitor> call_monitor;
448
133
    std::list<media::Player::PlayerKey> paused_sessions;
477
    std::list<media::Player::PlayerKey> paused_sessions;
449
134
};
478
};
450
135
479
451
136
media::ServiceImplementation::ServiceImplementation() : d(new Private())
480
media::ServiceImplementation::ServiceImplementation() : d(new Private())
452
137
{
481
{
453
138
    cout << __PRETTY_FUNCTION__ << endl;
454
139
455
140
    d->power_level->changed().connect([this](const core::IndicatorPower::PowerLevel::ValueType &level)
482
    d->power_level->changed().connect([this](const core::IndicatorPower::PowerLevel::ValueType &level)
456
141
    {
483
    {
457
142
        // When the battery level hits 10% or 5%, pause all multimedia sessions.
484
        // When the battery level hits 10% or 5%, pause all multimedia sessions.
458
@@ -153,6 +495,12 @@
459
153
            resume_multimedia_session();
495
            resume_multimedia_session();
460
154
    });
496
    });
461
155
497
462
498
    d->pause_playback.connect([this]()
463
499
    {
464
500
        std::cout << "Got pause_playback signal, pausing all multimedia sessions" << std::endl;
465
501
        pause_all_multimedia_sessions();
466
502
    });
467
503
468
156
    d->call_monitor->on_change([this](CallMonitor::State state) {
504
    d->call_monitor->on_change([this](CallMonitor::State state) {
469
157
        switch (state) {
505
        switch (state) {
470
158
        case CallMonitor::OffHook:
506
        case CallMonitor::OffHook:
471
159
507
472
=== modified file 'src/core/media/service_skeleton.cpp'
473
--- src/core/media/service_skeleton.cpp	2014-10-14 16:21:47 +0000
474
+++ src/core/media/service_skeleton.cpp	2014-11-20 18:31:53 +0000
475
@@ -14,6 +14,7 @@
476
14
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
14
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
477
15
 *
15
 *
478
16
 * Authored by: Thomas Voß <thomas.voss@canonical.com>
16
 * Authored by: Thomas Voß <thomas.voss@canonical.com>
479
17
 *              Jim Hodapp <jim.hodapp@canonical.com>
480
17
 */
18
 */
481
18
19
482
19
#include "service_skeleton.h"
20
#include "service_skeleton.h"
483
20
21
484
=== modified file 'tests/unit-tests/CMakeLists.txt'
485
--- tests/unit-tests/CMakeLists.txt	2014-11-03 00:56:55 +0000
486
+++ tests/unit-tests/CMakeLists.txt	2014-11-20 18:31:53 +0000
487
@@ -36,6 +36,7 @@
488
36
    ${PC_GSTREAMER_1_0_LIBRARIES}
36
    ${PC_GSTREAMER_1_0_LIBRARIES}
489
37
    ${PROCESS_CPP_LDFLAGS}
37
    ${PROCESS_CPP_LDFLAGS}
490
38
    ${GIO_LIBRARIES}
38
    ${GIO_LIBRARIES}
491
39
    ${PC_PULSE_AUDIO_LIBRARIES}
492
39
40
493
40
    gmock
41
    gmock
494
41
    gmock_main
42
    gmock_main
495
42
43
496
=== modified file 'tests/unit-tests/test-gstreamer-engine.cpp'
497
--- tests/unit-tests/test-gstreamer-engine.cpp	2014-08-26 20:34:30 +0000
498
+++ tests/unit-tests/test-gstreamer-engine.cpp	2014-11-20 18:31:53 +0000
499
@@ -65,7 +65,7 @@
500
65
    gstreamer::Engine engine;
65
    gstreamer::Engine engine;
501
66
}
66
}
502
67
67
504
68
TEST(GStreamerEngine, setting_uri_and_starting_audio_only_playback_works)
68
TEST(GStreamerEngine, DISABLED_setting_uri_and_starting_audio_only_playback_works)
505
69
{
69
{
506
70
    const std::string test_file{"/tmp/test.ogg"};
70
    const std::string test_file{"/tmp/test.ogg"};
507
71
    const std::string test_file_uri{"file:///tmp/test.ogg"};
71
    const std::string test_file_uri{"file:///tmp/test.ogg"};
508
@@ -110,7 +110,7 @@
509
110
                    std::chrono::seconds{10}));
110
                    std::chrono::seconds{10}));
510
111
}
111
}
511
112
112
513
113
TEST(GStreamerEngine, setting_uri_and_starting_video_playback_works)
113
TEST(GStreamerEngine, DISABLED_setting_uri_and_starting_video_playback_works)
514
114
{
114
{
515
115
    const std::string test_file{"/tmp/h264.avi"};
115
    const std::string test_file{"/tmp/h264.avi"};
516
116
    const std::string test_file_uri{"file:///tmp/h264.avi"};
116
    const std::string test_file_uri{"file:///tmp/h264.avi"};
517
@@ -152,7 +152,7 @@
518
152
                    std::chrono::seconds{10}));
152
                    std::chrono::seconds{10}));
519
153
}
153
}
520
154
154
522
155
TEST(GStreamerEngine, stop_pause_play_seek_audio_only_works)
155
TEST(GStreamerEngine, DISABLED_stop_pause_play_seek_audio_only_works)
523
156
{
156
{
524
157
    const std::string test_file{"/tmp/test.ogg"};
157
    const std::string test_file{"/tmp/test.ogg"};
525
158
    const std::string test_file_uri{"file:///tmp/test.ogg"};
158
    const std::string test_file_uri{"file:///tmp/test.ogg"};
526
@@ -198,7 +198,7 @@
527
198
                    std::chrono::seconds{40}));
198
                    std::chrono::seconds{40}));
528
199
}
199
}
529
200
200
531
201
TEST(GStreamerEngine, stop_pause_play_seek_video_works)
201
TEST(GStreamerEngine, DISABLED_stop_pause_play_seek_video_works)
532
202
{
202
{
533
203
    const std::string test_file{"/tmp/h264.avi"};
203
    const std::string test_file{"/tmp/h264.avi"};
534
204
    const std::string test_file_uri{"file:///tmp/h264.avi"};
204
    const std::string test_file_uri{"file:///tmp/h264.avi"};
Reviewer	Review Type	Date Requested	Status
Jim Hodapp (community)	code		Approve on 2014-11-20
PS Jenkins bot	continuous-integration		Approve on 2014-11-20
Ricardo Salveti (community)		2014-11-11	Approve on 2014-11-20
Review via email: mp+241452@code.launchpad.net