Here's the testbed code:

import processing.video.*;
Movie myMovie;
int screenSizeX = 800;
int screenSizeY = 600;
float duration = 0;

void settings()
{
  size(screenSizeX, screenSizeY);
}
void setup() {

  myMovie = new Movie(this, "20180201103135_20180201103155_01_M.dav");
  myMovie.frameRate(25);
  myMovie.speed(0.01);
  duration = myMovie.duration();
  println("setup duration =" + duration);
  duration = myMovie.playbin.queryDuration().toSeconds();
  println("setup playbin.queryDuration() duration =" + duration);
  myMovie.loop();
}

void draw() {
  image(myMovie, 0, 0);
  println("Duration=" + myMovie.duration());
}

// Called every time a new frame is available to read
void movieEvent(Movie m) {
  m.read();
  duration = myMovie.duration();
  println("movieEvent duration =" + duration);
}

When I run it, duration always appear to return 0.0 regardless of when I test it -- including if I call playbin directly (mimicking the library code at line 270 here: https://github.com/processing/processing-video/blob/master/src/processing/video/Movie.java ).

The console output is:
setup duration =0.0
setup playbin.queryDuration() duration =0.0
movieEvent duration =0.0
Duration=0.0
Duration=0.0
movieEvent duration =0.0
Duration=0.0
:

What I was really trying to do (apart from experimenting with playback at various speeds) was figure out how to detect when a Movie has finished playing? I've seen some example code that did this:

if (myMovie.time() >= myMovie.duration()) // Test if the playhead is at the end
{
   // end of Movie
}

Of course that's destined to fail if .duration() always returns zero. So that raises the question, how do you tell when a movie has finished?? I supposed I could check when .time() stops changing, but that squawks a dreaded red text error on the console when the code runs "off the end" of the Movie.

Anyone got any ideas how you test for when a Movie has finished playing? I need to work my way through a directory with hundreds of different movie files and extract individual frames -- I've figured out what I thought would be the hard part only to screech to a halt on this "simple" problem. :(

Oh....and anyone got any ideas why myMovie.frameRate() and .speed() don't appear to do anything?

Thanks in advance Andy

Im made this sketch but as soon as I hit reverse on the videolibrary with help of negative movie.speed it causes a error. Any solution?:

(Processing core video:475): GStreamer-WARNING **: wrong STREAM_LOCK count 0

(Processing core video:475): GStreamer-CRITICAL **: gst_segment_set_seek: assertion `start <= stop' failed

import processing.video.*;

Movie movie; // Step 1. Declare Movie object

void setup() {
  size(560, 480);
  // Step 2. Initialize Movie object
  movie = new Movie(this, "test1.mov");
  movie.loop();
  movie.jump(5);
  movie.pause();
}
// Step 4. Read new frames from movie
void movieEvent(Movie movie) {
  movie.read();
}
void draw() {
  image(movie, 650, 0);
}

void keyReleased() {
  if (key == 'a') movie.play(); // play
  if (key == 's') movie.pause(); // pause
  if (key == 'd') movie.stop(); // stop
  if (key == 'f') movie.jump(5); // jump
  movie.speed(1.0);
}

void keyPressed() {
  if (key == 'g') movie.speed(5.0); // forward
  if (key == 'h') movie.speed(-5.0); // reverse
}

Below is my code, any help is appreciated!

import processing.video.*;

float joystick_yaw, joystick_speed;
Movie movie;
PShader shader;
float yaw, pitch, fov;
boolean isPaused = false;

void setup() {
  size(1280, 720, P2D);
  // pitch and yaw set to start video in desired view
  yaw   = 225;
  pitch = 5;
  fov   = 80;
  shader = loadShader("data/video360.glsl");
  shader.set("resolution", float(width/2), float(height/2));
  shader.set("yaw", yaw);
  shader.set("pitch", pitch);
  shader.set("fov", fov);
  movie = new Movie(this, "stitch_high.mp4");
  movie.play();
  movie.volume(0);
  while (movie.height == 0) {
    println("waiting " + second()); 
    delay(10);
  }

  imageMode(CORNERS);
}

void draw() {
  // display video  
  shader(shader);
  image(movie, 0, 0, width, height);

  // display yaw
  joystick_yaw = map(mouseX, 0, 1200, yaw-(fov/3), yaw+(fov/3)); 
  shader.set("yaw", joystick_yaw);

  //choose speed of video
  joystick_speed = map(mouseY, 0, height, 2, -2); 

  if (joystick_speed > 0.2 && isPaused ) {
    movie.speed(joystick_speed);
    movie.play();
    movie.speed(joystick_speed);
    isPaused = false;
  } else if (joystick_speed < -0.2 && isPaused) {
    movie.speed(joystick_speed);
    movie.play();
    movie.speed(joystick_speed);
    isPaused = false;
  } else if (joystick_speed >= -0.2 && joystick_speed <= 0.2) {
    if (!isPaused) {
      movie.pause();
      isPaused = true;
    }
  }
}

// Called every time a new frame is available to read
void movieEvent(Movie m) {
  m.read();
}

Somewhat related, the video is very laggy when it plays back. I have it set to a very low bitrate at 240p H264. I just want it to play through smoothly. Thanks in advance.

I'm posting this code in the hope that it might help others and maybe to find a solution that works in Processing 3.x

here's the code with lots of comments and link to a reliable test video:

/*
 An example of frame accurate interactive video playback
 Tested working for frame accurate interactive viewing of videos at 25fps and 30fps - any length.
 This only works in processing 1.5.1
 I cannot get it working in newer versions of Processing
 This is probably due to the switch to the gstreamer library

 Easiest way to check it's working is to use a movie file with the
 correct frame number printed on each frame so you can spot skipping frames
 as you use the keys: -/+ to navigate.

 The suitable video for this sketch (with it's numbered frames) can be d/ld here:
 http://33dd.com/processing/100_Numbered_frames_30fps.mov
 */

import processing.video.*; 
Movie myMovie; 
float movieFps=30.00;//fps of the movie - please set to match your movie file
float advanceLength = 1/(movieFps-0.01);//get length of one frame in seconds - and subtract 0.01 (why -0.01 I don't know??)
//this movie is 30fps - but sketch is only accurate if we declare fps as 29.99fps - why??

void setup()
{ 
  size(640, 320, P2D);//P2D needed for processing 1.5.--
  //size(640, 320);//use this method in processing 2.++ - no more P2D
  background(0); 

  //load a movie with visible framenumbers - makes it easier to check accuracy
  myMovie = new Movie(this, "100_Numbered_frames_30fps.mov"); //see link at top for video source
  myMovie.loop();//play the movie
  myMovie.speed(0);//best way to stop the movie - pause() halts the thread - so we must use speed(0)
} 

void movieEvent(Movie myMovie)
{ 
  myMovie.read();
} 

void draw()
{ 
  image(myMovie, 0, 0, width, height);
} 

void keyPressed()
{ //use - / +  keys to go back and forward one frame
  if (key == '-')
  {
    if (myMovie.time() < advanceLength)//if movie time < 1 frame jump to start of movie (another hack needed to make it work)
    {
      myMovie.jump((myMovie.time() - advanceLength) % 0);
    } else  
    {//for some reason this only works accurately if we jump backwards then forward one frame
      myMovie.jump((myMovie.time() - advanceLength) % myMovie.duration()); 
      myMovie.jump((myMovie.time() + advanceLength) % myMovie.duration());
    }
  }  
  if (key == '=')
  {
    //jump forward by one frame 
    myMovie.jump((myMovie.time() + advanceLength) % myMovie.duration());
  }
}

import processing.video.*;
Movie myMovie;

void setup() {
  size(200, 200);
  frameRate(30);
  myMovie = new Movie(this, "totoro.mov");
  myMovie.speed(4.0);
  myMovie.loop();
}

void draw() {
  if (myMovie.available()) {
    myMovie.read();
  }
  image(myMovie, 0, 0);
}

but the player seems to ignore the call to Movie.speed() does it have to do with the video format, is there a video format that would work?

Thanks for any help sergio

When I print "myMovie.width" I get 0...

Here is my code:

package processingvideotest;

import processing.core.PApplet;
import processing.video.*;


public class ProcessingVideoTest extends PApplet{

    Movie myMovie;


    public void setup() {
    myMovie = new Movie(this,  "C:/Users/ollie/Documents/NetBeansProjects/ProcessingVideoTest/src/data/Evangelion.mp4");
    myMovie.play();
    myMovie.speed(1);
    myMovie.loop();

    }

    public void settings() {
      size(400, 400);

    }

    public void draw() {
    image(myMovie, 0, 0);
    }

    void movieEvent(Movie m) {
    m.read();
    }

    public static void main(String[] args) {
        PApplet.main(new String[] { "processingvideotest.ProcessingVideoTest" });
    }

}

most of time, if the sound level getting higher, that happens. i get the same warning message everytime:

2016-01-24 23:38:55.263 java[49121:34205664] 23:38:55.263 WARNING: 140: This application, or a library it uses, is using the deprecated Carbon Component Manager for hosting Audio Units. Support for this will be removed in a future release. Also, this makes the host incompatible with version 3 audio units. Please transition to the API's in AudioComponent.h.

this is the code so far:

import processing.video.*;
import processing.sound.*;

AudioIn input;
Amplitude rms;
int scale;
Movie myMovie;

String[] one = {"a.mp4","b.mp4","c.mp4"};

int a = 0;        
float md = 0;
float mt = 0;

void setup()
{
  size(1440 ,900);
  frameRate(25);
  background(0);
  myMovie = new Movie(this, one[int(random(one.length))]);
  myMovie.play();
  input = new AudioIn(this, 0); //Create an Audio input and grab the 1st channel
  input.start(); // start the Audio Input
  rms = new Amplitude(this); // create a new Amplitude analyzer
  rms.input(input); // Patch the input to an volume analyzer
}

void draw()
{
  scale=int(map(rms.analyze(), 0, 0.5, 1, 350));

  if(a == 0) { 
      image(myMovie, 0, 0,900,900);
      }
  image(myMovie, 0, 0,900,900);

  float md = myMovie.duration();
  float mt = myMovie.time();
  println(md - mt);
  if (Math.abs(md - mt)<0.1){// to find the end of the movie
     myMovie = null;
     myMovie = new Movie(this, one[int(random(one.length))]);
     myMovie.play();
  }
// rms.analyze() return a value between 0 and 1. To adjust the scaling and mapping of an ellipse we scale from 0 to 0.5
    if ((rms.analyze()>0)&&(rms.analyze()<3)) 
    tint (scale*20,scale*4,scale*4);
    myMovie.speed(scale*0.2);

}

void movieEvent(Movie m) { // Called every time a new frame is available to read
  m.read();
}

what am i doing wrong? any help will be great! thanks, Ravit :)

import processing.video.*;
Movie myMovie;

void setup() {
  size(600, 400);
  frameRate(30);
  myMovie = new Movie(this, "1.mp4");
  myMovie.loop();
}

void draw() {
  if (myMovie.available()) {
    myMovie.read();
    float  x1 = map(mouseX, 0, width, 0, 3);
    myMovie.speed(x1);
  }
  image(myMovie, 0, 0);
} 

1) How can I make the video play backwards? If I write the following code, I get this error message: (Processing core video:14294): GStreamer-CRITICAL **: get_segment_set_seek: assertion 'start <= stop' failed

    float  x1 = map(mouseX, 0, width, -1, 3)

2) Is there a way to make the playback a little more smooth? There is a lengthy delay between when the mouse is moved and when the video changes playback speeds.

I have code that works in Processing 2 but does not work in Processing 3. Here is the code, and below is a photo of the error that I get:

/**
 * Playback Speed 
 * 
 * Move the cursor across the screen to  
 * change the speed of the video playback. 
 * moving the cursor  farther to the left plays the movie
 * faster forward, moving it farther to the right plays it back 
 * faster backwards. Placing the cursor in the middle of the screen
 * pauses the movie.
 */

import jmcvideo.*;
import processing.opengl.*;
JMCMovie myMovie;



void setup() 
{
  size(320, 240, P2D);
  background(0);

  // Load and play the video in a loop
  myMovie = movieFromDataPath("lincoln_01.mov"); 

  //myMovie.play();
  myMovie.loop();
  //myMovie.bounce();

}

JMCMovie movieFromDataPath(String filename)
{
   return new JMCMovie(this, filename, RGB);
}


void draw() 
{

  image(myMovie, 0, 0, myMovie.width, myMovie.height);
  myMovie.setRate (((width/2.0-mouseX)/(width/2.0))*3.0);

}