1
00:00:00,000 --> 00:00:00,494

2
00:00:00,494 --> 00:00:13,350
>> [સંગીત વગાડવાનો]

3
00:00:13,350 --> 00:00:14,080
>> રોબ બોડેન: હાય.

4
00:00:14,080 --> 00:00:17,550
હું રોબ છું, અને દો આશા છે કે
આ ઉકેલ તમે મૂકી મદદ કરે છે

5
00:00:17,550 --> 00:00:19,600
વસૂલાત માટે રસ્તા પર.

6
00:00:19,600 --> 00:00:22,700
તેથી આપણે પ્રારંભ કરીએ.

7
00:00:22,700 --> 00:00:25,660
>> અમે તરત જ અમે છો જોઈ
માત્ર અમે છો તેની ખાતરી કરવા માટે

8
00:00:25,660 --> 00:00:27,170
યોગ્ય રીતે પુનઃપ્રાપ્ત મદદથી.

9
00:00:27,170 --> 00:00:31,490
તેથી વપરાશ કંઇક પ્રયત્ન કરીશું
કોઈ સ્લેશ વસૂલ છે.

10
00:00:31,490 --> 00:00:35,500
>> હવે અમે અપેક્ષા ખોલવા રહ્યા છીએ
કાર્ડ કાચા ફાઇલ DOT.

11
00:00:35,500 --> 00:00:39,740
અમે ઉપયોગ કરી રહ્યાં છો અહીં જુઓ કે આ
સતત કાચા નીચા ફાઇલ નામ,

12
00:00:39,740 --> 00:00:44,200
અમે હેશ છે અહીં જે
કાર્ડ કાચા ટપકું તરીકે વ્યાખ્યાયિત થયેલ છે.

13
00:00:44,200 --> 00:00:45,030
બરાબર.

14
00:00:45,030 --> 00:00:48,210
>> તેથી અમે ખાતરી કરો કે જરૂર છે
સફળતાપૂર્વક ખોલવામાં હા તે

15
00:00:48,210 --> 00:00:51,150
, તો પછી અમે વપરાશકર્તા ચેતવણી જોઈએ ન હતી.

16
00:00:51,150 --> 00:00:56,770
પરંતુ તે હતી કે એમ ધારી રહ્યા છીએ, આપણે હવે છો
કદ JPEG, એક બફર જાહેર જાઉં

17
00:00:56,770 --> 00:00:58,170
નામ લંબાઈ કરો.

18
00:00:58,170 --> 00:01:02,060
તેથી આ બફર કરી રહ્યું છે
અમે માં sprintf રહ્યા છીએ.

19
00:01:02,060 --> 00:01:04,360
>> તેથી JPEG ફાઈલ નામ લંબાઈ શું છે?

20
00:01:04,360 --> 00:01:08,490
અહીં સુધી, અમે તેને જુઓ કે
આઠ તરીકે વ્યાખ્યાયિત હેશ.

21
00:01:08,490 --> 00:01:10,670
તેથી શા માટે આઠ?

22
00:01:10,670 --> 00:01:15,150
વેલ આપેલ ફાઈલ નામ આપવામાં આવશે
શૂન્ય શૂન્ય શૂન્ય કંઈક.

23
00:01:15,150 --> 00:01:19,460
JPG અને પછી અમે એક બેકસ્લેશ શૂન્ય જરૂર છે.

24
00:01:19,460 --> 00:01:22,720
તેથી અમે તે કરી શકો છો એક બફર જરૂર
આઠ અક્ષરો સ્ટોર કરે છે.

25
00:01:22,720 --> 00:01:25,190
હવે અમે છે કે પ્રતિ હોય રહ્યા છીએ
આ સાચવી રાખે રહ્યું

26
00:01:25,190 --> 00:01:27,780
નંબર JPEGs અમે જોવા મળે છે.

27
00:01:27,780 --> 00:01:31,590
>> અને છેલ્લે, અમે હોય રહ્યા છીએ એક
શરૂઆતમાં નલ છે જે JPEG ફાઈલ

28
00:01:31,590 --> 00:01:35,920
હાલમાં કરી રહ્યું છે
અમે લખી રહ્યાં છે ફાઇલ ખોલો.

29
00:01:35,920 --> 00:01:37,540
હવે અમે હોય રહ્યા છીએ
વધારાની બફર.

30
00:01:37,540 --> 00:01:41,350
આ અમારા sprintf તરીકે જ નથી
આ બફર એક છે જ્યાં બફર

31
00:01:41,350 --> 00:01:45,020
અમે માહિતીમાં વાંચી રહ્યાં છો કે
કાર્ડ કાચા ડોટ છે.

32
00:01:45,020 --> 00:01:48,900
>> તેથી બફર કરી રહ્યું છે
સહી થયેલ નહિં અક્ષરો, જે તમે કરી શકો છો

33
00:01:48,900 --> 00:01:53,560
મૂળભૂત રીતે માત્ર અમને બાઇટ્સ સારવાર છે, અને તે છે
કદ બ્લોક કદના જ હશે

34
00:01:53,560 --> 00:01:57,950
જ્યાં, અમે તમને કહી છે,
બ્લોક માપ 512 છે.

35
00:01:57,950 --> 00:02:03,070
તેથી JPEGs તમે બધું સારવાર કરી શકે છે
512 બાઇટ્સ બ્લોકો રિલીઝ.

36
00:02:03,070 --> 00:02:05,890
>> હવે અમે લૂપ રહ્યા છીએ
આખી ફાઇલ પર.

37
00:02:05,890 --> 00:02:12,980
અમે એફ અમારા બફર માં વાંચી રહ્યા છીએ
એક બાઈટ બ્લોક માપ સમયથી

38
00:02:12,980 --> 00:02:14,710
કાર્ડ કાચા ફાઇલ DOT.

39
00:02:14,710 --> 00:02:16,630
હવે એફ પરત શું વાંચે છે?

40
00:02:16,630 --> 00:02:20,050
તે વસ્તુઓની સંખ્યા આપે છે
તે સફળતાપૂર્વક વાંચી.

41
00:02:20,050 --> 00:02:27,310
તે પછી, 512 બાઇટ્સ વાંચી વ્યવસ્થાપિત તેથી જો
અમે આ એક છે કે કેમ તે જોવા માટે કરવા માંગો છો

42
00:02:27,310 --> 00:02:29,700
JPEG, અથવા તે JPEG ફાઈલ પર લખો.

43
00:02:29,700 --> 00:02:34,450
અને તે 512 બાઇટ્સ પાછા ન હતી, તો
પછી ફાઇલ ક્યાં સમાપ્ત થયો છે

44
00:02:34,450 --> 00:02:37,870
અમે વાય તોડી પડશે જે કિસ્સામાં
લૂપ, અથવા ભૂલ અમુક પ્રકારની છે

45
00:02:37,870 --> 00:02:40,300
અમે બહાર ભંગ પડશે જે કિસ્સામાં
વાય લૂપ છે, પરંતુ અમે જાણ કરવા માંગો છો પડશે

46
00:02:40,300 --> 00:02:41,990
કે કંઈક ખોટું થયું હતું.

47
00:02:41,990 --> 00:02:42,290
>> બરાબર.

48
00:02:42,290 --> 00:02:47,630
તેથી અમે સફળતાપૂર્વક વાંચી એમ ધારી રહ્યા છીએ
512 બાઇટ્સ, અમે પ્રથમ તપાસ કરવા માંગો છો

49
00:02:47,630 --> 00:02:53,070
બનાવવા માટે કે આ બાઇટ્સ કે અમે
જસ્ટ વાંચી કોઈ JPEG શરૂ કરે છે.

50
00:02:53,070 --> 00:02:56,430
તેથી જો અમારી બફર JPEG, હેડર છે.

51
00:02:56,430 --> 00:02:58,460
હવે JPEG, હેડર તે શું કરી રહ્યો છે?

52
00:02:58,460 --> 00:03:00,120
માતાનો જુઓ.

53
00:03:00,120 --> 00:03:05,270
>> અહીં સુધી, અમે આ કાર્ય છે કે નહીં તે જોવા
બળદ ફર્યા, અને તે બળદ -

54
00:03:05,270 --> 00:03:08,820
અહીં પણ, અમે જોવા માટે ચકાસણી કરી રહ્યા છીએ જો
હેડર શૂન્ય આ સતત સમકક્ષ હોય છે અને

55
00:03:08,820 --> 00:03:11,880
હેડર એક આ સતત સમકક્ષ હોય છે અને
હેડર બે, આ સતત સમકક્ષ હોય છે

56
00:03:11,880 --> 00:03:15,640
હેડર ત્રણ આ કે આ જેટલી જ થાય છે
આ બધા સ્થિરાંકો છે જ્યાં સતત

57
00:03:15,640 --> 00:03:20,340
માત્ર અહીં વ્યાખ્યાયિત હેશ અને છે
અમે સ્પેક તમે કહ્યું બરાબર શું

58
00:03:20,340 --> 00:03:22,700
કોઈ JPEG સાથે શરૂ થાય છે.

59
00:03:22,700 --> 00:03:27,300
અને તેથી આ કાર્ય માત્ર રહ્યું છે
આ બફર રજૂ જો સાચું પરત

60
00:03:27,300 --> 00:03:31,750
નવી JPEG શરૂઆત
અને ખોટા અન્યથા.

61
00:03:31,750 --> 00:03:32,520
>> બરાબર.

62
00:03:32,520 --> 00:03:38,490
આ એક નવી JPEG રજૂ કરે છે તેથી જો,
પછી અમે પ્રથમ જોવા માટે ચકાસણી કરવા માંગો છો

63
00:03:38,490 --> 00:03:42,030
JPEG ફાઈલ, નલ સમાન નથી
જે કિસ્સામાં અમે તેને બંધ કરો.

64
00:03:42,030 --> 00:03:44,940
અને તેથી આપણે શા માટે તપાસ કરવાની જરૂર છે
તે નલ નથી તે જોવા? માટે

65
00:03:44,940 --> 00:03:48,980
વેલ પહેલીવાર JPEG, કે અમે
અમે પહેલાથી જ નથી શોધી

66
00:03:48,980 --> 00:03:50,440
એક ઓપન JPEG ફાઈલ.

67
00:03:50,440 --> 00:03:55,580
અને તેથી, અમે તે પછી, કે બંધ કરવા માટે પ્રયત્ન કરો
અમે તદ્દન યોગ્ય કંઈક કરી રહ્યા છીએ.

68
00:03:55,580 --> 00:03:59,090
>> પરંતુ દરેક અનુગામી JPEG, કે
અમે ખોલો, અમે બંધ કરવા માંગો છો

69
00:03:59,090 --> 00:04:00,710
પહેલાની ફાઈલની.

70
00:04:00,710 --> 00:04:04,630
તેથી હવે અમે અમે sprintf ઉપયોગ જઈ રહ્યાં છો
અમે ઉપયોગ કરી રહ્યાં છો જ્યાં પહેલાં જણાવ્યું હતું કે આ

71
00:04:04,630 --> 00:04:06,280
બફર JPEG ફાઈલ નામ.

72
00:04:06,280 --> 00:04:09,870
અને અમે JPEG ફાઈલ ઉપયોગ જઈ રહ્યાં છો
અમારા બંધારણ તરીકે બંધારણ નામ.

73
00:04:09,870 --> 00:04:12,030
અને તે શું છે?

74
00:04:12,030 --> 00:04:18,450
અહીં સુધી, અમે તેને ટકા શૂન્ય છે કે નહીં તે જોવા
3D.JPEG જ્યાં શૂન્ય ત્રણ માત્ર

75
00:04:18,450 --> 00:04:22,089
અમે ત્રણ પૂર્ણાંકો ઉપયોગ કરશો કહે છે કે
આ માટે zeros સાથે ગાદીવાળાં.

76
00:04:22,089 --> 00:04:27,470
તેથી આ અમે શૂન્ય શૂન્ય મળશે કેવી રીતે
તેથી one.JPEG અને શૂન્ય 10.JPEG છે.

77
00:04:27,470 --> 00:04:29,060
>> અમે sprintf ઉપયોગ જઈ રહ્યાં છો.

78
00:04:29,060 --> 00:04:33,760
અને અમે દાખલ કરી રહ્યા છો કે પૂર્ણાંક
શબ્દમાળા જડ JPEGs છે માં

79
00:04:33,760 --> 00:04:36,380
મૂળ શૂન્ય છે, જે વસૂલાત કરી હતી.

80
00:04:36,380 --> 00:04:39,950
જેથી પ્રથમ ફાઇલ ખોલી રહ્યું છે
શૂન્ય શૂન્ય શૂન્ય કોઈ JPEG છે.

81
00:04:39,950 --> 00:04:43,330
અને પછી અમે તેથી તેને incrementing કરી રહ્યાં છો
અમે ખોલો આગામી ફાઇલ શૂન્ય શૂન્ય હશે

82
00:04:43,330 --> 00:04:46,830
એક કોઈ JPEG, અને અમે તેને વધારતી પડશે
ફરીથી એટલે શૂન્ય શૂન્ય બે ડોટ હશો

83
00:04:46,830 --> 00:04:49,100
તેથી JPEG, અને.

84
00:04:49,100 --> 00:04:49,850
>> અધિકાર છે.

85
00:04:49,850 --> 00:04:53,210
તેથી હવે JPEG ફાઈલ ની અંદર
નામ આપો, અમે નું નામ છે

86
00:04:53,210 --> 00:04:54,990
અમે માંગો છો તે ફાઇલ.

87
00:04:54,990 --> 00:04:58,640
અમે એફ લખવા માટે તે ફાઇલ ખોલી શકે છે.

88
00:04:58,640 --> 00:04:59,170
બરાબર.

89
00:04:59,170 --> 00:05:02,820
અને ફરી એક વખત, અમે ખાતરી કરવા માટે ચકાસણી કરવાની જરૂર છે
ખાતરી કરો કે સફળતાપૂર્વક ફાઇલ

90
00:05:02,820 --> 00:05:08,460
તે નથી, તો પછી ન હોય તો ત્યારથી ખૂલી
કેટલાક ભૂલ આવી હતી.

91
00:05:08,460 --> 00:05:13,100
>> તેથી હવે અમે ભૂતકાળમાં મેળવેલ કર્યું
આ કોઈ JPEG ભાગ છે.

92
00:05:13,100 --> 00:05:16,390
અને અહીં આપણે જોઈ રહ્યા છીએ
એ JPEG માં લખવા માટે.

93
00:05:16,390 --> 00:05:20,980
પરંતુ અમે પ્રથમ કહે છે જે આ તપાસ કરવામાં
JPEG ફાઈલ સમાન નલ નહી હોય તો.

94
00:05:20,980 --> 00:05:22,490
એ કેવી જરૂર છે?

95
00:05:22,490 --> 00:05:28,020
વેલ JPEG ફાઈલ નલ સમકક્ષ હોય છે જ્યારે અમે
હાલમાં એક ઓપન JPEG છે.

96
00:05:28,020 --> 00:05:31,870
>> શું કાર્ડ કોઈ કાચા શરૂ થાય છે
બાઇટ્સ સમૂહ સાથે

97
00:05:31,870 --> 00:05:33,510
કોઈ JPEG પ્રતિનિધિત્વ નથી કરતાં?

98
00:05:33,510 --> 00:05:36,240
તો પછી અમે કરવા માંગો છો જઈ રહ્યાં છો
તે બાઇટ્સ ઉપર છોડી દો.

99
00:05:36,240 --> 00:05:39,600
અમે આ ચેક ન હોય તો, પછી અમે છો
એક unopened માટે લખી રહ્યા

100
00:05:39,600 --> 00:05:45,540
પ્રથમ 512 બાઇટ્સ ફાઇલ
સારી નથી કે જે કાર્ડ.

101
00:05:45,540 --> 00:05:46,030
બરાબર.

102
00:05:46,030 --> 00:05:51,330
>> તેથી પછી, અમે એક ફાઇલ ખોલો છે એમ ધારી રહ્યા છીએ
અમે તે ફાઇલ લખી રહ્યા છીએ

103
00:05:51,330 --> 00:05:53,290
આપણે બફર માં છે કે 512 બાઇટ્સ.

104
00:05:53,290 --> 00:05:57,390
અને અમે ફરી એક વાર કરવા માટે ચકાસણી કરી રહ્યા છીએ
ખાતરી કરો કે સફળતાપૂર્વક 512 બાઇટ્સ

105
00:05:57,390 --> 00:06:01,140
તેઓ ન હતા કારણ કે જો લખેલા હતા
સફળતાપૂર્વક લેખિત, પછી કંઈક

106
00:06:01,140 --> 00:06:02,080
ખોટું થયું હતું.

107
00:06:02,080 --> 00:06:06,540
અમે તે છાપો અમારા ફાઈલો બંધ પડશે
કંઈક ખોટું થયું હતું, અને વળતર.

108
00:06:06,540 --> 00:06:10,940
ધારી રહ્યા છીએ બધું પછી, યોગ્ય રીતે જાય છે
અમે બંધ રહ્યાં રાખવા પડશે

109
00:06:10,940 --> 00:06:15,060
જૂના ફાઇલ, નવું ફાઇલ ખોલીને, લેખન
જેથી નવી ફાઈલ માટે માહિતી અને

110
00:06:15,060 --> 00:06:20,990
છેલ્લે, આ એફ વાંચી સુધી
શૂન્ય આપે છે જેનો અર્થ એ થાય

111
00:06:20,990 --> 00:06:23,280
ફાઇલ કરવામાં આવે છે તે.

112
00:06:23,280 --> 00:06:28,490
>> તેથી હવે કાર્ડ વાંચન પર છે કે, અમે
અમે એફ બંધ રહ્યા છીએ કે નહીં તે જોવા માટે

113
00:06:28,490 --> 00:06:33,250
અમે ઓપન હતી, પરંતુ તે છેલ્લી ફાઈલ
અમે ચકાસણી કરી રહ્યાં છો JPEG ફાઈલ

114
00:06:33,250 --> 00:06:34,900
સમાન નથી નલ કરે છે.

115
00:06:34,900 --> 00:06:39,520
વેલ એફ બંધ કરો કારણ કે અર્થમાં બનાવે છે
આપણે બંધ કરી રહ્યા છીએ, ફાઇલો ખોલીને કરી રહ્યાં છો

116
00:06:39,520 --> 00:06:43,870
પહેલાની ફાઈલની, પરંતુ ખૂબ જ છેલ્લા
અમે ખોલી તે ફાઈલ બંધ નહીં ક્યારેય.

117
00:06:43,870 --> 00:06:45,580
જેથી આ શું કરી રહ્યા છે છે.

118
00:06:45,580 --> 00:06:47,720
>> પરંતુ શા માટે અમે નલ માટે તપાસ કરવાની જરૂર છે?

119
00:06:47,720 --> 00:06:53,130
વેલ જો કાર્ડ કોઈ કાચા ન હતી
તેની અંદર એક JPEG, છે?

120
00:06:53,130 --> 00:06:56,640
તે કિસ્સામાં, અમે પાસે હોત
ફાઇલ ખોલી નથી.

121
00:06:56,640 --> 00:07:00,230
અમે ફાઈલ ખોલો ક્યારેય અને, જો અમે જોઈએ
તે ફાઇલ બંધ કરવા પ્રયાસ.

122
00:07:00,230 --> 00:07:03,000
જેથી આ ચેક કરવાનું છે શું છે.

123
00:07:03,000 --> 00:07:07,880
>> હું પહેલાં જણાવ્યું હતું કે હવે અહીં, અમે કરી શકે
કે વાય લૂપ ક્યાં તો તૂટી ગયેલ છે

124
00:07:07,880 --> 00:07:13,520
કાર્ડ હોય તો અંત અથવા છે
કાર્ડ માંથી વાંચવા કેટલાક ભૂલ.

125
00:07:13,520 --> 00:07:16,680
તેથી આ હતી તે જોવા માટે ચકાસે છે
માં, કાર્ડમાંથી વાંચન ભૂલ

126
00:07:16,680 --> 00:07:19,400
જે કિસ્સામાં, અમે ત્યાં કહેવું પડશે
એક વાંચવામાં ભૂલ હતી.

127
00:07:19,400 --> 00:07:22,130
અમે વપરાશકર્તા લાગે નહિં માંગો
બધું સફળતાપૂર્વક ગયા હતા.

128
00:07:22,130 --> 00:07:24,750
અને અમે ભૂલ માટે પરત મળશે.

129
00:07:24,750 --> 00:07:29,580
>> છેલ્લે, અમે એફ અમારા કાચા ફાઈલ બંધ પડશે,
અમારા કાર્ડ સૂચવે છે કે, કાચા ડોટ

130
00:07:29,580 --> 00:07:34,070
બધું સારી રીતે અને વળતર ગયા
શૂન્ય અને તે છે.

131
00:07:34,070 --> 00:07:36,130
>> મારું નામ રોબ છે અને આ પુનઃપ્રાપ્ત હતી.

132
00:07:36,130 --> 00:07:42,102
>> [સંગીત વગાડવાનો]