Recherche avancée

Sur d’autres sites (6353)

• aarch64 : h264pred : Optimize the inner loop of existing 8 bit functions

  12 avril 2021, par Martin Storsjö

  aarch64 : h264pred : Optimize the inner loop of existing 8 bit functions
  Move the loop counter decrement further from the branch instruction,
  
  this hides the latency of the decrement.
  In loops that first load, then store (the horizontal prediction cases),
  
  do the decrement after the load (where the next instruction would
  
  stall a bit anyway, waiting for the result of the load).
  In loops that store twice using the same destination register,
  
  also do the decrement between the two stores (as the second store
  
  would need to wait for the updated destination register from the
  
  first instruction).
  In loops that store twice to two different destination registers,
  
  do the decrement before both stores, to do it as soon before the
  
  branch as possible.
  This gives minor (1-2 cycle) speedups in most cases (modulo measurement
  
  noise), but the horizontal prediction functions get a rather notable
  
  speedup on the Cortex A53.
  Before :                     Cortex A53     A72     A73
  
  pred8x8_dc_8_neon :                60.7    46.2    39.2
  
  pred8x8_dc_128_8_neon :            30.7    18.0    14.0
  
  pred8x8_horizontal_8_neon :        42.2    29.2    18.5
  
  pred8x8_left_dc_8_neon :           52.7    36.2    32.2
  
  pred8x8_mad_cow_dc_0l0_8_neon :    48.2    27.7    25.7
  
  pred8x8_mad_cow_dc_0lt_8_neon :    52.5    33.2    34.7
  
  pred8x8_mad_cow_dc_l0t_8_neon :    52.5    31.7    33.2
  
  pred8x8_mad_cow_dc_l00_8_neon :    43.2    27.0    25.5
  
  pred8x8_plane_8_neon :            112.2    86.2    88.2
  
  pred8x8_top_dc_8_neon :            40.7    23.0    21.2
  
  pred8x8_vertical_8_neon :          27.2    15.5    14.0
  
  pred16x16_dc_8_neon :              91.0    73.2    70.5
  
  pred16x16_dc_128_8_neon :          43.0    34.7    30.7
  
  pred16x16_horizontal_8_neon :      86.0    49.7    44.7
  
  pred16x16_left_dc_8_neon :         87.0    67.2    67.5
  
  pred16x16_plane_8_neon :          236.0   175.7   173.0
  
  pred16x16_top_dc_8_neon :          53.2    39.0    41.7
  
  pred16x16_vertical_8_neon :        41.7    29.7    31.0
  After :
  
  pred8x8_dc_8_neon :                59.0    46.7    42.5
  
  pred8x8_dc_128_8_neon :            28.2    18.0    14.0
  
  pred8x8_horizontal_8_neon :        34.2    29.2    18.5
  
  pred8x8_left_dc_8_neon :           51.0    38.2    32.7
  
  pred8x8_mad_cow_dc_0l0_8_neon :    46.7    28.2    26.2
  
  pred8x8_mad_cow_dc_0lt_8_neon :    55.2    33.7    37.5
  
  pred8x8_mad_cow_dc_l0t_8_neon :    51.2    31.7    37.2
  
  pred8x8_mad_cow_dc_l00_8_neon :    41.7    27.5    26.0
  
  pred8x8_plane_8_neon :            111.5    86.5    89.5
  
  pred8x8_top_dc_8_neon :            39.0    23.2    21.0
  
  pred8x8_vertical_8_neon :          27.2    16.0    14.0
  
  pred16x16_dc_8_neon :              85.0    70.2    70.5
  
  pred16x16_dc_128_8_neon :          42.0    30.0    30.7
  
  pred16x16_horizontal_8_neon :      66.5    49.5    42.5
  
  pred16x16_left_dc_8_neon :         81.0    66.5    67.5
  
  pred16x16_plane_8_neon :          235.0   175.7   173.0
  
  pred16x16_top_dc_8_neon :          52.0    39.0    41.7
  
  pred16x16_vertical_8_neon :        40.2    33.2    31.0
  Despite this, a number of these functions still are slower than
  
  what e.g. GCC 7 generates - this shows the relative speedup of the
  
  neon codepaths over the compiler generated ones :
                             Cortex A53    A72    A73
  
  pred8x8_dc_8_neon :               0.86   0.65   1.04
  
  pred8x8_dc_128_8_neon :           0.59   0.44   0.62
  
  pred8x8_horizontal_8_neon :       1.51   0.58   1.30
  
  pred8x8_left_dc_8_neon :          0.72   0.56   0.89
  
  pred8x8_mad_cow_dc_0l0_8_neon :   0.93   0.93   1.37
  
  pred8x8_mad_cow_dc_0lt_8_neon :   1.37   1.41   1.68
  
  pred8x8_mad_cow_dc_l0t_8_neon :   1.21   1.17   1.32
  
  pred8x8_mad_cow_dc_l00_8_neon :   1.24   1.19   1.60
  
  pred8x8_plane_8_neon :            3.36   3.58   3.76
  
  pred8x8_top_dc_8_neon :           0.97   0.99   1.43
  
  pred8x8_vertical_8_neon :         0.86   0.78   1.18
  
  pred16x16_dc_8_neon :             1.20   1.06   1.49
  
  pred16x16_dc_128_8_neon :         0.83   0.95   0.99
  
  pred16x16_horizontal_8_neon :     1.78   0.96   1.59
  
  pred16x16_left_dc_8_neon :        1.06   0.96   1.32
  
  pred16x16_plane_8_neon :          5.78   6.49   7.19
  
  pred16x16_top_dc_8_neon :         1.48   1.53   1.94
  
  pred16x16_vertical_8_neon :       1.39   1.34   1.98
  In particular, on Cortex A72, many of these functions are slower
  
  than the compiler generated code, while they're more beneficial on
  
  e.g. the Cortex A73.
  Signed-off-by : Martin Storsjö <martin@martin.st>
  

  • [DH] libavcodec/aarch64/h264pred_neon.S

• Concatenate multiple video files alongside delayed audio files

  28 mars 2022, par Spartan 117

  I am currently working on a utility that is responsible for pulling audio and video files from the cloud and merging them together via FFMPEG. As I am new to FFMPEG, I am going to split the question into an FFMPEG part and a C# part just so people can answer either 1 part or the other (or both !).

  


  FFMPEG Part

  


  Currently, I have a working FFMPEG arg if there is only 1 video file present and it needs to be merged with multiple files.

  


  ffmpeg -i input1.mkv -i input1.mka -i input2.mka -i input3.mka -i input4.mka -filter_complex "[1:a]adelay=0s:all=1[a1pad];[2:a]adelay=20s:all=1[a2pad];[3:a]adelay=30s:all=1[a3pad];[4:a]adelay=40s:all=1[a4pad];[a1pad][a2pad][a3pad][a4pad]amix=inputs=4:weights=1|1|1|1[aout]" -map [aout] -map 0:0 output4.mkv


  


  The delays you see in there are determined by subtracting the start time of each file from the start time of the earliest created audio or video file. I know that if I wanted to create a horizontal stack of multiple videos, i could just do

  


  ffmpeg -i input1.mkv -i input1.mka -i input2.mkv -i input2.mka -i input3.mka -i input4.mka
-filter_complex 
"[2:v]tpad=start_duration=120:color=black[vpad]; 
 [3:a]adelay=120000:all=1[a2pad]; 
 [4:a]adelay=180000:all=1[a3pad];
 [5:a]adelay=200000:all=1[a4pad]; 
 [0:v][vpad]hstack=inputs=2[vout]; 
 [1:a][a2pad][a3pad][a4pad]amix=inputs=4:weights=1|1|1|1[aout]" 
 -map [vout] -map [aout] 
 output.mkv


  


  but what I want to do is both keep those delays for the audio and video files AND concatenate (not stack) those videos, how would i go about doing that ?

  


  C# Part

  


  You see that giant arg up there ? The utility is supposed to generate that based on a List of recordings. Here is the model.

  


  List<filemodel> _records;&#xA;public class FileModel {&#xA;  public string Id { get; set; }&#xA;  public string FileType { get; set; }&#xA;  public string StartTime { get; set; }&#xA;}&#xA;</filemodel>

  


  The utility has to then go through that list and create the arg (as seen in the FFMPEG part) to be executed by the Xabe.FFMPEG package. The way i was thinking to approach this is to basically create 2 string builders. 1 string builder will be responsible for dealing with the inputs, the other string builder. Here is what i have so far

  


  private async Task CombineAsync()
    {
        var minTime = _records.Min(y => Convert.ToDateTime(y.StartTime));
        var frontBuilder = new StringBuilder("-y ");
        var middleBuilder = new StringBuilder("-filter_complex \"");
        var endString = $" -map [vout] -map [aout] {_folderPath}\\CombinedOutput.mkv";

        for (var i = 0; i < _records.Count; i++)
        {
            var type = _records[i].FileType.ToLower();
            var delay = (Convert.ToDateTime(_records[i].StartTime).Subtract(minTime)).TotalSeconds;
            frontBuilder.Append($"-i {_folderPath + "\\" + _records[i].Id} ");
            var addColon = i != _records.Count - 1 ? ";" : "";
            middleBuilder.Append(type.Equals("video") ? $"[{i}:v]tpad=start_duration={delay}:color=black[v{i}pad]{addColon} " : $"[{i}:a]adelay={delay}s:all=1[a{i}pad]{addColon} ");
        }
        middleBuilder.Append("\"");
        Console.WriteLine(frontBuilder.ToString() + middleBuilder.ToString() + endString);
        // var args = frontBuilder + middleBuilder + endString;
        // try
        // {
        //     var conversionResult = await FFmpeg.Conversions.New().Start(args);
        //     Console.WriteLine(JsonConvert.SerializeObject(conversionResult));
        // }
        // catch (Exception e)
        // {
        //     Console.WriteLine(e);
        // }
    }


  


  


  1. Is this the correct way to go about building the argument out ?

     


  


  2. How in god's name do i get something like this in there, since it relies on naming and total count for the piping and inputs=

     


       [0:v][vpad]hstack=inputs=2[vout]; // This part will change for video concatenation depending on what gets answered above
  [1:a][a2pad][a3pad][a4pad]amix=inputs=4:weights=1|1|1|1[aout]


     


  


  


• Scroll seamless image with FFMPEG

  22 septembre 2022, par Rob

  I want to create a video from a single image. The image should scroll vertically and the output needs to be seamless so it can be looped (the image itself is seamless).

  


  Example of what I want to create :
GIF example
and the texture from the example : seamless texture.

  


  Length of the video is not that important since if the scrolling is seamless I should be able to just loop it with ffmpeg -stream_loop 3 -i input.mp4 -c copy output.mp4 afterwards.

  


  I have tried :

  


  ffmpeg -loop 1 -i input.png -framerate 30 -vf "scroll=vertical=0.002,crop=iw:600:0:0,format=yuv420p" -t 10 -y output.mp4


  


  which creates a video with the desired scrolling effect but its not seamless due to Issues matching the video length with the height of the image/scrolling speed and it looks something like this : Example output (exaggerated) Also ignore it scrolls the other way.

  


  I'm not sure how to proceed, maybe its just a simple math that needs to be done to add to
-t X by looking at the scroll speed & image height ? . Any ideas welcome how to solve this with either ffmpeg/python/powershell under windows.