Alternative solution to ytdl-core

[iim-ayush]

I did a deep research where things are pilled up even in New Voice API .
I got very interesting news for both things
First Test :
Code :

var i_c = 0
client.on("message", async (message) => {
  if (message.content === "!start") {
    await procedure(message);
    }
});

const procedure = async (message) => {
  i_c++
  console.log(`New Prodecure ${i_c}`);
  
  // Connect to VC and play a song
  let connection = await join_vc(message);
  let stream = await ytdl(YOUTUBE_LINKS[0]);
  var source = createAudioResource(stream, { inputType: StreamType.Opus , inlineVolume : true })
  var player = createAudioPlayer()
  player.play(source)
  connection.subscribe(player)

  player.once(AudioPlayerStatus.Idle, () =>{
    console.log(stream)
    console.log('xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx')
    console.log(source)
  })
  // Let it play for 10 seconds.
  await new Promise((resolve) => {
    setTimeout(resolve, 10_000);
  });

  player.stop()
  connection.destroy()

  return;
};

Basically I tried to create a stream with ytdl-core-discord, and then passed it to createAudioResource and played that. After player has played 10 sec, then end the player and check if stream(ytdl-core-discord one) and source(createAudioResource one) gets destroyed or not.
Logs here [Just remember the xxxxx line for differentiating both sources]

As we can see here, stream didn't get destroyed while source a.k.a Audio Resource got destroyed after player has ended playing audio.

Second Test :
Code :

var i_c = 0
client.on("message", async (message) => {
    if (message.content === "!start") {
      await procedure(message);
      }
  });
  
  const procedure = async (message) => {
    i_c++
    console.log(`New Prodecure ${i_c}`);
    
     // Connect to VC and play a song
    let connection = await join_vc(message);
    const info = await ytdl.getInfo(YOUTUBE_LINKS[0])
    let stream = filter(info.formats)[0].url //filters opus audio from all formats and get url of first.
    var source = createAudioResource(stream, { inputType: StreamType.Opus , inlineVolume : true })
    var player = createAudioPlayer()
    player.play(source)
    connection.subscribe(player)
  
    player.once(AudioPlayerStatus.Idle, () =>{
      console.log(source)
    })
    // Let it play for 10 seconds.
    await new Promise((resolve) => {
      setTimeout(resolve, 10_000);
    });
  
    player.stop()
    connection.destroy()
  
    return;
  };

function filter(format) {
    var results = []
    format.forEach((ele) => {
        if(ele.codecs === 'opus' && ele.container === 'webm' && ele.audioSampleRate === '48000'){
            results.push(ele)
        }
    })
    return results
}

Now I tried to do something different. Instead ytdl-core-discord create a stream, I let Voice API to create a stream for my url. After player has played 10 sec, then end the player and check if Audio Resource gets destroyed or not. Then logging the results of Audio Resource only (since I never created ytdl stream).

Logs here

As we can clearly see that now everything including Audio Resource gets destroyed. So in my both tests, I found out that the stream (YTDL - core one) doesn't get destroyed after the player has stopped playing. So in my perspective, either it is an issue of DJS-voice for not closing that stream after the player.stop() has been called or it is a problem of ytdl-core.

So I wanted to know, if my thinking and results are true according to you or not. So let me know by commenting in this discussion.

[iCrawl]

Without going into any of the technicalities about this (I'll leave that to @amishshah).

You are advised to use youtube-dl as we did in our examples for this exact reason. We found out ytdl-core (and derivatives are just broken more often than not).

[iim-ayush]

I know the youtube-dl example, but I never used ytdl stream in second code ( just used once for getting info) and second code is as comparable to using youtube-dl in examples. I, personally tested your example code and my second code. Both show no sign of memory leak.