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
>> რობ Bowden: Hi.

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
ასე რომ, გამოყენება უნდა იყოს მხოლოდ რაღაც
ისევე როგორც dot ხაზი ფეხზე.

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
რომელიც აქ გვაქვს hash
განისაზღვრება, როგორც ანკეტა dot ნედლეული.

13
00:00:44,200 --> 00:00:45,030
OK.

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
აქ ჩვენ ვხედავთ, რომ ის
hash განისაზღვრება, როგორც რვა.

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 და მაშინ ჩვენ გვჭირდება backslash ნულოვანი.

24
00:01:19,460 --> 00:01:22,720
ამიტომ ჩვენ გვჭირდება ბუფერული, რომ შეიძლება
შენახვის რვა სიმბოლო.

25
00:01:22,720 --> 00:01:25,190
ახლა ჩვენ ვაპირებთ აქვს counter, რომ
აპირებს ტრეკზე

26
00:01:25,190 --> 00:01:27,780
ნომერი JPEGs აღმოვაჩინეთ.

27
00:01:27,780 --> 00:01:31,590
>> და ბოლოს, ჩვენ ვაპირებთ აქვს
JPEG ფაილის რომელიც თავდაპირველად null

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
რომ ჩვენ კითხვის მონაცემები
ბარათის dot ნედლეული.

32
00:01:45,020 --> 00:01:48,900
>> ასე რომ ბუფერული აპირებს იყოს
unsigned სიმბოლო, რომელიც შეგიძლიათ

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 bytes.

36
00:02:03,070 --> 00:02:05,890
>> ახლა ჩვენ ვაპირებთ loop
მთელ ფაილი.

37
00:02:05,890 --> 00:02:12,980
ჩვენ ვაპირებთ f წაიკითხოთ ჩვენს ბუფერული
ერთი ბაიტი ბლოკის ზომა ჯერ

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
ასეთ შემთხვევაში ჩვენ შესვენება გარეთ y
loop, ან არსებობს გარკვეული შეცდომა

45
00:02:37,870 --> 00:02:40,300
ამ შემთხვევაში ჩვენ ასევე შესვენება გარეთ
y loop, მაგრამ ჩვენ გვინდა, რომ მოხსენება

46
00:02:40,300 --> 00:02:41,990
რომ რაღაც წავიდა არასწორი.

47
00:02:41,990 --> 00:02:42,290
>> OK.

48
00:02:42,290 --> 00:02:47,630
ასე რომ, ვთქვათ, რომ ჩვენ წარმატებით წაკითხული
512 ბაიტი, ჩვენ გვინდა, რომ პირველი შემოწმება

49
00:02:47,630 --> 00:02:53,070
რათა, რომ ეს bytes რომ ჩვენ
უბრალოდ წაიკითხა დაიწყოს JPEG.

50
00:02:53,070 --> 00:02:56,430
ასე რომ, თუ არის JPEG header ჩვენი ბუფერული.

51
00:02:56,430 --> 00:02:58,460
ახლა რა ის JPEG header აკეთებს?

52
00:02:58,460 --> 00:03:00,120
მოდით შევხედოთ.

53
00:03:00,120 --> 00:03:05,270
>> აქ ჩვენ ვხედავთ, რომ ამ ფუნქციის
დაბრუნების bull, და რომ bull -

54
00:03:05,270 --> 00:03:08,820
კარგად აქ, ჩვენ შემოწმების თუ
header ნულოვანი შეადგენს ამ მუდმივი და

55
00:03:08,820 --> 00:03:11,880
header ერთი უდრის ამ მუდმივი და
header ორი უდრის ამ მუდმივი,

56
00:03:11,880 --> 00:03:15,640
header სამი უდრის ამ ან ამ
მუდმივი სადაც ყველა ამ მუდმივები არიან

57
00:03:15,640 --> 00:03:20,340
უბრალოდ hash განსაზღვრული უფლება აქ და
ზუსტად ის, რაც ჩვენ გითხარით სპეც

58
00:03:20,340 --> 00:03:22,700
რომ JPEG იწყება.

59
00:03:22,700 --> 00:03:27,300
და ა.შ. ეს ფუნქცია უბრალოდ აპირებს
TRUE თუ ეს ბუფერული წარმოადგენს

60
00:03:27,300 --> 00:03:31,750
დაწყების ახალი JPEG
და ცრუ სხვაგვარად.

61
00:03:31,750 --> 00:03:32,520
>> OK.

62
00:03:32,520 --> 00:03:38,490
ასე რომ, თუ ეს არ წარმოადგენს ახალი JPEG,
მაშინ ჩვენ პირველად გსურთ შეამოწმოთ თუ

63
00:03:38,490 --> 00:03:42,030
JPEG ფაილი არ არის ტოლი null,
ამ შემთხვევაში ჩვენ ვხურავთ მას.

64
00:03:42,030 --> 00:03:44,940
და რატომ გვჭირდება, რათა შეამოწმოს
თუ ეს არ null?

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
აქ ჩვენ ვხედავთ, რომ ეს არის პროცენტს zero
3D.JPEG სადაც ნულოვანი სამი უბრალოდ

75
00:04:18,450 --> 00:04:22,089
ამბობს, რომ ჩვენ ვიყენებთ სამი რიცხვებით
ამ padded ერთად zeros.

76
00:04:22,089 --> 00:04:27,470
ასე რომ, ეს არის, თუ როგორ მივიღებთ zero zero
one.JPEG და ნულოვანი 10.JPEG და ასე შემდეგ.

77
00:04:27,470 --> 00:04:29,060
>> ჩვენ ვაპირებთ გამოვიყენოთ sprintf.

78
00:04:29,060 --> 00:04:33,760
და რიცხვი, რომ ჩვენ ჩასმა
შევიდა string არის Numb JPEGs

79
00:04:33,760 --> 00:04:36,380
ამოღებული, რომელიც თავდაპირველად ნულოვანი.

80
00:04:36,380 --> 00:04:39,950
ასე რომ, პირველი ფაილი გახსნა აპირებს
უნდა იყოს ნულოვანი ნულოვანი ნულოვანი dot JPEG.

81
00:04:39,950 --> 00:04:43,330
და მაშინ ჩვენ დამატება ასე
შემდეგი ფაილის ჩვენ გახსნა იქნება ნულოვანი ნულოვანი

82
00:04:43,330 --> 00:04:46,830
ერთი dot JPEG და ჩვენ ნამატი იგი
ერთხელ, ასე რომ იქნება ნულოვანი ნულოვანი ორი dot

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
ჩვენ შეგვიძლია f ღია რომ ფაილი წერილობით.

88
00:04:58,640 --> 00:04:59,170
OK.

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 ფაილი არ თანაბარი null.

94
00:05:20,980 --> 00:05:22,490
რატომ გვჭირდება ეს?

95
00:05:22,490 --> 00:05:28,020
ისევე JPEG ფაილის შეადგენს null როდესაც ჩვენ
გაკეთებული აქვს ღია JPEG.

96
00:05:28,020 --> 00:05:31,870
>> რა მოხდება, თუ ანკეტა dot ნედლეული იწყება
ერთად bunch of bytes რომ

97
00:05:31,870 --> 00:05:33,510
არ წარმოადგენს JPEG?

98
00:05:33,510 --> 00:05:36,240
მაშინ ჩვენ ვაპირებთ მინდა
გაფართოებული იმ bytes.

99
00:05:36,240 --> 00:05:39,600
თუ ჩვენ არ გვაქვს ეს შემოწმება, მაშინ ჩვენ
აპირებს დაწეროს to გაუხსნელი

100
00:05:39,600 --> 00:05:45,540
წარადგინოს პირველი 512 ბაიტი
ბარათი, რომელიც არ არის კარგი.

101
00:05:45,540 --> 00:05:46,030
OK.

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 bytes წარმატებით

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
ვთქვათ, ყველაფერი სწორად, მაშინ
ჩვენ გავაგრძელებთ looping დახურვის

109
00:06:10,940 --> 00:06:15,060
ძველი ფაილის გახსნა ახალი ფაილი, წერა
მონაცემების ახალი ფაილი, და ა.შ.

110
00:06:15,060 --> 00:06:20,990
სანამ საბოლოოდ, ამ f წაკითხული
დააბრუნებს ნულოვანი რაც იმას ნიშნავს,

111
00:06:20,990 --> 00:06:23,280
რომ ფაილი კეთდება.

112
00:06:23,280 --> 00:06:28,490
>> ახლა რომ ბარათის მოსმენით მეტი, ჩვენ
ვხედავთ, რომ ჩვენ ვაპირებთ f დახურვა

113
00:06:28,490 --> 00:06:33,250
ბოლო ფაილი, რომელიც ჩვენ გვქონდა ღია, მაგრამ
ჩვენ შემოწმების თუ JPEG ფაილის

114
00:06:33,250 --> 00:06:34,900
არ თანაბარი null.

115
00:06:34,900 --> 00:06:39,520
კარგად f ახლო აზრი რადგან
ჩვენ გახსნის ფაილი, ჩვენ დახურვის

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
>> მაგრამ რატომ ჩვენ უნდა შევამოწმოთ null?

119
00:06:47,720 --> 00:06:53,130
ისე რა, თუ ანკეტა dot ნედლეული არ
აქვს ერთი 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
>> ახლა აქ, როგორც ვთქვი, ჩვენ შეგვიძლია
არ გატყდა, რომ y loop ან თუ

124
00:07:07,880 --> 00:07:13,520
ბარათის დასრულდა ან თუ არის
რაიმე შეცდომა კითხულობს ბარათი.

125
00:07:13,520 --> 00:07:16,680
ასე რომ, ეს შემოწმების თუ არ იყო
შეცდომა კითხულობს ბარათით in

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
>> და ბოლოს, ჩვენ f დავხუჭავთ ნედლეული ფაილი,
ჩვენი ანკეტა dot ნედლეული, მიუთითებს იმაზე, რომ

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
>> [მუსიკის დაკვრა]