media_list_player.c 14.1 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25
/*
 * media_list_player.c - libvlc smoke test
 *
 * $Id$
 */

/**********************************************************************
 *  Copyright (C) 2007 Rémi Denis-Courmont.                           *
 *  This program is free software; you can redistribute and/or modify *
 *  it under the terms of the GNU General Public License as published *
 *  by the Free Software Foundation; version 2 of the license, or (at *
 *  your option) any later version.                                   *
 *                                                                    *
 *  This program is distributed in the hope that it will be useful,   *
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of    *
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.              *
 *  See the GNU General Public License for more details.              *
 *                                                                    *
 *  You should have received a copy of the GNU General Public License *
 *  along with this program; if not, you can get it from:             *
 *  http://www.gnu.org/copyleft/gpl.html                              *
 **********************************************************************/

#include "test.h"

26 27 28 29
 // For msleep
#include <vlc_common.h>
#include <vlc_mtime.h>

30
#include "libvlc_additions.h"
31

32
/*
33 34 35 36
    HACK - FIX ME
    This allows for the direct addition of subitems in the playback options test.
    This would not be necessary if there were an add subitems function.
*/
37
#include "../../lib/media_internal.h"
38

39 40 41 42 43 44
struct check_items_order_data {
    bool done_playing;
    unsigned count;
    unsigned index;
    void * items[16];
};
45

46 47 48 49 50
static inline void check_data_init(struct check_items_order_data *check)
{
    check->index = 0;
    check->count = 0;
    check->done_playing = false;
51 52
}

53 54 55 56 57 58
static inline void queue_expected_item(struct check_items_order_data *check, void *item)
{
    assert(check->count < 16);
    check->items[check->count] = item;
    check->count++;
}
59

60
static inline void wait_queued_items(struct check_items_order_data *check)
61
{
62 63
    // Wait dummily for check_items_order_callback() to flag 'done_playing':
    while (!check->done_playing)
64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82
        sched_yield();
}

static inline void wait_playing(libvlc_media_list_player_t *mlp)
{
    while (!libvlc_media_list_player_is_playing (mlp))
        sched_yield();
}

static inline void wait_stopped(libvlc_media_list_player_t *mlp)
{
    while (libvlc_media_list_player_is_playing (mlp))
        sched_yield();
}

static inline void stop_and_wait(libvlc_media_list_player_t *mlp)
{
    libvlc_media_list_player_stop (mlp);
    wait_stopped (mlp);
83 84 85 86 87
}

static void check_items_order_callback(const libvlc_event_t * p_event, void * user_data)
{
    struct check_items_order_data *checks = user_data;
88
    libvlc_media_t *md = p_event->u.media_list_player_next_item_set.item;
89 90 91
    assert(checks->index < checks->count);
    if (checks->items[checks->index] != md)
    {
Rémi Denis-Courmont's avatar
Rémi Denis-Courmont committed
92
        char *title = libvlc_media_get_meta(md, libvlc_meta_Title);
93 94 95 96
        log ("Got items %s\n", title);
        free(title);
    }
    assert(checks->items[checks->index] == md);
97

Rémi Denis-Courmont's avatar
Rémi Denis-Courmont committed
98
    char *title = libvlc_media_get_meta(md, libvlc_meta_Title);
99 100
    log ("Item %d '%s' was correctly queued\n", checks->index, title);
    free(title);
101

102 103 104 105 106 107
    if (checks->index == (checks->count - 1))
    {
        log ("Done playing with success\n");
        checks->done_playing = true;
    }
    checks->index++;
108 109 110 111 112 113 114 115
}

static void test_media_list_player_items_queue(const char** argv, int argc)
{
    libvlc_instance_t *vlc;
    libvlc_media_t *md;
    libvlc_media_list_t *ml;
    libvlc_media_list_player_t *mlp;
116

117
    const char * file = test_default_sample;
118

119
    log ("Testing media player item queue-ing\n");
120

121 122
    vlc = libvlc_new (argc, argv);
    assert (vlc != NULL);
123

124 125
    md = libvlc_media_new_path (vlc, file);
    assert(md);
126

127 128
    ml = libvlc_media_list_new (vlc);
    assert (ml != NULL);
129

130 131
    mlp = libvlc_media_list_player_new (vlc);
    assert(mlp);
132

133
    libvlc_media_list_add_media (ml, md);
134 135 136 137

    static struct check_items_order_data check;
    check_data_init(&check);
    queue_expected_item(&check, md);
138 139

    // Add three more media
140 141 142 143 144
    queue_expected_item(&check, media_list_add_file_path (vlc, ml, file));
    queue_expected_item(&check, media_list_add_file_path (vlc, ml, file));
    queue_expected_item(&check, media_list_add_file_path (vlc, ml, file));

    // Add a node
145 146 147
    libvlc_media_t *node = libvlc_media_new_as_node(vlc, "node");
    assert(node);
    libvlc_media_list_add_media(ml, node);
148 149 150
    queue_expected_item(&check, node);

    // Add items to that node
Rémi Denis-Courmont's avatar
Rémi Denis-Courmont committed
151
    libvlc_media_list_t *subitems = libvlc_media_subitems(node);
152 153 154 155
    queue_expected_item(&check, media_list_add_file_path(vlc, subitems, file));
    queue_expected_item(&check, media_list_add_file_path(vlc, subitems, file));
    queue_expected_item(&check, media_list_add_file_path(vlc, subitems, file));
    libvlc_media_list_release(subitems);
156

157
    libvlc_media_list_player_set_media_list (mlp, ml);
158 159

    libvlc_event_manager_t * em = libvlc_media_list_player_event_manager(mlp);
160 161 162
    int val = libvlc_event_attach(em, libvlc_MediaListPlayerNextItemSet,
                                  check_items_order_callback, &check);
    assert(val == 0);
163

164
    libvlc_media_list_player_play(mlp);
165

166 167
    // Wait until all item are read
    wait_queued_items(&check);
168

169
    stop_and_wait (mlp);
170

171 172
    libvlc_media_list_player_release (mlp);
    libvlc_release (vlc);
173 174
}

175 176 177 178 179 180
static void test_media_list_player_previous(const char** argv, int argc)
{
    libvlc_instance_t *vlc;
    libvlc_media_t *md;
    libvlc_media_list_t *ml;
    libvlc_media_list_player_t *mlp;
181

182
    const char * file = test_default_sample;
183

184
    log ("Testing media player previous()\n");
185

186 187
    vlc = libvlc_new (argc, argv);
    assert (vlc != NULL);
188

189 190
    md = libvlc_media_new_path (vlc, file);
    assert(md);
191

192 193
    ml = libvlc_media_list_new (vlc);
    assert (ml != NULL);
194

195 196
    mlp = libvlc_media_list_player_new (vlc);
    assert(mlp);;
197

198
    libvlc_media_list_add_media (ml, md);
199 200 201 202 203 204

    // Add three media
    media_list_add_file_path (vlc, ml, file);
    media_list_add_file_path (vlc, ml, file);
    media_list_add_file_path (vlc, ml, file);

205
    libvlc_media_list_player_set_media_list (mlp, ml);
206

207
    libvlc_media_list_player_play_item (mlp, md);
208

209
    wait_playing (mlp);
210

211
    libvlc_media_release (md);
212

213
    libvlc_media_list_player_previous (mlp);
214

215
    wait_playing (mlp);
216

217 218
    libvlc_media_list_player_pause (mlp);
    libvlc_media_list_player_previous (mlp);
219

220
    wait_playing (mlp);
221

222
    stop_and_wait (mlp);
223

224
    libvlc_media_list_player_previous (mlp);
225

226
    wait_playing (mlp);
227

228
    stop_and_wait (mlp);
229

230 231 232 233
    libvlc_media_list_player_release (mlp);
    libvlc_release (vlc);
}

234 235 236 237 238 239
static void test_media_list_player_next(const char** argv, int argc)
{
    libvlc_instance_t *vlc;
    libvlc_media_t *md;
    libvlc_media_list_t *ml;
    libvlc_media_list_player_t *mlp;
240

241
    const char * file = test_default_sample;
242

243
    log ("Testing media player next()\n");
244

245 246
    vlc = libvlc_new (argc, argv);
    assert (vlc != NULL);
247

248 249
    md = libvlc_media_new_path (vlc, file);
    assert(md);
250

251 252
    ml = libvlc_media_list_new (vlc);
    assert (ml != NULL);
253

254 255
    mlp = libvlc_media_list_player_new (vlc);
    assert(mlp);
256

257
    libvlc_media_list_add_media (ml, md);
258 259 260 261 262 263

    // Add three media
    media_list_add_file_path (vlc, ml, file);
    media_list_add_file_path (vlc, ml, file);
    media_list_add_file_path (vlc, ml, file);

264
    libvlc_media_list_player_set_media_list (mlp, ml);
265

266
    libvlc_media_list_player_play_item (mlp, md);
267 268 269

    libvlc_media_release (md);

270
    wait_playing (mlp);
271

272
    libvlc_media_list_player_next (mlp);
273

274
    wait_playing (mlp);
275

276 277
    libvlc_media_list_player_pause (mlp);
    libvlc_media_list_player_next (mlp);
278

279
    wait_playing (mlp);
280

281
    stop_and_wait (mlp);
282

283
    libvlc_media_list_player_next (mlp);
284

285
    wait_playing (mlp);
286

287
    stop_and_wait (mlp);
288

289 290 291 292
    libvlc_media_list_player_release (mlp);
    libvlc_release (vlc);
}

293 294 295 296 297 298 299 300 301 302 303
static void test_media_list_player_pause_stop(const char** argv, int argc)
{
    libvlc_instance_t *vlc;
    libvlc_media_t *md;
    libvlc_media_list_t *ml;
    libvlc_media_list_player_t *mlp;

    const char * file = test_default_sample;

    log ("Testing play and pause of %s using the media list.\n", file);

304 305
    vlc = libvlc_new (argc, argv);
    assert (vlc != NULL);
306

307 308
    md = libvlc_media_new_path (vlc, file);
    assert(md);
309

310 311
    ml = libvlc_media_list_new (vlc);
    assert (ml != NULL);
312

313 314
    mlp = libvlc_media_list_player_new (vlc);
    assert(mlp);
315

316
    libvlc_media_list_add_media( ml, md);
317

318
    libvlc_media_list_player_set_media_list( mlp, ml );
319

320
    libvlc_media_list_player_play_item( mlp, md );
321

322
    wait_playing (mlp);
323

324
    libvlc_media_list_player_pause (mlp);
325

326
    stop_and_wait (mlp);
327

328 329 330 331 332
    libvlc_media_release (md);
    libvlc_media_list_player_release (mlp);
    libvlc_release (vlc);
}

333 334 335 336 337 338 339 340 341
static void test_media_list_player_play_item_at_index(const char** argv, int argc)
{
    libvlc_instance_t *vlc;
    libvlc_media_t *md;
    libvlc_media_list_t *ml;
    libvlc_media_list_player_t *mlp;

    const char * file = test_default_sample;

342
    log ("Testing play_item_at_index of %s using the media list.\n", file);
343

344
    vlc = libvlc_new (argc, argv);
345
    assert (vlc != NULL);
346

347 348
    md = libvlc_media_new_path (vlc, file);
    assert(md);
349

350 351
    ml = libvlc_media_list_new (vlc);
    assert (ml != NULL);
352

353 354
    mlp = libvlc_media_list_player_new (vlc);
    assert(mlp);
355

356
    for (unsigned i = 0; i < 5; i++)
357
        libvlc_media_list_add_media( ml, md );
358

359
    libvlc_media_list_player_set_media_list( mlp, ml );
360
    libvlc_media_list_player_play_item_at_index( mlp, 0 );
361

362
    wait_playing (mlp);
363

364
    stop_and_wait (mlp);
365

366 367 368 369 370
    libvlc_media_release (md);
    libvlc_media_list_player_release (mlp);
    libvlc_release (vlc);
}

371 372 373 374 375 376 377 378 379 380 381 382 383 384 385
static void test_media_list_player_playback_options (const char** argv, int argc)
{
    libvlc_instance_t *vlc;
    libvlc_media_t *md;
    libvlc_media_t *md2;
    libvlc_media_t *md3;
    libvlc_media_t *md4;
    libvlc_media_t *md5;
    libvlc_media_list_t *ml;
    libvlc_media_list_t *ml2;
    libvlc_media_list_t *ml3;
    libvlc_media_list_t *ml4;
    libvlc_media_list_t *ml5;
    libvlc_media_list_t *ml6;
    libvlc_media_list_player_t *mlp;
386

387
    const char * file = test_default_sample;
388

389
    log ("Testing media player playback options()\n");
390

391 392
    vlc = libvlc_new (argc, argv);
    assert (vlc != NULL);
393

394 395 396 397 398 399 400 401 402 403 404 405
    /*
     *   Create the following media tree:
     *
     *  ml1:            0 ---- 1 ---- 2
     *                 /       |       \
     *  ml2&4:      0 -- 1     |   0 -- 1 -- 2
     *                         |
     *  ml3:    0 -- 1 -- 2 -- 3 -- 4 -- 5 -- 6
     *                    |                   |
     *  ml5&6:            0                 0 -- 1
     */

406 407
    md = libvlc_media_new_path (vlc, file);
    assert(md);
408

409 410
    md2 = libvlc_media_new_path (vlc, file);
    assert(md2);
411

412 413
    md3 = libvlc_media_new_path (vlc, file);
    assert(md3);
414

415 416
    md4 = libvlc_media_new_path (vlc, file);
    assert(md4);
417

418 419
    md5 = libvlc_media_new_path (vlc, file);
    assert(md5);
420

421 422
    ml = libvlc_media_list_new (vlc);
    assert (ml != NULL);
423

424 425
    ml2 = libvlc_media_list_new (vlc);
    assert (ml2 != NULL);
426

427 428
    ml3 = libvlc_media_list_new (vlc);
    assert (ml3 != NULL);
429

430 431
    ml4 = libvlc_media_list_new (vlc);
    assert (ml4 != NULL);
432

433 434
    ml5 = libvlc_media_list_new (vlc);
    assert (ml5 != NULL);
435

436 437
    ml6 = libvlc_media_list_new (vlc);
    assert (ml6 != NULL);
438 439 440 441 442 443

    media_list_add_file_path (vlc, ml2, file);
    media_list_add_file_path (vlc, ml2, file);

    media_list_add_file_path (vlc, ml3, file);
    media_list_add_file_path (vlc, ml3, file);
444
    libvlc_media_list_add_media (ml3, md4);
445 446 447
    media_list_add_file_path (vlc, ml3, file);
    media_list_add_file_path (vlc, ml3, file);
    media_list_add_file_path (vlc, ml3, file);
448
    libvlc_media_list_add_media (ml3, md5);
449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464

    media_list_add_file_path (vlc, ml4, file);
    media_list_add_file_path (vlc, ml4, file);
    media_list_add_file_path (vlc, ml4, file);

    media_list_add_file_path (vlc, ml5, file);

    media_list_add_file_path (vlc, ml6, file);
    media_list_add_file_path (vlc, ml6, file);

    md->p_subitems = ml2;
    md2->p_subitems = ml3;
    md3->p_subitems = ml4;
    md4->p_subitems = ml5;
    md5->p_subitems = ml6;

465 466 467
    libvlc_media_list_add_media (ml, md);
    libvlc_media_list_add_media (ml, md2);
    libvlc_media_list_add_media (ml, md3);
468

469 470
    mlp = libvlc_media_list_player_new (vlc);
    assert(mlp);
471

472
    libvlc_media_list_player_set_media_list (mlp, ml);
473 474

    // Test default playback mode
475
    libvlc_media_list_player_set_playback_mode(mlp, libvlc_playback_mode_default);
476

477
    libvlc_media_list_player_play_item (mlp, md);
478

479
    wait_playing (mlp);
480

481 482 483 484 485 486
    libvlc_media_release (md);
    libvlc_media_release (md2);
    libvlc_media_release (md3);
    libvlc_media_release (md4);
    libvlc_media_release (md5);

487
    libvlc_media_list_player_stop (mlp);
488

489 490
    while (libvlc_media_list_player_is_playing (mlp))
        sched_yield();
491

492 493
    // Test looping playback mode
    log ("Testing media player playback option - Loop\n");
494
    libvlc_media_list_player_set_playback_mode(mlp, libvlc_playback_mode_loop);
495

496
    libvlc_media_list_player_play_item (mlp, md);
497

498
    wait_playing (mlp);
499

500
    stop_and_wait (mlp);
501

502 503
    // Test repeat playback mode
    log ("Testing media player playback option - Repeat\n");
504
    libvlc_media_list_player_set_playback_mode(mlp, libvlc_playback_mode_repeat);
505

506
    libvlc_media_list_player_play_item (mlp, md);
507

508
    wait_playing (mlp);
509

510
    stop_and_wait (mlp);
511

512 513 514 515
    libvlc_media_list_player_release (mlp);
    libvlc_release (vlc);
}

516 517 518 519 520

int main (void)
{
    test_init();

521 522 523
    // There are 6 tests. And they take some times.
    alarm(6 * 5);

524
    test_media_list_player_pause_stop (test_defaults_args, test_defaults_nargs);
525
    test_media_list_player_play_item_at_index (test_defaults_args, test_defaults_nargs);
526
    test_media_list_player_previous (test_defaults_args, test_defaults_nargs);
527
    test_media_list_player_next (test_defaults_args, test_defaults_nargs);
528
    test_media_list_player_items_queue (test_defaults_args, test_defaults_nargs);
529
    test_media_list_player_playback_options (test_defaults_args, test_defaults_nargs);
530 531
    return 0;
}