I think there are two problem in the code: 

1) the result of newMovementSum/1000 is always 0 because both numbers are integers, so Processing does an integer division. So you should turn one of them into float, for instance float(newMovementSum)/1000 or newMovementSum/1000.0

2) The errors (message, black screen) happen because gstreamer doesn't appear to behave well when the speed() function is called too frequently (here you are doing it every frame). So I would put a condition to make sure it is called no more than once every second. Also easing the newSpeed value would help to make things smoother:

1. import processing.video.*;
2. 
   
3. Movie movie;
4. 
   
5. int numPixels;
6. int[] previousFrame;
7. Capture video;
8. 
   
9. int movementSum;
10. int newMovementSum;
11. 
    
12. float newSpeed = 1;
13. 
    
14. void setup() {
15.   size(320, 240);
16.   background(0);
17.   movie = new Movie(this, "balloon.ogg");
18.   movie.loop();
19. 
    
20.   PFont font = loadFont("DejaVuSans-24.vlw");
21.   textFont(font, 24);
22. 
    
23.   video = new Capture(this, width, height);
24.   video.start();  
25.   numPixels = video.width * video.height;
26.   // Create an array to store the previously captured frame
27.   previousFrame = new int[numPixels];
28.   loadPixels();
29.   
30.   newMovementSum = 1;
31. }
32. 
    
33. void movieEvent(Movie movie) {
34.   movie.read();
35. }
36. 
    
37. void draw() {
38. 
    
39. 
    
40.   if (video.available()) {
41.     // When using video to manipulate the screen, use video.available() and
42.     // video.read() inside the draw() method so that it's safe to draw to the screen
43.     video.read(); // Read the new frame from the camera
44.     video.loadPixels(); // Make its pixels[] array available
45. 
    
46.     movementSum = 0; // Amount of movement in the frame
47.     for (int i = 0; i < numPixels; i++) { // For each pixel in the video frame...
48.       color currColor = video.pixels[i];
49.       color prevColor = previousFrame[i];
50.       // Extract the red, green, and blue components from current pixel
51.       int currR = (currColor >> 16) & 0xFF; // Like red(), but faster
52.       int currG = (currColor >> 8) & 0xFF;
53.       int currB = currColor & 0xFF;
54.       // Extract red, green, and blue components from previous pixel
55.       int prevR = (prevColor >> 16) & 0xFF;
56.       int prevG = (prevColor >> 8) & 0xFF;
57.       int prevB = prevColor & 0xFF;
58.       // Compute the difference of the red, green, and blue values
59.       int diffR = abs(currR - prevR);
60.       int diffG = abs(currG - prevG);
61.       int diffB = abs(currB - prevB);
62.       // Add these differences to the running tally
63.       movementSum += diffR + diffG + diffB;
64.       //newMovementSum = movementSum/1000;
65.       // Render the difference image to the screen
66.       pixels[i] = color(diffR, diffG, diffB);
67.       // The following line is much faster, but more confusing to read
68.       //pixels[i] = 0xff000000 | (diffR << 16) | (diffG << 8) | diffB;
69.       // Save the current color into the 'previous' buffer
70.       previousFrame[i] = currColor;
71.     }
72.     // To prevent flicker from frames that are all black (no movement),
73.     // only update the screen if the image has changed.
74.     if (movementSum > 0) {
75.       //updatePixels();
76.       newMovementSum = movementSum/1000;
77.       println(newMovementSum); // Print the total amount of movement to the console
78.     }
79.   }
80.   image(movie, 0, 0, width, height);
81.   
82.   newSpeed += 0.2 * (float(newMovementSum)/1000 - newSpeed);
83.   if (frameCount % 1000 == 0) {
84.     movie.speed(newSpeed);
85.     fill(240, 20, 30);    
86.   }
87.   text(nfc(newSpeed, 2) + "X", width - 80, 30);
88. }