>> [Música tocando]
>> ROB BOWDEN: Oi.
Estou Rob, e vamos esperar que esta solução ajuda a colocá-lo
no caminho para a recuperação.
Então, vamos começar.
>> Vemos que estamos imediatamente só para ter certeza de que estamos
Recuperar usando corretamente.
Assim, o uso deve ser apenas algo como barra dot recuperar.
>> Agora vamos abrir o esperado cartão de ponto arquivo raw.
Vemos aqui que estamos usando a constante nome do arquivo sublinhado cru,
que até aqui temos de hash definido como cartão de ponto cru.
OK.
>> Por isso, precisamos ter certeza de que isso aberto com sucesso porque se
não, então devemos avisar o usuário.
Mas supondo que ele fez, agora estamos vai declarar um buffer de tamanho JPEG
arquivo comprimento do nome.
Portanto, este vai ser o tampão que vamos em sprintf.
>> Então o que é JPEG arquivo comprimento do nome?
Até aqui, vemos que é botar definido como oito.
Então, por oito anos?
Bem um determinado arquivo será nomeado algo como zero zero zero.
JPG e então precisamos de uma barra invertida zero.
Então precisamos de um buffer que pode armazenar oito caracteres.
Agora nós vamos ter um contador que é vai acompanhar o
JPEGs número que encontramos.
>> E, finalmente, vamos ter um Arquivo JPEG que é inicialmente nula
qual vai ser o momento arquivo aberto que estamos escrevendo.
Agora nós vamos ter um tampão adicional.
Este não é o mesmo que o nosso sprintf buffer onde esse buffer é aquele
que estamos lendo nos dados do cartão de ponto cru.
>> Assim, o tampão será de caracteres não assinados, que você pode
basicamente apenas nos tratam bytes, e é vai ser do tamanho do tamanho do bloco
onde, como lhe digo, tamanho do bloco é 512.
Então JPEGs você pode tratar de tudo como blocos de 512 bytes.
>> Agora vamos fazer um loop sobre o arquivo inteiro.
Vamos f ler em nosso buffer um único byte vezes tamanho do bloco de
o cartão de ponto arquivo raw.
Agora, o que f ler voltar?
Ele retorna o número de itens que lida com êxito.
Então, se ele conseguiu ler 512 bytes, em seguida, queremos ver se este era um
JPEG ou gravá-lo em um arquivo JPEG.
E se ele não voltar 512 bytes, em seguida, o arquivo terminou em
caso em que nós vamos sair do y loop, ou se há algum tipo de erro
caso em que também vai sair da o loop y, mas vamos querer denunciar
que algo deu errado.
>> OK.
Assim, supondo que lemos com sucesso em 512 bytes, queremos primeiro cheque
para fazer que estes bytes que acabei de ler em começar um JPEG.
Então, se é cabeçalho JPEG do nosso buffer.
Agora, o que é cabeçalho JPEG fazendo?
Vamos dar uma olhada.
>> Até aqui, vemos que esta função é retornando um touro, e aquele touro -
bem aqui, estamos verificando se cabeçalho de zero é igual a este constante e
cabeçalho um é igual a esta constante e cabeçalho dois é igual a esta constante,
cabeçalho de três é igual a este ou esta constante, onde todos estes são constantes
só botar definido aqui e são exatamente o que nós dissemos-lhe na especificação
que começa com um formato JPEG.
E assim, esta função só vai return true se este tampão representa
o início de um novo JPEG e falso caso contrário.
>> OK.
Então, se isso não representa um novo JPEG, então primeiro quero verificar para ver se
Arquivo JPEG não é igual a zero, caso em que o fechar.
E assim, por que precisamos de verificar para ver se não é nulo?
Bem, a primeira JPEG que nós encontrar não vamos já tem
um arquivo JPEG aberto.
E assim, se tentar fechar isso, então nós não estamos fazendo algo certo.
>> Mas cada JPEG subseqüente que abrirmos, queremos fechar
o arquivo anterior.
Então agora nós vamos usar sprintf como nós disse antes, onde estamos usando a
nome do arquivo JPEG tampão.
E nós vamos usar arquivo JPEG formato de nome como o nosso formato.
E o que é isso?
Até aqui, vemos que ela é zero por cento 3D.JPEG onde a três zero apenas
diz que usaremos três inteiros para este preenchido com zeros.
Então é assim que nós vamos chegar zero zero one.JPEG e de zero 10.JPEG e assim por diante.
>> Nós vamos usar sprintf.
E o inteiro que estamos inserindo na seqüência é JPEGs dormentes
recuperado, o qual é inicialmente zero.
Assim, o primeiro arquivo aberto vai para ser zero zero zero ponto JPEG.
E depois vamos incrementá-lo de modo que o próxima imagem abrimos será zero zero
um ponto JPEG e vamos incrementá-lo novamente por isso vai ser zero zero dois ponto
JPEG e assim por diante.
>> Tudo bem.
Então, agora o interior de arquivo JPEG nomear, temos o nome do
arquivo que nós queremos.
Podemos f abrir esse arquivo para a escrita.
OK.
E mais uma vez, é preciso verificar para se Certifique-se de que o arquivo com sucesso
aberto, pois se ele não o fez, em seguida, houve algum erro.
>> Portanto, agora temos obtido após a isso é uma parte JPEG.
E aqui, vemos que vamos para escrever para o JPEG.
Mas primeiro temos essa verificação, que diz se o arquivo JPEG não é igual a nulo.
Por que precisamos disso?
Bem arquivo JPEG é igual a zero quando tem atualmente um JPEG aberto.
>> E se cartão ponto começa matérias com um monte de bytes que
não representam um JPEG?
Então nós vamos querer pular sobre esses bytes.
Se não temos essa verificação, então estamos vai escrever a um fechado
apresentar os primeiros 512 bytes de o cartão que não é bom.
OK.
>> Assim, supondo que temos um arquivo aberto, em seguida, vamos escrever para o arquivo a
512 bytes que dispomos no nosso buffer.
E estamos mais uma vez para fazer a verificação Certifique-se de que os 512 bytes com sucesso
foram escritas, porque se não fossem escrito com sucesso, então algo
deu errado.
Vamos fechar os arquivos, imprima que algo deu errado, e retorno.
Assumindo que tudo vai corretamente, vamos continuar fechando o looping
arquivo antigo, abrindo o novo arquivo, a escrita dados para o novo arquivo, e assim
até que, finalmente, este f ler retorna zero, o que significa
que o arquivo é feito.
>> Portanto, agora que a leitura do cartão é mais, nós ver que nós vamos fechar a f
último arquivo que tínhamos aberto, mas estamos verificando se o arquivo JPEG
não é igual a nulo.
Bem, o próximo f faz sentido porque, como estamos abrindo arquivos, estamos fechando
o arquivo anterior, mas o último arquivo que abrimos nunca fica fechada.
Então, isso é o que este está fazendo.
>> Mas por que é preciso verificar para null?
Bem, o que se o cartão de ponto-prima não ter um único JPEG dentro dele?
Nesse caso, teríamos nunca abriu um arquivo.
E se nós nunca abrir um arquivo, devemos não tentar fechar esse arquivo.
Então é isso que esta verificação está fazendo.
>> Agora aqui, como eu disse antes, nós poderíamos eclodiram que y laço ou se
o cartão tiver terminado, ou se existem algum erro de leitura do cartão.
Portanto, esta é a verificação para ver se havia um erro de leitura do cartão, em
caso em que, vamos dizer que não foi um erro ao ler.
Nós não queremos que o usuário a pensar tudo correu com sucesso.
E nós vamos voltar um para o erro.
>> Por fim, vamos f fechar nosso arquivo raw, nosso cartão de ponto cru, para indicar que
tudo correu bem e retorno zero e é isso.
>> Meu nome é Rob e esta foi Recover.
>> [Música tocando]