src/playermgr.cpp

   1 /*
   2  * Copyright (c) 2014 Samsung Electronics Co., Ltd All Rights Reserved
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the License);
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  * http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an AS IS BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15 */
  16
  17 #include <Elementary.h>
  18 #include <Eina.h>
  19 #include <dbg.h>
  20 #include "define.h"
  21 #include "playermgr.h"
  22
  23 #define SPEED_MAX 5.0
  24 #define SPEED_MIN -5.0
  25
  26 struct playermgr {
  27         player_h player;
  28         Evas_Object *win;
  29         Eina_List *media_list;
  30         float speed;
  31         int display_mode;
  32         int audio_effect;
  33         int current;
  34         int total;
  35 };
  36
  37 static void _destroy_list(Eina_List *list)
  38 {
  39         char *buf;
  40         void *o;
  41
  42         if (!list)
  43                 return;
  44
  45         EINA_LIST_FREE(list, o) {
  46                 buf = (char *)o;
  47                 free(buf);
  48         }
  49 }
  50
  51 static Eina_List *_create_list(const char *playlist)
  52 {
  53         Eina_List *list = NULL;
  54         FILE *fp;
  55         char buf[1024];
  56
  57         if (!playlist)
  58                 return NULL;
  59
  60         fp = fopen(playlist, "r");
  61         if (!fp)
  62                 return NULL;
  63
  64         while (fscanf(fp, "%s\n", buf) != EOF)
  65                 list = eina_list_append(list, strdup(buf));
  66
  67         fclose(fp);
  68
  69         return list;
  70 }
  71
  72 static int _get_current(Eina_List *list, const char *path)
  73 {
  74         Eina_List *l;
  75         const char *filepath;
  76         void *o;
  77         int cur;
  78
  79         if (!list || !path)
  80                 return 0;
  81
  82         cur = 0;
  83
  84         EINA_LIST_FOREACH(list, l, o) {
  85                 filepath = (const char *)o;
  86                 if (!strcmp(filepath, path))
  87                         break;
  88                 cur++;
  89         }
  90
  91         return cur;
  92 }
  93
  94 struct playermgr *playermgr_init(Evas_Object *win,
  95                 const char *path, const char *playlist)
  96 {
  97         struct playermgr *mgr;
  98
  99         mgr = (playermgr *)calloc(1, sizeof(*mgr));
 100         if (!mgr) {
 101                 _ERR("Allocation fail");
 102                 return NULL;
 103         }
 104
 105         mgr->win = win;
 106         mgr->display_mode = E_FULL_SCREEN;
 107         mgr->audio_effect = 0;
 108
 109         mgr->media_list = _create_list(playlist);
 110         if (!mgr->media_list) {
 111                 _ERR("play list is null");
 112                 free(mgr);
 113                 return NULL;
 114         }
 115
 116         mgr->current = _get_current(mgr->media_list, path);
 117         mgr->total = eina_list_count(mgr->media_list);
 118
 119         if (player_create(&mgr->player) != PLAYER_ERROR_NONE) {
 120                 _ERR("PLAYER CREATION ERROR");
 121                 free(mgr);
 122                 return NULL;
 123         }
 124
 125
 126         return mgr;
 127 }
 128
 129 static int _play_video(struct playermgr *mgr, const char *path)
 130 {
 131         Ecore_X_Window xwin;
 132         int r;
 133
 134         if (player_set_uri(mgr->player, path) != PLAYER_ERROR_NONE) {
 135                 _ERR("PLAYER SET URI ERROR");
 136                 return -1;
 137         }
 138
 139         xwin = elm_win_xwindow_get(mgr->win);
 140         r = player_set_display(mgr->player, PLAYER_DISPLAY_TYPE_X11,
 141                         GET_DISPLAY(xwin));
 142         if (r != PLAYER_ERROR_NONE) {
 143                 _ERR("SETTING DISPLAY ERROR");
 144                 return -1;
 145         }
 146
 147         playermgr_set_display_mode(mgr, mgr->display_mode);
 148
 149         r = player_prepare(mgr->player);
 150         if (r != PLAYER_ERROR_NONE) {
 151                 if (r == PLAYER_ERROR_NOT_SUPPORTED_FILE)
 152                         _ERR("PLAYER PREPARE ERROR NOT SUPPORTED FILE %d", r);
 153                 else if (r == PLAYER_ERROR_INVALID_URI)
 154                         _ERR("PLAYER PREPARE ERROR INVALID URI %d", r);
 155                 else
 156                         _ERR("PLAYER PREPARE ERROR");
 157
 158                 return -1;
 159         }
 160
 161         r = player_start(mgr->player);
 162         if (r != PLAYER_ERROR_NONE) {
 163                 _ERR("PLAYER START ERROR");
 164                 return -1;
 165         }
 166
 167         playermgr_set_audio_effect(mgr, mgr->audio_effect);
 168
 169         return 0;
 170 }
 171
 172 int playermgr_stop_video(struct playermgr *mgr)
 173 {
 174         if (!mgr || !mgr->player) {
 175                 _ERR("invalid parameter");
 176                 return -1;
 177         }
 178
 179         player_pause(mgr->player);
 180         player_stop(mgr->player);
 181         player_unprepare(mgr->player);
 182
 183         return 0;
 184 }
 185
 186 int playermgr_play_video(struct playermgr *mgr)
 187 {
 188         const char *path;
 189         int r;
 190
 191         if (!mgr || !mgr->media_list) {
 192                 _ERR("invalid parameter");
 193                 return -1;
 194         }
 195
 196         r = playermgr_stop_video(mgr);
 197         if (r < 0)
 198                 return r;
 199
 200         path = playermgr_get_video_path(mgr);
 201         r = _play_video(mgr, path);
 202
 203         return r;
 204 }
 205
 206 void playermgr_set_prev_video(struct playermgr *mgr)
 207 {
 208         if (!mgr) {
 209                 _ERR("invalid parameter");
 210                 return;
 211         }
 212
 213         if (mgr->current == 0)
 214                 mgr->current = mgr->total - 1;
 215         else
 216                 mgr->current--;
 217 }
 218
 219 Eina_Bool playermgr_set_next_video(struct playermgr *mgr, Eina_Bool repeat)
 220 {
 221         if (!mgr) {
 222                 _ERR("invalid parameter");
 223                 return EINA_FALSE;
 224         }
 225
 226         if (mgr->current == mgr->total - 1) {
 227                 mgr->current = 0;
 228
 229                 if (!repeat)
 230                         return EINA_FALSE;
 231         } else {
 232                 mgr->current++;
 233         }
 234
 235         return EINA_TRUE;
 236 }
 237
 238 const char *playermgr_get_video_path(struct playermgr *mgr)
 239 {
 240         const char *path;
 241
 242         if (!mgr || !mgr->media_list) {
 243                 _ERR("invalid parameter");
 244                 return NULL;
 245         }
 246
 247         path = (const char *)eina_list_nth(mgr->media_list, mgr->current);
 248
 249         return path;
 250 }
 251
 252 void playermgr_fini(struct playermgr *mgr)
 253 {
 254         if (!mgr)
 255                 return;
 256
 257         if (mgr->media_list)
 258                 _destroy_list(mgr->media_list);
 259
 260         if (mgr->player) {
 261                 player_pause(mgr->player);
 262                 player_stop(mgr->player);
 263                 player_unprepare(mgr->player);
 264                 player_destroy(mgr->player);
 265         }
 266
 267         free(mgr);
 268 }
 269
 270 int playermgr_pause(struct playermgr *mgr)
 271 {
 272         if (!mgr || !mgr->player) {
 273                 _ERR("invalid parameter");
 274                 return -1;
 275         }
 276
 277         if (player_pause(mgr->player) != PLAYER_ERROR_NONE) {
 278                 _ERR("Player pause error");
 279                 return -1;
 280         }
 281
 282         return 0;
 283 }
 284
 285 int playermgr_resume(struct playermgr *mgr)
 286 {
 287         if (!mgr || !mgr->player) {
 288                 _ERR("invalid parameter");
 289                 return -1;
 290         }
 291
 292         if (player_start(mgr->player) != PLAYER_ERROR_NONE) {
 293                 _ERR("Player resume error");
 294                 return -1;
 295         }
 296
 297         return 0;
 298 }
 299
 300 int playermgr_get_state(struct playermgr *mgr, player_state_e *state)
 301 {
 302         int r;
 303
 304         if (!mgr || !mgr->player) {
 305                 _ERR("invalid parameter");
 306                 return -1;
 307         }
 308
 309         r = player_get_state(mgr->player, state);
 310         if (r != PLAYER_ERROR_NONE) {
 311                 _ERR("Player get state error");
 312                 return -1;
 313         }
 314
 315         return 0;
 316 }
 317
 318 int playermgr_get_position(struct playermgr *mgr, int *position)
 319 {
 320         int r;
 321
 322         if (!mgr || !mgr->player) {
 323                 _ERR("invalid parameter");
 324                 return -1;
 325         }
 326
 327         /* deprecated */
 328         r = player_get_position(mgr->player, position);
 329         if (r != PLAYER_ERROR_NONE) {
 330                 _ERR("Player get position error");
 331                 return -1;
 332         }
 333
 334         return 0;
 335 }
 336
 337 int playermgr_seek(struct playermgr *mgr,
 338                 int sec, player_seek_completed_cb cb, void *data)
 339 {
 340         int r;
 341
 342         if (!mgr || !mgr->player) {
 343                 _ERR("invalid parameter");
 344                 return -1;
 345         }
 346
 347         /* deprecated */
 348         r = player_seek(mgr->player, sec, false, cb, data);
 349         if (r != PLAYER_ERROR_NONE) {
 350                 _ERR("Player seek error");
 351                 return -1;
 352         }
 353
 354         return 0;
 355 }
 356
 357 int playermgr_set_position(struct playermgr *mgr,
 358                 int sec, player_seek_completed_cb cb, void *data)
 359 {
 360         int r;
 361
 362         if (!mgr || !mgr->player) {
 363                 _ERR("invalid parameter");
 364                 return -1;
 365         }
 366
 367         /* deprecated */
 368         r = player_set_position(mgr->player, sec, cb, data);
 369         if (r != PLAYER_ERROR_NONE) {
 370                 _ERR("Player set position error");
 371                 return -1;
 372         }
 373
 374         return 0;
 375 }
 376
 377 int playermgr_set_playback_rate(struct playermgr *mgr, float speed)
 378 {
 379         int r;
 380
 381         if (!mgr || !mgr->player) {
 382                 _ERR("invalid parameter");
 383                 return -1;
 384         }
 385
 386         if (speed > SPEED_MAX)
 387                 speed = SPEED_MAX;
 388         else if (speed < SPEED_MIN)
 389                 speed = SPEED_MIN;
 390
 391         r = player_set_playback_rate(mgr->player, speed);
 392         if (r != PLAYER_ERROR_NONE) {
 393                 _ERR("Player set playback error");
 394                 return -1;
 395         }
 396
 397         mgr->speed = speed;
 398
 399         return 0;
 400 }
 401
 402 int playermgr_get_playback_rate(struct playermgr *mgr, float *speed)
 403 {
 404         if (!mgr) {
 405                 _ERR("invalid parameter");
 406                 return -1;
 407         }
 408
 409         *speed = mgr->speed;
 410
 411         return 0;
 412 }
 413
 414 int playermgr_set_looping(struct playermgr *mgr, bool value)
 415 {
 416         int r;
 417
 418         if (!mgr || !mgr->player) {
 419                 _ERR("invalid parameter");
 420                 return -1;
 421         }
 422
 423         r = player_set_looping(mgr->player, value);
 424         if (r != PLAYER_ERROR_NONE) {
 425                 _ERR("Player set looping error");
 426                 return -1;
 427         }
 428
 429         return 0;
 430 }
 431
 432 int playermgr_set_audio_effect(struct playermgr *mgr, int value)
 433 {
 434         /* audio_effect not supported, just return 0 */
 435         mgr->audio_effect = value;
 436
 437         return 0;
 438 }
 439
 440 int playermgr_set_display_mode(struct playermgr *mgr, int value)
 441 {
 442         int r;
 443         player_display_mode_e mode;
 444
 445         if (!mgr || !mgr->player) {
 446                 _ERR("invalid parameter");
 447                 return -1;
 448         }
 449
 450         switch (value) {
 451         case E_FULL_SCREEN:
 452                 mode = PLAYER_DISPLAY_MODE_FULL_SCREEN;
 453                 break;
 454         case E_ORIGINAL:
 455                 mode = PLAYER_DISPLAY_MODE_ORIGIN_SIZE;
 456                 break;
 457         default:
 458                 _ERR("Invalid value");
 459                 return -1;
 460         }
 461
 462         r = player_set_display_mode(mgr->player, mode);
 463         if (r != PLAYER_ERROR_NONE) {
 464                 _ERR("Player display mode set error");
 465                 return -1;
 466         }
 467
 468         mgr->display_mode = value;
 469
 470         return 0;
 471 }
 472
 473 int playermgr_set_completed_cb(struct playermgr *mgr,
 474                 player_completed_cb cb, void *data)
 475 {
 476         int r;
 477
 478         if (!mgr || !mgr->player) {
 479                 _ERR("invalid parameter");
 480                 return -1;
 481         }
 482
 483         r = player_set_completed_cb(mgr->player, cb, data);
 484         if (r != PLAYER_ERROR_NONE) {
 485                 _ERR("Player set completed cb error");
 486                 return -1;
 487         }
 488
 489         return 0;
 490 }
 491
 492 void playermgr_get_play_count(struct playermgr *mgr, char *str, int len)
 493 {
 494         if (!mgr) {
 495                 _ERR("invalid parameter");
 496                 return;
 497         }
 498
 499         snprintf(str, len, "%d/%d", mgr->current + 1, mgr->total);
 500 }