Recherche avancée

Sur d’autres sites (2488)

• FFmpeg : Combining Video with Transparent Image Results in 0-Byte Output

  14 juillet 2023, par hello world

  I'm trying to combine a video with a transparent image using FFmpeg in my C# application. However, I'm encountering an issue where the resulting output video is consistently 0 bytes in size. I have reviewed the code and made several attempts to troubleshoot the problem, but I haven't been able to find a solution.

  


  Here is the relevant code snippet I am using :

  


  private async void button6_Click(object sender, EventArgs e)
{
    string ffmpegPath = "ffmpeg.exe"; // Path to the FFmpeg executable
    string videoPath = "input.mp4"; // Path to the input video
    string imagePath = "image.png"; // Path to the transparent image
    string outputPath = "output.mp4"; // Path for the output video

    // Build the FFmpeg command with the image information
    string command = $"-i \"{videoPath}\" -loop 1 -t 5 -i \"{imagePath}\" -filter_complex \"[1:v]colorkey=0x000000:0.1:0.1[fg];[0:v][fg]overlay[outv]\" -map \"[outv]\" -map 0:a? -c:a copy \"{outputPath}\"";

    // Execute the FFmpeg command
    ProcessStartInfo startInfo = new ProcessStartInfo
    {
        FileName = ffmpegPath,
        Arguments = command,
        UseShellExecute = false,
        RedirectStandardOutput = true,
        RedirectStandardError = true,
        CreateNoWindow = true
    };

    using (Process process = new Process())
    {
        process.StartInfo = startInfo;
        process.Start();
        process.WaitForExit();
    }
}


  


  I have confirmed that the input video and transparent image files are valid and located in the correct paths. The code runs without any exceptions, but the resulting output video is always 0 bytes in size.

  


  I have also tried different approaches, such as adjusting the alpha channel blending and preprocessing the image to ensure the transparent areas are fully opaque. However, none of these attempts have resolved the issue.

  


  Is there anything I might be missing or any additional steps I should take to ensure that the resulting video is generated correctly with the transparent image properly overlayed ?

  


  Any suggestions or insights would be greatly appreciated. Thank you !

  


• FFmpeg transcoding on Lambda results in unusable (static) audio

  17 mai 2020, par jmkmay

  I'd like to move towards serverless for audio transcoding routines in AWS. I've been trying to setup a Lambda function to do just that ; execute a static FFmpeg binary and re-upload the resulting audio file. The static binary I'm using is here.

  



  The Lambda function I'm using in Python looks like this :

  



  import boto3

s3client = boto3.client('s3')
s3resource = boto3.client('s3')

import json
import subprocess 

from io import BytesIO

import os

os.system("cp -ra ./bin/ffmpeg /tmp/")
os.system("chmod -R 775 /tmp")

def lambda_handler(event, context):

    bucketname = event["Records"][0]["s3"]["bucket"]["name"]
    filename = event["Records"][0]["s3"]["object"]["key"]

    audioData = grabFromS3(bucketname, filename)

    with open('/tmp/' + filename, 'wb') as f:
        f.write(audioData.read())

    os.chdir('/tmp/')

    try:
        process = subprocess.check_output(['./ffmpeg -i /tmp/joe_and_bill.wav /tmp/joe_and_bill.aac'], shell=True, stderr=subprocess.STDOUT)
        pushToS3(bucketname, filename)
        return process.decode('utf-8')
    except subprocess.CalledProcessError as e:
        return e.output.decode('utf-8'), os.listdir()


def grabFromS3(bucket, file):

    obj = s3client.get_object(Bucket=bucket, Key=file)
    data = BytesIO(obj['Body'].read())

    return(data)

def pushToS3(bucket, file):

    s3client.upload_file('/tmp/' + file[:-4] + '.aac', bucket, file[:-4] + '.aac')

    return


  



  You can listen to the output of this here. WARNING : Turn your volume down or your ears will bleed.

  



  The original file can be heard here.

  



  Does anyone have any idea what might be causing the encoding errors ? It doesn't seem to be an issue with the file upload, since the md5 on the Lambda fs matches the MD5 of the uploaded file.

  



  I've also tried building the static binary on an Amazon Linux instance in EC2, then zipping and porting it into the Lambda project, but the same issue persists.

  



  I'm stumped ! :(

  


• Unusual results extracting VP9 pkt_size with ffprobe as compared to H.264

  26 novembre 2016, par Jeff S.

  I’m trying to graph the bitrate over time for H.264 and VP9 videos by extracting the frame size with ffprobe, but many of the VP9 videos are showing significantly lower bitrate and total size than both the file size would indicate and that ffprobe reports.

  Can someone point me in the right direction for finding the missing bytes ?

  For example :

  # The extracted values and the ffprobe values are very close for mp4
  
  Video Codec: h264
  
  Video Bitrate: 0.668869
  
  Frame Bitrate: 0.665552571931
  
  Video Size: 6381536.0
  
  Frame Total Size: 6349891
  
  
  
  # The extracted values and the ffprobe values are very different for some vp9 videos
  
  Video Codec: vp9
  
  Video Bitrate: 0.600966
  
  Frame Bitrate: 0.375144984531
  
  Video Size: 5730519.0
  
  Frame Total Size: 3577195

  Below is what I’m using for validation. Note that the sample videos do not contain audio.

  import subprocess
  
  import json
  
  
  
  def export_video_info(video_id):
  
      proc = subprocess.Popen(['ffprobe',
  
          '-v', 'quiet', '-print_format', 
  
          'json', '-show_format',
  
          '-show_streams', '-show_frames',
  
          video_id
  
          ],
  
          stdout=subprocess.PIPE,
  
      )
  
      return proc.communicate()[0]
  
  
  
  # Example video:  https://www.youtube.com/watch?v=g_OdgCrnzYo
  
  # youtube-dl --id -f 135 https://www.youtube.com/watch?v=g_OdgCrnzYo
  
  # youtube-dl --id -f 244 https://www.youtube.com/watch?v=g_OdgCrnzYo
  
  video_list = ['g_OdgCrnzYo.mp4', 'g_OdgCrnzYo.webm']
  
  
  
  '''
  
  Format for every frame: 
  
  
  
      {
  
          "media_type": "video",
  
          "key_frame": 0,
  
          "pkt_pts": 84484,
  
          "pkt_pts_time": "84.484000",
  
          "pkt_dts": 84484,
  
          "pkt_dts_time": "84.484000",
  
          "best_effort_timestamp": 84484,
  
          "best_effort_timestamp_time": "84.484000",
  
          "pkt_duration": 33,
  
          "pkt_duration_time": "0.033000",
  
          "pkt_pos": "7103361",
  
          "pkt_size": "28",
  
          "width": 854,
  
          "height": 480,
  
          "pix_fmt": "yuv420p",
  
          "sample_aspect_ratio": "1:1",
  
          "pict_type": "P",
  
          "coded_picture_number": 0,
  
          "display_picture_number": 0,
  
          "interlaced_frame": 0,
  
          "top_field_first": 0,
  
          "repeat_pict": 0
  
      },
  
  '''
  
  
  
  
  
  # NOTE: videos do not include audio
  
  for video in video_list:
  
      output = json.loads(export_video_info(video))
  
      ff_bitrate = float(output['format']['bit_rate']) / 10**6
  
      ff_duration = float(output['format']['duration'])
  
      ff_codec = output['streams'][0]['codec_name']
  
      ff_size = float(output['format']['size'])
  
      frame_size_sum = 0
  
      for val, items in enumerate(output['frames']):
  
          if output['frames'][val]['media_type'] == 'video': 
  
              frame_size_sum += int(output['frames'][val]['pkt_size'])
  
  
  
      frame_bitrate = frame_size_sum / ff_duration * 8 / 10**6
  
      print('Video Codec: {}\nVideo Bitrate: {}\nFrame Bitrate: {}\nVideo Size: {}\nFrame Total Size: {}\n\n'.format(ff_codec, ff_bitrate, frame_bitrate, ff_size, frame_size_sum))