import org.webrtc.VideoRenderer.I420Frame; //导入依赖的package包/类
@Override
public void setSize(final int width, final int height) {
  Log.d(TAG, "ID: " + id + ". YuvImageRenderer.setSize: " +
      width + " x " + height);
  videoWidth = width;
  videoHeight = height;
  int[] strides = { width, width / 2, width / 2  };
  // Frame re-allocation need to be synchronized with copying
  // frame to textures in draw() function to avoid re-allocating
  // the frame while it is being copied.
  synchronized (frameToRenderQueue) {
    // Clear rendering queue.
    frameToRenderQueue.poll();
    // Re-allocate / allocate the frame.
    yuvFrameToRender = new I420Frame(width, height, strides, null);
    textureFrameToRender = new I420Frame(width, height, null, -1);
    updateTextureProperties = true;
  }
}
 

import org.webrtc.VideoRenderer.I420Frame; //导入依赖的package包/类
private YuvImageRenderer(
    GLSurfaceView surface,
    int x, int y, int width, int height) {
  Log.v(TAG, "YuvImageRenderer.Create");
  this.surface = surface;
  frameToRenderQueue = new LinkedBlockingQueue<I420Frame>(1);
  // Create texture vertices.
  float xLeft = (x - 50) / 50.0f;
  float yTop = (50 - y) / 50.0f;
  float xRight = Math.min(1.0f, (x + width - 50) / 50.0f);
  float yBottom = Math.max(-1.0f, (50 - y - height) / 50.0f);
  float textureVeticesFloat[] = new float[] {
      xLeft, yTop,
      xLeft, yBottom,
      xRight, yTop,
      xRight, yBottom
  };
  textureVertices = directNativeFloatBuffer(textureVeticesFloat);
}
 

import org.webrtc.VideoRenderer.I420Frame; //导入依赖的package包/类
/** Queue |frame| to be uploaded. */
public void queueFrame(final Endpoint stream, I420Frame frame) {
  // Paying for the copy of the YUV data here allows CSC and painting time
  // to get spent on the render thread instead of the UI thread.
  abortUnless(framePool.validateDimensions(frame), "Frame too large!");
  final I420Frame frameCopy = framePool.takeFrame(frame).copyFrom(frame);
  boolean needToScheduleRender;
  synchronized (framesToRender) {
    // A new render needs to be scheduled (via updateFrames()) iff there isn't
    // already a render scheduled, which is true iff framesToRender is empty.
    needToScheduleRender = framesToRender.isEmpty();
    I420Frame frameToDrop = framesToRender.put(stream, frameCopy);
    if (frameToDrop != null) {
      framePool.returnFrame(frameToDrop);
    }
  }
  if (needToScheduleRender) {
    queueEvent(new Runnable() {
        public void run() {
          updateFrames();
        }
      });
  }
}
 

import org.webrtc.VideoRenderer.I420Frame; //导入依赖的package包/类
private void updateFrames() {
  I420Frame localFrame = null;
  I420Frame remoteFrame = null;
  synchronized (framesToRender) {
    localFrame = framesToRender.remove(Endpoint.LOCAL);
    remoteFrame = framesToRender.remove(Endpoint.REMOTE);
  }
  if (localFrame != null) {
    texImage2D(localFrame, yuvTextures[0]);
    framePool.returnFrame(localFrame);
  }
  if (remoteFrame != null) {
    texImage2D(remoteFrame, yuvTextures[1]);
    framePool.returnFrame(remoteFrame);
  }
  abortUnless(localFrame != null || remoteFrame != null,
              "Nothing to render!");
  requestRender();
}
 

import org.webrtc.VideoRenderer.I420Frame; //导入依赖的package包/类
@Override
public void renderFrame(I420Frame frame) {
  synchronized (frameLock) {
    ++framesRendered;
    width = frame.rotatedWidth();
    height = frame.rotatedHeight();
    frameLock.notify();
  }
  VideoRenderer.renderFrameDone(frame);
}
 

import org.webrtc.VideoRenderer.I420Frame; //导入依赖的package包/类
public List<I420Frame> waitForPendingFrames() throws InterruptedException {
  Logging.d(TAG, "Waiting for pending frames");
  synchronized (pendingFrames) {
    while (pendingFrames.isEmpty()) {
      pendingFrames.wait();
    }
    return new ArrayList<I420Frame>(pendingFrames);
  }
}
 

import org.webrtc.VideoRenderer.I420Frame; //导入依赖的package包/类
public void returnBufferLateEndToEnd() throws InterruptedException {
  final CapturerInstance capturerInstance = createCapturer(false /* initialize */);
  final VideoTrackWithRenderer videoTrackWithRenderer =
      createVideoTrackWithFakeAsyncRenderer(capturerInstance.capturer);
  // Wait for at least one frame that has not been returned.
  assertFalse(videoTrackWithRenderer.fakeAsyncRenderer.waitForPendingFrames().isEmpty());

  capturerInstance.capturer.stopCapture();

  // Dispose everything.
  disposeCapturer(capturerInstance);
  disposeVideoTrackWithRenderer(videoTrackWithRenderer);

  // Return the frame(s), on a different thread out of spite.
  final List<I420Frame> pendingFrames =
      videoTrackWithRenderer.fakeAsyncRenderer.waitForPendingFrames();
  final Thread returnThread = new Thread(new Runnable() {
    @Override
    public void run() {
      for (I420Frame frame : pendingFrames) {
        VideoRenderer.renderFrameDone(frame);
      }
    }
  });
  returnThread.start();
  returnThread.join();
}
 

import org.webrtc.VideoRenderer.I420Frame; //导入依赖的package包/类
/** Queue |frame| to be uploaded. */
public void queueFrame(final int stream, I420Frame frame) {
  // Paying for the copy of the YUV data here allows CSC and painting time
  // to get spent on the render thread instead of the UI thread.
  abortUnless(FramePool.validateDimensions(frame), "Frame demasiado grande!");
  final I420Frame frameCopy = framePool.takeFrame(frame).copyFrom(frame);
  queueEvent(new Runnable() {
    public void run() {
      updateFrame(stream, frameCopy);
    }
  });
}
 

import org.webrtc.VideoRenderer.I420Frame; //导入依赖的package包/类
private void updateFrame(int stream, I420Frame frame) {
  int[] textures = yuvTextures[stream];
  texImage2D(frame, textures);
  framePool.returnFrame(frame);

  requestRender();
}
 

import org.webrtc.VideoRenderer.I420Frame; //导入依赖的package包/类
private void texImage2D(I420Frame frame, int[] textures) {
  for (int i = 0; i < 3; ++i) {
    ByteBuffer plane = frame.yuvPlanes[i];
    GLES20.glActiveTexture(GLES20.GL_TEXTURE0 + i);
    GLES20.glBindTexture(GLES20.GL_TEXTURE_2D, textures[i]);
    int w = i == 0 ? frame.width : frame.width / 2;
    int h = i == 0 ? frame.height : frame.height / 2;
    abortUnless(w == frame.yuvStrides[i], frame.yuvStrides[i] + "!=" + w);
    GLES20.glTexImage2D(
                        GLES20.GL_TEXTURE_2D, 0, GLES20.GL_LUMINANCE, w, h, 0,
                        GLES20.GL_LUMINANCE, GLES20.GL_UNSIGNED_BYTE, plane);
  }
  checkNoGLES2Error();
}
 

import org.webrtc.VideoRenderer.I420Frame; //导入依赖的package包/类
public void returnFrame(I420Frame frame) {
    long desc = summarizeFrameDimensions(frame);
    synchronized (availableFrames) {
        LinkedList<I420Frame> frames = availableFrames.get(desc);
        if (frames == null) {
            throw new IllegalArgumentException("Unexpected frame dimensions");
        }
        frames.add(frame);
    }
}
 

import org.webrtc.VideoRenderer.I420Frame; //导入依赖的package包/类
/** Validate that |frame| can be managed by the pool. */
public static boolean validateDimensions(I420Frame frame) {
    return frame.width < MAX_DIMENSION && frame.height < MAX_DIMENSION &&
            frame.yuvStrides[0] < MAX_DIMENSION &&
            frame.yuvStrides[1] < MAX_DIMENSION &&
            frame.yuvStrides[2] < MAX_DIMENSION;
}
 

import org.webrtc.VideoRenderer.I420Frame; //导入依赖的package包/类
private static long summarizeFrameDimensions(I420Frame frame) {
    long ret = frame.width;
    ret = ret * MAX_DIMENSION + frame.height;
    ret = ret * MAX_DIMENSION + frame.yuvStrides[0];
    ret = ret * MAX_DIMENSION + frame.yuvStrides[1];
    ret = ret * MAX_DIMENSION + frame.yuvStrides[2];
    return ret;
}
 

import org.webrtc.VideoRenderer.I420Frame; //导入依赖的package包/类
private YuvImageRenderer(
    GLSurfaceView surface, int id,
    int x, int y, int width, int height,
    ScalingType scalingType) {
  Log.d(TAG, "YuvImageRenderer.Create id: " + id);
  this.surface = surface;
  this.id = id;
  this.scalingType = scalingType;
  frameToRenderQueue = new LinkedBlockingQueue<I420Frame>(1);
  // Create texture vertices.
  texLeft = (x - 50) / 50.0f;
  texTop = (50 - y) / 50.0f;
  texRight = Math.min(1.0f, (x + width - 50) / 50.0f);
  texBottom = Math.max(-1.0f, (50 - y - height) / 50.0f);
  float textureVeticesFloat[] = new float[] {
      texLeft, texTop,
      texLeft, texBottom,
      texRight, texTop,
      texRight, texBottom
  };
  textureVertices = directNativeFloatBuffer(textureVeticesFloat);
  // Create texture UV coordinates.
  float textureCoordinatesFloat[] = new float[] {
      0, 0, 0, 1, 1, 0, 1, 1
  };
  textureCoords = directNativeFloatBuffer(textureCoordinatesFloat);
  updateTextureProperties = false;
}
 

import org.webrtc.VideoRenderer.I420Frame; //导入依赖的package包/类
/** Queue |frame| to be uploaded. */
public void queueFrame(final String stream, I420Frame frame) {
	// Paying for the copy of the YUV data here allows CSC and painting time
	// to get spent on the render thread instead of the UI thread.
	abortUnless(FramePool.validateDimensions(frame), "Frame too large!");
	// boolean needToScheduleRender;
	synchronized (frameDescriptions) {
		// A new render needs to be scheduled (via updateFrames()) iff there
		// isn't
		// already a render scheduled, which is true iff framesToRender is
		// empty.
		// needToScheduleRender = frameDescriptions.isEmpty();
		FrameDescription desc = frameDescriptions.get(stream);
		// if (desc == null)
		// {
		// desc = createFrameDescription(stream);
		// }
		if (desc != null && desc.bufferIndex != -1) {
			I420Frame frameToDrop = desc.frameToRender;
			if (desc.bufferIndex != -1) {
				final I420Frame frameCopy = framePool.takeFrame(frame)
						.copyFrom(frame);
				desc.frameToRender = frameCopy;
			}
			if (frameToDrop != null) {
				framePool.returnFrame(frameToDrop);
			}
		}
	}
	long dt = System.nanoTime() - mLastRendered;
	if (dt > MIN_NANOS_BETWEEN_FRAMES
			&& mRenderRequested.compareAndSet(false, true)) {
		queueEvent(new Runnable() {
			public void run() {
				updateFrames();
			}
		});
	}
}
 

import org.webrtc.VideoRenderer.I420Frame; //导入依赖的package包/类
private void texImage2D(I420Frame frame, int[] textures) {
	for (int i = 0; i < 3; ++i) {
		ByteBuffer plane = frame.yuvPlanes[i];
		GLES20.glActiveTexture(GLES20.GL_TEXTURE0 + i);
		GLES20.glBindTexture(GLES20.GL_TEXTURE_2D, textures[i]);
		int w = i == 0 ? frame.width : frame.width / 2;
		int h = i == 0 ? frame.height : frame.height / 2;
		abortUnless(w == frame.yuvStrides[i], frame.yuvStrides[i] + "!="
				+ w);
		GLES20.glTexImage2D(GLES20.GL_TEXTURE_2D, 0, GLES20.GL_LUMINANCE,
				w, h, 0, GLES20.GL_LUMINANCE, GLES20.GL_UNSIGNED_BYTE,
				plane);
	}
	checkNoGLES2Error();
}
 

import org.webrtc.VideoRenderer.I420Frame; //导入依赖的package包/类
public void returnFrame(I420Frame frame) {
  long desc = summarizeFrameDimensions(frame);
  synchronized (availableFrames) {
    LinkedList<I420Frame> frames = availableFrames.get(desc);
    if (frames == null) {
      throw new IllegalArgumentException("Unexpected frame dimensions");
    }
    frames.add(frame);
  }
}
 

import org.webrtc.VideoRenderer.I420Frame; //导入依赖的package包/类
/** Validate that |frame| can be managed by the pool. */
public static boolean validateDimensions(I420Frame frame) {
  return frame.width < MAX_DIMENSION && frame.height < MAX_DIMENSION &&
      frame.yuvStrides[0] < MAX_DIMENSION &&
      frame.yuvStrides[1] < MAX_DIMENSION &&
      frame.yuvStrides[2] < MAX_DIMENSION;
}
 

import org.webrtc.VideoRenderer.I420Frame; //导入依赖的package包/类
private static long summarizeFrameDimensions(I420Frame frame) {
  long ret = frame.width;
  ret = ret * MAX_DIMENSION + frame.height;
  ret = ret * MAX_DIMENSION + frame.yuvStrides[0];
  ret = ret * MAX_DIMENSION + frame.yuvStrides[1];
  ret = ret * MAX_DIMENSION + frame.yuvStrides[2];
  return ret;
}
 

import org.webrtc.VideoRenderer.I420Frame; //导入依赖的package包/类
@Override
public void setSize(final int width, final int height) {
  Log.v(TAG, "YuvImageRenderer.setSize: " + width + " x " + height);
  int[] strides = { width, width / 2, width / 2  };
  // Frame re-allocation need to be synchronized with copying
  // frame to textures in draw() function to avoid re-allocating
  // the frame while it is being copied.
  synchronized (frameToRenderQueue) {
    // Clear rendering queue
    frameToRenderQueue.poll();
    // Re-allocate / allocate the frame
    frameToRender = new I420Frame(width, height, strides, null);
  }
}