I just don't agree with you.

I just don't understand your hesitation to just accept a same dimensioned PNG that replaces the one inside while rendering.
You are using the transparent frames stored in the BIN for overlaying too, because you don't have the needle, glass and light PNG's.

I've spent endless hours recreating BIN's (and making AIMP from it).

The background retrieval is a lot easier now because of BINextractor.

Really? People use VU meters and maybe want to put in another background, that's it. They are not developers, programmers or the like.

import binascii
import io
import lzma
import math
import subprocess
import sys

def decompress_lzma(compressed_path):
    with lzma.open(compressed_path, 'rb', format=lzma.FORMAT_ALONE) as f:
        file_content = f.read()
    return file_content

class HeaderNotSupported(Exception):
    pass

def unhexlify(bytedata):
    return binascii.unhexlify(bytedata)

def bytes2int(bytedata):
    return int.from_bytes(binascii.unhexlify(bytedata), byteorder=sys.byteorder)

def getint(bytedata):
    return int.from_bytes(bytedata, byteorder=sys.byteorder)

def read_bmp(file_path):
    content = None
    with open(file_path, 'rb') as f:
        content = f.read()
        content = binascii.hexlify(content)

    ID = unhexlify(content[:4]).decode('utf-8')
    SIZE = bytes2int(content[4:12])
    RESERVED = bytes2int(content[12:20])
    OFFSET = bytes2int(content[20:28])
    DIBHEADER = bytes2int(content[28:36])
    if DIBHEADER == 124:
        print('Header Type: BITMAPV5HEADER')
        WIDTH = bytes2int(content[36:44])
        HEIGHT = bytes2int(content[44:52])
        NBITSPERPIXEL = bytes2int(content[56:60])
        RAWIMGSIZE = bytes2int(content[68:76])
        PIXELARRAY = unhexlify(content[284:284 + RAWIMGSIZE])
    else:
        raise HeaderNotSupported('Header not supported')
    return OFFSET, RAWIMGSIZE, WIDTH, HEIGHT, NBITSPERPIXEL, PIXELARRAY

def rotate_top_down(width, height, pixel_data):
    row_size = width * 4
    rotated_data = bytearray()
    for row in range(height):
        start = row * row_size
        end = start + row_size
        rotated_data[0:0] = pixel_data[start:end]
    return rotated_data

def substitute_binary_bits(source_file, dest_file, dest_data, source_offset, dest_offset, width, height, bpp, length):
    try:
        with open(source_file, 'rb') as src:
            src.seek(source_offset)
            pixel_data = src.read(length)

        rotated_data = pixel_data  #rotate_top_down(width, height, pixel_data)

        dest = io.BytesIO(dest_data)
        dest.seek(4)
        dest_offset = 8 + getint(dest.read(2)) * math.floor(bpp / 8)
        dest.seek(7)
        zero = getint(dest.read(1))
        zero = bytearray([0xc0 | zero])  # 0x80 if rotated to top-down, 0xc0 if left bottom-up
        dest.seek(7)
        dest.write(zero)
        dest.seek(dest_offset)
        dest.write(rotated_data)

        with open(dest_file, 'wb') as file:
            file.write(dest.getvalue())

        print('Substitution completed successfully.')
    except Exception as e:
        print(f'An error occurred: {e}')

def main():
    compressed_bin = '7inch_3 X RR transparent.bin'
    source_file = 'test.bmp'
    dest_file = 'test.bin'

    command = ['magick.exe', 'L_0.png', 'test.bmp']
    subprocess.run(command, capture_output=False, text=True)
    source_offset, length, width, height, bpp, pixel_data = read_bmp(source_file)
    uncompressed_data = decompress_lzma(compressed_bin)
    substitute_binary_bits(source_file, dest_file, uncompressed_data, source_offset, 8 + 1024 * 4, width, height, bpp, length)

if __name__ == '__main__':
    main()

Figure 1. Left side replaced with transparent bottom-up bitmap. Right side unmodified. Using DUI.

problems found... 
(i used ratio 7.7 for toy encoding, somewhat near to 160kbps)
btw, when there aren't problems, toy is comparable to mp3, though encoding is much slower.

Included for example in the sample sets here: https://listening-test.coresv.net/index.htm. But I don't expect there to be any difference in behavior.