Recherche avancée

Sur d’autres sites (7046)

• Revision 108588 : Nouvelle saisie : une grille de choix (multiples ou cases à cocher). ...

  11 juin 2018, par rastapopoulos@… — Log

  Nouvelle saisie : une grille de choix (multiples ou cases à cocher). Donc radio et checkbox dans la même saisie car quasiment rien ne change, et donc juste à activer avec multiple=oui. Comme c’est à deux dimensions, on doit fournir la description des colonnes data_cols et la description des lignes data_rows (comme les data dans les autres saisies). Demande d’aide : les input n’ont pas de label, et je ne trouve aucune documentation pour rendre ce type de saisie accessible (je suppose avec des aria-truc…). Pour l’instant il y a juste la saisie, ce qui permet de l’utiliser dans vos formulaires. Il faudrait ajouter une vue + un yaml pour pouvoir l’utiliser dans Formidable par exemple. Sauf que je ne vois pas comment remplir la valeur par défaut, nos transformations depuis textarea ne savent que transformer en tableau à une dimension, pas deux. Ou bien on dit que pour l’instant pour ce type de saisie, on ne peut pas mettre de valeur par défaut dans Formidable et CE.

• using speech diarization results in speech recognition API

  10 septembre 2021, par FIRE

  I'm trying to understand more about speech diarization and speech recognition . I started following this tutorial and I was able to get tubles of the audio labeling .

  


  According to the tutorial you can use google speech API and send the audio segments to googles API and it will get transcribed and That is exactly where I'm stuck at !

  


  According to the tutorial All you have to do is

  


  

  0. Get a Google /Ibm watson API speech to text (done)

  


  


  (I have done this step and got Watson API key and url !)

  


  1.For each tuple element ‘ele’ in your labelling file, extract ele[0] as the speaker label, ele1 as the start time and ele[2] as the end time.

  


  (I didn't understand this step at all ... I tried this , but I'm not quit sure if this is what they mean)

  


  
for ele in labelling:
    speaker_label = ele[0]
    start_time = ele[1]
    end_time=ele[2]



  


  2.Trim your original audio file from start time to end time. You can use ffmpeg for this task.

  


  (This step depends on step 1 ,but I also don't understand it as I have no idea how to use ffmpeg or how to utilize it for this project)

  


  3.Pass the trimmed audio file obtained in the previous step to Google’s API/ Ibm watson API which will return you the text transcript of this audio segment.

  


  (I just need to understand the context or the code of how to pass the segmented audio and how it will look like)

  


  4.Write the transcript along with the speaker label to a text file and save it.

  


  Any help would be more than appreciated !

  


  My Full code :

  


  from resemblyzer import preprocess_wav, VoiceEncoder
from pathlib import Path

from resemblyzer.audio import sampling_rate

from spectralcluster import SpectralClusterer

import ffmpeg

from ibm_watson import SpeechToTextV1
from ibm_cloud_sdk_core.authenticators import IAMAuthenticator

# Ibm related components (Not used as it's not implemented )
authenticator = IAMAuthenticator('Key here')
speech_to_text = SpeechToTextV1(
    authenticator=authenticator
)


speech_to_text.set_service_url(
    'URL HERE')

#-------------------------------------------------------

#From the tutorial this part is to get the audio file and to process it 

# give the file path to your audio file
audio_file_path = 'Audio files/testForTheOthers.wav'
wav_fpath = Path(audio_file_path)

wav = preprocess_wav(wav_fpath)
encoder = VoiceEncoder("cpu")
_, cont_embeds, wav_splits = encoder.embed_utterance(wav, return_partials=True, rate=16)
print(cont_embeds.shape)



#-----------------------------------------------------------------------


#From the tutorial this is the clustering part
#(some parts of the code got me error that is why they are not included)
# (p_percentile=0.90,gaussian_blur_sigma=1) got removed (Errors)

clusterer = SpectralClusterer(
    min_clusters=2,
    max_clusters=100,
)

labels = clusterer.predict(cont_embeds)
#-----------------------------------------------------------------------



#From the tutorial this is the clustering part


def create_labelling(labels, wav_splits):
    from resemblyzer.audio import sampling_rate
    times = [((s.start + s.stop) / 2) / sampling_rate for s in wav_splits]
    labelling = []
    start_time = 0

    for i, time in enumerate(times):
        if i > 0 and labels[i] != labels[i - 1]:
            temp = [str(labels[i - 1]), start_time, time]
            labelling.append(tuple(temp))
            start_time = time
        if i == len(times) - 1:
            temp = [str(labels[i]), start_time, time]
            labelling.append(tuple(temp))

    return labelling


labelling = create_labelling(labels, wav_splits)


print(labelling)
#----------------------

#Me Trying to implement step 1

for ele in labelling:
    speaker_label = ele[0]
    start_time = ele[1]
    end_time=ele[2]


#-----------------------------------------------------------------------------

#After this part you are supposed to implement the rest of the tutorial 
#but I'm stuck




  


• Trying to convert code to be compatible with macOS by not using the .exe version of FFmpeg and FFmprobe. Cant open the .mp4 file when i go to run code

  9 juillet 2024, par Bruno Hawkins

  I am attempting to edit some code in python for extracting frames from a video (using parallel processing to make it faster) a friend created that works on windows, so that it can be used on macOS. However, i am running into some issues and i am not sure what the problem is.

  


  Essentially, when i go to run the frame extractor and try to select a video in the formats specified, it wont let me select it.

  


  i have commented my code best i can. i am an amateur programmer so apologies if it is straightforward.

  


  import os
import subprocess
import multiprocessing
import tkinter as tk
from tkinter import ttk, filedialog, messagebox

def extract_frames(video_path, output_folder, fps, start_time, duration, process_number):
    video_name = os.path.splitext(os.path.basename(video_path))[0]
    part_output_folder = os.path.join(output_folder, f"part_{process_number}")
    if not os.path.exists(part_output_folder):
        os.makedirs(part_output_folder)

    # Using 'ffmpeg' instead of 'ffmpeg.exe' for macOS compatibility
    ffmpeg_command = [
        'ffmpeg', '-ss', str(start_time), '-t', str(duration), '-i', video_path, '-vf', f'fps={fps}',
        os.path.join(part_output_folder, f'{video_name}_frame_%07d.png')
    ]

    print(f"Running FFmpeg command: {' '.join(ffmpeg_command)}")

    try:
        process = subprocess.run(ffmpeg_command, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
        if process.returncode != 0:
            print(f"Cannot process the file {video_path}: {process.stderr.decode('utf-8')}")
            return part_output_folder, 0
    except Exception as e:
        print(f"Failed to run FFmpeg command: {str(e)}")
        return part_output_folder, 0

    frame_count = len([f for f in os.listdir(part_output_folder) if f.endswith('.png')])
    return part_output_folder, frame_count

def worker_function(queue, video_path, output_folder, fps, start_time, duration, process_number):
    result = extract_frames(video_path, output_folder, fps, start_time, duration, process_number)
    queue.put(result)

def parallel_frame_extraction(video_path, output_folder, fps, num_processes):
    # Use 'ffprobe' instead of 'ffprobe.exe' for macOS compatibility
    ffprobe_command = [
        'ffprobe', '-v', 'error', '-select_streams', 'v:0', '-show_entries', 'format=duration', '-of',
        'default=noprint_wrappers=1:nokey=1', video_path
    ]

    try:
        result = subprocess.run(ffprobe_command, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
        duration = float(result.stdout.strip())
    except Exception as e:
        messagebox.showerror("Error", f"Failed to get video duration: {str(e)}")
        return

    chunk_duration = duration / num_processes
    processes = []
    manager = multiprocessing.Manager()
    queue = manager.Queue()

    if not os.path.exists(output_folder):
        os.makedirs(output_folder)

    for i in range(num_processes):
        start_time = i * chunk_duration
        p = multiprocessing.Process(target=worker_function,
                                    args=(queue, video_path, output_folder, fps, start_time, chunk_duration, i))
        p.start()
        processes.append(p)

    for p in processes:
        p.join()

    global_frame_offset = 0
    while not queue.empty():
        part_output_folder, frame_count = queue.get()
        frame_files = sorted([f for f in os.listdir(part_output_folder) if f.endswith('.png')])
        for i, frame_file in enumerate(frame_files):
            new_name = os.path.join(output_folder,
                                    f'{os.path.basename(video_path)}_frame_{global_frame_offset + i:07d}.png')
            os.rename(os.path.join(part_output_folder, frame_file), new_name)
        global_frame_offset += frame_count
        os.rmdir(part_output_folder)

    messagebox.showinfo("Complete",
                        f"Frame extraction completed for {video_path}. Total frames extracted: {global_frame_offset}")

def start_frame_extraction():
    video_path = filedialog.askopenfilename(filetypes=[("Video files", "*.mp4;*.avi;*.mkv")])
    if not video_path:
        return

    output_folder = output_folder_var.get()
    if not output_folder:
        return

    fps = int(fps_var.get())
    num_processes = int(num_processes_var.get())

    parallel_frame_extraction(video_path, output_folder, fps, num_processes)

if __name__ == "__main__":
    root = tk.Tk()
    root.title("Frame Extraction")

    output_folder_var = tk.StringVar()
    fps_var = tk.StringVar(value="1")
    num_processes_var = tk.StringVar(value="4")

    def browse_output_folder():
        folder_selected = filedialog.askdirectory()
        output_folder_var.set(folder_selected)

    tk.Label(root, text="Output Folder:").grid(row=0, column=0, padx=10, pady=10)
    tk.Entry(root, textvariable=output_folder_var, width=50).grid(row=0, column=1, padx=10, pady=10)
    tk.Button(root, text="Browse", command=browse_output_folder).grid(row=0, column=2, padx=10, pady=10)

    tk.Label(root, text="FPS:").grid(row=1, column=0, padx=10, pady=10)
    tk.Entry(root, textvariable=fps_var, width=10).grid(row=1, column=1, padx=10, pady=10)

    tk.Label(root, text="Number of Processes:").grid(row=2, column=0, padx=10, pady=10)
    tk.Entry(root, textvariable=num_processes_var, width=10).grid(row=2, column=1, padx=10, pady=10)

    tk.Button(root, text="Start Frame Extraction", command=start_frame_extraction).grid(row=3, column=0, columnspan=3,
                                                                                        padx=10, pady=20)

    root.mainloop()


  


  I tried changing the FFmpeg and FFmprobe path formats from

  


  ffmpeg_path = os.path.join(os.path.dirname(__file__), 'ffmpeg-7.0.1-essentials_build', 'bin', 'ffmpeg.exe')
ffprobe_path = os.path.join(os.path.dirname(__file__), 'ffmpeg-7.0.1-essentials_build', 'bin', 'ffprobe.exe')



  


  to

  


  ffmpeg_command = [
    'ffmpeg', '-ss', str(start_time), '-t', str(duration), '-i', video_path, '-vf', f'fps={fps}',
    os.path.join(part_output_folder, f'{video_name}_frame_%07d.png')
]

ffprobe_command = [
    'ffprobe', '-v', 'error', '-select_streams', 'v:0', '-show_entries', 'format=duration', '-of',
    'default=noprint_wrappers=1:nokey=1', video_path
]



  


  I found this online so im not sure if it is the correct thing to do.

  


  Thanks for any help.