Add support for scaling textures in AndroidVideoCapturer.

talk/app/webrtc/androidtests/src/org/webrtc/VideoCapturerAndroidTestFixtures.java

 /*
  * libjingle
  * Copyright 2015 Google Inc.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
  *
  *  1. Redistributions of source code must retain the above copyright notice,
  *     this list of conditions and the following disclaimer.
  *  2. Redistributions in binary form must reproduce the above copyright notice,
@@ skipping 25 matching lines @@
 import java.util.ArrayList;
 import java.util.List;
 import java.util.concurrent.CountDownLatch;
 
 import static junit.framework.Assert.*;
 
 public class VideoCapturerAndroidTestFixtures {
   static class RendererCallbacks implements VideoRenderer.Callbacks {
     private int framesRendered = 0;
     private Object frameLock = 0;
+    private int width = 0;
+    private int height = 0;
 
     @Override
     public void renderFrame(I420Frame frame) {
       synchronized (frameLock) {
         ++framesRendered;
+        width = frame.width;

[magjed_webrtc, 2015/11/25 13:38:28]

Maybe use frame.rotatedWidth(), because you don't care about the frames internal
rotation.

[perkj_webrtc, 2015/11/25 20:56:20]

Done.

+        height = frame.height;
         frameLock.notify();
       }
       VideoRenderer.renderFrameDone(frame);
     }
 
+    public int frameWidth() {
+      synchronized (frameLock) {
+        return width;
+      }
+    }
+
+    public int frameHeight() {
+      synchronized (frameLock) {
+        return height;
+      }
+    }
+
     public int WaitForNextFrameToRender() throws InterruptedException {
       synchronized (frameLock) {
         frameLock.wait();
         return framesRendered;
       }
     }
   }
 
   static class FakeAsyncRenderer implements VideoRenderer.Callbacks {
     private final List<I420Frame> pendingFrames = new ArrayList<I420Frame>();
@@ skipping 468 matching lines @@
     // Since we don't call returnBuffer, we should get a starvation message.
     assertEquals("Camera failure. Client must return video buffers.", events.WaitForCameraError());
 
     capturer.stopCapture();
     for (long timeStamp : observer.getCopyAndResetListOftimeStamps()) {
       capturer.returnBuffer(timeStamp);
     }
     capturer.dispose();
     assertTrue(capturer.isReleased());
   }
+
+  static public void scaleCameraOutput(VideoCapturerAndroid capturer) throws InterruptedException {
+    PeerConnectionFactory factory = new PeerConnectionFactory();
+    VideoSource source =
+        factory.createVideoSource(capturer, new MediaConstraints());
+    VideoTrack track = factory.createVideoTrack("dummy", source);
+    RendererCallbacks renderer = new RendererCallbacks();
+    track.addRenderer(new VideoRenderer(renderer));
+    assertTrue(renderer.WaitForNextFrameToRender() > 0);
+
+    final int startWidth = renderer.frameWidth();
+    final int startHeight = renderer.frameHeight();
+    final int frameRate = 30;
+    final int scaledWidth = startWidth / 2;
+    final int scaledHeight = startHeight / 2;
+
+    // Request the captured frames to be scaled.
+    capturer.onOutputFormatRequest(scaledWidth, scaledHeight, frameRate);
+
+    boolean gotExpectedResolution = false;
+    int numberOfInspectedFrames = 0;
+
+    do {
+      renderer.WaitForNextFrameToRender();
+      ++numberOfInspectedFrames;
+      // Check the frame size. The actual width and height depend on how the capturer is mounted.
+      final boolean identicalResolution = (renderer.frameWidth() == scaledWidth
+          &&  renderer.frameHeight() == scaledHeight);
+      final boolean flippedResolution = (renderer.frameWidth() == scaledHeight
+          && renderer.frameHeight() == scaledWidth);
+
+      gotExpectedResolution = identicalResolution || flippedResolution;
+    } while (!gotExpectedResolution && numberOfInspectedFrames < 30);
+
+    source.stop();
+    track.dispose();
+    source.dispose();
+    factory.dispose();
+    assertTrue(capturer.isReleased());
+
+    assertTrue(gotExpectedResolution);
+  }
+
 }