git.sesse.net Git - nageru/blob - player.cpp

   1 #include <algorithm>
   2 #include <chrono>
   3 #include <condition_variable>
   4 #include <mutex>
   5 #include <thread>
   6 #include <vector>
   7
   8 #include "clip_list.h"
   9 #include "defs.h"
  10 #include "jpeg_frame_view.h"
  11 #include "player.h"
  12
  13 using namespace std;
  14 using namespace std::chrono;
  15
  16 extern mutex frame_mu;
  17 extern vector<int64_t> frames[MAX_STREAMS];
  18
  19 void Player::thread_func()
  20 {
  21         for ( ;; ) {
  22                 // Wait until we're supposed to play something.
  23                 {
  24                         unique_lock<mutex> lock(queue_state_mu);
  25                         new_clip_changed.wait(lock, [this]{
  26                                 return new_clip_ready && current_clip.pts_in != -1;
  27                         });
  28                         new_clip_ready = false;
  29                 }
  30
  31                 Clip clip;
  32                 unsigned stream_idx;
  33                 {
  34                         lock_guard<mutex> lock(mu);
  35                         clip = current_clip;
  36                         stream_idx = current_stream_idx;
  37                 }
  38                 steady_clock::time_point origin = steady_clock::now();
  39                 int64_t pts_origin = clip.pts_in;
  40
  41                 int64_t next_pts = pts_origin - 1;  // Make sure we play the frame at clip.pts_in if it exists.
  42
  43                 bool aborted = false;
  44                 for ( ;; ) {
  45                         // Find the next frame.
  46                         {
  47                                 lock_guard<mutex> lock(frame_mu);
  48                                 auto it = upper_bound(frames[stream_idx].begin(),
  49                                         frames[stream_idx].end(),
  50                                         next_pts);
  51                                 if (it == frames[stream_idx].end() || *it >= clip.pts_out) {
  52                                         break;
  53                                 }
  54                                 next_pts = *it;
  55                         }
  56
  57                         // FIXME: assumes a given timebase.
  58                         double speed = 0.5;
  59                         steady_clock::time_point next_frame_start =
  60                                 origin + microseconds((next_pts - pts_origin) * int(1000000 / speed) / 12800);
  61
  62                         // Sleep until the next frame start, or until there's a new clip we're supposed to play.
  63                         {
  64                                 unique_lock<mutex> lock(queue_state_mu);
  65                                 aborted = new_clip_changed.wait_until(lock, next_frame_start, [this]{
  66                                         return new_clip_ready;
  67                                 });
  68                                 if (aborted) break;
  69                         }
  70
  71                         destination->setFrame(stream_idx, next_pts);
  72
  73                 }
  74
  75                 if (done_callback != nullptr && !aborted) {
  76                         done_callback();
  77                 }
  78         }
  79 }
  80
  81 Player::Player(JPEGFrameView *destination)
  82         : destination(destination)
  83 {
  84         thread(&Player::thread_func, this).detach();
  85 }
  86
  87 void Player::play_clip(const Clip &clip, unsigned stream_idx)
  88 {
  89         {
  90                 lock_guard<mutex> lock(mu);
  91                 current_clip = clip;
  92                 current_stream_idx = stream_idx;
  93         }
  94
  95         {
  96                 lock_guard<mutex> lock(queue_state_mu);
  97                 new_clip_ready = true;
  98                 new_clip_changed.notify_all();
  99         }
 100 }