1
00:00:00,000 --> 00:00:00,494

2
00:00:00,494 --> 00:00:13,350
>> [MUSIC ప్లే]

3
00:00:13,350 --> 00:00:14,080
>> రాబ్ బౌడెన్: ఎక్కువ.

4
00:00:14,080 --> 00:00:17,550
నేను రాబ్ ఉన్నాను, మరియు యొక్క ఆశిస్తున్నాము ఆ
ఈ పరిష్కారం మీరు ఉంచండి సహాయం చేస్తుంది

5
00:00:17,550 --> 00:00:19,600
రికవరీ రోడ్ మీద.

6
00:00:19,600 --> 00:00:22,700
కాబట్టి యొక్క ప్రారంభించడానికి వీలు.

7
00:00:22,700 --> 00:00:25,660
>> మేము వెంటనే మేము చూడండి
కేవలం మేము నిర్ధారించుకోండి

8
00:00:25,660 --> 00:00:27,170
సరిగ్గా తిరిగి ఉపయోగించి.

9
00:00:27,170 --> 00:00:31,490
వాడుక కేవలం ఏదో ఉండాలి
డాట్ స్లాష్ తిరిగి వంటి.

10
00:00:31,490 --> 00:00:35,500
>> ఇప్పుడు మేము అంచనా తెరవడం చూడాలని
కార్డ్ ముడి ఫైలు డాట్.

11
00:00:35,500 --> 00:00:39,740
మేము ఉపయోగించి చేస్తున్నట్లు ఇక్కడ చూడగలరు
స్థిరంగా ముడి అండర్ ఫైల్ పేరు,

12
00:00:39,740 --> 00:00:44,200
మేము హాష్ కలిగి ఇక్కడ ఇది
కార్డ్ ముడి డాట్ నిర్వచించారు.

13
00:00:44,200 --> 00:00:45,030
OK.

14
00:00:45,030 --> 00:00:48,210
>> కాబట్టి మేము నిర్ధారించుకోండి అవసరమైన
విజయవంతంగా ప్రారంభించింది ఎందుకంటే ఉంటే అది

15
00:00:48,210 --> 00:00:51,150
, అప్పుడు మేము వినియోగదారు హెచ్చరిస్తుంది ఉండాలి లేదు.

16
00:00:51,150 --> 00:00:56,770
కానీ అని ఊహిస్తూ, మేము ఇప్పుడు
పరిమాణం JPEG ఒక బఫర్ ప్రకటించాలని జరగబోతోంది

17
00:00:56,770 --> 00:00:58,170
పేరు పొడవు దాఖలు.

18
00:00:58,170 --> 00:01:02,060
కాబట్టి ఈ బఫర్ అన్నారు ఆ
మేము లోకి sprintf చూడాలని.

19
00:01:02,060 --> 00:01:04,360
>> కాబట్టి JPEG ఫైల్ పేరు పొడవు ఏమిటి?

20
00:01:04,360 --> 00:01:08,490
ఇక్కడ, మేము అది చూడండి
ఎనిమిది నిర్వచించారు హాష్.

21
00:01:08,490 --> 00:01:10,670
ఎందుకు ఎనిమిది?

22
00:01:10,670 --> 00:01:15,150
బాగా ఒక ఫైలు పేరుతో కనిపిస్తుంది
సున్నా సున్నా సున్నా లాగ.

23
00:01:15,150 --> 00:01:19,460
JPG మరియు అప్పుడు మేము ఒక బాక్ స్లాష్ సున్నా అవసరం.

24
00:01:19,460 --> 00:01:22,720
కాబట్టి మేము ఆ చెయ్యవచ్చు ఒక బఫర్ అవసరం
ఎనిమిది అక్షరాలు నిల్వ.

25
00:01:22,720 --> 00:01:25,190
ఇప్పుడు మేము ఒక కౌంటర్ చూడాలని
ట్రాక్ అన్నారు

26
00:01:25,190 --> 00:01:27,780
సంఖ్య JPEGs జపానీస్.

27
00:01:27,780 --> 00:01:31,590
>> చివరకు, మేము చూడాలని ఒక
ప్రారంభంలో శూన్య ఇది ​​JPEG ఫైల్

28
00:01:31,590 --> 00:01:35,920
ప్రస్తుతం మాత్రం ఇది
మేము రాస్తున్నాం ఓపెన్ ఫైల్.

29
00:01:35,920 --> 00:01:37,540
ఇప్పుడు మేము చూడాలని
అదనపు బఫర్.

30
00:01:37,540 --> 00:01:41,350
ఈ మా sprintf అదే కాదు
ఈ బఫర్ ఒకటి ఇక్కడ బఫర్

31
00:01:41,350 --> 00:01:45,020
మేము డేటా లో చదువుతున్న ఆ
కార్డ్ ముడి డాట్ నుండి.

32
00:01:45,020 --> 00:01:48,900
>> కాబట్టి బఫర్ యొక్క అన్నారు
సైన్ చేయని అక్షరాలు, మీరు ఇది

33
00:01:48,900 --> 00:01:53,560
ప్రధానంగా కేవలం మాకు బైట్లు చికిత్స, మరియు అది ఉంది
పరిమాణం బ్లాక్ పరిమాణం మాత్రం

34
00:01:53,560 --> 00:01:57,950
అక్కడ మేము మీరు చెప్పండి,,
బ్లాక్ పరిమాణం 512 ఉంది.

35
00:01:57,950 --> 00:02:03,070
కాబట్టి JPEGs మీరు ప్రతిదీ చికిత్స చేయవచ్చు
512 బైట్లు దిమ్మలు.

36
00:02:03,070 --> 00:02:05,890
>> ఇప్పుడు మేము లూప్ చూడాలని
మొత్తం ఫైల్ మీద.

37
00:02:05,890 --> 00:02:12,980
మేము F మా బఫర్ లోకి చదవండి చూడాలని
ఒక బైట్ బ్లాక్ పరిమాణం సార్లు నుండి

38
00:02:12,980 --> 00:02:14,710
కార్డ్ ముడి ఫైలు డాట్.

39
00:02:14,710 --> 00:02:16,630
ఇప్పుడు f తిరిగి ఏమి చదవండి లేదు?

40
00:02:16,630 --> 00:02:20,050
ఇది అంశాల సంఖ్య తిరిగి
ఇది విజయవంతంగా చదివే.

41
00:02:20,050 --> 00:02:27,310
అది, 512 బైట్లు చదవండి నిర్వహించేది ఉంటే
మేము ఈ ఒక అని చూడాలనుకుంటే

42
00:02:27,310 --> 00:02:29,700
JPEG లేదా ఒక JPEG ఫైల్ వ్రాయడం.

43
00:02:29,700 --> 00:02:34,450
మరియు అది 512 బైట్లు తిరిగి రాకపోతే,
అప్పుడు ఫైలు గాని ముగిసింది

44
00:02:34,450 --> 00:02:37,870
మేము Y బయటకు మేము కేసు
లూప్, లేదా లోపం విధమైన ఉన్నాయి

45
00:02:37,870 --> 00:02:40,300
మేము కూడా బయటకు వస్తుంది సందర్భంలో
y లూప్, కాని మేము రిపోర్ట్ చెయ్యవచ్చును

46
00:02:40,300 --> 00:02:41,990
ఏదో తప్పు జరిగింది.

47
00:02:41,990 --> 00:02:42,290
>> OK.

48
00:02:42,290 --> 00:02:47,630
కాబట్టి మేము విజయవంతంగా చదివే ఊహిస్తూ
512 బైట్లు లో, మేము మొదటి చెక్ అనుకుంటున్నారా

49
00:02:47,630 --> 00:02:53,070
చేయడానికి ఈ బైట్లు మేము
కేవలం చదివిన JPEG ప్రారంభం.

50
00:02:53,070 --> 00:02:56,430
అయితే మా బఫర్ యొక్క JPEG శీర్షిక ఉంది.

51
00:02:56,430 --> 00:02:58,460
ఇప్పుడు JPEG శీర్షిక ఇది ఏమి ఉంటుంది?

52
00:02:58,460 --> 00:03:00,120
యొక్క చూద్దాం.

53
00:03:00,120 --> 00:03:05,270
>> ఇక్కడ, ఈ ఫంక్షన్ అని చూడండి
ఒక ఎద్దు తిరిగి, మరియు ఎద్దు -

54
00:03:05,270 --> 00:03:08,820
బాగా ఇక్కడ, మేము చూడటానికి తనిఖీ ఉంటే
శీర్షిక సున్నా ఈ స్థిరంగా సమానం

55
00:03:08,820 --> 00:03:11,880
శీర్షిక ఈ స్థిరంగా సమానం
శీర్షిక రెండు, ఈ స్థిరంగా సమానం

56
00:03:11,880 --> 00:03:15,640
శీర్షిక మూడు లేదా ఈ సమానం
అన్ని ఈ స్థిరాంకాలు ఎక్కడ స్థిరంగా

57
00:03:15,640 --> 00:03:20,340
కేవలం ఇక్కడే నిర్వచించిన హాష్ మరియు
మేము స్పెక్ మీరు చెప్పారు వేటి

58
00:03:20,340 --> 00:03:22,700
ఒక JPEG ప్రారంభమవుతుంది.

59
00:03:22,700 --> 00:03:27,300
కాబట్టి ఈ ఫంక్షన్ కేవలం అన్నారు
ఈ బఫర్ ప్రాతినిధ్యం అయితే నిజమైన తిరిగి

60
00:03:27,300 --> 00:03:31,750
ఒక కొత్త JPEG ప్రారంభంలో
మరియు తప్పుడు లేకపోతే.

61
00:03:31,750 --> 00:03:32,520
>> OK.

62
00:03:32,520 --> 00:03:38,490
ఈ కొత్త JPEG ప్రాతినిధ్యం ఒకవేళ కాబట్టి,
అప్పుడు మేము చూడటానికి మొదటి తనిఖీ అనుకుంటే

63
00:03:38,490 --> 00:03:42,030
JPEG ఫైల్ శూన్య సమానం కాదు
ఇది విషయంలో మేము దగ్గరగా.

64
00:03:42,030 --> 00:03:44,940
కాబట్టి ఎందుకు మేము తనిఖీ చేయాలి
అది శూన్య కాదు చూడండి? కు

65
00:03:44,940 --> 00:03:48,980
బాగా మొట్టమొదటి JPEG మేము
మేము ఇప్పటికే ఉండదు కనుగొనేందుకు

66
00:03:48,980 --> 00:03:50,440
బహిరంగ JPEG ఫైల్.

67
00:03:50,440 --> 00:03:55,580
కాబట్టి, మేము అప్పుడు, ఆ దగ్గరగా ప్రయత్నించినట్లయితే
మేము సరైన ఏదో చేయడం లేదు.

68
00:03:55,580 --> 00:03:59,090
>> కానీ ప్రతి తరువాత JPEG ఆ
మేము ఓపెన్, మేము మూసివేయాలని మీరు అనుకుంటున్నారా

69
00:03:59,090 --> 00:04:00,710
మునుపటి ఫైలు.

70
00:04:00,710 --> 00:04:04,630
కాబట్టి ఇప్పుడు మనం వంటి sprintf ఉపయోగించడానికి వెళుతున్న
మేము ఉపయోగిస్తున్న పేరు ముందు చెప్పారు

71
00:04:04,630 --> 00:04:06,280
బఫర్ JPEG ఫైల్ పేరు.

72
00:04:06,280 --> 00:04:09,870
మరియు మేము JPEG ఫైల్ ఉపయోగించడానికి వెళుతున్న
మా ఫార్మాట్ వంటి ఫార్మాట్ పేరు.

73
00:04:09,870 --> 00:04:12,030
మరియు ఆ ఏమిటి?

74
00:04:12,030 --> 00:04:18,450
ఇక్కడ, మేము అది శాతం సున్నా చూడండి
3D.JPEG ఇక్కడ సున్నా మూడు కేవలం

75
00:04:18,450 --> 00:04:22,089
మేము మూడు పూర్ణాంకాల ఉపయోగిస్తాము చెప్పారు
ఈ కోసం సున్నాలు తో మందంగా.

76
00:04:22,089 --> 00:04:27,470
ఈ మేము సున్నా సున్నా పొందుతారు ఎలా ఉంది
అందువలన న one.JPEG మరియు సున్నా 10.JPEG మరియు.

77
00:04:27,470 --> 00:04:29,060
>> మేము sprintf ఉపయోగించడానికి వెళుతున్న.

78
00:04:29,060 --> 00:04:33,760
మరియు మేము ఇన్సర్ట్ ఆ పూర్ణాంక
స్ట్రింగ్ నంబ్ JPEGs ఉంది లోకి

79
00:04:33,760 --> 00:04:36,380
నిజానికి సున్నా ఇది పునరుద్ధరించారు.

80
00:04:36,380 --> 00:04:39,950
కాబట్టి మొదటి ఫైల్ అన్నారు ప్రారంభమైంది
సున్నా సున్నా సున్నా డాట్ JPEG ఉండాలి.

81
00:04:39,950 --> 00:04:43,330
మరియు తర్వాత మేము అది పెంచడం చేస్తున్నారు
మేము ఓపెన్ తదుపరి ఫైలు సున్నా సున్నా ఉంటుంది

82
00:04:43,330 --> 00:04:46,830
ఒక డాట్ JPEG మరియు మేము అది పెంచడం చేస్తాము
మళ్ళీ ఇది సున్నా సున్నా రెండు డాట్ ఉంటాం

83
00:04:46,830 --> 00:04:49,100
అందువలన న JPEG మరియు.

84
00:04:49,100 --> 00:04:49,850
>> అన్ని కుడి.

85
00:04:49,850 --> 00:04:53,210
కాబట్టి ఇప్పుడు JPEG ఫైల్ లోపలి
పేరు, మేము యొక్క పేరు

86
00:04:53,210 --> 00:04:54,990
మేము కావలసిన ఫైల్.

87
00:04:54,990 --> 00:04:58,640
మేము F రచనకు ఆ ఫైల్ విప్పగలరు.

88
00:04:58,640 --> 00:04:59,170
OK.

89
00:04:59,170 --> 00:05:02,820
మరియు మరోసారి మేము చేయడానికి తనిఖీ చెయ్యాలి
ఖచ్చితంగా విజయవంతంగా ఫైలు

90
00:05:02,820 --> 00:05:08,460
అది కాదు, అప్పుడు చేస్తే నుండి లెక్కించిన
కొన్ని లోపం ఉంది.

91
00:05:08,460 --> 00:05:13,100
>> కాబట్టి ఇప్పుడు మేము గత సంపాదించిన చేసిన
ఈ ఒక JPEG భాగం.

92
00:05:13,100 --> 00:05:16,390
మరియు ఇక్కడ, మేము వెళుతున్న చూడండి
JPEG వ్రాయడానికి.

93
00:05:16,390 --> 00:05:20,980
కానీ మేము మొదటి చెప్పారు ఈ తనిఖీ
JPEG ఫైల్ సమాన శూన్య కాకపోతే.

94
00:05:20,980 --> 00:05:22,490
ఎందుకు మేము ఆ అవసరం?

95
00:05:22,490 --> 00:05:28,020
బాగా JPEG ఫైల్ శూన్య సమానం మేము
ప్రస్తుతం బహిరంగ JPEG కలిగి.

96
00:05:28,020 --> 00:05:31,870
>> ఏ కార్డు డాట్ ముడి మొదలవుతుంది ఉంటే
బైట్లు కొంత ఆ

97
00:05:31,870 --> 00:05:33,510
ఒక JPEG సూచించని?

98
00:05:33,510 --> 00:05:36,240
అప్పుడు మేము మీరు చూడాలని
ఆ బైట్లు పైగా skip.

99
00:05:36,240 --> 00:05:39,600
మేము ఈ తనిఖీ లేదు, అప్పుడు మేము
మూసివుంచిన వ్రాయండి అన్నారు

100
00:05:39,600 --> 00:05:45,540
మొదటి 512 బైట్లు దాఖలు
మంచి కాదు ఇది కార్డు.

101
00:05:45,540 --> 00:05:46,030
OK.

102
00:05:46,030 --> 00:05:51,330
>> కాబట్టి అప్పుడు, మేము ఒక ఓపెన్ ఫైల్ కలిగి ఉండాలి
ఆ ఫైల్ను వ్రాయడానికి చూడాలని

103
00:05:51,330 --> 00:05:53,290
మేము మా బఫర్ లో కలిగి 512 బైట్లు.

104
00:05:53,290 --> 00:05:57,390
మరియు మేము మళ్లీ చేయడానికి తనిఖీ చేస్తున్నాము
ఖచ్చితంగా విజయవంతంగా 512 బైట్లు

105
00:05:57,390 --> 00:06:01,140
వారు ఒకవేళ ఎందుకంటే వ్రాయబడ్డాయి
విజయవంతంగా రాసిన, అప్పుడు ఏదో

106
00:06:01,140 --> 00:06:02,080
తప్పు జరిగింది.

107
00:06:02,080 --> 00:06:06,540
మేము ఆ ప్రింట్ మా ఫైల్స్ దగ్గరగా వస్తుంది
ఏదో తప్పు జరిగింది, మరియు తిరిగి.

108
00:06:06,540 --> 00:06:10,940
ఊహిస్తూ అన్ని అప్పుడు, సరిగ్గా వెళ్తాడు
మేము మూసివేయడం మళ్ళీ వెతికినా ఉంటాం

109
00:06:10,940 --> 00:06:15,060
పాత ఫైలు, కొత్త తెరుస్తోంది, రచన
కాబట్టి కొత్త ఫైలు డేటా, మరియు

110
00:06:15,060 --> 00:06:20,990
చివరకు ఈ f చదవండి వరకు
సున్నా తిరిగి సాధనాలు

111
00:06:20,990 --> 00:06:23,280
ఫైలు జరుగుతుంది.

112
00:06:23,280 --> 00:06:28,490
>> కాబట్టి ఇప్పుడు కార్డు రీడింగ్ పైగా అని, మేము
మేము F దగ్గరగా చూడాలని చూడండి

113
00:06:28,490 --> 00:06:33,250
మేము ఓపెన్, కాని ఆ గత ఫైలు
మేము తనిఖీ చేస్తున్నాము ఉంటే JPEG ఫైల్

114
00:06:33,250 --> 00:06:34,900
సమాన కాదు శూన్య చేస్తుంది.

115
00:06:34,900 --> 00:06:39,520
బాగా f దగ్గరగా ఎందుకంటే అర్ధమే
మేము మూసేస్తున్నాము, తెరిచేటప్పుడు చేస్తున్నారు

116
00:06:39,520 --> 00:06:43,870
మునుపటి ఫైలు, కానీ ఆఖరి
మేము ప్రారంభమైన ఫైలు మూసివేయబడింది అవుతుంది ఎప్పుడూ.

117
00:06:43,870 --> 00:06:45,580
కాబట్టి ఈ ఏమి ఉంది.

118
00:06:45,580 --> 00:06:47,720
>> అయితే ఎందుకు శూన్య తనిఖీ అవసరం?

119
00:06:47,720 --> 00:06:53,130
బాగా ఉంటే కార్డ్ డాట్ ముడి కాదు
అది లోపలి ఒక JPEG ఉందా?

120
00:06:53,130 --> 00:06:56,640
ఆ సందర్భంలో, మంచినీళ్లు
మోపడం ఎప్పుడూ.

121
00:06:56,640 --> 00:07:00,230
మేము ఒక ఫైల్ను తెరవడం ఎప్పుడూ ఉంటే, మేము తప్పక
ఆ ఫైల్ మూసి ప్రయత్నించండి కాదు.

122
00:07:00,230 --> 00:07:03,000
కాబట్టి ఆ ఈ తనిఖీ చేయడం ఏమిటి.

123
00:07:03,000 --> 00:07:07,880
>> అలాగేనండి ఇప్పుడు ఇక్కడ, మేము అని
అను లూప్ గాని ఉంటే విచ్ఛిన్నం చేశారు

124
00:07:07,880 --> 00:07:13,520
కార్డ్ ఉన్నాయి ముగిసింది లేదా ఉంది
కార్డ్ చదవడం కొన్ని లోపం.

125
00:07:13,520 --> 00:07:16,680
కాబట్టి ఈ ఉంది ఉంటే చూడటానికి తనిఖీ
లో, కార్డ్ చదవడం లోపం

126
00:07:16,680 --> 00:07:19,400
ఈ సందర్భంలో, మేము అక్కడ సే చేస్తాము
లోపం చదవటమే.

127
00:07:19,400 --> 00:07:22,130
మేము వినియోగదారు ఆలోచించడం వద్దు
ప్రతిదీ విజయవంతంగా వెళ్ళింది.

128
00:07:22,130 --> 00:07:24,750
మరియు మేము లోపానికి ఒక తిరిగి ఉంటాం.

129
00:07:24,750 --> 00:07:29,580
>> చివరకు, మేము f మా ముడి ఫైలు దగ్గరగా వస్తుంది,
మా కార్డు సూచించుటకు, ముడి డాట్

130
00:07:29,580 --> 00:07:34,070
ప్రతిదీ బాగా మరియు తిరిగి వెళ్ళింది
సున్నా అంతే.

131
00:07:34,070 --> 00:07:36,130
>> నా పేరు రాబ్ ఉంది మరియు ఈ తిరిగి ఉంది.

132
00:07:36,130 --> 00:07:42,102
>> [MUSIC ప్లే]