Theory
ચિત્ર memory માં ક્યાં વસે છે
Raster display સેકન્ડમાં અનેક વાર memory માંથી ચિત્ર વાંચીને refresh કરે છે. એ memory એટલે frame buffer (અથવા refresh buffer): એ જગ્યા જ્યાં દરેક pixel નો રંગ સચવાય છે.
તમે raster screen પર જ્યારે કશું 'દોરો' છો, ત્યારે ખરેખર તો તમે frame buffer માં pixel ની કિંમતો લખો છો, અને display નું hardware buffer માં જે હોય એને તમે જુઓ છો એ ચિત્રમાં ફેરવી આપે છે. આ પાઠ frame buffer શું છે, bit depth રંગોની સંખ્યા કઈ રીતે નક્કી કરે છે, અને એનું કદ કાઢવાનું સાદું સૂત્ર સમજાવે છે. તમારા drawing code અને પડદા પરના pixels વચ્ચેનો પુલ આ જ છે.
Theory
એક buffer, દરેક pixel દીઠ એક કિંમત
Frame buffer માં દરેક pixel દીઠ એક રંગની કિંમત સચવાય છે. Screen નો દરેક pixel આ memory માંની એક જગ્યા સાથે મળતો આવે છે, એટલે pixel (x, y) ને કોઈ રંગ આપવો એટલે buffer માંની એની સામેની જગ્યાએ એ રંગ સંઘરવો.
એક pixel કેટલા રંગ ધારણ કરી શકે એ એની bit depth, એટલે કે દરેક pixel દીઠ bits ની સંખ્યા, પર આધાર રાખે છે: 1 bit માં 2 કિંમતો સચવાય (monochrome, કાળો કે સફેદ), 8 bits માં 256 રંગ, અને 24 bits માં લગભગ 1 કરોડ 60 લાખ રંગ (એને true colour કહે છે, જે વાસ્તવિક લાગતાં ચિત્રો માટે પૂરતા છે). Pixel દીઠ વધુ bits એટલે વધુ શક્ય રંગ, પણ સાથે વધુ memory પણ. Display આ buffer ને refresh માટે સતત વાંચ્યા કરે છે, અને એટલે જ તમે જે ચિત્ર જુઓ છો એ બરાબર એ જ હોય છે જે frame buffer માં ભરેલું છે.
Formula
Frame buffer નું કદ = pixels ગુણ્યા pixel દીઠ bits
Frame buffer ને કેટલી memory જોઈએ એ ગણવું સહેલું છે: કદ = pixels ની સંખ્યા x દરેક pixel દીઠ bits (પછી એને bytes માં ફેરવો).
640 x 480 વાળી screen લો. એટલે 640 x 480 = 307200 pixels. દરેક pixel દીઠ 8 bits (એટલે કે 1 byte) હોય તો buffer 307200 x 1 = 307200 bytes = 300 KB થાય. દરેક pixel દીઠ 24 bits (એટલે કે 3 bytes) હોય તો એ 307200 x 3 = 921600 bytes, એટલે લગભગ 0.88 MB થાય. એટલે ઊંચી resolution અને ઊંચી bit depth, બંને frame buffer નું કદ વધારે છે, અને એ જ કારણે વધુ સમૃદ્ધ ચિત્રોને વધુ memory જોઈએ છે. આ ગણતરી પરીક્ષામાં વારંવાર પુછાય છે, એટલે એને બરાબર બેસાડી દો.
Quiz
એક display 640 x 480 pixels નું છે અને દરેક pixel દીઠ 8 bits (1 byte) વાપરે છે. એનું frame buffer કેટલું મોટું છે?
- લગભગ 1120 bytes (640 + 480)
- 307200 bytes (લગભગ 300 KB): 640 x 480 = 307200 pixels, અને દરેકના 1 byte લેખે
- લગભગ 30 bytes
- 8 bytes, દરેક bit દીઠ એક
Show the answer
307200 bytes (લગભગ 300 KB): 640 x 480 = 307200 pixels, અને દરેકના 1 byte લેખે
Frame buffer નું કદ = pixels ની સંખ્યા x દરેક pixel દીઠ bytes. Pixels ની સંખ્યા 640 x 480 = 307200 છે, અને દરેક pixel દીઠ 8 bits (1 byte) લેખે એ 307200 x 1 = 307200 bytes થાય, એટલે કે 300 KB (307200 / 1024). વિકલ્પ A માપને ગુણવાને બદલે ખોટી રીતે સરવાળો કરે છે (640 + 480); screen માં પહોળાઈ ગુણ્યા ઊંચાઈ જેટલા pixels હોય, પહોળાઈ વત્તા ઊંચાઈ જેટલા નહીં. વિકલ્પ C અને D બહુ જ નાના છે અને આંકડાનો ખોટો ઉપયોગ કરે છે. રીત આ છે: pixels ની સંખ્યા માટે પહોળાઈને ઊંચાઈથી ગુણો, પછી દરેક pixel દીઠ bytes થી ગુણો; અહીં 640 x 480 x 1 = 307200 bytes = 300 KB.
Think first
વધુ bit depth એટલે વધુ memory કેમ, અને એનાથી ફરક પડે છે ખરો?
8-bit થી 24-bit રંગ પર જવાથી frame buffer ત્રણ ગણું કેમ થઈ જાય છે, અને એ સોદો ક્યારે ફાયદાનો છે? વિચારીને પછી tap કરો.
Show the answer
કારણ કે frame buffer દરેક pixel માટે એક રંગની કિંમત સાચવે છે, અને bit depth એટલે એ દરેક કિંમત કેટલા bits રોકે છે. એટલે pixel દીઠ bits ત્રણ ગણા કરવાથી આખું buffer ત્રણ ગણું થઈ જાય છે, કારણ કે એ વધારો બધા pixels પર ગુણાય છે.
Pixel દીઠ 8 bits હોય ત્યારે 640x480 વાળી screen ના 307200 pixels માંથી દરેક 1 byte વાપરે છે, એટલે કુલ 300 KB. Pixel દીઠ 24 bits (3 bytes) હોય ત્યારે દરેક pixel ત્રણ ગણું વાપરે છે, એટલે buffer 921600 bytes, એટલે લગભગ 0.88 MB થાય, બરાબર ત્રણ ગણું.
એ વધારાના bits થી તમે જે ખરીદો છો તે છે રંગોનો વ્યાપ: 8 bits માં ફક્ત 256 જુદા રંગ મળે, જે સાદા graphics માટે ઠીક છે પણ સુંવાળા gradients માં પટ્ટા દેખાવા લાગે છે અને એનાથી વાસ્તવિક તસવીર રજૂ કરી શકાતી નથી. બીજી બાજુ 24 bits માં લગભગ 1 કરોડ 60 લાખ રંગ મળે છે (true colour), જે સુંવાળા અને કુદરતી રંગછટાવાળી તસવીરો માટે પૂરતા છે.
એટલે સોદો છે memory સામે રંગની ચોકસાઈ. ઇતિહાસમાં જ્યારે memory ઓછી અને મોંઘી હતી ત્યારે frame buffer નાનું રાખવા નીચી bit depth સામાન્ય હતી, અને ઓછા bits માંથી વધુ રંગ દેખાડવા માટે colour palettes જેવી ચતુર યુક્તિઓ વપરાતી. Memory સસ્તી થતાં 24-bit (અને એથી ઊંચી) depth પ્રમાણભૂત બની ગઈ, કારણ કે વાસ્તવિક લાગતાં displays માટે વધુ સમૃદ્ધ રંગ એ થોડા વધારાના bytes ને લાયક છે.
એ જ તર્ક RESOLUTION સાથે પણ લાગુ પડે છે: વધુ pixels પણ buffer ને એટલા જ ગુણાકારે વધારે છે. એટલે designers ઉપલબ્ધ memory અને bandwidth સામે resolution તથા bit depth નું સંતુલન ગોઠવે છે, અને જોઈતાં ચિત્રો માટે બંનેમાંથી પૂરતું લે છે, memory વેડફ્યા વગર. Pixel દીઠ વધુ bits એટલે વધુ રંગ, અને એટલે વધુ memory: સીધો ગુણાકારવાળો સોદો.
Summary
Key takeaways
- Frame buffer (refresh buffer) એ memory છે જે દરેક pixel નો રંગ સાચવે છે; display એને વાંચીને screen refresh કરે છે.
- દરેક pixel buffer માંની એક જગ્યા સાથે મળતો આવે છે; દોરવું એટલે એમાં pixel ની કિંમતો લખવી.
- Bit depth (દરેક pixel દીઠ bits) રંગોની સંખ્યા નક્કી કરે છે: 1 bit = 2, 8 bits = 256, 24 bits = લગભગ 1 કરોડ 60 લાખ (true colour).
- Frame buffer નું કદ = pixels ની સંખ્યા x દરેક pixel દીઠ bits (પછી bytes માં ફેરવેલું).
- દાખલો: 640 x 480 = 307200 pixels; 8 bits લેખે 300 KB; 24 bits લેખે લગભગ 0.88 MB.
- ઊંચી resolution અને ઊંચી bit depth, બંને frame buffer ની memory ની જરૂરિયાત વધારે છે.
- યાદ રાખવાની કડી: frame buffer એટલે દરેક pixel દીઠ એક રંગની કિંમત; કદ = pixels ગુણ્યા pixel દીઠ bits.