[ViewVC] Diff of: cvs/AnyEvent-MPV/MPV.pm

Comparing AnyEvent-MPV/MPV.pm (file contents):
Revision 1.6 by root, Sun Mar 19 23:24:20 2023 UTC vs.
Revision 1.10 by root, Mon Mar 20 12:31:03 2023 UTC

 use Scalar::Util ();
 use AnyEvent ();
 use AnyEvent::Util ();
+our $VERSION = '0.2';
+sub OBSID() { 0x10000000000000 } # 2**52
 our $JSON = eval { require JSON::XS; JSON::XS:: }
           || do  { require JSON::PP; JSON::PP:: };
 our $JSON_CODER =
-our $VERSION = '0.1';
 our $mpv_path; # last mpv path used
 our $mpv_optionlist; # output of mpv --list-options
 =item $mpv = AnyEvent::MPV->new (key => value...)
 sub start {
    my ($self, @extra_args) = @_;
    return 0 if $self->{fh};
+   $self->{obscb} = {};
    # cache optionlist for same "path"
    ($mpv_path, $mpv_optionlist) = ($self->{mpv}, scalar qx{\Q$self->{mpv}\E --list-options})
       if $self->{mpv} ne $mpv_path;
    my $trace = delete $self->{trace} || sub { };
    $trace = sub { warn "$_[0] $_[1]\n" } if $trace && !ref $trace;
    my $buf;
-   my $wbuf;
    Scalar::Util::weaken $self;
    $self->{rw} = AE::io $fh, 0, sub {
       if (sysread $fh, $buf, 8192, length $buf) {
                      ) {
                         if ($reply->{args}[1] eq "key") {
                            (my $key = $reply->{args}[2]) =~ s/\\x(..)/chr hex $1/ge;
                            $self->on_key ($key);
                         }
+                     } elsif (
+                        $reply->{event} eq "property-change"
+                        and OBSID <= $reply->{id}
+                     ) {
+                        if (my $cb = $self->{obscb}{$reply->{id}}) {
+                           $cb->($self, $reply->{name}, $reply->{data});
+                        }
                      } else {
-                        $self->on_event ($reply->{event}, $reply);
+                        $self->on_event (delete $reply->{event}, $reply);
                      }
                   } elsif (exists $reply->{request_id}) {
-                     my $cv = delete $self->{cmd_cv}{$reply->{request_id}};
+                     my $cv = delete $self->{cmdcv}{$reply->{request_id}};
                      unless ($cv) {
                         warn "no cv found for request id <$reply->{request_id}>\n";
                         next;
                      }
          $self->stop;
          $self->on_eof;
       }
    };
+   my $wbuf;
+   my $reqid;
-   $self->{_send} = sub {
+   $self->{_cmd} = sub {
-      $wbuf .= "$_[0]\n";
+      my $cv = AE::cv;
+      $self->{cmdcv}{++$reqid} = $cv;
+      my $cmd = $JSON->new->utf8->encode ({ command => ref $_[0] ? $_[0] : \@_, request_id => $reqid*1 });
+      # (un-)apply escape_binary hack
+      $cmd =~ s/\xf4\x8e\x97\x9f(..)/sprintf sprintf "\\x%02x", hex $1/ges; # f48e979f == 10e5df in utf-8
-      $trace->(">mpv" => "$_[0]");
+      $trace->(">mpv" => $cmd);
+      $wbuf .= "$cmd\n";
       $self->{ww} ||= AE::io $fh, 1, sub {
          my $len = syswrite $fh, $wbuf;
          substr $wbuf, 0, $len, "";
          undef $self->{ww} unless length $wbuf;
       };
+      $cv
    };
    1
+}
+sub DESTROY {
+   $_[0]->stop;
 }
 =item $mpv->stop
 Ensures that F<mpv> is being stopped, by killing F<mpv> with a C<TERM>
       kill TERM => $self->{pid};
    }
    delete $self->{pid};
-   delete $self->{cmd_cv};
+   delete $self->{cmdcv};
+   delete $self->{obsid};
+   delete $self->{obscb};
+   delete $self->{wbuf};
 }
 =item $mpv->on_eof
 This method is called when F<mpv> quits - usually unexpectedly. The
 This method is called when F<mpv> sends an asynchronous event. The default
 implementation will call the C<on_event> code reference specified in the
 constructor, or do nothing if none was given.
-The first/implicit argument is the C<$mpv> object, the second is the event
+The first/implicit argument is the C<$mpv> object, the second is the
-name (same as C<< $data->{event} >>, purely for convenience), and the
+event name (same as C<< $data->{event} >>, purely for convenience), and
-third argument is the full event object as sent by F<mpv>. See L<List of
+the third argument is the event object as sent by F<mpv> (sans C<event>
-events|https://mpv.io/manual/stable/#list-of-events> in its documentation.
+key). See L<List of events|https://mpv.io/manual/stable/#list-of-events>
+in its documentation.
 For subclassing, see I<SUBCLASSING>, below.
 =cut
 On error, the condvar will croak when C<recv> is called.
 =cut
 sub cmd {
-   my ($self, @cmd) = @_;
+   my $self = shift;
-   my $cv = AE::cv;
+   $self->{_cmd}->(@_)
-   my $reqid = ++$self->{reqid};
-   $self->{cmd_cv}{$reqid} = $cv;
-   my $cmd = $JSON->new->utf8->encode ({ command => ref $cmd[0] ? $cmd[0] : \@cmd, request_id => $reqid*1 });
-   # (un-)apply escape_binary hack
-   $cmd =~ s/\xf4\x8e\x97\x9f(..)/sprintf sprintf "\\x%02x", hex $1/ges; # f48e979f == 10e5df in utf-8
-   $self->{_send}($cmd);
-   $cv
 }
 =item $result = $mpv->cmd_recv ($command => $arg, $arg...)
 The same as calling C<cmd> and immediately C<recv> on its return
 =item $mpv->bind_key ($INPUT => $string)
 This is an extension implement by this module to make it easy to get key events. The way this is implemented
 is to bind a C<client-message> witha  first argument of C<AnyEvent::MPV> and the C<$string> you passed. This C<$string> is then
-passed ot the C<on_key> handle when the key is proessed, e.g.:
+passed to the C<on_key> handle when the key is proessed, e.g.:
    my $mpv = AnyEvent::MPV->new (
       on_key => sub {
          my ($mpv, $key) = @_;
 sub bind_key {
    my ($self, $key, $event) = @_;
    $event =~ s/([^A-Za-z0-9\-_])/sprintf "\\x%02x", ord $1/ge;
    $self->cmd (keybind => $key => "no-osd script-message AnyEvent::MPV key $event");
+}
+sub AnyEvent::MPV::Unobserve::DESTROY {
+   my ($mpv, $obscb, $obsid) = @{$_[0]};
+   delete $obscb->{$obsid};
+   if ($obscb == $mpv->{obscb}) {
+      $mpv->cmd (unobserve_property => $obsid+0);
+   }
+}
+=item [$guard] = $mpv->observe_property ($name => $coderef->($mpv, $name, $value))
+=item [$guard] = $mpv->observe_property_string ($name => $coderef->($mpv, $name, $value))
+These methods wrap a registry system around F<mpv>'s C<observe_property>
+and C<observe_property_string> commands - every time the named property
+changes, the coderef is invoked with the C<$mpv> object, the name of the
+property and the new value.
+For a list of properties that you can observe, see L<the mpv
+documentation|https://mpv.io/manual/stable/#property-list>.
+Due to the (sane :) way F<mpv> handles these requests, you will always
+get a property cxhange event right after registering an observer (meaning
+you don't have to query the current value), and it is also possible to
+register multiple observers for the same property - they will all be
+handled properly.
+When called in void context, the observer stays in place until F<mpv>
+is stopped. In any otrher context, these methods return a guard
+object that, when it goes out of scope, unregisters the observe using
+C<unobserve_property>.
+Internally, this method uses observer ids of 2**52 (0x10000000000000) or
+higher - it will not interfere with lower ovserver ids, so it is possible
+to completely ignore this system and execute C<observe_property> commands
+yourself, whilst listening to C<property-change> events - as long as your
+ids stay below 2**52.
+Example: register observers for changtes in C<aid> and C<sid>. Note that
+a dummy statement is added to make sure the method is called in void
+context.
+   sub register_observers {
+      my ($mpv) = @_;
+      $mpv->observe_property (aid => sub {
+         my ($mpv, $name, $value) = @_;
+         print "property aid (=$name) has changed to $value\n";
+      });
+      $mpv->observe_property (sid => sub {
+         my ($mpv, $name, $value) = @_;
+         print "property sid (=$name) has changed to $value\n";
+      });
+      () # ensure the above method is called in void context
+   }
+=cut
+sub _observe_property {
+   my ($self, $type, $property, $cb) = @_;
+   my $obsid = OBSID + ++$self->{obsid};
+   $self->cmd ($type => $obsid+0, $property);
+   $self->{obscb}{$obsid} = $cb;
+   defined wantarray and do {
+      my $unobserve = bless [$self, $self->{obscb}, $obsid], AnyEvent::MPV::Unobserve::;
+      Scalar::Util::weaken $unobserve->[0];
+      $unobserve
+   }
+}
+sub observe_property {
+   my ($self, $property, $cb) = @_;
+   $self->_observe_property (observe_property => $property, $cb)
+}
+sub observe_property_string {
+   my ($self, $property, $cb) = @_;
+   $self->_observe_property (observe_property_string => $property, $cb)
 }
 =back
 =head2 SUBCLASSING

Diff Legend

-–
+Removed lines
-+
+Added lines
-<
+Changed lines
->
+Changed lines

Comparing AnyEvent-MPV/MPV.pm (file contents): Revision 1.6 by root, Sun Mar 19 23:24:20 2023 UTC vs. Revision 1.10 by root, Mon Mar 20 12:31:03 2023 UTC

Diff Legend

Comparing AnyEvent-MPV/MPV.pm (file contents):
Revision 1.6 by root, Sun Mar 19 23:24:20 2023 UTC vs.
Revision 1.10 by root, Mon Mar 20 12:31:03 2023 UTC