Multiple calls but it’s 3 different models in sequence that are called.
Model A and B are rather heavy on GRUs and LSTMs together with a few (1D) convolutions.
B also uses some Gaussian upsampling mechanism with a bit of manual implementation.
Both are significantly slower in the “optimize for mobile” version.
The biggest part of it is this layer
  

      github.com
  

  
    as-ideas/ForwardTacotron/blob/203daff3e90536d8c4f8ca8f28df5364361ce1d1/models/common_layers.py#L39



      
      
                  self.conv = nn.Conv1d(in_channels, out_channels, kernel, stride=1, padding=kernel // 2, bias=False)
                  self.bnorm = nn.BatchNorm1d(out_channels)
                  self.relu = relu
          
              def forward(self, x: torch.Tensor) -> torch.Tensor:
                  x = self.conv(x)
                  x = F.relu(x) if self.relu is True else x
                  return self.bnorm(x)
          
          
          class CBHG(nn.Module):
          
              def __init__(self,
                           K: int,
                           in_channels: int,
                           channels: int,
                           proj_channels: list,
                           num_highways: int,
                           dropout: float = 0.5) -> None:
                  super().__init__()
          
      
    
  


  

  
    
    
  

  


The rest is also quite similar to the model in this repo.
Model C is mostly transposed 1D convolutions and here the performance is pretty much the same (looks like this melgan-neurips/modules.py at 6488045bfba1975602288de07a58570c7b4d66ea · descriptinc/melgan-neurips · GitHub)