Recherche avancée
Médias (91)
-
GetID3 - Boutons supplémentaires
9 avril 2013, par
Mis à jour : Avril 2013
Langue : français
Type : Image
-
Core Media Video
4 avril 2013, par
Mis à jour : Juin 2013
Langue : français
Type : Video
-
The pirate bay depuis la Belgique
1er avril 2013, par
Mis à jour : Avril 2013
Langue : français
Type : Image
-
Bug de détection d’ogg
22 mars 2013, par
Mis à jour : Avril 2013
Langue : français
Type : Video
-
Exemple de boutons d’action pour une collection collaborative
27 février 2013, par
Mis à jour : Mars 2013
Langue : français
Type : Image
-
Exemple de boutons d’action pour une collection personnelle
27 février 2013, par
Mis à jour : Février 2013
Langue : English
Type : Image
Autres articles (84)
-
MediaSPIP en mode privé (Intranet)
17 septembre 2013, parÀ partir de la version 0.3, un canal de MediaSPIP peut devenir privé, bloqué à toute personne non identifiée grâce au plugin "Intranet/extranet".
Le plugin Intranet/extranet, lorsqu’il est activé, permet de bloquer l’accès au canal à tout visiteur non identifié, l’empêchant d’accéder au contenu en le redirigeant systématiquement vers le formulaire d’identification.
Ce système peut être particulièrement utile pour certaines utilisations comme : Atelier de travail avec des enfants dont le contenu ne doit pas (...) -
Diogene : création de masques spécifiques de formulaires d’édition de contenus
26 octobre 2010, parDiogene est un des plugins ? SPIP activé par défaut (extension) lors de l’initialisation de MediaSPIP.
A quoi sert ce plugin
Création de masques de formulaires
Le plugin Diogène permet de créer des masques de formulaires spécifiques par secteur sur les trois objets spécifiques SPIP que sont : les articles ; les rubriques ; les sites
Il permet ainsi de définir en fonction d’un secteur particulier, un masque de formulaire par objet, ajoutant ou enlevant ainsi des champs afin de rendre le formulaire (...) -
MediaSPIP version 0.1 Beta
16 avril 2011, parMediaSPIP 0.1 beta est la première version de MediaSPIP décrétée comme "utilisable".
Le fichier zip ici présent contient uniquement les sources de MediaSPIP en version standalone.
Pour avoir une installation fonctionnelle, il est nécessaire d’installer manuellement l’ensemble des dépendances logicielles sur le serveur.
Si vous souhaitez utiliser cette archive pour une installation en mode ferme, il vous faudra également procéder à d’autres modifications (...)
Sur d’autres sites (5088)
-
Socket.io client in js and server in Socket.io go doesn't send connected messege and data
24 mars 2023, par OmriHalifaI am using
ffmpegandsocket.ioand I have some issues. I'm trying to send a connection request to a server written in Go through React, but I'm unable to connect to it. I tried adding the events in useEffect and it's still not working, what should I do ? i attaching my code in js and in go :
main.go

package main

import (
 "log"

 "github.com/gin-gonic/gin"

 socketio "github.com/googollee/go-socket.io"
)

func main() {
 router := gin.New()

 server := socketio.NewServer(nil)

 server.OnConnect("/", func(s socketio.Conn) error {
 s.SetContext("")
 log.Println("connected:", s.ID())
 return nil
 })

 server.OnEvent("/", "notice", func(s socketio.Conn, msg string) {
 log.Println("notice:", msg)
 s.Emit("reply", "have "+msg)
 })

 server.OnEvent("/", "transcoded-video", func(s socketio.Conn, data string) {
 log.Println("transcoded-video:", data)
 })

 server.OnEvent("/", "bye", func(s socketio.Conn) string {
 last := s.Context().(string)
 s.Emit("bye", last)
 s.Close()
 return last
 })

 server.OnError("/", func(s socketio.Conn, e error) {
 log.Println("meet error:", e)
 })

 server.OnDisconnect("/", func(s socketio.Conn, reason string) {
 log.Println("closed", reason)
 })

 go func() {
 if err := server.Serve(); err != nil {
 log.Fatalf("socketio listen error: %s\n", err)
 }
 }()
 defer server.Close()

 if err := router.Run(":8000"); err != nil {
 log.Fatal("failed run app: ", err)
 }
}



App.js

import './App.css';
import { useEffect } from 'react';
import { createFFmpeg, fetchFile } from '@ffmpeg/ffmpeg';
import { io } from 'socket.io-client'; 

function App() {
 const socket = io("http://localhost:8000",function() {
 // Send a message to the server when the client is connected
 socket.emit('clientConnected', 'Client has connected to the server!');
 })

 const ffmpegWorker = createFFmpeg({
 log: true
 })

 // Initialize FFmpeg when the component is mounted
 async function initFFmpeg() {
 await ffmpegWorker.load();
 }

 async function transcode(webcamData) {
 const name = 'record.webm';
 await ffmpegWorker.FS('writeFile', name, await fetchFile(webcamData));
 await ffmpegWorker.run('-i', name, '-preset', 'ultrafast', '-threads', '4', 'output.mp4');
 const data = ffmpegWorker.FS('readFile', 'output.mp4');
 
 // Set the source of the output video element to the transcoded video data
 const video = document.getElementById('output-video');
 video.src = URL.createObjectURL(new Blob([data.buffer], { type: 'video/mp4' }));
 
 // Remove the output.mp4 file from the FFmpeg virtual file system
 ffmpegWorker.FS('unlink', 'output.mp4');
 
 // Emit a "transcoded-video" event to the server with the transcoded video data
 socket.emit("transcoded-video", data.buffer)
 }
 
 

 let mediaRecorder;
 let chunks = [];
 
 // Request access to the user's camera and microphone and start recording
 function requestMedia() {
 const webcam = document.getElementById('webcam');
 navigator.mediaDevices.getUserMedia({ video: true, audio: true })
 .then(async (stream) => {
 webcam.srcObject = stream;
 await webcam.play();

 // Set up a MediaRecorder instance to record the video and audio
 mediaRecorder = new MediaRecorder(stream);

 // Add the recorded data to the chunks array
 mediaRecorder.ondataavailable = async (e) => {
 chunks.push(e.data);
 }

 // Transcode the recorded video data after the MediaRecorder stops
 mediaRecorder.onstop = async () => {
 await transcode(new Uint8Array(await (new Blob(chunks)).arrayBuffer()));

 // Clear the chunks array after transcoding
 chunks = [];

 // Start the MediaRecorder again after a 0 millisecond delay
 setTimeout(() => {
 mediaRecorder.start();
 
 // Stop the MediaRecorder after 3 seconds
 setTimeout(() => {
 mediaRecorder.stop();
 }, 500);
 }, 0);
 }

 // Start the MediaRecorder
 mediaRecorder.start();

 // Stop the MediaRecorder after 3 seconds
 setTimeout(() => {
 mediaRecorder.stop();
 }, 700);
 })
 }
 
 useEffect(() => {
 // Set up event listeners for the socket connection
 socket.on('/', function(){
 // Log a message when the client is connected to the server
 console.log("Connected to server!"); 
 });

 socket.on('transcoded-video', function(data){
 // Log the received data for debugging purposes
 console.log("Received transcoded video data:", data); 
 });

 socket.on('notice', function(data){
 // Emit a "notice" event back to the server to acknowledge the received data
 socket.emit("notice", "ping server!");
 });

 socket.on('bye', function(data){
 // Log the received data and disconnect from the server
 console.log("Server sent:", data); 
 socket.disconnect();
 });

 socket.on('disconnect', function(){
 // Log a message when the client is disconnected from the server
 console.log("Disconnected from server!"); 
 });
 }, [])

 return (
 <div classname="App">
 <div>
 <video muted="{true}"></video>
 <video autoplay="autoplay"></video>
 </div>
 <button>start streaming</button>
 </div>
 );
}

export default App;


What can i do to fix it ? thank you !!


-
Ytdl-Core / FFMPEG in NodeJs : Cannot find a matching stream for unlabeled input pad 0 on filter Parsed_split_0
25 mars 2023, par VenoMSo I'm using ytdl-core & ffmpeg to convert some videos from YouTube to MP4 and then manipulate them in a way or take screenshots. But the issue I'm facing is - some videos are downloaded and are completely playable, but others are corrupt.


This is the error I get when I try to take screenshot of the corrupted video :




Error : ffmpeg exited with code 1 : Cannot find a matching stream for unlabeled input pad 0 on filter Parsed_split_0




And obviously, error is there because the video is corrupted, but WHY is that the case ?


Here's my code (read TL ;DR below) :


router.post("/screenshot", async (req, res) => {
 const urlToScreenshot = req.body.url;
 const timestamp = parseInt(req.body.t, 10);
 const YouTubeURL = `https://youtube.com/watch?v=${urlToScreenshot}`;
 const filename = uuidv4();

 const videoPath = `${filePath}/${filename}.mp4`;

 const downloadStartTime = timestamp - 3;
 const downloadEndTime = timestamp + 3;

 const videoStream = ytdl(YouTubeURL, {
 quality: "highest",
 });

 const ffmpegCommand = ffmpeg(videoStream)
 .setStartTime(downloadStartTime)
 .duration(downloadEndTime - downloadStartTime)
 .outputOptions("-c:v", "libx264")
 .outputOptions("-c:a", "copy")
 .outputOptions("-b:v", "10M")
 .outputOptions("-filter:v", "scale=1920:1080")
 .outputOptions("-q:v", "1")
 .outputOptions("-reconnect", "1") // enable reconnection attempts
 .outputOptions("-ignore_io_errors", "1") // ignore input/output errors
 .on("end", async () => {
 console.log("Video downloaded successfully: " + videoPath);

 const screenshotPath = `${filePath}/${filename}.png`;
 ffmpeg(videoPath)
 .screenshots({
 count: 1,
 timemarks: ["1"],
 folder: filePath,
 filename: `${filename}.png`,
 })
 .on("end", async () => {
 console.log(`Screenshot saved successfully: ${screenshotPath}`);
 try {
 const cloudinaryResult = await cloudinary.uploader.upload(
 screenshotPath
 );
 const screenshotUrl = cloudinaryResult.secure_url;
 console.log(`Screenshot uploaded to Cloudinary: ${screenshotUrl}`);
 // await unlink(videoPath);
 console.log(`Video file deleted: ${videoPath}`);
 // await unlink(screenshotPath);
 console.log(`Screenshot file deleted: ${screenshotPath}`);
 res.status(200).json({ screenshotUrl });
 } catch (err) {
 console.error(
 "An error occurred while uploading the screenshot to Cloudinary:",
 err
 );
 // await unlink(videoPath);
 // await unlink(screenshotPath);
 res.status(500).send("Internal Server Error");
 }
 })
 .on("error", async (err) => {
 console.error("An error occurred while taking the screenshot:", err);
 // await unlink(videoPath);
 // await unlink(screenshotPath);
 res.status(500).send("Internal Server Error");
 });
 })
 .on("error", async (err) => {
 console.error("An error occurred while downloading the video:", err);
 await unlink(videoPath); // delete the file on error
 res.status(500).send("Internal Server Error");
 })
 .save(videoPath);

 // console.log(ffmpegCommand);
});


Code Summary : Basically I'm passing the videoID and timestamp (because I want to download a certain section of the video, not the whole video), it downloads the video, then takes a screenshot of the video at a certain timestamp (i.e 1st second) and sends the screenshot to Cloudinary (a cloud file storage).


This works fine for 50% of the videos I've tried, but doesn't for other videos.


Here's a picture of a corrupt video and a working video.








Some help would be greatly appreciated !


-
Cannot find a matching stream for unlabeled input pad 0 on filter Parsed_split_0
26 mars 2023, par VenoMSo I'm using ytdl-core & ffmpeg to convert some videos from YouTube to MP4 and then manipulate them in a way or take screenshots. But the issue I'm facing is - some videos are downloaded and are completely playable, but others are corrupt.


This is the error I get when I try to take screenshot of the corrupted video :




Error : ffmpeg exited with code 1 : Cannot find a matching stream for unlabeled input pad 0 on filter Parsed_split_0




And obviously, error is there because the video is corrupted, but WHY is that the case ?


Here's my code (read TL ;DR below) :


router.post("/screenshot", async (req, res) => {
 const urlToScreenshot = req.body.url;
 const timestamp = parseInt(req.body.t, 10);
 const YouTubeURL = `https://youtube.com/watch?v=${urlToScreenshot}`;
 const filename = uuidv4();

 const videoPath = `${filePath}/${filename}.mp4`;

 const downloadStartTime = timestamp - 3;
 const downloadEndTime = timestamp + 3;

 const videoStream = ytdl(YouTubeURL, {
 quality: "highest",
 });

 const ffmpegCommand = ffmpeg(videoStream)
 .setStartTime(downloadStartTime)
 .duration(downloadEndTime - downloadStartTime)
 .outputOptions("-c:v", "libx264")
 .outputOptions("-c:a", "copy")
 .outputOptions("-b:v", "10M")
 .outputOptions("-filter:v", "scale=1920:1080")
 .outputOptions("-q:v", "1")
 .outputOptions("-reconnect", "1") // enable reconnection attempts
 .outputOptions("-ignore_io_errors", "1") // ignore input/output errors
 .on("end", async () => {
 console.log("Video downloaded successfully: " + videoPath);

 const screenshotPath = `${filePath}/${filename}.png`;
 ffmpeg(videoPath)
 .screenshots({
 count: 1,
 timemarks: ["1"],
 folder: filePath,
 filename: `${filename}.png`,
 })
 .on("end", async () => {
 console.log(`Screenshot saved successfully: ${screenshotPath}`);
 try {
 const cloudinaryResult = await cloudinary.uploader.upload(
 screenshotPath
 );
 const screenshotUrl = cloudinaryResult.secure_url;
 console.log(`Screenshot uploaded to Cloudinary: ${screenshotUrl}`);
 // await unlink(videoPath);
 console.log(`Video file deleted: ${videoPath}`);
 // await unlink(screenshotPath);
 console.log(`Screenshot file deleted: ${screenshotPath}`);
 res.status(200).json({ screenshotUrl });
 } catch (err) {
 console.error(
 "An error occurred while uploading the screenshot to Cloudinary:",
 err
 );
 // await unlink(videoPath);
 // await unlink(screenshotPath);
 res.status(500).send("Internal Server Error");
 }
 })
 .on("error", async (err) => {
 console.error("An error occurred while taking the screenshot:", err);
 // await unlink(videoPath);
 // await unlink(screenshotPath);
 res.status(500).send("Internal Server Error");
 });
 })
 .on("error", async (err) => {
 console.error("An error occurred while downloading the video:", err);
 await unlink(videoPath); // delete the file on error
 res.status(500).send("Internal Server Error");
 })
 .save(videoPath);

 // console.log(ffmpegCommand);
});


Code Summary : Basically I'm passing the videoID and timestamp (because I want to download a certain section of the video, not the whole video), it downloads the video, then takes a screenshot of the video at a certain timestamp (i.e 1st second) and sends the screenshot to Cloudinary (a cloud file storage).


This works fine for 50% of the videos I've tried, but doesn't for other videos.


Here's a picture of a corrupt video and a working video.








Some help would be greatly appreciated !


Syndiquer tout le site
