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

2
00:00:00,494 --> 00:00:13,350
>> [Musikk spilles]

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

4
00:00:14,080 --> 00:00:17,550
Jeg er Rob, og la oss håpe at
denne løsningen bidrar til å sette deg

5
00:00:17,550 --> 00:00:19,600
på bedringens vei.

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

7
00:00:22,700 --> 00:00:25,660
>> Vi ser at straks vi er
bare for å være sikker på at vi er

8
00:00:25,660 --> 00:00:27,170
ved å bruke Recover riktig.

9
00:00:27,170 --> 00:00:31,490
Så det behandling bør bare være noe
som dot slash gjenopprette.

10
00:00:31,490 --> 00:00:35,500
>> Nå skal vi åpne den forventede
kort dot rå fil.

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

12
00:00:39,740 --> 00:00:44,200
som her oppe har vi hash
definert som kort dot rå.

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

14
00:00:45,030 --> 00:00:48,210
>> Så vi må sørge for at det
hell åpnet fordi hvis det

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

16
00:00:51,150 --> 00:00:56,770
Men forutsatt at det gjorde, er vi nå
kommer til å erklære en buffer på størrelse JPEG

17
00:00:56,770 --> 00:00:58,170
Lengden på filnavnet.

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

19
00:01:02,060 --> 00:01:04,360
>> Så hva er JPEG filnavnlengde?

20
00:01:04,360 --> 00:01:08,490
Her oppe, ser vi at det er
hash definert som åtte.

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

22
00:01:10,670 --> 00:01:15,150
Vel en gitt fil vil bli navngitt
noe som null null null.

23
00:01:15,150 --> 00:01:19,460
JPG og da trenger vi en backslash null.

24
00:01:19,460 --> 00:01:22,720
Så vi trenger en buffer som kan
lagre åtte tegn.

25
00:01:22,720 --> 00:01:25,190
Nå skal vi ha en teller som er
kommer til å holde orden på

26
00:01:25,190 --> 00:01:27,780
tall JPEG vi fant.

27
00:01:27,780 --> 00:01:31,590
>> Og til slutt, kommer vi til å ha en
JPEG-fil som er utgangspunktet null

28
00:01:31,590 --> 00:01:35,920
som kommer til å være det i dag
åpen fil som vi skriver til.

29
00:01:35,920 --> 00:01:37,540
Nå skal vi ha
en ytterligere buffer.

30
00:01:37,540 --> 00:01:41,350
Dette er ikke det samme som vår sprintf
buffer hvor denne bufferen er en

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

32
00:01:45,020 --> 00:01:48,900
>> Så bufferen kommer til å være av
usignerte tegn, som du kan

33
00:01:48,900 --> 00:01:53,560
utgangspunktet bare behandler oss bytes, og det er
kommer til å være av størrelsen blokkstørrelse

34
00:01:53,560 --> 00:01:57,950
der, som vi fortelle deg,
blokkstørrelse er 512.

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

36
00:02:03,070 --> 00:02:05,890
>> Nå skal vi sløyfe
over hele filen.

37
00:02:05,890 --> 00:02:12,980
Vi kommer til å f lese i vår buffer
en enkelt byte blokkstørrelse ganger fra

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

39
00:02:14,710 --> 00:02:16,630
Nå hva betyr f lese tilbake?

40
00:02:16,630 --> 00:02:20,050
Den returnerer antall elementer
at det med hell leses.

41
00:02:20,050 --> 00:02:27,310
Så hvis det klarte å lese 512 bytes, deretter
Vi ønsker å se om dette 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 returnerte 512 bytes,
deretter enten filen har endt i

44
00:02:34,450 --> 00:02:37,870
hvilket tilfelle vi vil bryte ut av y
loop, eller er det noen slags feil

45
00:02:37,870 --> 00:02:40,300
I så fall vil vi også bryte ut av
y loop, men vi vil ønske å rapportere

46
00:02:40,300 --> 00:02:41,990
at noe gikk galt.

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

48
00:02:42,290 --> 00:02:47,630
Så forutsatt at vi klarer å lese
i 512 bytes, vi ønsker å først sjekke

49
00:02:47,630 --> 00:02:53,070
å gjøre at disse bytes som vi
bare lest i begynne en JPEG.

50
00:02:53,070 --> 00:02:56,430
Så hvis er JPEG header av vår buffer.

51
00:02:56,430 --> 00:02:58,460
Nå hva det er JPEG header gjør?

52
00:02:58,460 --> 00:03:00,120
La oss se.

53
00:03:00,120 --> 00:03:05,270
>> Her oppe, ser vi at denne funksjonen er
returnere en okse, og at oksen -

54
00:03:05,270 --> 00:03:08,820
vel her, vi sjekker for å se om
header null tilsvarer dette konstant og

55
00:03:08,820 --> 00:03:11,880
header ett tilsvarer dette konstant og
header to tilsvarer dette konstant,

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

57
00:03:15,640 --> 00:03:20,340
bare hash definert akkurat her og er
akkurat hva vi fortalte deg i spec

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

59
00:03:22,700 --> 00:03:27,300
Og så denne funksjonen er bare kommer til å
return true hvis denne bufferen representerer

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 representerer en ny JPEG,
Da vi først ønsker å sjekke for å se om

63
00:03:38,490 --> 00:03:42,030
JPEG-fil er ikke lik null,
i hvilket tilfelle vi lukke den.

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

65
00:03:44,940 --> 00:03:48,980
Vel den aller første JPEG at vi
finner vi vil ikke allerede har

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

67
00:03:50,440 --> 00:03:55,580
Og så, hvis vi prøver å lukke det, så
vi ikke gjør noe helt riktig.

68
00:03:55,580 --> 00:03:59,090
>> Men hver påfølgende JPEG som
vi åpner, ønsker vi å lukke

69
00:03:59,090 --> 00:04:00,710
forrige fil.

70
00:04:00,710 --> 00:04:04,630
Så nå skal vi bruke sprintf som vi
sagt før hvor vi bruker

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

72
00:04:06,280 --> 00:04:09,870
Og vi kommer til å bruke JPEG-fil
nevne format som vår format.

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

74
00:04:12,030 --> 00:04:18,450
Her oppe, ser vi at det er prosent null
3D.JPEG der null tre like

75
00:04:18,450 --> 00:04:22,089
sier at vi vil bruke tre heltall
for dette polstret med nuller.

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

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

78
00:04:29,060 --> 00:04:33,760
Og heltall som vi setter inn
inn i strengen er nummen JPEG

79
00:04:33,760 --> 00:04:36,380
gjenopprettet, noe som er opprinnelig null.

80
00:04:36,380 --> 00:04:39,950
Så den første filen åpnes kommer
å være null null null dot JPEG.

81
00:04:39,950 --> 00:04:43,330
Og så skal vi økes det slik at
neste fil åpner vi vil være null null

82
00:04:43,330 --> 00:04:46,830
en prikk JPEG og vi vil øke den
igjen slik at det vil være null null to prikk

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å nå innsiden av JPEG-fil
navn, har vi navnet på

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

87
00:04:54,990 --> 00:04:58,640
Vi kan f åpne denne filen for skriving.

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

89
00:04:59,170 --> 00:05:02,820
Og nok en gang, trenger vi å sjekke for å være
sikker på at filen vellykket

90
00:05:02,820 --> 00:05:08,460
åpnet siden hvis det ikke gjorde det, så
det var noen feil.

91
00:05:08,460 --> 00:05:13,100
>> Så nå har vi fått forbi
Dette er en JPEG-delen.

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

93
00:05:16,390 --> 00:05:20,980
Men vi først har denne sjekken som sier
hvis JPEG-fil er ikke lik null.

94
00:05:20,980 --> 00:05:22,490
Hvorfor trenger vi det?

95
00:05:22,490 --> 00:05:28,020
Vel JPEG-fil er lik null når vi
øyeblikket en åpen JPEG.

96
00:05:28,020 --> 00:05:31,870
>> Hva om kortet dot rå starter
med en haug med byte som

97
00:05:31,870 --> 00:05:33,510
ikke representerer en JPEG?

98
00:05:33,510 --> 00:05:36,240
Så får vi kommer til å ønske å
hoppe over disse bytes.

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

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

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

102
00:05:46,030 --> 00:05:51,330
>> Så forutsatt at vi har en åpen fil, deretter
vi kommer til å skrive til denne filen

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

104
00:05:53,290 --> 00:05:57,390
Og vi er nok en gang kontrollerer
sikker på at de 512 bytes vellykket

105
00:05:57,390 --> 00:06:01,140
ble skrevet fordi hvis de ikke var
hell skrevet, så noe

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

107
00:06:02,080 --> 00:06:06,540
Vi vil lukke våre filer, skrive ut som
noe gikk galt, og retur.

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

109
00:06:10,940 --> 00:06:15,060
gamle filen, åpner den nye filen, skriving
data til den nye filen, og så

110
00:06:15,060 --> 00:06:20,990
på helt til slutt, dette f lese
returnerer null hvilke midler

111
00:06:20,990 --> 00:06:23,280
at filen er gjort.

112
00:06:23,280 --> 00:06:28,490
>> Så nå at kortleser er over, vi
se at vi kommer til å f lukke

113
00:06:28,490 --> 00:06:33,250
siste fil som vi hadde åpent, men
Vi sjekker om JPEG-fil

114
00:06:33,250 --> 00:06:34,900
ikke lik null.

115
00:06:34,900 --> 00:06:39,520
Vel f nær er fornuftig fordi som
vi er åpne filer, vi stenger

116
00:06:39,520 --> 00:06:43,870
den forrige fil, men den aller siste
fil som vi åpnet aldri blir stengt.

117
00:06:43,870 --> 00:06:45,580
Så det er hva dette gjør.

118
00:06:45,580 --> 00:06:47,720
>> Men hvorfor vi må sjekke for null?

119
00:06:47,720 --> 00:06:53,130
Vel, hva om kortet dot rå gjorde ikke
har en enkelt JPEG innsiden av det?

120
00:06:53,130 --> 00:06:56,640
I så fall ville vi ha
aldri åpnet en fil.

121
00:06:56,640 --> 00:07:00,230
Og hvis vi aldri åpne en fil, bør vi
Ikke prøv å lukke filen.

122
00:07:00,230 --> 00:07:03,000
Så det er hva denne sjekken gjør.

123
00:07:03,000 --> 00:07:07,880
>> Nå her, som jeg sa tidligere, vi kunne
har brutt ut at y sløyfe enten hvis

124
00:07:07,880 --> 00:07:13,520
kortet er avsluttet, eller hvis det finnes
noen feil ved lesing fra kortet.

125
00:07:13,520 --> 00:07:16,680
Så dette er å sjekke for å se om det var
en feil ved lesing fra kortet, i

126
00:07:16,680 --> 00:07:19,400
så fall, vil vi si at det
var en feil lesing.

127
00:07:19,400 --> 00:07:22,130
Vi ønsker ikke brukeren å tenke
alt gikk vellykket.

128
00:07:22,130 --> 00:07:24,750
Og vi vil returnere en for feil.

129
00:07:24,750 --> 00:07:29,580
>> Til slutt vil vi f lukke våre rå fil,
våre kort dot rå, for å indikere at

130
00:07:29,580 --> 00:07:34,070
alt gikk bra og retur
null og det er det.

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

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