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

2
00:00:00,494 --> 00:00:13,350
>> [Musikgengivelse]

3
00:00:13,350 --> 00:00:14,080
>> ROB BOWDEN: Hej.

4
00:00:14,080 --> 00:00:17,550
Jeg er Rob, og lad os håbe, at
denne løsning hjælper sætte dig

5
00:00:17,550 --> 00:00:19,600
på vejen til bedring.

6
00:00:19,600 --> 00:00:22,700
Så lad os komme i gang.

7
00:00:22,700 --> 00:00:25,660
>> Vi ser, at det samme er vi
bare sørge for, at vi er

8
00:00:25,660 --> 00:00:27,170
hjælp Recover korrekt.

9
00:00:27,170 --> 00:00:31,490
Så brug bare skal være noget
ligesom dot skråstreg komme sig.

10
00:00:31,490 --> 00:00:35,500
>> Nu skal vi til at åbne den forventede
kort dot rå fil.

11
00:00:35,500 --> 00:00:39,740
Vi ser her, at vi bruger den
konstant rå understregning filnavn,

12
00:00:39,740 --> 00:00:44,200
der op her har vi hash
defineret som kort prik rå.

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

14
00:00:45,030 --> 00:00:48,210
>> Så vi er nødt til at sørge for, at der
succes åbnet fordi hvis det

15
00:00:48,210 --> 00:00:51,150
ikke, så vi bør advare brugeren.

16
00:00:51,150 --> 00:00:56,770
Men det antages, at det gjorde, vi nu
kommer til at erklære en buffer størrelse JPEG

17
00:00:56,770 --> 00:00:58,170
filnavn længde.

18
00:00:58,170 --> 00:01:02,060
Så dette vil være den buffer, der
vi kommer til at sprintf ind.

19
00:01:02,060 --> 00:01:04,360
>> Så hvad er JPEG filnavn længde?

20
00:01:04,360 --> 00:01:08,490
Heroppe ser vi, at det er
hash defineres som otte.

21
00:01:08,490 --> 00:01:10,670
Så hvorfor otte?

22
00:01:10,670 --> 00:01:15,150
Nå en given fil vil blive navngivet
noget som nul nul nul.

23
00:01:15,150 --> 00:01:19,460
JPG og så har vi brug for en backslash nul.

24
00:01:19,460 --> 00:01:22,720
Så vi har brug for en buffer, der kan
gemme otte tegn.

25
00:01:22,720 --> 00:01:25,190
Nu skal vi til at have en tæller, der er
kommer til at holde styr på

26
00:01:25,190 --> 00:01:27,780
antal JPEG vi fundet.

27
00:01:27,780 --> 00:01:31,590
>> Og endelig vil vi have en
JPEG-fil, der er i første omgang null

28
00:01:31,590 --> 00:01:35,920
der kommer til at være den aktuelt
åben fil, som vi skriver til.

29
00:01:35,920 --> 00:01:37,540
Nu vil vi have
en yderligere buffer.

30
00:01:37,540 --> 00:01:41,350
Dette er ikke det samme som vores sprintf
buffer hvor denne buffer er den ene

31
00:01:41,350 --> 00:01:45,020
at vi læser i de data,
fra kortet dot rå.

32
00:01:45,020 --> 00:01:48,900
>> Så bufferen vil være til
chars signerede, som du kan

33
00:01:48,900 --> 00:01:53,560
dybest set bare behandle os bytes, og det er
vil være til størrelse blokstørrelse

34
00:01:53,560 --> 00:01:57,950
hvor, som vi fortæller dig,
blokstørrelse er 512.

35
00:01:57,950 --> 00:02:03,070
Så JPEG kan du behandle alt
som blokke af 512 bytes.

36
00:02:03,070 --> 00:02:05,890
>> Nu skal vi til at sløjfe
over hele filen.

37
00:02:05,890 --> 00:02:12,980
Vi kommer til at f læse i vores buffer
en enkelt byte blok størrelse gange fra

38
00:02:12,980 --> 00:02:14,710
kortet dot rå fil.

39
00:02:14,710 --> 00:02:16,630
Nu hvad betyder f læse tilbage?

40
00:02:16,630 --> 00:02:20,050
Den returnerer antallet af elementer
at den med held læse.

41
00:02:20,050 --> 00:02:27,310
Så hvis det lykkedes at læse 512 bytes, så
vi ønsker at se, om det var en

42
00:02:27,310 --> 00:02:29,700
JPEG eller skrive det til en JPEG-fil.

43
00:02:29,700 --> 00:02:34,450
Og hvis det ikke vendte tilbage 512 byte,
derefter enten filen er afsluttet i

44
00:02:34,450 --> 00:02:37,870
hvilket tilfælde vi vil bryde ud af y
loop, eller der er en form for fejl

45
00:02:37,870 --> 00:02:40,300
i hvilket tilfælde vi vil også bryde ud af
y loop, men vi vil få lyst til at rapportere

46
00:02:40,300 --> 00:02:41,990
gik der noget galt.

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

48
00:02:42,290 --> 00:02:47,630
Så under forudsætning af, at vi med succes læse
i 512 bytes, ønsker vi at først kontrollere

49
00:02:47,630 --> 00:02:53,070
at gøre disse bytes, som vi
bare læse i begynde en JPEG.

50
00:02:53,070 --> 00:02:56,430
Så hvis er JPEG header på vores buffer.

51
00:02:56,430 --> 00:02:58,460
Nu, hvad er det JPEG header gør?

52
00:02:58,460 --> 00:03:00,120
Lad os se.

53
00:03:00,120 --> 00:03:05,270
>> Heroppe ser vi, at denne funktion er
returnere en tyr, og at der i noget -

54
00:03:05,270 --> 00:03:08,820
godt her, vi kontrol for at se, om
header nul er lig med denne konstante og

55
00:03:08,820 --> 00:03:11,880
header en er lig med denne konstante og
header to er lig med denne konstant,

56
00:03:11,880 --> 00:03:15,640
header tre er lig med dette eller dette
konstant, hvor alle disse konstanter er

57
00:03:15,640 --> 00:03:20,340
bare hash defineret lige her og er
præcis, hvad vi fortalte dig i spec

58
00:03:20,340 --> 00:03:22,700
at en JPEG begynder med.

59
00:03:22,700 --> 00:03:27,300
Og så denne funktion er bare at
returnere sand, hvis denne buffer repræsenterer

60
00:03:27,300 --> 00:03:31,750
starten på en ny JPEG
og falsk ellers.

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

62
00:03:32,520 --> 00:03:38,490
Så hvis dette ikke udgør en ny JPEG,
så vi først ønsker at kontrollere, om

63
00:03:38,490 --> 00:03:42,030
JPEG-fil er ikke lig med nul,
i hvilket tilfælde vi lukke det.

64
00:03:42,030 --> 00:03:44,940
Og så hvorfor har vi brug for at kontrollere
at se, om det ikke er null?

65
00:03:44,940 --> 00:03:48,980
Nå den allerførste JPEG, at vi
finder vi ikke allerede har

66
00:03:48,980 --> 00:03:50,440
en åben JPEG-fil.

67
00:03:50,440 --> 00:03:55,580
Og så, hvis vi forsøger at lukke det, så
Vi laver ikke noget helt rigtigt.

68
00:03:55,580 --> 00:03:59,090
>> Men hver efterfølgende JPEG som
vi åbner, vi ønsker at lukke

69
00:03:59,090 --> 00:04:00,710
den foregående fil.

70
00:04:00,710 --> 00:04:04,630
Så nu vil vi bruge sprintf som vi
sagde før, hvor vi ved hjælp af

71
00:04:04,630 --> 00:04:06,280
buffer JPEG-fil navn.

72
00:04:06,280 --> 00:04:09,870
Og vi kommer til at bruge JPEG-fil
navngive format som vores format.

73
00:04:09,870 --> 00:04:12,030
Og hvad er det?

74
00:04:12,030 --> 00:04:18,450
Heroppe ser vi, at det er procent nul
3D.JPEG hvor nul tre lige

75
00:04:18,450 --> 00:04:22,089
siger, at vi vil bruge tre heltal
for dette nuller.

76
00:04:22,089 --> 00:04:27,470
Så dette er, hvordan vi får nul nul
one.JPEG og nul 10.JPEG og så videre.

77
00:04:27,470 --> 00:04:29,060
>> Vi kommer til at bruge sprintf.

78
00:04:29,060 --> 00:04:33,760
Og det heltal, at vi indsætter
i strengen er følelsesløs JPEG

79
00:04:33,760 --> 00:04:36,380
genvundet, som er oprindeligt nul.

80
00:04:36,380 --> 00:04:39,950
Så den første fil åbnes går
at være nul nul nul prik JPEG.

81
00:04:39,950 --> 00:04:43,330
Og så er vi forøge det, så
næste fil åbner vi vil være nul nul

82
00:04:43,330 --> 00:04:46,830
en prik JPEG og vi vil forøge det
igen, så det vil være nul nul to prik

83
00:04:46,830 --> 00:04:49,100
JPEG og så videre.

84
00:04:49,100 --> 00:04:49,850
>> Ok.

85
00:04:49,850 --> 00:04:53,210
Så nu inde i JPEG-fil
navn, har vi navnet på den

86
00:04:53,210 --> 00:04:54,990
fil, vi ønsker.

87
00:04:54,990 --> 00:04:58,640
Vi kan f åbne den pågældende fil til skrivning.

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

89
00:04:59,170 --> 00:05:02,820
Og endnu en gang, er vi nødt til at tjekke for at
sikker på, at filen med succes

90
00:05:02,820 --> 00:05:08,460
åbnet siden, hvis det ikke gjorde det, så
der var en fejl.

91
00:05:08,460 --> 00:05:13,100
>> Så nu har vi fået forbi den
er dette en JPEG-del.

92
00:05:13,100 --> 00:05:16,390
Og her ser vi vi vil
at skrive til JPEG.

93
00:05:16,390 --> 00:05:20,980
Men vi først har denne kontrol, som siger
Hvis JPEG-fil er ikke lig nul.

94
00:05:20,980 --> 00:05:22,490
Hvorfor har vi brug for det?

95
00:05:22,490 --> 00:05:28,020
Nå JPEG-fil er lig nul, når vi
øjeblikket har en åben JPEG.

96
00:05:28,020 --> 00:05:31,870
>> Hvad hvis kortet dot rå starter
med en flok bytes,

97
00:05:31,870 --> 00:05:33,510
ikke udgør en JPEG?

98
00:05:33,510 --> 00:05:36,240
Så vi vil gerne
springe over disse bytes.

99
00:05:36,240 --> 00:05:39,600
Hvis vi ikke har denne check, så er vi
kommer til at skrive til en uåbnet

100
00:05:39,600 --> 00:05:45,540
indgive de første 512 bytes
kortet, som ikke er god.

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

102
00:05:46,030 --> 00:05:51,330
>> Så antager vi har en åben fil, så
vi kommer til at skrive til denne fil

103
00:05:51,330 --> 00:05:53,290
512 bytes, som vi har i vores buffer.

104
00:05:53,290 --> 00:05:57,390
Og vi er endnu engang kontrol for at
sikker på, at de 512 bytes succes

105
00:05:57,390 --> 00:06:01,140
blev skrevet, fordi hvis de ikke var
skrevet korrekt, så noget

106
00:06:01,140 --> 00:06:02,080
gik galt.

107
00:06:02,080 --> 00:06:06,540
Vi lukker vores filer, udskrive denne
gik noget galt, og vende tilbage.

108
00:06:06,540 --> 00:06:10,940
Antages alt går korrekt, så
vi vil holde looping lukke

109
00:06:10,940 --> 00:06:15,060
gamle fil, åbner den nye fil, skrivning
data til den nye fil, og så

110
00:06:15,060 --> 00:06:20,990
indtil endelig denne f læse
returneres nul hvilke organer

111
00:06:20,990 --> 00:06:23,280
at filen er færdig.

112
00:06:23,280 --> 00:06:28,490
>> Så nu, at kortet læsning er overstået, vi
se, at vi kommer til at f lukke

113
00:06:28,490 --> 00:06:33,250
sidste fil, som vi havde åbent, men
Vi tjekker, om JPEG-fil

114
00:06:33,250 --> 00:06:34,900
ikke er lig nul.

115
00:06:34,900 --> 00:06:39,520
Nå f tæt giver mening, fordi som
Vi åbner filer, vi lukker

116
00:06:39,520 --> 00:06:43,870
den tidligere fil, men den allersidste
fil, som vi åbnede aldrig bliver lukket.

117
00:06:43,870 --> 00:06:45,580
Så det er hvad det gør.

118
00:06:45,580 --> 00:06:47,720
>> Men hvorfor er vi nødt til at tjekke for null?

119
00:06:47,720 --> 00:06:53,130
Jamen hvad nu hvis kortet dot rå gjorde ikke
har en enkelt JPEG inde i det?

120
00:06:53,130 --> 00:06:56,640
I så fald ville vi have
aldrig åbnet en fil.

121
00:06:56,640 --> 00:07:00,230
Og hvis vi aldrig åbne en fil, skal vi
ikke forsøger at lukke filen.

122
00:07:00,230 --> 00:07:03,000
Så det er hvad denne kontrol gør.

123
00:07:03,000 --> 00:07:07,880
>> Nu her, som jeg sagde før, vi kunne
har brudt ud, at y loop enten hvis

124
00:07:07,880 --> 00:07:13,520
kortet er afsluttet, eller hvis der er
nogle fejl ved læsning fra kortet.

125
00:07:13,520 --> 00:07:16,680
Så dette er kontrol for at se, om der var
en fejl ved læsning fra kortet, i

126
00:07:16,680 --> 00:07:19,400
hvilket tilfælde, vil vi sige, at der
var en fejl læsning.

127
00:07:19,400 --> 00:07:22,130
Vi ønsker ikke, at brugeren til at tænke
alt gik med succes.

128
00:07:22,130 --> 00:07:24,750
Og vi vil man vende tilbage til fejl.

129
00:07:24,750 --> 00:07:29,580
>> Endelig vil vi f lukke vores rå fil,
vores kort dot rå, for at angive,

130
00:07:29,580 --> 00:07:34,070
alt gik godt og afkast
nul og det er det.

131
00:07:34,070 --> 00:07:36,130
>> Mit navn er Rob og dette var Recover.

132
00:07:36,130 --> 00:07:42,102
>> [Musikgengivelse]