Recherche avancée

Sur d’autres sites (6491)

• checkasm : use perf API on Linux ARM*

  1er septembre 2017, par Clément Bœsch

  checkasm : use perf API on Linux ARM*
  On ARM platforms, accessing the PMU registers requires special user
  
  access permissions. Since there is no other way to get accurate timers,
  
  the current implementation of timers in FFmpeg rely on these registers.
  
  Unfortunately, enabling user access to these registers on Linux is not
  
  trivial, and generally involve compiling a random and unreliable github
  
  kernel module, or patching somehow your kernel.
  Such module is very unlikely to reach the upstream anytime soon. Quoting
  
  Robin Murphin from ARM :
  > Say you do give userspace direct access to the PMU ; now run two or more
  
  > programs at once that believe they can use the counters for their own
  
  > "minimal-overhead" profiling. Have fun interpreting those results...
  
  >
  
  > And that's not even getting into the implications of scheduling across
  
  > different CPUs, CPUidle, etc. where the PMU state is completely beyond
  
  > userspace's control. In general, the plan to provide userspace with
  
  > something which might happen to just about work in a few corner cases,
  
  > but is meaningless, misleading or downright broken in all others, is to
  
  > never do so.
  As a result, the alternative is to use the Performance Monitoring Linux
  
  API which makes use of these registers internally (assuming the PMU of
  
  your ARM board is supported in the kernel, which is definitely not a
  
  given...).
  While the Linux API is obviously cross platform, it does have a
  
  significant overhead which needs to be taken into account. As a result,
  
  that mode is only weakly enabled on ARM platforms exclusively.
  Note on the non flexibility of the implementation : the timers (native
  
  FFmpeg vs Linux API) are selected at compilation time to prevent the
  
  need of function calls, which would result in a negative impact on the
  
  cycle counters.
  

  • [DH] configure
  • [DH] tests/checkasm/checkasm.c
  • [DH] tests/checkasm/checkasm.h

• Node.js - Buffer Data to Ffmpeg

  24 septembre 2017, par user8568709

  I used Node.js and Ffmpeg to create animations. Because I was trying to avoid third-party avi/mp4 parsers, I decided to output the animation as raw rgb24 data file and then use some program to convert it to mp4 file.

  I found that Ffmpeg is free and open source which can do exactly it. So, I made a Node.js application which allocates a Buffer of size 1920 x 1080 x 3 (width times height times number of bytes per pixel), then I created a rendering context library, and finally I animated frame by frame and saved each frame consecutivelly in a binary file (using fs module).

  Then I invoked Ffmpeg to convert it to mp4 file and it works very good. Animations are pretty easy to make and Ffmpeg does its job correctly.

  However, the only problem is because it is very slow and eats space on hard disk. I want to create very long animations (more than a hour). The final mp4 file is relativelly small, but raw video file is extremelly big. About ninety percents of each frame are black pixels, so Ffmpeg comress it very good, but raw file cannot be compressed and it takes sometimes mor ethan 100 Gigabytes. Also, there is very unnecessary double processing same data. Firstly I process it in Node.js to save data to file, and then Ffmpeg reads it to convert it to mp4. There is a lot of unnecessary work.

  So, I’m looking for a way (and I’m pretty sure it is possible, but I didn’t find a way to do it yet) to output raw video data (one frame at a time) to Ffmpeg process (without saving anything to the hard disk).

  My goal is to do the following :

  1. Open Ffmpeg process
  2. Render a frame in Node.js
  3. Output raw byte stream to Ffmpeg
  4. Wait for Ffmpeg to encode it and append to mp4 file
  5. Let Ffmpeg wait for my Node.js process to render next frame

  ---

  Is there a way to achieve it ? I really don’t see a reason to post code, because my current code has nothing to do with the question I’m asking here. I don’t struggle with syntax errors or implementation problems. No, instead I just don’t know which parameters to pass to Ffmpeg process in order to achieve what I’ve already explained.

  I’ve searched in documentation to find out which parameters I need to pass to Ffmpeg process in order to let it read raw data from stdin instead from file, and also to wait until my Node.js process render next frame (so to disable time limit) because rendering a frame may take more than 24 hours. Therefore, Ffmpeg process should wait without time limit. However, I didn’t find anything about it in documentation.

  I know how to write to stdin from Node.js and similar technical stuff, so no need to explain it. The only question(s) here :

  1. Which parameters to pass to Ffmpeg ?
  2. Do I need to create Ffmpeg process (using child_process) with some special options ?

  ---

  Thank you in advance. Please, take it easy, this is my first question ! :)

• Ffmpeg error with output file not specified on linux when executing from dockerized new process in .net-core

  29 août 2017, par DutchGuy

  Some time back i created a small program in full .net framework that could rip mp3 and then add meta-info and a thumbnail to it. For innovation sake i started porting the application to .net core. After that i thought it would be cool to run this in docker on Linux. It took some time but i got it working. Now i’m running into the issue where i can rip the mp3 from the video file but when i try to combine the meta-info, thumbnail and mp3 ffmpeg tells me "At least one output file must be specified"

  I added some checks so the program can run on Linux and Windows (to switch paths etc)

  What i tried :

  • running same argument structure on windows (works)
  • Manualy starting the encode on linux (works)
  • Simplifying the names, paths and titles used in the command
  • replacing extra spaces and special characters, only "-" and single spaces allowed

  Below i have an example of the command that does work when i execute it manually but produces the earlier mentioned error when my program executes it. Also keep in mind that ripping the mp3 from the video does result in the desired outputfile.

  ffmpeg -i "temp/vid-id.mp3" -i "temp/vid-id.jpg" -map 0:0 -map 1:0 -c copy -y -id3v2_version 3 -metadata title="title" -metadata artist="artist" -metadata album="album" "completed/file - name.mp3"

  To start this from .net-core context i use the snippet below :

  using (var ffmpegProcess = new Process())
  
  {
  
    ffmpegProcess.EnableRaisingEvents = false;
  
    ffmpegProcess.StartInfo.CreateNoWindow = true;
  
    ffmpegProcess.StartInfo.UseShellExecute = false;
  
    ffmpegProcess.StartInfo.FileName = ffmpegPath(); (returns "/bin/bash")
  
  
  
    string command = "ffmpeg " + arguments;
  
  
  
    ffmpegProcess.StartInfo.Arguments = "-c \" " + command + " \"";
  
  
  
    ffmpegProcess.Start();
  
    ffmpegProcess.WaitForExit();
  
    ffmpegProcess.Dispose();
  
  }

  arguments :

  String.Format("-i \"{0}\" -i \"{1}.jpg\" -map 0:0 -map 1:0 -c copy -y -id3v2_version 3 -metadata title=\"{2}\" -metadata artist=\"{3}\" -metadata album=\"{4}\" \"{5}\"",inputFile, albumArtFile, outputTitle, artist, outputAlbum, outputFile);

  To rip the mp3 from the video file i use the same method mentioned above with the following arguments :

  -i "temp/vid-id.mp4" -vn -ab 320k -y -threads 2 "temp/vid-id.mp3"

  This works as expected.
  Arguments :

  String.Format("-i \"{0}\" -vn -ab 320k -y -threads 2 \"{1}\"", inputFile, outputFile);

  Vid-id does not contain spaces, below is and example of how it could look :

  "abcd12ef-gh34i"

  Since the initial ripping is working i cant figure out why Ffmpeg complains about the second operation. The only real difference between the two operations is that in the second one the output-file name can contain spaces. But even then, running the same command manually does work and produces the desired file in the completed dir.

  Update
  After more troubleshooting i have now narrowed the problem down to the usage of the metadata arguments. Still can’t figure out why

  Update
  The problem is with the spaces in the naming i have chosen. On linux the spaces are interpreted as end of file name. Any pointer how i can still use the naming with spaces ?