>> [მუსიკის დაკვრა]
>> რობ Bowden: Hi.
მე რობ, და იმედი ვიქონიოთ, რომ ეს გადაწყვეტა ეხმარება დააყენა თქვენ
გზაზე აღდგენა.
მოდით დავიწყოთ.
>> ჩვენ ვხედავთ, რომ დაუყოვნებლივ ჩვენ უბრალოდ დარწმუნდით, რომ ჩვენ
გამოყენებით აღდგენა სწორად.
ასე რომ, გამოყენება უნდა იყოს მხოლოდ რაღაც ისევე როგორც dot ხაზი ფეხზე.
>> ახლა ჩვენ ვაპირებთ გახსნა მოსალოდნელია ანკეტა dot ნედლეული ფაილი.
ჩვენ ვხედავთ, აქ რომ ჩვენ გამოყენებით მუდმივი ნედლეულის ხაზგასმა ფაილის სახელი,
რომელიც აქ გვაქვს hash განისაზღვრება, როგორც ანკეტა dot ნედლეული.
OK.
>> ამიტომ, ჩვენ უნდა დავრწმუნდეთ, რომ უპრობლემოდ გაიხსნა, რადგან თუ ეს
არ, მაშინ ჩვენ უნდა გააფრთხილოს შესახებ.
მაგრამ თუ გავითვალისწინებთ, რომ ეს გააკეთა, ჩვენ ახლა აპირებს გამოაცხადოს ბუფერული ზომის JPEG
ფაილის სახელი სიგრძეზე.
ასე რომ, ეს იქნება ბუფერული რომ ჩვენ ვაპირებთ sprintf შევიდა.
>> რა არის JPEG ფაილის სახელი სიგრძე?
აქ ჩვენ ვხედავთ, რომ ის hash განისაზღვრება, როგორც რვა.
რატომ რვა?
ასევე მოცემული ფაილი იქნება დასახელებული რაღაც ნულოვანი ნულოვანი ნულოვანი.
JPG და მაშინ ჩვენ გვჭირდება backslash ნულოვანი.
ამიტომ ჩვენ გვჭირდება ბუფერული, რომ შეიძლება შენახვის რვა სიმბოლო.
ახლა ჩვენ ვაპირებთ აქვს counter, რომ აპირებს ტრეკზე
ნომერი JPEGs აღმოვაჩინეთ.
>> და ბოლოს, ჩვენ ვაპირებთ აქვს JPEG ფაილის რომელიც თავდაპირველად null
რომელიც იქნება გაკეთებული ვხსნი, რომ ჩვენ წერილობით.
ახლა ჩვენ ვაპირებთ აქვს დამატებითი ბუფერული.
ეს არ არის იგივე, რაც ჩვენი sprintf ბუფერული სადაც ეს ბუფერული არის ერთი
რომ ჩვენ კითხვის მონაცემები ბარათის dot ნედლეული.
>> ასე რომ ბუფერული აპირებს იყოს unsigned სიმბოლო, რომელიც შეგიძლიათ
ძირითადად მხოლოდ გვექცევიან ბაიტი, და ეს იქნება ზომა ბლოკის ზომა
სადაც, როგორც ჩვენ გეტყვით, ბლოკის ზომა არის 512.
ასე რომ JPEGs შეგიძლიათ მკურნალობა ყველაფერი ბლოკების სახით 512 bytes.
>> ახლა ჩვენ ვაპირებთ loop მთელ ფაილი.
ჩვენ ვაპირებთ f წაიკითხოთ ჩვენს ბუფერული ერთი ბაიტი ბლოკის ზომა ჯერ
ბარათის dot ნედლეული ფაილი.
ახლა რას ვ წაკითხვის დაბრუნებას?
ის დააბრუნებს რაოდენობის ნივთები რომ ის წარმატებით წაიკითხა.
ასე რომ, თუ ეს მოახერხა წაიკითხა 512 ბაიტი, მაშინ ჩვენ გვინდა თუ არა, ეს იყო
JPEG ან ჩაწერის მას JPEG ფაილი.
და თუ ეს არ დაბრუნდება 512 ბაიტი, მაშინ არც ფაილის დასრულდა
ასეთ შემთხვევაში ჩვენ შესვენება გარეთ y loop, ან არსებობს გარკვეული შეცდომა
ამ შემთხვევაში ჩვენ ასევე შესვენება გარეთ y loop, მაგრამ ჩვენ გვინდა, რომ მოხსენება
რომ რაღაც წავიდა არასწორი.
>> OK.
ასე რომ, ვთქვათ, რომ ჩვენ წარმატებით წაკითხული 512 ბაიტი, ჩვენ გვინდა, რომ პირველი შემოწმება
რათა, რომ ეს bytes რომ ჩვენ უბრალოდ წაიკითხა დაიწყოს JPEG.
ასე რომ, თუ არის JPEG header ჩვენი ბუფერული.
ახლა რა ის JPEG header აკეთებს?
მოდით შევხედოთ.
>> აქ ჩვენ ვხედავთ, რომ ამ ფუნქციის დაბრუნების bull, და რომ bull -
კარგად აქ, ჩვენ შემოწმების თუ header ნულოვანი შეადგენს ამ მუდმივი და
header ერთი უდრის ამ მუდმივი და header ორი უდრის ამ მუდმივი,
header სამი უდრის ამ ან ამ მუდმივი სადაც ყველა ამ მუდმივები არიან
უბრალოდ hash განსაზღვრული უფლება აქ და ზუსტად ის, რაც ჩვენ გითხარით სპეც
რომ JPEG იწყება.
და ა.შ. ეს ფუნქცია უბრალოდ აპირებს TRUE თუ ეს ბუფერული წარმოადგენს
დაწყების ახალი JPEG და ცრუ სხვაგვარად.
>> OK.
ასე რომ, თუ ეს არ წარმოადგენს ახალი JPEG, მაშინ ჩვენ პირველად გსურთ შეამოწმოთ თუ
JPEG ფაილი არ არის ტოლი null, ამ შემთხვევაში ჩვენ ვხურავთ მას.
და რატომ გვჭირდება, რათა შეამოწმოს თუ ეს არ null?
ასევე პირველივე JPEG, რომ ჩვენ მოძებნეთ ჩვენ არ გაქვთ
ღია JPEG ფაილი.
ასე რომ, თუ ჩვენ ვცდილობთ დახურვა, მაშინ ჩვენ არ აკეთებს რაღაც საკმაოდ უფლება.
>> მაგრამ ყოველ მომდევნო JPEG, რომ ჩვენ გახსნა, ჩვენ გვინდა დახურვა
წინა ფაილი.
ახლა ჩვენ ვაპირებთ გამოვიყენოთ sprintf როგორც ჩვენ განაცხადა, სადაც ჩვენ გამოყენებით
ბუფერული JPEG ფაილის სახელი.
და ჩვენ ვაპირებთ გამოვიყენოთ JPEG ფაილის ასახელებს ფორმატში, როგორც ჩვენი ფორმატში.
და რა არის ეს?
აქ ჩვენ ვხედავთ, რომ ეს არის პროცენტს zero 3D.JPEG სადაც ნულოვანი სამი უბრალოდ
ამბობს, რომ ჩვენ ვიყენებთ სამი რიცხვებით ამ padded ერთად zeros.
ასე რომ, ეს არის, თუ როგორ მივიღებთ zero zero one.JPEG და ნულოვანი 10.JPEG და ასე შემდეგ.
>> ჩვენ ვაპირებთ გამოვიყენოთ sprintf.
და რიცხვი, რომ ჩვენ ჩასმა შევიდა string არის Numb JPEGs
ამოღებული, რომელიც თავდაპირველად ნულოვანი.
ასე რომ, პირველი ფაილი გახსნა აპირებს უნდა იყოს ნულოვანი ნულოვანი ნულოვანი dot JPEG.
და მაშინ ჩვენ დამატება ასე შემდეგი ფაილის ჩვენ გახსნა იქნება ნულოვანი ნულოვანი
ერთი dot JPEG და ჩვენ ნამატი იგი ერთხელ, ასე რომ იქნება ნულოვანი ნულოვანი ორი dot
JPEG და ასე შემდეგ.
>> ყველა უფლება.
ახლა შიგნით JPEG ფაილის ასახელებს, ჩვენ გვაქვს სახელი,
ფაილი რომ ჩვენ გვინდა.
ჩვენ შეგვიძლია f ღია რომ ფაილი წერილობით.
OK.
და კიდევ ერთხელ, ჩვენ უნდა შეამოწმოთ, რომ დარწმუნებული ვარ, რომ ფაილი წარმატებით
გაიხსნა, რადგან თუ ეს არ, მაშინ გარკვეული შეცდომა.
>> ასე რომ, ახლა ჩვენ მიღებული წარსულში ეს JPEG ნაწილი.
და აქ, ჩვენ ვხედავთ, ჩვენ ვაპირებთ ვწერ JPEG.
მაგრამ ჩვენ პირველი უნდა ამ გამშვები რომელშიც ნათქვამია, თუ JPEG ფაილი არ თანაბარი null.
რატომ გვჭირდება ეს?
ისევე JPEG ფაილის შეადგენს null როდესაც ჩვენ გაკეთებული აქვს ღია JPEG.
>> რა მოხდება, თუ ანკეტა dot ნედლეული იწყება ერთად bunch of bytes რომ
არ წარმოადგენს JPEG?
მაშინ ჩვენ ვაპირებთ მინდა გაფართოებული იმ bytes.
თუ ჩვენ არ გვაქვს ეს შემოწმება, მაშინ ჩვენ აპირებს დაწეროს to გაუხსნელი
წარადგინოს პირველი 512 ბაიტი ბარათი, რომელიც არ არის კარგი.
OK.
>> ასე რომ ვთქვათ, ჩვენ ღია ფაილი, შემდეგ ჩვენ ვაპირებთ, რომ ვწერ, რომ ფაილი
512 ბაიტი, რომ ჩვენ გვაქვს ჩვენი ბუფერული.
და ჩვენ კიდევ ერთხელ შემოწმების რათა დარწმუნებული ვარ, რომ 512 bytes წარმატებით
დაიწერა იმიტომ, რომ თუ ისინი არ იყვნენ წარმატებით დაწერილი, მაშინ რაიმე
წავიდა არასწორი.
ჩვენ დავხუჭავთ ფაილი ბეჭდვა, რომ რაღაც წავიდა არასწორი, და სანაცვლოდ.
ვთქვათ, ყველაფერი სწორად, მაშინ ჩვენ გავაგრძელებთ looping დახურვის
ძველი ფაილის გახსნა ახალი ფაილი, წერა მონაცემების ახალი ფაილი, და ა.შ.
სანამ საბოლოოდ, ამ f წაკითხული დააბრუნებს ნულოვანი რაც იმას ნიშნავს,
რომ ფაილი კეთდება.
>> ახლა რომ ბარათის მოსმენით მეტი, ჩვენ ვხედავთ, რომ ჩვენ ვაპირებთ f დახურვა
ბოლო ფაილი, რომელიც ჩვენ გვქონდა ღია, მაგრამ ჩვენ შემოწმების თუ JPEG ფაილის
არ თანაბარი null.
კარგად f ახლო აზრი რადგან ჩვენ გახსნის ფაილი, ჩვენ დახურვის
წინა ფაილი, მაგრამ ძალიან ბოლო ფაილი, რომელიც გავხსენით არასოდეს იღებს დახურულია.
ასე რომ, ის, რაც ამ აკეთებს.
>> მაგრამ რატომ ჩვენ უნდა შევამოწმოთ null?
ისე რა, თუ ანკეტა dot ნედლეული არ აქვს ერთი JPEG შიგნით მას?
ამ შემთხვევაში, ჩვენ უნდა არასდროს არ გაიხსნა ფაილი.
და თუ ჩვენ არ გახსნა ფაილი, ჩვენ უნდა არ ცდილობენ დახურვა რომ ფაილი.
ასე რომ რა ამ გამშვები აკეთებს.
>> ახლა აქ, როგორც ვთქვი, ჩვენ შეგვიძლია არ გატყდა, რომ y loop ან თუ
ბარათის დასრულდა ან თუ არის რაიმე შეცდომა კითხულობს ბარათი.
ასე რომ, ეს შემოწმების თუ არ იყო შეცდომა კითხულობს ბარათით in
შემთხვევაში, ჩვენ ვიტყვით, იქ შეცდომა მოსმენით.
ჩვენ არ გვინდა მომხმარებელს ვფიქრობ ყველაფერი წარმატებით.
და ჩვენ დაბრუნდება ერთი შეცდომა.
>> და ბოლოს, ჩვენ f დავხუჭავთ ნედლეული ფაილი, ჩვენი ანკეტა dot ნედლეული, მიუთითებს იმაზე, რომ
ყველაფერი კარგად მიდიოდა და დაბრუნების ნულოვანი და რომ არის ის.
>> ჩემი სახელი არის რობ და ეს იყო აღდგენა.
>> [მუსიკის დაკვრა]