rifftrax.pl 8.1 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333
  1. #!/usr/bin/perl
  2. use strict;
  3. use warnings;
  4. use File::Temp qw( tempfile );
  5. use Time::HiRes qw( usleep sleep time );
  6. use IPC::System::Simple qw( system capture );
  7. # Local modules
  8. use Cwd qw(abs_path);
  9. use File::Basename qw(dirname);
  10. use lib dirname(abs_path($0));
  11. use DMX;
  12. use Audio;
  13. # Config
  14. my $MEDIA_PATH = `~/bin/video/mediaPath`;
  15. my $CONFIG_PATH = $MEDIA_PATH . '/DMX/RiffTrax';
  16. my $RIFF_PATH = $MEDIA_PATH . '/iTunes/iTunes Music/RiffTrax';
  17. my $ACTION_DELAY = 0.1;
  18. my $JUMP_THRESHOLD = 5;
  19. # Prototypes
  20. sub playRiff();
  21. sub pauseRiff();
  22. # App config
  23. my $DATA_DIR = DMX::dataDir();
  24. my $OUTPUT_FILE = $DATA_DIR . 'RIFF';
  25. my $STATE_SOCK = $OUTPUT_FILE . '.socket';
  26. my $PULL_TIMEOUT = 60;
  27. my $DELAY = $PULL_TIMEOUT / 3;
  28. my %RIFFS = ();
  29. # Debug
  30. my $DEBUG = 0;
  31. if ($ENV{'DEBUG'}) {
  32. $DEBUG = 1;
  33. }
  34. # Read the config
  35. opendir(CONF, $CONFIG_PATH)
  36. or die('Unable to open config directory: ' . $! . "\n");
  37. foreach my $file (readdir(CONF)) {
  38. # Skip silly files
  39. if ($file =~ /^\._/) {
  40. next;
  41. }
  42. if ($file =~ /\.riff$/) {
  43. my $path = $CONFIG_PATH . '/' . $file;
  44. # Slurp the contents
  45. my $text = '';
  46. if (!open(my $fh, $path)) {
  47. warn('Unable to open ' . $path . "\n");
  48. } else {
  49. local $/;
  50. $text = <$fh>;
  51. close($fh);
  52. }
  53. # Parse out the data we care about
  54. my %data = ();
  55. if ($text =~ /^\s*Name:\s*(\S.*\S)\s*$/mi) {
  56. $data{'name'} = $1;
  57. }
  58. if ($text =~ /^\s*File:\s*(\S.*\S)\s*$/mi) {
  59. $data{'file'} = $1;
  60. }
  61. if ($text =~ /^\s*Offset:\s*([\-\+]?\d+(?:\.\d+)?)\s*$/mi) {
  62. $data{'offset'} = $1;
  63. }
  64. if ($text =~ /^\s*Rate:\s*(\d+(?:\.\d+)?)\s*$/mi) {
  65. $data{'rate'} = $1;
  66. }
  67. # Ensure we have a valid record
  68. if (!$data{'name'} || !$data{'file'}) {
  69. die('Invalid riff file: ' . $file . ' => ' . $data{'name'} . "\n");
  70. }
  71. # Construct an absolute path
  72. if ($data{'file'} =~ /^\//) {
  73. $data{'path'} = $data{'file'};
  74. } else {
  75. $data{'path'} = $RIFF_PATH . '/' . $data{'file'};
  76. }
  77. # Ensure the path is valid
  78. if (!-r $data{'path'}) {
  79. die('Invalid riff path: ' . $file . ' => ' . $data{'path'} . "\n");
  80. }
  81. # Debug
  82. if ($DEBUG) {
  83. print STDERR 'Added RiffTrax: ' . $data{'name'} . "\n\tFile: " . $data{'file'} . "\n\tOffset: " . $data{'offset'} . "\n\tRate: " . $data{'rate'} . "\n";
  84. }
  85. # Push the data up the chain
  86. $RIFFS{ $data{'name'} } = \%data;
  87. }
  88. }
  89. closedir(CONF);
  90. # Sockets
  91. DMX::stateSocket($STATE_SOCK);
  92. DMX::stateSubscribe($STATE_SOCK);
  93. # State
  94. my $state = 'OFF';
  95. my $stateLast = $state;
  96. my $riff = '';
  97. my $riffLast = $riff;
  98. my $title = '';
  99. my $titleLast = $title;
  100. my $nudge = 0;
  101. my %exists = ();
  102. my %last = ();
  103. my $pullLast = time();
  104. my $lastSync = time();
  105. my $playing = 0;
  106. my $delay = $DELAY;
  107. # Loop forever
  108. while (1) {
  109. # Save the last RIFF and state
  110. $stateLast = $state;
  111. $riffLast = $riff;
  112. %last = %exists;
  113. # Reconnect if we're playing and haven't seen an update for $JUMP_THRESHOLD seconds
  114. if ($playing && time() - $pullLast > $JUMP_THRESHOLD) {
  115. print STDERR "Attempting to reconnect state socket...\n";
  116. DMX::stateSubscribe($STATE_SOCK);
  117. }
  118. # Wait for state updates
  119. my $cmdState = DMX::readState($delay, \%exists, undef(), undef());
  120. if (defined($cmdState)) {
  121. $state = $cmdState;
  122. $pullLast = time();
  123. }
  124. # Die if we don't see regular updates
  125. if (time() - $pullLast > $PULL_TIMEOUT) {
  126. die('No update on state socket in past ' . $PULL_TIMEOUT . " seconds. Exiting...\n");
  127. }
  128. # Record nudges
  129. if ($state eq 'NUDGE_FORWARD') {
  130. $nudge -= 0.1;
  131. next;
  132. } elsif ($state eq 'NUDGE_BACK') {
  133. $nudge += 0.1;
  134. next;
  135. }
  136. # Save the last URL, so we can find changes
  137. # Do not delete the last URL if no new one is provided
  138. if (exists($exists{'PLAYING_TITLE'})) {
  139. $titleLast = $title;
  140. $title = $exists{'PLAYING_TITLE'};
  141. }
  142. # Update our state when the PLAYING_TITLE changes
  143. if ($title ne $titleLast) {
  144. # If a RIFF was active, clear it
  145. if ($riff) {
  146. if ($DEBUG) {
  147. print STDERR "RIFF complete\n";
  148. }
  149. $delay = $DELAY;
  150. Audio::drop('RIFF');
  151. $riff = 0;
  152. $nudge = 0;
  153. DMX::say('RiffTrax complete');
  154. }
  155. # Activate a new RIFF, if applicable
  156. if ($RIFFS{$title}) {
  157. if ($DEBUG) {
  158. print STDERR 'Matched RIFF: ' . $title . ' => ' . $RIFFS{$title}->{'file'} . "\n";
  159. }
  160. $riff = $title;
  161. $delay = 1;
  162. Audio::addLoad('RIFF', $RIFFS{$riff}->{'path'});
  163. Audio::rate('RIFF', $RIFFS{$riff}->{'rate'});
  164. playRiff();
  165. DMX::say('RiffTrax initiated');
  166. }
  167. }
  168. # If the RIFF has changed, save the state to disk
  169. if ($riff ne $riffLast) {
  170. my $new = '<none>';
  171. if ($riff) {
  172. $new = $RIFFS{$riff}->{'name'};
  173. }
  174. my $old = $new;
  175. if ($riffLast > 0) {
  176. $old = $RIFFS{$riffLast}->{'name'};
  177. }
  178. if ($DEBUG) {
  179. print STDERR 'New RIFF: ' . $old . ' => ' . $new . "\n";
  180. }
  181. my ($fh, $tmp) = tempfile($OUTPUT_FILE . '.XXXXXXXX', 'UNLINK' => 0);
  182. print $fh $new . "\n";
  183. close($fh);
  184. rename($tmp, $OUTPUT_FILE);
  185. }
  186. # Play/pause to match the video
  187. # This assumes our local state is valid. We double-check that state tracking if the sync error is large enough to trigger a jump
  188. if ($riff) {
  189. if ($state eq 'PAUSE' && $playing) {
  190. pauseRiff();
  191. } elsif ($state eq 'PLAY' && !$playing) {
  192. playRiff();
  193. }
  194. }
  195. # Sync at most once per second
  196. if ($riff && $lastSync < time()) {
  197. if ($DEBUG) {
  198. print STDERR "Syncing\n";
  199. }
  200. $lastSync = time();
  201. # Get the video and riff playback positions
  202. my $rate = Audio::rate('RIFF', undef());
  203. my $riffTime = Audio::position('RIFF', undef());
  204. my $videoTime = $exists{'PLAYING_POSITION'};
  205. # Convert to seconds
  206. my @parts = split(/\:/, $videoTime);
  207. $videoTime = 0;
  208. if (scalar(@parts) == 3) {
  209. $videoTime = ($parts[0] * 3600) + ($parts[1] * 60) + $parts[2];
  210. } elsif (scalar(@parts) == 2) {
  211. $videoTime = ($parts[0] * 60) + $parts[1];
  212. } else {
  213. $videoTime = $parts[0];
  214. }
  215. # Calculate the adjusted riff time and the error between the riff and video times
  216. my $riffAdjTime = ($riffTime * $RIFFS{$riff}->{'rate'}) - $RIFFS{$riff}->{'offset'} + $nudge;
  217. my $error = $videoTime - $riffAdjTime;
  218. my $errorAbs = abs($error);
  219. # Debug
  220. if ($DEBUG) {
  221. print STDERR "\tRate: " . $RIFFS{$riff}->{'rate'} . "\n";
  222. print STDERR "\tAdjusted Rate: " . $rate . "\n";
  223. print STDERR "\tNudge: " . $nudge . "\n";
  224. print STDERR "\tOffset: " . $RIFFS{$riff}->{'offset'} . "\n";
  225. print STDERR "\tRiff time: " . $riffTime . "\n";
  226. print STDERR "\tVideo time: " . $videoTime . "\n";
  227. print STDERR "\tAdjusted riff time: " . $riffAdjTime . "\n";
  228. print STDERR "\tError: " . $error . "\n";
  229. }
  230. # Adjust the riff position if we're off by 0.5 seconds or more
  231. if ($errorAbs > 0.5) {
  232. # Calculate the new position, including an ACTION_DELAY adjustment to compensate for time elapsed in this process
  233. my $newPos = $riffTime + $error + $ACTION_DELAY;
  234. if ($newPos < 0) {
  235. pauseRiff();
  236. } else {
  237. # Ensure our local playing state tracking is accurate
  238. $playing = Audio::playing('RIFF');
  239. # Jump if we're off by more than a few seconds
  240. if ($errorAbs > $JUMP_THRESHOLD) {
  241. if ($DEBUG) {
  242. print STDERR 'Jumping to: ' . $newPos . "\n";
  243. }
  244. Audio::position('RIFF', $newPos);
  245. $nudge = 0;
  246. $error = 0;
  247. $errorAbs = 0;
  248. }
  249. # Set the rate when we adjust, unless we're paused
  250. if ($playing) {
  251. my $rateDiff = $errorAbs / $JUMP_THRESHOLD;
  252. if ($error < 0) {
  253. $rateDiff *= -1;
  254. }
  255. my $newRate = $RIFFS{$riff}->{'rate'} + $rateDiff;
  256. if ($DEBUG) {
  257. print STDERR 'Setting rate to: ' . $newRate . "\n";
  258. }
  259. Audio::rate('RIFF', $newRate);
  260. }
  261. # Play/pause as needed, before we adjust
  262. # The state-change detection should handle most of this
  263. # But double-check while adjusting in case things get out-of-sync
  264. if (exists($exists{'PLAYING'})) {
  265. if ($exists{'PLAYING'} && !$playing) {
  266. playRiff();
  267. } elsif (!$exists{'PLAYING'} && $playing) {
  268. pauseRiff();
  269. }
  270. }
  271. }
  272. } else {
  273. # Reset the rate to standard if we're inside sync the window
  274. if ($rate != $RIFFS{$riff}->{'rate'}) {
  275. Audio::rate('RIFF', $RIFFS{$riff}->{'rate'});
  276. }
  277. }
  278. }
  279. }
  280. sub playRiff() {
  281. $playing = 1;
  282. Audio::background('RIFF');
  283. }
  284. sub pauseRiff() {
  285. $playing = 0;
  286. Audio::pause('RIFF');
  287. }