Replace FFmpeg with lameenc in audio/recorder.py for MP3 Encoding

[drankush]

Description:

We are currently using FFmpeg in the convert_wav_to_encrypted_mp3 function (located in audio/recorder.py) to convert .wav files to .mp3. However, FFmpeg is licensed under the GPLv3, which imposes restrictions on our project's licensing if we distribute it with FFmpeg included. To avoid these restrictions, we propose replacing FFmpeg with lameenc, a Python wrapper around the LAME MP3 encoder, which is licensed under the LGPL and MIT licenses.

This issue outlines the proposed changes, their benefits, and the licensing ramifications.

---

Current Implementation:

The current implementation uses FFmpeg via subprocess calls to encode .wav files into .mp3 format. The relevant code snippet is as follows:

command = [
    "ffmpeg",
    "-y",
    "-i", wav_path,
    "-vn",  # Disable video recording
    "-ar", "44100",  # Set audio sample rate
    "-ac", "1",  # Set number of audio channels
    "-b:a", f"{bitrate}k",  # Set audio bitrate
    "-f", "mp3",
    mp3_path,
]
subprocess.run(command, stdout=subprocess.PIPE, stderr=subprocess.PIPE, check=True)

This approach works well but requires FFmpeg to be installed on the system or bundled with the application, which introduces GPLv3 licensing concerns.

---

Proposed Solution:

We propose replacing FFmpeg with lameenc, a Python library that provides a pure Python interface to the LAME MP3 encoder. The updated implementation avoids subprocess calls and directly encodes .wav files into .mp3 using the following steps:

1. Use the wave module to extract raw PCM data from the .wav file.
2. Use lameenc to encode the PCM data into MP3 format.
3. Dynamically adjust the bitrate to ensure the resulting MP3 file size is less than 25 MB.

The updated code snippet is as follows:

encoder = lameenc.Encoder()
encoder.set_bit_rate(bitrate)  # Set bitrate (e.g., 128 kbps)
encoder.set_in_sample_rate(frame_rate)
encoder.set_channels(num_channels)
encoder.set_quality(2)  # Quality range: 0 (best) to 9 (worst)

mp3_data = encoder.encode(pcm_data)
mp3_data += encoder.flush()

This approach eliminates the need for FFmpeg entirely.

---

Benefits of Using lameenc:

1. Avoids GPLv3 Licensing Restrictions:

   • lameenc is licensed under the LGPL (for the LAME encoder) and MIT (for the Python wrapper), which are more permissive than GPLv3. This allows us to users to use it in both open-source and proprietary projects without requiring them to open-source entire codebase.

2. No External Dependencies:

   • Unlike FFmpeg, which must be pre-installed or bundled, lameenc can be installed via pip and works out of the box.

3. Pure Python Integration:

   • The integration is seamless and avoids subprocess calls, making the code easier to maintain and debug.

4. Dynamic Bitrate Adjustment:

   • The updated implementation includes logic to dynamically reduce the bitrate until the MP3 file size is below 25 MB, ensuring compliance with size constraints.

---

Licensing Ramifications:

1. Current Licensing with FFmpeg:

   • FFmpeg is licensed under the GPLv3, which requires any project distributing FFmpeg (or linking to it) to also be licensed under GPLv3 or a compatible license. This poses a problem for proprietary or closed-source projects.

2. Proposed Licensing with lameenc:

   • The LAME encoder itself is licensed under the LGPL, which allows dynamic linking without imposing copyleft requirements on the entire project.
   • The lameenc Python wrapper is licensed under the MIT License, which is permissive and imposes no additional restrictions.
   • As a result, switching to lameenc removes the GPLv3 dependency and allows us to retain our project's current licensing model (whether open-source or proprietary).

---

Action Items:

1. Update audio/recorder.py:

   • Replace the FFmpeg-based implementation with the lameenc-based implementation.
   • Ensure the new implementation includes dynamic bitrate adjustment to keep the MP3 file size below 25 MB.

2. Test the Updated Code:

   • Verify that the new implementation produces valid MP3 files and meets the file size constraint.
   • Test edge cases, such as very large .wav files or low bitrates.

3. Update Documentation:

   • Update the README and any relevant documentation to reflect the change from FFmpeg to lameenc.

4. Remove FFmpeg Dependency:

   • Remove any FFmpeg-related code, including the get_ffmpeg_path function and subprocess calls.

---

Additional Notes:

• If future requirements involve supporting additional audio formats or advanced features, we may need to explore alternative libraries like PyAV or pydub with non-FFmpeg backends.
• The switch to lameenc is limited to MP3 encoding. If other formats are needed, further investigation will be required.

---

References:

• lameenc Documentation: https://pypi.org/project/lameenc/
• LAME Encoder Licensing: https://lame.sourceforge.io/license.txt
• FFmpeg Licensing: https://ffmpeg.org/legal.html