apps/plugins/mpegplayer/stream_mgr.c

   1 /***************************************************************************
   2  *             __________               __   ___.
   3  *   Open      \______   \ ____   ____ |  | _\_ |__   _______  ___
   4  *   Source     |       _//  _ \_/ ___\|  |/ /| __ \ /  _ \  \/  /
   5  *   Jukebox    |    |   (  <_> )  \___|    < | \_\ (  <_> > <  <
   6  *   Firmware   |____|_  /\____/ \___  >__|_ \|___  /\____/__/\_ \
   7  *                     \/            \/     \/    \/            \/
   8  * $Id$
   9  *
  10  * AV stream manager implementation
  11  *
  12  * Copyright (c) 2007 Michael Sevakis
  13  *
  14  * This program is free software; you can redistribute it and/or
  15  * modify it under the terms of the GNU General Public License
  16  * as published by the Free Software Foundation; either version 2
  17  * of the License, or (at your option) any later version.
  18  *
  19  * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
  20  * KIND, either express or implied.
  21  *
  22  ****************************************************************************/
  23 #include "plugin.h"
  24 #include "mpegplayer.h"
  25 #include "lib/grey.h"
  26 #include "mpeg_settings.h"
  27
  28 #ifndef HAVE_LCD_COLOR
  29 GREY_INFO_STRUCT_IRAM
  30 #endif
  31
  32 static struct event_queue stream_mgr_queue SHAREDBSS_ATTR;
  33 static struct queue_sender_list stream_mgr_queue_send SHAREDBSS_ATTR;
  34 static uint32_t stream_mgr_thread_stack[DEFAULT_STACK_SIZE*2/sizeof(uint32_t)];
  35
  36 struct stream_mgr stream_mgr SHAREDBSS_ATTR;
  37
  38 /* Forward decs */
  39 static int stream_on_close(void);
  40
  41 struct str_broadcast_data
  42 {
  43     long cmd;       /* Command to send to stream */
  44     intptr_t data;  /* Data to send with command */
  45 };
  46
  47 static inline void stream_mgr_lock(void)
  48 {
  49     rb->mutex_lock(&stream_mgr.str_mtx);
  50 }
  51
  52 static inline void stream_mgr_unlock(void)
  53 {
  54     rb->mutex_unlock(&stream_mgr.str_mtx);
  55 }
  56
  57 static inline void actl_lock(void)
  58 {
  59     rb->mutex_lock(&stream_mgr.actl_mtx);
  60 }
  61
  62 static inline void actl_unlock(void)
  63 {
  64     rb->mutex_unlock(&stream_mgr.actl_mtx);
  65 }
  66
  67 static inline void stream_mgr_post_msg(long id, intptr_t data)
  68 {
  69     rb->queue_post(stream_mgr.q, id, data);
  70 }
  71
  72 static inline intptr_t stream_mgr_send_msg(long id, intptr_t data)
  73 {
  74     return rb->queue_send(stream_mgr.q, id, data);
  75 }
  76
  77 static inline void stream_mgr_reply_msg(intptr_t retval)
  78 {
  79     rb->queue_reply(stream_mgr.q, retval);
  80 }
  81
  82 int str_next_data_not_ready(struct stream *str)
  83 {
  84     /* Save the current window since it actually might be ready by the time
  85      * the registration is received by buffering. */
  86     off_t win_right = str->hdr.win_right;
  87
  88     if (str->hdr.win_right < disk_buf.filesize - MIN_BUFAHEAD &&
  89         disk_buf.filesize > MIN_BUFAHEAD)
  90     {
  91         /* Set right edge to where probing left off + the minimum margin */
  92         str->hdr.win_right += MIN_BUFAHEAD;
  93     }
  94     else
  95     {
  96         /* Request would be passed the end of the file */
  97         str->hdr.win_right = disk_buf.filesize;
  98     }
  99
 100     switch (disk_buf_send_msg(DISK_BUF_DATA_NOTIFY, (intptr_t)str))
 101     {
 102     case DISK_BUF_NOTIFY_OK:
 103         /* Was ready - restore window and process */
 104         str->hdr.win_right = win_right;
 105         return STREAM_OK;
 106
 107     case DISK_BUF_NOTIFY_ERROR:
 108         /* Error - quit parsing */
 109         str_end_of_stream(str);
 110         return STREAM_DATA_END;
 111
 112     default:
 113         /* Not ready - go wait for notification from buffering. */
 114         str->pkt_flags = 0;
 115         return STREAM_DATA_NOT_READY;
 116     }
 117 }
 118
 119 void str_data_notify_received(struct stream *str)
 120 {
 121     /* Normalize win_right back to the packet length */
 122     if (str->state == SSTATE_END)
 123         return;
 124
 125     if (str->curr_packet == NULL)
 126     {
 127         /* Nothing was yet parsed since init */
 128         str->hdr.win_right = str->hdr.win_left;
 129     }
 130     else
 131     {
 132         /* Restore window based upon current packet */
 133         str->hdr.win_right = str->hdr.win_left +
 134             (str->curr_packet_end - str->curr_packet);
 135     }
 136 }
 137
 138 /* Set stream manager to a "no-file" state */
 139 static void stream_mgr_init_state(void)
 140 {
 141     stream_mgr.filename = NULL;
 142     stream_mgr.resume_time = INVALID_TIMESTAMP;
 143     stream_mgr.seeked = false;
 144 }
 145
 146 /* Add a stream to the playback pool */
 147 void stream_add_stream(struct stream *str)
 148 {
 149     actl_lock();
 150
 151     list_remove_item(stream_mgr.strl, str);
 152     list_add_item(stream_mgr.strl, str);
 153
 154     actl_unlock();
 155 }
 156
 157 /* Callback for various list-moving operations */
 158 static bool strl_enum_callback(struct stream *str, intptr_t data)
 159 {
 160     actl_lock();
 161
 162     list_remove_item(stream_mgr.strl, str);
 163
 164     if (data == 1)
 165         list_add_item(stream_mgr.actl, str);
 166
 167     actl_unlock();
 168
 169     return true;
 170 }
 171
 172 /* Clear all streams from active and playback pools */
 173 void stream_remove_streams(void)
 174 {
 175     list_enum_items(stream_mgr.strl,
 176                     (list_enum_callback_t)strl_enum_callback, 0);
 177 }
 178
 179 /* Move the playback pool to the active list */
 180 void move_strl_to_actl(void)
 181 {
 182     list_enum_items(stream_mgr.strl,
 183                     (list_enum_callback_t)strl_enum_callback, 1);
 184 }
 185
 186 /* Remove a stream from the active list and return it to the pool */
 187 static bool actl_stream_remove(struct stream *str)
 188 {
 189     bool retval;
 190
 191     actl_lock();
 192
 193     retval = list_remove_item(stream_mgr.actl, str);
 194
 195     if (retval)
 196         list_add_item(stream_mgr.strl, str);
 197
 198     actl_unlock();
 199
 200     return retval;
 201 }
 202
 203 /* Broadcast a message to all active streams */
 204 static bool actl_stream_broadcast_callback(struct stream *str,
 205                                            struct str_broadcast_data *sbd)
 206 {
 207     switch (sbd->cmd)
 208     {
 209     case STREAM_PLAY:
 210     case STREAM_PAUSE:
 211         break;
 212
 213     case STREAM_STOP:
 214         if (sbd->data != 0)
 215         {
 216             actl_lock();
 217
 218             list_remove_item(stream_mgr.actl, str);
 219             list_add_item(stream_mgr.strl, str);
 220
 221             actl_unlock();
 222             sbd->data = 0;
 223         }
 224         break;
 225
 226     default:
 227         return false;
 228     }
 229
 230     str_send_msg(str, sbd->cmd, sbd->data);
 231     return true;
 232 }
 233
 234 static void actl_stream_broadcast(int cmd, intptr_t data)
 235 {
 236     struct str_broadcast_data sbd;
 237     sbd.cmd = cmd;
 238     sbd.data = data;
 239     list_enum_items(stream_mgr.actl,
 240                     (list_enum_callback_t)actl_stream_broadcast_callback,
 241                     (intptr_t)&sbd);
 242 }
 243
 244 /* Set the current base clock */
 245 static void set_stream_clock(uint32_t time)
 246 {
 247     /* Fudge: Start clock 100ms early to allow for some filling time */
 248     if (time > 100*TS_SECOND/1000)
 249         time -= 100*TS_SECOND/1000;
 250     else
 251         time = 0;
 252
 253     pcm_output_set_clock(TS_TO_TICKS(time));
 254 }
 255
 256 static void stream_start_playback(uint32_t time, bool fill_buffer)
 257 {
 258     if (stream_mgr.seeked)
 259     {
 260         /* Clear any seeked status */
 261         stream_mgr.seeked = false;
 262
 263         /* Flush old PCM data */
 264         pcm_output_flush();
 265
 266         /* Set the master clock */
 267         set_stream_clock(time);
 268
 269         /* Make sure streams are back in active pool */
 270         move_strl_to_actl();
 271
 272         /* Prepare the parser and associated streams */
 273         parser_prepare_streaming();
 274     }
 275
 276     /* Start buffer which optional force fill */
 277     disk_buf_send_msg(STREAM_PLAY, fill_buffer);
 278
 279     /* Tell each stream to start - may generate end of stream signals
 280      * now - we'll handle this when finished */
 281     actl_stream_broadcast(STREAM_PLAY, 0);
 282
 283     /* Actually start the clock */
 284     pcm_output_play_pause(true);
 285 }
 286
 287 /* Return the play time relative to the specified play time */
 288 static uint32_t time_from_whence(uint32_t time, int whence)
 289 {
 290     int64_t currtime;
 291     uint32_t start;
 292
 293     switch (whence)
 294     {
 295     case SEEK_SET:
 296         /* Set the current time (time = unsigned offset from 0) */
 297         if (time > str_parser.duration)
 298             time = str_parser.duration;
 299         break;
 300     case SEEK_CUR:
 301         /* Seek forward or backward from the current time
 302          * (time = signed offset from current) */
 303         currtime = stream_get_seek_time(&start);
 304         currtime -= start;
 305         currtime += (int32_t)time;
 306
 307         if (currtime < 0)
 308             currtime = 0;
 309         else if ((uint64_t)currtime > str_parser.duration)
 310             currtime = str_parser.duration;
 311
 312         time = (uint32_t)currtime;
 313         break;
 314     case SEEK_END:
 315         /* Seek from the end (time = unsigned offset from end) */
 316         if (time > str_parser.duration)
 317             time = str_parser.duration;
 318         time = str_parser.duration - time;
 319         break;
 320     }
 321
 322     return time;
 323 }
 324
 325 /* Handle seeking details if playing or paused */
 326 static uint32_t stream_seek_intl(uint32_t time, int whence,
 327                                  int status, bool *was_buffering)
 328 {
 329     if (status != STREAM_STOPPED)
 330     {
 331         bool wb;
 332
 333         /* Place streams in a non-running state - keep them on actl if
 334          * still there */
 335         actl_stream_broadcast(STREAM_PAUSE, 0);
 336
 337         /* Stop all buffering or else risk clobbering random-access data */
 338         wb = disk_buf_send_msg(STREAM_STOP, 0);
 339
 340         if (was_buffering != NULL)
 341             *was_buffering = wb;
 342     }
 343
 344     time = time_from_whence(time, whence);
 345
 346     stream_mgr.seeked = true;
 347
 348     return parser_seek_time(time);
 349 }
 350
 351 /* Store the resume time at the last seek/current clock point */
 352 static void stream_remember_resume_time(void)
 353 {
 354     /* Assume invalidity */
 355     stream_mgr.resume_time = 0;
 356
 357     if (stream_can_seek())
 358     {
 359         /* Read the current stream time or the last seeked position */
 360         uint32_t start;
 361         uint32_t time = stream_get_seek_time(&start);
 362
 363         if (time >= str_parser.start_pts && time <= str_parser.end_pts)
 364         {
 365             /* Save the current stream time */
 366             stream_mgr.resume_time = time - start;
 367         }
 368     }
 369 }
 370
 371 /* Handle STREAM_OPEN */
 372 void stream_on_open(const char *filename)
 373 {
 374     int err = STREAM_ERROR;
 375
 376     stream_mgr_lock();
 377
 378     trigger_cpu_boost();
 379
 380     /* Open the video file */
 381     if (disk_buf_open(filename) >= 0)
 382     {
 383         /* Initialize the parser */
 384         err = parser_init_stream();
 385
 386         if (err >= STREAM_OK)
 387         {
 388             /* File ok - save the opened filename */
 389             stream_mgr.filename = filename;
 390         }
 391     }
 392
 393     /* If error - cleanup */
 394     if (err < STREAM_OK)
 395         stream_on_close();
 396
 397     cancel_cpu_boost();
 398
 399     stream_mgr_unlock();
 400
 401     stream_mgr_reply_msg(err);
 402 }
 403
 404 /* Handler STREAM_PLAY */
 405 static void stream_on_play(void)
 406 {
 407     int status = stream_mgr.status;
 408
 409     stream_mgr_lock();
 410
 411     if (status == STREAM_STOPPED)
 412     {
 413         uint32_t start;
 414
 415         /* We just say we're playing now */
 416         stream_mgr.status = STREAM_PLAYING;
 417
 418         /* Reply with previous state */
 419         stream_mgr_reply_msg(status);
 420
 421         trigger_cpu_boost();
 422
 423         /* Seek to initial position and set clock to that time */
 424
 425         /* Save the resume time */
 426         stream_remember_resume_time();
 427
 428         /* Prepare seek to start point */
 429         start = stream_seek_intl(stream_mgr.resume_time, SEEK_SET,
 430                                  STREAM_STOPPED, NULL);
 431
 432         /* Sync and start - force buffer fill */
 433         stream_start_playback(start, true);
 434     }
 435     else
 436     {
 437         /* Reply with previous state */
 438         stream_mgr_reply_msg(status);
 439     }
 440
 441     stream_mgr_unlock();
 442 }
 443
 444 /* Handle STREAM_PAUSE */
 445 static void stream_on_pause(void)
 446 {
 447     int status = stream_mgr.status;
 448
 449     stream_mgr_lock();
 450
 451     /* Reply with previous state */
 452     stream_mgr_reply_msg(status);
 453
 454     if (status == STREAM_PLAYING)
 455     {
 456         /* Pause the clock */
 457         pcm_output_play_pause(false);
 458
 459         /* Pause each active stream */
 460         actl_stream_broadcast(STREAM_PAUSE, 0);
 461
 462         /* Pause the disk buffer - buffer may continue filling */
 463         disk_buf_send_msg(STREAM_PAUSE, false);
 464
 465         /* Unboost the CPU */
 466         cancel_cpu_boost();
 467
 468         /* Offically paused */
 469         stream_mgr.status = STREAM_PAUSED;
 470     }
 471
 472     stream_mgr_unlock();
 473 }
 474
 475 /* Handle STREAM_RESUME */
 476 static void stream_on_resume(void)
 477 {
 478     int status = stream_mgr.status;
 479
 480     stream_mgr_lock();
 481
 482     /* Reply with previous state */
 483     stream_mgr_reply_msg(status);
 484
 485     if (status == STREAM_PAUSED)
 486     {
 487         /* Boost the CPU */
 488         trigger_cpu_boost();
 489
 490         /* Sync and start - no force buffering */
 491         stream_start_playback(str_parser.last_seek_time, false);
 492
 493         /* Officially playing */
 494         stream_mgr.status = STREAM_PLAYING;
 495     }
 496
 497     stream_mgr_unlock();
 498 }
 499
 500 /* Handle STREAM_STOP */
 501 static void stream_on_stop(bool reply)
 502 {
 503     int status = stream_mgr.status;
 504
 505     stream_mgr_lock();
 506
 507     if (reply)
 508         stream_mgr_reply_msg(status);
 509
 510     if (status != STREAM_STOPPED)
 511     {
 512         /* Pause the clock */
 513         pcm_output_play_pause(false);
 514
 515         /* Update the resume time info */
 516         stream_remember_resume_time();
 517
 518         /* Not stopped = paused or playing */
 519         stream_mgr.seeked = false;
 520
 521         /* Stop buffering */
 522         disk_buf_send_msg(STREAM_STOP, 0);
 523
 524         /* Clear any still-active streams and remove from actl */
 525         actl_stream_broadcast(STREAM_STOP, 1);
 526
 527         /* Stop PCM output (and clock) */
 528         pcm_output_stop();
 529
 530         /* Cancel our processor boost */
 531         cancel_cpu_boost();
 532
 533         stream_mgr.status = STREAM_STOPPED;
 534     }
 535
 536     stream_mgr_unlock();
 537 }
 538
 539 /* Handle STREAM_SEEK */
 540 static void stream_on_seek(struct stream_seek_data *skd)
 541 {
 542     uint32_t time = skd->time;
 543     int whence = skd->whence;
 544
 545     switch (whence)
 546     {
 547     case SEEK_SET:
 548     case SEEK_CUR:
 549     case SEEK_END:
 550         if (stream_mgr.filename == NULL)
 551             break;
 552
 553         /* Keep things spinning if already doing so */
 554         stream_keep_disk_active();
 555
 556         /* Have data - reply in order to acquire lock */
 557         stream_mgr_reply_msg(STREAM_OK);
 558
 559         stream_mgr_lock();
 560
 561         /* Either seeking must be possible or a full rewind must be done */
 562         if (stream_can_seek() || time_from_whence(time, whence) == 0)
 563         {
 564             bool buffer;
 565
 566             if (stream_mgr.status == STREAM_PLAYING)
 567             {
 568                 /* Keep clock from advancing while seeking */
 569                 pcm_output_play_pause(false);
 570             }
 571
 572             time = stream_seek_intl(time, whence, stream_mgr.status, &buffer);
 573             stream_remember_resume_time();
 574
 575             if (stream_mgr.status == STREAM_PLAYING)
 576             {
 577                 /* Sync and restart - no force buffering */
 578                 stream_start_playback(time, buffer);
 579             }
 580         }
 581
 582         stream_mgr_unlock();
 583         return;
 584     }
 585
 586     /* Invalid parameter or no file */
 587     stream_mgr_reply_msg(STREAM_ERROR);
 588 }
 589
 590 /* Handle STREAM_CLOSE */
 591 static int stream_on_close(void)
 592 {
 593     int status = STREAM_STOPPED;
 594
 595     stream_mgr_lock();
 596
 597     /* Any open file that was accepted for playback? */
 598     if (stream_mgr.filename != NULL)
 599     {
 600         /* Yes - hide video */
 601         stream_show_vo(false);
 602         /* Stop any playback */
 603         status = stream_mgr.status;
 604         stream_on_stop(false);
 605         /* Tell parser file is finished */
 606         parser_close_stream();
 607         /* Reinitialize manager */
 608         stream_mgr_init_state();
 609     }
 610
 611     /* Let disk buffer reset itself - file might be open even if no good */
 612     disk_buf_close();
 613
 614     stream_mgr_unlock();
 615
 616     return status;
 617 }
 618
 619 /* Handle STREAM_EV_COMPLETE */
 620 static void stream_on_ev_complete(struct stream *str)
 621 {
 622     stream_mgr_lock();
 623
 624     /* Stream is active? */
 625     if (actl_stream_remove(str))
 626     {
 627         /* No - remove this stream from the active list */
 628         DEBUGF("  finished: 0x%02x\n", str->id);
 629         if (list_is_empty(stream_mgr.actl))
 630         {
 631             /* All streams have acked - stop playback */
 632             stream_on_stop(false);
 633             stream_mgr.resume_time = 0; /* Played to end - no resume */
 634         }
 635         else
 636         {
 637             /* Stream is done - stop it and place back in pool */
 638             str_send_msg(str, STREAM_STOP, 1);
 639         }
 640     }
 641
 642     stream_mgr_unlock();
 643 }
 644
 645 /* Callback for stream to notify about events internal to them */
 646 void stream_generate_event(struct stream *str, long id, intptr_t data)
 647 {
 648     if (str == NULL)
 649         return;
 650
 651     switch (id)
 652     {
 653     case STREAM_EV_COMPLETE:
 654         /* The last stream has ended */
 655         stream_mgr_post_msg(STREAM_EV_COMPLETE, (intptr_t)str);
 656         break;
 657     }
 658
 659     (void)data;
 660 }
 661
 662 /* Clear any particular notification for which a stream registered */
 663 void stream_clear_notify(struct stream *str, int for_msg)
 664 {
 665     switch (for_msg)
 666     {
 667     case DISK_BUF_DATA_NOTIFY:
 668         disk_buf_send_msg(DISK_BUF_CLEAR_DATA_NOTIFY, (intptr_t)str);
 669         break;
 670     }
 671 }
 672
 673 /* Special handling for certain messages since they involve multiple
 674  * operations behind the scenes */
 675 static intptr_t send_video_msg(long id, intptr_t data)
 676 {
 677     intptr_t retval = 0;
 678
 679     if (video_str.thread != 0 && disk_buf.in_file >= 0)
 680     {
 681
 682         switch (id)
 683         {
 684         case VIDEO_DISPLAY_SHOW:
 685             if (data != 0 && disk_buf_status() == STREAM_STOPPED)
 686             {   /* Only prepare image if showing and not playing */
 687                 parser_prepare_image(str_parser.last_seek_time);
 688             }
 689             break;
 690
 691         case VIDEO_PRINT_FRAME:
 692             if (data)
 693                 break;
 694         case VIDEO_PRINT_THUMBNAIL:
 695             if (disk_buf_status() != STREAM_STOPPED)
 696                 break; /* Prepare image if not playing */
 697
 698             /* Ignore return and try video thread anyway */
 699             parser_prepare_image(str_parser.last_seek_time);
 700
 701             /* Image ready - pass message to video thread */
 702             break;
 703         }
 704
 705         retval = str_send_msg(&video_str, id, data);
 706     }
 707
 708     return retval;
 709 }
 710
 711 /* Show/hide the video output */
 712 bool stream_show_vo(bool show)
 713 {
 714     bool vis;
 715     stream_mgr_lock();
 716
 717     vis = send_video_msg(VIDEO_DISPLAY_SHOW, show);
 718 #ifndef HAVE_LCD_COLOR
 719     grey_show(show);
 720 #endif
 721     stream_mgr_unlock();
 722
 723     return vis;
 724 }
 725
 726 /* Query the visibility of video output */
 727 bool stream_vo_is_visible(void)
 728 {
 729     bool vis;
 730     stream_mgr_lock();
 731     vis = send_video_msg(VIDEO_DISPLAY_IS_VISIBLE, 0);
 732     stream_mgr_unlock();
 733     return vis;
 734 }
 735
 736 /* Return the video dimensions */
 737 bool stream_vo_get_size(struct vo_ext *sz)
 738 {
 739     bool retval = false;
 740
 741     stream_mgr_lock();
 742
 743     if (str_parser.dims.w > 0 && str_parser.dims.h > 0)
 744     {
 745         *sz = str_parser.dims;
 746         retval = true;
 747     }
 748
 749     stream_mgr_unlock();
 750
 751     return retval;
 752 }
 753
 754 void stream_vo_set_clip(const struct vo_rect *rc)
 755 {
 756     stream_mgr_lock();
 757
 758     if (rc)
 759     {
 760         stream_mgr.parms.rc = *rc;
 761         rc = &stream_mgr.parms.rc;
 762     }
 763
 764     send_video_msg(VIDEO_SET_CLIP_RECT, (intptr_t)rc);
 765
 766     stream_mgr_unlock();
 767 }
 768
 769 bool stream_vo_get_clip(struct vo_rect *rc)
 770 {
 771     bool retval;
 772
 773     if (!rc)
 774         return false;
 775
 776     stream_mgr_lock();
 777
 778     retval = send_video_msg(VIDEO_GET_CLIP_RECT,
 779                             (intptr_t)&stream_mgr.parms.rc);
 780
 781     *rc = stream_mgr.parms.rc;
 782
 783     stream_mgr_unlock();
 784
 785     return retval;
 786 }
 787
 788 #ifndef HAVE_LCD_COLOR
 789 /* Show/hide the gray video overlay (independently of vo visibility). */
 790 void stream_gray_show(bool show)
 791 {
 792     stream_mgr_lock();
 793
 794     grey_show(show);
 795
 796     stream_mgr_unlock();
 797 }
 798
 799 #endif /* !HAVE_LCD_COLOR */
 800
 801 /* Display a thumbnail at the last seek point */
 802 bool stream_display_thumb(const struct vo_rect *rc)
 803 {
 804     bool retval;
 805
 806     if (rc == NULL)
 807         return false;
 808
 809     stream_mgr_lock();
 810
 811     stream_mgr.parms.rc = *rc;
 812     retval = send_video_msg(VIDEO_PRINT_THUMBNAIL,
 813                 (intptr_t)&stream_mgr.parms.rc);
 814
 815     stream_mgr_unlock();
 816
 817     return retval;
 818 }
 819
 820 bool stream_draw_frame(bool no_prepare)
 821 {
 822     bool retval;
 823     stream_mgr_lock();
 824
 825     retval = send_video_msg(VIDEO_PRINT_FRAME, no_prepare);
 826
 827     stream_mgr_unlock();
 828
 829     return retval;
 830 }
 831
 832 bool stream_set_callback(long id, void *fn)
 833 {
 834     bool retval = false;
 835
 836     stream_mgr_lock();
 837
 838     switch (id)
 839     {
 840     case VIDEO_SET_POST_FRAME_CALLBACK:
 841         retval =  send_video_msg(id, (intptr_t)fn);
 842     }
 843
 844     stream_mgr_unlock();
 845
 846     return retval;
 847 }
 848
 849 /* Return the time playback should resume if interrupted */
 850 uint32_t stream_get_resume_time(void)
 851 {
 852     uint32_t resume_time;
 853
 854     /* A stop request is async and replies before setting this - must lock */
 855     stream_mgr_lock();
 856
 857     resume_time = stream_mgr.resume_time;
 858
 859     stream_mgr_unlock();
 860
 861     return resume_time;
 862 }
 863
 864 uint32_t stream_get_seek_time(uint32_t *start)
 865 {
 866     uint32_t time;
 867
 868     stream_mgr_lock();
 869
 870     if (stream_mgr.seeked)
 871     {
 872         time = str_parser.last_seek_time;
 873     }
 874     else
 875     {
 876         time = TICKS_TO_TS(pcm_output_get_clock());
 877
 878         /* Clock can be start early so keep in range */
 879         if (time < str_parser.start_pts)
 880             time = str_parser.start_pts;
 881     }
 882
 883     if (start != NULL)
 884         *start = str_parser.start_pts;
 885
 886     stream_mgr_unlock();
 887
 888     return time;
 889 }
 890
 891 /* Wait for a state transistion to complete */
 892 void stream_wait_status(void)
 893 {
 894     stream_mgr_lock();
 895     stream_mgr_unlock();
 896 }
 897
 898 /* Returns the smallest file window that includes all active streams'
 899  * windows */
 900 static bool stream_get_window_callback(struct stream *str,
 901                                        struct stream_window *sw)
 902 {
 903     off_t swl = str->hdr.win_left;
 904     off_t swr = str->hdr.win_right;
 905
 906     if (swl < sw->left)
 907         sw->left = swl;
 908
 909     if (swr > sw->right)
 910         sw->right = swr;
 911
 912     return true;
 913 }
 914
 915 bool stream_get_window(struct stream_window *sw)
 916 {
 917     if (sw == NULL)
 918         return false;
 919
 920     sw->left = LONG_MAX;
 921     sw->right = LONG_MIN;
 922
 923     actl_lock();
 924     list_enum_items(stream_mgr.actl,
 925                     (list_enum_callback_t)stream_get_window_callback,
 926                     (intptr_t)sw);
 927     actl_unlock();
 928
 929     return sw->left <= sw->right;
 930 }
 931
 932 /* Playback control thread */
 933 static void stream_mgr_thread(void)
 934 {
 935     struct queue_event ev;
 936
 937     while (1)
 938     {
 939         rb->queue_wait(stream_mgr.q, &ev);
 940
 941         switch (ev.id)
 942         {
 943         case STREAM_OPEN:
 944             stream_on_open((const char *)ev.data);
 945             break;
 946
 947         case STREAM_CLOSE:
 948             stream_on_close();
 949             break;
 950
 951         case STREAM_PLAY:
 952             stream_on_play();
 953             break;
 954
 955         case STREAM_PAUSE:
 956             if (ev.data)
 957                 stream_on_resume();
 958             else
 959                 stream_on_pause();
 960             break;
 961
 962         case STREAM_STOP:
 963             stream_on_stop(true);
 964             break;
 965
 966         case STREAM_SEEK:
 967             stream_on_seek((struct stream_seek_data *)ev.data);
 968             break;
 969
 970         case STREAM_EV_COMPLETE:
 971             stream_on_ev_complete((struct stream *)ev.data);
 972             break;
 973
 974         case STREAM_QUIT:
 975             if (stream_mgr.status != STREAM_STOPPED)
 976                 stream_on_stop(false);
 977             return;
 978         }
 979     }
 980 }
 981
 982 /* Stream command interface APIs */
 983
 984 /* Opens a new file */
 985 int stream_open(const char *filename)
 986 {
 987     if (stream_mgr.thread != 0)
 988         return stream_mgr_send_msg(STREAM_OPEN, (intptr_t)filename);
 989     return STREAM_ERROR;
 990 }
 991
 992 /* Plays the current file starting at time 'start' */
 993 int stream_play(void)
 994 {
 995     if (stream_mgr.thread != 0)
 996         return stream_mgr_send_msg(STREAM_PLAY, 0);
 997     return STREAM_ERROR;
 998 }
 999
1000 /* Pauses playback if playing */
1001 int stream_pause(void)
1002 {
1003     if (stream_mgr.thread != 0)
1004         return stream_mgr_send_msg(STREAM_PAUSE, false);
1005     return STREAM_ERROR;
1006 }
1007
1008 /* Resumes playback if paused */
1009 int stream_resume(void)
1010 {
1011     if (stream_mgr.thread != 0)
1012         return stream_mgr_send_msg(STREAM_PAUSE, true);
1013     return STREAM_ERROR;
1014 }
1015
1016 /* Stops playback if not stopped */
1017 int stream_stop(void)
1018 {
1019     if (stream_mgr.thread != 0)
1020         return stream_mgr_send_msg(STREAM_STOP, 0);
1021     return STREAM_ERROR;
1022 }
1023
1024 /* Seeks playback time to/by the specified time */
1025 int stream_seek(uint32_t time, int whence)
1026 {
1027     int ret;
1028
1029     if (stream_mgr.thread == 0)
1030         return STREAM_ERROR;
1031
1032     stream_mgr_lock();
1033
1034     stream_mgr.parms.skd.time = time;
1035     stream_mgr.parms.skd.whence = whence;
1036
1037     ret = stream_mgr_send_msg(STREAM_SEEK, (intptr_t)&stream_mgr.parms.skd);
1038
1039     stream_mgr_unlock();
1040
1041     return ret;
1042 }
1043
1044 /* Closes the current file */
1045 int stream_close(void)
1046 {
1047     if (stream_mgr.thread != 0)
1048         return stream_mgr_send_msg(STREAM_CLOSE, 0);
1049     return STREAM_ERROR;
1050 }
1051
1052 /* Initializes the playback engine */
1053 int stream_init(void)
1054 {
1055     void *mem;
1056     size_t memsize;
1057
1058     stream_mgr.status = STREAM_STOPPED;
1059     stream_mgr_init_state();
1060
1061     /* Initialize our window to the outside world first */
1062     rb->mutex_init(&stream_mgr.str_mtx);
1063     rb->mutex_init(&stream_mgr.actl_mtx);
1064
1065     stream_mgr.q = &stream_mgr_queue;
1066     rb->queue_init(stream_mgr.q, false);
1067
1068     /* sets audiosize and returns buffer pointer */
1069     mem = rb->plugin_get_audio_buffer(&memsize);
1070
1071     /* Initialize non-allocator blocks first */
1072 #ifndef HAVE_LCD_COLOR
1073     long greysize;
1074
1075     /* Greylib init handles all necessary cache alignment */
1076     if (!grey_init(mem, memsize, GREY_BUFFERED|GREY_ON_COP,
1077                    LCD_WIDTH, LCD_HEIGHT, &greysize))
1078     {
1079         rb->splash(HZ, "greylib init failed!");
1080         return STREAM_ERROR;
1081     }
1082
1083     mem += greysize;
1084     memsize -= greysize;
1085
1086     grey_clear_display();
1087 #endif /* !HAVE_LCD_COLOR */
1088
1089     stream_mgr.thread = rb->create_thread(stream_mgr_thread,
1090         stream_mgr_thread_stack, sizeof(stream_mgr_thread_stack),
1091         0, "mpgstream_mgr" IF_PRIO(, PRIORITY_SYSTEM) IF_COP(, CPU));
1092
1093     rb->queue_enable_queue_send(stream_mgr.q, &stream_mgr_queue_send,
1094                                 stream_mgr.thread);
1095
1096     if (stream_mgr.thread == 0)
1097     {
1098         rb->splash(HZ, "Could not create stream manager thread!");
1099         return STREAM_ERROR;
1100     }
1101
1102     /* Wait for thread to initialize */
1103     stream_mgr_send_msg(STREAM_NULL, 0);
1104
1105     /* Initialise our malloc buffer */
1106     if (!mpeg_alloc_init(mem, memsize))
1107     {
1108         rb->splash(HZ, "Out of memory in stream_init");
1109     }
1110     /* These inits use the allocator */
1111     else if (!pcm_output_init())
1112     {
1113         rb->splash(HZ, "Could not initialize PCM!");
1114     }
1115     else if (!audio_thread_init())
1116     {
1117         rb->splash(HZ, "Cannot create audio thread!");
1118     }
1119     else if (!video_thread_init())
1120     {
1121         rb->splash(HZ, "Cannot create video thread!");
1122     }
1123     /* Disk buffer takes max allotment of what's left so it must be last */
1124     else if (!disk_buf_init())
1125     {
1126         rb->splash(HZ, "Cannot create buffering thread!");
1127     }
1128     else if (!parser_init())
1129     {
1130         rb->splash(HZ, "Parser init failed!");
1131     }
1132     else
1133     {
1134         return STREAM_OK;
1135     }
1136
1137     return STREAM_ERROR;
1138 }
1139
1140 /* Cleans everything up */
1141 void stream_exit(void)
1142 {
1143     stream_close();
1144
1145     /* Stop the threads and wait for them to terminate */
1146     video_thread_exit();
1147     audio_thread_exit();
1148     disk_buf_exit();
1149     pcm_output_exit();
1150
1151     if (stream_mgr.thread != 0)
1152     {
1153         stream_mgr_post_msg(STREAM_QUIT, 0);
1154         rb->thread_wait(stream_mgr.thread);
1155         stream_mgr.thread = 0;
1156     }
1157
1158 #ifndef HAVE_LCD_COLOR
1159     grey_release();
1160 #endif
1161 }