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

2
00:00:00,494 --> 00:00:13,350
>> [MUSIK SPELA]

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

4
00:00:14,080 --> 00:00:17,550
Jag är Rob, och låt oss hoppas att
denna lösning hjälper sätta dig

5
00:00:17,550 --> 00:00:19,600
på vägen till återhämtning.

6
00:00:19,600 --> 00:00:22,700
Så låt oss komma igång.

7
00:00:22,700 --> 00:00:25,660
>> Vi ser att vi omedelbart är
bara att se till att vi är

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

9
00:00:27,170 --> 00:00:31,490
Så användningen ska bara vara något
som punkt snedstreck återhämta sig.

10
00:00:31,490 --> 00:00:35,500
>> Nu ska vi öppna den förväntade
kort dot raw-filen.

11
00:00:35,500 --> 00:00:39,740
Vi ser här att vi använder
konstant filnamn rå streck,

12
00:00:39,740 --> 00:00:44,200
som här uppe har vi hash
definierad 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åste se till att det
öppnat för om det

15
00:00:48,210 --> 00:00:51,150
inte, bör vi varna användaren.

16
00:00:51,150 --> 00:00:56,770
Men om man antar att den gjorde det, är vi nu
kommer att förklara en buffert av storlek JPEG

17
00:00:56,770 --> 00:00:58,170
filnamnslängd.

18
00:00:58,170 --> 00:01:02,060
Så det här kommer att bli den buffert som
vi ska sprintf in.

19
00:01:02,060 --> 00:01:04,360
>> Så vad är JPEG filnamnslängd?

20
00:01:04,360 --> 00:01:08,490
Här uppe, ser vi att det är
hash definieras som åtta.

21
00:01:08,490 --> 00:01:10,670
Så varför åtta?

22
00:01:10,670 --> 00:01:15,150
Jo en viss fil får namnet
något som noll noll noll.

23
00:01:15,150 --> 00:01:19,460
JPG och då behöver vi ett omvänt snedstreck noll.

24
00:01:19,460 --> 00:01:22,720
Så vi behöver en buffert som kan
lagra åtta tecken.

25
00:01:22,720 --> 00:01:25,190
Nu ska vi ha en räknare som är
kommer att hålla reda på

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

27
00:01:27,780 --> 00:01:31,590
>> Och slutligen kommer vi att ha en
JPEG-fil som är initialt noll

28
00:01:31,590 --> 00:01:35,920
som kommer att vara den för tillfället
öppna filen som vi skriver på.

29
00:01:35,920 --> 00:01:37,540
Nu ska vi ha
en ytterligare buffert.

30
00:01:37,540 --> 00:01:41,350
Detta är inte samma sak som vår sprintf
buffert där denna buffert är en

31
00:01:41,350 --> 00:01:45,020
att vi läser i data
från kortet dot rå.

32
00:01:45,020 --> 00:01:48,900
>> Så bufferten kommer att vara av
osignerade tecken, som du kan

33
00:01:48,900 --> 00:01:53,560
princip bara behandla oss byte, och det är
kommer att vara av storleksblockstorlek

34
00:01:53,560 --> 00:01:57,950
där, eftersom vi berätta,
blockstorlek är 512.

35
00:01:57,950 --> 00:02:03,070
Så JPEG-bilder som du kan behandla allt
som block av 512 bitgrupper.

36
00:02:03,070 --> 00:02:05,890
>> Nu ska vi slinga
över hela filen.

37
00:02:05,890 --> 00:02:12,980
Vi kommer att f läsa in vår buffert
en enda byte blocket storlek tider från

38
00:02:12,980 --> 00:02:14,710
kortet dot raw-filen.

39
00:02:14,710 --> 00:02:16,630
Nu vad f läser tillbaka?

40
00:02:16,630 --> 00:02:20,050
Den returnerar antalet objekt
att det framgångsrikt läsa.

41
00:02:20,050 --> 00:02:27,310
Så om det lyckats läsa 512 byte, då
vi önskar att se om detta var ett

42
00:02:27,310 --> 00:02:29,700
JPEG eller skriva den till en JPEG-fil.

43
00:02:29,700 --> 00:02:34,450
Och om det inte kom tillbaka 512 byte,
sedan antingen filen har slutat i

44
00:02:34,450 --> 00:02:37,870
då vi ska bryta ut y
slinga, eller om det finns någon form av fel

45
00:02:37,870 --> 00:02:40,300
i vilket fall kommer vi också bryta sig ur
y slingan, men vi vill rapportera

46
00:02:40,300 --> 00:02:41,990
att något gick fel.

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

48
00:02:42,290 --> 00:02:47,630
Så antar att vi lyckas läsa
på 512 byte, vi vill först kontrollera

49
00:02:47,630 --> 00:02:53,070
att göra att dessa byte som vi
bara läsa in påbörja en JPEG.

50
00:02:53,070 --> 00:02:56,430
Så om är JPEG rubriken på vår buffert.

51
00:02:56,430 --> 00:02:58,460
Nu vad det JPEG header gör?

52
00:02:58,460 --> 00:03:00,120
Låt oss titta.

53
00:03:00,120 --> 00:03:05,270
>> Här uppe, ser vi att denna funktion är
returnera en tjur, och att tjuren -

54
00:03:05,270 --> 00:03:08,820
bra här, vi kontrollera om
header noll är lika med detta konstant och

55
00:03:08,820 --> 00:03:11,880
header ett är lika med detta konstant och
header två är lika med denna konstant,

56
00:03:11,880 --> 00:03:15,640
header tre är lika med detta eller detta
konstant där alla dessa konstanter är

57
00:03:15,640 --> 00:03:20,340
precis hash definieras här och är
exakt vad vi sagt i spec

58
00:03:20,340 --> 00:03:22,700
att en JPEG börjar med.

59
00:03:22,700 --> 00:03:27,300
Och så den här funktionen är bara att
return true om denna buffert representerar

60
00:03:27,300 --> 00:03:31,750
början på en ny JPEG
och i annat fall false.

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

62
00:03:32,520 --> 00:03:38,490
Så om detta inte utgör en ny JPEG,
då vi först vill kontrollera om

63
00:03:38,490 --> 00:03:42,030
JPEG-fil är inte lika med noll,
i vilket fall vi stänga den.

64
00:03:42,030 --> 00:03:44,940
Och så varför behöver vi för att kontrollera
för att se om det inte är noll?

65
00:03:44,940 --> 00:03:48,980
Jo det första JPEG som vi
finner vi inte redan har

66
00:03:48,980 --> 00:03:50,440
en öppen JPEG-fil.

67
00:03:50,440 --> 00:03:55,580
Och så, om vi försöker stänga det, då
att vi inte gör något helt rätt.

68
00:03:55,580 --> 00:03:59,090
>> Men varje efterföljande JPEG som
vi öppnar, vi vill stänga

69
00:03:59,090 --> 00:04:00,710
föregående fil.

70
00:04:00,710 --> 00:04:04,630
Så nu ska vi använda sprintf som vi
sa innan där vi använder

71
00:04:04,630 --> 00:04:06,280
buffert JPEG filnamn.

72
00:04:06,280 --> 00:04:09,870
Och vi kommer att använda JPEG-fil
name format som vårt format.

73
00:04:09,870 --> 00:04:12,030
Och vad är det?

74
00:04:12,030 --> 00:04:18,450
Här uppe, ser vi att det är procent noll
3D.JPEG där noll tre bara

75
00:04:18,450 --> 00:04:22,089
säger att vi kommer att använda tre heltal
för detta utfylls med nollor.

76
00:04:22,089 --> 00:04:27,470
Så det här är hur vi ska få noll noll
one.JPEG och noll 10.JPEG och så vidare.

77
00:04:27,470 --> 00:04:29,060
>> Vi kommer att använda sprintf.

78
00:04:29,060 --> 00:04:33,760
Och det heltal som vi sätter i
i strängen är numb JPEG

79
00:04:33,760 --> 00:04:36,380
återvinnas, vilket är ursprungligen noll.

80
00:04:36,380 --> 00:04:39,950
Så den första filen öppnas går
vara noll noll noll dot JPEG.

81
00:04:39,950 --> 00:04:43,330
Och sedan vi uppräkning det så
nästa fil öppnar vi kommer att vara noll noll

82
00:04:43,330 --> 00:04:46,830
en prick JPEG och vi kommer att öka det
igen så det ska bli noll noll två dot

83
00:04:46,830 --> 00:04:49,100
JPEG och så vidare.

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

85
00:04:49,850 --> 00:04:53,210
Så nu insidan av JPEG-fil
namn, har vi namnet på den

86
00:04:53,210 --> 00:04:54,990
fil som vi vill ha.

87
00:04:54,990 --> 00:04:58,640
Vi kan f öppna filen för skrivning.

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

89
00:04:59,170 --> 00:05:02,820
Och än en gång, måste vi kontrollera att
Se till att filen framgångsrikt

90
00:05:02,820 --> 00:05:08,460
öppnats sedan om det inte gjorde det, då
det fanns vissa fel.

91
00:05:08,460 --> 00:05:13,100
>> Så nu har vi kommit förbi
detta är en JPEG-delen.

92
00:05:13,100 --> 00:05:16,390
Och här ser vi att vi ska
att skriva till JPEG.

93
00:05:16,390 --> 00:05:20,980
Men vi först har denna kontroll, som säger
Om JPEG-filen inte är lika med noll.

94
00:05:20,980 --> 00:05:22,490
Varför behöver vi det?

95
00:05:22,490 --> 00:05:28,020
Tja JPEG-fil är lika med noll när vi
för närvarande har en öppen JPEG.

96
00:05:28,020 --> 00:05:31,870
>> Tänk om kort dot rå starter
med en massa byte som

97
00:05:31,870 --> 00:05:33,510
representerar inte en JPEG?

98
00:05:33,510 --> 00:05:36,240
Sen ska vi vilja
hoppa över dessa bytes.

99
00:05:36,240 --> 00:05:39,600
Om vi ​​inte har denna kontroll, då är vi
ska skriva till en oöppnad

100
00:05:39,600 --> 00:05:45,540
lämna de första 512 byte av
kortet, som inte är bra.

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

102
00:05:46,030 --> 00:05:51,330
>> Så antar att vi har en öppen fil, sedan
vi kommer att skriva till den filen på

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

104
00:05:53,290 --> 00:05:57,390
Och vi återigen kontrollera för att
Se till att de 512 byte framgångsrikt

105
00:05:57,390 --> 00:06:01,140
skrevs för om de inte var
framgångsrikt skriven, då något

106
00:06:01,140 --> 00:06:02,080
gick fel.

107
00:06:02,080 --> 00:06:06,540
Vi stänger våra filer, skriva ut den
något gick fel, och retur.

108
00:06:06,540 --> 00:06:10,940
Förutsatt att allt går rätt, då
Vi ska hålla looping stänga

109
00:06:10,940 --> 00:06:15,060
gamla filen, öppna den nya filen, skrift
data till den nya filen, och så

110
00:06:15,060 --> 00:06:20,990
på tills slutligen, detta f läsa
returnerar noll som medel

111
00:06:20,990 --> 00:06:23,280
att filen är gjort.

112
00:06:23,280 --> 00:06:28,490
>> Så nu att kort behandlingen är över, vi
ser att vi kommer att f stänga

113
00:06:28,490 --> 00:06:33,250
sista filen som vi hade öppet, men
Vi kollar om JPEG-fil

114
00:06:33,250 --> 00:06:34,900
inte lika med noll.

115
00:06:34,900 --> 00:06:39,520
Tja f nära vettigt eftersom som
vi öppnar filer, vi stänger

116
00:06:39,520 --> 00:06:43,870
den tidigare filen, men den allra sista
fil som vi öppnade aldrig blir stängd.

117
00:06:43,870 --> 00:06:45,580
Så det är vad det gör.

118
00:06:45,580 --> 00:06:47,720
>> Men varför måste vi kontrollera null?

119
00:06:47,720 --> 00:06:53,130
Tja vad händer om kort prick rå inte
har en enda JPEG insidan av det?

120
00:06:53,130 --> 00:06:56,640
I så fall skulle vi ha
aldrig öppnat en fil.

121
00:06:56,640 --> 00:07:00,230
Och om vi öppnar aldrig en fil, bör vi
inte försöker stänga den filen.

122
00:07:00,230 --> 00:07:03,000
Så det är vad denna kontroll gör.

123
00:07:03,000 --> 00:07:07,880
>> Nu här, som jag sa tidigare, vi kunde
har brutit ut att y slinga antingen om

124
00:07:07,880 --> 00:07:13,520
kortet är avslutad eller om det finns
några fel vid läsning från kortet.

125
00:07:13,520 --> 00:07:16,680
Så detta är kontroll för att se om det fanns
ett fel vid läsning från kortet, i

126
00:07:16,680 --> 00:07:19,400
vilket fall, vi säger att det
Ett fel läsning.

127
00:07:19,400 --> 00:07:22,130
Vi vill inte att användaren att tänka
allt gick utan problem.

128
00:07:22,130 --> 00:07:24,750
Och vi kommer att återvända en för fel.

129
00:07:24,750 --> 00:07:29,580
>> Slutligen ska vi f stänga vår raw-filen,
våra kort dot rå, för att indikera att

130
00:07:29,580 --> 00:07:34,070
allt gick bra och retur
noll och det är det.

131
00:07:34,070 --> 00:07:36,130
>> Mitt namn är Rob och detta var Recover.

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