Properly convert 24-bit audio to 32-bit

Author: Matthew Sills

pydub/audio_segment.py

@@ -6,12 +6,15 @@
 from tempfile import TemporaryFile, NamedTemporaryFile
 import wave
 import sys
+import struct
 from .logging_utils import log_conversion
 
 try:
     from StringIO import StringIO
 except:
-    from io import StringIO, BytesIO
+    from io import StringIO
+
+from io import BytesIO
 
 try:
     from itertools import izip
@@ -150,15 +153,24 @@ def __init__(self, data=None, *args, **kwargs):
         # Convert 24-bit audio to 32-bit audio.
         # (stdlib audioop and array modules do not support 24-bit data)
         if self.sample_width == 3:
-            # Pad each triplet of bytes with one more byte, either 0 or 0xFF.
-            padding = {False: b'\x00', True: b'\xFF'}
-            pad_byte = lambda b: bytes(b) + padding[b[-1] > b'\x7f'[0]]
+            byte_buffer = BytesIO()
+
+            # Workaround for python 2 vs python 3. _data in 2.x are length-1 strings,
+            # And in 3.x are ints.
+            pack_fmt = 'BBB' if isinstance(self._data[0], int) else 'ccc'
 
-            i = iter(self._data)
             # This conversion maintains the 24 bit values.  The values are
             # not scaled up to the 32 bit range.  Other conversions could be
             # implemented.
-            self._data = b''.join(pad_byte(t) for t in izip(i, i, i))
+            i = iter(self._data)
+            padding = {False: b'\x00', True: b'\xFF'}
+            for b0, b1, b2 in izip(i, i, i):
+                byte_buffer.write(padding[b2 > b'\x7f'[0]])
+                old_bytes = struct.pack(pack_fmt, b0, b1, b2)
+                byte_buffer.write(old_bytes)
+
+
+            self._data = byte_buffer.getvalue()
             self.sample_width = 4
             self.frame_width = self.channels * self.sample_width
 

test/test.py

@@ -3,6 +3,7 @@
 import os
 import unittest
 from tempfile import NamedTemporaryFile
+import struct
 
 from pydub import AudioSegment
 from pydub.utils import (
@@ -109,10 +110,17 @@ def test_direct_instantiation_with_bytes(self):
         self.assertEqual(seg.frame_rate, 32000)
 
     def test_24_bit_audio(self):
-        seg24 = AudioSegment._from_safe_wav(os.path.join(data_dir, 'test1-24bit.wav'))
+        path24 = os.path.join(data_dir, 'test1-24bit.wav')
+        seg24 = AudioSegment._from_safe_wav(path24)
+        # The data length lies at bytes 40-44
+        with open(path24, 'rb') as f:
+            raw24 = f.read()
+        len24 = struct.unpack("<L", raw24[40:44])[0]
 
         # should have been converted to 32 bit
         self.assertEqual(seg24.sample_width, 4)
+        # the data length should have grown by exactly 4:3 (24 bits turn into 32 bits)
+        self.assertEqual(len(seg24.raw_data) * 3, len24 * 4)
 
     def test_concat(self):
         catted_audio = self.seg1 + self.seg2