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

2
00:00:00,494 --> 00:00:13,350
>> [MUSIQUE JEU]

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

4
00:00:14,080 --> 00:00:17,550
Je suis Rob, et espérons que
cette solution vous aide à mettre

5
00:00:17,550 --> 00:00:19,600
sur la voie de la reprise.

6
00:00:19,600 --> 00:00:22,700
Donc, nous allons commencer.

7
00:00:22,700 --> 00:00:25,660
>> Nous voyons que nous sommes immédiatement
juste pour s'assurer que nous sommes

8
00:00:25,660 --> 00:00:27,170
utilisant récupérer correctement.

9
00:00:27,170 --> 00:00:31,490
Donc, l'utilisation devrait juste être quelque chose
comme slash dot récupérer.

10
00:00:31,490 --> 00:00:35,500
>> Maintenant, nous allons ouvrir le prévu
carte dot fichier brut.

11
00:00:35,500 --> 00:00:39,740
Nous voyons ici que nous utilisons la
nom de fichier de soulignement première constante,

12
00:00:39,740 --> 00:00:44,200
qui ici nous avons hachage
définie comme carte dot brut.

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

14
00:00:45,030 --> 00:00:48,210
>> Donc, nous devons faire en sorte que cette
ouvert avec succès parce que si elle

15
00:00:48,210 --> 00:00:51,150
n'avons pas, alors nous devrions avertir l'utilisateur.

16
00:00:51,150 --> 00:00:56,770
Mais en supposant qu'il a fait, nous sommes maintenant
va déclarer un tampon de taille JPEG

17
00:00:56,770 --> 00:00:58,170
le nom de fichier long.

18
00:00:58,170 --> 00:01:02,060
Donc cela va être le tampon
nous allons sprintf en.

19
00:01:02,060 --> 00:01:04,360
>> Alors, quel est le nom de fichier JPEG longueur?

20
00:01:04,360 --> 00:01:08,490
Ici, nous voyons que c'est
hachage définie comme huit.

21
00:01:08,490 --> 00:01:10,670
Alors pourquoi huit?

22
00:01:10,670 --> 00:01:15,150
Eh bien un fichier donné sera nommé
quelque chose comme zéro zéro zéro.

23
00:01:15,150 --> 00:01:19,460
JPG et nous avons besoin d'une barre oblique inverse zéro.

24
00:01:19,460 --> 00:01:22,720
Nous avons donc besoin d'un tampon qui peut
stocker huit caractères.

25
00:01:22,720 --> 00:01:25,190
Maintenant, nous allons avoir un compteur qui est
va garder une trace de l'

26
00:01:25,190 --> 00:01:27,780
nombre JPEG nous avons trouvé.

27
00:01:27,780 --> 00:01:31,590
>> Et enfin, nous allons avoir un
Fichier JPEG qui est initialement nulle

28
00:01:31,590 --> 00:01:35,920
qui va être le moment
fichier ouvert que nous écrivant à.

29
00:01:35,920 --> 00:01:37,540
Maintenant, nous allons avoir
un tampon supplémentaire.

30
00:01:37,540 --> 00:01:41,350
Ce n'est pas le même que notre sprintf
tampon où ce tampon est une

31
00:01:41,350 --> 00:01:45,020
que nous lisons dans les données
de la carte dot brut.

32
00:01:45,020 --> 00:01:48,900
>> Donc, le tampon va être d'
caractères non signés, que vous pouvez

33
00:01:48,900 --> 00:01:53,560
essentiellement traiter juste nous octets, et c'est
va être d'une taille de bloc de taille

34
00:01:53,560 --> 00:01:57,950
où, comme nous vous le disons,
taille de bloc est de 512.

35
00:01:57,950 --> 00:02:03,070
Donc, JPEG, vous pouvez traiter tout
sous forme de blocs de 512 octets.

36
00:02:03,070 --> 00:02:05,890
>> Maintenant, nous allons à la boucle
sur l'ensemble du dossier.

37
00:02:05,890 --> 00:02:12,980
Nous allons f lire dans notre buffer
une seule fois de la taille de bloc d'octets à partir de

38
00:02:12,980 --> 00:02:14,710
la carte dot fichier brut.

39
00:02:14,710 --> 00:02:16,630
Maintenant qu'est-ce que f lu revenir?

40
00:02:16,630 --> 00:02:20,050
Elle renvoie le nombre d'éléments
qu'il a lu avec succès.

41
00:02:20,050 --> 00:02:27,310
Donc, si il a réussi à lire 512 octets, alors
nous voulons voir s'il s'agissait d'une

42
00:02:27,310 --> 00:02:29,700
JPEG ou écrire dans un fichier JPEG.

43
00:02:29,700 --> 00:02:34,450
Et si elle ne revenait pas 512 octets,
alors soit le fichier a terminé en

44
00:02:34,450 --> 00:02:37,870
auquel cas nous allons faire une pause de la y
boucle, ou il ya une sorte d'erreur

45
00:02:37,870 --> 00:02:40,300
dans ce cas, nous allons également sortir de
la boucle de y, mais nous voulons signaler

46
00:02:40,300 --> 00:02:41,990
que quelque chose n'allait pas.

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

48
00:02:42,290 --> 00:02:47,630
Donc, en supposant que nous lisons avec succès
en 512 octets, nous voulons d'abord vérifier

49
00:02:47,630 --> 00:02:53,070
de faire que ces octets que nous
il suffit de lire en commencer une JPEG.

50
00:02:53,070 --> 00:02:56,430
Donc, si c'est en-tête JPEG de notre tampon.

51
00:02:56,430 --> 00:02:58,460
Maintenant ce qu'il est tête JPEG faire?

52
00:02:58,460 --> 00:03:00,120
Voyons.

53
00:03:00,120 --> 00:03:05,270
>> Ici, nous voyons que cette fonction est
retour d'un taureau, et le taureau -

54
00:03:05,270 --> 00:03:08,820
bien ici, nous vérifions pour voir si
tête zéro égal à cette constante et

55
00:03:08,820 --> 00:03:11,880
tête un égal à cette constante et
tête de deux égal à cette constante,

56
00:03:11,880 --> 00:03:15,640
tête à trois est égal à ce ou cette
constante où tous ces constantes sont

57
00:03:15,640 --> 00:03:20,340
juste hachage défini ici et sont
exactement ce que nous vous avons dit dans la spécification

58
00:03:20,340 --> 00:03:22,700
qu'un JPEG commence par.

59
00:03:22,700 --> 00:03:27,300
Et si cette fonction va juste
return true si ce tampon représente

60
00:03:27,300 --> 00:03:31,750
le début d'une nouvelle JPEG
et false sinon.

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

62
00:03:32,520 --> 00:03:38,490
Donc, si cela ne représente une nouvelle JPEG,
alors nous voulons d'abord vérifier si

63
00:03:38,490 --> 00:03:42,030
Fichier JPEG n'est pas égale à zéro,
dans ce cas, nous fermons.

64
00:03:42,030 --> 00:03:44,940
Et pourquoi avons-nous besoin de vérifier
pour voir si elle n'est pas nulle?

65
00:03:44,940 --> 00:03:48,980
Eh bien la première JPEG que nous
trouver nous n'aurons pas déjà

66
00:03:48,980 --> 00:03:50,440
un fichier JPEG ouvert.

67
00:03:50,440 --> 00:03:55,580
Et donc, si nous essayons de combler ce, alors
nous ne faisons pas quelque chose de tout à fait raison.

68
00:03:55,580 --> 00:03:59,090
>> Mais chaque JPEG ultérieure que
nous ouvrons, nous voulons fermer

69
00:03:59,090 --> 00:04:00,710
le fichier précédent.

70
00:04:00,710 --> 00:04:04,630
Alors maintenant, nous allons utiliser sprintf que nous
dit avant où nous utilisons la

71
00:04:04,630 --> 00:04:06,280
nom de fichier JPEG tampon.

72
00:04:06,280 --> 00:04:09,870
Et nous allons utiliser un fichier JPEG
nommer format que notre forme.

73
00:04:09,870 --> 00:04:12,030
Et qu'est-ce que c'est?

74
00:04:12,030 --> 00:04:18,450
Ici, nous voyons qu'il est zéro pour cent
3D.jpeg où le zéro trois juste

75
00:04:18,450 --> 00:04:22,089
dit que nous allons utiliser trois entiers
pour cette complétées par des zéros.

76
00:04:22,089 --> 00:04:27,470
Voilà donc comment nous allons obtenir zéro zéro
one.JPEG et 10.jpeg zéro et ainsi de suite.

77
00:04:27,470 --> 00:04:29,060
>> Nous allons utiliser sprintf.

78
00:04:29,060 --> 00:04:33,760
Et le nombre entier que nous insertion
dans la chaîne est JPEG engourdis

79
00:04:33,760 --> 00:04:36,380
récupéré, qui est à l'origine zéro.

80
00:04:36,380 --> 00:04:39,950
Ainsi, le premier fichier ouvert se passe
à zéro zéro point zéro JPEG.

81
00:04:39,950 --> 00:04:43,330
Et puis nous incrémentation de sorte que le
l'image suivante nous ouvrons sera zéro zéro

82
00:04:43,330 --> 00:04:46,830
un point JPEG et nous incrémentons
encore si ce sera zéro zéro deux points

83
00:04:46,830 --> 00:04:49,100
JPEG et ainsi de suite.

84
00:04:49,100 --> 00:04:49,850
>> Très bien.

85
00:04:49,850 --> 00:04:53,210
Alors maintenant, l'intérieur du fichier JPEG
nom, nous avons le nom de l'

86
00:04:53,210 --> 00:04:54,990
déposons que nous voulons.

87
00:04:54,990 --> 00:04:58,640
Nous pouvons f ouvrir ce fichier pour l'écriture.

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

89
00:04:59,170 --> 00:05:02,820
Et encore une fois, nous devons vérifier pour vous
Vérifiez que le fichier avec succès

90
00:05:02,820 --> 00:05:08,460
ouvert car si elle n'a pas, alors
il y avait une erreur.

91
00:05:08,460 --> 00:05:13,100
>> Alors maintenant, nous avons obtenu le passé
est-ce une partie JPEG.

92
00:05:13,100 --> 00:05:16,390
Et ici, nous voyons que nous allons
d'écrire sur le JPEG.

93
00:05:16,390 --> 00:05:20,980
Mais nous devons d'abord cette vérification qui dit
si le fichier JPEG n'est pas égal à zéro.

94
00:05:20,980 --> 00:05:22,490
Pourquoi avons-nous besoin de cela?

95
00:05:22,490 --> 00:05:28,020
Bien fichier JPEG est égale à zéro lorsque nous
ont actuellement un JPEG ouvert.

96
00:05:28,020 --> 00:05:31,870
>> Que faire si la carte commence points premières
avec un groupe d'octets

97
00:05:31,870 --> 00:05:33,510
ne représentent pas un JPEG?

98
00:05:33,510 --> 00:05:36,240
Ensuite, nous allons vouloir
sauter par-dessus les octets.

99
00:05:36,240 --> 00:05:39,600
Si nous n'avons pas cette vérification, nous sommes
va écrire dans un ouvert

100
00:05:39,600 --> 00:05:45,540
déposer les 512 premiers octets de
la carte qui n'est pas bon.

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

102
00:05:46,030 --> 00:05:51,330
>> Donc, en supposant que nous avons un fichier ouvert, alors
nous allons écrire dans ce fichier la

103
00:05:51,330 --> 00:05:53,290
512 octets que nous avons dans notre mémoire tampon.

104
00:05:53,290 --> 00:05:57,390
Et nous sommes encore une fois la vérification pour s'assurer
s'assurer que les 512 octets succès

105
00:05:57,390 --> 00:06:01,140
ont été écrit parce que si elles n'étaient pas
écrit avec succès, alors quelque chose

106
00:06:01,140 --> 00:06:02,080
qui a mal tourné.

107
00:06:02,080 --> 00:06:06,540
Nous fermons nos fichiers, imprimer que
quelque chose s'est mal passé, et retour.

108
00:06:06,540 --> 00:06:10,940
En supposant que tout se passe bien, alors
nous allons continuer à boucle de fermeture du

109
00:06:10,940 --> 00:06:15,060
ancien fichier, ouvrir le nouveau fichier, l'écriture
données dans le nouveau fichier, et ainsi

110
00:06:15,060 --> 00:06:20,990
jusqu'à ce que finalement, ce f lu
renvoie zéro qui aide

111
00:06:20,990 --> 00:06:23,280
que le dossier est fait.

112
00:06:23,280 --> 00:06:28,490
>> Alors, maintenant que la lecture de la carte est terminée, nous
voyons que nous allons fermer la f

113
00:06:28,490 --> 00:06:33,250
dernier fichier que nous avions ouvert, mais
nous vérifions si le fichier JPEG

114
00:06:33,250 --> 00:06:34,900
n'est pas égal à zéro.

115
00:06:34,900 --> 00:06:39,520
Eh bien la f près de sens parce que
nous allons ouvrir des fichiers, on ferme

116
00:06:39,520 --> 00:06:43,870
le fichier précédent, mais la dernière
fichier que nous avons ouvert obtient jamais fermé.

117
00:06:43,870 --> 00:06:45,580
C'est ce que ce fait.

118
00:06:45,580 --> 00:06:47,720
>> Mais pourquoi nous devons vérifier pour nulle?

119
00:06:47,720 --> 00:06:53,130
Eh bien si la carte n'a pas de point brut
avoir un seul JPEG à l'intérieur de celui-ci?

120
00:06:53,130 --> 00:06:56,640
Dans ce cas, nous aurions
jamais ouvert un fichier.

121
00:06:56,640 --> 00:07:00,230
Et si nous n'avons jamais ouvrir un fichier, nous devrions
pas essayer de refermer ce dossier.

122
00:07:00,230 --> 00:07:03,000
C'est ce que ce contrôle est fait.

123
00:07:03,000 --> 00:07:07,880
>> Ici, comme je l'ai déjà dit, nous avons pu
ont éclaté cette boucle y soit si

124
00:07:07,880 --> 00:07:13,520
la carte est terminé ou si il ya
une erreur de lecture de la carte.

125
00:07:13,520 --> 00:07:16,680
Donc vérifie pour voir s'il y avait
une erreur de lecture de la carte, dans

126
00:07:16,680 --> 00:07:19,400
auquel cas, nous y disons
était une erreur de lecture.

127
00:07:19,400 --> 00:07:22,130
Nous ne voulons pas que l'utilisateur pense
tout marche bien.

128
00:07:22,130 --> 00:07:24,750
Et nous reviendrons un droit à l'erreur.

129
00:07:24,750 --> 00:07:29,580
>> Enfin, nous terminons notre f fichier brut,
notre carte dot brut, pour indiquer que

130
00:07:29,580 --> 00:07:34,070
tout s'est bien passé et le retour
zéro et c'est tout.

131
00:07:34,070 --> 00:07:36,130
>> Mon nom est Rob et c'était récupérer.

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