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

2
00:00:00,494 --> 00:00:13,350
>> [Música tocando]

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

4
00:00:14,080 --> 00:00:17,550
Estou Rob, e vamos esperar que
esta solução ajuda a colocá-lo

5
00:00:17,550 --> 00:00:19,600
no caminho para a recuperação.

6
00:00:19,600 --> 00:00:22,700
Então, vamos começar.

7
00:00:22,700 --> 00:00:25,660
>> Vemos que estamos imediatamente
só para ter certeza de que estamos

8
00:00:25,660 --> 00:00:27,170
Recuperar usando corretamente.

9
00:00:27,170 --> 00:00:31,490
Assim, o uso deve ser apenas algo
como barra dot recuperar.

10
00:00:31,490 --> 00:00:35,500
>> Agora vamos abrir o esperado
cartão de ponto arquivo raw.

11
00:00:35,500 --> 00:00:39,740
Vemos aqui que estamos usando a
constante nome do arquivo sublinhado cru,

12
00:00:39,740 --> 00:00:44,200
que até aqui temos de hash
definido como cartão de ponto cru.

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

14
00:00:45,030 --> 00:00:48,210
>> Por isso, precisamos ter certeza de que isso
aberto com sucesso porque se

15
00:00:48,210 --> 00:00:51,150
não, então devemos avisar o usuário.

16
00:00:51,150 --> 00:00:56,770
Mas supondo que ele fez, agora estamos
vai declarar um buffer de tamanho JPEG

17
00:00:56,770 --> 00:00:58,170
arquivo comprimento do nome.

18
00:00:58,170 --> 00:01:02,060
Portanto, este vai ser o tampão que
vamos em sprintf.

19
00:01:02,060 --> 00:01:04,360
>> Então o que é JPEG arquivo comprimento do nome?

20
00:01:04,360 --> 00:01:08,490
Até aqui, vemos que é
botar definido como oito.

21
00:01:08,490 --> 00:01:10,670
Então, por oito anos?

22
00:01:10,670 --> 00:01:15,150
Bem um determinado arquivo será nomeado
algo como zero zero zero.

23
00:01:15,150 --> 00:01:19,460
JPG e então precisamos de uma barra invertida zero.

24
00:01:19,460 --> 00:01:22,720
Então precisamos de um buffer que pode
armazenar oito caracteres.

25
00:01:22,720 --> 00:01:25,190
Agora nós vamos ter um contador que é
vai acompanhar o

26
00:01:25,190 --> 00:01:27,780
JPEGs número que encontramos.

27
00:01:27,780 --> 00:01:31,590
>> E, finalmente, vamos ter um
Arquivo JPEG que é inicialmente nula

28
00:01:31,590 --> 00:01:35,920
qual vai ser o momento
arquivo aberto que estamos escrevendo.

29
00:01:35,920 --> 00:01:37,540
Agora nós vamos ter
um tampão adicional.

30
00:01:37,540 --> 00:01:41,350
Este não é o mesmo que o nosso sprintf
buffer onde esse buffer é aquele

31
00:01:41,350 --> 00:01:45,020
que estamos lendo nos dados
do cartão de ponto cru.

32
00:01:45,020 --> 00:01:48,900
>> Assim, o tampão será de
caracteres não assinados, que você pode

33
00:01:48,900 --> 00:01:53,560
basicamente apenas nos tratam bytes, e é
vai ser do tamanho do tamanho do bloco

34
00:01:53,560 --> 00:01:57,950
onde, como lhe digo,
tamanho do bloco é 512.

35
00:01:57,950 --> 00:02:03,070
Então JPEGs você pode tratar de tudo
como blocos de 512 bytes.

36
00:02:03,070 --> 00:02:05,890
>> Agora vamos fazer um loop
sobre o arquivo inteiro.

37
00:02:05,890 --> 00:02:12,980
Vamos f ler em nosso buffer
um único byte vezes tamanho do bloco de

38
00:02:12,980 --> 00:02:14,710
o cartão de ponto arquivo raw.

39
00:02:14,710 --> 00:02:16,630
Agora, o que f ler voltar?

40
00:02:16,630 --> 00:02:20,050
Ele retorna o número de itens
que lida com êxito.

41
00:02:20,050 --> 00:02:27,310
Então, se ele conseguiu ler 512 bytes, em seguida,
queremos ver se este era um

42
00:02:27,310 --> 00:02:29,700
JPEG ou gravá-lo em um arquivo JPEG.

43
00:02:29,700 --> 00:02:34,450
E se ele não voltar 512 bytes,
em seguida, o arquivo terminou em

44
00:02:34,450 --> 00:02:37,870
caso em que nós vamos sair do y
loop, ou se há algum tipo de erro

45
00:02:37,870 --> 00:02:40,300
caso em que também vai sair da
o loop y, mas vamos querer denunciar

46
00:02:40,300 --> 00:02:41,990
que algo deu errado.

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

48
00:02:42,290 --> 00:02:47,630
Assim, supondo que lemos com sucesso
em 512 bytes, queremos primeiro cheque

49
00:02:47,630 --> 00:02:53,070
para fazer que estes bytes que
acabei de ler em começar um JPEG.

50
00:02:53,070 --> 00:02:56,430
Então, se é cabeçalho JPEG do nosso buffer.

51
00:02:56,430 --> 00:02:58,460
Agora, o que é cabeçalho JPEG fazendo?

52
00:02:58,460 --> 00:03:00,120
Vamos dar uma olhada.

53
00:03:00,120 --> 00:03:05,270
>> Até aqui, vemos que esta função é
retornando um touro, e aquele touro -

54
00:03:05,270 --> 00:03:08,820
bem aqui, estamos verificando se
cabeçalho de zero é igual a este constante e

55
00:03:08,820 --> 00:03:11,880
cabeçalho um é igual a esta constante e
cabeçalho dois é igual a esta constante,

56
00:03:11,880 --> 00:03:15,640
cabeçalho de três é igual a este ou esta
constante, onde todos estes são constantes

57
00:03:15,640 --> 00:03:20,340
só botar definido aqui e são
exatamente o que nós dissemos-lhe na especificação

58
00:03:20,340 --> 00:03:22,700
que começa com um formato JPEG.

59
00:03:22,700 --> 00:03:27,300
E assim, esta função só vai
return true se este tampão representa

60
00:03:27,300 --> 00:03:31,750
o início de um novo JPEG
e falso caso contrário.

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

62
00:03:32,520 --> 00:03:38,490
Então, se isso não representa um novo JPEG,
então primeiro quero verificar para ver se

63
00:03:38,490 --> 00:03:42,030
Arquivo JPEG não é igual a zero,
caso em que o fechar.

64
00:03:42,030 --> 00:03:44,940
E assim, por que precisamos de verificar
para ver se não é nulo?

65
00:03:44,940 --> 00:03:48,980
Bem, a primeira JPEG que nós
encontrar não vamos já tem

66
00:03:48,980 --> 00:03:50,440
um arquivo JPEG aberto.

67
00:03:50,440 --> 00:03:55,580
E assim, se tentar fechar isso, então
nós não estamos fazendo algo certo.

68
00:03:55,580 --> 00:03:59,090
>> Mas cada JPEG subseqüente que
abrirmos, queremos fechar

69
00:03:59,090 --> 00:04:00,710
o arquivo anterior.

70
00:04:00,710 --> 00:04:04,630
Então agora nós vamos usar sprintf como nós
disse antes, onde estamos usando a

71
00:04:04,630 --> 00:04:06,280
nome do arquivo JPEG tampão.

72
00:04:06,280 --> 00:04:09,870
E nós vamos usar arquivo JPEG
formato de nome como o nosso formato.

73
00:04:09,870 --> 00:04:12,030
E o que é isso?

74
00:04:12,030 --> 00:04:18,450
Até aqui, vemos que ela é zero por cento
3D.JPEG onde a três zero apenas

75
00:04:18,450 --> 00:04:22,089
diz que usaremos três inteiros
para este preenchido com zeros.

76
00:04:22,089 --> 00:04:27,470
Então é assim que nós vamos chegar zero zero
one.JPEG e de zero 10.JPEG e assim por diante.

77
00:04:27,470 --> 00:04:29,060
>> Nós vamos usar sprintf.

78
00:04:29,060 --> 00:04:33,760
E o inteiro que estamos inserindo
na seqüência é JPEGs dormentes

79
00:04:33,760 --> 00:04:36,380
recuperado, o qual é inicialmente zero.

80
00:04:36,380 --> 00:04:39,950
Assim, o primeiro arquivo aberto vai
para ser zero zero zero ponto JPEG.

81
00:04:39,950 --> 00:04:43,330
E depois vamos incrementá-lo de modo que o
próxima imagem abrimos será zero zero

82
00:04:43,330 --> 00:04:46,830
um ponto JPEG e vamos incrementá-lo
novamente por isso vai ser zero zero dois ponto

83
00:04:46,830 --> 00:04:49,100
JPEG e assim por diante.

84
00:04:49,100 --> 00:04:49,850
>> Tudo bem.

85
00:04:49,850 --> 00:04:53,210
Então, agora o interior de arquivo JPEG
nomear, temos o nome do

86
00:04:53,210 --> 00:04:54,990
arquivo que nós queremos.

87
00:04:54,990 --> 00:04:58,640
Podemos f abrir esse arquivo para a escrita.

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

89
00:04:59,170 --> 00:05:02,820
E mais uma vez, é preciso verificar para se
Certifique-se de que o arquivo com sucesso

90
00:05:02,820 --> 00:05:08,460
aberto, pois se ele não o fez, em seguida,
houve algum erro.

91
00:05:08,460 --> 00:05:13,100
>> Portanto, agora temos obtido após a
isso é uma parte JPEG.

92
00:05:13,100 --> 00:05:16,390
E aqui, vemos que vamos
para escrever para o JPEG.

93
00:05:16,390 --> 00:05:20,980
Mas primeiro temos essa verificação, que diz
se o arquivo JPEG não é igual a nulo.

94
00:05:20,980 --> 00:05:22,490
Por que precisamos disso?

95
00:05:22,490 --> 00:05:28,020
Bem arquivo JPEG é igual a zero quando
tem atualmente um JPEG aberto.

96
00:05:28,020 --> 00:05:31,870
>> E se cartão ponto começa matérias
com um monte de bytes que

97
00:05:31,870 --> 00:05:33,510
não representam um JPEG?

98
00:05:33,510 --> 00:05:36,240
Então nós vamos querer
pular sobre esses bytes.

99
00:05:36,240 --> 00:05:39,600
Se não temos essa verificação, então estamos
vai escrever a um fechado

100
00:05:39,600 --> 00:05:45,540
apresentar os primeiros 512 bytes de
o cartão que não é bom.

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

102
00:05:46,030 --> 00:05:51,330
>> Assim, supondo que temos um arquivo aberto, em seguida,
vamos escrever para o arquivo a

103
00:05:51,330 --> 00:05:53,290
512 bytes que dispomos no nosso buffer.

104
00:05:53,290 --> 00:05:57,390
E estamos mais uma vez para fazer a verificação
Certifique-se de que os 512 bytes com sucesso

105
00:05:57,390 --> 00:06:01,140
foram escritas, porque se não fossem
escrito com sucesso, então algo

106
00:06:01,140 --> 00:06:02,080
deu errado.

107
00:06:02,080 --> 00:06:06,540
Vamos fechar os arquivos, imprima que
algo deu errado, e retorno.

108
00:06:06,540 --> 00:06:10,940
Assumindo que tudo vai corretamente,
vamos continuar fechando o looping

109
00:06:10,940 --> 00:06:15,060
arquivo antigo, abrindo o novo arquivo, a escrita
dados para o novo arquivo, e assim

110
00:06:15,060 --> 00:06:20,990
até que, finalmente, este f ler
retorna zero, o que significa

111
00:06:20,990 --> 00:06:23,280
que o arquivo é feito.

112
00:06:23,280 --> 00:06:28,490
>> Portanto, agora que a leitura do cartão é mais, nós
ver que nós vamos fechar a f

113
00:06:28,490 --> 00:06:33,250
último arquivo que tínhamos aberto, mas
estamos verificando se o arquivo JPEG

114
00:06:33,250 --> 00:06:34,900
não é igual a nulo.

115
00:06:34,900 --> 00:06:39,520
Bem, o próximo f faz sentido porque, como
estamos abrindo arquivos, estamos fechando

116
00:06:39,520 --> 00:06:43,870
o arquivo anterior, mas o último
arquivo que abrimos nunca fica fechada.

117
00:06:43,870 --> 00:06:45,580
Então, isso é o que este está fazendo.

118
00:06:45,580 --> 00:06:47,720
>> Mas por que é preciso verificar para null?

119
00:06:47,720 --> 00:06:53,130
Bem, o que se o cartão de ponto-prima não
ter um único JPEG dentro dele?

120
00:06:53,130 --> 00:06:56,640
Nesse caso, teríamos
nunca abriu um arquivo.

121
00:06:56,640 --> 00:07:00,230
E se nós nunca abrir um arquivo, devemos
não tentar fechar esse arquivo.

122
00:07:00,230 --> 00:07:03,000
Então é isso que esta verificação está fazendo.

123
00:07:03,000 --> 00:07:07,880
>> Agora aqui, como eu disse antes, nós poderíamos
eclodiram que y laço ou se

124
00:07:07,880 --> 00:07:13,520
o cartão tiver terminado, ou se existem
algum erro de leitura do cartão.

125
00:07:13,520 --> 00:07:16,680
Portanto, esta é a verificação para ver se havia
um erro de leitura do cartão, em

126
00:07:16,680 --> 00:07:19,400
caso em que, vamos dizer que não
foi um erro ao ler.

127
00:07:19,400 --> 00:07:22,130
Nós não queremos que o usuário a pensar
tudo correu com sucesso.

128
00:07:22,130 --> 00:07:24,750
E nós vamos voltar um para o erro.

129
00:07:24,750 --> 00:07:29,580
>> Por fim, vamos f fechar nosso arquivo raw,
nosso cartão de ponto cru, para indicar que

130
00:07:29,580 --> 00:07:34,070
tudo correu bem e retorno
zero e é isso.

131
00:07:34,070 --> 00:07:36,130
>> Meu nome é Rob e esta foi Recover.

132
00:07:36,130 --> 00:07:42,102
>> [Música tocando]