playback.c

   1 /* -*- Mode: C ; c-basic-offset: 2 -*- */
   2 /*****************************************************************************
   3  *
   4  *   Playback control and playlist handling
   5  *   This file is part of monster
   6  *
   7  *   Copyright (C) 2006,2007 Nedko Arnaudov <nedko@arnaudov.name>
   8  *
   9  *   This program is free software; you can redistribute it and/or modify
  10  *   it under the terms of the GNU General Public License as published by
  11  *   the Free Software Foundation; version 2 of the License
  12  *
  13  *   This program is distributed in the hope that it will be useful,
  14  *   but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16  *   GNU General Public License for more details.
  17  *
  18  *   You should have received a copy of the GNU General Public License
  19  *   along with this program; if not, write to the Free Software
  20  *   Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  21  *
  22  *****************************************************************************/
  23
  24 #include <stdlib.h>
  25 #include <pthread.h>
  26 #include <libxml/parser.h>
  27 #include <libxml/xpath.h>
  28 #include <string.h>
  29 #include <libgen.h>
  30 #include <unistd.h>
  31
  32 #define DISABLE_DEBUG_OUTPUT
  33
  34 #include "playback.h"
  35 #include "song_player.h"
  36 #include "log.h"
  37 #include "song_player.h"
  38 #include "types.h"
  39 #include "list.h"
  40 #include "xml.h"
  41 #include "path.h"
  42
  43 /* XPath expression used for song path selection */
  44 #define XPATH_SONG_PATH_EXPRESSION "/playlist/song/path"
  45
  46 pthread_mutex_t g_playback_mutex;
  47 pthread_cond_t g_playback_cond;
  48 pthread_t g_playback_thread;
  49 bool g_destroy_flag;
  50 bool g_playback_toggle_flag;
  51 bool g_eos_flag;
  52 signed int g_roll;
  53 unsigned int g_goto;
  54
  55 struct playlist_entry
  56 {
  57   struct list_head siblings;
  58   char * song_name_ptr;
  59   char * song_filename_ptr;
  60   int intro_silence;
  61 };
  62
  63 struct list_head g_playlist;
  64
  65 struct playlist_entry * g_current_song_ptr;
  66
  67 void
  68 playlist_free()
  69 {
  70   struct list_head * node_ptr;
  71   struct playlist_entry * entry_ptr;
  72
  73   DEBUG_OUT("playlist_free() called.");
  74
  75   while (!list_empty(&g_playlist))
  76   {
  77     node_ptr = g_playlist.next;
  78
  79     list_del(node_ptr);
  80
  81     entry_ptr = list_entry(node_ptr, struct playlist_entry, siblings);
  82
  83     free(entry_ptr->song_name_ptr);
  84
  85     free(entry_ptr->song_filename_ptr);
  86
  87     free(entry_ptr);
  88   }
  89 }
  90
  91 void
  92 playlist_display()
  93 {
  94   struct list_head * node_ptr;
  95   struct playlist_entry * entry_ptr;
  96   int i;
  97
  98   OUTPUT_MESSAGE("-------- Playlist ---------");
  99
 100   i = 0;
 101
 102   list_for_each(node_ptr, &g_playlist)
 103   {
 104     entry_ptr = list_entry(node_ptr, struct playlist_entry, siblings);
 105
 106     if (entry_ptr->intro_silence != 0)
 107     {
 108       OUTPUT_MESSAGE("%02i - %s (%d seconds intro silence)", i+1, entry_ptr->song_name_ptr, entry_ptr->intro_silence);
 109     }
 110     else
 111     {
 112       OUTPUT_MESSAGE("%02i - %s", i+1, entry_ptr->song_name_ptr);
 113     }
 114
 115     i++;
 116   }
 117
 118   OUTPUT_MESSAGE("------------------");
 119 }
 120
 121 int
 122 playlist_build(const char * playlist_filename_ptr)
 123 {
 124   int ret;
 125   xmlDocPtr doc_ptr;
 126   xmlXPathContextPtr xpath_ctx_ptr;
 127   xmlXPathObjectPtr xpath_obj_ptr;
 128   xmlXPathObjectPtr xpath_obj2_ptr;
 129   xmlBufferPtr content_buffer_ptr;
 130   int i;
 131   char * playlist_name_ptr;
 132   char * playlist_filename_copy_ptr;
 133   const char * playlist_dirname_ptr;
 134   size_t playlist_dirname_size;
 135   struct playlist_entry * entry_ptr;
 136   const char * song_filename_ptr;
 137   size_t temp_size;
 138   int intro_silence;
 139   char xpath[1000];
 140
 141   DEBUG_OUT("Loading playlist from \"%s\"", playlist_filename_ptr);
 142
 143   INIT_LIST_HEAD(&g_playlist);
 144
 145   playlist_filename_copy_ptr = strdup(playlist_filename_ptr);
 146   if (playlist_filename_copy_ptr == NULL)
 147   {
 148     ERROR_OUT("strdup() failed");
 149     ret = -1;
 150     goto exit;
 151   }
 152
 153   playlist_dirname_ptr = dirname(playlist_filename_copy_ptr);
 154
 155   DEBUG_OUT("playlist dirname is \"%s\"", playlist_dirname_ptr);
 156
 157   playlist_dirname_size = strlen(playlist_dirname_ptr);
 158
 159   doc_ptr = xmlParseFile(playlist_filename_ptr);
 160   if (doc_ptr == NULL)
 161   {
 162     ERROR_OUT("Failed to parse playlist \"%s\"", playlist_filename_ptr);
 163     ret = -1;
 164     goto free_playlist_filename_copy;
 165   }
 166
 167   /* Create xpath evaluation context */
 168   xpath_ctx_ptr = xmlXPathNewContext(doc_ptr);
 169   if (xpath_ctx_ptr == NULL)
 170   {
 171     ERROR_OUT("Unable to create new XPath context");
 172     ret = -1;
 173     goto free_doc;
 174   }
 175
 176   /* Evaluate xpath expression */
 177   xpath_obj_ptr = xmlXPathEvalExpression((const xmlChar *)XPATH_SONG_PATH_EXPRESSION, xpath_ctx_ptr);
 178   if (xpath_obj_ptr == NULL)
 179   {
 180     ERROR_OUT("Unable to evaluate XPath expression \"%s\"", XPATH_SONG_PATH_EXPRESSION);
 181     ret = -1;
 182     goto free_xpath_ctx;
 183   }
 184
 185   if (xpath_obj_ptr->nodesetval == NULL || xpath_obj_ptr->nodesetval->nodeNr == 0)
 186   {
 187     ERROR_OUT("XPath \"%s\" evaluation returned no data", XPATH_SONG_PATH_EXPRESSION);
 188     ret = -1;
 189     goto free_xpath_obj;
 190   }
 191
 192   content_buffer_ptr = xmlBufferCreate();
 193   if (content_buffer_ptr == NULL)
 194   {
 195     ERROR_OUT("xmlBufferCreate() failed.");
 196     ret = -1;
 197     goto free_xpath_obj;
 198   }
 199
 200   ret = xml_get_string_dup(doc_ptr, "/playlist/name", &playlist_name_ptr);
 201   if (ret != 0)
 202   {
 203     ERROR_OUT("xml_get_string_dup() failed. Cannot get playlist name (%d)", ret);
 204     ret = -1;
 205     goto free_buffer;
 206   }
 207
 208   OUTPUT_MESSAGE("-------- Playlist \"%s\" ---------", playlist_name_ptr);
 209
 210   for (i = 0 ; i < xpath_obj_ptr->nodesetval->nodeNr ; i++)
 211   {
 212     //DEBUG_OUT("song at index %d", i);
 213
 214     {
 215       intro_silence = 0;
 216
 217       sprintf(xpath, "/playlist/song[%d]/intro_silence", i + 1);
 218
 219       /* Evaluate xpath expression */
 220       xpath_obj2_ptr = xmlXPathEvalExpression((const xmlChar *)xpath, xpath_ctx_ptr);
 221       if (xpath_obj2_ptr == NULL)
 222       {
 223         ERROR_OUT("Unable to evaluate xpath expression for selecting intro_silence");
 224       }
 225       else
 226       {
 227         if (xpath_obj2_ptr->nodesetval == NULL || xpath_obj2_ptr->nodesetval->nodeNr == 0)
 228         {
 229           DEBUG_OUT("XPath evaluation returned no data (%s)", xpath);
 230         }
 231         else if (xpath_obj2_ptr->nodesetval->nodeNr != 1)
 232         {
 233           ERROR_OUT("XPath evaluation returned too many data");
 234         }
 235         else
 236         {
 237           ret = xmlNodeBufGetContent(content_buffer_ptr, xpath_obj2_ptr->nodesetval->nodeTab[0]);
 238           if (ret != 0)
 239           {
 240             ERROR_OUT("xmlNodeBufGetContent() failed. (%d)", ret);
 241           }
 242           else
 243           {
 244             DEBUG_OUT("Intro silence is %s seconds", (const char *)xmlBufferContent(content_buffer_ptr));
 245             intro_silence = atoi((const char *)xmlBufferContent(content_buffer_ptr));
 246             if (intro_silence < 0)
 247             {
 248               intro_silence = 0;
 249             }
 250           }
 251
 252           xmlBufferEmpty(content_buffer_ptr);
 253         }
 254       }
 255     }
 256
 257     ret = xmlNodeBufGetContent(content_buffer_ptr, xpath_obj_ptr->nodesetval->nodeTab[i]);
 258     if (ret != 0)
 259     {
 260       ERROR_OUT("xmlNodeBufGetContent() failed. (%d)", ret);
 261       ret = -1;
 262       goto free_playlist;
 263     }
 264
 265     entry_ptr = (struct playlist_entry *)malloc(sizeof(struct playlist_entry));
 266     if (entry_ptr == NULL)
 267     {
 268       ERROR_OUT("malloc() failed.");
 269       ret = -1;
 270       goto free_playlist;
 271     }
 272
 273     entry_ptr->intro_silence = intro_silence;
 274
 275     song_filename_ptr = (const char *)xmlBufferContent(content_buffer_ptr);
 276     DEBUG_OUT("Song filename \"%s\"", song_filename_ptr);
 277     temp_size = xmlBufferLength(content_buffer_ptr);
 278
 279     entry_ptr->song_filename_ptr = (char *)malloc(playlist_dirname_size + 1 + temp_size + 1);
 280     if (entry_ptr->song_filename_ptr == NULL)
 281     {
 282       ERROR_OUT("malloc() failed.");
 283       ret = -1;
 284       goto free_entry;
 285     }
 286
 287     memcpy(entry_ptr->song_filename_ptr, playlist_dirname_ptr, playlist_dirname_size);
 288     entry_ptr->song_filename_ptr[playlist_dirname_size] = '/';
 289     memcpy(entry_ptr->song_filename_ptr + playlist_dirname_size + 1, song_filename_ptr, temp_size);
 290     entry_ptr->song_filename_ptr[playlist_dirname_size + 1 + temp_size] = 0;
 291
 292     xmlBufferEmpty(content_buffer_ptr);
 293
 294     path_normalize(entry_ptr->song_filename_ptr);
 295
 296     ret = get_song_name(entry_ptr->song_filename_ptr, &entry_ptr->song_name_ptr);
 297     if (ret != 0)
 298     {
 299       ERROR_OUT("Cannot get song name from \"%s\"", xmlBufferContent(content_buffer_ptr));
 300       ret = -1;
 301       goto free_song_filename;
 302     }
 303
 304     if (entry_ptr->intro_silence != 0)
 305     {
 306       OUTPUT_MESSAGE("%02i - %s (%d seconds intro silence)", i+1, entry_ptr->song_name_ptr, entry_ptr->intro_silence);
 307     }
 308     else
 309     {
 310       OUTPUT_MESSAGE("%02i - %s", i+1, entry_ptr->song_name_ptr);
 311     }
 312
 313     list_add_tail(&entry_ptr->siblings, &g_playlist);
 314   }
 315
 316   OUTPUT_MESSAGE("------------------");
 317
 318   if (list_empty(&g_playlist))
 319   {
 320     ERROR_OUT("There is no point to play empty playlist");
 321     ret = -1;
 322     goto free_playlist;
 323   }
 324
 325   /* Make first song current */
 326   g_current_song_ptr = list_entry(g_playlist.next, struct playlist_entry, siblings);
 327
 328   ret = 0;
 329   goto free_playlist_name;
 330
 331 free_song_filename:
 332   free(entry_ptr->song_filename_ptr);
 333
 334 free_entry:
 335   free(entry_ptr);
 336
 337 free_playlist:
 338   playlist_free();
 339
 340 free_playlist_name:
 341   free(playlist_name_ptr);
 342
 343 free_buffer:
 344   xmlBufferFree(content_buffer_ptr);
 345
 346 free_xpath_obj:
 347   xmlXPathFreeObject(xpath_obj_ptr);
 348
 349 free_xpath_ctx:
 350   xmlXPathFreeContext(xpath_ctx_ptr);
 351
 352 free_doc:
 353   xmlFreeDoc(doc_ptr);
 354
 355 free_playlist_filename_copy:
 356   free(playlist_filename_copy_ptr);
 357 exit:
 358   return ret;
 359 }
 360
 361 void
 362 end_of_song_callback()
 363 {
 364   NOTICE_OUT("End of song");
 365   pthread_mutex_lock(&g_playback_mutex);
 366   g_eos_flag = true;
 367   pthread_cond_signal(&g_playback_cond);
 368   pthread_mutex_unlock(&g_playback_mutex);
 369 }
 370
 371 void * playback_thread(void * context)
 372 {
 373   int ret;
 374   bool playback_toggle_flag = !g_playback_toggle_flag;
 375   bool playing_flag = false;
 376   bool song_changed;
 377   struct list_head * node_ptr;
 378   unsigned int index;
 379   bool acted;
 380   int silence_counter;
 381
 382   pthread_mutex_lock(&g_playback_mutex);
 383 loop:
 384   acted = false;
 385
 386   if (g_destroy_flag)
 387   {
 388     pthread_mutex_unlock(&g_playback_mutex);
 389     goto exit;
 390   }
 391
 392   if (g_eos_flag)
 393   {
 394     g_eos_flag = false;
 395     pthread_mutex_unlock(&g_playback_mutex);
 396     DEBUG_OUT("End of song detected.");
 397     end_song();
 398     playing_flag = false;
 399     pthread_mutex_lock(&g_playback_mutex);
 400     acted = true;
 401
 402     if (g_current_song_ptr->siblings.next != &g_playlist)
 403     {
 404       OUTPUT_MESSAGE("End of song, moving to next in playlist.");
 405       g_current_song_ptr = list_entry(g_current_song_ptr->siblings.next, struct playlist_entry, siblings);
 406       goto play;
 407     }
 408     else
 409     {
 410       OUTPUT_MESSAGE("End of last song.");
 411     }
 412   }
 413
 414   song_changed = false;
 415
 416   if (g_goto > 0)
 417   {
 418     index = 0;
 419
 420     list_for_each(node_ptr, &g_playlist)
 421     {
 422       index++;
 423
 424       if (index == g_goto)
 425       {
 426         g_current_song_ptr = list_entry(node_ptr, struct playlist_entry, siblings);
 427         song_changed = true;
 428         break;
 429       }
 430     }
 431
 432     if (!song_changed)
 433     {
 434       ERROR_OUT("there is no song %u (ignoring goto)", g_goto);
 435     }
 436
 437     g_goto = 0;
 438   }
 439
 440   if (g_roll > 0)
 441   {
 442     while (g_roll > 0 && g_current_song_ptr->siblings.next != &g_playlist)
 443     {
 444       g_current_song_ptr = list_entry(g_current_song_ptr->siblings.next, struct playlist_entry, siblings);
 445       g_roll--;
 446       song_changed = true;
 447     }
 448
 449     g_roll = 0;
 450   }
 451   else if (g_roll < 0)
 452   {
 453     while (g_roll < 0 && g_current_song_ptr->siblings.prev != &g_playlist)
 454     {
 455       g_current_song_ptr = list_entry(g_current_song_ptr->siblings.prev, struct playlist_entry, siblings);
 456       g_roll++;
 457       song_changed = true;
 458     }
 459
 460     g_roll = 0;
 461   }
 462
 463   if (song_changed)
 464   {
 465     OUTPUT_MESSAGE("Current song changed to \"%s\"", g_current_song_ptr->song_name_ptr);
 466
 467     if (playing_flag)
 468     {
 469       pthread_mutex_unlock(&g_playback_mutex);
 470       DEBUG_OUT("Stopping because current song changed.");
 471       end_song();
 472       playing_flag = false;
 473       playback_toggle_flag = !g_playback_toggle_flag; /* schedule play after song change */
 474       pthread_mutex_lock(&g_playback_mutex);
 475       acted = true;
 476     }
 477   }
 478
 479   if (g_playback_toggle_flag != playback_toggle_flag)
 480   {
 481     DEBUG_OUT("Playback toggle detected.");
 482   play:
 483     acted = true;
 484     playback_toggle_flag = g_playback_toggle_flag;
 485     pthread_mutex_unlock(&g_playback_mutex);
 486
 487     if (playing_flag)
 488     {
 489       DEBUG_OUT("Ending playback.");
 490       end_song();
 491       playing_flag = false;
 492     }
 493     else
 494     {
 495       if (g_current_song_ptr->intro_silence != 0)
 496       {
 497         OUTPUT_MESSAGE("Intro silence %d seconds...", g_current_song_ptr->intro_silence);
 498         silence_counter = g_current_song_ptr->intro_silence;
 499         while (silence_counter != 0)
 500         {
 501           sleep(1);
 502           if (g_playback_toggle_flag != playback_toggle_flag ||
 503               g_goto != 0 ||
 504               g_roll != 0 ||
 505               g_destroy_flag)
 506           {
 507             OUTPUT_MESSAGE("Canceling intro silence.");
 508             pthread_mutex_lock(&g_playback_mutex);
 509             goto loop;
 510           }
 511           silence_counter--;
 512           DEBUG_OUT("Intro silence: tick");
 513         }
 514       }
 515
 516       DEBUG_OUT("Starting playback of \"%s\"", g_current_song_ptr->song_name_ptr);
 517       ret = play_song(g_current_song_ptr->song_filename_ptr, end_of_song_callback);
 518       if (ret != 0)
 519       {
 520         ERROR_OUT("failed to play song");
 521       }
 522       else
 523       {
 524         playing_flag = true;
 525       }
 526     }
 527
 528     pthread_mutex_lock(&g_playback_mutex);
 529   }
 530
 531   if (!acted)
 532   {
 533     pthread_cond_wait(&g_playback_cond, &g_playback_mutex);
 534   }
 535
 536   goto loop;
 537
 538 exit:
 539   if (playing_flag)
 540   {
 541     DEBUG_OUT("Ending playback.");
 542     end_song();
 543   }
 544
 545   return NULL;
 546 }
 547
 548 int
 549 playback_init(const char * playlist_filename_ptr)
 550 {
 551   int ret, ret1;
 552
 553   /* parse and build playlist */
 554   ret = playlist_build(playlist_filename_ptr);
 555   if (ret != 0)
 556   {
 557     ERROR_OUT("Failed to build playlist");
 558     ret = -1;
 559     goto exit;
 560   }
 561
 562   /* start playback thread */
 563   ret = pthread_mutex_init(&g_playback_mutex, NULL);
 564   if (ret != 0)
 565   {
 566     ERROR_OUT("Failed to init real mask mutex (%d)", ret);
 567     ret = -1;
 568     goto exit_playlist_cleanup;
 569   }
 570
 571   ret = pthread_cond_init(&g_playback_cond, NULL);
 572   if (ret != 0)
 573   {
 574     ERROR_OUT("Failed to init real mask cond (%d)", ret);
 575     ret = -1;
 576     goto exit_destroy_mutex;
 577   }
 578
 579   ret = pthread_create(&g_playback_thread, NULL, playback_thread, NULL);
 580   if (ret != 0)
 581   {
 582     ERROR_OUT("Failed to start feed thread (%d)", ret);
 583     ret = -1;
 584     goto exit_destroy_cond;
 585   }
 586
 587   ret = 0;
 588   goto exit;
 589
 590 exit_destroy_cond:
 591   ret1 = pthread_cond_destroy(&g_playback_cond);
 592   if (ret1 != 0)
 593   {
 594     ERROR_OUT("Failed to destroy playback cond (%d)", ret1);
 595   }
 596
 597 exit_destroy_mutex:
 598   ret1 = pthread_mutex_destroy(&g_playback_mutex);
 599   if (ret1 != 0)
 600   {
 601     ERROR_OUT("Failed to destroy playback mutex (%d)", ret1);
 602   }
 603
 604 exit_playlist_cleanup:
 605   playlist_free();
 606
 607 exit:
 608   return ret;
 609 }
 610
 611 void
 612 playback_toggle()
 613 {
 614   pthread_mutex_lock(&g_playback_mutex);
 615   g_playback_toggle_flag = !g_playback_toggle_flag;
 616   pthread_cond_signal(&g_playback_cond);
 617   pthread_mutex_unlock(&g_playback_mutex);
 618 }
 619
 620 void
 621 playback_next()
 622 {
 623   pthread_mutex_lock(&g_playback_mutex);
 624   g_roll++;
 625   pthread_cond_signal(&g_playback_cond);
 626   pthread_mutex_unlock(&g_playback_mutex);
 627 }
 628
 629 void
 630 playback_prev()
 631 {
 632   pthread_mutex_lock(&g_playback_mutex);
 633   g_roll--;
 634   pthread_cond_signal(&g_playback_cond);
 635   pthread_mutex_unlock(&g_playback_mutex);
 636 }
 637
 638 void
 639 playback_goto(unsigned int song)
 640 {
 641   pthread_mutex_lock(&g_playback_mutex);
 642   g_roll = 0;
 643   g_goto = song;
 644   pthread_cond_signal(&g_playback_cond);
 645   pthread_mutex_unlock(&g_playback_mutex);
 646 }
 647
 648 void
 649 playback_destroy()
 650 {
 651   pthread_mutex_lock(&g_playback_mutex);
 652   g_destroy_flag = true;
 653   pthread_cond_signal(&g_playback_cond);
 654   pthread_mutex_unlock(&g_playback_mutex);
 655
 656   pthread_join(g_playback_thread, NULL);
 657
 658   pthread_cond_destroy(&g_playback_cond);
 659   pthread_mutex_destroy(&g_playback_mutex);
 660
 661   playlist_free();
 662 }