Recherche avancée
Médias (1)
-
The pirate bay depuis la Belgique
1er avril 2013, par
Mis à jour : Avril 2013
Langue : français
Type : Image
Autres articles (56)
-
Submit bugs and patches
13 avril 2011Unfortunately a software is never perfect.
If you think you have found a bug, report it using our ticket system. Please to help us to fix it by providing the following information : the browser you are using, including the exact version as precise an explanation as possible of the problem if possible, the steps taken resulting in the problem a link to the site / page in question
If you think you have solved the bug, fill in a ticket and attach to it a corrective patch.
You may also (...) -
(Dés)Activation de fonctionnalités (plugins)
18 février 2011, parPour gérer l’ajout et la suppression de fonctionnalités supplémentaires (ou plugins), MediaSPIP utilise à partir de la version 0.2 SVP.
SVP permet l’activation facile de plugins depuis l’espace de configuration de MediaSPIP.
Pour y accéder, il suffit de se rendre dans l’espace de configuration puis de se rendre sur la page "Gestion des plugins".
MediaSPIP est fourni par défaut avec l’ensemble des plugins dits "compatibles", ils ont été testés et intégrés afin de fonctionner parfaitement avec chaque (...) -
Le plugin : Podcasts.
14 juillet 2010, parLe problème du podcasting est à nouveau un problème révélateur de la normalisation des transports de données sur Internet.
Deux formats intéressants existent : Celui développé par Apple, très axé sur l’utilisation d’iTunes dont la SPEC est ici ; Le format "Media RSS Module" qui est plus "libre" notamment soutenu par Yahoo et le logiciel Miro ;
Types de fichiers supportés dans les flux
Le format d’Apple n’autorise que les formats suivants dans ses flux : .mp3 audio/mpeg .m4a audio/x-m4a .mp4 (...)
Sur d’autres sites (8945)
-
FFMPEG SAR mismatch when concatenating videos
6 septembre 2020, par marcmanI'm trying to concatenate videos with different codecs using the
concatfilter. I'm also doing a bunch of processing to scale and pad the individual clips in this filter as well. However, I keep getting an error of this form :

[Parsed_concat_14 @ 0x556b918ed580] Input link in1:v0 parameters (size 960x1280, SAR 0:1) do not match the corresponding output link in0:v0 parameters (1280x720, SAR 1:1)


Here is my command :


ffmpeg \
 -y \
 -loglevel warning \
 -stats \
 -i videos/vid0.mp4 \
 -i videos/vid1.mp4 \
 -i videos/vid2.mov \
 -filter_complex \
"[0:v]setpts=PTS-STARTPTS, scale=1920:1080, setsar=1, drawtext=expansion=strftime: basetime=$(date +%s -d'2020-07-10 16:04:44')000000 : fontcolor=white : text='%^b %d, %Y%n%l\\:%M%p' : fontsize=36 : y=1080-4*lh : x=1920-text_w-2*max_glyph_w; \
[1:v]setpts=PTS-STARTPTS, scale=810:1080, pad=width=1920:height=1080:x=555:y=0:color=black, setsar=1, drawtext=expansion=strftime: basetime=$(date +%s -d'2020-08-20 21:12:27')000000 : fontcolor=white : text='%^b %d, %Y%n%l\\:%M%p' : fontsize=36 : y=1080-4*lh : x=1365-text_w-2*max_glyph_w; \
[2:v]setpts=PTS-STARTPTS, scale=607:1080, pad=width=1920:height=1080:x=656:y=0:color=black, setsar=1, drawtext=expansion=strftime: basetime=$(date +%s -d'2020-08-27 16:42:26')000000 : fontcolor=white : text='%^b %d, %Y%n%l\\:%M%p' : fontsize=36 : y=1080-4*lh : x=1263-text_w-2*max_glyph_w; \
[0:v][0:a][1:v][1:a][2:v][2:a]concat=n=3:v=1:a=1[v][a]" \
 -map "[v]" \
 -map "[a]" \
 videos.mp4


This gives the following error :


[Parsed_concat_14 @ 0x563ab9d840c0] Input link in1:v0 parameters (size 960x1280, SAR 0:1) do not match the corresponding output link in0:v0 parameters (1280x720, SAR 1:1)
[Parsed_concat_14 @ 0x563ab9d840c0] Input link in2:v0 parameters (size 1080x1920, SAR 0:1) do not match the corresponding output link in0:v0 parameters (1280x720, SAR 1:1)


The input videos have these resolutions :


- 

- vid0.mp4 : (1280x720)
- vid1.mp4 : (960x1280)
- vid2.mp4 : (1080x1920)








The output resolution of the concatenated output is to be 1920x1080.


I've added the
setsar=1command after all my scaling and padding operations, as per this question and answer. I've also triedsetdar=16/9as in this answer, but it made no difference.

What am I missing here ?


-
NodeJS - efficiently and correctly convert from raw PCM to WAV at scale (without FFMPEG ?)
13 juillet 2024, par Royi BernthalI have a stream of raw PCM buffers I need to convert to playable WAV buffers.


@ffmpeg.wasmcan convert an individual buffer in the stream well, but it's limited to executing 1 command at a time, so it won't work in a real-life streaming scenario (streams x concurrent users). We can use it as a reference to a conversion that outputs a good playable wav.

import { FFmpeg, createFFmpeg, fetchFile } from '@ffmpeg.wasm/main';

async pcmToWavFFMPEG(buffer: Buffer) {
 // bitDepth - PCM signed 16-bit little-endian
 const options = { sampleRate: '24k', channels: '1', bitDepth: 's16le' };

 this.ffmpeg.FS('writeFile', 'input.pcm', await fetchFile(buffer));

 await this.ffmpeg.run(
 '-f',
 options.bitDepth,
 '-ar',
 options.sampleRate,
 '-ac',
 options.channels,
 '-i',
 'input.pcm',
 'output.wav',
 );

 const wavBuffer = this.ffmpeg.FS('readFile', 'output.wav');

 this.ffmpeg.FS('unlink', `input.pcm`);
 this.ffmpeg.FS('unlink', `output.wav`);

 return Buffer.from(wavBuffer);
 }


In order to get over the command execution limit, I've tried
fluent-ffmpeg. I couldn't find a way to convert a single buffer, so I'm just passing the whole readable stream so that ffmpeg can convert all of its buffers to wav. The buffers I'm getting in on('data') aren't playable wav. The same is true for concatting the accumulated buffers in on('complete') - the result is not a playable wav.

import ffmpeg from 'fluent-ffmpeg';
import internal from 'stream';

async pcmToWavFluentFFMPEG(
 readable: internal.Readable,
 callback: (chunk: Buffer) => void,
 ) {
 const options = { sampleRate: 24000, channels: 1, bitDepth: 's16le' };

 ffmpeg(readable)
 .inputFormat(options.bitDepth)
 .audioFrequency(options.sampleRate)
 .audioChannels(options.channels)
 .outputFormat('wav')
 .pipe()
 .on('data', callback);
 }


I've also tried using
node-wavto convert each buffer individually. It manages to convert everything to playable wavs that sound close to the desired result, however for some reason they're extremely loud and sound a bit weird.

import wav from 'node-wav';

pcmToWavBad(buffer: Buffer) {
 const pcmData = new Int16Array(
 buffer.buffer,
 buffer.byteOffset,
 buffer.byteLength / Int16Array.BYTES_PER_ELEMENT,
 );

 const channelData = [pcmData]; // assuming mono channel

 return wav.encode(channelData, { sampleRate: 24000, bitDepth: 16 });
 }


I've also tried wrapping the PCM as a WAV with
wavefilewithout any actual conversion (which is redundant as PCM is contained as is in WAV), but it results in white noise :

import { WaveFile } from 'wavefile';

pcmToWav(buffer: Buffer) {
 const wav = new WaveFile();

 wav.fromScratch(1, 24000, '16', buffer); // 's16le' is invalid

 return Buffer.from(wav.toBuffer());
 }


-
Creating a continuous stream for RTMP in Node.js
9 mars 2023, par hankthetank27I'm working on an app that downloads audio from youtube that will be streamed sequentially, similar to radio broadcast. I'm having trouble getting the individual tracks to stream continuously. My idea was to write the tracks sequentially into a readable stream that then is read by FFMPEG. Here is the code I'm having trouble with...


import ytdl from "ytdl-core";
import ffmpeg from 'fluent-ffmpeg';
import { Readable } from "node:stream"

export async function startAudioStream(): Promise<void>{

 const mainStream = await createStreamedQueue()

 ffmpeg(mainStream)
 .inputOptions([
 '-re'
 ])
 .outputOption([
 // '-c:v libx264',
 // '-preset veryfast',
 // '-tune zerolatency',
 '-c:a aac',
 '-ar 44100',
 ])
 .save('rtmp://localhost/live/main.flv');
};

async function createStreamedQueue(): Promise<readable>{

 function createStream(): Readable{
 const stream = new Readable({
 read(){},
 highWaterMark: 1024 * 512,
 });
 stream._destroy = () => { stream.destroyed = true };
 return stream;
 }

 const mainStream = createStream();

 const ref1 = 'https://youtu.be/lLCEUpIg8rE'
 const ref2 = 'https://youtu.be/bRdyzdXJ0KA';

 function queueSong(src: string, stream: Readable): Promise<void>{
 return new Promise<void>((resolve, reject) => {
 ytdl(src, {
 filter: 'audioonly',
 quality: 'highestaudio'
 })
 .on('data', (data) => {
 stream.push(data);
 })
 .on('end', () => {
 resolve();
 })
 .on('error', (err) => {
 console.error('Error downloading file from YouTube.', err);
 reject(err);
 })
 })
 }
 
 await queueSong(ref1, mainStream);
 // console.log('after firsrt: ', mainStream)
 await queueSong(ref2, mainStream);
 // console.log('after second: ', mainStream)
 return mainStream;
};
</void></void></readable></void>

To start,
startAudioStreamis called to initiate a readable stream of audio to an RTMP server via FFMPEG. That is working fine. The part I'm having trouble with is "queuing" the tracks into the stream that's being fed into FFMPEG. Right now, I have a "main" stream that each songs data is being pushed into, as you can see inqueueSong. At the end of ytdl stream, the promise is resolved, allowing for the next song to be queued and its data to be pushed intomainStream. The issue that I'm experiencing is that the audio fromref1is only every played.

I can see in the logs that
mainStreamdoes grow in length after each call toqueueSong, but still will only stream the audio from the first track. My initial thought was that there is a terminating character at the of the last data chunk thats being written to the steam for each song ? But maybe im getting screwed up on how streams work...

Syndiquer tout le site
