WAVE, JPEG ഫോർമാറ്റുകളിൽ മീഡിയ ഡാറ്റ കംപ്രസ്സുചെയ്യുന്ന/സംഭരിക്കുന്നതിനുള്ള രീതികൾ, ഭാഗം 1

ഹലോ! എന്റെ ആദ്യ ലേഖന പരമ്പരകൾ ഇമേജ്/ഓഡിയോ കംപ്രഷൻ, JPEG (ഇമേജ്), WAVE (ശബ്‌ദം) പോലുള്ള സ്റ്റോറേജ് രീതികൾ പഠിക്കുന്നതിൽ ശ്രദ്ധ കേന്ദ്രീകരിക്കും, കൂടാതെ പ്രായോഗികമായി ഈ ഫോർമാറ്റുകൾ (.jpg, .wav) ഉപയോഗിക്കുന്ന പ്രോഗ്രാമുകളുടെ ഉദാഹരണങ്ങളും ഉൾപ്പെടുത്തും. ഈ ഭാഗത്ത് നമ്മൾ WAVE നോക്കും.

കഥ

ഒരു ഓഡിയോ സ്ട്രീമിന്റെ റെക്കോർഡിംഗ് സംഭരിക്കുന്നതിനുള്ള ഒരു കണ്ടെയ്നർ ഫയൽ ഫോർമാറ്റാണ് WAVE (Waveform Audio File Format). കംപ്രസ് ചെയ്യാത്ത പൾസ് കോഡ് മോഡുലേറ്റ് ചെയ്ത ഓഡിയോ സംഭരിക്കാനാണ് ഈ കണ്ടെയ്‌നർ സാധാരണയായി ഉപയോഗിക്കുന്നത്. (വിക്കിപീഡിയയിൽ നിന്ന് എടുത്തത്)

മൈക്രോസോഫ്റ്റും ഐബിഎമ്മും (അക്കാലത്തെ പ്രമുഖ ഐടി കമ്പനികൾ) RIFF-നൊപ്പം 1991-ൽ ഇത് കണ്ടുപിടിക്കുകയും പ്രസിദ്ധീകരിക്കുകയും ചെയ്തു.

ഫയൽ ഘടന

ഫയലിന് ഒരു ഹെഡർ ഭാഗമുണ്ട്, ഡാറ്റ തന്നെ, പക്ഷേ അടിക്കുറിപ്പില്ല. തലക്കെട്ടിന് ആകെ 44 ബൈറ്റുകൾ ഭാരമുണ്ട്.
സാമ്പിളിലെ ബിറ്റുകളുടെ എണ്ണം, സാമ്പിൾ നിരക്ക്, ശബ്‌ദ ഡെപ്ത് മുതലായവയ്ക്കുള്ള ക്രമീകരണങ്ങൾ ഹെഡറിൽ അടങ്ങിയിരിക്കുന്നു. സൗണ്ട് കാർഡിന് ആവശ്യമായ വിവരങ്ങൾ. (എല്ലാ സംഖ്യാ പട്ടിക മൂല്യങ്ങളും ലിറ്റിൽ-എൻഡിയൻ ക്രമത്തിൽ എഴുതണം)

ബ്ലോക്ക് പേര്
ബ്ലോക്ക് വലിപ്പം (B)
വിവരണം/ഉദ്ദേശ്യം
മൂല്യം (ചിലർക്ക് ഇത് നിശ്ചയിച്ചിരിക്കുന്നു

ചങ്ക് ഐഡി
4
ഒരു ഫയലിനെ മീഡിയ കണ്ടെയ്‌നറായി നിർവചിക്കുന്നു
ബിഗ്-എൻഡിയനിൽ ("RIFF") 0x52494646

ചങ്ക് വലിപ്പം
4
chunkId കൂടാതെ chunkSize ഇല്ലാതെ മുഴുവൻ ഫയലിന്റെയും വലുപ്പം
FILE_SIZE - 8

ഫോർമാറ്റ്
4
RIFF-ൽ നിന്ന് തരം നിർവചനം
ബിഗ്-എൻഡിയനിൽ 0x57415645 (“WAVE”)

ഉപചങ്ക്1ഐഡി
4
അതിനാൽ ഫോർമാറ്റിന്റെ തുടർച്ചയായി ഫയൽ കൂടുതൽ ഇടം എടുക്കുന്നു
ബിഗ്-എൻഡിയനിൽ ("fmt") 0x666d7420

ഉപഭാഗം1 വലിപ്പം
4
ശേഷിക്കുന്ന തലക്കെട്ട് (ബൈറ്റുകളിൽ)
16 ഡിഫോൾട്ടായി (ഓഡിയോ സ്ട്രീം കംപ്രഷൻ ഇല്ലാത്ത കേസിൽ)

ഓഡിയോ ഫോർമാറ്റ്
2
ഓഡിയോ ഫോർമാറ്റ് (കംപ്രഷൻ രീതിയെയും ഓഡിയോ ഡാറ്റ ഘടനയെയും ആശ്രയിച്ചിരിക്കുന്നു)
1 (പി‌സി‌എമ്മിനായി, അതാണ് ഞങ്ങൾ പരിഗണിക്കുന്നത്)

numChannels
2
ചാനലുകളുടെ എണ്ണം
1/2, ഞങ്ങൾ 1 ചാനൽ എടുക്കും (3/4/5/6/7... - ഒരു നിർദ്ദിഷ്‌ട ഓഡിയോ ട്രാക്ക്, ഉദാഹരണത്തിന് 4 ക്വാഡ് സൗണ്ട് മുതലായവ)

മാതൃകാ നിരക്ക്
4
ഓഡിയോ സാമ്പിൾ നിരക്ക് (ഹെർട്ട്സിൽ)
ഉയർന്നത്, ശബ്‌ദം മികച്ചതായിരിക്കും, എന്നാൽ അതേ ദൈർഘ്യമുള്ള ഒരു ഓഡിയോ ട്രാക്ക് സൃഷ്‌ടിക്കുന്നതിന് കൂടുതൽ മെമ്മറി ആവശ്യമായി വരും, ശുപാർശ ചെയ്യുന്ന മൂല്യം 48000 ആണ് (ഏറ്റവും സ്വീകാര്യമായ ശബ്‌ദ നിലവാരം)

ബൈറ്റ് റേറ്റ്
4
സെക്കൻഡിൽ ബൈറ്റുകളുടെ എണ്ണം
മാതൃകാ നിരക്ക് numChannels bitsPerSample (കൂടുതൽ)

ബ്ലോക്ക്അലൈൻ
2
ഒരു സാമ്പിളിനുള്ള ബൈറ്റുകളുടെ എണ്ണം
numChannels * bitsPerSample: 8

ബിറ്റ്സ്പെർസാമ്പിൾ
2
ഒരു സാമ്പിളിലെ ബിറ്റുകളുടെ എണ്ണം (ആഴം)
8 ന്റെ ഗുണിതമായ ഏത് സംഖ്യയും. ഉയർന്ന സംഖ്യ, മികച്ചതും ഭാരമുള്ളതുമായ ഓഡിയോ ആയിരിക്കും; 32 ബിറ്റുകളിൽ നിന്ന് മനുഷ്യർക്ക് വ്യത്യാസമില്ല

ഉപചങ്ക്2ഐഡി
4
ഡാറ്റ റഫറൻസ് മാർക്ക് (ഓഡിയോ ഫോർമാറ്റിനെ ആശ്രയിച്ച് മറ്റ് തലക്കെട്ട് ഘടകങ്ങൾ ഉണ്ടാകാമെന്നതിനാൽ)
ബിഗ്-എൻഡിയനിൽ ("ഡാറ്റ") 0x64617461

ഉപഭാഗം2 വലിപ്പം
4
ഡാറ്റ ഏരിയ വലിപ്പം
int ലെ ഡാറ്റയുടെ വലുപ്പം

ഡാറ്റ
byteRate * ഓഡിയോ ദൈർഘ്യം
ഓഡിയോ ഡാറ്റ
?

വേവ് ഉദാഹരണം

മുമ്പത്തെ പട്ടിക സിയിലെ ഒരു ഘടനയിലേക്ക് എളുപ്പത്തിൽ വിവർത്തനം ചെയ്യാൻ കഴിയും, എന്നാൽ ഇന്നത്തെ നമ്മുടെ ഭാഷ പൈത്തൺ ആണ്. നിങ്ങൾക്ക് ചെയ്യാൻ കഴിയുന്ന ഏറ്റവും എളുപ്പമുള്ള കാര്യം ഒരു "തരംഗം" ഉപയോഗിക്കുക എന്നതാണ് - ഒരു ശബ്ദ ജനറേറ്റർ. ഈ ടാസ്ക്കിന് ഞങ്ങൾക്ക് ഉയർന്ന ബൈറ്റ്റേറ്റും കംപ്രഷനും ആവശ്യമില്ല.
ആദ്യം, നമുക്ക് ആവശ്യമായ മൊഡ്യൂളുകൾ ഇറക്കുമതി ചെയ്യാം:

# WAV.py

from struct import pack  # перевод py-объектов в базовые типы из C
from os import urandom  # функция для чтения /dev/urandom, для windows:
# from random import randint
# urandom = lambda sz: bytes([randint(0, 255) for _ in range(sz)])  # лямбда под windows, т.к. urandom'а в винде нет
from sys import argv, exit  # аргументы к проге и выход

if len(argv) != 3:  # +1 имя скрипта (-1, если будете замораживать)
    print('Usage: python3 WAV.py [num of samples] [output]')
    exit(1)

അടുത്തതായി, അവയുടെ വലുപ്പത്തിനനുസരിച്ച് പട്ടികയിൽ നിന്ന് ആവശ്യമായ എല്ലാ വേരിയബിളുകളും ഞങ്ങൾ സൃഷ്ടിക്കേണ്ടതുണ്ട്. ഇതിലെ വേരിയബിൾ മൂല്യങ്ങൾ numSamples (സാമ്പിളുകളുടെ എണ്ണം) മാത്രം ആശ്രയിച്ചിരിക്കുന്നു. അവ കൂടുന്തോറും നമ്മുടെ ബഹളം നീളും.

numSamples = int(argv[1])
output_path = argv[2]

chunkId = b'RIFF'
Format = b'WAVE'
subchunk1ID = b'fmt '
subchunk1Size = b'x10x00x00x00'  # 0d16
audioFormat = b'x01x00'
numChannels = b'x02x00'  # 2-х каналов будет достаточно (стерео)
sampleRate = pack('<L', 1000)  # 1000 хватит, но если поставить больше, то шум будет слышен лучше. С 1000-ю он звучит, как ветер
bitsPerSample = b'x20x00'  # 0d32
byteRate = pack('<L', 1000 * 2 * 4)  # sampleRate * numChannels * bitsPerSample / 8  (32 bit sound)
blockAlign = b'x08x00'  # numChannels * BPS / 8
subchunk2ID = b'data'
subchunk2Size = pack('<L', numSamples * 2 * 4)  # * numChannels * BPS / 8
chunkSize = pack('<L', 36 + numSamples * 2 * 4)  # 36 + subchunk2Size

data = urandom(1000 * 2 * 4 * numSamples)  # сам шум

അവ ആവശ്യമുള്ള ക്രമത്തിൽ (പട്ടികയിലെന്നപോലെ) എഴുതുക മാത്രമാണ് അവശേഷിക്കുന്നത്:

with open(output_path, 'wb') as fh:
    fh.write(chunkId + chunkSize + Format + subchunk1ID +
            subchunk1Size + audioFormat + numChannels + 
            sampleRate + byteRate + blockAlign + bitsPerSample +
            subchunk2ID + subchunk2Size + data)  # записываем

അങ്ങനെ, തയ്യാറാണ്. സ്ക്രിപ്റ്റ് ഉപയോഗിക്കുന്നതിന്, ഞങ്ങൾ ആവശ്യമായ കമാൻഡ് ലൈൻ ആർഗ്യുമെന്റുകൾ ചേർക്കേണ്ടതുണ്ട്:
python3 WAV.py [num of samples] [output]
സാമ്പിളുകളുടെ എണ്ണം - എണ്ണം. സാമ്പിളുകൾ
output — ഔട്ട്പുട്ട് ഫയലിലേക്കുള്ള പാത

ശബ്‌ദമുള്ള ഒരു ടെസ്റ്റ് ഓഡിയോ ഫയലിലേക്കുള്ള ഒരു ലിങ്ക് ഇതാ, എന്നാൽ മെമ്മറി ലാഭിക്കാൻ ഞാൻ BPS 1b/s ആയി താഴ്ത്തി ചാനലുകളുടെ എണ്ണം 1 ആയി താഴ്ത്തി (32kbs-ൽ 64-ബിറ്റ് അൺ കംപ്രസ് ചെയ്യാത്ത സ്റ്റീരിയോ ഓഡിയോ സ്ട്രീം ഉപയോഗിച്ച്, അത് മാറി 80M ശുദ്ധമായ .wav ഫയൽ, കൂടാതെ 10 മാത്രം): https://instaud.io/3Dcy

മുഴുവൻ കോഡും (WAV.py) (കോഡിന് ധാരാളം ഡ്യൂപ്ലിക്കേറ്റ് വേരിയബിൾ മൂല്യങ്ങളുണ്ട്, ഇതൊരു സ്കെച്ച് മാത്രമാണ്):

from struct import pack  # перевод py-объектов в базовые типы из C
from os import urandom  # функция для чтения /dev/urandom, для windows:
# from random import randint
# urandom = lambda sz: bytes([randint(0, 255) for _ in range(sz)])  # лямбда под windows, т.к. urandom'а в винде нет
from sys import argv, exit  # аргументы к проге и выход

if len(argv) != 3:  # +1 имя скрипта (-1, если будете замораживать)
    print('Usage: python3 WAV.py [num of samples] [output]')
    exit(1)

numSamples = int(argv[1])
output_path = argv[2]

chunkId = b'RIFF'
Format = b'WAVE'
subchunk1ID = b'fmt '
subchunk1Size = b'x10x00x00x00'  # 0d16
audioFormat = b'x01x00'
numChannels = b'x02x00'  # 2-х каналов будет достаточно (стерео) 
sampleRate = pack('<L', 1000)  # 1000 хватит, но можно и больше.
bitsPerSample = b'x20x00'  # 0d32
byteRate = pack('<L', 1000 * 2 * 4)  # sampleRate * numChannels * bitsPerSample / 8  (32 bit sound)
blockAlign = b'x08x00'  # numChannels * BPS / 8
subchunk2ID = b'data'
subchunk2Size = pack('<L', numSamples * 2 * 4)  # * numChannels * BPS / 8
chunkSize = pack('<L', 36 + numSamples * 2 * 4)  # 36 + subchunk2Size

data = urandom(1000 * 2 * 4 * numSamples)  # сам шум

with open(output_path, 'wb') as fh:
    fh.write(chunkId + chunkSize + Format + subchunk1ID +
            subchunk1Size + audioFormat + numChannels + 
            sampleRate + byteRate + blockAlign + bitsPerSample +
            subchunk2ID + subchunk2Size + data)  # записываем в файл результат

ഫലം

അതിനാൽ ഡിജിറ്റൽ ശബ്ദത്തെക്കുറിച്ചും അത് എങ്ങനെ സംഭരിക്കുന്നു എന്നതിനെക്കുറിച്ചും നിങ്ങൾ കുറച്ചുകൂടി പഠിച്ചു. ഈ പോസ്റ്റിൽ ഞങ്ങൾ കംപ്രഷൻ (ഓഡിയോ ഫോർമാറ്റ്) ഉപയോഗിച്ചിട്ടില്ല, എന്നാൽ ജനപ്രിയമായ ഓരോന്നും പരിഗണിക്കുന്നതിന്, 10 ലേഖനങ്ങൾ ആവശ്യമാണ്. നിങ്ങൾ സ്വയം പുതിയ എന്തെങ്കിലും പഠിച്ചുവെന്നും ഇത് ഭാവിയിലെ സംഭവവികാസങ്ങളിൽ നിങ്ങളെ സഹായിക്കുമെന്നും ഞാൻ പ്രതീക്ഷിക്കുന്നു.
നന്ദി!

ഉറവിടങ്ങൾ

WAV ഫയൽ ഘടന
WAV - വിക്കിപീഡിയ

അവലംബം: www.habr.com