Recherche avancée

Médias (0)

Mot : - Tags -/metadatas

Aucun média correspondant à vos critères n’est disponible sur le site.

Autres articles (29)

  • HTML5 audio and video support

    13 avril 2011, par

    MediaSPIP uses HTML5 video and audio tags to play multimedia files, taking advantage of the latest W3C innovations supported by modern browsers.
    The MediaSPIP player used has been created specifically for MediaSPIP and can be easily adapted to fit in with a specific theme.
    For older browsers the Flowplayer flash fallback is used.
    MediaSPIP allows for media playback on major mobile platforms with the above (...)

  • De l’upload à la vidéo finale [version standalone]

    31 janvier 2010, par

    Le chemin d’un document audio ou vidéo dans SPIPMotion est divisé en trois étapes distinctes.
    Upload et récupération d’informations de la vidéo source
    Dans un premier temps, il est nécessaire de créer un article SPIP et de lui joindre le document vidéo "source".
    Au moment où ce document est joint à l’article, deux actions supplémentaires au comportement normal sont exécutées : La récupération des informations techniques des flux audio et video du fichier ; La génération d’une vignette : extraction d’une (...)

  • Support audio et vidéo HTML5

    10 avril 2011

    MediaSPIP utilise les balises HTML5 video et audio pour la lecture de documents multimedia en profitant des dernières innovations du W3C supportées par les navigateurs modernes.
    Pour les navigateurs plus anciens, le lecteur flash Flowplayer est utilisé.
    Le lecteur HTML5 utilisé a été spécifiquement créé pour MediaSPIP : il est complètement modifiable graphiquement pour correspondre à un thème choisi.
    Ces technologies permettent de distribuer vidéo et son à la fois sur des ordinateurs conventionnels (...)

Sur d’autres sites (3870)

  • Discord bot stops playing music at a certain iteration

    3 mai 2023, par denisnumb

    I'm using the following code to play music in a discord voice channel :

    


    import discord
import asyncio
from yt_dlp import YoutubeDL

YDL_OPTIONS = {
    'format': 'bestaudio/best', 
}

FFMPEG_OPTIONS = {
    'before_options': '-reconnect 1 -reconnect_streamed 1 -reconnect_delay_max 5', 
    'options': '-vn'
}

bot = discord.Client(intents=discord.Intents.all())

async def get_source_url(url: str) -> str:
    with YoutubeDL(YDL_OPTIONS) as ydl:
        return ydl.extract_info(url, download=False).get('url')

@bot.slash_command(name='play')
async def __play(ctx, url: str) -> None:
    source = await get_source_url(url)
    vc = await ctx.author.voice.channel.connect()
    vc.play(discord.FFmpegPCMAudio(source=source, **FFMPEG_OPTIONS))

    while vc.is_playing() or vc.is_paused():
        await asyncio.sleep(1)

    await vc.disconnect()

bot.run('TOKEN')


    


    The principle of operation is as follows :

    


      

    1. The /play command handler receives a url argument, in the form of a link to a live stream from YouTube : https://youtu.be/jfKfPfyJRdk (or any other video)

      


    2. 


    3. The link is passed to the get_source_url function, which, using the yt-dlp library, returns a direct link to the sound from the video

      


    4. 


    5. The direct link is passed via discord.FFmpegPCMAudio to the ffmpeg program, which then returns audio bytes for transmission to the discord voice channel via the vc.play method

      


    6. 


    



    


    Problem :

    


    Bot is hosted on the virtual hosting server aeza, OS - Ubuntu Server 22.04. I installed the ffmpeg version 4.4.2 with the command sudo apt install ffmpeg.

    


    On the first day everything worked fine, but the next day the bot began to steadily stop playing music at the same moment in different videos (this moment is different for each video). Restarting the bot or server did not help.

    


    Only reinstalling the operating system helps, but also only for one day.

    


    Specific problem :

    


    I checked the execution of every single line of the discord.VoiceClient.play method, including all methods called internally. It turned out that the bot hangs every time on the same iteration of the cycle of receiving and sending bytes. Namely, on the first line of the discord.FFmpegPCMAudio.read method, that is does not receive data from ffmpeg and waits indefinitely.

    



    


    Source of the problem :

    


    The problem is not with a specific ffmpeg :

    


      

    • I also installed ffmpeg on another version 5.1.2 and the problem was repeated on it.
    • 


    


    The problem is not Ubuntu Server :

    


      

    • I changed OS Ubuntu Server to Debian 11 and it's the same there
    • 


    


    The problem is not in Linux :

    


      

    • When I put the same OS on my virtual machine, everything worked fine with any version of ffmpeg.
    • 


    



    


    So the problem is on the hosting side ? I asked those. support to change the server itself and the location of the location. Changed from Sweden to Germany - the same result.

    


    If the data does not come from ffmpeg, then you need to find out what is wrong in the program itself. When calling, I pass the -loglevel debug argument, which shows the most detailed report on the program's operation - all debugging information is displayed, but there are no errors on the "hung" iteration.

    


    What could be the problem ?

    



    


    UPD 03.05.2023 : I reinstalled OS Ubuntu Server again and the bot works now. But obviously not for long. Maybe I need to clear some cache ?

    


  • FFmpeg - RTMP streaming from NodeJS, stream is faster than realtime

    6 avril 2023, par Weston

    My goal is to render a canvas in Node, and stream that canvas to an RTMP server (Twitch ultimately, but for now I'm testing on a local RTMP server). The standard way to stream to RTMP seems to be ffmpeg, so I'm using that, spawned as a child process from within NodeJS.

    


    I've tried a bunch of different combinations of techniques and ffmpeg params to get a consistent framerate and a stream at "realtime" speed, but can't figure it out. Here's the paths I've gone down so far

    


    Render canvas and send input in continuous interval

    


    import { createCanvas } from 'canvas';

const canvas = createCanvas(1920, 1080);
const ctx = canvas.getContext('2d');

const fps = 30;
const ffmpeg = spawn('ffmpeg', [
  '-re',
  '-framerate', String(.fps),
  '-r', String(fps),

  '-i', '-',
  
  '-vcodec', 'libx264',
  '-r', String(fps),
  '-s', '1920x1080',
  '-g:v', String(2*fps),
  '-c:a', 'aac',
  '-f', 'flv', 'rtmp://127.0.0.1/live'
]);
ffmpeg.stdout.pipe(process.stdout)
ffmpeg.stderr.pipe(process.stderr)


const send = () => {
  ctx.fillStyle = 'red'
  ctx.fillRect(0, 0, 1920, 1080);
  ctx.font = '100px Arial';
  ctx.fillStyle = 'black'
  ctx.fillText(new Date().toLocaleString(), 500, 500);
  ffmpeg.stdin.write(canvas.toBuffer())
  setImmediate(() => send())
}
send()


    


    Observations

    


      

    • Took about 35 seconds for the stream to actually start (I think because of ffmpeg needing some amount of time to analyze the input ?)
    • 


    • Frame rate extremely below what I set it to, and "speed" also very low, although I'm not 100% sure what this means. example log Frame=  906 fps=3.9 q=29.0 size= 311kB time=00:00:27.83 bitrate= 91.5kbits/s speed=0.119x
    • 


    • Stream behavior

        

      • Takes about a minute to load once opened in VLC
      • 


      • Timer on the stream starts about 1 minute behind real time, stays stuck on a single second for 30+ seconds, then shoots up a few seconds quickly, and gets stuck again
      • 


      


    • 


    


    I had a hunch here that at least some of the reason for the strange behavior was that rendering the canvas in the same loop that I send input to ffmpeg in was too slow to achieve 30 FPS.

    


    Render canvas in separate interval from ffmpeg input interval

    


    Only render canvas FPS-times per second

    


    Continue sending input to ffmpeg as fast as possible

    


    import { createCanvas } from 'canvas';

const canvas = createCanvas(1920, 1080);
const ctx = canvas.getContext('2d');

let buffer = canvas.toBuffer();

const fps = 30;
const ffmpeg = spawn('ffmpeg', [
  ...same as before
]);

const render = () => {
  ctx.fillStyle = 'red'
  ctx.fillRect(0, 0, 1920, 1080);
  ctx.font = '100px Arial';
  ctx.fillStyle = 'black'
  ctx.fillText(new Date().toLocaleString(), 500, 500);
  buffer = canvas.toBuffer();
  setTimeout(() => render(), 1/fps)
}
render();

const send = () => {
  ffmpeg.stdin.write(buffer)
  setImmediate(() => send())
}
send()


    


    Observations

    


      

    • ffmpeg starts streaming almost immediately
    • 


    • fps starts out around 16, takes a couple seconds to hit 28, and then 30 more seconds to hit 30fps. speed much closer to 1x, but not quite all the way. example log frame=15421 fps= 30 q=29.0 size=    4502kB time=00:08:31.66 bitrate=  72.1kbits/s speed=0.994x      
    • 


    • Stream behavior

        

      • Takes about 5 seconds to load once opened in VLC
      • 


      • Timer stays stuck on the same second for multiple minutes
      • 


      


    • 


    


    My hunch here for the stream being stuck on 1 timestamp is that while ffmpeg is sending frames out at 30 frames per second, I'm sending it frames much quicker than that. So in the first 1st of a second of streaming

    


      

    1. Canvas renders with timestamp T 30 times
    2. 


    3. send runs N times where N is likely way higher than 30, sending ffmpeg N frames with the current timestamp
    4. 


    5. ffmpeg now has N frames with timestamp T on them, but can only send them out 30 per second, so it takes more than 1 second for the timestamp on the screen to change
    6. 


    


    Only send ffmpeg a frame every 1/FPS second

    


    Same as before, but instead of sending ffmpeg frames as quickly as possible, only send it FPS frames every second.

    


    import { createCanvas } from 'canvas';

const canvas = createCanvas(1920, 1080);
const ctx = canvas.getContext('2d');

let buffer = canvas.toBuffer();

const fps = 30;
const ffmpeg = spawn('ffmpeg', [
  ...same as before
]);

const render = () => {
  ...same as before
}
render();

const send = () => {
  ffmpeg.stdin.write(buffer)
  setTimeout(() => send(), 1/fps)
}
send()


    


    Observations

    


      

    • ffmpeg takes a few seconds to start streaming
    • 


    • fps starts out high, around 28, and over the next minute or so drops down to 16. Speed drops along with it. example log frame= 1329 fps= 16 q=29.0 size=     463kB time=00:00:41.93 bitrate=  90.5kbits/s speed= 0.5x
    • 


    • Stream behavior

        

      • Takes about 10 seconds to load once opened in VLC
      • 


      • Timer increases about twice as fast as expected, then gets hung on one second for a bit, and then starts increasing again at same rate
      • 


      


    • 


    



    


    I'll stop there, but tl ;dr I've tried a whole bunch of different combinations of -re, -framerate, -fps_mode, -r ffmpeg args, and some other techniques in the code like continuing to use setImmediate to send frames, but use a date comparison to actually send a frame at an FPS rate. I'm sure there's probably some fundamental video streaming knowledge I'm missing, so I'm just looking for any sort of guidance on how I can get my canvas to stream at a "realtime" speed, or whatever I could be missing here.

    


  • FFmpeg - RTMP streaming from Node, stream is faster than realtime

    31 mars 2023, par Weston

    My goal is to render a canvas in Node, and stream that canvas to an RTMP server (Twitch ultimately, but testing on a local RTMP server). The standard way to stream to RTMP seems to be ffmpeg, so I'm using that, spawned as a child process from within node. I've tried a bunch of different combinations of techniques and ffmpeg params to get a consistent framerate and a stream at "realtime" speed, but can't figure it out. Here's the paths I've gone down so far

    


    Render canvas and send input in continuous interval

    


    import { createCanvas } from 'canvas';

const canvas = createCanvas(1920, 1080);
const ctx = canvas.getContext('2d');

const fps = 30;
const ffmpeg = spawn('ffmpeg', [
  '-re',
  '-framerate', String(.fps),
  '-r', String(fps),

  '-i', '-',
  
  '-vcodec', 'libx264',
  '-r', String(fps),
  '-s', '1920x1080',
  '-g:v', String(2*fps),
  '-c:a', 'aac',
  '-f', 'flv', 'rtmp://127.0.0.1/live'
]);
ffmpeg.stdout.pipe(process.stdout)
ffmpeg.stderr.pipe(process.stderr)


const send = () => {
  ctx.fillStyle = 'red'
  ctx.fillRect(0, 0, 1920, 1080);
  ctx.font = '100px Arial';
  ctx.fillStyle = 'black'
  ctx.fillText(new Date().toLocaleString(), 500, 500);
  ffmpeg.stdin.write(canvas.toBuffer())
  setImmediate(() => send())
}
send()


    


    Observations

    


      

    • Took about 35 seconds for the stream to actually start (I think because of ffmpeg needing some amount of time to analyze the input ?)
    • 


    • Frame rate extremely below what I set it to, and "speed" also very low, although I'm not 100% sure what this means. example log Frame=  906 fps=3.9 q=29.0 size= 311kB time=00:00:27.83 bitrate= 91.5kbits/s speed=0.119x
    • 


    • Stream behavior

        

      • Takes about a minute to load once opened in VLC
      • 


      • Timer on the stream starts about 1 minute behind real time, stays stuck on a single second for 30+ seconds, then shoots up a few seconds quickly, and gets stuck again
      • 


      


    • 


    


    I had a hunch here that at least some of the reason for the strange behavior was that rendering the canvas in the same loop that I send input to ffmpeg in was too slow to achieve 30 FPS.

    


    Render canvas in separate interval from ffmpeg input interval

    


    Only render canvas FPS-times per second

    


    Continue sending input to ffmpeg as fast as possible

    


    import { createCanvas } from 'canvas';

const canvas = createCanvas(1920, 1080);
const ctx = canvas.getContext('2d');

let buffer = canvas.toBuffer();

const fps = 30;
const ffmpeg = spawn('ffmpeg', [
  ...same as before
]);

const render = () => {
  ctx.fillStyle = 'red'
  ctx.fillRect(0, 0, 1920, 1080);
  ctx.font = '100px Arial';
  ctx.fillStyle = 'black'
  ctx.fillText(new Date().toLocaleString(), 500, 500);
  buffer = canvas.toBuffer();
  setTimeout(() => render(), 1/fps)
}
render();

const send = () => {
  ffmpeg.stdin.write(buffer)
  setImmediate(() => send())
}
send()


    


    Observations

    


      

    • ffmpeg starts streaming almost immediately
    • 


    • fps starts out around 16, takes a couple seconds to hit 28, and then 30 more seconds to hit 30fps. speed much closer to 1x, but not quite all the way. example log frame=15421 fps= 30 q=29.0 size=    4502kB time=00:08:31.66 bitrate=  72.1kbits/s speed=0.994x      
    • 


    • Stream behavior

        

      • Takes about 5 seconds to load once opened in VLC
      • 


      • Timer stays stuck on the same second for multiple minutes
      • 


      


    • 


    


    My hunch here for the stream being stuck on 1 timestamp is that while ffmpeg is sending frames out at 30 frames per second, I'm sending it frames much quicker than that. So in the first 1st of a second of streaming

    


      

    1. Canvas renders with timestamp T 30 times
    2. 


    3. send runs N times where N is likely way higher than 30, sending ffmpeg N frames with the current timestamp
    4. 


    5. ffmpeg now has N frames with timestamp T on them, but can only send them out 30 per second, so it takes more than 1 second for the timestamp on the screen to change
    6. 


    


    Only send ffmpeg a frame every 1/FPS second

    


    Same as before, but instead of sending ffmpeg frames as quickly as possible, only send it FPS frames every second.

    


    import { createCanvas } from 'canvas';

const canvas = createCanvas(1920, 1080);
const ctx = canvas.getContext('2d');

let buffer = canvas.toBuffer();

const fps = 30;
const ffmpeg = spawn('ffmpeg', [
  ...same as before
]);

const render = () => {
  ...same as before
}
render();

const send = () => {
  ffmpeg.stdin.write(buffer)
  setTimeout(() => send(), 1/fps)
}
send()


    


    Observations

    


      

    • ffmpeg takes a few seconds to start streaming
    • 


    • fps starts out high, around 28, and over the next minute or so drops down to 16. Speed drops along with it. example log frame= 1329 fps= 16 q=29.0 size=     463kB time=00:00:41.93 bitrate=  90.5kbits/s speed= 0.5x
    • 


    • Stream behavior

        

      • Takes about 10 seconds to load once opened in VLC
      • 


      • Timer increases about twice as fast as expected, then gets hung on one second for a bit, and then starts increasing again at same rate
      • 


      


    • 


    



    


    I'll stop there, but tl ;dr I've tried a whole bunch of different combinations of -re, -framerate, -fps_mode, -r ffmpeg args, and some other techniques in the code like continuing to use setImmediate to send frames, but use a date comparison to actually send a frame at an FPS rate. I'm sure there's probably some fundamental video streaming knowledge I'm missing, so I'm just looking for any sort of guidance on how I can get my canvas to stream at a "realtime" speed, or whatever I could be missing here.