Recherche avancée

Sur d’autres sites (8348)

• Enable Quality Selector Control in Angular Using Video.js

  22 juillet, par Abhay Singh

  I am using Video.js in an Angular 19.1.3 application, with version 8.21.0 of Video.js. I have successfully set up an HLS stream using a master index.m3u8 file, and the player automatically switches to lower quality segments when the network is slow, and to higher quality when the network is good. This part works as expected.

  


  However, I would like to add a manual quality selection option to allow users to choose the video quality themselves. Despite trying several plugins (such as videojs-hls-quality-selector and videojs-contrib-quality-levels), I haven't been able to get it working.

  


  Can anyone guide me on how to implement this feature in Video.js, ensuring that the quality selector is available for manual selection ?

  


  Below is my Components code -

  


  import {AfterViewInit, Component} from '@angular/core';
import videojs from 'video.js';
import '@videojs/http-streaming';
import 'video.js/dist/video-js.css';

@Component({
  selector: 'app-home',
  imports: [],
  templateUrl: './home.component.html',
  styleUrl: './home.component.css'
})
export class HomeComponent implements AfterViewInit {
  
  ngAfterViewInit(): void {
    const player = videojs('my-video', {
      autoplay: false,
      controls: true,
      preload: 'auto',
      fluid: true,
      aspectRatio: '16:9',
    })
  
  }
}


  


  Below is my HTML code -

  


  <video class="video-js vjs-default-skin" controls="controls">&#xA;    <source src="https://localhost:7063/videos/no1lvswh.zdw.mkv/index.m3u8" type="application/x-mpegURL">&#xA;  </source></video>  &#xA;

  


• How to Dynamically Control FFmpeg Encoding Bitrate Based on Current Network Bandwidth ? [closed]

  26 novembre 2024, par Stove Fire

  I’ve implemented a program using FFmpeg where the server encodes OpenGL render results and sends them to the client. The client then decodes the video and renders the result onto a texture using OpenGL. What I’m trying to achieve is to adjust the encoding bitrate dynamically based on the current network bandwidth — higher bandwidth results in higher bitrate encoding, and lower bandwidth results in lower bitrate encoding.

  


  I use libx264 encoder and rtsp.

  


  I found the iperf tool online, which is useful for measuring network bandwidth, but it is a command-line tool and does not have a readily available API for programmatic use.

  


  My questions are :

  


  How can I monitor the current network bandwidth programmatically in my application (preferably in C++) ?

  


  Is there a way to integrate bandwidth monitoring into my FFmpeg encoding process so I can adjust the bitrate dynamically based on the current network conditions ?

  


• ffmpeg : Apply a time-based expression to control lowpass, highpass, aphaser, or aecho [closed]

  17 mai 2024, par Wes Modes

  I am constructing complexFilters to procedurally generate audio with ffmpeg via fluent-ffmpeg. The interesting part of my fluent-ffmpeg complex filters look like :

  


  {
   "filter": "volume",
   "options": {
       "volume": "min(1, max(0, ((cos(PI * t * 1 / 13) * 1 + cos(PI * t * 1 / 7) * 0.5 + cos(PI * t * 1 / 3) * 0.25) +
-0.5 ) * 0.75 * -1 + 0.5))",
       "eval": "frame"
    },
    "inputs": "track_1_output",
    "outputs": "track_1_adjusted"
},


  


  Note that I am using an expression to determine the volume dynamically. To simplify my tests, I'm constructing complexFilters on the command line to understand the mysteries of some of the lightly-documented ffmpeg filters. Here's a working CLI test of using the volume filter to fade the sources in and out according to a time-based expresssion :

  


  # working fade in/out
ffmpeg -i knox.mp3 -i static.mp3 -filter_complex \
"[0:a] \
    volume = 'min(1, max(0, 0.5 + 0.5 * cos(PI * t / 5)))': eval=frame \
    [a0]; \
[1:a] \
    volume = 'min(1, max(0, 0.5 - 0.5 * cos(PI * t / 5)))': eval=frame \
    [a1]; \
[a0][a1]
    amix = inputs=2: duration=shortest" \
-c:a libmp3lame -q:a 2 output.mp3


  


  Now I want to apply lowpass, highpass, aphaser, and/or aecho to the transitions using a time-based expression. For instance, looking at lowpasss, according to ffmpeg -filters it says that it has time-based support :

  


    T.. = Timeline support
 TSC lowpass           A->A       Apply a low-pass filter with 3dB point frequency.


  


  How can I similarly apply a time-based expression to lowpass, highpass, aphaser, or aecho ? I thought the mix option might be the key, but I couldn't construct a working example and couldn't find any examples.

  


  # applying a lowpass filter
ffmpeg -i knox.mp3 -filter_complex \
"[0:a] \
    lowpass=f=3000:mix='0.5 + 0.5 * cos(PI * t / 5)';" \
-c:a libmp3lame -q:a 2 output.mp3


  


  Or if you prefer the fluent-ffmpeg filter :

  


  const ffmpeg = require('fluent-ffmpeg');

ffmpeg('knox.mp3')
    .complexFilter([
        {
            filter: 'lowpass',
            options: {
                f: 3000,
                mix: '0.5 + 0.5 * cos(PI * t / 5)'
            },
            inputs: '[0:a]',
        }
    ])
    .audioCodec('libmp3lame')
    .audioQuality(2)
    .save('output.mp3')
    .on('end', () => {
        console.log('Processing finished successfully');
    })
    .on('error', (err) => {
        console.error('Error: ' + err.message);
    });


  


  With the resultant error :

  


  [Parsed_lowpass_1 @ 0x7f9a72005c00] [Eval @ 0x7ff7bec423d8] Undefined constant or missing '(' in 't/5)'
[Parsed_lowpass_1 @ 0x7f9a72005c00] Unable to parse option value "0.5 + 0.5 * cos(PI * t / 5)"
Error applying option 'mix' to filter 'lowpass': Invalid argument


  


  What complicated fffmpeg faerie magic is needed to make some of the filters other than volume controlled by a time-based expr ?