1
00:00:00,000 --> 00:00:12,240
>> [MUSIC ప్లే]

2
00:00:12,240 --> 00:00:15,870
>> రాబ్ బౌడెన్: హాయ్, నేను రాబ్ ఉన్నాను, వీలు యొక్క
పరిమాణానికి ఈ ప్రయత్నించండి.

3
00:00:15,870 --> 00:00:21,100
కాబట్టి, మేము మళ్ళీ తో ఆరంభమవుతుంది
ప్రాథమికంగా ఒక copy.c కాపీ, మరియు

4
00:00:21,100 --> 00:00:22,860
కొన్ని మార్పులు చేయండి.

5
00:00:22,860 --> 00:00:26,280
వెంటనే మేము, ఒక మార్పు చూడండి గమనించండి ఇక్కడ
బదులుగా చూడటానికి తనిఖీ ఉంటే

6
00:00:26,280 --> 00:00:30,440
argc, మేము తనిఖీ 3 సమాన కాదు అనుకుంటుంది
argc నుండి, 4 సమానంగా లేదు ఉంటే

7
00:00:30,440 --> 00:00:34,350
ఇప్పుడు మేము ఒక infile తీసుకోవడం లేదు
మరియు outfile, కానీ మేము కూడా లో వేస్తున్నాము

8
00:00:34,350 --> 00:00:38,980
మేము ఆ మొత్తం అని,
అసలు చిత్రం స్కేలింగ్.

9
00:00:38,980 --> 00:00:44,340
మేము ఆ లేదో ఉన్నారు, మేము కేవలం
atoi ఉపయోగించి పూర్ణాంకం n మార్చేందుకు.

10
00:00:44,340 --> 00:00:48,760
>> కాబట్టి, ఇప్పుడు మేము సృష్టించడానికి చూడాలని
మారుపేర్ల, కేవలం 2 infile argv కాల్, మరియు

11
00:00:48,760 --> 00:00:54,240
argv 3 outfile, argv 2 మరియు ఎందుకంటే
argv 3 చాలా సహాయకారిగా పేర్లు కావు.

12
00:00:54,240 --> 00:00:58,510
ఇప్పుడు మేము ఖచ్చితంగా n ఉంది చేయడానికి చెక్ అనుకుంటున్నారా
హద్దుల్లో కాదనీ, కాబట్టి

13
00:00:58,510 --> 00:01:02,910
స్పెక్ పేర్కొనే ఇది కంటే తక్కువ లేదా ఉంటే
, సున్నాకి సమానం, లేదా 100 కంటే ఎక్కువ

14
00:01:02,910 --> 00:01:08,580
ఆ చెల్లని పునఃపరిమాణం ఫాక్టర్,
మరియు మేము ఆ యూజర్ హెచ్చరిస్తుంది ఉండాలి.

15
00:01:08,580 --> 00:01:13,090
>> మేము అన్ని ఆ దాటి అయ్యాక, మేము
చివరికి మా infile లెట్ మరియు మేము అవసరం

16
00:01:13,090 --> 00:01:16,270
నిర్ధారించుకోండి తనిఖీ తప్పొప్పులకు
ప్రారంభ కారణం విఫలం లేదు.

17
00:01:16,270 --> 00:01:19,860
మేము కూడా మా outfile తెరిచి, మరియు
మళ్ళీ నిర్ధారించుకోండి తనిఖీ లోపం

18
00:01:19,860 --> 00:01:21,250
కారణం విఫలం లేదు.

19
00:01:21,250 --> 00:01:26,270
కానీ తప్పకుండా ఉంటే ప్రారంభ
outfile మేము దగ్గరగా అవసరమైన విఫలమైంది

20
00:01:26,270 --> 00:01:29,040
ఇప్పటికే ఆరంభించబడింది infile,.

21
00:01:29,040 --> 00:01:33,690
>> కాబట్టి, అప్పుడు, ఆ విఫలం లేదు ఊహిస్తూ
we're - కేవలం వంటి copy.c--

22
00:01:33,690 --> 00:01:36,140
శీర్షికలో చదవగల
infile నుండి.

23
00:01:36,140 --> 00:01:40,130
మేము అది ఒక చెల్లదు చేయడానికి చూడాలని
బిట్మ్యాప్, కానీ ఇప్పుడు మేము కొన్ని చేయబోతున్నామని

24
00:01:40,130 --> 00:01:41,620
ఒక బిట్ భిన్నంగా పనులు.

25
00:01:41,620 --> 00:01:44,870
కాబట్టి మొదటి, మేము మీరు చూడాలని
అసలు వెడల్పు మరియు ఎత్తు గుర్తు

26
00:01:44,870 --> 00:01:48,290
infile యొక్క, ఎందుకంటే మేము చూడాలని
outfile కోసం ఇది మారుతున్న.

27
00:01:48,290 --> 00:01:53,890
కాబట్టి ఇప్పుడు విచిత్రమైన కారణాల గుర్తుంచుకోవాలి
bi.biheight, ప్రతికూల, మరియు

28
00:01:53,890 --> 00:01:58,670
కాబట్టి లో అసలు ఎత్తు, అనుకూల, మేము
సంపూర్ణ విలువ తీసుకోవాలని.

29
00:01:58,670 --> 00:02:02,580
>> ఇప్పుడు, పాడింగ్ అదే అన్నారు
ఇది copy.c లో లెక్కింపు వంటి,

30
00:02:02,580 --> 00:02:06,060
పాత వెడల్పు ఉపయోగించి, మరియు ఇప్పుడు మేము ఉన్నాము
నిజానికి మార్చుకోబోతున్నారు

31
00:02:06,060 --> 00:02:07,320
మా శీర్షికలో ఏమి యొక్క.

32
00:02:07,320 --> 00:02:11,200
కాబట్టి మేము మా వెడల్పు గుణిస్తారు చూడాలని
n, మేము ద్వారా వెడల్పు కొలిస్తే చేస్తున్నారు నుండి

33
00:02:11,200 --> 00:02:15,100
మేము నుండి n, n ఎత్తు గుణిస్తారు
n, స్కేలింగ్ మరియు ఇప్పుడు మనం

34
00:02:15,100 --> 00:02:19,250
ఒక కొత్త పాడింగ్ కోసం లెక్కింపు
కొత్త వెడల్పు ఆధారంగా.

35
00:02:19,250 --> 00:02:21,840
>> కాబట్టి ఇప్పుడు మేము కొన్ని మార్చాలి
మా శీర్షిక ఇతర ఖాళీలను.

36
00:02:21,840 --> 00:02:26,890
Bi.biSizeImage భావించబడేది
పిక్సెళ్ళు లో అన్ని బైట్లు పరిమాణం

37
00:02:26,890 --> 00:02:28,520
మరియు చిత్రం యొక్క పాడింగ్.

38
00:02:28,520 --> 00:02:34,190
కాబట్టి మా ఒక వరుస యొక్క పరిమాణం
చిత్రం RGB యొక్క పరిమాణం ట్రిపుల్, పరిమాణం ఉంది

39
00:02:34,190 --> 00:02:39,430
ఒక పిక్సెల్ యొక్క, సార్లు సంఖ్య
వరుసగా పిక్సెళ్ళు, ప్లస్ పాడింగ్ వద్ద

40
00:02:39,430 --> 00:02:40,910
వరుసగా ముగింపు.

41
00:02:40,910 --> 00:02:45,200
మరియు తర్వాత మేము ద్వారా గుణించాలి చూడాలని
పొందడానికి మా ఎత్తు సంపూర్ణ విలువ

42
00:02:45,200 --> 00:02:48,350
బైట్లు మొత్తం సంఖ్య
చిత్రం డేటా.

43
00:02:48,350 --> 00:02:53,050
bf.bfSize కేవలం మొత్తం సంఖ్య
మా చిత్రం డేటా బైట్లు, కాబట్టి

44
00:02:53,050 --> 00:02:56,530
bi.biSizeImage, ప్లస్
మా శీర్షికలు యొక్క పరిమాణం.

45
00:02:56,530 --> 00:02:59,850
కాబట్టి, బిట్మ్యాప్ ఫైల్ పరిమాణంపై జోడించడం
బిట్మ్యాప్ సమాచారం యొక్క శీర్షిక, మరియు పరిమాణం

46
00:02:59,850 --> 00:03:00,800
OK, శీర్షిక.

47
00:03:00,800 --> 00:03:03,170
కాబట్టి మేము అవసరమైనవి
మా శీర్షికల్లో మార్చడానికి.

48
00:03:03,170 --> 00:03:07,020
ఇప్పుడు మేము బిట్మ్యాప్ ఫైలు శీర్షిక వ్రాసే చేస్తాము
మా outfile, మరియు మా బిట్మ్యాప్ సమాచారం

49
00:03:07,020 --> 00:03:09,880
ఇప్పుడు మా outfile శీర్షిక, మరియు
మేము వెళ్లి సిద్ధంగా

50
00:03:09,880 --> 00:03:11,990
నిజమైన పిక్సెళ్ళు పైగా.

51
00:03:11,990 --> 00:03:15,720
>> కాబట్టి మేము కంటే iterate
infile యొక్క స్కాన్ పంక్తులు.

52
00:03:15,720 --> 00:03:17,730
కాబట్టి మేము oldheight కంటే iterate.

53
00:03:17,730 --> 00:03:20,830
మేము గుర్తు అవసరమైన ఎందుకు ఉంది
మేము మారుతుంది ముందు అసలు ఎత్తు,

54
00:03:20,830 --> 00:03:23,040
మరియు n ద్వారా స్కేల్.

55
00:03:23,040 --> 00:03:27,810
ఇప్పుడు మేము ఒక చదవండి చూడాలని
ఒక లోకి infile వరుస

56
00:03:27,810 --> 00:03:30,630
పరిమాణం oldwidth బఫర్.

57
00:03:30,630 --> 00:03:36,190
RGB యొక్క ఇక్కడ, మేము freading చేస్తున్నారు పరిమాణం
ట్రిపుల్, ఒక పిక్సెల్, మరియు పాత వెడల్పు

58
00:03:36,190 --> 00:03:39,760
మా బఫర్ లోకి infile నుండి.

59
00:03:39,760 --> 00:03:43,480
మరియు ఆ మొత్తం చేస్తాడు
ఈ శ్రేణి లో వరుస.

60
00:03:43,480 --> 00:03:50,390
కాబట్టి ఇప్పుడు, మేము n సార్లు iterate మీరు
మా outfile n సార్లు ఈ వరుసగా ప్రింట్.

61
00:03:50,390 --> 00:03:52,510
అందువలన, ఈ లూప్ చేస్తున్నది ఉంది.

62
00:03:52,510 --> 00:03:57,910
ఇది లోపలి లూప్ పైగా iterating ఉంది
శ్రేణి, ముద్రణ పైగా, స్వయంగా వరుస

63
00:03:57,910 --> 00:04:00,710
శ్రేణి n కాలంలో ప్రతి పిక్సెల్.

64
00:04:00,710 --> 00:04:04,510
కాబట్టి జేరోయేత్ మూలకం ముద్రించబడ్డాయి ఉంది
n సార్లు, మొదటి మూలకం ఉంది

65
00:04:04,510 --> 00:04:05,660
n సార్లు ముద్రించిన.

66
00:04:05,660 --> 00:04:10,820
మరియు ఆ విధమైన ఎలా మేము చూడాలని ఉంది
అడ్డంగా outfile లో స్థాయికి

67
00:04:10,820 --> 00:04:13,390
ఈ లూప్, మేము n మళ్ళీ వెతికినా నుండి
సార్లు, మేము వెళుతున్న ఉంది

68
00:04:13,390 --> 00:04:15,580
నిలువుగా స్థాయి.

69
00:04:15,580 --> 00:04:19,850
>> డౌన్ ఇక్కడ, మేము జోడించడానికి చూడండి
ప్రతి వరుసలో చివర పాడింగ్.

70
00:04:19,850 --> 00:04:25,050
ఈ కోసం లూప్ లోపల ఎందుకు పేర్కొంది
కేవలం యొక్క n వరుసలు ముద్రించిన యొక్క

71
00:04:25,050 --> 00:04:28,400
infile నుండి ఈ ఒక వరుసగా.

72
00:04:28,400 --> 00:04:32,150
అప్పుడు డౌన్ ఇక్కడ, నేను పైగా skip వెళుతున్న
infile లో పాడింగ్, ఒకసారి నుండి

73
00:04:32,150 --> 00:04:34,560
మేము ఒక వరుస పూర్తి చేసిన
infile, మనం శ్రద్ధ లేదు

74
00:04:34,560 --> 00:04:35,290
ఏ పాడింగ్ ఉంది.

75
00:04:35,290 --> 00:04:37,110
మేము రెండవ వరుసలో ను మీరు.

76
00:04:37,110 --> 00:04:40,870
మరియు తర్వాత మేము తిరిగి లూప్ చేస్తాము మరియు అన్ని చేయండి
మళ్ళీ రెండవ వరుసలో కోసం.

77
00:04:40,870 --> 00:04:44,406
>> చివరగా, ఒకసారి మేము అన్ని ఆ పూర్తి చేసిన,
మేము దగ్గరగా, infile మూసివేయవచ్చు

78
00:04:44,406 --> 00:04:47,430
outfile, మరియు తిరిగి
0 మేము పూర్తి చేసిన ఎందుకంటే.

79
00:04:47,430 --> 00:04:50,330
>> నా పేరు రాబ్ ఉంది, మరియు ఈ పునఃపరిమాణం ఉంది.

80
00:04:50,330 --> 00:04:54,934
>> [MUSIC ప్లే]