1
00:00:00,000 --> 00:00:00,996

2
00:00:00,996 --> 00:00:12,470
>> [Muziek]

3
00:00:12,470 --> 00:00:13,210
>> ROB BOWDEN: Hi.

4
00:00:13,210 --> 00:00:16,870
Ik ben Rob en laten we de grootte
van dit probleem.

5
00:00:16,870 --> 00:00:20,990
Dus we gaan beginnen met copy.c als
een sjabloon, maar we gaan wel

6
00:00:20,990 --> 00:00:23,340
maakt nogal wat veranderingen.

7
00:00:23,340 --> 00:00:27,570
>> Nu zien we dat we meteen het maken van een
veranderen waar we niet meer controleren

8
00:00:27,570 --> 00:00:31,560
voor onze rxc niet gelijk 3, maar nu
we controleren rc niet gelijk 4.

9
00:00:31,560 --> 00:00:34,670
Omdat we willen ook omvatten, in
Naast de in het dossier en uit bestanden

10
00:00:34,670 --> 00:00:39,550
argumenten, f die gaat dit worden
factor waarmee we schaalvergroting.

11
00:00:39,550 --> 00:00:45,430
>> Dus zodra we zijn er zeker van dat, we willen
Gebruik s scan f om de string te zetten

12
00:00:45,430 --> 00:00:49,030
argv1 een vlotter.

13
00:00:49,030 --> 00:00:51,330
En we gaan slaan
dat factor.

14
00:00:51,330 --> 00:00:55,180
Deze extra karakter is ervoor te zorgen
dat we eigenlijk niet betreden

15
00:00:55,180 --> 00:00:59,200
iets als 1.4 ABC
op de opdrachtregel.

16
00:00:59,200 --> 00:01:02,960
>> Nu gaan we een aantal aliassen
sinds RV2 en RV3 niet

17
00:01:02,960 --> 00:01:04,310
zeer behulpzaam namen.

18
00:01:04,310 --> 00:01:07,660
We zijn, in plaats daarvan, gaan noemen
hen in het dossier en uit bestand.

19
00:01:07,660 --> 00:01:11,580
Nu gaan we ervoor zorgen dat
onze factor was eigenlijk geldig.

20
00:01:11,580 --> 00:01:16,330
Als factor kleiner is dan of gelijk aan
nul of groter dan 100, dan volgens

21
00:01:16,330 --> 00:01:19,660
de spec, moeten we afwijzen
deze factor.

22
00:01:19,660 --> 00:01:23,890
>> Als we weten zeker dat het goed is, nu kunnen we
open het n-bestand, en we moeten maken

23
00:01:23,890 --> 00:01:25,950
zeker van dat het met succes werd geopend.

24
00:01:25,950 --> 00:01:28,630
Als het niet, zal dat null terugkeren.

25
00:01:28,630 --> 00:01:30,390
We gaan om de file te openen.

26
00:01:30,390 --> 00:01:33,420
En nogmaals, we willen controleren om er
ervoor dat het succesvol geopend.

27
00:01:33,420 --> 00:01:37,270
En als het niet met goed gevolg heeft geopend, dan
we moeten ook zeker om te sluiten

28
00:01:37,270 --> 00:01:40,870
de n bestand dat oorspronkelijk succes
geopend, of anders hebben we een

29
00:01:40,870 --> 00:01:42,600
geheugenlek.

30
00:01:42,600 --> 00:01:46,350
>> Dus nu gaan we lezen in de bitmap
header en bitmap info

31
00:01:46,350 --> 00:01:48,890
header van de n-bestand.

32
00:01:48,890 --> 00:01:52,360
We gaan ervoor zorgen dat de
n bestand was een geldig bitmap.

33
00:01:52,360 --> 00:01:52,640
OK.

34
00:01:52,640 --> 00:01:55,100
>> Dus nu gaan we om te beginnen
een aantal wijzigingen.

35
00:01:55,100 --> 00:01:58,840
Dus omdat we gaan veranderen
dingen, we willen eerst denken aan de

36
00:01:58,840 --> 00:02:01,510
oude breedte van de n-bestand.

37
00:02:01,510 --> 00:02:05,160
We willen de oude vulling van herinneren
de n-bestand met behulp van dezelfde berekening

38
00:02:05,160 --> 00:02:06,990
van copy.c.

39
00:02:06,990 --> 00:02:09,840
>> En nu gaan we veranderen
de bitmap info header.

40
00:02:09,840 --> 00:02:13,630
En dus gaan we zowel de breedte te vermenigvuldigen
en de hoogte van factor sinds

41
00:02:13,630 --> 00:02:15,750
dat is wat we schaalvergroting door.

42
00:02:15,750 --> 00:02:18,420
We gaan bepalen
nieuwe vulling van het dossier door

43
00:02:18,420 --> 00:02:21,140
met de nieuwe breedte.

44
00:02:21,140 --> 00:02:27,330
En we gaan naar de nieuwe te bepalen
grootte van het beeld met behulp van het aantal

45
00:02:27,330 --> 00:02:31,610
bytes in een enkele rij die gaat
is het aantal pixels in die rij

46
00:02:31,610 --> 00:02:35,960
keer de grootte van een pixel plus
aantal bytes padding eind

47
00:02:35,960 --> 00:02:40,310
van die rij, en vermenigvuldigen dat alles
door het aantal rijen die we hebben.

48
00:02:40,310 --> 00:02:43,800
Dus dat is het aantal bytes
we hebben in onze beeldgegevens.

49
00:02:43,800 --> 00:02:48,190
>> Bf.Bfsize nu gaat om het nummer te
van bytes naar ons beeld beta plus

50
00:02:48,190 --> 00:02:49,350
de grootte van onze headers.

51
00:02:49,350 --> 00:02:53,910
Dus plus size van bitmap-bestand header
en de grootte van de bitmap info header.

52
00:02:53,910 --> 00:02:54,510
OK.

53
00:02:54,510 --> 00:02:56,440
Dus dat is het voor onze headers.

54
00:02:56,440 --> 00:02:59,030
We kunnen het bestand hoofd schrijven en
info header aan onze uit

55
00:02:59,030 --> 00:03:01,590
bestand, en we zijn goed.

56
00:03:01,590 --> 00:03:03,800
>> Nu is het tijd om daadwerkelijk te starten
schrijven van de pixel

57
00:03:03,800 --> 00:03:05,120
gegevens naar de file.

58
00:03:05,120 --> 00:03:10,460
We gaan een buffer van omvang verklaren
oude breedte RGB triples, en we zijn

59
00:03:10,460 --> 00:03:13,790
gaat om een ​​variabele genaamd verklaren
rij gevoelloos, wat we gaan

60
00:03:13,790 --> 00:03:15,640
aanvankelijk gelijk aan negatief 1.

61
00:03:15,640 --> 00:03:19,090
We zullen zien dat we gaan gebruiken
dat, om bij te houden van wat

62
00:03:19,090 --> 00:03:22,640
rij die we momenteel hebben geladen
in deze buffer.

63
00:03:22,640 --> 00:03:23,290
OK.

64
00:03:23,290 --> 00:03:28,750
>> Dus nu in tegenstelling tot de standaard editie,
in plaats van itereren over op de in

65
00:03:28,750 --> 00:03:32,900
bestand, gaan we itereren over elk
rij in de file en erachter te komen

66
00:03:32,900 --> 00:03:38,130
welke rij in de in het dossier willen we
plaats in deze rij in de file.

67
00:03:38,130 --> 00:03:44,930
Dus itereren over alle rijen in de
bestand met behulp van de nieuwe hoogte, we zijn eerst

68
00:03:44,930 --> 00:03:48,890
naar de rij bepalen de oude
file we gaan gebruiken, die we

69
00:03:48,890 --> 00:03:53,560
gaan doen door het nemen van deze stroom
rij gedeeld door factor.

70
00:03:53,560 --> 00:03:58,000
Dus dat gaat ons de rij te geven
in het oude bestand dat we willen.

71
00:03:58,000 --> 00:04:03,310
>> Dus nu als rij gevoelloos niet gelijk oud y,
we gaan te hebben om de rij te lezen

72
00:04:03,310 --> 00:04:05,940
dat we willen in ons huidig ​​rij buffer.

73
00:04:05,940 --> 00:04:07,700
Dus hoe gaan we dat doen?

74
00:04:07,700 --> 00:04:11,650
Ten eerste gaan we te achterhalen van de
standpunt dat rij begint in de

75
00:04:11,650 --> 00:04:13,100
originele bestand.

76
00:04:13,100 --> 00:04:18,630
Zodat die positie gaat worden
verleden al onze headers en

77
00:04:18,630 --> 00:04:21,589
nu langs oude y rijen.

78
00:04:21,589 --> 00:04:23,880
>> En ja hoeveel bytes
zijn in een enkele rij?

79
00:04:23,880 --> 00:04:28,740
Nogmaals, de grootte van RGB triple keer oud
breedte plus oud padding, dus dat is het

80
00:04:28,740 --> 00:04:30,640
aantal bytes in een enkele rij.

81
00:04:30,640 --> 00:04:33,680
En we willen langs oude y rijen overslaan.

82
00:04:33,680 --> 00:04:37,580
Dus we gaan om f te zoeken en we zijn
door seek set uit te gaan van de

83
00:04:37,580 --> 00:04:39,100
het begin van een bestand.

84
00:04:39,100 --> 00:04:42,740
We gaan f trachten deze positie
in het bestand, wat ons bij de

85
00:04:42,740 --> 00:04:46,500
het begin van de rij die we willen
te lezen in onze buffer.

86
00:04:46,500 --> 00:04:48,510
>> We gaan reeks rij
gevoelloos gelijk aan oude y.

87
00:04:48,510 --> 00:04:53,080
Dus nu als we lus terug en we willen
Gebruik deze zelfde rij in onze uit-bestand,

88
00:04:53,080 --> 00:04:55,970
dan zijn we niet van plan om te lezen
deze opnieuw onnodig.

89
00:04:55,970 --> 00:04:59,310
Dus echt, rij gevoelloos is
alleen een optimalisatie.

90
00:04:59,310 --> 00:05:05,500
>> Tot slot gaan we lezen in de
huidige rij de oude breedte RGB verdrievoudigt

91
00:05:05,500 --> 00:05:08,040
dat we willen van het originele bestand.

92
00:05:08,040 --> 00:05:12,270
Dus nu huidig ​​rij bevat de pixels van
het oorspronkelijke bestand dat we willen

93
00:05:12,270 --> 00:05:14,200
schrijven naar de file.

94
00:05:14,200 --> 00:05:18,960
Dus nu, net als boven, in plaats van
itereren over het oude bestand, moeten we

95
00:05:18,960 --> 00:05:22,560
het aan itereren over de nieuwe bestanden rijen.

96
00:05:22,560 --> 00:05:27,450
Nou hier, in plaats van itereren over alle
van de oude pixels die in huidig ​​rij,

97
00:05:27,450 --> 00:05:31,210
willen we itereren over alle
pixels in het nieuwe bestand in deze

98
00:05:31,210 --> 00:05:32,480
bepaalde rij.

99
00:05:32,480 --> 00:05:34,140
>> Waarom willen we dat doen?

100
00:05:34,140 --> 00:05:38,960
Want we zien hier dat we niet
eigenlijk noodzakelijk met alle

101
00:05:38,960 --> 00:05:41,020
pixels in het originele bestand.

102
00:05:41,020 --> 00:05:46,630
Want als we krimpen, zouden we
eigenlijk willen de pixels overslaan.

103
00:05:46,630 --> 00:05:48,090
En we zien dat dit -

104
00:05:48,090 --> 00:05:49,690
x gedeeld door factor -

105
00:05:49,690 --> 00:05:55,620
nauw spiegels hier waar we zeggen y
gedeeld door factor om erachter te komen dat

106
00:05:55,620 --> 00:06:02,480
de oude y-de rij correspondeert met
de y-de rij in dit nieuwe bestand.

107
00:06:02,480 --> 00:06:05,880
>> Nu gaan we allemaal schrijven
deze pixels van de oude rij

108
00:06:05,880 --> 00:06:07,440
in onze nieuwe rij.

109
00:06:07,440 --> 00:06:10,890
Zodra we dat gedaan hebt, moeten we gewoon
zet de padding aan het einde van onze rij

110
00:06:10,890 --> 00:06:15,540
en we zullen loop terug en blijven voor
alle rijen in onze nieuwe bestand.

111
00:06:15,540 --> 00:06:19,390
Op het einde moeten we sluiten onze oude
bestand, sluit onze nieuw bestand, en de terugkeer

112
00:06:19,390 --> 00:06:21,540
nul want alles ging prima.

113
00:06:21,540 --> 00:06:24,220
>> Mijn naam is Rob en dit was Recess.

114
00:06:24,220 --> 00:06:29,184
>> [Muziek]