Recherche avancée
Autres articles (52)
-
(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 (...) -
Emballe médias : à quoi cela sert ?
4 février 2011, parCe plugin vise à gérer des sites de mise en ligne de documents de tous types.
Il crée des "médias", à savoir : un "média" est un article au sens SPIP créé automatiquement lors du téléversement d’un document qu’il soit audio, vidéo, image ou textuel ; un seul document ne peut être lié à un article dit "média" ; -
Automated installation script of MediaSPIP
25 avril 2011, parTo overcome the difficulties mainly due to the installation of server side software dependencies, an "all-in-one" installation script written in bash was created to facilitate this step on a server with a compatible Linux distribution.
You must have access to your server via SSH and a root account to use it, which will install the dependencies. Contact your provider if you do not have that.
The documentation of the use of this installation script is available here.
The code of this (...)
Sur d’autres sites (8732)
-
On-demand and seamless transcoding of individual HLS segments
5 janvier 2024, par Omid AriyanBackground


I've been meaning to implement on-demand transcoding of certain video formats such as ".mkv", ".wmv", ".mov", etc. in order to serve them on a media management server using ASP.NET Core 6.0, C# and ffmpeg.


My Approach


The approach I've decided to use is to serve a dynamically generated .m3u8 file which is simply generated using a segment duration of choice e.g. 10s and the known video duration. Here's how I've done it. Note that the resolution is currently not implemented and discarded :


public string GenerateVideoOnDemandPlaylist(double duration, int segment)
{
 double interval = (double)segment;
 var content = new StringBuilder();

 content.AppendLine("#EXTM3U");
 content.AppendLine("#EXT-X-VERSION:6");
 content.AppendLine(String.Format("#EXT-X-TARGETDURATION:{0}", segment));
 content.AppendLine("#EXT-X-MEDIA-SEQUENCE:0");
 content.AppendLine("#EXT-X-PLAYLIST-TYPE:VOD");
 content.AppendLine("#EXT-X-INDEPENDENT-SEGMENTS");

 for (double index = 0; (index * interval) < duration; index++)
 {
 content.AppendLine(String.Format("#EXTINF:{0:#.000000},", ((duration - (index * interval)) > interval) ? interval : ((duration - (index * interval)))));
 content.AppendLine(String.Format("{0:00000}.ts", index));
 }

 content.AppendLine("#EXT-X-ENDLIST");

 return content.ToString();
}

[HttpGet]
[Route("stream/{id}/{resolution}.m3u8")]
public IActionResult Stream(string id, string resolution)
{
 double duration = RetrieveVideoLengthInSeconds();
 return Content(GenerateVideoOnDemandPlaylist(duration, 10), "application/x-mpegURL", Encoding.UTF8);
}


Here's an example of how the .m3u8 file looks like :


#EXTM3U
#EXT-X-VERSION:6
#EXT-X-TARGETDURATION:10
#EXT-X-MEDIA-SEQUENCE:0
#EXT-X-PLAYLIST-TYPE:VOD
#EXT-X-INDEPENDENT-SEGMENTS
#EXTINF:10.000000,
00000.ts
#EXTINF:3.386667,
00001.ts
#EXT-X-ENDLIST


So the player would ask for 00000.ts, 00001.ts, etc. and the next step is to have them generated on demand :


public byte[] GenerateVideoOnDemandSegment(int index, int duration, string path)
{
 int timeout = 30000;
 int totalWaitTime = 0;
 int waitInterval = 100;
 byte[] output = Array.Empty<byte>();
 string executable = "/opt/homebrew/bin/ffmpeg";
 DirectoryInfo temp = Directory.CreateDirectory(System.IO.Path.Combine(System.IO.Path.GetTempPath(), System.IO.Path.GetRandomFileName()));
 string format = System.IO.Path.Combine(temp.FullName, "output-%05d.ts");

 using (Process ffmpeg = new())
 {
 ffmpeg.StartInfo.FileName = executable;

 ffmpeg.StartInfo.Arguments = String.Format("-ss {0} ", index * duration);
 ffmpeg.StartInfo.Arguments += String.Format("-y -t {0} ", duration);
 ffmpeg.StartInfo.Arguments += String.Format("-i \"{0}\" ", path);
 ffmpeg.StartInfo.Arguments += String.Format("-c:v libx264 -c:a aac ");
 ffmpeg.StartInfo.Arguments += String.Format("-segment_time {0} -reset_timestamps 1 -break_non_keyframes 1 -map 0 ", duration);
 ffmpeg.StartInfo.Arguments += String.Format("-initial_offset {0} ", index * duration);
 ffmpeg.StartInfo.Arguments += String.Format("-f segment -segment_format mpegts {0}", format);

 ffmpeg.StartInfo.CreateNoWindow = true;
 ffmpeg.StartInfo.UseShellExecute = false;
 ffmpeg.StartInfo.RedirectStandardError = false;
 ffmpeg.StartInfo.RedirectStandardOutput = false;

 ffmpeg.Start();

 do
 {
 Thread.Sleep(waitInterval);
 totalWaitTime += waitInterval;
 }
 while ((!ffmpeg.HasExited) && (totalWaitTime < timeout));

 if (ffmpeg.HasExited)
 {
 string filename = System.IO.Path.Combine(temp.FullName, "output-00000.ts");

 if (!File.Exists(filename))
 {
 throw new FileNotFoundException("Unable to find the generated segment: " + filename);
 }

 output = File.ReadAllBytes(filename);
 }
 else
 {
 // It's been too long. Kill it!
 ffmpeg.Kill();
 }
 }

 // Remove the temporary directory and all its contents.
 temp.Delete(true);

 return output;
}

[HttpGet]
[Route("stream/{id}/{index}.ts")]
public IActionResult Segment(string id, int index)
{
 string path = RetrieveVideoPath(id);
 return File(GenerateVideoOnDemandSegment(index, 10, path), "application/x-mpegURL", true);
}
</byte>

So as you can see, here's the command I use to generate each segment incrementing -ss and -initial_offset by 10 for each segment :


ffmpeg -ss 0 -y -t 10 -i "video.mov" -c:v libx264 -c:a aac -segment_time 10 -reset_timestamps 1 -break_non_keyframes 1 -map 0 -initial_offset 0 -f segment -segment_format mpegts /var/folders/8h/3xdhhky96b5bk2w2br6bt8n00000gn/T/4ynrwu0q.z24/output-%05d.ts


The Problem


Things work on a functional level, however the transition between segments is slightly glitchy and especially the audio has very short interruptions at each 10 second mark. How can I ensure the segments are seamless ? What can I improve in this process ?


-
Révision 21364 : Toujours dans les langues...
13 mai 2014, par kent1 -Ajoutons le Dari, variante du persan utilisée en Afghanistan notamment (http://fr.wikipedia.org/wiki/Dari)
-
Révision 21365 : Report de c21364
13 mai 2014, par kent1 -Ajoutons le Dari, variante du persan utilisée en Afghanistan notamment (http://fr.wikipedia.org/wiki/Dari)
Syndiquer tout le site
