Recherche avancée

Sur d’autres sites (3536)

• How to hide the output of yt-dl in CMD ? python

  10 février, par Qais Albeaiz

  I'm coding program that download mp3 audio from youtube videos but I have an issue that yt-dl show some output in console

  


  my code :

  


  with open('Links.txt') as f:
    content = f.readlines()
    for links in content:

        ydl_opts = {
            'format': 'bestaudio/best',
            'postprocessors': [{
                'key': 'FFmpegExtractAudio',
                'preferredcodec': 'mp3',
                'preferredquality': '192',
            }],
        }
        with youtube_dl.YoutubeDL(ydl_opts) as ydl:
            ydl.download([links])


  


  photo of output :


  


  and i need the option or some way to hide the output.

  


• how to play m3u8 videos from laravel storage

  10 mars 2019, par Farzane Khazaei

  I used ffmpeg to convert my MP4 videos to M3U8 format to have multiple qualities and stream my videos. because of security reason I have to put my videos in storage folder (not public) and now when I try to watch videos the browser just download M3U8 text file and video wont display. I install chrome extension to display M3U8 videos and i can see my M3U8 videos if I put the files in public folder and call the URL directly. this is my code

  $fileName = $product->details()['sample_file_name'];
  
  $filePath = $product->type.'s/'.$product->id.'/'.$fileName;       
  
  $fileContents = Storage::disk('products')->path($filePath);
  
  $header = ['Content-type' => Storage::disk('products')->mimeType($filePath)];
  
  $header = ['Content-Disposition' => 'attachment; filename='.basename($filePath)];
  
  $response = Response::download($fileContents, $fileName, $header);
  
  return $response;

  please help me what headers should i set for my download response.

• C# Process Multitasking and Limitations

  30 juin 2017, par Komak57

  To give you a intro, me and some guys have suddenly come across a need for a dedicated encoding machine to receive dynamic requests from a server. I wrote a TCP Server, and put it on a Pi to listen for requests. I also wrote a TCP Client that will connect to the Pi, tell it how many cores it has, how many encoders it can run, what kind of latency is involved and other system relevant information. When the Server receives instruction, it will send a request to a valid TCP Client that will then begin a Process to use FFMPEG to start encoding based on some parameters. I’ve been having some weird issues where, when stress testing an 8-core system, it starts 8 encoders, but only 3 of them are actually encoding. The remaining 5 sit at 0% idle waiting for a slot to open up.

  tl ;dr - I’ve determined that using Process.StartInfo.UseShellExecute == false manages the processes in a thread based system, and due to my systems current limitations, only allows 3 threads to run simultaneously. This command is required for Process.BeginOutputReadLine() and Process.BeginErrorReadLine() to get useful information about the encoding process.

  Program.cs

  using System;
  
  using System.Collections.Generic;
  
  using System.Diagnostics;
  
  using System.Linq;
  
  using System.Text;
  
  using System.Text.RegularExpressions;
  
  using System.Threading;
  
  using System.Threading.Tasks;
  
  
  
  namespace EncodeMinimum
  
  {
  
      class Program
  
      {
  
          private static int threadCount = 0;
  
          /// <summary>
  
          /// Returns the number of available CPU Threads
  
          /// </summary>
  
          public static int ThreadCount
  
          {
  
              set
  
              {
  
                  threadCount = value;
  
                  CoreStatus = new bool[threadCount];
  
              }
  
              get
  
              {
  
                  return threadCount;
  
              }
  
          }
  
          private static int lastCore = -1;
  
          /// <summary>
  
          /// Increment to next available core and return. Causes IndexOutOfRangeException if there are no available cores.
  
          /// </summary>
  
          private static int nextCore
  
          {
  
              get
  
              {
  
                  int start = lastCore;
  
                  lastCore++;
  
                  if (lastCore >= ThreadCount)
  
                      lastCore = 0;
  
                  while (CoreStatus[lastCore] &amp;&amp; lastCore != start)
  
                  {
  
                      lastCore++;
  
                      if (lastCore >= ThreadCount)
  
                          lastCore = 0;
  
                  }
  
                  if (lastCore == start &amp;&amp; CoreStatus[lastCore])
  
                  {
  
                      throw new IndexOutOfRangeException("No valid cores available.");
  
                  }
  
                  return lastCore;
  
              }
  
          }
  
          private static bool[] CoreStatus = new bool[0];
  
          private static Dictionary tasks = new Dictionary();
  
  
  
          /// <summary>
  
          /// IntPtr representing the affinity of a single core. Max of 1 of 16 cores.
  
          /// </summary>
  
          public static IntPtr[] SingleCore = new IntPtr[]{ (IntPtr)0x0001, (IntPtr)0x0002, (IntPtr)0x0004, (IntPtr)0x0008,
  
                                                      (IntPtr)0x0010,(IntPtr)0x0020,(IntPtr)0x0040,(IntPtr)0x0080,
  
                                                      (IntPtr)0x0100,(IntPtr)0x0200,(IntPtr)0x0400,(IntPtr)0x0800,
  
                                                      (IntPtr)0x1000,(IntPtr)0x2000,(IntPtr)0x4000,(IntPtr)0x8000};
  
  
  
          /// <summary>
  
          /// Allows for compatibility between Linux and Windows operating systems, sorta.
  
          /// </summary>
  
          public static bool IsLinux
  
          {
  
              get
  
              {
  
                  PlatformID p = Environment.OSVersion.Platform;
  
                  return (p == PlatformID.Unix);
  
              }
  
          }
  
  
  
          static void Main(string[] args)
  
          {
  
              Console.WriteLine("[" + DateTime.Now.ToString("h:mm:ss") + "] Program Start");
  
              ThreadCount = Environment.ProcessorCount;
  
              bool HandleText = true;
  
              for (int id = 0; id &lt; ThreadCount; id++)
  
              {
  
                  Console.WriteLine("[" + DateTime.Now.ToString("h:mm:ss") + "] Creating Encoding process for ID " + id);
  
                  tasks.Add(id, new Encoder(id, new Process(), nextCore));
  
                  CoreStatus[tasks[id].Core] = true;
  
  
  
                  if (Program.IsLinux)
  
                      tasks[id].Process.StartInfo.FileName = "/usr/bin/ffmpeg";
  
                  else
  
                      tasks[id].Process.StartInfo.FileName = @"C:\FFMEPG\ffmpeg.exe";
  
                  tasks[id].Process.StartInfo.Arguments = String.Format("-y -i {0} -threads 1 -c:v libx264 -preset ultrafast -s {1} -r {2} -b:v {3}k -c:a aac -b:a 41k -f flv {4}", "./original.mp4", "1280x720", "60", "7500", "./out-"+id+".flv");
  
                  tasks[id].Process.StartInfo.Verb = "runas";
  
                  if (HandleText)
  
                  {
  
                      tasks[id].Process.StartInfo.CreateNoWindow = true; // true
  
                      tasks[id].Process.StartInfo.UseShellExecute = false; //false
  
                      tasks[id].Process.StartInfo.StandardOutputEncoding = Encoding.UTF8;
  
                      tasks[id].Process.OutputDataReceived += new DataReceivedEventHandler(ScannerHandler);
  
                      tasks[id].Process.ErrorDataReceived += new DataReceivedEventHandler(ScannerHandler);
  
                      tasks[id].Process.StartInfo.RedirectStandardOutput = true; // true
  
                      tasks[id].Process.StartInfo.RedirectStandardError = true; // true
  
                  } else
  
                  {
  
                      tasks[id].Process.StartInfo.CreateNoWindow = false;
  
                      tasks[id].Process.StartInfo.UseShellExecute = true;
  
                  }
  
  
  
                  try
  
                  {
  
                      Console.WriteLine("[" + DateTime.Now.ToString("h:mm:ss") + "] Starting Encoder for stream " + id);
  
                      tasks[id].Process.Start();
  
                      if (HandleText)
  
                      {
  
                          tasks[id].Process.BeginOutputReadLine();
  
                          tasks[id].Process.BeginErrorReadLine();
  
                      }
  
                      tasks[id].Process.ProcessorAffinity = Program.SingleCore[tasks[id].Core];
  
                      // Used in multithreaded operations to immediately notify when a process has closed
  
                      /*tasks[id].Process.WaitForExit();
  
                      CoreStatus[tasks[id].Core] = false;
  
                      tasks.Remove(id);*/
  
                  }
  
                  catch (Exception e)
  
                  {
  
                      Console.WriteLine("[" + DateTime.Now.ToString("h:mm:ss") + "] Failed to start Encoder: " + e.ToString());
  
                      CoreStatus[tasks[id].Core] = false;
  
                      tasks.Remove(id);
  
                  }
  
              }
  
  
  
              // Asynchronously look for Escape Key
  
              Thread keyscan = new Thread(new ThreadStart(CheckKeys));
  
              keyscan.Start();
  
  
  
              // Sleep until Escape Key found
  
              while (keyscan.IsAlive)
  
                  Thread.Sleep(100);
  
  
  
              for(int i = 0; i &lt; tasks.Count; i++)
  
              {
  
                  tasks[i].Process.Kill();
  
              }
  
          }
  
  
  
          /// <summary>
  
          /// Scans for Escape key 10 time a second
  
          /// </summary>
  
          static void CheckKeys()
  
          {
  
              // run thread until key is pressed
  
              while (Console.ReadKey(true).Key != ConsoleKey.Escape)
  
                  Thread.Sleep(100);
  
              return;
  
          }
  
  
  
          /// <summary>
  
          /// Prints output from processes directly to console.
  
          /// </summary>
  
          private static void ScannerHandler(object sendingProcess,
  
              DataReceivedEventArgs errLine)
  
          {
  
              if (!String.IsNullOrEmpty(errLine.Data))
  
              {
  
                  Process p = sendingProcess as Process;
  
                  string msg = errLine.Data.ToString().Trim();
  
                  Console.WriteLine("[" + DateTime.Now.ToString("h:mm:ss") + "] &lt;" + p.Id + ">: " + msg);
  
              }
  
          }
  
      }
  
  }

  Encoder.cs

  using System;
  
  using System.Collections.Generic;
  
  using System.Diagnostics;
  
  using System.Linq;
  
  using System.Text;
  
  using System.Threading;
  
  using System.Threading.Tasks;
  
  
  
  namespace EncodeMinimum
  
  {
  
      public class Encoder
  
      {
  
          public Process Process;
  
          public Thread Task;
  
          public int ID;
  
          public int Core;
  
          public Encoder(int ID, Process Task, int Core)
  
          {
  
              this.ID = ID;
  
              this.Process = Task;
  
              this.Core = Core;
  
          }
  
      }
  
  }

  I need a way to handle the output from each process created in a live-update manner, while being able to handle any number of simultaneous processes. I might be able to command the process to output to a text file, and read changes from it, but because there’s so little documentation on doing so, I’m not sure how to begin. Are there any alternatives to reading a Processes output without running into this threading issue ?