src/audioOutputs/audioOutput_shout.c

   1 /* the Music Player Daemon (MPD)
   2  * Copyright (C) 2003-2007 by Warren Dukes (warren.dukes@gmail.com)
   3  * This project's homepage is: http://www.musicpd.org
   4  *
   5  * This program is free software; you can redistribute it and/or modify
   6  * it under the terms of the GNU General Public License as published by
   7  * the Free Software Foundation; either version 2 of the License, or
   8  * (at your option) any later version.
   9  *
  10  * This program is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  * GNU General Public License for more details.
  14  * You should have received a copy of the GNU General Public License
  15  * along with this program; if not, write to the Free Software
  16  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  17  */
  18
  19 #include "../audioOutput.h"
  20
  21 #include <stdlib.h>
  22
  23 #ifdef HAVE_SHOUT
  24
  25 #include "../conf.h"
  26 #include "../log.h"
  27 #include "../pcm_utils.h"
  28 #include "../timer.h"
  29
  30 #include <string.h>
  31 #include <time.h>
  32
  33 #include <shout/shout.h>
  34 #include <vorbis/vorbisenc.h>
  35
  36 #define CONN_ATTEMPT_INTERVAL 60
  37 #define DEFAULT_CONN_TIMEOUT  2
  38
  39 static int shoutInitCount;
  40
  41 /* lots of this code blatantly stolent from bossogg/bossao2 */
  42
  43 typedef struct _ShoutData {
  44         shout_t *shoutConn;
  45         int shoutError;
  46
  47         ogg_stream_state os;
  48         ogg_page og;
  49         ogg_packet op;
  50         ogg_packet header_main;
  51         ogg_packet header_comments;
  52         ogg_packet header_codebooks;
  53
  54         vorbis_dsp_state vd;
  55         vorbis_block vb;
  56         vorbis_info vi;
  57         vorbis_comment vc;
  58
  59         float quality;
  60         int bitrate;
  61
  62         int opened;
  63
  64         MpdTag *tag;
  65         int tagToSend;
  66
  67         int timeout;
  68         int connAttempts;
  69         time_t lastAttempt;
  70
  71         Timer *timer;
  72
  73         /* just a pointer to audioOutput->outAudioFormat */
  74         AudioFormat *audioFormat;
  75 } ShoutData;
  76
  77 static ShoutData *newShoutData(void)
  78 {
  79         ShoutData *ret = xmalloc(sizeof(ShoutData));
  80
  81         ret->shoutConn = shout_new();
  82         ret->opened = 0;
  83         ret->tag = NULL;
  84         ret->tagToSend = 0;
  85         ret->bitrate = -1;
  86         ret->quality = -2.0;
  87         ret->timeout = DEFAULT_CONN_TIMEOUT;
  88         ret->connAttempts = 0;
  89         ret->lastAttempt = 0;
  90         ret->audioFormat = NULL;
  91         ret->timer = NULL;
  92
  93         return ret;
  94 }
  95
  96 static void freeShoutData(ShoutData * sd)
  97 {
  98         if (sd->shoutConn)
  99                 shout_free(sd->shoutConn);
 100         if (sd->tag)
 101                 freeMpdTag(sd->tag);
 102         if (sd->timer)
 103                 timer_free(sd->timer);
 104
 105         free(sd);
 106 }
 107
 108 #define checkBlockParam(name) { \
 109         blockParam = getBlockParam(param, name); \
 110         if (!blockParam) { \
 111                 FATAL("no \"%s\" defined for shout device defined at line " \
 112                                 "%i\n", name, param->line); \
 113         } \
 114 }
 115
 116 static int myShout_initDriver(AudioOutput * audioOutput, ConfigParam * param)
 117 {
 118         ShoutData *sd;
 119         char *test;
 120         int port;
 121         char *host;
 122         char *mount;
 123         char *passwd;
 124         char *user;
 125         char *name;
 126         BlockParam *blockParam;
 127         unsigned int public = 0;
 128
 129         sd = newShoutData();
 130
 131         if (shoutInitCount == 0)
 132                 shout_init();
 133
 134         shoutInitCount++;
 135
 136         checkBlockParam("host");
 137         host = blockParam->value;
 138
 139         checkBlockParam("mount");
 140         mount = blockParam->value;
 141
 142         checkBlockParam("port");
 143
 144         port = strtol(blockParam->value, &test, 10);
 145
 146         if (*test != '\0' || port <= 0) {
 147                 FATAL("shout port \"%s\" is not a positive integer, line %i\n",
 148                       blockParam->value, blockParam->line);
 149         }
 150
 151         checkBlockParam("password");
 152         passwd = blockParam->value;
 153
 154         checkBlockParam("name");
 155         name = blockParam->value;
 156
 157         blockParam = getBlockParam(param, "public");
 158         if (blockParam) {
 159                 if (0 == strcmp(blockParam->value, "yes")) {
 160                         public = 1;
 161                 } else if (0 == strcmp(blockParam->value, "no")) {
 162                         public = 0;
 163                 } else {
 164                         FATAL("public \"%s\" is not \"yes\" or \"no\" at line "
 165                               "%i\n", param->value, param->line);
 166                 }
 167         }
 168
 169         blockParam = getBlockParam(param, "user");
 170         if (blockParam)
 171                 user = blockParam->value;
 172         else
 173                 user = "source";
 174
 175         blockParam = getBlockParam(param, "quality");
 176
 177         if (blockParam) {
 178                 int line = blockParam->line;
 179
 180                 sd->quality = strtod(blockParam->value, &test);
 181
 182                 if (*test != '\0' || sd->quality < -1.0 || sd->quality > 10.0) {
 183                         FATAL("shout quality \"%s\" is not a number in the "
 184                               "range -1 to 10, line %i\n", blockParam->value,
 185                               blockParam->line);
 186                 }
 187
 188                 blockParam = getBlockParam(param, "bitrate");
 189
 190                 if (blockParam) {
 191                         FATAL("quality (line %i) and bitrate (line %i) are "
 192                               "both defined for shout output\n", line,
 193                               blockParam->line);
 194                 }
 195         } else {
 196                 blockParam = getBlockParam(param, "bitrate");
 197
 198                 if (!blockParam) {
 199                         FATAL("neither bitrate nor quality defined for shout "
 200                               "output at line %i\n", param->line);
 201                 }
 202
 203                 sd->bitrate = strtol(blockParam->value, &test, 10);
 204
 205                 if (*test != '\0' || sd->bitrate <= 0) {
 206                         FATAL("bitrate at line %i should be a positive integer "
 207                               "\n", blockParam->line);
 208                 }
 209         }
 210
 211         checkBlockParam("format");
 212         sd->audioFormat = &audioOutput->outAudioFormat;
 213
 214         if (shout_set_host(sd->shoutConn, host) != SHOUTERR_SUCCESS ||
 215             shout_set_port(sd->shoutConn, port) != SHOUTERR_SUCCESS ||
 216             shout_set_password(sd->shoutConn, passwd) != SHOUTERR_SUCCESS ||
 217             shout_set_mount(sd->shoutConn, mount) != SHOUTERR_SUCCESS ||
 218             shout_set_name(sd->shoutConn, name) != SHOUTERR_SUCCESS ||
 219             shout_set_user(sd->shoutConn, user) != SHOUTERR_SUCCESS ||
 220             shout_set_public(sd->shoutConn, public) != SHOUTERR_SUCCESS ||
 221             shout_set_nonblocking(sd->shoutConn, 1) != SHOUTERR_SUCCESS ||
 222             shout_set_format(sd->shoutConn, SHOUT_FORMAT_VORBIS)
 223             != SHOUTERR_SUCCESS ||
 224             shout_set_protocol(sd->shoutConn, SHOUT_PROTOCOL_HTTP)
 225             != SHOUTERR_SUCCESS ||
 226             shout_set_agent(sd->shoutConn, "MPD") != SHOUTERR_SUCCESS) {
 227                 FATAL("error configuring shout defined at line %i: %s\n",
 228                       param->line, shout_get_error(sd->shoutConn));
 229         }
 230
 231         /* optional paramters */
 232         blockParam = getBlockParam(param, "timeout");
 233         if (blockParam) {
 234                 sd->timeout = strtod(blockParam->value, &test);
 235                 if (*test != '\0' || sd->timeout <= 0) {
 236                         FATAL("shout timeout is not a positive integer, "
 237                               "line %i\n", blockParam->line);
 238                 }
 239         }
 240
 241         blockParam = getBlockParam(param, "genre");
 242         if (blockParam && shout_set_genre(sd->shoutConn, blockParam->value)) {
 243                 FATAL("error configuring shout defined at line %i: %s\n",
 244                       param->line, shout_get_error(sd->shoutConn));
 245         }
 246
 247         blockParam = getBlockParam(param, "description");
 248         if (blockParam && shout_set_description(sd->shoutConn,
 249                                                 blockParam->value)) {
 250                 FATAL("error configuring shout defined at line %i: %s\n",
 251                       param->line, shout_get_error(sd->shoutConn));
 252         }
 253
 254         {
 255                 char temp[11];
 256                 memset(temp, 0, sizeof(temp));
 257
 258                 snprintf(temp, sizeof(temp), "%d", sd->audioFormat->channels);
 259                 shout_set_audio_info(sd->shoutConn, SHOUT_AI_CHANNELS, temp);
 260
 261                 snprintf(temp, sizeof(temp), "%d", sd->audioFormat->sampleRate);
 262
 263                 shout_set_audio_info(sd->shoutConn, SHOUT_AI_SAMPLERATE, temp);
 264
 265                 if (sd->quality >= -1.0) {
 266                         snprintf(temp, sizeof(temp), "%2.2f", sd->quality);
 267                         shout_set_audio_info(sd->shoutConn, SHOUT_AI_QUALITY,
 268                                              temp);
 269                 } else {
 270                         snprintf(temp, sizeof(temp), "%d", sd->bitrate);
 271                         shout_set_audio_info(sd->shoutConn, SHOUT_AI_BITRATE,
 272                                              temp);
 273                 }
 274         }
 275
 276         audioOutput->data = sd;
 277
 278         return 0;
 279 }
 280
 281 static int myShout_handleError(ShoutData * sd, int err)
 282 {
 283         switch (err) {
 284         case SHOUTERR_SUCCESS:
 285                 break;
 286         case SHOUTERR_UNCONNECTED:
 287         case SHOUTERR_SOCKET:
 288                 ERROR("Lost shout connection to %s:%i: %s\n",
 289                       shout_get_host(sd->shoutConn),
 290                       shout_get_port(sd->shoutConn),
 291                       shout_get_error(sd->shoutConn));
 292                 sd->shoutError = 1;
 293                 return -1;
 294         default:
 295                 ERROR("shout: connection to %s:%i error: %s\n",
 296                       shout_get_host(sd->shoutConn),
 297                       shout_get_port(sd->shoutConn),
 298                       shout_get_error(sd->shoutConn));
 299                 sd->shoutError = 1;
 300                 return -1;
 301         }
 302
 303         return 0;
 304 }
 305
 306 static int write_page(ShoutData * sd)
 307 {
 308         int err = 0;
 309
 310         shout_sync(sd->shoutConn);
 311         err = shout_send(sd->shoutConn, sd->og.header, sd->og.header_len);
 312         if (myShout_handleError(sd, err) < 0)
 313                 return -1;
 314         err = shout_send(sd->shoutConn, sd->og.body, sd->og.body_len);
 315         if (myShout_handleError(sd, err) < 0)
 316                 return -1;
 317
 318         return 0;
 319 }
 320
 321 static void finishEncoder(ShoutData * sd)
 322 {
 323         vorbis_analysis_wrote(&sd->vd, 0);
 324
 325         while (vorbis_analysis_blockout(&sd->vd, &sd->vb) == 1) {
 326                 vorbis_analysis(&sd->vb, NULL);
 327                 vorbis_bitrate_addblock(&sd->vb);
 328                 while (vorbis_bitrate_flushpacket(&sd->vd, &sd->op)) {
 329                         ogg_stream_packetin(&sd->os, &sd->op);
 330                 }
 331         }
 332 }
 333
 334 static int flushEncoder(ShoutData * sd)
 335 {
 336         return (ogg_stream_pageout(&sd->os, &sd->og) > 0);
 337 }
 338
 339 static void clearEncoder(ShoutData * sd)
 340 {
 341         finishEncoder(sd);
 342         while (1 == flushEncoder(sd)) {
 343                 if (!sd->shoutError)
 344                         write_page(sd);
 345         }
 346
 347         vorbis_comment_clear(&sd->vc);
 348         ogg_stream_clear(&sd->os);
 349         vorbis_block_clear(&sd->vb);
 350         vorbis_dsp_clear(&sd->vd);
 351         vorbis_info_clear(&sd->vi);
 352 }
 353
 354 static void myShout_closeShoutConn(ShoutData * sd)
 355 {
 356         if (sd->opened)
 357                 clearEncoder(sd);
 358
 359         if (shout_get_connected(sd->shoutConn) != SHOUTERR_UNCONNECTED &&
 360             shout_close(sd->shoutConn) != SHOUTERR_SUCCESS) {
 361                 ERROR("problem closing connection to shout server: %s\n",
 362                       shout_get_error(sd->shoutConn));
 363         }
 364
 365         sd->opened = 0;
 366 }
 367
 368 static void myShout_finishDriver(AudioOutput * audioOutput)
 369 {
 370         ShoutData *sd = (ShoutData *) audioOutput->data;
 371
 372         myShout_closeShoutConn(sd);
 373
 374         freeShoutData(sd);
 375
 376         shoutInitCount--;
 377
 378         if (shoutInitCount == 0)
 379                 shout_shutdown();
 380 }
 381
 382 static void myShout_dropBufferedAudio(AudioOutput * audioOutput)
 383 {
 384         ShoutData *sd = (ShoutData *)audioOutput->data;
 385         timer_reset(sd->timer);
 386
 387         /* needs to be implemented for shout */
 388 }
 389
 390 static void myShout_closeDevice(AudioOutput * audioOutput)
 391 {
 392         ShoutData *sd = (ShoutData *) audioOutput->data;
 393
 394         myShout_closeShoutConn(sd);
 395
 396         if (sd->timer) {
 397                 timer_free(sd->timer);
 398                 sd->timer = NULL;
 399         }
 400
 401         audioOutput->open = 0;
 402 }
 403
 404 #define addTag(name, value) { \
 405         if(value) vorbis_comment_add_tag(&(sd->vc), name, value); \
 406 }
 407
 408 static void copyTagToVorbisComment(ShoutData * sd)
 409 {
 410         if (sd->tag) {
 411                 int i;
 412
 413                 for (i = 0; i < sd->tag->numOfItems; i++) {
 414                         switch (sd->tag->items[i].type) {
 415                         case TAG_ITEM_ARTIST:
 416                                 addTag("ARTIST", sd->tag->items[i].value);
 417                                 break;
 418                         case TAG_ITEM_ALBUM:
 419                                 addTag("ALBUM", sd->tag->items[i].value);
 420                                 break;
 421                         case TAG_ITEM_TITLE:
 422                                 addTag("TITLE", sd->tag->items[i].value);
 423                                 break;
 424                         }
 425                 }
 426         }
 427 }
 428
 429 static int initEncoder(ShoutData * sd)
 430 {
 431         vorbis_info_init(&(sd->vi));
 432
 433         if (sd->quality >= -1.0) {
 434                 if (0 != vorbis_encode_init_vbr(&(sd->vi),
 435                                                 sd->audioFormat->channels,
 436                                                 sd->audioFormat->sampleRate,
 437                                                 sd->quality * 0.1)) {
 438                         ERROR("problem setting up vorbis encoder for shout\n");
 439                         vorbis_info_clear(&(sd->vi));
 440                         return -1;
 441                 }
 442         } else {
 443                 if (0 != vorbis_encode_init(&(sd->vi),
 444                                             sd->audioFormat->channels,
 445                                             sd->audioFormat->sampleRate, -1.0,
 446                                             sd->bitrate * 1000, -1.0)) {
 447                         ERROR("problem setting up vorbis encoder for shout\n");
 448                         vorbis_info_clear(&(sd->vi));
 449                         return -1;
 450                 }
 451         }
 452
 453         vorbis_analysis_init(&(sd->vd), &(sd->vi));
 454         vorbis_block_init(&(sd->vd), &(sd->vb));
 455
 456         ogg_stream_init(&(sd->os), rand());
 457
 458         vorbis_comment_init(&(sd->vc));
 459
 460         return 0;
 461 }
 462
 463 static int myShout_connect(ShoutData *sd)
 464 {
 465         time_t t = time(NULL);
 466         int state = shout_get_connected(sd->shoutConn);
 467
 468         /* already connected */
 469         if (state == SHOUTERR_CONNECTED)
 470                 return 0;
 471
 472         /* waiting to connect */
 473         if (state == SHOUTERR_BUSY && sd->connAttempts != 0) {
 474                 /* timeout waiting to connect */
 475                 if ((t - sd->lastAttempt) > sd->timeout) {
 476                         ERROR("timeout connecting to shout server %s:%i "
 477                               "(attempt %i)\n",
 478                               shout_get_host(sd->shoutConn),
 479                               shout_get_port(sd->shoutConn),
 480                               sd->connAttempts);
 481                         return -1;
 482                 }
 483
 484                 return 1;
 485         }
 486
 487         /* we're in some funky state, so just reset it to unconnected */
 488         if (state != SHOUTERR_UNCONNECTED)
 489                 shout_close(sd->shoutConn);
 490
 491         /* throttle new connection attempts */
 492         if (sd->connAttempts != 0 &&
 493             (t - sd->lastAttempt) <= CONN_ATTEMPT_INTERVAL) {
 494                 return -1;
 495         }
 496
 497         /* initiate a new connection */
 498
 499         sd->connAttempts++;
 500         sd->lastAttempt = t;
 501
 502         state = shout_open(sd->shoutConn);
 503         switch (state) {
 504         case SHOUTERR_SUCCESS:
 505         case SHOUTERR_CONNECTED:
 506                 return 0;
 507         case SHOUTERR_BUSY:
 508                 return 1;
 509         default:
 510                 ERROR("problem opening connection to shout server %s:%i "
 511                       "(attempt %i): %s\n",
 512                       shout_get_host(sd->shoutConn),
 513                       shout_get_port(sd->shoutConn),
 514                       sd->connAttempts, shout_get_error(sd->shoutConn));
 515                 return -1;
 516         }
 517 }
 518
 519 static int myShout_openShoutConn(AudioOutput * audioOutput)
 520 {
 521         ShoutData *sd = (ShoutData *) audioOutput->data;
 522         int status;
 523
 524         status = myShout_connect(sd);
 525         if (status != 0)
 526                 return status;
 527
 528         if (initEncoder(sd) < 0) {
 529                 shout_close(sd->shoutConn);
 530                 return -1;
 531         }
 532
 533         sd->shoutError = 0;
 534
 535         copyTagToVorbisComment(sd);
 536
 537         vorbis_analysis_headerout(&(sd->vd), &(sd->vc), &(sd->header_main),
 538                                   &(sd->header_comments),
 539                                   &(sd->header_codebooks));
 540
 541         ogg_stream_packetin(&(sd->os), &(sd->header_main));
 542         ogg_stream_packetin(&(sd->os), &(sd->header_comments));
 543         ogg_stream_packetin(&(sd->os), &(sd->header_codebooks));
 544
 545         sd->opened = 1;
 546         sd->tagToSend = 0;
 547
 548         while (ogg_stream_flush(&(sd->os), &(sd->og))) {
 549                 if (write_page(sd) < 0) {
 550                         myShout_closeShoutConn(sd);
 551                         return -1;
 552                 }
 553         }
 554
 555         sd->connAttempts = 0;
 556
 557         return 0;
 558 }
 559
 560 static int myShout_openDevice(AudioOutput * audioOutput)
 561 {
 562         ShoutData *sd = (ShoutData *) audioOutput->data;
 563
 564         if (!sd->opened && myShout_openShoutConn(audioOutput) < 0)
 565                 return -1;
 566
 567         if (sd->timer)
 568                 timer_free(sd->timer);
 569
 570         sd->timer = timer_new(&audioOutput->outAudioFormat);
 571
 572         audioOutput->open = 1;
 573
 574         return 0;
 575 }
 576
 577 static void myShout_sendMetadata(ShoutData * sd)
 578 {
 579         if (!sd->opened || !sd->tag)
 580                 return;
 581
 582         clearEncoder(sd);
 583         if (initEncoder(sd) < 0)
 584                 return;
 585
 586         copyTagToVorbisComment(sd);
 587
 588         vorbis_analysis_headerout(&(sd->vd), &(sd->vc), &(sd->header_main),
 589                                   &(sd->header_comments),
 590                                   &(sd->header_codebooks));
 591
 592         ogg_stream_packetin(&(sd->os), &(sd->header_main));
 593         ogg_stream_packetin(&(sd->os), &(sd->header_comments));
 594         ogg_stream_packetin(&(sd->os), &(sd->header_codebooks));
 595
 596         while (ogg_stream_flush(&(sd->os), &(sd->og))) {
 597                 if (write_page(sd) < 0) {
 598                         myShout_closeShoutConn(sd);
 599                         return;
 600                 }
 601         }
 602
 603         /*if(sd->tag) freeMpdTag(sd->tag);
 604            sd->tag = NULL; */
 605         sd->tagToSend = 0;
 606 }
 607
 608 static int myShout_play(AudioOutput * audioOutput, char *playChunk, int size)
 609 {
 610         int i, j;
 611         ShoutData *sd = (ShoutData *) audioOutput->data;
 612         float **vorbbuf;
 613         int samples;
 614         int bytes = sd->audioFormat->bits / 8;
 615         int status;
 616
 617         if (!sd->timer->started)
 618                 timer_start(sd->timer);
 619
 620         timer_add(sd->timer, size);
 621
 622         if (sd->opened && sd->tagToSend)
 623                 myShout_sendMetadata(sd);
 624
 625         if (!sd->opened) {
 626                 status = myShout_openShoutConn(audioOutput);
 627                 if (status < 0) {
 628                         myShout_closeDevice(audioOutput);
 629                         return -1;
 630                 } else if (status > 0) {
 631                         timer_sync(sd->timer);
 632                         return 0;
 633                 }
 634         }
 635
 636         samples = size / (bytes * sd->audioFormat->channels);
 637
 638         /* this is for only 16-bit audio */
 639
 640         vorbbuf = vorbis_analysis_buffer(&(sd->vd), samples);
 641
 642         for (i = 0; i < samples; i++) {
 643                 for (j = 0; j < sd->audioFormat->channels; j++) {
 644                         vorbbuf[j][i] = (*((mpd_sint16 *) playChunk)) / 32768.0;
 645                         playChunk += bytes;
 646                 }
 647         }
 648
 649         vorbis_analysis_wrote(&(sd->vd), samples);
 650
 651         while (1 == vorbis_analysis_blockout(&(sd->vd), &(sd->vb))) {
 652                 vorbis_analysis(&(sd->vb), NULL);
 653                 vorbis_bitrate_addblock(&(sd->vb));
 654
 655                 while (vorbis_bitrate_flushpacket(&(sd->vd), &(sd->op))) {
 656                         ogg_stream_packetin(&(sd->os), &(sd->op));
 657                 }
 658         }
 659
 660         while (ogg_stream_pageout(&(sd->os), &(sd->og)) != 0) {
 661                 if (write_page(sd) < 0) {
 662                         myShout_closeDevice(audioOutput);
 663                         return -1;
 664                 }
 665         }
 666
 667         return 0;
 668 }
 669
 670 static void myShout_setTag(AudioOutput * audioOutput, MpdTag * tag)
 671 {
 672         ShoutData *sd = (ShoutData *) audioOutput->data;
 673
 674         if (sd->tag)
 675                 freeMpdTag(sd->tag);
 676         sd->tag = NULL;
 677         sd->tagToSend = 0;
 678
 679         if (!tag)
 680                 return;
 681
 682         sd->tag = mpdTagDup(tag);
 683         sd->tagToSend = 1;
 684 }
 685
 686 AudioOutputPlugin shoutPlugin = {
 687         "shout",
 688         NULL,
 689         myShout_initDriver,
 690         myShout_finishDriver,
 691         myShout_openDevice,
 692         myShout_play,
 693         myShout_dropBufferedAudio,
 694         myShout_closeDevice,
 695         myShout_setTag,
 696 };
 697
 698 #else
 699
 700 DISABLED_AUDIO_OUTPUT_PLUGIN(shoutPlugin)
 701 #endif