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

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

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

4
00:00:14,080 --> 00:00:17,550
Ik ben Rob, en laten we hopen dat
Deze oplossing helpt zet je

5
00:00:17,550 --> 00:00:19,600
op de weg naar herstel.

6
00:00:19,600 --> 00:00:22,700
Dus laten we beginnen.

7
00:00:22,700 --> 00:00:25,660
>> We zien dat we meteen zijn
gewoon om ervoor te zorgen dat we

8
00:00:25,660 --> 00:00:27,170
met behulp van de juiste herstellen.

9
00:00:27,170 --> 00:00:31,490
Dus het gebruik moet gewoon iets zijn
zoals dot slash herstellen.

10
00:00:31,490 --> 00:00:35,500
>> Nu gaan we openen de verwachte
kaart dot RAW bestand.

11
00:00:35,500 --> 00:00:39,740
We zien hier dat we met behulp van de
constante ruwe underscore bestandsnaam,

12
00:00:39,740 --> 00:00:44,200
die tot hier hebben we hash
gedefinieerd als kaart dot rauw.

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

14
00:00:45,030 --> 00:00:48,210
>> Dus moeten we ervoor zorgen dat die
succesvol geopend want als het

15
00:00:48,210 --> 00:00:51,150
niet, dan moeten we de gebruiker te waarschuwen.

16
00:00:51,150 --> 00:00:56,770
Maar de veronderstelling dat het deed, zijn we nu
gaat om een ​​buffer van omvang JPEG verklaren

17
00:00:56,770 --> 00:00:58,170
lengte van de bestandsnaam.

18
00:00:58,170 --> 00:01:02,060
Dus dit gaat om de buffer te zijn dat
we gaan sprintf in.

19
00:01:02,060 --> 00:01:04,360
>> Dus wat is JPEG lengte van de bestandsnaam?

20
00:01:04,360 --> 00:01:08,490
Hier zien we dat het
hash gedefinieerd als acht.

21
00:01:08,490 --> 00:01:10,670
Dus waarom acht?

22
00:01:10,670 --> 00:01:15,150
Nou een bepaald bestand wordt benoemd
iets als nul nul nul.

23
00:01:15,150 --> 00:01:19,460
JPG en dan moeten we een backslash nul.

24
00:01:19,460 --> 00:01:22,720
Dus hebben we een buffer die kan nodig
slaan acht tekens.

25
00:01:22,720 --> 00:01:25,190
Nu gaan we een teller die hebben
gaan voor het bijhouden van de te houden

26
00:01:25,190 --> 00:01:27,780
aantal JPEG's vonden we.

27
00:01:27,780 --> 00:01:31,590
>> En tot slot, we gaan een
JPEG-bestand dat is in eerste instantie null

28
00:01:31,590 --> 00:01:35,920
die gaat het op dit moment zijn
geopend bestand dat we schriftelijk aan.

29
00:01:35,920 --> 00:01:37,540
Nu gaan we hebben
een extra buffer.

30
00:01:37,540 --> 00:01:41,350
Dit is niet hetzelfde als onze sprintf
buffer waar buffer degene

31
00:01:41,350 --> 00:01:45,020
dat we lezen in de data
van de kaart dot rauw.

32
00:01:45,020 --> 00:01:48,900
>> Dus de buffer gaat te zijn
unsigned chars, die u kunt

33
00:01:48,900 --> 00:01:53,560
eigenlijk gewoon behandelen ons bytes, en het is
gaan van grootte blokgrootte te zijn

34
00:01:53,560 --> 00:01:57,950
waar, zoals we u vertellen,
blokgrootte 512.

35
00:01:57,950 --> 00:02:03,070
Dus JPEG's kunt u alles te behandelen
als blokken van 512 bytes.

36
00:02:03,070 --> 00:02:05,890
>> Nu gaan we een lus
over het gehele bestand.

37
00:02:05,890 --> 00:02:12,980
We gaan f lezen in onze buffer
een enkele keer byte blok grootte van

38
00:02:12,980 --> 00:02:14,710
de kaart dot RAW bestand.

39
00:02:14,710 --> 00:02:16,630
Nu wat doet f leest terug?

40
00:02:16,630 --> 00:02:20,050
Het geeft het aantal items
dat het met succes lezen.

41
00:02:20,050 --> 00:02:27,310
Dus als het erin geslaagd om 512 bytes lezen, dan
we willen zien of dit een

42
00:02:27,310 --> 00:02:29,700
JPEG of schrijf het op een JPEG-bestand.

43
00:02:29,700 --> 00:02:34,450
En als het niet 512 bytes terug,
vervolgens het bestand is geëindigd in

44
00:02:34,450 --> 00:02:37,870
welk geval we uit de y breek
lus, of er een soort van fout

45
00:02:37,870 --> 00:02:40,300
In dat geval zullen we ook doorbreken
de y-lus, maar we willen rapporteren

46
00:02:40,300 --> 00:02:41,990
dat er iets mis ging.

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

48
00:02:42,290 --> 00:02:47,630
Dus de veronderstelling dat we met succes lezen
in 512 bytes, willen we eerst controleren

49
00:02:47,630 --> 00:02:53,070
ervoor dat deze bytes dat we
lees net in beginnen aan een JPEG.

50
00:02:53,070 --> 00:02:56,430
Dus als is JPEG header van onze buffer.

51
00:02:56,430 --> 00:02:58,460
Nu wat het JPEG header aan het doen?

52
00:02:58,460 --> 00:03:00,120
Laten we eens kijken.

53
00:03:00,120 --> 00:03:05,270
>> Hier zien we dat deze functie
terugsturen van een stier, en die stier -

54
00:03:05,270 --> 00:03:08,820
goed hier, we controleren om te zien of
header nul is gelijk aan deze constante en

55
00:03:08,820 --> 00:03:11,880
header een is deze constante en
header twee is deze constante,

56
00:03:11,880 --> 00:03:15,640
header drie is deze of deze
constant waar al deze constanten zijn

57
00:03:15,640 --> 00:03:20,340
gewoon hash hier gedefinieerd en zijn
precies wat we u verteld in de spec

58
00:03:20,340 --> 00:03:22,700
dat een JPEG begint met.

59
00:03:22,700 --> 00:03:27,300
En dus deze functie is slechts gaat
return true als deze buffer vertegenwoordigt

60
00:03:27,300 --> 00:03:31,750
de start van een nieuwe JPEG
en anders false.

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

62
00:03:32,520 --> 00:03:38,490
Dus als dit doet vertegenwoordigen een nieuwe JPEG,
dan we willen eerst controleren of

63
00:03:38,490 --> 00:03:42,030
JPEG-bestand is niet gelijk aan nul,
in welk geval we sluiten.

64
00:03:42,030 --> 00:03:44,940
En waarom hebben we nodig om te controleren
om te zien of het is niet nul?

65
00:03:44,940 --> 00:03:48,980
Nou, de eerste JPEG dat we
vinden we niet al

66
00:03:48,980 --> 00:03:50,440
een open JPEG-bestand.

67
00:03:50,440 --> 00:03:55,580
En dus, als we proberen te sluiten dat, dan
we zijn niet iets heel goed doen.

68
00:03:55,580 --> 00:03:59,090
>> Maar elke volgende JPEG dat
we openen, willen we sluiten

69
00:03:59,090 --> 00:04:00,710
het vorige bestand.

70
00:04:00,710 --> 00:04:04,630
Dus nu gaan we sprintf gebruiken als we
gezegd waar we met behulp van de

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

72
00:04:06,280 --> 00:04:09,870
En we gaan JPEG-bestand gebruiken
noemen formaat als onze formaat.

73
00:04:09,870 --> 00:04:12,030
En wat is dat?

74
00:04:12,030 --> 00:04:18,450
Hier zien we dat het percentage nul
3D.JPEG waar de nul drie net

75
00:04:18,450 --> 00:04:22,089
zegt dat we drie getallen zullen gebruiken
voor deze opgevuld met nullen.

76
00:04:22,089 --> 00:04:27,470
Dus dit is hoe we nul nul krijgt
one.JPEG en nul 10.JPEG enzovoort.

77
00:04:27,470 --> 00:04:29,060
>> We gaan sprintf gebruiken.

78
00:04:29,060 --> 00:04:33,760
En het getal dat we het invoegen
in de string is gevoelloos JPEG's

79
00:04:33,760 --> 00:04:36,380
teruggewonnen, wat van oorsprong nul.

80
00:04:36,380 --> 00:04:39,950
Dus het eerste bestand geopend gaat
te zijn nul nul nul dot JPEG.

81
00:04:39,950 --> 00:04:43,330
En dan zijn we het verhogen van het zo de
volgend bestand openen we zullen nul nul

82
00:04:43,330 --> 00:04:46,830
een punt JPEG en we zullen het verhogen
weer dus het zal nul nul twee dot be

83
00:04:46,830 --> 00:04:49,100
JPEG enzovoort.

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

85
00:04:49,850 --> 00:04:53,210
Dus nu de binnenkant van JPEG-bestand
te noemen, hebben we de naam van de

86
00:04:53,210 --> 00:04:54,990
bestand dat we willen.

87
00:04:54,990 --> 00:04:58,640
We kunnen f openen dat bestand voor schrijven.

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

89
00:04:59,170 --> 00:05:02,820
En nogmaals, we moeten controleren om ervoor te
ervoor dat het bestand met succes

90
00:05:02,820 --> 00:05:08,460
aangezien geopend als het niet, dan
er was een fout.

91
00:05:08,460 --> 00:05:13,100
>> Dus nu hebben we langs de gekregen
is dit een JPEG deel.

92
00:05:13,100 --> 00:05:16,390
En hier zien we we gaan
te schrijven aan de JPEG.

93
00:05:16,390 --> 00:05:20,980
Maar we moeten eerst deze controle die zegt
als JPEG-bestand is niet gelijk aan nul.

94
00:05:20,980 --> 00:05:22,490
Waarom hebben we dat nodig?

95
00:05:22,490 --> 00:05:28,020
Nou JPEG-bestand is gelijk aan nul als we
momenteel hebben een open JPEG.

96
00:05:28,020 --> 00:05:31,870
>> Wat als kaart dot ruwe start
met een bos van bytes die

97
00:05:31,870 --> 00:05:33,510
niet die van een JPEG?

98
00:05:33,510 --> 00:05:36,240
Dan gaan we willen
overslaan die bytes.

99
00:05:36,240 --> 00:05:39,600
Als we niet over deze controle, dan zijn we
gaat schrijven aan een ongeopende

100
00:05:39,600 --> 00:05:45,540
het dossier van de eerste 512 bytes van
de kaart die is niet goed.

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

102
00:05:46,030 --> 00:05:51,330
>> Dus de veronderstelling dat we er een open bestand, dan
we gaan schrijven dat het dossier van de

103
00:05:51,330 --> 00:05:53,290
512 bytes die we hebben in onze buffer.

104
00:05:53,290 --> 00:05:57,390
En we opnieuw controleren om ervoor te
ervoor dat de 512 bytes succes

105
00:05:57,390 --> 00:06:01,140
werden geschreven omdat als ze niet waren
succes geschreven, dan is er iets

106
00:06:01,140 --> 00:06:02,080
ging het mis.

107
00:06:02,080 --> 00:06:06,540
We zullen onze bestanden te sluiten, af te drukken dat
ging er iets mis, en terugkeer.

108
00:06:06,540 --> 00:06:10,940
Ervan uitgaande dat alles goed gaat correct, maar dan
we houden looping het sluiten van de

109
00:06:10,940 --> 00:06:15,060
oude bestand, het openen van het nieuwe bestand, schrijven
gegevens naar het nieuwe bestand, en dus

110
00:06:15,060 --> 00:06:20,990
op totdat uiteindelijk, deze f lezen
nul terug die middelen

111
00:06:20,990 --> 00:06:23,280
dat het bestand wordt uitgevoerd.

112
00:06:23,280 --> 00:06:28,490
>> Dus nu dat de kaart lezen is voorbij, we
zien dat we gaan f sluiten

113
00:06:28,490 --> 00:06:33,250
laatste bestand dat we open, maar
we controleren of JPEG-bestand

114
00:06:33,250 --> 00:06:34,900
is niet gelijk aan nul.

115
00:06:34,900 --> 00:06:39,520
Nou, de f dicht is logisch, want als
we openen van bestanden, we gaan sluiten

116
00:06:39,520 --> 00:06:43,870
het vorige bestand, maar de allerlaatste
bestand dat we geopend wordt nooit gesloten.

117
00:06:43,870 --> 00:06:45,580
Dus dat is wat dit doet.

118
00:06:45,580 --> 00:06:47,720
>> Maar waarom moeten wij om te controleren op nul?

119
00:06:47,720 --> 00:06:53,130
Tja, wat indien kaart dot ruwe niet
hebben een enkele JPEG binnenkant van het?

120
00:06:53,130 --> 00:06:56,640
In dat geval zouden we
nooit een bestand geopend.

121
00:06:56,640 --> 00:07:00,230
En als we nooit een bestand te openen, moeten we
niet proberen om dat bestand te sluiten.

122
00:07:00,230 --> 00:07:03,000
Dus dat is wat deze controle doet.

123
00:07:03,000 --> 00:07:07,880
>> Nu hier, zoals ik al zei, konden we
dat y lus ofwel als zijn uitgebroken

124
00:07:07,880 --> 00:07:13,520
de kaart is beëindigd of wanneer er
enkele fout bij het lezen van de kaart.

125
00:07:13,520 --> 00:07:16,680
Dus dit is het controleren om te zien of er
een fout bij het lezen van de kaart, in

126
00:07:16,680 --> 00:07:19,400
dat geval, zullen we daar zeggen
was een fout bij het lezen.

127
00:07:19,400 --> 00:07:22,130
We willen niet dat de gebruiker om na te denken
alles verliep succesvol.

128
00:07:22,130 --> 00:07:24,750
En we zullen een voor fout geretourneerd.

129
00:07:24,750 --> 00:07:29,580
>> Tot slot zullen we f onze ruwe bestand te sluiten,
onze kaart dot rauw, om aan te geven dat

130
00:07:29,580 --> 00:07:34,070
alles ging goed en de terugkeer
nul en dat is het.

131
00:07:34,070 --> 00:07:36,130
>> Mijn naam is Rob en dit was Recover.

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