Recherche avancée

Sur d’autres sites (5193)

• Can I create a VFR video from timestamped images ?

  18 juin 2016, par Beginner

  First, I have almost zero experience in making videos from images.

  What I have is a set of BMP timestamped images from which I want to generate a video.
  Since the timestamps are not equally spaced, I cannot simply use software that create constant-frame-rate videos from images.

  A possible solution would be to create artificial images at fixed time intervals, but I prefer to leave that as a last resort if I fail to make a VFR video.

  Any suggestions on how to achieve what I want ?

• Cutting a live stream into separate mp4 files

  9 juin 2017, par Fearhunter

  I am doing a research for cutting a live stream in piece and save it as mp4 files. I am using this source for the proof of concept :

  https://docs.microsoft.com/en-us/azure/media-services/media-services-dotnet-creating-live-encoder-enabled-channel#download-sample

  And this is the example code I use :

  using System;
  
  using System.Collections.Generic;
  
  using System.Configuration;
  
  using System.IO;
  
  using System.Linq;
  
  using System.Net;
  
  using System.Security.Cryptography;
  
  using System.Text;
  
  using System.Threading.Tasks;
  
  using Microsoft.WindowsAzure.MediaServices.Client;
  
  using Newtonsoft.Json.Linq;
  
  
  
  namespace AMSLiveTest
  
  {
  
      class Program
  
      {
  
          private const string StreamingEndpointName = "streamingendpoint001";
  
          private const string ChannelName = "channel001";
  
          private const string AssetlName = "asset001";
  
          private const string ProgramlName = "program001";
  
  
  
          // Read values from the App.config file.
  
          private static readonly string _mediaServicesAccountName =
  
          ConfigurationManager.AppSettings["MediaServicesAccountName"];
  
          private static readonly string _mediaServicesAccountKey =
  
          ConfigurationManager.AppSettings["MediaServicesAccountKey"];
  
  
  
          // Field for service context.
  
          private static CloudMediaContext _context = null;
  
          private static MediaServicesCredentials _cachedCredentials = null;
  
  
  
          static void Main(string[] args)
  
          {
  
              // Create and cache the Media Services credentials in a static class variable.
  
              _cachedCredentials = new MediaServicesCredentials(
  
              _mediaServicesAccountName,
  
              _mediaServicesAccountKey);
  
              // Used the cached credentials to create CloudMediaContext.
  
              _context = new CloudMediaContext(_cachedCredentials);
  
  
  
              IChannel channel = CreateAndStartChannel();
  
  
  
              // Set the Live Encoder to point to the channel's input endpoint:
  
              string ingestUrl = channel.Input.Endpoints.FirstOrDefault().Url.ToString();
  
  
  
              // Use the previewEndpoint to preview and verify
  
              // that the input from the encoder is actually reaching the Channel.
  
              string previewEndpoint = channel.Preview.Endpoints.FirstOrDefault().Url.ToString();
  
  
  
              IProgram program = CreateAndStartProgram(channel);
  
              ILocator locator = CreateLocatorForAsset(program.Asset, program.ArchiveWindowLength);
  
              IStreamingEndpoint streamingEndpoint = CreateAndStartStreamingEndpoint();
  
              GetLocatorsInAllStreamingEndpoints(program.Asset);
  
  
  
              // Once you are done streaming, clean up your resources.
  
              Cleanup(streamingEndpoint, channel);
  
          }
  
  
  
          public static IChannel CreateAndStartChannel()
  
          {
  
              //If you want to change the Smooth fragments to HLS segment ratio, you would set the ChannelCreationOptions’s Output property.
  
  
  
              IChannel channel = _context.Channels.Create(
  
              new ChannelCreationOptions
  
              {
  
              Name = ChannelName,
  
              Input = CreateChannelInput(),
  
              Preview = CreateChannelPreview()
  
              });
  
  
  
              //Starting and stopping Channels can take some time to execute. To determine the state of operations after calling Start or Stop, query the IChannel.State .
  
  
  
              channel.Start();
  
  
  
              return channel;
  
          }
  
  
  
          private static ChannelInput CreateChannelInput()
  
          {
  
              return new ChannelInput
  
              {
  
                  StreamingProtocol = StreamingProtocol.RTMP,
  
                  AccessControl = new ChannelAccessControl
  
                  {
  
                      IPAllowList = new List<iprange>
  
                              {
  
                              new IPRange
  
                          {
  
                              Name = "TestChannelInput001",
  
                              // Setting 0.0.0.0 for Address and 0 for SubnetPrefixLength
  
                              // will allow access to IP addresses.
  
                              Address = IPAddress.Parse("0.0.0.0"),
  
                              SubnetPrefixLength = 0
  
                          }
  
                      }
  
                  }
  
              };
  
          }
  
  
  
          private static ChannelPreview CreateChannelPreview()
  
          {
  
              return new ChannelPreview
  
              {
  
                  AccessControl = new ChannelAccessControl
  
                  {
  
                      IPAllowList = new List<iprange>
  
                      {
  
                          new IPRange
  
                          {
  
                              Name = "TestChannelPreview001",
  
                              // Setting 0.0.0.0 for Address and 0 for SubnetPrefixLength
  
                              // will allow access to IP addresses.
  
                              Address = IPAddress.Parse("0.0.0.0"),
  
                              SubnetPrefixLength = 0
  
                          }
  
                      }
  
                  }
  
              };
  
          }
  
  
  
          public static void UpdateCrossSiteAccessPoliciesForChannel(IChannel channel)
  
          {
  
              var clientPolicy =
  
                  @"&lt;?xml version=""1.0"" encoding=""utf-8""?>
  
              
  
                  
  
                      <policy>
  
                          
  
                              <domain uri=""></domain>
  
                          
  
                          
  
                             <resource path=""></resource>"" include-subpaths=""true""/>
  
                          
  
                      </policy>
  
                  
  
              ";
  
  
  
              var xdomainPolicy =
  
                  @"&lt;?xml version=""1.0"" ?>
  
              
  
                  
  
              ";
  
  
  
              channel.CrossSiteAccessPolicies.ClientAccessPolicy = clientPolicy;
  
              channel.CrossSiteAccessPolicies.CrossDomainPolicy = xdomainPolicy;
  
  
  
              channel.Update();
  
          }
  
  
  
          public static IProgram CreateAndStartProgram(IChannel channel)
  
          {
  
              IAsset asset = _context.Assets.Create(AssetlName, AssetCreationOptions.None);
  
  
  
              // Create a Program on the Channel. You can have multiple Programs that overlap or are sequential;
  
              // however each Program must have a unique name within your Media Services account.
  
              IProgram program = channel.Programs.Create(ProgramlName, TimeSpan.FromHours(3), asset.Id);
  
              program.Start();
  
  
  
              return program;
  
          }
  
  
  
          public static ILocator CreateLocatorForAsset(IAsset asset, TimeSpan ArchiveWindowLength)
  
          {
  
              // You cannot create a streaming locator using an AccessPolicy that includes write or delete permissions.            
  
  
  
              var locator = _context.Locators.CreateLocator
  
                  (
  
                      LocatorType.OnDemandOrigin,
  
                      asset,
  
                      _context.AccessPolicies.Create
  
                      (
  
                          "Live Stream Policy",
  
                          ArchiveWindowLength,
  
                          AccessPermissions.Read
  
                      )
  
                  );
  
  
  
              return locator;
  
          }
  
  
  
          public static IStreamingEndpoint CreateAndStartStreamingEndpoint()
  
          {
  
              var options = new StreamingEndpointCreationOptions
  
              {
  
                  Name = StreamingEndpointName,
  
                  ScaleUnits = 1,
  
                  AccessControl = GetAccessControl(),
  
                  CacheControl = GetCacheControl()
  
              };
  
  
  
              IStreamingEndpoint streamingEndpoint = _context.StreamingEndpoints.Create(options);
  
              streamingEndpoint.Start();
  
  
  
              return streamingEndpoint;
  
          }
  
  
  
          private static StreamingEndpointAccessControl GetAccessControl()
  
          {
  
              return new StreamingEndpointAccessControl
  
              {
  
                  IPAllowList = new List<iprange>
  
                  {
  
                      new IPRange
  
                      {
  
                          Name = "Allow all",
  
                          Address = IPAddress.Parse("0.0.0.0"),
  
                          SubnetPrefixLength = 0
  
                      }
  
                  },
  
  
  
                  AkamaiSignatureHeaderAuthenticationKeyList = new List<akamaisignatureheaderauthenticationkey>
  
                  {
  
                      new AkamaiSignatureHeaderAuthenticationKey
  
                      {
  
                          Identifier = "My key",
  
                          Expiration = DateTime.UtcNow + TimeSpan.FromDays(365),
  
                          Base64Key = Convert.ToBase64String(GenerateRandomBytes(16))
  
                      }
  
                  }
  
              };
  
          }
  
  
  
          private static byte[] GenerateRandomBytes(int length)
  
          {
  
              var bytes = new byte[length];
  
              using (var rng = new RNGCryptoServiceProvider())
  
              {
  
                  rng.GetBytes(bytes);
  
              }
  
  
  
              return bytes;
  
          }
  
  
  
          private static StreamingEndpointCacheControl GetCacheControl()
  
          {
  
              return new StreamingEndpointCacheControl
  
              {
  
                  MaxAge = TimeSpan.FromSeconds(1000)
  
              };
  
          }
  
  
  
          public static void UpdateCrossSiteAccessPoliciesForStreamingEndpoint(IStreamingEndpoint streamingEndpoint)
  
          {
  
              var clientPolicy =
  
                  @"&lt;?xml version=""1.0"" encoding=""utf-8""?>
  
              
  
                  
  
                      <policy>
  
                          
  
                              <domain uri=""></domain>
  
                          
  
                          
  
                             <resource path=""></resource>"" include-subpaths=""true""/>
  
                          
  
                      </policy>
  
                  
  
              ";
  
  
  
              var xdomainPolicy =
  
                  @"&lt;?xml version=""1.0"" ?>
  
              
  
                  
  
              ";
  
  
  
              streamingEndpoint.CrossSiteAccessPolicies.ClientAccessPolicy = clientPolicy;
  
              streamingEndpoint.CrossSiteAccessPolicies.CrossDomainPolicy = xdomainPolicy;
  
  
  
              streamingEndpoint.Update();
  
          }
  
  
  
          public static void GetLocatorsInAllStreamingEndpoints(IAsset asset)
  
          {
  
              var locators = asset.Locators.Where(l => l.Type == LocatorType.OnDemandOrigin);
  
              var ismFile = asset.AssetFiles.AsEnumerable().FirstOrDefault(a => a.Name.EndsWith(".ism"));
  
              var template = new UriTemplate("{contentAccessComponent}/{ismFileName}/manifest");
  
              var urls = locators.SelectMany(l =>
  
                          _context
  
                              .StreamingEndpoints
  
                              .AsEnumerable()
  
                              .Where(se => se.State == StreamingEndpointState.Running)
  
                              .Select(
  
                                  se =>
  
                                      template.BindByPosition(new Uri("http://" + se.HostName),
  
                                      l.ContentAccessComponent,
  
                                          ismFile.Name)))
  
                          .ToArray();
  
  
  
          }
  
  
  
          public static void Cleanup(IStreamingEndpoint streamingEndpoint,
  
                                      IChannel channel)
  
          {
  
              if (streamingEndpoint != null)
  
              {
  
                  streamingEndpoint.Stop();
  
                  streamingEndpoint.Delete();
  
              }
  
  
  
              IAsset asset;
  
              if (channel != null)
  
              {
  
  
  
                  foreach (var program in channel.Programs)
  
                  {
  
                      asset = _context.Assets.Where(se => se.Id == program.AssetId)
  
                                              .FirstOrDefault();
  
  
  
                      program.Stop();
  
                      program.Delete();
  
  
  
                      if (asset != null)
  
                      {
  
                          foreach (var l in asset.Locators)
  
                              l.Delete();
  
  
  
                          asset.Delete();
  
                      }
  
                  }
  
  
  
                  channel.Stop();
  
                  channel.Delete();
  
              }
  
          }
  
      }
  
  }
  
  </akamaisignatureheaderauthenticationkey></iprange></iprange></iprange>

  Now I want to make a method to cut a live stream for example every 15 minutes and save it as mp4 but don’t know where to start.

  Can someone point me in the right direction ?

  Kind regards

  UPDATE :

  I want to save the mp4 files on my hard disk.

• FFMPEG - await ffmpeg.load() - overlay.ts Uncaught ReferenceError : document is not defined

  26 mars 2024, par devVue123

  I use FFMPEG plugin with Vue3 and Vite. My code :

  


  <code class="echappe-js">&lt;script setup&gt;&amp;#xA;import { FFmpeg } from &amp;#x27;@ffmpeg/ffmpeg&amp;#x27;&amp;#xA;import { fetchFile, toBlobURL } from &amp;#x27;@ffmpeg/util&amp;#x27;&amp;#xA;import {onMounted} from &quot;vue&quot;;&amp;#xA;&amp;#xA;// const baseURL = &amp;#x27;https://unpkg.com/@ffmpeg/core@0.12.6/dist/esm&amp;#x27; // doc - vite&amp;#xA;const baseURL = &amp;#x27;https://unpkg.com/@ffmpeg/core-mt@0.12.6/dist/esm&amp;#x27; // example&amp;#xA;&amp;#xA;const ffmpeg = new FFmpeg();&amp;#xA;&amp;#xA;onMounted(() =&gt; {&amp;#xA;    initializeFfmpeg()&amp;#xA;})&amp;#xA;&amp;#xA;const initializeFfmpeg = async () =&gt; {&amp;#xA;await ffmpeg.load()&amp;#xA;}&amp;#xA;&lt;/script&gt;&#xA;

  


  but FFMPEG is not initialized correctly.
the error occurs when I run the command :

  


  await ffmpeg.load()


  


  I get an error that may be related to vite :



  


  I tried several import options, but I still get this error. please help me, thank you

  


  package.json

  


  "dependencies": {
    "@ffmpeg/core": "^0.12.6",
    "@ffmpeg/ffmpeg": "0.12.6",
    "@ffmpeg/util": "^0.12.1",
    "vue": "^3.4.21"
  },
  "devDependencies": {
    "@vitejs/plugin-vue": "^5.0.4",
    "vite": "^5.2.0"
  }


  


  vite.config.js

  


  import { defineConfig } from 'vite'
import vue from '@vitejs/plugin-vue'
import { fileURLToPath, URL } from 'node:url'

// https://vitejs.dev/config/
export default defineConfig({
    plugins: [vue()],
    resolve: {
        alias: {
            '@': fileURLToPath(new URL('./src', import.meta.url))
        }
    },
    optimizeDeps: {
        exclude: ["@ffmpeg/ffmpeg", "@ffmpeg/util"],
    },
    server: {
        headers: {
            "Cross-Origin-Opener-Policy": "same-origin",
            "Cross-Origin-Embedder-Policy": "require-corp",
        },
    },
})


  


  node version :

  


  v18.18.2


  


  I try this too :

  


  await ffmpeg.load({
        coreURL: await toBlobURL(`${baseURL}/ffmpeg-core.js`, 'text/javascript'),
        wasmURL: await toBlobURL(`${baseURL}/ffmpeg-core.wasm`, 'application/wasm'),
        workerURL: await toBlobURL(`${baseURL}/ffmpeg-core.worker.js`, 'text/javascript')
    })