Recherche avancée

Sur d’autres sites (9607)

• What permission ffmpeg-static need in AWS Lambda ?

  17 février 2023, par János

  I have this code. It download a image, made a video from it and upload it to S3. It runs on Lambda. Added packages, intalled, zipped, uploaded.

  


  npm install --production
zip -r my-lambda-function.zip ./


  


  But get an error code 126

  


  2023-02-17T09:27:55.236Z    5c845bb6-02c1-41b0-8759-4459591b57b0    INFO    Error: ffmpeg exited with code 126&#xA;    at ChildProcess.<anonymous> (/var/task/node_modules/fluent-ffmpeg/lib/processor.js:182:22)&#xA;    at ChildProcess.emit (node:events:513:28)&#xA;    at ChildProcess._handle.onexit (node:internal/child_process:291:12)&#xA;2023-02-17T09:27:55.236Z 5c845bb6-02c1-41b0-8759-4459591b57b0 INFO Error: ffmpeg exited with code 126 at ChildProcess.<anonymous> (/var/task/node_modules/fluent-ffmpeg/lib/processor.js:182:22) at ChildProcess.emit (node:events:513:28) at ChildProcess._handle.onexit (node:internal/child_process:291:12)&#xA;</anonymous></anonymous>

  


  Do I need to set a specific premission for ffmpeg ?

  


  import { PutObjectCommand, S3Client } from '@aws-sdk/client-s3'
import { fromNodeProviderChain } from '@aws-sdk/credential-providers'
import axios from 'axios'
import pathToFfmpeg from 'ffmpeg-static'
import ffmpeg from 'fluent-ffmpeg'
import fs from 'fs'
ffmpeg.setFfmpegPath(pathToFfmpeg)
const credentials = fromNodeProviderChain({
    clientConfig: {
        region: 'eu-central-1',
    },
})
const client = new S3Client({ credentials })

export const handler = async (event, context) => {
    try {
        let body
        let statusCode = 200
        const query = event?.queryStringParameters
        if (!query?.imgId && !query?.video1Id && !query?.video2Id) {
            return
        }

        const imgId = query?.imgId
        const video1Id = query?.video1Id
        const video2Id = query?.video2Id
        console.log(
            `Parameters received, imgId: ${imgId}, video1Id: ${video1Id}, video2Id: ${video2Id}`
        )
        const imgURL = getFileURL(imgId)
        const video1URL = getFileURL(`${video1Id}.mp4`)
        const video2URL = getFileURL(`${video2Id}.mp4`)
        const imagePath = `/tmp/${imgId}`
        const video1Path = `/tmp/${video1Id}.mp4`
        const video2Path = `/tmp/${video2Id}.mp4`
        const outputPath = `/tmp/${imgId}.mp4`
        await Promise.all([
            downloadFile(imgURL, imagePath),
            downloadFile(video1URL, video1Path),
            downloadFile(video2URL, video2Path),
        ])
        await new Promise((resolve, reject) => {
            console.log('Input files downloaded')
            ffmpeg()
                .input(imagePath)
                .inputFormat('image2')
                .inputFPS(30)
                .loop(1)
                .size('1080x1080')
                .videoCodec('libx264')
                .format('mp4')
                .outputOptions([
                    '-tune animation',
                    '-pix_fmt yuv420p',
                    '-profile:v baseline',
                    '-level 3.0',
                    '-preset medium',
                    '-crf 23',
                    '-movflags +faststart',
                    '-y',
                ])
                .output(outputPath)
                .on('end', () => {
                    console.log('Output file generated')
                    resolve()
                })
                .on('error', (e) => {
                    console.log(e)
                    reject()
                })
                .run()
            
        })
        await uploadFile(outputPath, imgId + '.mp4')
            .then((url) => {
                body = JSON.stringify({
                    url,
                })
            })
            .catch((error) => {
                console.error(error)
                statusCode = 400
                body = error?.message ?? error
            })
        console.log(`File uploaded to S3`)
        const headers = {
            'Content-Type': 'application/json',
            'Access-Control-Allow-Headers': 'Content-Type',
            'Access-Control-Allow-Origin': 'https://tikex.com, https://borespiac.hu',
            'Access-Control-Allow-Methods': 'GET',
        }
        return {
            statusCode,
            body,
            headers,
        }
    } catch (error) {
        console.error(error)
        return {
            statusCode: 500,
            body: JSON.stringify('Error fetching data'),
        }
    }
}

const downloadFile = async (url, path) => {
    try {
        console.log(`Download will start: ${url}`)
        const response = await axios(url, {
            responseType: 'stream',
        })
        if (response.status !== 200) {
            throw new Error(
                `Failed to download file, status code: ${response.status}`
            )
        }
        response.data
            .pipe(fs.createWriteStream(path))
            .on('finish', () => console.log(`File downloaded to ${path}`))
            .on('error', (e) => {
                throw new Error(`Failed to save file: ${e}`)
            })
    } catch (e) {
        console.error(`Error downloading file: ${e}`)
    }
}
const uploadFile = async (path, id) => {
    const buffer = fs.readFileSync(path)
    const params = {
        Bucket: 't44-post-cover',
        ACL: 'public-read',
        Key: id,
        ContentType: 'video/mp4',
        Body: buffer,
    }
    await client.send(new PutObjectCommand(params))
    return getFileURL(id)
}
const getFileURL = (id) => {
    const bucket = 't44-post-cover'
    const url = `https://${bucket}.s3.eu-central-1.amazonaws.com/${id}`
    return url
}


  


  Added AWSLambdaBasicExecutionRole-16e770c8-05fa-4c42-9819-12c468cb5b49 permission, with policy :

  


  {
    "Version": "2012-10-17",
    "Statement": [
        {
            "Effect": "Allow",
            "Action": "logs:CreateLogGroup",
            "Resource": "arn:aws:logs:eu-central-1:634617701827:*"
        },
        {
            "Effect": "Allow",
            "Action": [
                "logs:CreateLogStream",
                "logs:PutLogEvents"
            ],
            "Resource": [
                "arn:aws:logs:eu-central-1:634617701827:log-group:/aws/lambda/promo-video-composer-2:*"
            ]
        },
        {
            "Effect": "Allow",
            "Action": [
                "s3:GetObject",
                "s3:PutObject",
                "s3:ListBucket"
            ],
            "Resource": [
                "arn:aws:s3:::example-bucket",
                "arn:aws:s3:::example-bucket/*"
            ]
        },
        {
            "Effect": "Allow",
            "Action": [
                "logs:CreateLogGroup",
                "logs:CreateLogStream",
                "logs:PutLogEvents"
            ],
            "Resource": [
                "arn:aws:logs:*:*:*"
            ]
        },
        {
            "Effect": "Allow",
            "Action": [
                "ec2:DescribeNetworkInterfaces"
            ],
            "Resource": [
                "*"
            ]
        },
        {
            "Effect": "Allow",
            "Action": [
                "sns:*"
            ],
            "Resource": [
                "*"
            ]
        },
        {
            "Effect": "Allow",
            "Action": [
                "cloudwatch:*"
            ],
            "Resource": [
                "*"
            ]
        },
        {
            "Effect": "Allow",
            "Action": [
                "kms:Decrypt"
            ],
            "Resource": [
                "*"
            ]
        }
    ]
}


  


  What do I miss ?

  


  janoskukoda@Janoss-MacBook-Pro promo-video-composer-2 % ls -l $(which ffmpeg)
lrwxr-xr-x  1 janoskukoda  admin  35 Feb 10 12:50 /opt/homebrew/bin/ffmpeg -> ../Cellar/ffmpeg/5.1.2_4/bin/ffmpeg


  


• ffmpeg in C# (ScrCpy)

  23 janvier 2020, par RunicSheep

  I’m trying to access the screen of my android device like ScrCpy does (https://github.com/Genymobile/scrcpy) but in C#.
  What I’ve done so far is pushing the jar (server) to my device and receiving the input. (Device resolution etc.)
  But I can’t re implement the decoding process in c#, there has to be some sort of error so far.
  C# library used for ffmpeg is ffmpeg.AutoGen (https://github.com/Ruslan-B/FFmpeg.AutoGen)

  Here’s the decoding code :

      using System;
  
  using System.Drawing;
  
  using System.Drawing.Imaging;
  
  using System.IO;
  
  using System.Linq;
  
  using System.Net;
  
  using System.Net.Sockets;
  
  using System.Runtime.InteropServices;
  
  using System.Runtime.InteropServices.ComTypes;
  
  using System.Threading;
  
  using FFmpeg.AutoGen;
  
  
  
  namespace Source.Android.Scrcpy
  
  {
  
      public unsafe class Decoder
  
      {
  
          private const string LD_LIBRARY_PATH = "LD_LIBRARY_PATH";
  
  
  
          private AVFrame* _decodingFrame;
  
          private AVCodec* _codec;
  
          private AVCodecContext* _codec_ctx;
  
          private AVFormatContext* _format_ctx;
  
  
  
          public Decoder()
  
          {
  
              RegisterFFmpegBinaries();
  
              SetupLogging();
  
  
  
              this.InitFormatContext();
  
          }
  
  
  
          private void InitFormatContext()
  
          {
  
              _decodingFrame = ffmpeg.av_frame_alloc();
  
              _codec = ffmpeg.avcodec_find_decoder(AVCodecID.AV_CODEC_ID_H264);
  
              if (_codec== null)
  
              {
  
                  throw new Exception("H.264 decoder not found");// run_end;
  
              }
  
  
  
              _codec_ctx = ffmpeg.avcodec_alloc_context3(_codec);
  
              if (_codec_ctx == null)
  
              {
  
                  throw new Exception("Could not allocate decoder context"); //run_end
  
              }
  
  
  
              if (ffmpeg.avcodec_open2(_codec_ctx, _codec, null) < 0)
  
              {
  
                  throw new Exception("Could not open H.264 codec");// run_finally_free_codec_ctx
  
              }
  
  
  
              _format_ctx = ffmpeg.avformat_alloc_context();
  
              if (_format_ctx == null)
  
              {
  
                  throw new Exception("Could not allocate format context");// run_finally_close_codec;
  
              }
  
          }
  
  
  
          private void RegisterFFmpegBinaries()
  
          {
  
              switch (Environment.OSVersion.Platform)
  
              {
  
                  case PlatformID.Win32NT:
  
                  case PlatformID.Win32S:
  
                  case PlatformID.Win32Windows:
  
                      var current = Environment.CurrentDirectory;
  
                      var probe = Path.Combine("FFmpeg", Environment.Is64BitProcess ? "x64" : "x86");
  
                      while (current != null)
  
                      {
  
                          var ffmpegDirectory = Path.Combine(current, probe);
  
                          if (Directory.Exists(ffmpegDirectory))
  
                          {
  
                              Console.WriteLine($"FFmpeg binaries found in: {ffmpegDirectory}");
  
                              RegisterLibrariesSearchPath(ffmpegDirectory);
  
                              return;
  
                          }
  
                          current = Directory.GetParent(current)?.FullName;
  
                      }
  
                      break;
  
                  case PlatformID.Unix:
  
                  case PlatformID.MacOSX:
  
                      var libraryPath = Environment.GetEnvironmentVariable(LD_LIBRARY_PATH);
  
                      RegisterLibrariesSearchPath(libraryPath);
  
                      break;
  
              }
  
          }
  
          private static void RegisterLibrariesSearchPath(string path)
  
          {
  
              switch (Environment.OSVersion.Platform)
  
              {
  
                  case PlatformID.Win32NT:
  
                  case PlatformID.Win32S:
  
                  case PlatformID.Win32Windows:
  
                      SetDllDirectory(path);
  
                      break;
  
                  case PlatformID.Unix:
  
                  case PlatformID.MacOSX:
  
                      string currentValue = Environment.GetEnvironmentVariable(LD_LIBRARY_PATH);
  
                      if (string.IsNullOrWhiteSpace(currentValue) == false && currentValue.Contains(path) == false)
  
                      {
  
                          string newValue = currentValue + Path.PathSeparator + path;
  
                          Environment.SetEnvironmentVariable(LD_LIBRARY_PATH, newValue);
  
                      }
  
                      break;
  
              }
  
          }
  
  
  
          [DllImport("kernel32", SetLastError = true)]
  
          private static extern bool SetDllDirectory(string lpPathName);
  
  
  
          private AVPacket GetPacket()
  
          {
  
              var packet = ffmpeg.av_packet_alloc();
  
              ffmpeg.av_init_packet(packet);
  
  
  
              packet->data = null;
  
              packet->size = 0;
  
  
  
              return *packet;
  
          }
  
  
  
          private static int read_raw_packet(void* opaque, ushort* buffer, int bufSize)
  
          {
  
              var buffSize = 1024;
  
              var remaining = dt.Length - dtp - 1;
  
              var written = 0;
  
              for (var i = 0; i < buffSize && i+dtp < dt.Length; i++)
  
              {
  
                  buffer[i] = dt[i+dtp];
  
                  written++;
  
              }
  
  
  
              dtp += written;
  
  
  
              if (written <= 0)
  
              {
  
                  return ffmpeg.AVERROR_EOF;
  
              }
  
  
  
              return written;
  
          }
  
  
  
          [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
  
          public delegate int av_read_function_callback(void* opaque, ushort* endData, int bufSize);
  
  
  
          private static byte[] dt;
  
          private static int dtp;
  
  
  
          public Bitmap DecodeScrCpy(byte[] data)
  
          {
  
              if (data.Length == 0)
  
              {
  
                  return null;
  
              }
  
  
  
              byte* _buffer;
  
              ulong _bufferSize = 1024*2;
  
              _buffer = (byte*)ffmpeg.av_malloc(_bufferSize);
  
              if (_buffer == null)
  
              {
  
                  throw new Exception("Could not allocate buffer"); // run_finally_free_format_ctx;
  
              }
  
  
  
              fixed (byte* dataPtr = data)
  
              {
  
                  dt = data;
  
                  dtp = 0;
  
                  fixed (AVFormatContext** formatCtxPtr = &_format_ctx)
  
                  {
  
                      var mReadCallbackFunc = new av_read_function_callback(read_raw_packet);
  
                      AVIOContext* avio_ctx = ffmpeg.avio_alloc_context(_buffer, (int)_bufferSize, 0, null, //TODO: IntPtr.Zero nutzen?
  
                          new avio_alloc_context_read_packet_func{Pointer = Marshal.GetFunctionPointerForDelegate(mReadCallbackFunc) }, 
  
                          null, null);
  
                      if (avio_ctx == null)
  
                      {
  
                          ffmpeg.av_free(dataPtr);
  
                          throw new Exception("Could not allocate avio context"); //goto run_finally_free_format_ctx;
  
                      }
  
  
  
                      _format_ctx->pb = avio_ctx;
  
  
  
                      if (ffmpeg.avformat_open_input(formatCtxPtr, null, null, null) < 0)
  
                      {
  
                          throw new Exception("Could not open video stream"); // goto run_finally_free_avio_ctx;
  
                      }
  
  
  
                      var packet = GetPacket();
  
  
  
                      while (ffmpeg.av_read_frame(_format_ctx, &packet) == 0)
  
                      {
  
                          if (ffmpeg.LIBAVDEVICE_VERSION_INT >= ffmpeg.AV_VERSION_INT(57, 37, 0))
  
                          {
  
                              int ret;
  
                              if ((ret = ffmpeg.avcodec_send_packet(_codec_ctx, &packet)) < 0)
  
                              {
  
                                  throw new Exception($"Could not send video packet: {ret}"); //goto run_quit
  
                              }
  
  
  
                              ret = ffmpeg.avcodec_receive_frame(_codec_ctx, _decodingFrame);
  
                              if (ret == 0)
  
                              {
  
                                  // a frame was received
  
                              }
  
                              else if (ret != ffmpeg.AVERROR(ffmpeg.EAGAIN))
  
                              {
  
                                  ffmpeg.av_packet_unref(&packet);
  
                                  throw new Exception($"Could not receive video frame: {ret}"); //goto run_quit;
  
                              }
  
                          }
  
                      }
  
                  }
  
              }
  
  
  
              return null;
  
          }
  
      }
  
  }

  Entry is DecodeScrCpy with read data from network stream.
  Things I noticed :

  • read_raw_packet is called again after ffmpeg.AVERROR_EOF is returned
  • ffmpeg.avformat_open_input fails

  Question is, did I miss anything ?

• Data Privacy Day 2021 : Five ways to embrace privacy into your business

  27 janvier 2021, par Matomo Core Team — Community, Privacy

  Welcome to Data Privacy Day 2021 !

  This year we are excited to announce that we are participating as a #PrivacyAware Champion for DPD21 through the National Cyber Security Alliance. This means that on this significant day we are in partnership with hundreds of other organisations and businesses to share a unified message that empowers individuals to “Own Your Privacy” and for organisations to “Respect Privacy.”

  "Last year dawned a new era in the way many businesses operate from a traditional office work setting to a remote working from home environment for employees. This now means it’s more important than ever for your employees to understand how to take ownership of their privacy when working online."

  As a Data Privacy Day #PrivacyAware Champion we would like to provide some practical tips and share examples of how the Matomo team helps employees be privacy aware.

  

  Five ways to embrace privacy into your business

  1. Create a privacy aware culture within your business

  • Get leadership involved.
  • Appoint privacy ambassadors within your team. 
  • Create a privacy awareness campaign where you educate employees on your company privacy policy. 
  • Share messages about privacy around the office/or in meetings online, on internal message boards, in company newsletters, or emails. 
  • Teach new employees their role in your privacy culture and reinforce throughout their career.

  2. Organise privacy awareness training for your employees

  • Invite outside speakers to talk to employees about why privacy matters. 
  • Engage staff by asking them to consider how privacy and data security applies to the work they do on a daily basis.
  • Encourage employees to complete online courses to gain a better understanding of how to avoid privacy risks.

  3. Help employees manage their individual privacy

  • Better security and privacy behaviours at home will translate to better security and privacy practices at work. 
  • Teach employees how to update their privacy and security settings on personal accounts.
  • Use NCSA’s privacy settings page to help them get started

  4. Add privacy to the employee’s toolbox

  • Give your employees actual tools they can use to improve their privacy, such as company-branded camera covers or privacy screens for their devices, or virtual private networks (VPNs) to secure their connections.

  5. Join Matomo and we’ll be your web analytics experts

  • At Matomo, ensuring our users and customers that their privacy is protected is not only a core component of the work we do, it’s why we do what we do ! Find out how.

  Want to find out more about data privacy download your free DPD 2021 Champion Toolkit and read our post on “Why is privacy important”.

  Team Matomo

  2021 Data Privacy Day Toolkit

  Your guide to Data Privacy Day, January 28, 2021

  Free Download