update

.streamlit/config.toml

@@ -0,0 +1,2 @@
+[server]
+maxUploadSize = 1000

app.py

@@ -22,7 +22,7 @@ def convert_audio(input_file):
 # Function to split audio into segments
 def split_audio(audio_file):
     segment_pattern = os.path.splitext(audio_file)[0] + ".segmented_%03d.wav"
-    ffmpeg.input(audio_file).output(segment_pattern, f="segment", segment_time=300).run()
+    ffmpeg.input(audio_file).output(segment_pattern, f="segment", segment_time=60).run()
     return segment_pattern
 
 # Function to filter each audio segment
@@ -48,41 +48,87 @@ def get_format_info(input_file):
     result = os.popen(f"ffprobe -v error -show_entries stream=codec_name -of default=noprint_wrappers=1:nokey=1 {input_file}").read()
     return result
 
+# Function to increase volume of audio with sox
+def increase_volume(input_file):
+    os.system(f"sox -v 1.5 {input_file} {input_file}.vol.wav")
+    os.rename(f"{input_file}.vol.wav", input_file)
+    return input_file
+
+def restore_metadata(input, output):
+    os.system(f"ffmpeg -y -i {input} -c copy -map_metadata 0 -f ffmetadata {input}.txt")
+    
+    lines = open(f"{input}.txt").readlines()
+
+    if len(lines) > 1:
+        lines = [lines[0],] + [line for line in lines if any(x in line for x in ("title", "artist", "album", "track", "date", "comment"))]
+        open(f"{input}.txt", "w").writelines(lines)
+        os.system(f"ffmpeg -y -i {output} -f ffmetadata -i {input}.txt -c copy -map_metadata 1 fixed.{output}")
+        os.rename(f"fixed.{output}", output)
+
+    os.remove(f"{input}.txt")
+    return output
+
+def override_metadata(output, title="", artist="", album=""):
+    lines = [";FFMETADATA1", f"title={title}", f"artist={artist}", f"album={album}"]
+    open(f"{output}.txt", "w").write("\n".join(lines) + "\n")
+
+    # strip existing metadata
+    os.system(f"ffmpeg -y -i {output} -map_metadata -1 -c:v copy -c:a copy temp.{output}")
+
+    # add new metadata
+    os.system(f"ffmpeg -y -i temp.{output} -f ffmetadata -i {output}.txt -c copy -map_metadata 1 {output}")
+
+    os.remove(f"temp.{output}")
+    os.remove(f"{output}.txt")
+    return output
+
+def get_samplerate(input_file):
+    result = os.popen(f"ffprobe -v error -show_entries stream=sample_rate -of default=noprint_wrappers=1:nokey=1 {input_file}").read()
+    return int(result.strip())
 
 # Function to handle video or audio input
-def process_input(input_file):
+def process_input(input_file, convert_to_mp3=False):
     try:
+        # extract audio from video and convert to wav
         audio_file = convert_audio(input_file)
+
+        # split audio into smaller segments
         segments = split_audio(audio_file)
+
+        # filter each segment
         filtered_dir = filter_audio(segments)
+
+        # combine filtered segments
         output_file = combine_segments(filtered_dir, f"{input_file}.filtered.wav")
-        shutil.rmtree(filtered_dir)
+        shutil.rmtree(filtered_dir) # delete temp directory
+
+        # increase volume
+        output_file = increase_volume(output_file)
         output_format = input_file.split(".")[-1]
 
-        if is_video(input_file):
+        if convert_to_mp3:
+            output_format = "mp3"
+
+        processed_file = f"filtered-{input_file}.{output_format}"
+
+        if output_format in ["mp4", "mkv", "webm", "avi", "mov", "flv", "wmv", "m4v"]:
             audio_aac_file = f"filtered-{input_file}.aac"
             ffmpeg.input(output_file).output(audio_aac_file, ar=44100, codec="aac").run()
 
             video_stream = ffmpeg.input(input_file).video
             audio_aac_stream = ffmpeg.input(audio_aac_file).audio
-            
-            merged_file = f"filtered-{input_file}.{output_format}"
-            ffmpeg.output(video_stream, audio_aac_stream, merged_file, vcodec="copy", acodec="copy").run()
-
+            ffmpeg.output(video_stream, audio_aac_stream, processed_file, vcodec="copy", acodec="copy").run()
             os.remove(audio_aac_file)
-            os.remove(output_file)
-            os.remove(audio_file)
-            os.rename(merged_file, input_file)
-
-            return input_file
         else:
-            ffmpeg.input(output_file).output(f"filtered-{input_file}.{output_format}", ac=1, ar=16000).run()
+            sample_rate = 16000 if convert_to_mp3 else get_samplerate(input_file) 
+            ffmpeg.input(output_file).output(processed_file, ac=1, ar=16000 if sample_rate < 16000 else sample_rate).run()
 
-            os.rename(f"filtered-{input_file}.{output_format}", input_file)
-            os.remove(output_file)
-            os.remove(audio_file)
+        os.remove(output_file)
+        os.remove(audio_file)
+
+        restore_metadata(input_file, processed_file)
+        return processed_file
 
-            return input_file
     except Exception as e:
         log_error(f"Error occurred during processing: {str(e)}")
         return None
@@ -97,6 +143,17 @@ if uploaded_file is not None:
         file_details = {"FileName": uploaded_file.name, "FileType": uploaded_file.type, "FileSize": uploaded_file.size}
         st.write(file_details)
 
+        convert_to_mp3 = st.toggle("Convert to MP3", False)
+        title = st.text_input("Title", "")
+        artist = st.text_input("Artist", "")
+        album = st.text_input("Album", "")
+
+        args = {
+            "title": title,
+            "artist": artist,
+            "album": album,
+        }
+
         if st.button("Process File"):
             # generate a random file name to save the uploaded file
             file_path = f"temp-{str(uuid.uuid4())[:8]}.{uploaded_file.name.split('.')[-1]}"
@@ -104,17 +161,25 @@ if uploaded_file is not None:
             with open(file_path, "wb") as f:
                 f.write(uploaded_file.getbuffer())
 
-            output_file_path = process_input(file_path)
+            output_file_path = process_input(file_path, convert_to_mp3=convert_to_mp3)
+
+            # Override metadata if any
+            if title or artist or album:
+                override_metadata(output_file_path, title=title, artist=artist, album=album)
 
             if output_file_path and os.path.exists(output_file_path):
                 data = open(output_file_path, "rb").read()
                 os.remove(file_path)
+                os.remove(output_file_path)
+
+                # uploaded file name without extension
+                download_name = "filtered-" + uploaded_file.name.split('.')[0] + "." + output_file_path.split(".")[-1]
 
                 st.success("File processed successfully!")
                 st.download_button(label="Download Processed File", 
                                     data=data,
-                                    file_name="filtered-" + uploaded_file.name)
+                                    file_name=download_name)
             else:
                 st.error("File processing failed.")
     except Exception as e:
-        log_error(f"Error occurred during file processing: {str(e)}")
+        log_error(f"Error occurred during file processing: {str(e)}")

packages.txt

@@ -1 +1,2 @@
+ffmpeg
 sox