GPUImage源码解读(二十一)

GPUImageThreeInputFilter 可以接收三个帧缓存对象的输入。它的作用可以将三个帧缓存对象的输入合并成一个帧缓存对象的输出。它继承自GPUImageTwoInputFilter，与GPUImageTwoInputFilter类似，主要增加了第三个帧缓存对象处理的相关操作。

• 实例变量。主要增加了与第三个帧缓存对象相关的实例变量

  “`

  @interface GPUImageThreeInputFilter : GPUImageTwoInputFilter
  {
  GPUImageFramebuffer *thirdInputFramebuffer;

  GLint filterThirdTextureCoordinateAttribute;
  GLint filterInputTextureUniform3;
  GPUImageRotationMode inputRotation3;
  GLuint filterSourceTexture3;
  CMTime thirdFrameTime;

  BOOL hasSetSecondTexture, hasReceivedThirdFrame, thirdFrameWasVideo;
  BOOL thirdFrameCheckDisabled;
  }

// 需不需要检查第三个纹理输入
- (void)disableThirdFrameCheck;

- 方法列表。

// 增加方法
- (void)disableThirdFrameCheck;
// 重写方法
- (void)newFrameReadyAtTime:(CMTime)frameTime atIndex:(NSInteger)textureIndex;
- (void)renderToTextureWithVertices:(const GLfloat )vertices textureCoordinates:(const GLfloat )textureCoordinates;

• (void)newFrameReadyAtTime:(CMTime)frameTime atIndex:(NSInteger)textureIndex;
  {
  // You can set up infinite update loops, so this helps to short circuit them
  if (hasReceivedFirstFrame && hasReceivedSecondFrame && hasReceivedThirdFrame)
  {
  return;
  }

  BOOL updatedMovieFrameOppositeStillImage = NO;

  if (textureIndex == 0)
  {
  hasReceivedFirstFrame = YES;
  firstFrameTime = frameTime;
  // 如果不检查第二个纹理输入，则直接默认已经接收了第二个纹理
  if (secondFrameCheckDisabled)
  {
  hasReceivedSecondFrame = YES;
  }
  // 如果不检查第三个纹理输入，则直接默认已经接收了第三个纹理
  if (thirdFrameCheckDisabled)
  {
  hasReceivedThirdFrame = YES;
  }

  if (!CMTIME_IS_INDEFINITE(frameTime))
  {
      if CMTIME_IS_INDEFINITE(secondFrameTime)
      {
          updatedMovieFrameOppositeStillImage = YES;
      }
  }
  

  }
  else if (textureIndex == 1)
  {
  hasReceivedSecondFrame = YES;
  secondFrameTime = frameTime;

  // 如果不检查第一个纹理输入，则直接默认已经接收了第一个纹理
  if (firstFrameCheckDisabled)
  {
      hasReceivedFirstFrame = YES;
  }
  
   // 如果不检查第三个纹理输入，则直接默认已经接收了第三个纹理
  if (thirdFrameCheckDisabled)
  {
      hasReceivedThirdFrame = YES;
  }
  
  if (!CMTIME_IS_INDEFINITE(frameTime))
  {
      if CMTIME_IS_INDEFINITE(firstFrameTime)
      {
          updatedMovieFrameOppositeStillImage = YES;
      }
  }
  

  }
  else
  {
  hasReceivedThirdFrame = YES;
  thirdFrameTime = frameTime;
  // 如果不检查第一个纹理输入，则直接默认已经接收了第一个纹理
  if (firstFrameCheckDisabled)
  {
  hasReceivedFirstFrame = YES;
  }
  // 如果不检查第二个纹理输入，则直接默认已经接收了第二个纹理
  if (secondFrameCheckDisabled)
  {
  hasReceivedSecondFrame = YES;
  }

  if (!CMTIME_IS_INDEFINITE(frameTime))
  {
      if CMTIME_IS_INDEFINITE(firstFrameTime)
      {
          updatedMovieFrameOppositeStillImage = YES;
      }
  }
  

  }

  // || (hasReceivedFirstFrame && secondFrameCheckDisabled) || (hasReceivedSecondFrame && firstFrameCheckDisabled)
  //如果已经接收了三个纹理输入或者是有效帧，则渲染
  if ((hasReceivedFirstFrame && hasReceivedSecondFrame && hasReceivedThirdFrame) || updatedMovieFrameOppositeStillImage)
  {
  static const GLfloat imageVertices[] = {
  -1.0f, -1.0f,
  1.0f, -1.0f,
  -1.0f, 1.0f,
  1.0f, 1.0f,
  };

  [self renderToTextureWithVertices:imageVertices textureCoordinates:[[self class] textureCoordinatesForRotation:inputRotation]];
  
  [self informTargetsAboutNewFrameAtTime:frameTime];
  
  hasReceivedFirstFrame = NO;
  hasReceivedSecondFrame = NO;
  hasReceivedThirdFrame = NO;
  

  }
  }

  • (void)renderToTextureWithVertices:(const GLfloat )vertices textureCoordinates:(const GLfloat )textureCoordinates;
    {
    if (self.preventRendering)
    {
    [firstInputFramebuffer unlock];
    [secondInputFramebuffer unlock];
    [thirdInputFramebuffer unlock];
    return;
    }

  [GPUImageContext setActiveShaderProgram:filterProgram];
  outputFramebuffer = [[GPUImageContext sharedFramebufferCache] fetchFramebufferForSize:[self sizeOfFBO] textureOptions:self.outputTextureOptions onlyTexture:NO];
  [outputFramebuffer activateFramebuffer];
  if (usingNextFrameForImageCapture)
  {
  [outputFramebuffer lock];
  }

  [self setUniformsForProgramAtIndex:0];

  glClearColor(backgroundColorRed, backgroundColorGreen, backgroundColorBlue, backgroundColorAlpha);
  glClear(GL_COLOR_BUFFER_BIT);

  // 激活第一个纹理
  glActiveTexture(GL_TEXTURE2);
  glBindTexture(GL_TEXTURE_2D, [firstInputFramebuffer texture]);
  glUniform1i(filterInputTextureUniform, 2);

  // 激活第二个纹理
  glActiveTexture(GL_TEXTURE3);
  glBindTexture(GL_TEXTURE_2D, [secondInputFramebuffer texture]);
  glUniform1i(filterInputTextureUniform2, 3);

  // 激活第三个纹理
  glActiveTexture(GL_TEXTURE4);
  glBindTexture(GL_TEXTURE_2D, [thirdInputFramebuffer texture]);
  glUniform1i(filterInputTextureUniform3, 4);

  glVertexAttribPointer(filterPositionAttribute, 2, GL_FLOAT, 0, 0, vertices);
  glVertexAttribPointer(filterTextureCoordinateAttribute, 2, GL_FLOAT, 0, 0, textureCoordinates);
  glVertexAttribPointer(filterSecondTextureCoordinateAttribute, 2, GL_FLOAT, 0, 0, [[self class] textureCoordinatesForRotation:inputRotation2]);
  glVertexAttribPointer(filterThirdTextureCoordinateAttribute, 2, GL_FLOAT, 0, 0, [[self class] textureCoordinatesForRotation:inputRotation3]);

  glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
  [firstInputFramebuffer unlock];
  [secondInputFramebuffer unlock];
  [thirdInputFramebuffer unlock];
  if (usingNextFrameForImageCapture)
  {
  dispatch_semaphore_signal(imageCaptureSemaphore);
  }
  }

  “`