1
00:00:00,000 --> 00:00:09,500
>> [સંગીત વગાડવાનો]

2
00:00:09,500 --> 00:00:12,350
>> ZAMYLA ચાન: તે મિસ સ્કારલેટ હતી
કૅન્ડલસ્ટિક સાથે.

3
00:00:12,350 --> 00:00:13,560
ગૂઢ રહસ્યની અથવા ડિટેક્ટિવ વાર્તા કે નાટક?

4
00:00:13,560 --> 00:00:15,030
ઠીક છે, અમે શોધી રહ્યા છીએ.

5
00:00:15,030 --> 00:00:20,870
બોર્ડ રમત સંકેત, તમે કદાચ
ભૌતિક લાલ છબી આપવામાં.

6
00:00:20,870 --> 00:00:24,120
અને તે ખૂબ જ લાલ અને છબી છે
સ્પોટી, અને તમારી નોકરી છે

7
00:00:24,120 --> 00:00:25,490
ગુપ્ત સંદેશો પ્રદર્શિત કરે છે.

8
00:00:25,490 --> 00:00:29,740
અને સામાન્ય રીતે તમે એક લાલ સાથે પૂરી પાડવામાં આવેલ કરી રહ્યાં છો
બૃહદદર્શક કાચ, અથવા એક લાલ સ્ક્રીન

9
00:00:29,740 --> 00:00:31,410
કે છુપાયેલા સંદેશ પ્રદર્શિત કરે છે.

10
00:00:31,410 --> 00:00:33,340
ઠીક છે, અમે તે નકલ રહ્યા છીએ.

11
00:00:33,340 --> 00:00:37,960
>> ગૂઢ રહસ્યની અથવા ડિટેક્ટિવ વાર્તા કે નાટક, તમે એક બીટમેપ છબી આપવામાં રહ્યા છો
કે, ખૂબ જ સ્પોટી અને લાલ દેખાય છે

12
00:00:37,960 --> 00:00:43,430
અને પછી ગૂઢ રહસ્યની અથવા ડિટેક્ટિવ વાર્તા કે નાટક કાર્યક્રમ ચલાવો
એક છુપાયેલા સંદેશ પ્રદર્શિત કરે છે.

13
00:00:43,430 --> 00:00:45,650
>> તેથી આપણે પગલાં આ ભંગ કરીએ.

14
00:00:45,650 --> 00:00:50,390
પ્રથમ, તમે ફાઈલ ખોલવા માંગો છો -
તમે આપવામાં આવી છે કે ચાવી.

15
00:00:50,390 --> 00:00:53,880
અને પછી પણ બનાવવો
ચુકાદો બીટમેપ ફાઇલ.

16
00:00:53,880 --> 00:00:58,240
પછી તમે બીટમેપ અપડેટ કરવા માંગો છો
ચુકાદો outfile માટે માહિતી હેડર.

17
00:00:58,240 --> 00:00:59,920
પાછળથી તે પર વધુ.

18
00:00:59,920 --> 00:01:04,319
અને પછી તમે વંચાય રહ્યા છીએ
ચાવી, scanline, પિક્સેલ દ્વારા પિક્સેલ,

19
00:01:04,319 --> 00:01:07,320
તરીકે પિક્સેલ રંગ બદલીને
જરૂરી છે, અને લેખન

20
00:01:07,320 --> 00:01:08,960
ચુકાદો માં તે -

21
00:01:08,960 --> 00:01:12,000
આ માં પિક્સેલ દ્વારા પિક્સેલ
ચુકાદો scanline.

22
00:01:12,000 --> 00:01:13,780
>> આપણે કઈ રીતે આ વિશે જવાનું શરૂ કરી શકું?

23
00:01:13,780 --> 00:01:16,940
વેલ, સદભાગ્યે, અમે copy.c છે
વિતરણ કોડ.

24
00:01:16,940 --> 00:01:21,240
અને આ સાબિત રહ્યું છે
અમારા માટે ખૂબ ઉપયોગી છે.

25
00:01:21,240 --> 00:01:29,700
Copy.c, ફાઈલ ખોલે છે માં વાંચો
પછી infile હેડર અને સુધારાઓ

26
00:01:29,700 --> 00:01:31,070
outfile હેડર.

27
00:01:31,070 --> 00:01:37,010
અને પછી તે દરેક પિક્સેલ વાંચે
પછી scanline, પિક્સેલ દ્વારા પિક્સેલ, અને

28
00:01:37,010 --> 00:01:42,390
outfile માં કે પિક્સેલ લખે છે.

29
00:01:42,390 --> 00:01:45,020
>> તેથી, તમારું પ્રથમ પગલું કદાચ
નીચેની ચલાવવા માટે કરી

30
00:01:45,020 --> 00:01:46,420
ટર્મિનલમાં આદેશ -

31
00:01:46,420 --> 00:01:50,270
સી.પી. copy.c whodunit.c.

32
00:01:50,270 --> 00:01:55,320
આ એક નકલ બનાવવા માટે પડશે
copy.c whodunit.c નામ આપ્યું હતું.

33
00:01:55,320 --> 00:01:58,320
તેથી ખોલવા માટે અમારી પ્રથમ પગલું એ
ફાઇલ, સાથે સાથે, કોઈ ચોક્કસ છે

34
00:01:58,320 --> 00:02:00,070
copy.c. કે પ્રતિકૃતિ

35
00:02:00,070 --> 00:02:03,360
તેથી હું જોવા માટે તમે છોડી જાય છે.

36
00:02:03,360 --> 00:02:07,860
>> અમે આ pset સાથે છે કામ કરીએ છીએ શું
ફાઈલ I / O, મૂળભૂત રીતે ફાઈલો લઈ,

37
00:02:07,860 --> 00:02:10,229
, વાંચન, લેખન, તેમને ફેરફાર.

38
00:02:10,229 --> 00:02:12,650
તમે કેવી રીતે પ્રથમ ફાઇલ ખોલો છે?

39
00:02:12,650 --> 00:02:16,800
વેલ, તમે ફાઈલ જાહેર રહ્યા છીએ
નિર્દેશક છે, અને પછી તમે ફોન કરો

40
00:02:16,800 --> 00:02:18,670
કાર્ય fopen.

41
00:02:18,670 --> 00:02:23,150
પાથ, અથવા તે નામે પસાર
ફાઇલ અને પછી તમને જોઈતી સ્થિતિ

42
00:02:23,150 --> 00:02:24,700
સાઇન તે ફાઈલ ખોલવા માટે

43
00:02:24,700 --> 00:02:28,620
એક આર માં પસાર ખુલશે
વાંચન માટે foo.bmp.

44
00:02:28,620 --> 00:02:35,670
જ્યારે એક વાઇડ માં પસાર સાથે fopen કરશે
ઓપન bar.bmp, ફાઈલ લખવા માટે અને

45
00:02:35,670 --> 00:02:37,020
ખરેખર તે ફેરફાર.

46
00:02:37,020 --> 00:02:41,970
>> તેથી હવે અમે ફાઇલ ખોલી છે કે અમારા
આગળનું પગલું એ હેડર માહિતી અપડેટ કરવા માટે છે

47
00:02:41,970 --> 00:02:43,230
outfile માટે.

48
00:02:43,230 --> 00:02:44,610
કોઇ શીર્ષક માહિતી શું છે?

49
00:02:44,610 --> 00:02:48,160
વેલ, પ્રથમ અમે જાણવાની જરૂર છે
શું એક બીટમેપ છે.

50
00:02:48,160 --> 00:02:51,000
એક બીટમેપ માત્ર એક સરળ છે
બાઇટ્સ ગોઠવણી.

51
00:02:51,000 --> 00:02:55,480
અને તેઓ આ ફાઈલમાં જાહેર કરી રહ્યા છીએ
સમૂહ સાથે અહીં, bmp.h,

52
00:02:55,480 --> 00:02:58,610
શું એક બીટમેપ માહિતી
ખરેખર બહાર કરવામાં આવે છે.

53
00:02:58,610 --> 00:03:05,730
પરંતુ અમે ખરેખર કાળજી આ છે
બીટમેપ ફાઇલ હેડરમાં, અહીં છે, અને

54
00:03:05,730 --> 00:03:08,460
અહીં બીટમેપ માહિતી હેડર,.

55
00:03:08,460 --> 00:03:13,170
હેડર એક દંપતિ બનેલું હોય છે
ખૂબ જ ઉપયોગી સાબિત થશે કે ચલો.

56
00:03:13,170 --> 00:03:18,400
આ છે biSizeImage છે
બાઈટમાં ઈમેજના કુલ માપ.

57
00:03:18,400 --> 00:03:20,890
અને આ પિક્સેલ અને ગાદી સમાવેશ થાય છે.

58
00:03:20,890 --> 00:03:24,210
પૅડિંગ ખૂબ જ મહત્વપૂર્ણ છે, પરંતુ
અમે પછી તે માટે મળશે.

59
00:03:24,210 --> 00:03:30,000
>> BiWidth પાંચ પહોળાઇ રજૂ કરે છે
પિક્સેલ ઓછા પેડિંગ છબી.

60
00:03:30,000 --> 00:03:34,220
BiHeight પણ પછી ઊંચાઇ છે
પિક્સેલમાં ઈમેજના.

61
00:03:34,220 --> 00:03:38,240
અને પછી BITMAPFILEHEADER અને
મેં પહેલાં કહ્યું તેમ BITMAPINFOHEADER,

62
00:03:38,240 --> 00:03:40,900
અગાઉ, તે રજૂ થાય છે
સ્ટ્ર્ક્ટ્સ રિલીઝ.

63
00:03:40,900 --> 00:03:45,410
તેથી, તમે ફાઇલ હેડરમાં ઍક્સેસ કરી શકતા નથી
પોતે છે, પરંતુ તમે મેળવવા માંગો છો પડશે

64
00:03:45,410 --> 00:03:47,370
અંદર તે ચલો.

65
00:03:47,370 --> 00:03:48,170
>> બરાબર.

66
00:03:48,170 --> 00:03:50,600
તેથી અમે કેવી રીતે હેડર માહિતી સુધારી શકીશ?

67
00:03:50,600 --> 00:03:54,020
વેલ, પ્રથમ અમે જોવા માટે હોય છે કે શું અમે
કોઇ પણ માહિતી બદલવાની જરૂર

68
00:03:54,020 --> 00:03:58,480
આ માટે infile, ચાવી,
outfile, ચુકાદો.

69
00:03:58,480 --> 00:04:00,250
કંઈપણ આ કિસ્સામાં બદલાતી રહે છે?

70
00:04:00,250 --> 00:04:04,320
વેલ, વાસ્તવમાં, અમે જઈ રહ્યાં છો કારણ કે
માત્ર રંગ બદલીને છે.

71
00:04:04,320 --> 00:04:07,550
અમે ફાઇલ બદલવા નથી જઈ રહ્યાં છો
કદ, ઇમેજ માપ, પહોળાઈ,

72
00:04:07,550 --> 00:04:08,310
અથવા ઊંચાઇ.

73
00:04:08,310 --> 00:04:14,010
તેથી તમે હવે તમામ સાચા છો
માત્ર દરેક પિક્સેલ નકલ.

74
00:04:14,010 --> 00:04:14,840
>> બરાબર.

75
00:04:14,840 --> 00:04:20,720
તેથી હવે આપણે કેવી રીતે અમે ખરેખર જુઓ
ફાઇલ માંથી દરેક પિક્સેલ વાંચી શકે છે.

76
00:04:20,720 --> 00:04:23,640
બીજી ફાઇલ I / O નો કાર્ય
સક્રિય થવું પડશે -

77
00:04:23,640 --> 00:04:24,700
fread.

78
00:04:24,700 --> 00:04:28,440
તે સ્ટ્રક્ટ માટે નિર્દેશક લે
કે બાઇટ્સ સમાવે છે

79
00:04:28,440 --> 00:04:30,110
તમે વાંચી રહ્યા છો.

80
00:04:30,110 --> 00:04:31,890
તેથી તમે તે માં વાંચી રહ્યાં છો.

81
00:04:31,890 --> 00:04:36,090
અને પછી તમે, કે જે એક માપ પાસ
દરેક તત્વ માપ કે તમે

82
00:04:36,090 --> 00:04:37,360
વાંચી શકો છો.

83
00:04:37,360 --> 00:04:40,640
અહીં, કાર્ય sizeof
હાથમાં આવશે.

84
00:04:40,640 --> 00:04:45,570
પછી તમે નંબર પાસ જે
તત્વો સંખ્યા પ્રતિનિધિત્વ

85
00:04:45,570 --> 00:04:47,480
વાંચવા માટે માપ.

86
00:04:47,480 --> 00:04:51,180
અને પછી છેવટે, inptr, જે છે
તમે કે ફાઈલ નિર્દેશક

87
00:04:51,180 --> 00:04:52,530
વાંચી રહ્યું.

88
00:04:52,530 --> 00:04:58,650
તેથી તે બધા તત્વો અંદર છે
inptr અને તેઓ ડેટા રહ્યા છીએ.

89
00:04:58,650 --> 00:05:01,660
>> આપણે થોડી ઉદાહરણ જુઓ.

90
00:05:01,660 --> 00:05:07,590
હું માહિતી બે શ્વાન માં વાંચવા માંગો છો,
સાથે સાથે, હું તે બે રીતે એક કરી શકો છો.

91
00:05:07,590 --> 00:05:15,250
હું ક્યાં કદ બે વસ્તુઓ વાંચી શકે છે
મારા inptr થી કૂતરો, અથવા હું વાંચી શકે છે

92
00:05:15,250 --> 00:05:19,280
એક બે કૂતરાં માપ પદાર્થ.

93
00:05:19,280 --> 00:05:23,580
તેથી તમે જુઓ છો તે માર્ગ પર આધાર રાખીને
તમે, તમે કદ અને સંખ્યા વ્યવસ્થા કે

94
00:05:23,580 --> 00:05:25,840
બાઇટ્સ જ સંખ્યામાં વાંચી શકે છે.

95
00:05:25,840 --> 00:05:28,720

96
00:05:28,720 --> 00:05:33,020
>> તેથી હવે, ચાલો બદલવા દો
અમે જરૂર તરીકે પિક્સેલ રંગ.

97
00:05:33,020 --> 00:05:37,320
તમે ફરીથી bmp.h જોવા, પછી
તમે નીચે જોશો કે

98
00:05:37,320 --> 00:05:42,920
RGBTRIPLEs, અન્ય સ્ટ્રક્ટ જ્યાં
તેઓ ત્રણ બાઇટ્સ બનેલું છે.

99
00:05:42,920 --> 00:05:49,220
એક, rgbtBlue, rgbtGreen, અને rgbtRed.

100
00:05:49,220 --> 00:05:52,480
તેથી આ દરેક માત્રા છે
વાદળી, ગ્રીન રકમ, અને

101
00:05:52,480 --> 00:05:57,250
આ પિક્સેલ અંદર લાલ રકમ, જ્યાં
દરેક રકમ દ્વારા રજૂ થાય છે

102
00:05:57,250 --> 00:05:58,670
હેક્સાડેસિમલ નંબર.

103
00:05:58,670 --> 00:06:04,370
>> તેથી ff0000 વાદળી રંગ હશે,
તે વાદળી જાય છે, કારણ કે

104
00:06:04,370 --> 00:06:05,850
લાલ, લીલા છે.

105
00:06:05,850 --> 00:06:09,300
અને પછી બધા એફ માતાનો સફેદ હોય છે.

106
00:06:09,300 --> 00:06:13,440
માતાનો smiley.bmp પર એક નજર, નાખો જે
તમે તમારા વિતરણ કોડ છે.

107
00:06:13,440 --> 00:06:15,690
તમે માત્ર એક છબી માં તેને ખોલવા જો
દર્શક, તો પછી તમે પડશે

108
00:06:15,690 --> 00:06:17,080
માત્ર લાલ હસતો જુઓ.

109
00:06:17,080 --> 00:06:20,380
પરંતુ અમે પડશે, એક ઊંડા ડાઈવ લેવા
જુઓ કે માળખું

110
00:06:20,380 --> 00:06:22,340
તે માત્ર પિક્સેલ્સ છે.

111
00:06:22,340 --> 00:06:25,880
અમે સફેદ પિક્સેલ હોય છે,
અને પછી લાલ પિક્સેલ્સ.

112
00:06:25,880 --> 00:06:31,000
આ તમામ પછી આ, વ્હાઇટ ffffff, અને
હું તમારા માટે રંગના છે લાલ પિક્સેલ્સ

113
00:06:31,000 --> 00:06:35,440
અહીં, અને તમે તેઓ 0000ff છો જુઓ.

114
00:06:35,440 --> 00:06:39,760
ઝીરો વાદળી, શૂન્ય લીલો, અને સંપૂર્ણ લાલ.

115
00:06:39,760 --> 00:06:45,350
અને હસતો આઠ પિક્સેલ્સ વિશાળ છે, કારણ કે
અમે કોઈ પેડિંગ નથી.

116
00:06:45,350 --> 00:06:47,360
અધિકાર છે.

117
00:06:47,360 --> 00:06:53,310
>> હું અલગ અલગ કિંમતો સોંપી હતી તેથી જો
એક RGBTRIPLE માટે અને હું માગતા હતા

118
00:06:53,310 --> 00:06:58,350
તે લીલા કરે છે, તો પછી હું શું કરશે
હું નામ આપવામાં એક RGBTRIPLE જાહેર કરશે

119
00:06:58,350 --> 00:07:02,660
ત્રણ અને પછી દરેક પ્રવેશ કરવા માટે
કે સ્ટ્રક્ટ હું અંદર બાઇટ

120
00:07:02,660 --> 00:07:04,030
કોઈ ઓપરેટર ઉપયોગ કરશે.

121
00:07:04,030 --> 00:07:08,430
તેથી triple.rgbtBlue, હું કરી શકો છો
0 થી કે સોંપો.

122
00:07:08,430 --> 00:07:13,460
લીલા હું સંપૂર્ણ માટે સોંપી શકો છો - કોઈપણ
નંબર, ખરેખર, 0 અને એફએફ વચ્ચે.

123
00:07:13,460 --> 00:07:15,470
અને પછી લાલ, હું પણ 0 કહેવા જાઉં છું.

124
00:07:15,470 --> 00:07:19,160
તેથી પછી તે મને એક લીલા પિક્સેલ આપે છે.

125
00:07:19,160 --> 00:07:23,030
>> આગળ, હું ચેક કરો શું માંગો છો
કંઈક ની કિંમત?

126
00:07:23,030 --> 00:07:27,250
હું ચકાસે છે કે કંઈક કરી શકે છે
ત્રણ માતાનો rgbtBlue કિંમત છે કે શું

127
00:07:27,250 --> 00:07:31,080
એફએફ અને પછી પ્રિન્ટ, "હું લાગણી છું
વાદળી! "પરિણામે.

128
00:07:31,080 --> 00:07:35,640
હવે, તે જરૂરી અર્થ એ નથી
પિક્સેલ હક, વાદળી કે?

129
00:07:35,640 --> 00:07:40,060
પિક્સેલ લીલા અને લાલ કિંમતો કારણ કે
પણ બિન 0 કિંમતો કરી શકે છે.

130
00:07:40,060 --> 00:07:43,470
આ અર્થ એ થાય કે બધા, અને તે
આ છે માટે ચકાસે છે

131
00:07:43,470 --> 00:07:45,610
સંપૂર્ણ વાદળી રંગ માટે.

132
00:07:45,610 --> 00:07:50,050
પરંતુ બધા પિક્સેલ્સ પણ આંશિક કરી શકે છે
આ જેમ રંગ મૂલ્યો,

133
00:07:50,050 --> 00:07:52,180
અહીં આગામી ઉદાહરણ છે.

134
00:07:52,180 --> 00:07:55,400
>> તે થોડો કઠિન જોવા માટે છે
આ ચિત્રનો છે.

135
00:07:55,400 --> 00:08:00,320
આ થોડો વધુ પાંચ જેવો દેખાય છે
તમને આપવામાં આવશે કે clue.bmp.

136
00:08:00,320 --> 00:08:03,600
હવે, શારીરિક, તમે આ ઉકેલવા શકે છે,
દ્વારા, લાલ ઘણો છે, કારણ કે

137
00:08:03,600 --> 00:08:07,040
છબીમાં લાલ સ્ક્રીન હોલ્ડિંગ જેથી
અન્ય રંગો દેખાય શકે છે.

138
00:08:07,040 --> 00:08:10,968
તેથી અમે કેવી રીતે સી સાથે આ નકલ છે?

139
00:08:10,968 --> 00:08:15,640
વેલ, અમે બધા Red દૂર કરી શકે છે
છબી સંપૂર્ણપણે.

140
00:08:15,640 --> 00:08:21,870
અને તેથી અમે દરેક સેટ છો તે કરવા માટે
0 થી પિક્સેલ લાલ મૂલ્ય.

141
00:08:21,870 --> 00:08:25,020
અને તેથી છબી થોડી લાગશે
અમે લાંબા લાલ હોય છે આ જેવા બીટ

142
00:08:25,020 --> 00:08:26,300
બિલકુલ.

143
00:08:26,300 --> 00:08:29,390
>> અમે છુપાયેલા સંદેશ જોઈ શકો છો
થોડો વધુ સ્પષ્ટ રીતે હવે.

144
00:08:29,390 --> 00:08:31,730
અન્ય હસતો ચહેરો છે.

145
00:08:31,730 --> 00:08:33,870
અથવા કદાચ અમે અન્ય પદ્ધતિ ઉપયોગ કરી શકે છે.

146
00:08:33,870 --> 00:08:36,480
કદાચ, આપણે ઓળખી શકે
લાલ પિક્સેલ્સ તમામ -

147
00:08:36,480 --> 00:08:41,100
કે, પિક્સેલ બધા સાથે છે
0 વાદળી, 0 લીલો, અને લાલ 0 -

148
00:08:41,100 --> 00:08:43,169
અને સફેદ તે બદલો.

149
00:08:43,169 --> 00:08:45,470
અને અમારા છબી દેખાય છે,
આ કંઈક.

150
00:08:45,470 --> 00:08:48,250
જોવા માટે થોડો સરળ.

151
00:08:48,250 --> 00:08:51,170
>> બહાર પાડે છે અન્ય ઘણી બધી રીતો છે
ગુપ્ત સંદેશ સાથે સાથે,

152
00:08:51,170 --> 00:08:53,730
રંગ મેનીપ્યુલેશન સાથે વ્યવહાર.

153
00:08:53,730 --> 00:08:57,050
કદાચ તમે એક પદ્ધતિ વાપરો શકે
હું ઉપર ઉલ્લેખ કર્યો છે.

154
00:08:57,050 --> 00:08:59,600
અને વધુમાં, તમે છો
કેટલાક રંગો વધારે છે

155
00:08:59,600 --> 00:09:02,620
અને તે બહાર લાવે છે.

156
00:09:02,620 --> 00:09:06,190
>> તેથી હવે અમે પિક્સેલ બદલ્યું છે કે
રંગ, આગળ આપણે ફક્ત તેને લખવા માટે જરૂર

157
00:09:06,190 --> 00:09:08,500
પિક્સેલ દ્વારા scanline માટે, પિક્સેલ.

158
00:09:08,500 --> 00:09:11,860
અને હજુ સુધી ફરીથી, તમે પાછા જોવા માંગો છો પડશે
તમે નકલ કરેલ હોય, તો, copy.c માટે

159
00:09:11,860 --> 00:09:18,170
તે પહેલેથી જ, અને fwrite જુઓ
માહિતી લે છે, જે કાર્ય, એક નિર્દેશક

160
00:09:18,170 --> 00:09:23,230
બાઇટ્સ સમાવે છે સ્ટ્રક્ટ માટે
તમે માપ, માંથી વાંચવા રહ્યાં છો

161
00:09:23,230 --> 00:09:26,610
આ વસ્તુઓ, વસ્તુઓની સંખ્યા,
અને પછી outptr -

162
00:09:26,610 --> 00:09:29,450
તે ફાઈલો અંતિમ મુકામ.

163
00:09:29,450 --> 00:09:34,010
>> તમે પિક્સેલમાં લખો પછી, તો તમે
પણ ગાદી માં લખી છે.

164
00:09:34,010 --> 00:09:34,970
ગાદી શું છે?

165
00:09:34,970 --> 00:09:38,670
વેલ, દરેક rgbt પિક્સેલ
ત્રણ બાઇટ્સ લાંબી છે.

166
00:09:38,670 --> 00:09:43,670
પરંતુ, એક બીટમેપ છબી માટે scanline
ચાર બાઇટ્સ એક બહુવિધ પ્રયત્ન છે.

167
00:09:43,670 --> 00:09:47,650
અને પિક્સેલોની સંખ્યા ન હોય તો એક
ચાર ઘણી, તો પછી અમે ઉમેરવાની જરૂર છે

168
00:09:47,650 --> 00:09:48,880
આ ગાદી.

169
00:09:48,880 --> 00:09:51,420
પૅડિંગ માત્ર 0s પ્રતિનિધિત્વ કરતી હતી.

170
00:09:51,420 --> 00:09:54,380
તેથી, અમે કેવી રીતે લખો, અથવા આ વાંચી છે?

171
00:09:54,380 --> 00:09:59,280
વેલ, તે તારણ તમે કરી શકતા નથી કે
ખરેખર fread ગાદી, પરંતુ તમે કરી શકો છો

172
00:09:59,280 --> 00:10:00,970
તે ગણતરી.

173
00:10:00,970 --> 00:10:04,400
>> આ કિસ્સામાં, ચાવી અને ચુકાદો
એ જ પહોળાઈ હોય છે, જેથી

174
00:10:04,400 --> 00:10:05,910
ગાદી જ છે.

175
00:10:05,910 --> 00:10:09,370
અને ગાદી, તમે જોશો
copy.c માં, ગણવામાં આવે છે

176
00:10:09,370 --> 00:10:11,790
નીચે સૂત્ર સાથે -

177
00:10:11,790 --> 00:10:16,690
bi.biWidth વખત sizeof (RGBTRIPLE) કરશે
કેટલા બાઇટ્સ પાંચ BMP અમને આપો

178
00:10:16,690 --> 00:10:18,280
દરેક પંક્તિ છે.

179
00:10:18,280 --> 00:10:21,890
ત્યાંથી, modulos અને subtractions
4 ગણતરી કરી શકે છે સાથે કેવી રીતે

180
00:10:21,890 --> 00:10:25,610
ઘણા બાઇટ્સ ઉમેરાવી જ જોઈએ કે જેથી
પર બાઇટ્સ બહુવિધ

181
00:10:25,610 --> 00:10:27,250
દરેક પંક્તિ ચાર છે.

182
00:10:27,250 --> 00:10:30,490
>> હવે અમે માટે સૂત્ર છે કે
અમે જરૂર કેટલી પેડિંગ, હવે

183
00:10:30,490 --> 00:10:31,610
અમે તેને લખી શકો છો.

184
00:10:31,610 --> 00:10:34,080
હવે, હું પહેલાં ઉલ્લેખ કર્યો છે,
ગાદી માત્ર 0s છે.

185
00:10:34,080 --> 00:10:39,730
તેથી તે કિસ્સામાં, અમે ફક્ત આપી રહ્યા છીએ
આ કિસ્સામાં એક 0 ચાર રચે છે, અમારા

186
00:10:39,730 --> 00:10:41,710
outptr - અમારા outfile.

187
00:10:41,710 --> 00:10:47,530
જેથી માત્ર fputc બની શકે છે
0, અલ્પવિરામ outptr.

188
00:10:47,530 --> 00:10:52,400
>> તેથી, અમે માં કરવામાં વાંચન કર્યું છે, જ્યારે અમારી
ફાઈલ, ફાઈલ I / O નો સાચવી રાખવામાં આવી છે અમારા

189
00:10:52,400 --> 00:10:57,440
કંઈક સાથે તે ફાઇલોમાં સ્થિતિ
ફાઈલ સ્થિતિ સૂચક છે.

190
00:10:57,440 --> 00:10:59,350
કર્સર તરીકે તે વિચારો.

191
00:10:59,350 --> 00:11:03,550
મૂળભૂત રીતે, તે દર વખતે એડવાન્સિસ
અમે fread, પરંતુ અમે કે જે

192
00:11:03,550 --> 00:11:05,671
પણ, તેની પર નિયંત્રણ કરે છે.

193
00:11:05,671 --> 00:11:11,030
>> ફાઈલ સ્થિતિ સૂચક ખસેડવા માટે,
તમે કાર્ય fseek ઉપયોગ કરી શકો છો.

194
00:11:11,030 --> 00:11:15,600
પાંચ inptr ફાઈલ રજૂ કરે છે
તમે માગી રહ્યા છો તે નિર્દેશક છે,

195
00:11:15,600 --> 00:11:20,370
જથ્થો બાઇટ્સ સંખ્યા છે કે જે તમે
પછી કર્સરને ખસેડવા માટે, અને છો

196
00:11:20,370 --> 00:11:23,470
સંદર્ભ બિંદુ સાથે સંબંધિત છે
તમારા જ્યાં કર્સર છે.

197
00:11:23,470 --> 00:11:26,770
તમે SEEK_CUR પાસ, કે જે
વર્તમાન રજૂ

198
00:11:26,770 --> 00:11:28,100
ફાઈલમાં સ્થાન.

199
00:11:28,100 --> 00:11:31,020
અથવા તમે અમુક અન્ય પરિમાણો ઉપયોગ કરી શકો છો.

200
00:11:31,020 --> 00:11:35,400
તેથી, અમે અવગણો fseek ઉપયોગ કરવા માંગો છો
આ માં ફાઈલની ગાદી પર.

201
00:11:35,400 --> 00:11:39,410
તમે અટવાઇ કરી રહ્યાં છો અને ફરી,, છે
copy.c. કે એક ઉદાહરણ

202
00:11:39,410 --> 00:11:43,260
>> તેથી હવે અમે ફાઇલ ખોલી છે,
આ ચાવી, અને ચુકાદો.

203
00:11:43,260 --> 00:11:46,450
અમે માટે હેડર માહિતી અપડેટ કરી
અમારા ચુકાદો, કારણ કે દરેક

204
00:11:46,450 --> 00:11:48,730
બીટમેપ કોઇ શીર્ષક જરૂર છે.

205
00:11:48,730 --> 00:11:52,280
અમે પછી ચાવી ના દાયકામાં વાંચ્યા છે
scanline, પિક્સેલ દ્વારા પિક્સેલ, બદલાતી

206
00:11:52,280 --> 00:11:55,210
દરેક રંગ જરૂરી છે, અને
આ માં તે લખવાનું

207
00:11:55,210 --> 00:11:57,340
ચુકાદો, પિક્સેલ દ્વારા પિક્સેલ.

208
00:11:57,340 --> 00:12:01,550
તમે ચુકાદો ખોલવા જાય, તમે જોઈ શકો છો જે
ગુનેગાર, અથવા શું ગુપ્ત

209
00:12:01,550 --> 00:12:02,850
સંદેશ છે.

210
00:12:02,850 --> 00:12:05,550
મારું નામ Zamyla છે, અને
આ ગૂઢ રહસ્યની અથવા ડિટેક્ટિવ વાર્તા કે નાટક હતી.

211
00:12:05,550 --> 00:12:12,864