Is it inefficient to use more than two Swapchains for buffering? (iOS, CVPixelBuffer)

[Windowline]

• I'm using swapchain with CVPixelBuffer on iOS.

    uint64_t swapchain_flags =
        SwapChain::CONFIG_READABLE | SwapChain::CONFIG_TRANSPARENT | SwapChain::CONFIG_APPLE_CVPIXELBUFFER;
    auto swapchain = engine_->createSwapChain(cvpixelbuffer_ptr, swapchain_flags);
  

• Then, the rendered result in the cvpixelbuffer must be used in another module, and at that time, synchronization must be maintained.
  (For zero-copy, I used CVPixelBuffer as swapchain)

• To effectively synchronize this, I buffered the fence and swapchain. The code is below.

  struct InFlightFrame {
      filament::Fence* fence = nullptr;
      filament::SwapChain* swapchain = nullptr;
      void* pixel_buffer = nullptr;
  };
  
  // ..
  
  std::vector<InFlightFrame> in_flight_frames_; // size: 2, double buffering
  
  // @return: inflight frames index (0 or 1)
  int render() { 
        InFlightFrame& prev_frame = in_flight_frames_[in_flight_frame_index_];
        if (prev_frame.fence != nullptr) {
            filament::Fence::waitAndDestroy(prev_frame.fence);
            prev_frame.fence = nullptr;
         }
        
       int rendered_index = in_flight_frame_index_;
       
       in_flight_frame_index_ = (in_flight_frame_index_ + 1) % in_flight_frames_.size();
       InFlightFrame& curr_frame = in_flight_frames_[in_flight_frame_index_];
       assert(curr_frame.fence == nullptr);
       
       // Update.. Uniforms
      
       if (renderer_->beginFrame(curr_frame.swapchain)) {
         // render..
         renderer_->endFrame();
         curr_frame.fence = engine_->createFence();
       }
      
       return rendered_index;
  }
  

It seems that in general, multiple swapchains are not used for buffering.
Is there a better way?

Thank you!.