1
00:00:00,000 --> 00:00:09,500
>> [ಸಂಗೀತ]

2
00:00:09,500 --> 00:00:12,350
>> ZAMYLA ಚಾನ್: ಇದು ಮಿಸ್ ಸ್ಕಾರ್ಲೆಟ್ ಆಗಿತ್ತು
ಕ್ಯಾಂಡಲ್ ಜೊತೆ.

3
00:00:12,350 --> 00:00:13,560
ವೊಡುನಿಟ್?

4
00:00:13,560 --> 00:00:15,030
ಹಾಗೆಯೇ, ನಾವು ಕಂಡುಹಿಡಿಯಲು ನೀನು.

5
00:00:15,030 --> 00:00:20,870
ಬೋರ್ಡ್ ಆಟ ಸುಳಿವಿನ, ನೀವು ಬಹುಶಃ
ಒಂದು ಭೌತಿಕ ಕೆಂಪು ಚಿತ್ರವನ್ನು ನೀಡಲಾಗುವುದು.

6
00:00:20,870 --> 00:00:24,120
ಮತ್ತು ಚಿತ್ರದ ತುಂಬಾ ಕೆಂಪು ಮತ್ತು
ಕಲೆಯುಳ್ಳ, ಮತ್ತು ನಿಮ್ಮ ಕೆಲಸ ಮಾಡುವುದು

7
00:00:24,120 --> 00:00:25,490
ಗುಪ್ತ ಸಂದೇಶ ಬಹಿರಂಗ.

8
00:00:25,490 --> 00:00:29,740
ಮತ್ತು ಸಾಮಾನ್ಯವಾಗಿ ನೀವು ಒಂದು ಕೆಂಪು ಒದಗಿಸಲಾಗುತ್ತದೆ ಮಾಡುತ್ತಿದ್ದೇವೆ
ಭೂತಗನ್ನಡಿಯಿಂದ, ಅಥವಾ ಒಂದು ಕೆಂಪು ಪರದೆಯ

9
00:00:29,740 --> 00:00:31,410
ಎಂದು ಗುಪ್ತ ಸಂದೇಶ ಬಹಿರಂಗ.

10
00:00:31,410 --> 00:00:33,340
ಅಲ್ಲದೆ, ನಾವು ಅನುಕರಿಸಲು ನೀನು.

11
00:00:33,340 --> 00:00:37,960
>> ವೊಡುನಿಟ್ ರಲ್ಲಿ, ನೀವು ಒಂದು ಬಿಟ್ಮ್ಯಾಪ್ ಚಿತ್ರ ನೀಡಿದ ನೀವು
ಎಂದು, ಬಹಳ ಕಲೆಯುಳ್ಳ ಮತ್ತು ಕೆಂಪು ಕಾಣುತ್ತದೆ

12
00:00:37,960 --> 00:00:43,430
ತದನಂತರ ವೊಡುನಿಟ್ ಪ್ರೋಗ್ರಾಂ
ಒಂದು ಗುಪ್ತ ಸಂದೇಶ ಬಹಿರಂಗಪಡಿಸಲು.

13
00:00:43,430 --> 00:00:45,650
>> ಆದ್ದರಿಂದ ಹಂತಗಳನ್ನು ಈ ಮುರಿಯಲು ಅವಕಾಶ.

14
00:00:45,650 --> 00:00:50,390
ಮೊದಲ, ನೀವು ಕಡತವನ್ನು ತೆರೆಯಲು ಬಯಸುವ -
ನೀವು ನೀಡಲಾಗಿದೆ ಎಂಬುದನ್ನು ಸುಳಿವು.

15
00:00:50,390 --> 00:00:53,880
ತದನಂತರ ಒಂದು ರಚಿಸಲು
ತೀರ್ಪು ಬಿಟ್ಮ್ಯಾಪ್ ಕಡತ.

16
00:00:53,880 --> 00:00:58,240
ನಂತರ ನೀವು ಬಿಟ್ಮ್ಯಾಪ್ ನವೀಕರಿಸಲು ಬಯಸುತ್ತೀರಾ
ತೀರ್ಪು outfile ಫಾರ್ ಮಾಹಿತಿಯನ್ನು ಹೆಡರ್.

17
00:00:58,240 --> 00:00:59,920
ನಂತರ ಮೇಲೆ ಹೆಚ್ಚು.

18
00:00:59,920 --> 00:01:04,319
ತದನಂತರ ನೀವು ಒಳಗೆ ಓದಲು ನೀನು
ಸುಳಿವು, scanline, ಪಿಕ್ಸೆಲ್ ಮೂಲಕ ಪಿಕ್ಸೆಲ್,

19
00:01:04,319 --> 00:01:07,320
ಮಾಹಿತಿ ಪಿಕ್ಸೆಲ್ ಬಣ್ಣಗಳನ್ನು ಬದಲಾಯಿಸುವ
ಅಗತ್ಯ, ಮತ್ತು ಬರವಣಿಗೆ

20
00:01:07,320 --> 00:01:08,960
ತೀರ್ಪು ಆ -

21
00:01:08,960 --> 00:01:12,000
ಆಗಿ ಪಿಕ್ಸೆಲ್ ಮೂಲಕ ಪಿಕ್ಸೆಲ್
ತೀರ್ಪು scanline.

22
00:01:12,000 --> 00:01:13,780
>> ಹೇಗೆ ನಾವು ಈ ಬಗ್ಗೆ ಹೋಗುವ ಆರಂಭಿಸಲು ಇಲ್ಲ?

23
00:01:13,780 --> 00:01:16,940
ಅಲ್ಲದೆ, ಅದೃಷ್ಟವಶಾತ್, ನಾವು copy.c ಹೊಂದಿವೆ
ಹಂಚಿಕೆ ಕೋಡ್.

24
00:01:16,940 --> 00:01:21,240
ಮತ್ತು ಈ ಸಾಬೀತುಪಡಿಸಲು ನಾನು
ನಮಗೆ ಸಾಕಷ್ಟು ಉಪಯುಕ್ತ.

25
00:01:21,240 --> 00:01:29,700
Copy.c, ಒಂದು ಕಡತ ತೆರೆಯುತ್ತದೆ ಓದುತ್ತದೆ
ನಂತರ, infile ಹೆಡರ್, ಮತ್ತು ನವೀಕರಣಗಳನ್ನು

26
00:01:29,700 --> 00:01:31,070
outfile ಹೆಡರ್.

27
00:01:31,070 --> 00:01:37,010
ನಂತರ ಇದು ಪ್ರತಿ ಪಿಕ್ಸೆಲ್ ಓದುತ್ತದೆ
ನಂತರ scanline, ಪಿಕ್ಸೆಲ್ ಮೂಲಕ ಪಿಕ್ಸೆಲ್, ಮತ್ತು

28
00:01:37,010 --> 00:01:42,390
outfile ಆಗಿ ಪಿಕ್ಸೆಲ್ ಬರೆಯುತ್ತಾರೆ.

29
00:01:42,390 --> 00:01:45,020
>> ಆದ್ದರಿಂದ, ನಿಮ್ಮ ಮೊದಲ ಹಂತದ might
ಕೆಳಗಿನ ಓಟವನ್ನು

30
00:01:45,020 --> 00:01:46,420
ಟರ್ಮಿನಲ್ ಆಜ್ಞೆಯನ್ನು -

31
00:01:46,420 --> 00:01:50,270
CP copy.c whodunit.c.

32
00:01:50,270 --> 00:01:55,320
ಈ ಪ್ರತಿಯನ್ನು ರಚಿಸುತ್ತದೆ
copy.c whodunit.c ಹೆಸರಿನ.

33
00:01:55,320 --> 00:01:58,320
ಆದ್ದರಿಂದ ತೆರೆಯಲು ನಮ್ಮ ಮೊದಲ ಹಂತದ
ಕಡತ, ಚೆನ್ನಾಗಿ, ನಿಖರ ಇಲ್ಲ

34
00:01:58,320 --> 00:02:00,070
copy.c. ಆ ಪ್ರತಿಕೃತಿ

35
00:02:00,070 --> 00:02:03,360
ಹಾಗಾಗಿ ನೋಡಲು ನೀವು ಬಿಟ್ಟು ಮಾಡುತ್ತೇವೆ.

36
00:02:03,360 --> 00:02:07,860
>> ನಾವು ಈ pset ಜೊತೆ ಇದೆ ಮಾತಾಡುತ್ತಿದ್ದೀರಿ ಏನು
ಕಡತ I / O, ಮೂಲತಃ ಕಡತಗಳನ್ನು ತೆಗೆದುಕೊಳ್ಳುವ,

37
00:02:07,860 --> 00:02:10,229
, ಓದಲು, ಬರೆಯಲು, ಸಂಪಾದನೆ.

38
00:02:10,229 --> 00:02:12,650
ನೀವು ಮೊದಲ ಒಂದು ಕಡತವನ್ನು ತೆರೆಯಲು ಇಲ್ಲ?

39
00:02:12,650 --> 00:02:16,800
ಅಲ್ಲದೆ, ನೀವು ಒಂದು ಕಡತ ಘೋಷಿಸಲು ನೀನು
ಪಾಯಿಂಟರ್, ಮತ್ತು ನಂತರ ನೀವು ಕರೆ

40
00:02:16,800 --> 00:02:18,670
ಕಾರ್ಯ fopen.

41
00:02:18,670 --> 00:02:23,150
ಮಾರ್ಗ, ಅಥವಾ ಆ ಹೆಸರಿನಲ್ಲಿ ಪಾಸ್
ಫೈಲ್, ಮತ್ತು ನಂತರ ನೀವು ಬಯಸುವ ಕ್ರಮದಲ್ಲಿ

42
00:02:23,150 --> 00:02:24,700
ಸೈನ್ ಕಡತವನ್ನು ತೆರೆಯಲು

43
00:02:24,700 --> 00:02:28,620
ಆರ್ ಸಾಗುವ ತೆರೆಯುತ್ತದೆ
ಓದುವ foo.bmp.

44
00:02:28,620 --> 00:02:35,670
ಆದರೆ ಒಂದು W ಸಾಗುವ ಜೊತೆ fopen ತಿನ್ನುವೆ
ತೆರೆದ bar.bmp, ಕಡತ ಬರೆಯಲು ಮತ್ತು

45
00:02:35,670 --> 00:02:37,020
ವಾಸ್ತವವಾಗಿ ಅದನ್ನು ಸಂಪಾದನೆ.

46
00:02:37,020 --> 00:02:41,970
>> ಈಗ ನಾವು ಫೈಲ್ ತೆರೆಯಿತು ನೀವು, ನಮ್ಮ
ಮುಂದಿನ ಹಂತದ ಹೆಡರ್ ಮಾಹಿತಿಯನ್ನು ನವೀಕರಿಸಲು ಆಗಿದೆ

47
00:02:41,970 --> 00:02:43,230
outfile ಫಾರ್.

48
00:02:43,230 --> 00:02:44,610
ಒಂದು ಹೆಡರ್ ಮಾಹಿತಿಯನ್ನು ಯಾವುದು?

49
00:02:44,610 --> 00:02:48,160
ಸರಿ, ಮೊದಲ ನಾವು ತಿಳಿದುಕೊಳ್ಳಬೇಕು
ಏನು ಒಂದು ಬಿಟ್ಮ್ಯಾಪ್.

50
00:02:48,160 --> 00:02:51,000
ಒಂದು ಬಿಟ್ಮ್ಯಾಪ್ ಕೇವಲ ಒಂದು ಸರಳ
ಬೈಟ್ಗಳು ವ್ಯವಸ್ಥೆ.

51
00:02:51,000 --> 00:02:55,480
ಮತ್ತು ಅವರು ಈ ಫೈಲ್ ಘೋಷಿಸಲಾಗಿದೆ ಮಾಡುತ್ತಿದ್ದೇವೆ
ಒಂದು ಗುಂಪನ್ನು ಇಲ್ಲಿ, bmp.h,

52
00:02:55,480 --> 00:02:58,610
ಏನು ಒಂದು ಬಿಟ್ಮ್ಯಾಪ್ ಆಫ್ ಮಾಹಿತಿ
ವಾಸ್ತವವಾಗಿ ಔಟ್ ಮಾಡಲಾಗುತ್ತದೆ.

53
00:02:58,610 --> 00:03:05,730
ಆದರೆ ನಾವು ನಿಜವಾಗಿಯೂ ಕಾಳಜಿ ಆಗಿದೆ
ಬಿಟ್ಮ್ಯಾಪ್ ಕಡತ ಹೆಡರ್, ಇಲ್ಲಿಯೇ, ಮತ್ತು

54
00:03:05,730 --> 00:03:08,460
ಇಲ್ಲಿ ಬಿಟ್ಮ್ಯಾಪ್ ಮಾಹಿತಿಯನ್ನು ಹೆಡರ್,.

55
00:03:08,460 --> 00:03:13,170
ಹೆಡರ್ ಒಂದೆರಡು ಕೂಡಿದೆ
ಬಹಳ ಉಪಯುಕ್ತ ಸಾಬೀತು ಎಂದು ಚರಾಂಕಗಳ.

56
00:03:13,170 --> 00:03:18,400
ಇದು biSizeImage ಇಲ್ಲ
ಬೈಟ್ಗಳು ಚಿತ್ರದ ಒಟ್ಟು ಗಾತ್ರ.

57
00:03:18,400 --> 00:03:20,890
ಮತ್ತು ಈ ಪಿಕ್ಸೆಲ್ಗಳು ಮತ್ತು ಪ್ಯಾಡಿಂಗ್ ಒಳಗೊಂಡಿದೆ.

58
00:03:20,890 --> 00:03:24,210
ಪ್ಯಾಡಿಂಗ್ ಬಹಳ ಮುಖ್ಯ, ಆದರೆ
ನಾವು ನಂತರ ಆ ಪಡೆಯುತ್ತೀರಿ.

59
00:03:24,210 --> 00:03:30,000
>> BiWidth ಅಗಲ ಪ್ರತಿನಿಧಿಸುತ್ತದೆ
ಪಿಕ್ಸೆಲ್ಗಳು ಮೈನಸ್ ಪ್ಯಾಡಿಂಗ್ ಚಿತ್ರ.

60
00:03:30,000 --> 00:03:34,220
BiHeight ನಂತರ ಎತ್ತರ
ಪಿಕ್ಸೆಲ್ಗಳಲ್ಲಿ ಚಿತ್ರದ.

61
00:03:34,220 --> 00:03:38,240
ತದನಂತರ BITMAPFILEHEADER ಮತ್ತು
ನಾನು ಹೇಳಿದಂತೆ BITMAPINFOHEADER,

62
00:03:38,240 --> 00:03:40,900
ಹಿಂದಿನ, ಆ ಪ್ರತಿನಿಧಿಸುತ್ತದೆ
ಸ್ಟ್ರಕ್ಟ್ಸ್ಳ ಎಂದು.

63
00:03:40,900 --> 00:03:45,410
ಆದ್ದರಿಂದ, ನೀವು ಕಡತ ಹೆಡರ್ ಪ್ರವೇಶಿಸಲು ಸಾಧ್ಯವಿಲ್ಲ
ಸ್ವತಃ, ಆದರೆ ನೀವು ಪಡೆಯಲು ಬಯಸುವಿರಿ

64
00:03:45,410 --> 00:03:47,370
ಒಳಗೆ ಆ ಅಸ್ಥಿರ.

65
00:03:47,370 --> 00:03:48,170
>> ಸರಿ.

66
00:03:48,170 --> 00:03:50,600
ಆದ್ದರಿಂದ ಹೇಗೆ ನಾವು ಹೆಡರ್ ಮಾಹಿತಿಯನ್ನು ಅಪ್ಡೇಟ್ ಇಲ್ಲ?

67
00:03:50,600 --> 00:03:54,020
ಸರಿ, ಮೊದಲ ನಾವು ನೋಡಲು ಹೊಂದಿವೆ ನಾವು ಎಂಬುದನ್ನು
ಯಾವುದೇ ಮಾಹಿತಿಯನ್ನು ಬದಲಾಯಿಸಲು ಅಗತ್ಯವಿದೆ

68
00:03:54,020 --> 00:03:58,480
ಗೆ, infile, ಸುಳಿವು,
outfile, ತೀರ್ಪು.

69
00:03:58,480 --> 00:04:00,250
ಏನು ಈ ಸಂದರ್ಭದಲ್ಲಿ ಬದಲಾಗುತ್ತಿರುವ?

70
00:04:00,250 --> 00:04:04,320
ಅಲ್ಲದೆ, ವಾಸ್ತವವಾಗಿ, ನಾವು ನೀನು ಏಕೆಂದರೆ
ಕೇವಲ ಬಣ್ಣಗಳ ಬದಲಾಗುತ್ತಿರುವ.

71
00:04:04,320 --> 00:04:07,550
ನಾವು ಕಡತ ಬದಲಾವಣೆ ಹೋಗುತ್ತಿಲ್ಲ
ಗಾತ್ರ, ಚಿತ್ರದ ಗಾತ್ರ, ಅಗಲ,

72
00:04:07,550 --> 00:04:08,310
ಅಥವಾ ಎತ್ತರ.

73
00:04:08,310 --> 00:04:14,010
ಆದ್ದರಿಂದ ನೀವು ಈಗ ಎಲ್ಲಾ ಸರಿ
ಕೇವಲ ಪ್ರತಿ ಪಿಕ್ಸೆಲ್ ನಕಲು.

74
00:04:14,010 --> 00:04:14,840
>> ಸರಿ.

75
00:04:14,840 --> 00:04:20,720
ಈಗ ಹೇಗೆ ನಾವು ವಾಸ್ತವವಾಗಿ ನೋಡೋಣ
ಕಡತದಿಂದ ಪ್ರತಿ ಪಿಕ್ಸೆಲ್ ಓದಬಹುದು.

76
00:04:20,720 --> 00:04:23,640
ಇನ್ನೊಂದು ಫೈಲ್ ನಾನು / ಒ ಕಾರ್ಯ
ಕಾರ್ಯರೂಪಕ್ಕೆ ಬರುತ್ತವೆ -

77
00:04:23,640 --> 00:04:24,700
fread.

78
00:04:24,700 --> 00:04:28,440
ಇದು struct ಒಂದು ಪಾಯಿಂಟರ್ ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ
ಬೈಟ್ಗಳು ಹೊಂದಿರುವ ಆ

79
00:04:28,440 --> 00:04:30,110
ನೀವು ಓದುವ ಬಳಸುತ್ತಿದ್ದರೆ.

80
00:04:30,110 --> 00:04:31,890
ಆದ್ದರಿಂದ ನೀವು ಒಳಗೆ ಓದುವ ಬಳಸುತ್ತಿದ್ದರೆ.

81
00:04:31,890 --> 00:04:36,090
ತದನಂತರ ನೀವು ಇದು, ಒಂದು ಗಾತ್ರ ರವಾನಿಸಲು
ಪ್ರತಿ ಅಂಶ ಗಾತ್ರವನ್ನು ನೀವು

82
00:04:36,090 --> 00:04:37,360
ಓದಲು ಬಯಸುವ.

83
00:04:37,360 --> 00:04:40,640
ಇಲ್ಲಿ, ಕಾರ್ಯ sizeof
HANDY ಬರುತ್ತವೆ.

84
00:04:40,640 --> 00:04:45,570
ನಂತರ ನೀವು, ಹಲವು ಪಾಸ್ ಇದು
ಅಂಶಗಳನ್ನು ಸಂಖ್ಯೆಯನ್ನು ಪ್ರತಿನಿಧಿಸುತ್ತದೆ

85
00:04:45,570 --> 00:04:47,480
ಓದಲು ಗಾತ್ರ.

86
00:04:47,480 --> 00:04:51,180
ತದನಂತರ ಅಂತಿಮವಾಗಿ, inptr, ಇದು
ನೀವು ನೀವು ಫೈಲ್ನಲ್ಲಿ ಪಾಯಿಂಟರ್

87
00:04:51,180 --> 00:04:52,530
ನಿಂದ ಓದಲು ವಿಶೇಷವೇನು.

88
00:04:52,530 --> 00:04:58,650
ಆದ್ದರಿಂದ ಆ ಅಂಶಗಳನ್ನು ಎಲ್ಲಾ ಒಳಗೆ
inptr ಮತ್ತು ಅವರು ಡೇಟಾ ನೀನು.

89
00:04:58,650 --> 00:05:01,660
>> ನ ಸ್ವಲ್ಪ ಉದಾಹರಣೆಯನ್ನು ನೋಡೋಣ.

90
00:05:01,660 --> 00:05:07,590
ನಾನು ದಶಮಾಂಶ ಎರಡು ನಾಯಿಗಳು ಒಳಗೆ ಓದಲು ಬಯಸಿದರೆ,
ಅಲ್ಲದೆ, ನಾನು ಎರಡು ವಿಧಾನಗಳಲ್ಲಿ ಒಂದು ಮಾಡಬಹುದು.

91
00:05:07,590 --> 00:05:15,250
ನಾನು ಎರಡೂ ಗಾತ್ರದ ಎರಡು ವಸ್ತುಗಳು ಓದಬಹುದು
ನನ್ನ inptr ರಿಂದ ನಾಯಿ, ಅಥವಾ ನಾನು ಓದಬಹುದು

92
00:05:15,250 --> 00:05:19,280
ಒಂದು ಎರಡು ನಾಯಿಗಳು ಗಾತ್ರವನ್ನು ವಸ್ತು.

93
00:05:19,280 --> 00:05:23,580
ಆದ್ದರಿಂದ ನೀವು ನೋಡಿ ಆ ರೀತಿಯಲ್ಲಿ ಅವಲಂಬಿಸಿ
ನೀವು, ನೀವು ಗಾತ್ರ ಮತ್ತು ಸಂಖ್ಯೆ ವ್ಯವಸ್ಥೆ

94
00:05:23,580 --> 00:05:25,840
ಬೈಟ್ಗಳು ಒಂದೇ ಸಂಖ್ಯೆಯ ಓದಬಹುದು.

95
00:05:25,840 --> 00:05:28,720

96
00:05:28,720 --> 00:05:33,020
>> ಈಗ, ನ ಬದಲಾಯಿಸಲು ಅವಕಾಶ
ನಾವು ಅಗತ್ಯವಿದೆ ಪಿಕ್ಸೆಲ್ ಬಣ್ಣ.

97
00:05:33,020 --> 00:05:37,320
ನೀವು ಮತ್ತೆ bmp.h ನೋಡಿದರೆ, ನಂತರ
ನೀವು ಕೆಳಗೆ ನೋಡುತ್ತಾರೆ

98
00:05:37,320 --> 00:05:42,920
RGBTRIPLEs, ಮತ್ತೊಂದು struct ಅಲ್ಲಿ
ಅವರು ಮೂರು ಬೈಟ್ಗಳು ಒಳಗೊಂಡಿರುವುದರಿಂದ.

99
00:05:42,920 --> 00:05:49,220
ಒಂದು,, rgbtBlue, rgbtGreen, ಮತ್ತು rgbtRed.

100
00:05:49,220 --> 00:05:52,480
ಆದ್ದರಿಂದ ಈ ಪ್ರತಿಯೊಂದು ಪ್ರಮಾಣವನ್ನು ಸೂಚಿಸುತ್ತದೆ
ನೀಲಿ, ಹಸಿರು ಪ್ರಮಾಣವನ್ನು ಮತ್ತು

101
00:05:52,480 --> 00:05:57,250
ಈ ಪಿಕ್ಸೆಲ್ ಒಳಗೆ ಕೆಂಪು, ಪ್ರಮಾಣವನ್ನು ಅಲ್ಲಿ
ಪ್ರತಿ ಪ್ರಮಾಣದ ಪ್ರತಿನಿಧಿಸುತ್ತದೆ

102
00:05:57,250 --> 00:05:58,670
ಹೆಕ್ಸಾಡೆಸಿಮಲ್ ಸಂಖ್ಯೆ.

103
00:05:58,670 --> 00:06:04,370
>> ಆದ್ದರಿಂದ ff0000 ನೀಲಿ ಬಣ್ಣವನ್ನು ಇರುತ್ತದೆ,
ಇದು ನೀಲಿ ಹೋಗುತ್ತದೆ, ಏಕೆಂದರೆ

104
00:06:04,370 --> 00:06:05,850
ಕೆಂಪು, ಹಸಿರು.

105
00:06:05,850 --> 00:06:09,300
ತದನಂತರ ಎಲ್ಲಾ ಎಫ್ ಬಿಳಿ ಕಾಣಿಸುತ್ತದೆ.

106
00:06:09,300 --> 00:06:13,440
ನ smiley.bmp ಒಂದು ನೋಟ, ನೋಡೋಣ ಇದು
ನಿಮ್ಮ ವಿತರಣೆ ಕೋಡ್ ಹೊಂದಿವೆ.

107
00:06:13,440 --> 00:06:15,690
ನೀವು ಕೇವಲ ಒಂದು ಚಿತ್ರದಲ್ಲಿ ಅದನ್ನು ತೆರೆಯಲು ವೇಳೆ
ನೋಡುವವನು ನೀವು ಮಾಡುತ್ತೇವೆ

108
00:06:15,690 --> 00:06:17,080
ಕೇವಲ ಕೆಂಪು ನಗು ನೋಡಿ.

109
00:06:17,080 --> 00:06:20,380
ಆದರೆ ನಾವು ಮಾಡುತ್ತೇವೆ, ಒಂದು ಆಳವಾದ ಡೈವ್ ತೆಗೆದುಕೊಳ್ಳುವ
ನೋಡಿ ರಚನೆ

110
00:06:20,380 --> 00:06:22,340
ಅದು ಕೇವಲ ಪಿಕ್ಸೆಲ್ಗಳು.

111
00:06:22,340 --> 00:06:25,880
ನಾವು ಬಿಳಿ ಪಿಕ್ಸೆಲ್ಗಳು ಹೊಂದಿವೆ,
ತದನಂತರ ಕೆಂಪು ಪಿಕ್ಸೆಲ್ಗಳು.

112
00:06:25,880 --> 00:06:31,000
ಎಲ್ಲಾ ನಂತರ, ಬಿಳಿ ffffff, ಮತ್ತು
ನಾನು ಬಣ್ಣದ ಬಂದಿದೆ ಕೆಂಪು ಪಿಕ್ಸೆಲ್ಗಳು

113
00:06:31,000 --> 00:06:35,440
ಇಲ್ಲಿ, ಮತ್ತು ನೀವು ಅವರು 0000ff ಎಂಬುದನ್ನು ನೋಡಿ.

114
00:06:35,440 --> 00:06:39,760
ಝೀರೋ ನೀಲಿ, ಶೂನ್ಯ ಹಸಿರು, ಮತ್ತು ಪೂರ್ಣ ಕೆಂಪು.

115
00:06:39,760 --> 00:06:45,350
ಮತ್ತು ನಗು ಎಂಟು ಪಿಕ್ಸೆಲ್ ಅಗಲ ರಿಂದ,
ನಾವು ಯಾವುದೇ ಪ್ಯಾಡಿಂಗ್ ಇಲ್ಲ.

116
00:06:45,350 --> 00:06:47,360
ಸರಿ.

117
00:06:47,360 --> 00:06:53,310
>> ನಾನು ವಿಭಿನ್ನ ಮೌಲ್ಯಗಳನ್ನು ನಿಯೋಜಿಸಲು ಆದ್ದರಿಂದ ವೇಳೆ
ಒಂದು RGBTRIPLE ಮತ್ತು ನಾನು ಬಯಸಿದರು

118
00:06:53,310 --> 00:06:58,350
ಇದು ಹಸಿರು ಮಾಡಿ, ನಂತರ ಏನು ನಾನು ಎಂದು ಹೊಂದಿದೆ
ನಾನು ಎಂಬ RGBTRIPLE ಘೋಷಿಸಲು

119
00:06:58,350 --> 00:07:02,660
ಟ್ರಿಪಲ್, ಮತ್ತು ನಂತರ ಪ್ರತಿ ಪ್ರವೇಶಿಸಲು
ಎಂಬುದನ್ನು struct ನಾನು ಒಳಗೆ ಬೈಟ್

120
00:07:02,660 --> 00:07:04,030
ಡಾಟ್ ಆಯೋಜಕರು ಬಳಸಲು ಎಂದು.

121
00:07:04,030 --> 00:07:08,430
ಆದ್ದರಿಂದ triple.rgbtBlue, ನಾನು
0 ಆ ನಿಯೋಜಿಸಲು.

122
00:07:08,430 --> 00:07:13,460
ಗ್ರೀನ್ ನಾನು ಪೂರ್ಣ ಅದನ್ನು ನಿಯೋಜಿಸಲು - ಯಾವುದೇ
ಸಂಖ್ಯೆ, ನಿಜವಾಗಿಯೂ, 0 ಮತ್ತು ff ನಡುವೆ.

123
00:07:13,460 --> 00:07:15,470
ತದನಂತರ ಕೆಂಪು, ನಾನು 0 ಹೇಳಲು ಪಡೆಯಲಿದ್ದೇನೆ.

124
00:07:15,470 --> 00:07:19,160
ಆದ್ದರಿಂದ ನನಗೆ ಒಂದು ಹಸಿರು ಪಿಕ್ಸೆಲ್ ನೀಡುತ್ತದೆ.

125
00:07:19,160 --> 00:07:23,030
>> ಮುಂದೆ, ನಾನು ಪರಿಶೀಲಿಸಿ ಬಯಸಿದರೆ ಏನು
ಏನೋ ಮೌಲ್ಯವನ್ನು?

126
00:07:23,030 --> 00:07:27,250
ನಾನು ಪರಿಶೀಲಿಸುತ್ತದೆ ವಿಷಯ ತೋರಿಸಬಹುದಿತ್ತು
ಟ್ರಿಪಲ್ ನ, rgbtBlue ಮೌಲ್ಯ ಎಂದು

127
00:07:27,250 --> 00:07:31,080
FF ಮತ್ತು ನಂತರ ಮುದ್ರಣ, "ನಾನು ನನ್ನದಾಗಿದೆ
ನೀಲಿ! ", ಪರಿಣಾಮವಾಗಿ.

128
00:07:31,080 --> 00:07:35,640
ಈಗ, ಅವಶ್ಯವಾಗಿ
ಪಿಕ್ಸೆಲ್ ಬಲ, ನೀಲಿ ಎಂದು?

129
00:07:35,640 --> 00:07:40,060
ಪಿಕ್ಸೆಲ್ ನ ಹಸಿರು ಮತ್ತು ಕೆಂಪು ಮೌಲ್ಯಗಳನ್ನು ಕಾರಣ
ಸಹ ಅಲ್ಲದ 0 ಮೌಲ್ಯಗಳನ್ನು ತೋರಿಸಬಹುದಿತ್ತು.

130
00:07:40,060 --> 00:07:43,470
ಈ ಎಲ್ಲಾ ಅಂದರೆ, ಮತ್ತು ಎಲ್ಲಾ
ಈ ಪರಿಶೀಲಿಸುವ ಇದೆ

131
00:07:43,470 --> 00:07:45,610
ಪೂರ್ಣ ನೀಲಿ ಬಣ್ಣ.

132
00:07:45,610 --> 00:07:50,050
ಆದರೆ ಎಲ್ಲಾ ಪಿಕ್ಸೆಲ್ಗಳು ಭಾಗಶಃ ತೋರಿಸಬಹುದಿತ್ತು
ಈ ರೀತಿಯ ಬಣ್ಣದ ಮೌಲ್ಯಗಳನ್ನು,

133
00:07:50,050 --> 00:07:52,180
ಇಲ್ಲಿ ಮುಂದಿನ ಉದಾಹರಣೆಗೆ.

134
00:07:52,180 --> 00:07:55,400
>> ಇದು ಸ್ವಲ್ಪ ಕಷ್ಟ ನೋಡಿ ಇಲ್ಲಿದೆ
ಈ ಚಿತ್ರ ಈಗ.

135
00:07:55,400 --> 00:08:00,320
ಈ ಸ್ವಲ್ಪ ತೋರುತ್ತಿದೆ
ನೀವು ನೀಡಲಾಗುವುದು ಮಾಡುತ್ತೇವೆ ಎಂದು clue.bmp.

136
00:08:00,320 --> 00:08:03,600
ಈಗ, ದೈಹಿಕವಾಗಿ, ನೀವು ಈ ಪರಿಹರಿಸಲು ಇರಬಹುದು,
ಮೂಲಕ, ಕೆಂಪು ಬಹಳಷ್ಟು ಇರುವುದರಿಂದ

137
00:08:03,600 --> 00:08:07,040
ಚಿತ್ರ ಕೆಂಪು ಪರದೆಯ ಹಿಡಿದುಕೊಂಡು ಆದ್ದರಿಂದ
ಇತರ ಬಣ್ಣಗಳನ್ನು ಕಾಣಿಸಿಕೊಳ್ಳಬಹುದು.

138
00:08:07,040 --> 00:08:10,968
ಆದ್ದರಿಂದ ಹೇಗೆ ನಾವು ಸಿ ಈ ಅನುಕರಿಸುವ ಇಲ್ಲ?

139
00:08:10,968 --> 00:08:15,640
ಹಾಗೆಯೇ, ನಾವು ಎಲ್ಲಾ ಕೆಂಪು ತೆಗೆದು ಇರಬಹುದು
ಚಿತ್ರ ಸಂಪೂರ್ಣವಾಗಿ.

140
00:08:15,640 --> 00:08:21,870
ಆದ್ದರಿಂದ ನಾವು ಪ್ರತಿ ಸೆಟ್ ಬಯಸುವ ಮಾಡಲು
0 ಪಿಕ್ಸೆಲ್ ಕೆಂಪು ಮೌಲ್ಯ.

141
00:08:21,870 --> 00:08:25,020
ಆದ್ದರಿಂದ ಚಿತ್ರ ಸ್ವಲ್ಪ ನೋಡುತ್ತಿದ್ದರು
ನಾವು ಯಾವುದೇ ಕೆಂಪು ಹೊಂದಿವೆ ಅಲ್ಲಿ ಈ ತರಹದ ಬಿಟ್

142
00:08:25,020 --> 00:08:26,300
ಇಲ್ಲ.

143
00:08:26,300 --> 00:08:29,390
>> ನಾವು ಗುಪ್ತ ಸಂದೇಶ ಒಂದು ನೋಡಬಹುದು
ಸ್ವಲ್ಪ ಹೆಚ್ಚು ಸ್ಪಷ್ಟವಾಗಿ ಈಗ.

144
00:08:29,390 --> 00:08:31,730
ಇದು ಮತ್ತೊಂದು ನಗು ಮುಖದ ಇಲ್ಲಿದೆ.

145
00:08:31,730 --> 00:08:33,870
ಅಥವಾ ಬಹುಶಃ ನಾವು ಮತ್ತೊಂದು ವಿಧಾನವನ್ನು ಬಳಸಬಹುದು.

146
00:08:33,870 --> 00:08:36,480
ಬಹುಶಃ, ನಾವು ಗುರುತಿಸಲು
ಕೆಂಪು ಪಿಕ್ಸೆಲ್ಗಳ ಎಲ್ಲಾ -

147
00:08:36,480 --> 00:08:41,100
ಎಂದು, ಪಿಕ್ಸೆಲ್ಗಳ ಎಲ್ಲಾ ಹೊಂದಿದೆ
0 ನೀಲಿ, 0 ಹಸಿರು, ಮತ್ತು ಕೆಂಪು 0 -

148
00:08:41,100 --> 00:08:43,169
ಮತ್ತು ಬಿಳಿ ಆ ಬದಲಾಯಿಸಲು.

149
00:08:43,169 --> 00:08:45,470
ಮತ್ತು ನಮ್ಮ ಚಿತ್ರವನ್ನು ನೋಡಲು ಇರಬಹುದು
ಈ ರೀತಿಯ.

150
00:08:45,470 --> 00:08:48,250
ನೋಡಲು ಸ್ವಲ್ಪ ಸುಲಭವಾಗಿ.

151
00:08:48,250 --> 00:08:51,170
>> ಬಹಿರಂಗಪಡಿಸಲು ಇತರ ಹಾದಿಗಳಿವೆ ಇವೆ
ರಹಸ್ಯ ಸಂದೇಶ ಹಾಗೂ,

152
00:08:51,170 --> 00:08:53,730
ಬಣ್ಣ ಕುಶಲ ವ್ಯವಹರಿಸುವಾಗ.

153
00:08:53,730 --> 00:08:57,050
ಬಹುಶಃ ನೀವು ವಿಧಾನಗಳಲ್ಲಿ ಒಂದನ್ನು ಬಳಸಬಹುದು
ನಾನು ಮೇಲೆ ತಿಳಿಸಿದ.

154
00:08:57,050 --> 00:08:59,600
ಮತ್ತು ಹೆಚ್ಚುವರಿಯಾಗಿ, ನೀವು ಬಯಸಬಹುದು
ಕೆಲವು ಬಣ್ಣಗಳನ್ನು ವರ್ಧಿಸಲು

155
00:08:59,600 --> 00:09:02,620
ಮತ್ತು ಆ ಹೊರತರುವ.

156
00:09:02,620 --> 00:09:06,190
>> ಈಗ ನಾವು ಪಿಕ್ಸೆಲ್ ಬದಲಾಯಿಸಿದ್ದರೆ ಎಂದು
ಬಣ್ಣ, ಮುಂದಿನ ನಾವು ಅವುಗಳನ್ನು ಬರೆಯಲು ಅಗತ್ಯವಿದೆ

157
00:09:06,190 --> 00:09:08,500
ಪಿಕ್ಸೆಲ್ scanline ಗೆ, ಪಿಕ್ಸೆಲ್.

158
00:09:08,500 --> 00:09:11,860
ಮತ್ತು ಇನ್ನೂ ಮತ್ತೆ, ನೀವು ಮತ್ತೆ ನೋಡಲು ಬಯಸುವಿರಿ
ನೀವು ಕಾಪಿ ಇದ್ದರೆ, copy.c ಗೆ

159
00:09:11,860 --> 00:09:18,170
ಈಗಾಗಲೇ, ಮತ್ತು fwrite ನೋಡಲು
ಡೇಟಾ ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ ಕಾರ್ಯ, ಒಂದು ಪಾಯಿಂಟರ್

160
00:09:18,170 --> 00:09:23,230
ಬೈಟ್ಗಳು ಹೊಂದಿರುವ struct ಗೆ
ನೀವು ಗಾತ್ರ, ಓದುವಲ್ಲಿ ಎಂಬುದನ್ನು

161
00:09:23,230 --> 00:09:26,610
ಐಟಂಗಳನ್ನು, ಐಟಂಗಳ ಸಂಖ್ಯೆ,
ತದನಂತರ outptr -

162
00:09:26,610 --> 00:09:29,450
ಆ ಕಡತಗಳ ತಾಣವಾಗಿದೆ.

163
00:09:29,450 --> 00:09:34,010
>> ನೀವು ಪಿಕ್ಸೆಲ್ಗಳಲ್ಲಿ ಬರೆಯಲು ನಂತರ, ನೀವು ಮಾಡುತ್ತೇವೆ
ಸಹ ಪ್ಯಾಡಿಂಗ್ ಬರೆಯಬೇಕು.

164
00:09:34,010 --> 00:09:34,970
ಪ್ಯಾಡಿಂಗ್ ಏನು?

165
00:09:34,970 --> 00:09:38,670
ಅಲ್ಲದೆ, ಪ್ರತಿ rgbt ಪಿಕ್ಸೆಲ್
ಮೂರು ಬೈಟ್ಗಳು ಉದ್ದವಾಗಿದೆ.

166
00:09:38,670 --> 00:09:43,670
ಆದರೆ, ಒಂದು ಬಿಟ್ಮ್ಯಾಪ್ ಚಿತ್ರಕ್ಕಾಗಿ scanline
ನಾಲ್ಕು ಬೈಟ್ಗಳು ಒಂದು ಬಹು ಎಂದು ಹೊಂದಿದೆ.

167
00:09:43,670 --> 00:09:47,650
ಮತ್ತು ಪಿಕ್ಸೆಲ್ಗಳ ಸಂಖ್ಯೆ ವೇಳೆ ಒಂದು
ನಾಲ್ಕು ಅನೇಕ, ನಾವು ಸೇರಿಸುವ ಅಗತ್ಯವಿದೆ

168
00:09:47,650 --> 00:09:48,880
ಈ ಪ್ಯಾಡಿಂಗ್.

169
00:09:48,880 --> 00:09:51,420
ಪ್ಯಾಡಿಂಗ್ ಕೇವಲ 0 ಸೆ ಪ್ರತಿನಿಧಿಸುತ್ತದೆ.

170
00:09:51,420 --> 00:09:54,380
ಆದ್ದರಿಂದ, ಹೇಗೆ ನಾವು ಬರೆಯಲು, ಅಥವಾ ಈ ಓದಲು ಇಲ್ಲ?

171
00:09:54,380 --> 00:09:59,280
ಅಲ್ಲದೆ, ಇದು ತಿರುಗಿದರೆ ನೀವು ಎಂಬುದನ್ನು
ವಾಸ್ತವವಾಗಿ fread ಪ್ಯಾಡಿಂಗ್, ಆದರೆ ನೀವು ಮಾಡಬಹುದು

172
00:09:59,280 --> 00:10:00,970
ಲೆಕ್ಕ.

173
00:10:00,970 --> 00:10:04,400
>> ಈ ಸಂದರ್ಭದಲ್ಲಿ, ಸುಳಿವು ಮತ್ತು ತೀರ್ಪು
ಒಂದೇ ಅಗಲವನ್ನು ಹೊಂದಿರುತ್ತವೆ, ಆದ್ದರಿಂದ

174
00:10:04,400 --> 00:10:05,910
ಪ್ಯಾಡಿಂಗ್ ಒಂದೇ.

175
00:10:05,910 --> 00:10:09,370
ಮತ್ತು ಪ್ಯಾಡಿಂಗ್, ನೀವು ನೋಡುತ್ತಾರೆ ಎಂದು
copy.c ರಲ್ಲಿ, ಲೆಕ್ಕಾಚಾರ

176
00:10:09,370 --> 00:10:11,790
ಕೆಳಗೆ ಸೂತ್ರವನ್ನು -

177
00:10:11,790 --> 00:10:16,690
bi.biWidth ಬಾರಿ Sizeof (RGBTRIPLE) ತಿನ್ನುವೆ
ಎಷ್ಟು ಬೈಟ್ಗಳು BMP ನಮಗೆ ನೀಡಿ

178
00:10:16,690 --> 00:10:18,280
ಪ್ರತಿ ಸತತವಾಗಿ ಹೊಂದಿದೆ.

179
00:10:18,280 --> 00:10:21,890
ಅಲ್ಲಿಂದ modulos ಮತ್ತು subtractions
4 ಲೆಕ್ಕ ಮಾಡಬಹುದು ಹೇಗೆ

180
00:10:21,890 --> 00:10:25,610
ಅನೇಕ ಬೈಟ್ಗಳು ಸೇರಿಸಬೇಕು ಆದ್ದರಿಂದ
ಮೇಲೆ ಬೈಟ್ಗಳು ಅನೇಕ

181
00:10:25,610 --> 00:10:27,250
ಪ್ರತಿ ಸಾಲಿನ ನಾಲ್ಕು.

182
00:10:27,250 --> 00:10:30,490
>> ಈಗ ನಾವು ಸೂತ್ರ ಹೊಂದಿರುವ
ನಾವು ಎಷ್ಟು ಪ್ಯಾಡಿಂಗ್, ಈಗ

183
00:10:30,490 --> 00:10:31,610
ನಾವು ಅದನ್ನು ಬರೆಯಬಹುದು.

184
00:10:31,610 --> 00:10:34,080
ಈಗ, ನಾನು ಮೊದಲೇ ಹೇಳಿದಂತೆ,
ಪ್ಯಾಡಿಂಗ್ ಕೇವಲ 0 ಸೆ ಆಗಿದೆ.

185
00:10:34,080 --> 00:10:39,730
ಆ ಸಂದರ್ಭದಲ್ಲಿ, ನಾವು ಪುಟ್ಟಿಂಗ್ ಮಾಡುತ್ತಿರುವ
ಈ ಸಂದರ್ಭದಲ್ಲಿ 0 ಚಾರ್, ನಮ್ಮ

186
00:10:39,730 --> 00:10:41,710
outptr - ನಮ್ಮ outfile.

187
00:10:41,710 --> 00:10:47,530
ಆದ್ದರಿಂದ ಕೇವಲ fputc ಮಾಡಬಹುದು
0 ಅಲ್ಪವಿರಾಮ outptr.

188
00:10:47,530 --> 00:10:52,400
>> ಆದ್ದರಿಂದ, ನಾವು ಒಳಗೆ ಓದುವ ನಾವು ನಮ್ಮ
ಫೈಲ್, ಕಡತ I / O ನ ಟ್ರ್ಯಾಕ್ ಇಟ್ಟುಕೊಂಡಿದೆ ನಮ್ಮ

189
00:10:52,400 --> 00:10:57,440
ಏನೋ ಆ ಕಡತಗಳನ್ನು ಸ್ಥಾನವನ್ನು
ಕಡತ ಸ್ಥಾನವನ್ನು ಸೂಚಕ ಎಂಬ.

190
00:10:57,440 --> 00:10:59,350
ಒಂದು ಕರ್ಸರ್ ಎಂದೇ ತಿಳಿಯುತ್ತಾರೆ.

191
00:10:59,350 --> 00:11:03,550
ಮೂಲತಃ, ಇದು ಪ್ರತಿ ಬಾರಿ ಬೆಳವಣಿಗೆಗಳು
ನಾವು fread, ಆದರೆ ನಾವು ಹೊಂದಿರುವ

192
00:11:03,550 --> 00:11:05,671
ತುಂಬಾ, ಇದು ನಿಯಂತ್ರಣವನ್ನು.

193
00:11:05,671 --> 00:11:11,030
>> ಕಡತ ಸ್ಥಾನವನ್ನು ಸೂಚಕ ಸರಿಸಲು,
ನೀವು ಕಾರ್ಯ fseek ಬಳಸಬಹುದು.

194
00:11:11,030 --> 00:11:15,600
Inptr ಕಡತ ನಿರೂಪಿಸುತ್ತದೆ
ನೀವು ಹುಡುಕುತ್ತಿರುವ ಆ ಪಾಯಿಂಟರ್,

195
00:11:15,600 --> 00:11:20,370
ಪ್ರಮಾಣದ ಬೈಟ್ಗಳು ಸಂಖ್ಯೆ ಎಂದು ನೀವು
ನಂತರ ಕರ್ಸರ್ ಸರಿಸು ಮತ್ತು ಬಯಸುವ

196
00:11:20,370 --> 00:11:23,470
ಉಲ್ಲೇಖ ಪಾಯಿಂಟ್ ಸಂಬಂಧಿಸಿದೆ
ನಿಮ್ಮ ಕರ್ಸರ್ ಸ್ಥಳದಿಂದ.

197
00:11:23,470 --> 00:11:26,770
ನೀವು SEEK_CUR ಹಾದು ನೀವು ಎಂದು
ಪ್ರಸ್ತುತ ಪ್ರತಿನಿಧಿಸುತ್ತದೆ

198
00:11:26,770 --> 00:11:28,100
ಕಡತದಲ್ಲಿ ಸ್ಥಾನವನ್ನು.

199
00:11:28,100 --> 00:11:31,020
ಅಥವಾ ನೀವು ಕೆಲವು ಇತರೆ ನಿಯತಾಂಕಗಳನ್ನು ಬಳಸಬಹುದು.

200
00:11:31,020 --> 00:11:35,400
ಆದ್ದರಿಂದ, ನಾವು ತೆರಳಿ fseek ಬಳಸಲು ಬಯಸಬಹುದು
ಕಡತದ ಪ್ಯಾಡಿಂಗ್ ಮೇಲೆ.

201
00:11:35,400 --> 00:11:39,410
ನೀವು ಅಂಟಿಕೊಂಡಿತು ಬಳಸುತ್ತಿದ್ದರೆ ಮತ್ತೆ,, ಇಲ್ಲ
copy.c. ಆ ಒಂದು ಉದಾಹರಣೆ

202
00:11:39,410 --> 00:11:43,260
>> ಈಗ ನಾವು ಫೈಲ್ ತೆರೆಯಿತು ನಾವು,
ಸುಳಿವು, ಮತ್ತು ತೀರ್ಪು.

203
00:11:43,260 --> 00:11:46,450
ನಾವು ಹೆಡರ್ ಮಾಹಿತಿಯನ್ನು ಅಪ್ಡೇಟ್ಗೊಳಿಸಲಾಗಿದೆ ಬಂದಿದೆ
ನಮ್ಮ ತೀರ್ಪು, ಏಕೆಂದರೆ ಪ್ರತಿ

204
00:11:46,450 --> 00:11:48,730
ಬಿಟ್ಮ್ಯಾಪ್ ಒಂದು ಹೆಡರ್ ಅಗತ್ಯವಿದೆ.

205
00:11:48,730 --> 00:11:52,280
ನಾವು ನಂತರ ಸುಳಿವು ನ ಒಳಗೆ ಓದಿದ
scanline, ಪಿಕ್ಸೆಲ್ ಮೂಲಕ ಪಿಕ್ಸೆಲ್, ಬದಲಾಗುತ್ತಿರುವ

206
00:11:52,280 --> 00:11:55,210
ಪ್ರತಿ ಬಣ್ಣ ಅಗತ್ಯ, ಮತ್ತು
ಆ ಬರೆಯಲು

207
00:11:55,210 --> 00:11:57,340
ತೀರ್ಪು, ಪಿಕ್ಸೆಲ್ ಮೂಲಕ ಪಿಕ್ಸೆಲ್.

208
00:11:57,340 --> 00:12:01,550
ನೀವು ತೀರ್ಪು ತೆರೆಯಲು ಒಮ್ಮೆ ನೋಡಬಹುದು ಯಾರು
ಅಪರಾಧಿ, ಅಥವಾ ಯಾವ ರಹಸ್ಯ

209
00:12:01,550 --> 00:12:02,850
ಸಂದೇಶ.

210
00:12:02,850 --> 00:12:05,550
ನನ್ನ ಹೆಸರು Zamyla ಹೊಂದಿದೆ, ಮತ್ತು
ಈ ವೊಡುನಿಟ್ ಆಗಿತ್ತು.

211
00:12:05,550 --> 00:12:12,864