Recherche avancée

Sur d’autres sites (8863)

• Batch splitting large audio files into small fixed-length audio files in moments of silence

  26 juillet 2023, par Haldjärvi

  to train the SO-VITS-SVC neural network, we need 10-14 second voice files. As a material, let's say I use phrases from some game. I have already made a batch script for decoding different files into one working format, another batch script for removing silence, as well as a batch script for combining small audio files into files of 13-14 seconds (I used Python, pydub and FFmpeg). To successfully automatically create a training dataset, it remains only to make one batch script - Cutting audio files lasting more than 14 seconds into separate files lasting 10-14 seconds, cutting in places of silence or close to silence is highly preferable.

  


  So, it is necessary to batch cut large audio files (20 seconds, 70 seconds, possibly several hundred seconds) into segments of approximately 10-14 seconds, however, the main task is to look for the quietest place in the cut areas so as not to cut phrases in the middle of a word (this is not very good for model training). So, is it really possible to do this in a very optimal way, so that the processing of a 30-second file does not take 15 seconds, but is fast ? Quiet zone detection is required only in the area of cuts, that is, 10-14 seconds, if counted from the very beginning of the file.

  


  I would be very grateful for any help.

  


  I tried to write a script together with ChatGPT, but all options gave completely unpredictable results and were not even close to what I needed... I had to stop at the option with a sharp cut of files for exactly 14000 milliseconds. However, I hope there is a chance to make a variant with cutting exactly in quiet areas.

  


  import os
from pydub import AudioSegment

input_directory = ".../RemSilence/"
output_directory = ".../Split/"
max_duration = 14000

def split_audio_by_duration(input_file, duration):
    audio = AudioSegment.from_file(input_file)
    segments = []
    for i in range(0, len(audio), duration):
        segment = audio[i:i + duration]
        segments.append(segment)
    return segments

if __name__ == "__main__":
    os.makedirs(output_directory, exist_ok=True)
    audio_files = [os.path.join(input_directory, file) for file in os.listdir(input_directory) if file.endswith(".wav")]
    audio_files.sort(key=lambda file: len(AudioSegment.from_file(file)))
    for file in audio_files:
        audio = AudioSegment.from_file(file)
        if len(audio) > max_duration:
            segments = split_audio_by_duration(file, max_duration)
            for i, segment in enumerate(segments):
                output_filename = f"output_{len(os.listdir(output_directory))+1}.wav"
                output_file_path = os.path.join(output_directory, output_filename)
                segment.export(output_file_path, format="wav")
        else:
            output_filename = f"output_{len(os.listdir(output_directory))+1}.wav"
            output_file_path = os.path.join(output_directory, output_filename)
            audio.export(output_file_path, format="wav")


  


• Unable to loop QTRLE video in Processing

  7 juin 2021, par AtrashDingDong

  I have converted series of JPEG images into videos with Ffmpeg and played them in loop in Processing. I need good image quality, fast response from a "play" button, and the ability to loop.

  


  With some Ffmpeg commands, this playback system works ok, but the video quality is poor, the playback is stuttering and there is significant delay between the moment I call the video (with OSC from PureData) and the moment it's starting :

  


  ffmpeg -r 24 -f image2 -s 6000x3376 -start_number 1 -i frame%d.jpg -vframes 366 -vf scale=1920:1080,setsar=1:1 -vcodec libx264 -crf 25 -pix_fmt yuv420p clip.mov

  


  or

  


  ffmpeg -r 24 -f image2 -s 6000x3376 -start_number 1 -i frame%d.jpg -vframes 366 -vf scale=1920:1080,setsar=1:1 -vcodec mjpeg clipMJPEG.mov

  


  I've been getting good image quality and playing response with QTRLE codec :

  


  ffmpeg -r 24 -f image2 -s 6000x3376 -start_number 1 -i frame%d.jpg -vframes 366 -vf scale=1920:1080,setsar=1:1 -vcodec qtrle clipQTRLE.mov

  


  But with those QTRLE videos, they play once through in Processing but don't loop, whereas with the exact same Processing code, I am able to loop the poor quality MJPEG and H.264 videos.

  


  What is strange is that one of the QTRLE videos actually loops and looks great, but all the other ones don't. I'm suspecting there might be something wrong or confusing to render with my JPEG images. Some of the images are really small (5 to 15 MiB) whereas others in the same sequence are quite bigger (200 MiB until 1 GiB). The bigger ones show a video format, with a 16:9 aspect ratio. The smaller ones don't show that kind of information. Would there be a way to make all the images the same format ? Would that help ?

  


  Also, all of the above codes show an error :

  


  ­[swscaler @ 000002098c0ec540] deprecated pixel format used, make sure you did set range correctly

  


  but the videos can nevertheless be played just like explained above. I've played around with the pixel format, but the problems have stayed the same.

  


  Is this a problem with the codec ? The JPEGs ? The pixel format ? Or something else ?

  


  Thanks in advance

  


• aacenc : add support for changing options based on a profile

  12 octobre 2015, par Rostislav Pehlivanov

  aacenc : add support for changing options based on a profile
  This commit adds the ability for a profile to set the default
  
  options, as well as for the user to override such options
  
  by simply stating them in the command line while still keeping
  
  the same profile, as long as those options are still permitted by
  
  the profile.
  Example : setting the profile to aac_low (the default) will turn
  
  PNS and IS on. They can be disabled by -aac_pns 0 and -aac_is 0,
  
  respectively. Turning on -aac_pred 1 will cause the profile to be
  
  elevated to aac_main, as long as no options forbidding aac_main
  
  have been entered (like AAC-LTP, which will be pushed soon).
  A useful feature is that by setting the profile to mpeg2_aac_low,
  
  all MPEG4 features will be disabled and if the user tries to enable
  
  them then the program will exit with an error. This profile is
  
  signalled with the same bitstream as aac_low (MPEG4) but some devices
  
  and decoders will fail if any MPEG4 features have been enabled.
  

  • [DH] libavcodec/aaccoder_twoloop.h
  • [DH] libavcodec/aacenc.c
  • [DH] libavcodec/aacenc.h
  • [DH] libavcodec/aacenc_utils.h
  • [DH] libavcodec/aacenctab.h