🥇WAVE మరియు JPEG ఫార్మాట్లలో మీడియా డేటాను కుదింపు/నిల్వ చేసే పద్ధతులు, భాగం 1

హలో! నా మొదటి కథనాలు చిత్రం/ఆడియో కంప్రెషన్ మరియు JPEG (చిత్రం) మరియు WAVE (ధ్వని) వంటి నిల్వ పద్ధతులను అధ్యయనం చేయడంపై దృష్టి పెడతాయి మరియు ఆచరణలో ఈ ఫార్మాట్‌లను (.jpg, .wav) ఉపయోగించే ప్రోగ్రామ్‌ల ఉదాహరణలను కూడా కలిగి ఉంటాయి. ఈ భాగంలో మనం WAVEని పరిశీలిస్తాము.

కథ

WAVE (వేవ్‌ఫార్మ్ ఆడియో ఫైల్ ఫార్మాట్) అనేది ఆడియో స్ట్రీమ్ యొక్క రికార్డింగ్‌ను నిల్వ చేయడానికి ఒక కంటైనర్ ఫైల్ ఫార్మాట్. ఈ కంటైనర్ సాధారణంగా కంప్రెస్ చేయని పల్స్ కోడ్ మాడ్యులేటెడ్ ఆడియోని నిల్వ చేయడానికి ఉపయోగించబడుతుంది. (వికీపీడియా నుండి తీసుకోబడింది)

ఇది మైక్రోసాఫ్ట్ మరియు IBM (ఆనాటి ప్రముఖ IT కంపెనీలు) ద్వారా RIFFతో కలిసి 1991లో కనుగొనబడింది మరియు ప్రచురించబడింది.

ఫైల్ నిర్మాణం

ఫైల్‌లో హెడర్ భాగం ఉంది, డేటా కూడా ఉంది, కానీ ఫుటరు లేదు. హెడర్ మొత్తం 44 బైట్‌ల బరువు ఉంటుంది.
హెడర్ నమూనాలోని బిట్‌ల సంఖ్య, నమూనా రేటు, ధ్వని లోతు మొదలైన వాటి కోసం సెట్టింగ్‌లను కలిగి ఉంటుంది. సౌండ్ కార్డ్ కోసం అవసరమైన సమాచారం. (అన్ని సంఖ్యా పట్టిక విలువలు లిటిల్-ఎండియన్ క్రమంలో వ్రాయబడాలి)

బ్లాక్ పేరు
బ్లాక్ పరిమాణం (B)
వివరణ/ప్రయోజనం
విలువ (కొందరికి ఇది స్థిరంగా ఉంటుంది

chunkId
4
ఫైల్‌ను మీడియా కంటైనర్‌గా నిర్వచించడం
బిగ్-ఎండియన్ (“RIFF”)లో 0x52494646

భాగం పరిమాణం
4
chunkId మరియు chunkSize లేకుండా మొత్తం ఫైల్ పరిమాణం
FILE_SIZE - 8

ఫార్మాట్
4
RIFF నుండి రకం నిర్వచనం
బిగ్-ఎండియన్ (“వేవ్”)లో 0x57415645

subchunk1Id
4
తద్వారా ఫైల్ ఫార్మాట్ యొక్క కొనసాగింపుగా ఎక్కువ స్థలాన్ని తీసుకుంటుంది
బిగ్-ఎండియన్‌లో 0x666d7420 (“fmt”)

ఉపభాగము1పరిమాణము
4
మిగిలిన హెడర్ (బైట్‌లలో)
16 డిఫాల్ట్‌గా (ఆడియో స్ట్రీమ్ కంప్రెషన్ లేని సందర్భంలో)

ఆడియో ఫార్మాట్
2
ఆడియో ఫార్మాట్ (కంప్రెషన్ పద్ధతి మరియు ఆడియో డేటా నిర్మాణంపై ఆధారపడి ఉంటుంది)
1 (PCM కోసం, మేము పరిశీలిస్తున్నది)

numChannels
2
ఛానెల్‌ల సంఖ్య
1/2, మేము 1 ఛానెల్‌ని తీసుకుంటాము (3/4/5/6/7... - ఒక నిర్దిష్ట ఆడియో ట్రాక్, ఉదాహరణకు 4 క్వాడ్ ఆడియో కోసం, మొదలైనవి)

నమూనా రేటు
4
ఆడియో నమూనా రేటు (హెర్ట్జ్‌లో)
ఎక్కువ, ధ్వని మెరుగ్గా ఉంటుంది, కానీ అదే పొడవుతో ఆడియో ట్రాక్‌ని సృష్టించడానికి ఎక్కువ మెమరీ అవసరం అవుతుంది, సిఫార్సు చేయబడిన విలువ 48000 (అత్యంత ఆమోదయోగ్యమైన ధ్వని నాణ్యత)

బైట్ రేటు
4
సెకనుకు బైట్‌ల సంఖ్య
నమూనా రేటు numChannels bitsPerSample (మరింత)

బ్లాక్అలైన్
2
1 నమూనా కోసం బైట్‌ల సంఖ్య
numChannels * bitsPerSample: 8

bitsPerSample
2
1 నమూనాకు బిట్‌ల సంఖ్య (లోతు)
8 యొక్క గుణకారం ఉన్న ఏదైనా సంఖ్య. ఎక్కువ సంఖ్య, 32 బిట్‌ల నుండి ఆడియో మెరుగ్గా మరియు బరువుగా ఉంటుంది;

subchunk2Id
4
డేటా రిఫరెన్స్ మార్క్ (ఆడియోఫార్మాట్‌పై ఆధారపడి ఇతర హెడర్ ఎలిమెంట్స్ ఉండవచ్చు కాబట్టి)
బిగ్-ఎండియన్‌లో 0x64617461("డేటా")

ఉపభాగము2పరిమాణము
4
డేటా ప్రాంతం పరిమాణం
Intలో డేటా పరిమాణం

సమాచారం
byteRate * ఆడియో వ్యవధి
ఆడియో డేటా
?

WAVE ఉదాహరణ

మునుపటి టేబుల్‌ని సులభంగా సిలో స్ట్రక్చర్‌లోకి అనువదించవచ్చు, కానీ ఈ రోజు మన భాష పైథాన్. మీరు చేయగలిగే సులభమైన పని “వేవ్” - శబ్దం జనరేటర్‌ని ఉపయోగించడం. ఈ పని కోసం మాకు అధిక బైట్‌రేట్ మరియు కుదింపు అవసరం లేదు.
ముందుగా, అవసరమైన మాడ్యూళ్లను దిగుమతి చేద్దాం:

# 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)  # записываем в файл результат

ఫలితం

కాబట్టి మీరు డిజిటల్ ధ్వని మరియు అది ఎలా నిల్వ చేయబడిందో గురించి కొంచెం ఎక్కువ నేర్చుకున్నారు. ఈ పోస్ట్‌లో మేము కంప్రెషన్ (ఆడియోఫార్మాట్) ఉపయోగించలేదు, కానీ జనాదరణ పొందిన వాటిలో ప్రతిదాన్ని పరిగణనలోకి తీసుకోవడానికి, మీరు మీ కోసం ఏదైనా క్రొత్తదాన్ని నేర్చుకున్నారని నేను ఆశిస్తున్నాను మరియు ఇది భవిష్యత్ పరిణామాలలో మీకు సహాయం చేస్తుంది.
ధన్యవాదాలు!