1
00:00:00,000 --> 00:00:00,996

2
00:00:00,996 --> 00:00:12,470
>> [સંગીત વગાડવાનો]

3
00:00:12,470 --> 00:00:13,210
>> રોબ બોડેન: હાય.

4
00:00:13,210 --> 00:00:16,870
હું રોબ છું અને દો કદ
આ સમસ્યા છે.

5
00:00:16,870 --> 00:00:20,990
તેથી અમે copy.c સાથે શરૂ રહ્યા છીએ
એક નમૂનો છે, પરંતુ અમે કરી રહ્યા છીએ

6
00:00:20,990 --> 00:00:23,340
ખૂબ થોડા ફેરફારો કર્યા.

7
00:00:23,340 --> 00:00:27,570
>> હવે અમે અમે તરત જ કરી રહ્યા છીએ જુઓ
અમે લાંબા સમય સુધી ચકાસણી કરી રહ્યા છીએ જ્યાં બદલી

8
00:00:27,570 --> 00:00:31,560
અમારા rxc હવે 3 સમાન નથી, પરંતુ માટે
અમે ચકાસણી કરી રહ્યા છીએ આરસી 4 સમાન નથી.

9
00:00:31,560 --> 00:00:34,670
અમે જેમાં સમાવેશ થાય છે કરવા માંગો છો
ફાઇલ અને બહાર ફાઈલો ઉપરાંત

10
00:00:34,670 --> 00:00:39,550
આ પ્રયત્ન રહ્યું છે જે દલીલો, F
અમે ખેંચે કરી રહ્યાં છે કે જેના દ્વારા પરિબળ.

11
00:00:39,550 --> 00:00:45,430
>> કેવી રીતે માની છો તેથી એક વખત, અમે કરવા માંગો છો
શબ્દમાળા કન્વર્ટ એ સ્કેન એફ વાપરો

12
00:00:45,430 --> 00:00:49,030
ફ્લોટ માટે argv1.

13
00:00:49,030 --> 00:00:51,330
અને અમે સ્ટોર રહ્યા છીએ
કે અવયવો.

14
00:00:51,330 --> 00:00:55,180
આ વધારાના પાત્ર ખાતરી બનાવે છે
અમે ખરેખર ન દાખલ કરવામાં આવે છે

15
00:00:55,180 --> 00:00:59,200
1.4 એબીસી કંઈક
આદેશ વાક્ય પર.

16
00:00:59,200 --> 00:01:02,960
>> હવે અમે કેટલીક ઉપનામો બનાવો રહ્યા છીએ
RV2 અને RV3 નથી કારણ કે

17
00:01:02,960 --> 00:01:04,310
ખૂબ જ ઉપયોગી નામો.

18
00:01:04,310 --> 00:01:07,660
અમે, ને બદલે, કહી રહ્યા છીએ
તેમને ફાઈલમાં અને ફાઈલ.

19
00:01:07,660 --> 00:01:11,580
હવે અમે તેની ખાતરી કરવા જઈ રહ્યાં છો
અમારા પરિબળ ખરેખર માન્ય હતું.

20
00:01:11,580 --> 00:01:16,330
તેથી પરિબળ કરતાં ઓછી અથવા સમાન છે
શૂન્ય અથવા વધારે 100 કરતા, તો પછી તરીકે દીઠ

21
00:01:16,330 --> 00:01:19,660
સ્પેક, અમે નકારવા જોઈએ
કે પરિબળ.

22
00:01:19,660 --> 00:01:23,890
>> અમે ખાતરી કરો છો તે હવે અમે કરી શકો છો, સારી છે
આ n એ ફાઇલ ખોલો, અને અમે બનાવવા માટે છે

23
00:01:23,890 --> 00:01:25,950
તે સફળતાપૂર્વક ખોલવામાં આવી હતી તેની ખાતરી કરો.

24
00:01:25,950 --> 00:01:28,630
જો તે નથી, કે નલ આપશે.

25
00:01:28,630 --> 00:01:30,390
અમે બહાર ફાઈલ ખોલવા જઈ રહ્યાં છો.

26
00:01:30,390 --> 00:01:33,420
અને ફરી, અમે ખાતરી કરવા માટે ચકાસણી કરવા માંગો છો
ખાતરી કરો કે તે સફળતાપૂર્વક ખોલવામાં છે.

27
00:01:33,420 --> 00:01:37,270
અને તે સફળતાપૂર્વક પછી, ઓપન નથી, તો
અમે બંધ કરવા માટે ખાતરી કરો કરવાની જરૂર છે

28
00:01:37,270 --> 00:01:40,870
આ n એ ફાઇલ કે જે મૂળ સફળતાપૂર્વક
ખોલી, અથવા અન્ય અમે એક

29
00:01:40,870 --> 00:01:42,600
મેમરી છિદ્ર.

30
00:01:42,600 --> 00:01:46,350
>> તેથી હવે અમે બીટમેપ વાંચી રહ્યા છીએ
ફાઈલ હેડર અને બીટમેપ માહિતી

31
00:01:46,350 --> 00:01:48,890
આ n એ ફાઇલમાંથી મથાળા.

32
00:01:48,890 --> 00:01:52,360
અમે ખાતરી કરો કે રહ્યા છીએ
n એ ફાઈલ માન્ય બીટમેપ હતી.

33
00:01:52,360 --> 00:01:52,640
બરાબર.

34
00:01:52,640 --> 00:01:55,100
>> તેથી હવે અમે શરૂ રહ્યા છીએ
કેટલાક ફેરફારો કર્યા.

35
00:01:55,100 --> 00:01:58,840
અમે બદલાતી કરી રહ્યા છીએ તેથી, કારણ કે
વસ્તુઓ, અમે પ્રથમ યાદ કરવા માંગો છો

36
00:01:58,840 --> 00:02:01,510
આ n એ ફાઈલની જૂની પહોળાઈ.

37
00:02:01,510 --> 00:02:05,160
અમે જૂના ગાદી યાદ કરવા માંગો છો
એ જ ગણતરી મદદથી n એ ફાઇલ

38
00:02:05,160 --> 00:02:06,990
copy.c. થી

39
00:02:06,990 --> 00:02:09,840
>> અને હવે અમે બદલી રહ્યા છીએ
બીટમેપ માહિતી હેડર.

40
00:02:09,840 --> 00:02:13,630
અને તેથી અમે પહોળાઇ બંને ગુણાકાર કરી રહ્યાં છો
અને કારણ કે પરિબળ દ્વારા ઊંચાઇ

41
00:02:13,630 --> 00:02:15,750
કે અમે દ્વારા માપન કરી રહ્યા છો શું છે.

42
00:02:15,750 --> 00:02:18,420
અમે નક્કી કરવા માટે જઈ રહ્યાં છો
ફાઈલ દ્વારા નવા ગાદી

43
00:02:18,420 --> 00:02:21,140
નવા પહોળાઈ મદદથી.

44
00:02:21,140 --> 00:02:27,330
અને અમે નવા નક્કી રહ્યા છીએ
સંખ્યા મદદથી છબી કદ

45
00:02:27,330 --> 00:02:31,610
રહ્યું છે એક પંક્તિ બાઇટ્સ
કે સળંગ પિક્સેલોની સંખ્યા કરી

46
00:02:31,610 --> 00:02:35,960
વખત એક પિક્સેલ માપ વત્તા
અંતે ગાદી બાઇટ્સ નંબર

47
00:02:35,960 --> 00:02:40,310
કે પંક્તિ, અને તે ગુણાકાર
અમે કે જે પંક્તિઓ સંખ્યા દ્વારા.

48
00:02:40,310 --> 00:02:43,800
જેથી બાઇટ્સ સંખ્યા છે
અમે અમારી છબી માહિતી માં છે.

49
00:02:43,800 --> 00:02:48,190
>> Bf.Bfsize હવે સંખ્યા પ્રયત્ન રહ્યું છે
અમારી છબી બીટા બાઇટ્સ વત્તા

50
00:02:48,190 --> 00:02:49,350
અમારા હેડરો માપ.

51
00:02:49,350 --> 00:02:53,910
બીટમેપ ફાઇલ હેડર તેથી પ્લસ માપ
અને બીટમેપ માહિતી હેડર માપ.

52
00:02:53,910 --> 00:02:54,510
બરાબર.

53
00:02:54,510 --> 00:02:56,440
જેથી અમારી હેડરો માટે છે.

54
00:02:56,440 --> 00:02:59,030
અમે ફાઇલ વડા લખી શકો છો અને
અમારા આઉટ માહિતી હેડર

55
00:02:59,030 --> 00:03:01,590
ફાઇલ, અને અમે સારા છીએ.

56
00:03:01,590 --> 00:03:03,800
>> હવે તે ખરેખર શરૂ સમય
પિક્સેલ લખી

57
00:03:03,800 --> 00:03:05,120
બહાર ફાઇલમાં માહિતી.

58
00:03:05,120 --> 00:03:10,460
અમે કદ એક બફર જાહેર રહ્યા છીએ
જૂના પહોળાઈ RGB triples, અને અમે છો

59
00:03:10,460 --> 00:03:13,790
કહેવાય ચલ જાહેર જાઉં
અમે જઈ રહ્યાં છો, કે જે પંક્તિ જડ,

60
00:03:13,790 --> 00:03:15,640
શરૂઆતમાં નકારાત્મક 1 બરાબર સુયોજિત કરો.

61
00:03:15,640 --> 00:03:19,090
અમે અમે ઉપયોગ કરી રહ્યા છીએ કે નહીં તે જોવા મળશે
કે શું સાચવી રાખવા માટે

62
00:03:19,090 --> 00:03:22,640
અમે હાલમાં મેળવી લીધી પંક્તિ
આ બફર માં.

63
00:03:22,640 --> 00:03:23,290
બરાબર.

64
00:03:23,290 --> 00:03:28,750
>> તેથી હવે, પ્રમાણભૂત આવૃત્તિ અલગ
બદલે ઓછામાં પર વારો

65
00:03:28,750 --> 00:03:32,900
ફાઇલ, અમે દરેક ઉપર ફરી વળવું રહ્યા છીએ
બહાર ફાઈલમાં પંક્તિ અને આકૃતિ

66
00:03:32,900 --> 00:03:38,130
અમે કરવા માંગો છો કે જે ફાઈલ માં જે પંક્તિ
બહાર ફાઇલમાં આ પંક્તિ મૂકો.

67
00:03:38,130 --> 00:03:44,930
તેથી બહાર તમામ પંક્તિઓ પર વારો
નવી ઊંચાઇ મદદથી ફાઇલ, અમે પ્રથમ છો

68
00:03:44,930 --> 00:03:48,890
જૂના માં પંક્તિ નક્કી રહ્યું
આપણે છો, જે ઉપયોગ જઈ રહ્યાં છો ફાઇલ

69
00:03:48,890 --> 00:03:53,560
આ વર્તમાન લઈને કરવા જાઉં
પંક્તિ પરિબળ દ્વારા વિ.

70
00:03:53,560 --> 00:03:58,000
જેથી અમને આ પંક્તિ આપી રહ્યું છે
અમે માંગો છો તે જૂના ફાઇલમાં.

71
00:03:58,000 --> 00:04:03,310
>> તેથી હવે જો પંક્તિ જડ સમાન નથી જૂના વાય છે,
અમે આ પંક્તિ વાંચી હોય રહ્યા છીએ

72
00:04:03,310 --> 00:04:05,940
આપણે શા માટે પંક્તિ બફર માં માંગો છો.

73
00:04:05,940 --> 00:04:07,700
તેથી અમે કેવી રીતે કે શું થઈ રહ્યું છે?

74
00:04:07,700 --> 00:04:11,650
પ્રથમ, અમે આકૃતિ રહ્યા છીએ
પાંચ કે પંક્તિ શરૂ થાય છે તે સ્થિતિમાં

75
00:04:11,650 --> 00:04:13,100
મૂળ ફાઇલ.

76
00:04:13,100 --> 00:04:18,630
તેથી તે સ્થિતિમાં પ્રયત્ન રહ્યું છે
અમારા હેડરો તમામ અને છેલ્લા

77
00:04:18,630 --> 00:04:21,589
હવે ભૂતકાળ જૂના વાય પંક્તિઓ.

78
00:04:21,589 --> 00:04:23,880
>> અને તેથી કેટલા બાઇટ્સ
એક પંક્તિ છે?

79
00:04:23,880 --> 00:04:28,740
ફરીથી, ત્રણ વખત RGB કદ જૂના
પહોળાઈ વત્તા જૂના ગાદી, તેથી કે છે

80
00:04:28,740 --> 00:04:30,640
એક પંક્તિ માં બાઇટ્સ સંખ્યા.

81
00:04:30,640 --> 00:04:33,680
અને અમે છેલ્લા જૂના વાય પંક્તિઓ અવગણો કરવા માંગો છો.

82
00:04:33,680 --> 00:04:37,580
તેથી અમે એફ લેવી રહ્યા છીએ અને અમે છો
આ જ શરૂ કરવાની સેટ લેવી મદદથી

83
00:04:37,580 --> 00:04:39,100
ફાઇલ કરે છે.

84
00:04:39,100 --> 00:04:42,740
અમે આ સ્થિતિમાં લેવી એફ રહ્યા છીએ
ફાઇલ માં, પર અમને મૂકે

85
00:04:42,740 --> 00:04:46,500
અમે માંગો છો આ પંક્તિ ની શરૂઆત
અમારા બફર માં વાંચવા માટે.

86
00:04:46,500 --> 00:04:48,510
>> અમે પંક્તિ સેટ રહ્યા છીએ
જૂના વાય સમાન જડ.

87
00:04:48,510 --> 00:04:53,080
તેથી હવે જો આપણે લૂપ પાછા અને અમે કરવા માંગો છો
અમારા બહાર ફાઇલમાં આ જ પંક્તિ વાપરવા માટે,

88
00:04:53,080 --> 00:04:55,970
પછી અમે વાંચી નથી જઈ રહ્યાં છો
તેને ફરીથી બિનજરૂરી.

89
00:04:55,970 --> 00:04:59,310
તેથી ખરેખર, પંક્તિ જડ છે
માત્ર એક ઓપ્ટિમાઇઝેશન.

90
00:04:59,310 --> 00:05:05,500
>> છેલ્લે, અમે વંચાય રહ્યા છીએ
વર્તમાન પંક્તિ જૂના પહોળાઈ RGB triples

91
00:05:05,500 --> 00:05:08,040
અમે મૂળ ફાઇલમાંથી માંગો છો.

92
00:05:08,040 --> 00:05:12,270
તેથી હવે શા હરોળમાંથી પિક્સેલ સમાવે
અમે કરવા માંગો છો તે મૂળ ફાઇલ

93
00:05:12,270 --> 00:05:14,200
બહાર ફાઈલમાં લખો.

94
00:05:14,200 --> 00:05:18,960
તેથી હવે, માત્ર ઉપર છે, તેના બદલે ના
જૂની ફાઈલ પર વારો, અમે જરૂર

95
00:05:18,960 --> 00:05:22,560
તે નવી ફાઈલો પંક્તિઓ પર ફરી વળવું છે.

96
00:05:22,560 --> 00:05:27,450
વેલ, અહીં બદલે પર વારો તમામ
જૂના પિક્સેલ્સ કે શા પંક્તિ,

97
00:05:27,450 --> 00:05:31,210
અમે બધા ફરી વળવું કરવા માંગો છો
આ અમારી નવી ફાઇલમાં પિક્સેલ

98
00:05:31,210 --> 00:05:32,480
ચોક્કસ પંક્તિ.

99
00:05:32,480 --> 00:05:34,140
>> અમે તે શા માટે કરવા માંગો છો?

100
00:05:34,140 --> 00:05:38,960
અમે અમે છો અહીં જુઓ કે કારણ
ખરેખર જરૂરી તમામ મદદથી

101
00:05:38,960 --> 00:05:41,020
મૂળ ફાઈલમાં પિક્સેલ્સ.

102
00:05:41,020 --> 00:05:46,630
અમે સંકોચાયા કરી રહ્યાં છો, અમે કદાચ કારણ કે
વાસ્તવમાં પિક્સેલ્સ અવગણો કરવા માંગો છો.

103
00:05:46,630 --> 00:05:48,090
અને અમે તે આ જુઓ -

104
00:05:48,090 --> 00:05:49,690
એક્સ ફેક્ટર દ્વારા વિ -

105
00:05:49,690 --> 00:05:55,620
અમે વાય કહે છે નજીકથી અહીં પ્રતિબિંબ
આકૃતિ પરિબળ દ્વારા વિ કે

106
00:05:55,620 --> 00:06:02,480
જૂના વાય મી પંક્તિ અનુલક્ષે
આ નવી ફાઈલ માં y-મી પંક્તિ.

107
00:06:02,480 --> 00:06:05,880
>> હવે અમે તમામ લખી રહ્યા છીએ
જૂના પંક્તિ આ પિક્સેલ્સ

108
00:06:05,880 --> 00:06:07,440
અમારી નવી પંક્તિ માં.

109
00:06:07,440 --> 00:06:10,890
અમે કે જે કર્યું છે, અમે કરવાની જરૂર છે માત્ર
અમારા પંક્તિ ઓવરને અંતે પેડિંગ મૂકી

110
00:06:10,890 --> 00:06:15,540
અને અમે પાછા લૂપ પડશે અને માટે ચાલુ
અમારી નવી ફાઇલમાં પંક્તિઓ તમામ.

111
00:06:15,540 --> 00:06:19,390
અંતે, અમે અમારા જૂના બંધ કરવાની જરૂર છે
, ફાઈલ અમારા નવા ફાઇલ બંધ કરો અને વળતર

112
00:06:19,390 --> 00:06:21,540
શૂન્ય બધું સારું થયું છે.

113
00:06:21,540 --> 00:06:24,220
>> મારું નામ રોબ છે અને આ ગોખલો હતો.

114
00:06:24,220 --> 00:06:29,184
>> [સંગીત વગાડવાનો]