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

2
00:00:00,494 --> 00:00:13,350
>> [MUSIC PLAYING]

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

4
00:00:14,080 --> 00:00:17,550
Aku Rob, dan mari kita berharap bahwa
Solusi ini membantu menempatkan Anda

5
00:00:17,550 --> 00:00:19,600
di jalan menuju pemulihan.

6
00:00:19,600 --> 00:00:22,700
Jadi mari kita mulai.

7
00:00:22,700 --> 00:00:25,660
>> Kita melihat bahwa segera kita
hanya untuk memastikan bahwa kita

8
00:00:25,660 --> 00:00:27,170
menggunakan Recover benar.

9
00:00:27,170 --> 00:00:31,490
Jadi penggunaan hanya harus menjadi sesuatu
seperti dot slash pulih.

10
00:00:31,490 --> 00:00:35,500
>> Sekarang kita akan membuka diharapkan
kartu dot file mentah.

11
00:00:35,500 --> 00:00:39,740
Kita lihat di sini bahwa kita menggunakan
konstan nama file underscore mentah,

12
00:00:39,740 --> 00:00:44,200
yang di sini kita memiliki hash
didefinisikan sebagai kartu dot baku.

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

14
00:00:45,030 --> 00:00:48,210
>> Jadi kita perlu memastikan bahwa
berhasil dibuka karena jika

15
00:00:48,210 --> 00:00:51,150
tidak, maka kita harus memperingatkan pengguna.

16
00:00:51,150 --> 00:00:56,770
Tetapi dengan asumsi bahwa hal itu, kita sekarang
akan mendeklarasikan penyangga ukuran JPEG

17
00:00:56,770 --> 00:00:58,170
mengajukan nama panjang.

18
00:00:58,170 --> 00:01:02,060
Jadi ini akan menjadi buffer yang
kita akan sprintf ke.

19
00:01:02,060 --> 00:01:04,360
>> Jadi apa yang JPEG nama file panjang?

20
00:01:04,360 --> 00:01:08,490
Sampai di sini, kita melihat bahwa itu
hash didefinisikan sebagai delapan.

21
00:01:08,490 --> 00:01:10,670
Jadi mengapa delapan?

22
00:01:10,670 --> 00:01:15,150
Nah file yang diberikan akan diberi nama
sesuatu seperti nol nol nol.

23
00:01:15,150 --> 00:01:19,460
JPG dan kemudian kita perlu backslash nol.

24
00:01:19,460 --> 00:01:22,720
Jadi kita perlu penyangga yang dapat
menyimpan delapan karakter.

25
00:01:22,720 --> 00:01:25,190
Sekarang kita akan memiliki counter yang
akan melacak

26
00:01:25,190 --> 00:01:27,780
nomor JPEG yang kami temukan.

27
00:01:27,780 --> 00:01:31,590
>> Dan akhirnya, kita akan memiliki
File JPEG yang awalnya nol

28
00:01:31,590 --> 00:01:35,920
yang akan menjadi saat
membuka file yang kita sedang menulis ke.

29
00:01:35,920 --> 00:01:37,540
Sekarang kita akan memiliki
buffer tambahan.

30
00:01:37,540 --> 00:01:41,350
Ini tidak sama dengan sprintf kami
penyangga di mana penyangga ini adalah salah satu

31
00:01:41,350 --> 00:01:45,020
bahwa kita membaca dalam data
dari kartu dot mentah.

32
00:01:45,020 --> 00:01:48,900
>> Jadi buffer akan menjadi
unsigned chars, yang Anda dapat

33
00:01:48,900 --> 00:01:53,560
pada dasarnya hanya memperlakukan kita byte, dan itu
akan menjadi ukuran ukuran blok

34
00:01:53,560 --> 00:01:57,950
di mana, karena kami memberitahu Anda,
ukuran blok adalah 512.

35
00:01:57,950 --> 00:02:03,070
Jadi JPEG Anda dapat mengobati segala sesuatu
sebagai blok 512 byte.

36
00:02:03,070 --> 00:02:05,890
>> Sekarang kita akan lingkaran
atas seluruh file.

37
00:02:05,890 --> 00:02:12,980
Kita akan f membaca ke dalam buffer kita
kali byte ukuran blok tunggal dari

38
00:02:12,980 --> 00:02:14,710
kartu dot file mentah.

39
00:02:14,710 --> 00:02:16,630
Sekarang apa f baca kembali?

40
00:02:16,630 --> 00:02:20,050
Ia mengembalikan jumlah item
yang berhasil membaca.

41
00:02:20,050 --> 00:02:27,310
Jadi jika berhasil membaca 512 byte, maka
kita ingin melihat apakah ini merupakan

42
00:02:27,310 --> 00:02:29,700
JPEG atau menulis ke file JPEG.

43
00:02:29,700 --> 00:02:34,450
Dan jika itu tidak kembali 512 byte,
maka baik berkas ini telah berakhir

44
00:02:34,450 --> 00:02:37,870
hal ini kita akan keluar dari y
lingkaran, atau ada semacam kesalahan

45
00:02:37,870 --> 00:02:40,300
dalam hal ini kita juga akan keluar dari
y lingkaran, tapi kami akan ingin melaporkan

46
00:02:40,300 --> 00:02:41,990
sesuatu yang tidak beres.

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

48
00:02:42,290 --> 00:02:47,630
Jadi dengan asumsi bahwa kita berhasil membaca
dalam 512 byte, kita ingin cek pertama

49
00:02:47,630 --> 00:02:53,070
untuk membuat byte ini yang kita
hanya membaca di mulai JPEG a.

50
00:02:53,070 --> 00:02:56,430
Jadi jika adalah JPEG header penyangga kami.

51
00:02:56,430 --> 00:02:58,460
Sekarang apa yang JPEG sundulan lakukan?

52
00:02:58,460 --> 00:03:00,120
Mari kita lihat.

53
00:03:00,120 --> 00:03:05,270
>> Sampai di sini, kita melihat bahwa fungsi ini
kembali banteng, dan banteng yang -

54
00:03:05,270 --> 00:03:08,820
baik di sini, kami sedang memeriksa untuk melihat apakah
Header nol sama dengan konstan dan

55
00:03:08,820 --> 00:03:11,880
Header satu sama dengan konstan dan
Header dua sama dengan konstan ini,

56
00:03:11,880 --> 00:03:15,640
kepala tiga sama ini atau ini
konstan di mana semua konstanta ini

57
00:03:15,640 --> 00:03:20,340
hanya hash didefinisikan di sini dan
persis apa yang kita katakan di spec

58
00:03:20,340 --> 00:03:22,700
bahwa JPEG dimulai dengan.

59
00:03:22,700 --> 00:03:27,300
Dan fungsi ini hanya akan
return true jika buffer ini merupakan

60
00:03:27,300 --> 00:03:31,750
awal dari JPEG baru
dan false jika tidak.

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

62
00:03:32,520 --> 00:03:38,490
Jadi, jika ini tidak mewakili JPEG baru,
maka pertama-tama kita ingin memeriksa untuk melihat apakah

63
00:03:38,490 --> 00:03:42,030
JPEG file tidak sama dengan nol,
dalam hal ini kita menutupnya.

64
00:03:42,030 --> 00:03:44,940
Jadi mengapa kita perlu memeriksa
untuk melihat apakah itu tidak nol?

65
00:03:44,940 --> 00:03:48,980
Nah JPEG pertama yang kita
menemukan kita tidak akan sudah

66
00:03:48,980 --> 00:03:50,440
file JPEG terbuka.

67
00:03:50,440 --> 00:03:55,580
Jadi, jika kita mencoba untuk menutup itu, maka
kita tidak melakukan sesuatu yang benar.

68
00:03:55,580 --> 00:03:59,090
>> Tapi setiap JPEG berikutnya yang
kita buka, kita ingin menutup

69
00:03:59,090 --> 00:04:00,710
file sebelumnya.

70
00:04:00,710 --> 00:04:04,630
Jadi sekarang kita akan menggunakan sprintf seperti yang kita
mengatakan sebelum di mana kita menggunakan

71
00:04:04,630 --> 00:04:06,280
nama file JPEG penyangga.

72
00:04:06,280 --> 00:04:09,870
Dan kita akan menggunakan file JPEG
nama Format sebagai format kami.

73
00:04:09,870 --> 00:04:12,030
Dan apa itu?

74
00:04:12,030 --> 00:04:18,450
Sampai di sini, kita melihat bahwa itu adalah nol persen
3D.JPEG mana nol tiga hanya

75
00:04:18,450 --> 00:04:22,089
mengatakan bahwa kita akan menggunakan tiga bilangan bulat
untuk ini diisi dengan nol.

76
00:04:22,089 --> 00:04:27,470
Jadi ini adalah bagaimana kita akan mendapatkan nol nol
one.JPEG dan nol 10.JPEG dan sebagainya.

77
00:04:27,470 --> 00:04:29,060
>> Kita akan menggunakan sprintf.

78
00:04:29,060 --> 00:04:33,760
Dan integer yang kita memasukkan
ke dalam string adalah JPEG mati rasa

79
00:04:33,760 --> 00:04:36,380
pulih, yang awalnya nol.

80
00:04:36,380 --> 00:04:39,950
Jadi file pertama kali dibuka akan
menjadi nol nol nol dot JPEG.

81
00:04:39,950 --> 00:04:43,330
Dan kemudian kita incrementing itu sehingga
file selanjutnya kita buka akan menjadi nol nol

82
00:04:43,330 --> 00:04:46,830
satu titik JPEG dan kami akan kenaikan itu
lagi sehingga akan nol nol dua titik

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

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

85
00:04:49,850 --> 00:04:53,210
Jadi sekarang bagian dalam file JPEG
nama, kita memiliki nama

86
00:04:53,210 --> 00:04:54,990
mengajukan yang kita inginkan.

87
00:04:54,990 --> 00:04:58,640
Kita bisa f membuka file untuk menulis.

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

89
00:04:59,170 --> 00:05:02,820
Dan sekali lagi, kita perlu memeriksa untuk membuat
yakin bahwa file berhasil

90
00:05:02,820 --> 00:05:08,460
dibuka karena jika tidak, maka
ada beberapa kesalahan.

91
00:05:08,460 --> 00:05:13,100
>> Jadi sekarang kita sudah melewati
apakah ini bagian JPEG.

92
00:05:13,100 --> 00:05:16,390
Dan di sini, kita melihat kita akan
menulis ke JPEG.

93
00:05:16,390 --> 00:05:20,980
Tapi pertama-tama kita cek ini yang mengatakan
jika file JPEG tidak nol sama.

94
00:05:20,980 --> 00:05:22,490
Mengapa kita perlu itu?

95
00:05:22,490 --> 00:05:28,020
Nah file JPEG sama dengan nol ketika kita
saat ini memiliki JPEG terbuka.

96
00:05:28,020 --> 00:05:31,870
>> Bagaimana jika kartu dot dimulai baku
dengan sekelompok byte yang

97
00:05:31,870 --> 00:05:33,510
tidak mewakili JPEG?

98
00:05:33,510 --> 00:05:36,240
Kemudian kita akan ingin
melewatkan mereka byte.

99
00:05:36,240 --> 00:05:39,600
Jika kita tidak memiliki cek ini, maka kita
akan menulis ke belum dibuka

100
00:05:39,600 --> 00:05:45,540
mengajukan 512 byte pertama dari
kartu yang tidak baik.

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

102
00:05:46,030 --> 00:05:51,330
>> Jadi dengan asumsi kita memiliki file terbuka, maka
kita akan menulis ke file yang

103
00:05:51,330 --> 00:05:53,290
512 byte yang kita miliki dalam buffer kita.

104
00:05:53,290 --> 00:05:57,390
Dan kami sekali lagi memeriksa untuk membuat
memastikan bahwa 512 byte berhasil

105
00:05:57,390 --> 00:06:01,140
ditulis karena jika mereka tidak
berhasil ditulis, kemudian sesuatu

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

107
00:06:02,080 --> 00:06:06,540
Kami akan menutup file-file kita, mencetak bahwa
sesuatu yang tidak beres, dan kembali.

108
00:06:06,540 --> 00:06:10,940
Dengan asumsi semuanya berjalan dengan benar, maka
kita akan terus looping menutup

109
00:06:10,940 --> 00:06:15,060
file lama, membuka file baru, penulisan
data ke file baru, dan sebagainya

110
00:06:15,060 --> 00:06:20,990
sampai akhirnya, f ini telah dibaca
kembali nol yang berarti

111
00:06:20,990 --> 00:06:23,280
bahwa file tersebut dilakukan.

112
00:06:23,280 --> 00:06:28,490
>> Jadi sekarang bahwa membaca kartu berakhir, kita
melihat bahwa kita akan f menutup

113
00:06:28,490 --> 00:06:33,250
File terakhir yang kita miliki terbuka, tapi
kita memeriksa apakah file JPEG

114
00:06:33,250 --> 00:06:34,900
tidak nol tidak sama.

115
00:06:34,900 --> 00:06:39,520
Nah f dekat masuk akal karena sebagai
kita membuka file, kita menutup

116
00:06:39,520 --> 00:06:43,870
file sebelumnya, tapi yang terakhir
file yang kita buka tidak pernah akan ditutup.

117
00:06:43,870 --> 00:06:45,580
Jadi itulah yang ini lakukan.

118
00:06:45,580 --> 00:06:47,720
>> Tapi mengapa kita perlu memeriksa null?

119
00:06:47,720 --> 00:06:53,130
Nah bagaimana jika kartu dot mentah tidak
memiliki JPEG tunggal di dalamnya?

120
00:06:53,130 --> 00:06:56,640
Dalam hal ini, kita akan memiliki
tidak pernah membuka file.

121
00:06:56,640 --> 00:07:00,230
Dan jika kita tidak pernah membuka file, kita harus
tidak mencoba untuk menutup file tersebut.

122
00:07:00,230 --> 00:07:03,000
Jadi itulah yang cek ini lakukan.

123
00:07:03,000 --> 00:07:07,880
>> Sekarang di sini, seperti yang saya katakan sebelumnya, kita bisa
telah rusak bahwa y lingkaran baik jika

124
00:07:07,880 --> 00:07:13,520
kartu telah berakhir atau jika ada
beberapa kesalahan membaca dari kartu.

125
00:07:13,520 --> 00:07:16,680
Jadi ini memeriksa untuk melihat apakah ada
kesalahan membaca dari kartu, di

126
00:07:16,680 --> 00:07:19,400
hal ini, kita akan mengatakan ada
adalah kesalahan membaca.

127
00:07:19,400 --> 00:07:22,130
Kami tidak ingin pengguna untuk berpikir
semuanya berjalan dengan sukses.

128
00:07:22,130 --> 00:07:24,750
Dan kami akan kembali satu kesalahan.

129
00:07:24,750 --> 00:07:29,580
>> Akhirnya, kami akan menutup file f baku kami,
kartu kami dot mentah, untuk menunjukkan bahwa

130
00:07:29,580 --> 00:07:34,070
semuanya berjalan baik dan kembali
nol dan hanya itu.

131
00:07:34,070 --> 00:07:36,130
>> Nama saya Rob dan ini adalah Recover.

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