1
00:00:00,000 --> 00:00:12,240
>> [ಸಂಗೀತ]

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
ನಾವು ಭಾವಿಸುತ್ತೇವೆ ಒಮ್ಮೆ ನಾವು ಕೇವಲ
ಅಟೊಯ್ ಬಳಸಿಕೊಂಡು ಒಂದು ಪೂರ್ಣಾಂಕ ಎನ್ ಪರಿವರ್ತಿಸಲು.

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
ಈಗ ನಾವು ಖಚಿತವಾಗಿ ಎನ್ ಹೊಂದಿದೆ ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಿ ಬಯಸುವ
ಪರಿಧಿಯಿಂದ ಒಳಗೆ ನಾವು ನಿರೀಕ್ಷಿಸಬಹುದು, ಆದ್ದರಿಂದ

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
ನಾವು ನಮ್ಮ ಅಗಲ ಗುಣಿಸುವುದು ನೀನು
ಎನ್, ನಾವು ಮೂಲಕ ಅಗಲ ಅಳೆಯುವುದು ನೀವು ರಿಂದ

33
00:02:11,200 --> 00:02:15,100
ನಾವು ಕಾರಣ 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
ಸರಿ, ಹೆಡರ್.

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
>> ನಾವು ಮೇಲೆ ಮರಳಿ ಬಯಸುವ
, infile ನ ಸ್ಕ್ಯಾನ್ ಸಾಲುಗಳನ್ನು.

52
00:03:15,720 --> 00:03:17,730
ನಾವು oldheight ಮೇಲೆ ಮರಳಿ ಬಯಸುವ.

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 ಬಾರಿ ಮರಳಿ ಬಯಸುವ
ನಮ್ಮ 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
ಈ ಲೂಪ್ ಒಳಗೆ ಏಕೆ ಆ
ಕೇವಲ ಎನ್ ಸಾಲುಗಳನ್ನು ಔಟ್ ಮುದ್ರಿಸುವ

71
00:04:25,050 --> 00:04:28,400
, infile ಈ ಒಂದು ಸಾಲು.

72
00:04:28,400 --> 00:04:32,150
ನಂತರ ಕೆಳಗೆ ಇಲ್ಲಿ, ನಾನು ಮೇಲೆ ತೆರಳಿ ಪಡೆಯಲಿದ್ದೇನೆ
, 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
>> ಅಂತಿಮವಾಗಿ, ಒಮ್ಮೆ ನಾವು ಎಲ್ಲಾ ಪೂರೈಸಿದ,
ನಾವು ಹತ್ತಿರ, outfile ಮುಚ್ಚಿ ಮಾಡಬಹುದು

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
>> [ಸಂಗೀತ]