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

2
00:00:00,996 --> 00:00:12,470
>> [MUSIC ప్లే]

3
00:00:12,470 --> 00:00:13,210
>> రాబ్ బౌడెన్: ఎక్కువ.

4
00:00:13,210 --> 00:00:16,870
నేను రాబ్ ఉన్నాను తెలియజేస్తుంది మరియు పరిమాణం
ఈ సమస్య అప్.

5
00:00:16,870 --> 00:00:20,990
కాబట్టి మేము వంటి copy.c ప్రారంభం చూడాలని
ఒక టెంప్లేట్, కానీ మేము మాత్రం

6
00:00:20,990 --> 00:00:23,340
చాలా కొన్ని మార్పులతో.

7
00:00:23,340 --> 00:00:27,570
>> ఇప్పుడు మనం వెంటనే చేస్తున్న చూడండి ఒక
మేము ఇకపై తనిఖీ చేస్తున్నాము పేరు మార్చడానికి

8
00:00:27,570 --> 00:00:31,560
మా rxc ఇప్పుడు 3 సమానంగా, కానీ లేదు కోసం
మేము rc తనిఖీ చేస్తున్నాము 4 సమానంగా లేదు.

9
00:00:31,560 --> 00:00:34,670
మేము కూడా లో, చేర్చాలనుకుంటే నుండి
ఫైలు లో మరియు అవుట్ ఫైళ్లు పాటు

10
00:00:34,670 --> 00:00:39,550
ఈ అన్నారు ఇది వాదనలు, f
మేము కొలిస్తే చేస్తున్నారు ఇది ద్వారా అంశం.

11
00:00:39,550 --> 00:00:45,430
>> మేము ఆ యొక్క ఖచ్చితంగా ఉన్నాము కాబట్టి ఒకసారి, మేము కావలసిన
స్ట్రింగ్ మార్చడానికి లు స్కాన్ F ఉపయోగించడానికి

12
00:00:45,430 --> 00:00:49,030
ఒక ఫ్లోట్ argv1.

13
00:00:49,030 --> 00:00:51,330
మరియు మేము నిల్వ చూడాలని
ఆ అంశం.

14
00:00:51,330 --> 00:00:55,180
ఈ అదనపు పాత్ర చూసుకోవాలి ఉంది
మేము నిజంగా ఎంటర్ లేని

15
00:00:55,180 --> 00:00:59,200
1.4 ABC లాగ
కమాండ్ లైన్ వద్ద.

16
00:00:59,200 --> 00:01:02,960
>> ఇప్పుడు మేము కొన్ని మారుపేర్ల సృష్టించడానికి చూడాలని
RV2 మరియు RV3 లేని కారణంగా

17
00:01:02,960 --> 00:01:04,310
చాలా సహాయకారిగా పేర్లు.

18
00:01:04,310 --> 00:01:07,660
మేము, బదులుగా, కాల్ చూడాలని
వాటిని ఫైలు లో మరియు ఫైల్.

19
00:01:07,660 --> 00:01:11,580
ఇప్పుడు మేము నిర్ధారించుకోండి చూడాలని
మా అంశం నిజానికి ఆమోదయోగ్యమని.

20
00:01:11,580 --> 00:01:16,330
కాబట్టి అంశం కంటే తక్కువ లేదా సమానంగా ఉంటే
సున్నా లేదా ఎక్కువ 100 కంటే, అప్పుడు వంటి శాతం

21
00:01:16,330 --> 00:01:19,660
స్పెక్, మేము మానేయాలని
ఆ అంశం.

22
00:01:19,660 --> 00:01:23,890
>> మేము ఖచ్చితంగా ఉన్నప్పుడు అది ఇప్పుడు మేము, మంచి
n ఫైల్ తెరిచి, మేము కలిగి

23
00:01:23,890 --> 00:01:25,950
ఇది విజయవంతంగా ప్రారంభించబడింది నిర్ధారించుకోండి.

24
00:01:25,950 --> 00:01:28,630
అది లేకపోతే, ఆ శూన్య చూపిస్తుంది.

25
00:01:28,630 --> 00:01:30,390
మేము ఫైల్ను తెరవడం చూడాలని.

26
00:01:30,390 --> 00:01:33,420
మరియు తిరిగి, మేము చేయడానికి చెక్ అనుకుంటున్నారా
అది విజయవంతంగా విప్పి.

27
00:01:33,420 --> 00:01:37,270
మరియు అది విజయవంతంగా అప్పుడు, ఓపెన్ పొతే
మేము కూడా మూసి ఖచ్చితంగా ఉండాలి

28
00:01:37,270 --> 00:01:40,870
n ఫైల్ ఇది నిజానికి విజయవంతంగా
తెరిచింది, లేదంటే ఒక

29
00:01:40,870 --> 00:01:42,600
మెమొరీ లీక్.

30
00:01:42,600 --> 00:01:46,350
>> కాబట్టి ఇప్పుడు మేము బిట్మ్యాప్ లో చదవండి చూడాలని
ఫైలు శీర్షిక మరియు బిట్మ్యాప్ సమాచారం

31
00:01:46,350 --> 00:01:48,890
n ఫైల్ నుండి శీర్షిక.

32
00:01:48,890 --> 00:01:52,360
మేము నిర్ధారించుకోండి చూడాలని
n ఫైలు సరైన బిట్మ్యాప్ ఉంది.

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

34
00:01:52,640 --> 00:01:55,100
>> కాబట్టి ఇప్పుడు మేము ఆరంభమవుతుంది చేస్తున్నారు
కొన్ని మార్పులతో.

35
00:01:55,100 --> 00:01:58,840
మేము మారుతున్న కావడం వలన
విషయాలు, మేము మొదటి గుర్తు

36
00:01:58,840 --> 00:02:01,510
n ఫైలు యొక్క పాత వెడల్పు.

37
00:02:01,510 --> 00:02:05,160
మేము పాత పాడింగ్ గుర్తు
అదే లెక్కింపు ఉపయోగించి n ఫైల్

38
00:02:05,160 --> 00:02:06,990
copy.c. నుండి

39
00:02:06,990 --> 00:02:09,840
>> ఇప్పుడు మేము మార్చడానికి వెళుతున్న
బిట్మ్యాప్ సమాచారం శీర్షిక.

40
00:02:09,840 --> 00:02:13,630
అందువలన మేము వెడల్పు రెండు గుణించడం చేస్తున్నారు
మరియు నుండి అంశం ఎత్తు

41
00:02:13,630 --> 00:02:15,750
మేము స్కేలింగ్ ఏమిటి.

42
00:02:15,750 --> 00:02:18,420
మేము గుర్తించడానికి చూడాలని
ఫైలు ద్వారా కొత్త పాడింగ్

43
00:02:18,420 --> 00:02:21,140
కొత్త వెడల్పు ఉపయోగించి.

44
00:02:21,140 --> 00:02:27,330
మరియు మేము కొత్త గుర్తించడానికి చూడాలని
సంఖ్య ఉపయోగించి చిత్రం యొక్క పరిమాణం

45
00:02:27,330 --> 00:02:31,610
అన్నారు ఇది ఒక వరుసగా బైట్లు
వరుసగా పిక్సెళ్ళు సంఖ్య అని

46
00:02:31,610 --> 00:02:35,960
సార్లు పిక్సెల్ పరిమాణం ప్లస్
చివరిలో పాడింగ్ బైట్లు సంఖ్య

47
00:02:35,960 --> 00:02:40,310
ఆ వరుస యొక్క, మరియు అన్ని గుణించడం
మేము కలిగి వరుసల సంఖ్య ద్వారా.

48
00:02:40,310 --> 00:02:43,800
కాబట్టి ఆ బైట్లు సంఖ్య ఉంది
మేము మా చిత్రం డేటా కలిగి.

49
00:02:43,800 --> 00:02:48,190
>> Bf.Bfsize ఇప్పుడు సంఖ్య అన్నారు
మా చిత్రం బీటా లో బైట్లు ప్లస్

50
00:02:48,190 --> 00:02:49,350
మా శీర్షికలు యొక్క పరిమాణం.

51
00:02:49,350 --> 00:02:53,910
బిట్మ్యాప్ ఫైల్ హెడర్ కాబట్టి ప్లస్ పరిమాణం
మరియు బిట్మ్యాప్ సమాచారం శీర్షిక యొక్క పరిమాణం.

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

53
00:02:54,510 --> 00:02:56,440
కాబట్టి మా శీర్షికలు కోసం ఇది.

54
00:02:56,440 --> 00:02:59,030
మేము ఫైలు తల వ్రాసి చేయవచ్చు
మా అవ్ట్ సమాచారం శీర్షిక

55
00:02:59,030 --> 00:03:01,590
ఫైల్, మరియు మేము మధురంగా.

56
00:03:01,590 --> 00:03:03,800
>> ఇప్పుడు ఇది నిజానికి ప్రారంభించడానికి సమయం
పిక్సెల్ రాయడం

57
00:03:03,800 --> 00:03:05,120
ఫైలు అవుట్ డేటా.

58
00:03:05,120 --> 00:03:10,460
మేము పరిమాణం ఒక బఫర్ ప్రకటించాలని వెళుతున్న
పాత వెడల్పు RGB ట్రిపుల్స్, మరియు మేము ఉన్నాము

59
00:03:10,460 --> 00:03:13,790
ఒక వేరియబుల్ అని అన్నారు
మేము చూడాలని ఇది వరుసగా నంబ్,

60
00:03:13,790 --> 00:03:15,640
ప్రారంభంలో ప్రతికూల 1 సమానము.

61
00:03:15,640 --> 00:03:19,090
మేము ఉపయోగించి కావడం చేస్తున్న చూస్తారు
ఏ ట్రాక్ క్రమంలో

62
00:03:19,090 --> 00:03:22,640
మేము ప్రస్తుతం లోడుచేసినతరువాత వరుసగా
ఈ బఫర్ లోకి.

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

64
00:03:23,290 --> 00:03:28,750
>> కాబట్టి ఇప్పుడు, ప్రామాణిక ఎడిషన్ కాకుండా
బదులుగా లో పైగా iterating

65
00:03:28,750 --> 00:03:32,900
ఫైలు, మేము ప్రతి పైగా iterate చూడాలని
ఫైలు అవుట్ లో వరుస మరియు గుర్తించడానికి

66
00:03:32,900 --> 00:03:38,130
మేము మీరు లో ఫైలు లో ఇది వరుసగా
ఫైలు అవుట్ లో ఈ వరుసగా ఉంచండి.

67
00:03:38,130 --> 00:03:44,930
కాబట్టి అన్ని వరుసలు పైగా iterating
కొత్త ఎత్తు ఉపయోగించి దాఖలు, మేము మొదటి ఉన్నారు

68
00:03:44,930 --> 00:03:48,890
పాత లో వరుసగా నిర్ణయించే అన్నారు
మేము, ఇది ఉపయోగించడానికి వెళుతున్న దాఖలు

69
00:03:48,890 --> 00:03:53,560
ఈ ప్రస్తుత తీసుకొని చేయబోవడం
వరుసగా అంశం ద్వారా విభజించబడింది.

70
00:03:53,560 --> 00:03:58,000
కాబట్టి మాకు వరుసగా ఇవ్వడం అవకాశముంది
మేము కావలసిన పాత ఫైలు లో.

71
00:03:58,000 --> 00:04:03,310
>> కాబట్టి ఇప్పుడు ఉంటే వరుసగా నంబ్ సమానం కాదు పాత y చేస్తుంది,
మేము వరుస చదవడానికి చూడాలని

72
00:04:03,310 --> 00:04:05,940
మేము మా ప్రస్తుత వరుసగా బఫర్ లోకి కావలసిన.

73
00:04:05,940 --> 00:04:07,700
కాబట్టి మేము ఎలా అలా వెళ్తున్నారు?

74
00:04:07,700 --> 00:04:11,650
మొదటి, మేము గుర్తించడానికి చూడాలని
లో ఆ వరుస మొదలై స్థానం

75
00:04:11,650 --> 00:04:13,100
అసలు ఫైల్.

76
00:04:13,100 --> 00:04:18,630
కాబట్టి ఆ స్థానం అన్నారు
మా శీర్షికలు అన్ని మరియు గత

77
00:04:18,630 --> 00:04:21,589
ఇప్పుడు గత పాత y వరుసలు.

78
00:04:21,589 --> 00:04:23,880
>> కాబట్టి ఎన్ని బైట్లు
ఒకే వరుసలో ఉన్న?

79
00:04:23,880 --> 00:04:28,740
మళ్ళీ, మూడు రెట్లు RGB యొక్క పరిమాణం పాత
వెడల్పు ప్లస్ పాత పాడింగ్, అలా ఆ

80
00:04:28,740 --> 00:04:30,640
ఒకే వరుసగా బైట్లు సంఖ్య.

81
00:04:30,640 --> 00:04:33,680
మరియు మేము గత పాత y వరుసలు వెళ్ళకండి.

82
00:04:33,680 --> 00:04:37,580
కాబట్టి మేము f కోరుకుంటారు చూడాలని మరియు మేము ఉన్నాము
నుండి ప్రారంభించడానికి సెట్ కోరుకుంటారు ఉపయోగించి

83
00:04:37,580 --> 00:04:39,100
ఒక ఫైలు ప్రారంభం.

84
00:04:39,100 --> 00:04:42,740
మేము ఈ స్థానానికి కోరుకుంటారు f చూడాలని
ఫైలు లో, మాకు ఉంచడం

85
00:04:42,740 --> 00:04:46,500
మేము వరుసగా ప్రారంభం
మా బఫర్ లోకి చదవడానికి.

86
00:04:46,500 --> 00:04:48,510
>> మేము వరుసగా సెట్ చూడాలని
పాత y సమానంగా నంబ్.

87
00:04:48,510 --> 00:04:53,080
కాబట్టి ఇప్పుడు మేము లూప్ తిరిగి మరియు మేము కావలసిన
మా అవ్ట్ ఫైలు లో అదే వరుస ఉపయోగించడానికి,

88
00:04:53,080 --> 00:04:55,970
అప్పుడు మేము చదవడానికి వెళ్ళి లేదు
అది మళ్ళీ అనవసరంగా.

89
00:04:55,970 --> 00:04:59,310
కాబట్టి నిజంగా, వరుసగా నంబ్ ఉంది
కేవలం కనిపి.

90
00:04:59,310 --> 00:05:05,500
>> చివరకు, మేము చదవడానికి చూడాలని
ప్రస్తుత వరుస పాత వెడల్పు RGB ట్రిపుల్స్

91
00:05:05,500 --> 00:05:08,040
మేము అసలు ఫైల్ నుండి కావలసిన.

92
00:05:08,040 --> 00:05:12,270
కాబట్టి ఇప్పుడు ప్రస్తుత వరుసగా నుండి పిక్సెళ్ళు కలిగి
మేము కావలసిన అసలు ఫైల్

93
00:05:12,270 --> 00:05:14,200
ఫైలు అవుట్ లోకి రాయడానికి.

94
00:05:14,200 --> 00:05:18,960
కాబట్టి ఇప్పుడు, కేవలం పైన ఇష్టం, బదులుగా
పాత ఫైలు మీద iterating, మేము అవసరం

95
00:05:18,960 --> 00:05:22,560
కొత్త ఫైళ్లు వరుసలు పైగా iterate.

96
00:05:22,560 --> 00:05:27,450
బాగా ఇక్కడ, బదులుగా మీద iterating యొక్క అన్ని
పాత పిక్సెళ్ళు ఆ ప్రస్తుత వరుసగా,

97
00:05:27,450 --> 00:05:31,210
మేము అన్ని పైగా iterate మీరు
ఈ లో మా కొత్త ఫైల్లోని పిక్సెల్స్

98
00:05:31,210 --> 00:05:32,480
ప్రత్యేక వరుసగా.

99
00:05:32,480 --> 00:05:34,140
>> ఎందుకు మేము అలా అనుకుంటున్నారు?

100
00:05:34,140 --> 00:05:38,960
మేము లేదు ఇక్కడ చూడండి ఎందుకంటే
నిజానికి తప్పనిసరిగా అన్ని ఉపయోగించి

101
00:05:38,960 --> 00:05:41,020
అసలు ఫైల్లోని పిక్సెల్స్.

102
00:05:41,020 --> 00:05:46,630
మేము తగ్గిపోతున్న చేస్తుంటే, మేము ఎందుకంటే
నిజానికి పిక్సెళ్ళు వెళ్ళకండి.

103
00:05:46,630 --> 00:05:48,090
మరియు మేము ఈ చూడండి -

104
00:05:48,090 --> 00:05:49,690
x అంశం ద్వారా విభజించబడింది -

105
00:05:49,690 --> 00:05:55,620
మేము Y చెప్పారు పేరు దగ్గరగా ఇక్కడ అద్దం
గుర్తించడానికి అంశం ద్వారా విభజించబడింది ఆ

106
00:05:55,620 --> 00:06:02,480
పాత y-th వరుస అనుగుణంగా
ఈ కొత్త ఫైలు లో y-th వరుస.

107
00:06:02,480 --> 00:06:05,880
>> ఇప్పుడు మేము అన్ని రాయాలో
పాత వరుసగా నుండి ఈ పిక్సెళ్ళు

108
00:06:05,880 --> 00:06:07,440
మా కొత్త వరుసలో.

109
00:06:07,440 --> 00:06:10,890
మేము ఉండే చేసిన, మేము అవసరం కేవలం
మా వరుస చివరిలో పాడింగ్ చాలు

110
00:06:10,890 --> 00:06:15,540
మరియు మేము తిరిగి లూప్ చేస్తాము మరియు కొనసాగుతుందని
మా కొత్త ఫైలు లో అన్ని వరుసలను.

111
00:06:15,540 --> 00:06:19,390
చివరిలో, మేము మా పాత దగ్గరగా అవసరం
, ఫైల్ మా కొత్త ఫైలు మూసివేయండి, తిరిగి

112
00:06:19,390 --> 00:06:21,540
సున్నా నష్టమూ వెళ్లిన కారణంగా.

113
00:06:21,540 --> 00:06:24,220
>> నా పేరు రాబ్ ఉంది మరియు ఈ రీసెస్ ఉంది.

114
00:06:24,220 --> 00:06:29,184
>> [MUSIC ప్లే]