mc_kibel

Sony Ericsson Widget Manager v2.1
? kaczmar22, mc_kibel

Uwaga:
-w tym temacie wrzucamy tylko widgety, nie prowadzimy rozmów.
-Będą się też tutaj pojawiały informacje o ważnych aktualizacjach.

Przedstawiamy zaawansowany manager widgetów dla SE.
Krótka uwaga na początek: nie musisz mieć żadnej wiedzy o 'tuningu', żeby sobie z tym poradzić.
Obsługiwane telefony: wszystkie SE od platformy DB3150 w górę [rozdzielczość ekranu 240x320].

-O SE-WM 2.0 (Sony Ericsson Widget Manager v2.0).
1. Obsługa widgetów w formacie Flash - do dziesięciu w tym samym czasie na jednej konfiguracji.
2. Opcja Multi-screen! Potrząsnij w lewo -> wczyta pierwszą konfigurację, potrząśnij w prawo -> wczyta drugą, do przodu -> trzecią, do siebie -> czwartą.
3. Możliwość włączenia/wyłączenia każdego z widgetów przy muzyce.
4. Konfiguracja w łatwy i wygodny sposób - plik .xml - w wersji 2.0 jest ona jeszcze łatwiejsza i przejrzystsza!
5. Nie trzeba uruchamiać telefonu ponownie aby ujrzeć zmiany - wystarczy ustawić tapetę ponownie.
6. W pełni konfigurowalne ścieżki i nazwy widgetów.
7. Oddzielne foldery dla różnych konfiguracji.

-Instalacja SE-WM 2.1
1. Ściągamy WidgetManager 2.1: http://www.sendspace.com/file/q640dt
2. Wypakowujemy. Do folderu "Zdjęcia" wrzucamy cały folder WidgetManager 2.1.
3. Plik WidgetManager.swf ustawiamy jako tapetę.
Ta paczka (v2.1) zawiera przykładową konfigurację czteroekranową, która wygląda tak:
(pierwszy screen - pierwsza konfiguracja ; drugi - druga itd.)




-Konfiguracja SE-WM 2.0
XML w v2.0 jest zmieniony - starsze konfiguracje nie będą współpracowały z tą wersją, jak i nowe konfiguracje nie będą współpracowały ze starszą.
1. Otwórz config.xml z folderu WidgetManager 2.0.
2. Widzimy:

<widgets>
		<main_settings>
				<multi_screen enable="true"/>
		</main_settings>
		<screen1 wallpaper="Screen1/Zanzibar.jpg">
				<widget1 wpath="Screen1/Winamp.swf" enable="true" xpos="0" ypos="210" mdisable="false" menable="true"/>
				<widget2 wpath="Screen1/Analog.swf" enable="true" xpos="128" ypos="25" mdisable="false" menable="false"/>
				<widget3 wpath="Screen1/PhoneStatus.swf" enable="true" xpos="0" ypos="25" mdisable="false" menable="false"/>
		</screen1>
		<screen2 wallpaper="Screen2/Lake.jpg">
				<widget1 wpath="Screen2/HTCClock.swf" enable="true" xpos="4" ypos="25" mdisable="false" menable="false"/>
				<widget2 wpath="Screen2/HTCPlayer.swf" enable="true" xpos="5" ypos="190" mdisable="false" menable="true"/>
				<widget3 wpath="Screen2/Notes.swf" enable="true" xpos="0" ypos="180" mdisable="true" menable="false"/>
		</screen2>
</widgets>

main_settings:
Możesz włączyć/wyłączyć opcję Multi-Screen - true lub false. Jeśli jest ustawione na false, konfiguracje po potrząśnięciu nie będą zmieniały się.
screen1:
-wpath: ścieżka do widgetu i jego nazwa
-enable: włącz/wyłącz widget - true lub false
-xpos: pozycja od lewej krawędzi ekranu
-ypos: pozycja od górnej krawędzi ekranu
-mdisable: wyłącz widget, gdy muzyka zostanie włączona - true lub false
-menable: pokazuj widget TYLKO, gdy muzyka jest włączona - true lub false
-Chcesz więcej widgetów? Dodaj nowe linijki, jak ta:

<widgetX wpath="folder/file.swf" enable="true" xpos="10" ypos="20" mdisable="false" menable="false"/>

zamiast X wpisz numer widgetu [wyższy od poprzedniej pozycji].
screen2:
-Wszystko tak samo jak w sekcji screen1

-Ustaw ścieżkę i nazwę tapet tutaj: <screenX wallpaper="...."/>
-Zalecane rozszerzenie - jpg.

-Uwagi
1. Zalecane jest usunięcie layoutem loga operatora, daty i godziny (co by zrobić miejsce dla Widgetów ).
2. Parametry mdisable i menable nie mogą być jednocześnie ustawione na true. Możliwe kombinacje: false-false ; false-true ; true-false.

Widgety!
1. Analog (1)

Prosty zegar analogowy - wersja small i big.
Autor: DemonicHawk
Edycja: kaczmar22

 Analog1.rar   146.26K   20 downloads

2. Analog (2)

Zegar analogowy - autor: DemonicHawk
Edycja: kaczmar22

 analog2.rar   32.07K   10 downloads

3. Analog (3)

Zegar analogowy - autor: DemonicHawk
Edycja: kaczmar22

 analog3.rar   29.02K   9 downloads

4. Analog (4)

Zegar analogowy - autor: DemonicHawk
Edycja: kaczmar22

 analog4.rar   50.76K   12 downloads

5. Analog (5)

Zegar analogowy - autor: DemonicHawk
Edycja: kaczmar22

 analog5.rar   119.69K   17 downloads

6. Analog (6)

Autor: DemonicHawk
Edycja: kaczmar22

 analog6.rar   135.86K   17 downloads

7. Analog (7)

Autor: DemonicHawk
Edycja: mc_kibel, kaczmar22
Info: Poprawiona wersja -> brak błędu ze wskazówką godzin.

 analog7.rar   41.39K   17 downloads



8. Analog ( 8 )

Autor: DemonicHawk
Edycja: kaczmar22

 analog8.rar   37.63K   7 downloads

9. Analog (9)

Autor: DemonicHawk
Edycja: kaczmar22
 analog9.rar   38.13K   9 downloads

10. Calendar

Autor: DemonicHawk
Edycja: kaczmar22

 calendar.rar   54.62K   30 downloads

11. HTC Clock + pogoda

Autor: DemonicHawk
Edycja: mc_kibel, kaczmar22
Uwagi: Widget nie łączy się z internetem - plik weather.txt aktualizuje się ręcznie, np. tutaj: http://www.joeearl.co.uk/portfolio/22/

 HTC Clock.rar   260.34K   45 downloads


12. Simple Analog

Autor: mc_kibel

 SimpleAnalog.rar   12.66K   14 downloads

13. Notes

Autor: mc_kibel
Uwagi: Plik Note.txt wrzucamy do katalogu WidgetManager. Zawartość takiego pliku to:
MyNote=Wpisz tresc notatki

Gdy chcemy pozbyć się notatki, usuwamy wiadomość, ale MyNote= zostawiamy (obowiązkowo!).

 Notes.rar   10.55K   17 downloads
14. HTC Player

Autor: mc_kibel
Widget playera pokazujący się przy włączonej muzyce.

 HTCplayer.rar   11.39K   26 downloads


15. Winamp Widget

Autor: mc_kibel
Podobny widget do powyższego HTC Player

 Winamp.rar   11.32K   17 downloads

16. Windows Media Player

Autor: kaczmar22
Info: dwie wersje: non-stop (pokazuje się nawet przy wyłączonej muzyce) i normalna

 WMP.rar   31.38K   13 downloads


17. Kalendarz - dwie wersje, mała i duża

Autor: kaczmar22

 Kalendarz.rar   21.51K   18 downloads

Życzymy miłej zabawy

Edit: przez pośpiech zapomniałem dodać przykładowych plików konfiguracyjnych -> dodano archiwum Example Configs.

Changelog!

WidgetManager 2.0: Kompletna aktualizacja całego managera - pełen opis w pierwszym poście tematu. Poprawiona obsługa XML, duża optymalizacja, dodana opcja Multi-Screen.
WidgetManager_update1: Aktualizacja tylko w WidgetManager.swf. Dużo lepsza obsługa akcelerometru!

 WidgetManager 2.1.rar   635.88K   109 downloads

 Example Configs.rar   992bytes   53 downloads

 WidgetManager_update1.rar   7.14K   61 downloads

Sony Ericsson WidgetSuite
? 2010 mc_kibel


Ogólne informacje:
Projekt jest rozwiniętą i zmodyfikowaną wersją WidgetManagera. Jest dedykowany dla telefonów na platformie DB3350, ale zadziała na każdym A2.
Ważne: Aby wyeksportować własną konfigurację, będzie potrzebny Adobe Flash CS3 lub nowszy. Na stronie Adobe dostaniemy darmowy trial na 30 dni.

1. Jak użyć?
Na początek musisz utworzyć własną konfigurację.
Pobierz Sony Ericsson WidgetSuite Editor 1.1:
http://www.sendspace.com/file/ipatwg

Obejrzyj przykładowe video, pokazujące tworzenie kompletnej konfiguracji.


Więcej o SE WidgetSuite Editor:
-Aby włączyć/wyłączyć widget, kliknij na niego na liście.
-Jeśli widget jest już włączony, kliknij "E" aby edytować jego właściwości.
-Naciśnij Prev. / Next screen aby przełączać się między ekranami.
-Kliknij na "Simulate Media Player" aby włączyć lub wyłączyć symulowanie odtwarzacza.

Obejrzałeś video? To dobrze! Po prostu skopiuj zawartość pola tekstowego po wciśnięciu "Generate" i wklej całą zawartość do pliku Config.txt w katalogu WidgetSuite na PC.
Teraz otwieramy WidgetSuite.fla, klikamy "Publish" na dole (CS3) lub "Edit" w pobliżu "Publish" (CS4), a następnie "Publish" w nowo otwartym okienku:



Można zamknąć Adobe Flash. WidgetSuite.swf jest gotowy do wgrania na telefon. Kopiujemy tylko ten jeden plik i ustawiamy na tapetę.

Aby przełączać ekrany, wystarczy lekko przechylić telefon (w lewo -> poprzedni ekran ; w prawo -> następny ekran).

Można również użyć standardowej konfiguracji, aby poznać możliwości tej modyfikacji. Przykładowy config dla WidgetSuite w załączniku.


2. Co tutaj jest trudniejsze niż WidgetManager?
-Pobieranie pogody.
--Wchodzimy na http://weather.joeearl.co.uk/
--Pobieramy pogodę dla naszego miasta.
--Ściągamy WeatherFix.rar, wypakowujemy.
--Przeciągamy ściągnięty weather.txt na WeatherFix.exe.
--Usuwamy weather.txt, a nazwę nowo utworzonego weather.txt.fix.txt zmieniamy na weather.txt.
--Umieszczamy zmodyfikowany weather.txt w katalogu, gdzie znajduje się WidgetManager.fla.

-Ustawianie tekstu notatki
--Otwieramy Note.txt. W pliku można się łatwo połapać, więc chyba nie muszę tłumaczyć

-Zmiana tapety jest również trudniejsza:
--Otwieramy WidgetSuite.fla, otwieramy folder "Main Content" w oknie "Library" i dwukrotnie klikamy na Tween 1.
--Klikamy na obrazek i wciskamy "delete" na klawiaturze.
--Naciskamy CTRL+R i wybieramy nową tapetę (480x320!)
--Robimy "Publish" (tak jak to było opisywane wcześniej)

-Po operacjach takich, jak pobraniu pogody, zmianie tapety czy aktualizacji treści notatki, musimy "wypublishować" plik .fla. Robimy to tak, jak to zostało opisane wcześniej.


---------------------------------------------------------------------------------

3. Dotacje
Spędziłem wiele godzin przed komputerem i wypisałem dość pokaźną ilość linijek kodu (szczególnie stworzenie WidgetSuite Editora było najtrudniejszym elementem). Będę wdzięczny za każde, nawet najmniejsze, wsparcie. Jeśli więc chcesz pomóc:



---------------------------------------------------------------------------------







 WidgetSuite_1.1.rar   1.49MB   30 downloads

 WeatherFix.rar   8.23K   21 downloads

 WidgetSuite_1.1_CS3.rar   979.63K   26 downloads

Witam

Poradnik tworzenia tapet we flash lite 1.1 wyświetlających info o MP3 jest w dziale ogólnie o SE i oprogramowaniu > software. Jest jednak wyjątkowo łopatologicznie napisany, co dla ludzi bawiących się flashem może okazać się męczące.

Dlatego zebrałem wszystkie informacje i umieściłem je tutaj. Wszystko znajduje się w jednym miejscu - do tego dochodzą jeszcze informacje o Flash Lite 2.x

Jak wiadomo, dużo SE obsługuje Flash Lite.

Tutaj pokażę Wam trochę przydatnych rzeczy na ten temat, do tworzenia na przykład tapet flash lub flash menu (jeśli chodzi o flash menu to w wolnej chwili przeanalizuje kod, teraz zajęty jestem innymi sprawami ). Potrzebny program to najlepiej Macromedia Flash 8 z zainstalowanym update-m dla Flash Lite 2.x. Jest szybsza i stabilniejsza od Adobe Flash CS3.

No więc kilka rzeczy:

• Zegar analogowy:
  -Instance name movie clipa dla wskazówki godzin - HourHand
  -Instance name movie clipa dla wskazówki minut - MinHand
  -Instance name movie clipa dla wskazówki sekund - SecHand
  -Wszystkie movie clipy muszą mieć punkt obrotu ustalony na środkowy dół.
  Dla Flash Lite 1.1:
  
  

  Hours1 = fscommand2("GetTimeHours");
  Minutes1 = fscommand2("GetTimeMinutes");
  Seconds1 = fscommand2("GetTimeSeconds");
  setProperty("HourHand", _rotation, Hours1 * 30 + Minutes1 / 2);
  setProperty("MinutesHand", _rotation, Minutes1 * 6);
  setProperty("SecHand", _rotation, Seconds1 * 6);
  

  Dla Flash Lite 2.x:
  
  

  Hours1 = fscommand2("GetTimeHours");
  Minutes1 = fscommand2("GetTimeMinutes");
  Seconds1 = fscommand2("GetTimeSeconds");
  HourHand._rotation = Hours1 * 30 + Minutes1 / 2;
  MinutesHand._rotation = Minutes1 * 6;
  SecHand._rotation = Seconds1 * 6;
  

• Zegar cyfrowy (bez sekund)
  -VAR pola tekstowego wyświetlającego czas to "CurrentTime"
  Dla Flash Lite 1.1 i 2.x:
  
  

  hour = fscommand2("GetTimeHours");
  minutes = fscommand2("GetTimeMinutes");
  if(hour < 10){
  	 hour = "0" add hour;
  }
  if(minutes < 10){
  	 minutes = "0" add minutes;
  }
  CurrentTime = hour add":" add minutes;
  

• Wyświetlanie % baterii
  -VAR pola tekstowego wyświetlającego stan baterii: "BattStatus"
  Dla Flash Lite 1.1 i 2.x:
  
  

  Battery = fscommand2("GetBatteryLevel");
  MaxBattery = fscommand2("GetMaxBatteryLevel");
  BatLevel = Math.round(Battery / MaxBattery * 100);
  BattStatus = "Battery" add":" add BatLevel add"%";
  

• Wyświetlanie dnia tygodnia
  -VAR pola tekstowego: "weekdayTXT"
  Dla Flash Lite 1.1 i 2.x:
  
  

  weekday = fscommand2("GetDateWeekday");
  if(weekday == 6){weekdayTXT = "Sobota"}
  if(weekday == 5){weekdayTXT = "Piatek"}
  if(weekday == 4){weekdayTXT = "Czwartek"}
  if(weekday == 3){weekdayTXT = "Sroda"}
  if(weekday == 2){weekdayTXT = "Wtorek"}
  if(weekday == 1){weekdayTXT = "Poniedzialek"}
  if(weekday == 0){weekdayTXT = "Niedziela"}
  

• Wyświetlanie nazwy operatora:
  -VAR pola tekstowego: "myProvider"
  Testowane dla Flash Lite 1.1, jednak na 2.x też powinno działać:
  
  

  fscommand2("GetNetworkName", "myProvider");
  

• Wyświetlanie informacji o aktualnie odtwarzanej MP3:
  Flash lite 1.1:
  

  -VAR pól tekstowych:
  --Dla tytułu: TITLE
  --Dla artysty: ARTIST
  --Dla albumu: ALBUM
  loadVariables("MP:",_root);
  fscommand2 ("MP:", "TITLE");
  fscommand2 ("MP:", "ARTIST");
  fscommand2 ("MP:", "ALBUM");
  

  Flash lite 2.x:
  

  -Instance Name pól tekstowych:
  --Dla tytułu: TITLE
  --Dla artysty: ARTIST
  --Dla albumu: ALBUM
  onEnterFrame = function ()
  {
  loadVariables("MP://data", _root);
  Title.text = _root.TITLE;
  Album.text = _root.ALBUM;
  Artist.text = _root.ARTIST;
  }
  

Teraz trochę opisu.
Żeby informacje były odświeżane, należy zapętlić kod. Najlepszym sposobem jest po prostu przedłużenie animacji do dwóch klatek, a kod umieścić w pierwszej. Wtedy w drugiej klatce należy dodać:

gotoAndPlay(1);

Wtedy informacje są odświeżane na bięrząco (tj. godzina, dzień tygodnia, nazwa operatora).

Można też zrobić tak, aby kod został wykonywany dopiero wtedy, gdy jakiś warunek będzie spełniony:

if (warunek){
kod-do-wykonania();
}

Tak więc na przykład dla flash lite ukazanie się obrazku, gdy zostanie włączona muzyka:

loadVariables("MP:",_root);
fscommand2 ("MP:", "TITLE");
fscommand2 ("MP:", "ARTIST");
fscommand2 ("MP:", "ALBUM");
if(length(TITLE) != 0 or length(ARTIST) != 0 or length(ALBUM) != 0){
gotoAndPlay(xx);
}

Należy dodać, że kod umieszczamy w pierwszej klatce, w drugiej dodajemy "gotoAndPlay(1);", które zapętli ten kod. Gdy w końcu zostanie wykryte włączenie odtwarzacza, animacja przejdzie do klatki xx - gdzie będzie można umieścić obrazek.
Teraz w klatce xx dodać należy kod, który wykryje wyłączenie odtwarzacza:

loadVariables("MP:",_root);
fscommand2 ("MP:", "TITLE");
fscommand2 ("MP:", "ARTIST");
fscommand2 ("MP:", "ALBUM");
if(length(TITLE) == 0 && length(ARTIST) == 0 && length(ALBUM) == 0){
gotoAndPlay(1);
}

A w klatce następującej po xx, należy dodać kod "gotoAndPlay(xx);", który zapętli wykonywanie akcji odpowiedzialnej za wykrycie wyłączenia odtwarzacza.
Oto był właśnie taki przykład prostej pętli z wykonaniem akcji, gdy odtwarzacz zostanie włączony i z wykonaniem akcji, gdy odtwarzacz zostanie wyłączony.
Bawiąc się trochę we Flashu, można uzyskać naprawde wiele ciekawych rzeczy

Pozdrawiam.

not found: Poprawiłem emotikonki, bo ich nie wyświetlało

Witam!

Jako, że miałem k770i i strasznie zainteresował mnie Flash Lite, a dokładnie tapety, wyświetlające tytuł, artystę i album aktualnie odtwarzanej piosenki Tak więc krótki poradnik, co i jak.

Zaznaczam, że nie jestem autorem, przetłumaczyłem to z angielskiego poradnika. Przetestowałem i naprawdę działa.

Screeny mojego autorstwa!

Zaczynamy:

Potrzebny jest nam program Macromedia Flash 8 (lub nowsza wersja, Adobe Flash 9);
Tapeta, do której chcemy dodać wyświetlanie piosenki.

1. Otwieramy program, tworzymy nowy dokument o rozdzielczości 240x320.

2. W panelu na dole, pokazanym na screenie poniżej klikamy Settings


3. Ustawiamy w polu "Version" "Flash Lite 1.1". Oprócz tego w polu JPEG Quality ustawiamy "100".


4. Klikamy na pierwszej warstwie, "Layer 1".


5. Naciskamy "CTRL + R" i wybieramy tapetę, którą chcemy mieć za tło.

6. Tworzymy nową warstwę.


7. Teraz robimy wszystko tak jak na screenie:
- przechodzimy na "Layer 2"
- wybieramy narzędzie tekstu
- wyznaczamy nim zakres pola tekstowego
- typ pola tekstowego ustawiamy na Dynamic Text
- w polu "VAR:" na dolnym panelu wpisujemy TITLE


8. Na tej samej warstwie robimy wszystko jeszcze dwa razy, z tym że ustawiamy VAR: nowych pól tekstowych na ARTIST, a później na ALBUM.

9. Nad dolnym panelem jest do rozwinięcia pole Actions - klikamy na nie. Oczywiście mamy być na drugiej warstwie.

10. Mając zaznaczoną drugą warstwę, w polu "actions" powinna być możliwość pisania. Jeśli jej nie ma to zaznaczamy pierwszą klatkę animacji na drugiej warstwie Tak więc wklejamy do pola actions:
loadVariables("MP:",_root);
fscommand2 ("MP:", "TITLE");
fscommand2 ("MP:", "ARTIST");
fscommand2 ("MP:", "ALBUM");


Powinno to wyglądać tak:


11. Na linii czasu będąc na pierwszej warstwie, wybieramy drugą klatkę (pustą) i naciskamy F5. To samo robimy na drugiej warstwie. Jest to bardzo ważne!

12. Naciskamy CTRL+S i zapisujemy plik gdziekolwiek chcemy. Następnie na panelu properties klikamy przycisk Settings przy Publish. W nowo otwartym oknie klikamy Publish.





12. Plik o nazwie wpisanej przy zapisywaniu pliku, znajdzie się w tym samym miejscu co projekt i będzie w formacie .swf. Wgrywamy do fona i sprawdzamy, czy widać tytuł przy odtwarzaniu piosenki



Mam nadzieję, że to wam się przyda.

Uwaga!
Jest to stary poradnik na temat portowania patchy. Nowy, dokładniejszy, a przede wszystkim profesjonalny sposób portowania znajduje się tutaj: http://www.sonyerics...rzy-uzyciu-asm/

Witam.

Poradnik od początku do końca został napisany przeze mnie. Kopiowanie, rozprzestrzenianie lub jakakolwiek modyfikacja bez mojej wiedzy jest zabroniona. Zaznaczam, że nie odpowiadam za uszkodzenia telefonu spowodowane niedokładnym czytaniem poradnika. Wszystko robisz na własną odpowiedzialność.

Uwaga. Opis portowania PROSTYCH patchy również jest tutaj zawarty i znajduje się na samym dole poradnika. Na początek dobrze jest właśnie zacząć od prostych patchy, aby później przesiąść się na większe.


Rozpisywać się nie będę, tylko od razu do rzeczy: przedstawiam Wam poradnik portowania zaawansowanych patchy.
Pod pojęciem "zaawansowanych patchy" kryje się pojęcie portowania patchy, które używają wolnych miejsc w mainie, czyli takich, które obok offseta mają wartości z zerami:

1bd7940: 00000000000000000000000000000000 142801D2002070471E2801D201207047

Uwaga! Cała procedura będzie przedstawiona na patchu "Podświetlenie od 10 do 100%", portowanego z K770i R8BA024 na K770i R8BC004 [db2020].
Wszystko wykonujemy analogicznie dla innych modeli telefonu.
Zaleca się również portowanie z softu jednego telefonu na inny soft również tego samego telefonu, gdyż mainy są do siebie bardziej podobne co ułatwia portowanie.
Nie oznacza to jednak, że nie można portować np. z K800i na W580i Owszem można tylko w niektórych momentach może być ciężko.


Wprowadzenie

Pierwszym krokiem będzie ustalenie bazy naszego firmware oraz platformy.
Będę dodawał tutaj telefony w miarę zdobywania informacji.
Jeśli ktoś będzie znał model telefonu i jego bazę, proszę o napisanie tego w tym temacie, uzupełnię wtedy poradnik.

DB2010
baza w zależności od modelu:

• dla K510i: 44140000
• dla K750i/D750i/W800i/W700i: 44020000
• dla W810i: 44140000

DB2020

• K770i/k800i/k790i/k810i/w850i : 44140000
• Inne modele tutaj niewymienione powinny posiadać bazę 44140000.

DB3150 - tutaj portowanie jest troche cięższą sprawą.

• Wszystkie telefony z softem a2 v1: baza dla całego phone_app: FFFE000, a baza właściwej części maina 10000000 (czyli tyle będziemy dodawać do jump adresów).

Teraz już wiemy (mam nadzieję, że wiemy ) jaką baze ma nasz telefon.

Pobieranie / przygotowanie niezbędnych plików

1. Musimy zaopatrzyć się w WinHexa (tak, w WinHexa, żadne inne hex-edytory, gdyż skróty klawiaturowe i dokładny opis będzie właśnie dla niego)
Wpisać w google i pobrać.

2. Teraz oczywiście musimy mieć patcha, którego chcemy przeportować.

3. Pobieramy MAIN, dla którego patch istnieje oraz MAIN, na który chcemy przeportować patcha.

4. Pobieramy program Main2Raw. Przeciągamy pliki .mbn od ściągniętych softów na ten program. W folderze z mainem utworzą się pliki w formacie RAW o takiej samej nazwie jak plik .mbn.

Otwieranie plików
Ehh już jestem zmęczony a to dopiero początek...

1. Otwieramy w WinHexie utworzone przez program Main2Raw pliki softu [obydwa].

2. Otwieramy plik .vkp patcha za pomocą notatnika. W moim przypadku jest to:

;K770 SW-R8BA024
;Alows to adjust brightness from 10 before 100%
;? IronMaster
;(p)A1z
+44140000
12d0e7c: 401D0A21 401C0A21
12d2110: 262801D200207047312801D2 00B50149884700BD4179D145
12d213c: 042810D801A1095C8F44C046 00B50149884700BD8D79D145
12d218a: 0522281C 0922281C
1384c78: 242901D22421 0A2901D20A24
1bd7940: 00000000000000000000000000000000 142801D2002070471E2801D201207047
1bd7950: 00000000000000000000000000000000 282801D202207047322801D203207047
1bd7960: 00000000000000000000000000000000 3C2801D204207047462801D205207047
1bd7970: 00000000000000000000000000000000 502801D2062070475A2801D207207047
1bd7980: 00000000000000000000000000000000 642801D2082070470920704708281AD8
1bd7990: 00000000000000000000000000000000 01A1095C8F44C0460A0E12161A1E2226
1bd79a0: 00000000000000000000000000000000 2A000A207047142070471E2070472820
1bd79b0: 00000000000000000000000000000000 7047322070473C207047462070475020
1bd79c0: 00000000000000000000 70475A20704764207047

Gdy patch nie ma bazy

Może się zdarzyć tak, że patch nie ma bazy. Baza jest to linijka z plusem i wartością obok, poprzedzające główną część patcha:

+44140000
12d0e7c: 401D0A21 401C0A21

W przypadku tego patcha jest to baza +44140000. Tak więc gdy bazy nie ma, od offsetu musimy odjąć baze softa naszego telefonu (wymienione we wprowadzeniu). Dla przykładu patch na zmianę położenia progressbara (w850):

;W850 SW-R1KG001
;Changing position progressbar in recording video
;(c) jamesbond22
4513d492: E11D 611C
4513d49a: 50 6E
4513d66c: 51 6F
4513d66e: 08 02
45075752: 50 6E
45075768: C01D 401C

Tak więc bierzemy pierwszy offset z patcha (4513d492), odejmujemy bazę maina w850 (jest to 44140000) i wychodzi nam FFD492. Dopisujemy bazę +44140000 (akurat w tym przypadku jest to taka wartość) linijkę nad patchem i wpisujemy wynik naszego działania zamiast oryginalnego offsetu:

;W850 SW-R1KG001
;Changing position progressbar in recording video
;(c) jamesbond22
+44140000
FFD492: E11D 611C
xxxxxxxx: 50 6E
xxxxxxxx: 51 6F
xxxxxxxx: 08 02
xxxxxxxx: 50 6E
xxxxxxxx: C01D 401C

No i to samo robimy z kolejnymi offsetami. Teraz tylko odejmujemy od nich bazę i zamieniamy. Gdy zrobimy to ze wszystkimi offsetami, przechodzimy do portowania.

Portowanie!

1. Pierwszym krokiem będzie odnalezienie Jump adresów. Jump adresy mogą być w każdym miejcu.
Rozpoznaje się je po co siódmym i co ósmym znaku, a wartością rozpoznawczą wśród db201x i db2020 jest 44 lub 45. W przypadku DB3150 są to 11 lub 12. Długość jump adresu to 8 znaków.
Dla przykładu w tym patchu są to pogrubione wartości [a miejsca po których to rozpoznano są podkreślone] :

;K770 SW-R8BA024
;Alows to adjust brightness from 10 before 100%
;? IronMaster
;(p)A1z
+44140000
12d0e7c: 401D0A21 401C0A21
12d2110: 262801D200207047312801D2 00B50149884700BD4179D145
12d213c: 042810D801A1095C8F44C046 00B50149884700BD8D79D145
12d218a: 0522281C 0922281C
1384c78: 242901D22421 0A2901D20A24
1bd7940: 00000000000000000000000000000000 142801D2002070471E2801D201207047
1bd7950: 00000000000000000000000000000000 282801D202207047322801D203207047
1bd7960: 00000000000000000000000000000000 3C2801D204207047462801D205207047
1bd7970: 00000000000000000000000000000000 502801D2062070475A2801D207207047
1bd7980: 00000000000000000000000000000000 642801D2082070470920704708281AD8
1bd7990: 00000000000000000000000000000000 01A1095C8F44C0460A0E12161A1E2226
1bd79a0: 00000000000000000000000000000000 2A000A207047142070471E2070472820
1bd79b0: 00000000000000000000000000000000 7047322070473C207047462070475020
1bd79c0: 00000000000000000000 70475A20704764207047

2. Kolejnym krokiem będzie ustalenie miejsca, do którego jump adresy się odwołują.

Bierzemy pierwszy pogrubiony jump z patcha: 4179D145.
Takie rzeczy w patchu są poodwracane bajtami (jako, że jest to system heksadecymalny, to jednym bajtem są dwa znaki).
Odczytujemy więc jump adress od końca po dwa znaki: czyli zamiast 41 79 D1 45 będzie to 45 D1 79 41 [porobiłem odstępy i pooznaczałem znaki, żeby rzuciło wam się to lepiej w oczy].
Tak więc dobrze jest mieć otwarty pusty dokument w notatniku, aby można było sobie notować jump adresy i je odwracać.
Bierzemy ten odwrócony jump adres zaznaczamy myszką i kopiujemy [Tym odwróconym jump adresem jest 45D17941 w moim przypadku].

Zamiast odwracać jump adresy ręcznie można użyć programu Bytes Reverser. Odznaczamy w nim opcję "Jump into reversed adress in IDA", wklejamy jump, dajemy REVERSE i kopiujemy wartość z dołu. Program do pobrania w załączniku.

Otwieramy windowsowski kalkulator.Klikamy u góry Widok>Naukowy. Zaznaczamy kropkę przy HEX.
Dajemy edycja>wklej. Klikamy na minus ( - ) i odejmujemy bazę naszego telefonu + 1. Dla K770i jest to 44140001.
Tak więc po wykonaniu działania: 45D17941 - 44140001 = 1BD7940.

Teraz przyglądamy się naszemu patchowi. Jeśli znajdziemy offset o wartości takiej, jakiej jest wynik działania to wykonujemy to co jest do wykonania poniżej. A jeśli nie ma offsetu o wartości takiej jak wynik działania, to przechodzimy do offsetu jakim jest wynik działania [klikamy na dole winhexa na offset i wpisujemy wartość] w mainie dla którego patch istnieje, zaznaczamy kilka miejsc na prawo, wciskamy CTRL+shift+c, w drugim mainie dajemy w WinHexie "search" i "find hex values", Wklejamy skopiowane wartości i wciskamy ENTER, gdy winhex znajdzie wartości to wciskamy F3. Jeśli znajdzie kolejne, to z pierwszego maina kopiujemy więcej wartości i szukamy w drugim mainie, a jeśli nie znajdzie wogóle, to kopiujemy mniej wartości i szukamy w drugim mainie, w każdym razie musimy doprowadzić do takiego stanu, aby wynik poszukiwania == 1; gdy uda nam się to zrobić spisujemy offset z dołu winhexa, dodajemy do niego kalkulatorem 44140001 i odwracamy po dwa znaki.

Jednak w naszym przypadku jest taki offset w patchu. Jest to ta linijka:

1bd7940: 00000000000000000000000000000000 142801D2002070471E2801D201207047

I zaraz się nią zajmiemy. Teraz jednak musimy zlokalizować, gdzie drugi jump adress się odwołuje.

3. Teraz sprawdzamy gdzie odwołuje się drugi jump - jest to 8D79D145. Odwracamy go po dwa znaki i odejmujemy bazę + 1, czyli w naszym przypadku 44140001. Czyli z 8D79D145 powstaje 45d1798d, odejmujemy 44140001 i powstaje 1BD798C. Tak więc robimy sobie notatki przy patchu:

;K770 SW-R8BA024
;Alows to adjust brightness from 10 before 100%
;? IronMaster
;(p)A1z
+44140000
12d0e7c: 401D0A21 401C0A21
12d2110: 262801D200207047312801D2 00B50149884700BD4179D145; jump do offsetu 1bd7940 w patchu
12d213c: 042810D801A1095C8F44C046 00B50149884700BD8D79D145; jump do offsetu 1BD798C w patchu
12d218a: 0522281C 0922281C
1384c78: 242901D22421 0A2901D20A24
1bd7940: 00000000000000000000000000000000 142801D2002070471E2801D201207047
1bd7950: 00000000000000000000000000000000 282801D202207047322801D203207047
1bd7960: 00000000000000000000000000000000 3C2801D204207047462801D205207047
1bd7970: 00000000000000000000000000000000 502801D2062070475A2801D207207047
1bd7980: 00000000000000000000000000000000 642801D2082070470920704708281AD8
1bd7990: 00000000000000000000000000000000 01A1095C8F44C0460A0E12161A1E2226
1bd79a0: 00000000000000000000000000000000 2A000A207047142070471E2070472820
1bd79b0: 00000000000000000000000000000000 7047322070473C207047462070475020
1bd79c0: 00000000000000000000 70475A20704764207047

Teraz pytanie skąd wiemy że 1bd798c odwołuje się do patcha, skoro nie ma takiego offsetu. Tak więc owszem jest, ale głębiej.

Interesuje nas offset + C.



Tak więc jump odwołuje się do offsetu 1bd7980 + C.

4. Musimy teraz przeportować wartości do miejsc z zerami, czyli

+44140000
12d0e7c: 401D0A21 401C0A21
12d2110: 262801D200207047312801D2 00B50149884700BD4179D145; jump do offsetu 1bd7940 w patchu
12d213c: 042810D801A1095C8F44C046 00B50149884700BD8D79D145; jump do offsetu 1BD798C w patchu
12d218a: 0522281C 0922281C
1384c78: 242901D22421 0A2901D20A24

Tak więc kopiujemy pierwszy offset 12d0e7c. W winhexie, mając otwarty main dla którego patch istenieje klikamy na dole offset, wklejamy te 12d0e7c i klikamy ENTER. Kopiujemy kilka wartości na prawo [ctrl+shift+c]. Przechodzimy do drugiego maina, klikamy u góry search>find hex values. Wklejamy wartości, dajemy ENTER. Winhex znajdzie wartości. Klikamy F3. Jak znajdzie kolejne to kopiujemy więcej wartości, a gdy nie znajdzie już więcej to wpisujemy nowy offset zamiast 12d0e7c do patcha. W naszym przypadku będzie to nowy offset 12d2a2c.

Wykonujemy punkt powyżej dla wszystkich offsetów przed zerami, czyli do offsetu 1384c78 włącznie. Jeśli zrobiliśmy wszystko dobrze, to wychodzi nam:

+44140000
12d2a2c: 401D0A21 401C0A21
12d3cb8: 262801D200207047312801D2 00B50149884700BD4179D145
12d3ce4: 042810D801A1095C8F44C046 00B50149884700BD8D79D145
12d3d32: 0522281C 0922281C
138682c: 242901D22421 0A2901D20A24

No więc te miejsca mamy przeportowane.

5. Teraz kolejnym krokiem będzie znalezienie wolnych miejsc w mainie, czyli miejsc z zerami. Mając otwarty main, dla którego chcemy przeportować patcha, zjeżdżamy na sam dół. Wybieramy któryś offset z tych wolnych miejsc.
Mała uwaga: musimy użyć miejsc, których nie używają inne zaawansowane patche, dobrze jest więc przejrzeć patche żeby mieć rozeznanie, które miejsca są użyte. W moim przypadku nowym wolnym miejscem będzie offset 1CBF400.

Tak więc zmieniamy wartość pierwszego offseta obok którego występują zera z 1bd7940 na 1CBF400. Kolejny offset wpisujemy taki, jaki jest offset wyżej + 10 (liczymy kalkulatorem w hexie) tak więc kolejny offset będzie miał 1CBF410. Z kolejnym offsetem robimy to samo, z tą różnicą, że 10 dodajemy do poprzedniego, czyli 1cbf410 + 10.

Tak więc wychodzi nam:

1CBF400: 00000000000000000000000000000000 142801D2002070471E2801D201207047
1CBF410: 00000000000000000000000000000000 282801D202207047322801D203207047
1CBF420: 00000000000000000000000000000000 3C2801D204207047462801D205207047
1CBF430: 00000000000000000000000000000000 502801D2062070475A2801D207207047
1CBF440: 00000000000000000000000000000000 642801D2082070470920704708281AD8
1CBF450: 00000000000000000000000000000000 01A1095C8F44C0460A0E12161A1E2226
1CBF460: 00000000000000000000000000000000 2A000A207047142070471E2070472820
1CBF470: 00000000000000000000000000000000 7047322070473C207047462070475020
1CBF480: 00000000000000000000 70475A20704764207047

6. Łączymy utworzone przez nas części, czyli części z zerami i część do miejsc z zerami. Wychodzi:

;K770 SW-R8BA024
;Alows to adjust brightness from 10 before 100%
;? IronMaster
;(p) mc_kibel
+44140000
12d2a2c: 401D0A21 401C0A21
12d3cb8: 262801D200207047312801D2 00B50149884700BD4179D145
12d3ce4: 042810D801A1095C8F44C046 00B50149884700BD8D79D145
12d3d32: 0522281C 0922281C
138682c: 242901D22421 0A2901D20A24
1CBF400: 00000000000000000000000000000000 142801D2002070471E2801D201207047
1CBF410: 00000000000000000000000000000000 282801D202207047322801D203207047
1CBF420: 00000000000000000000000000000000 3C2801D204207047462801D205207047
1CBF430: 00000000000000000000000000000000 502801D2062070475A2801D207207047
1CBF440: 00000000000000000000000000000000 642801D2082070470920704708281AD8
1CBF450: 00000000000000000000000000000000 01A1095C8F44C0460A0E12161A1E2226
1CBF460: 00000000000000000000000000000000 2A000A207047142070471E2070472820
1CBF470: 00000000000000000000000000000000 7047322070473C207047462070475020
1CBF480: 00000000000000000000 70475A20704764207047

7. Pozostało nam przeportowanie jump adresów, czyli pogrubionych adresów w patchu.

Jako, że w oryginalnym patchu dla k770i r8ba024 wartości te odwoływały się odpowiednio do 1bd7940 i druga do 1BD7980 + C w patchu dla r8ba024, to teraz pierwszy jump będzie odwoływał się do 1CBF400, a drugi do 1CBF440 + C, czyli 1CBF44C.

Trzeba z nich tylko utworzyć jump adresy.

8. Tworzenie jumpów z offsetów.

Mając offset 1CBF400, kopiujemy go do kalkulatora, dodajemy bazę + 1, czyli w moim przypadku 44140001. Wychodzi nam 45DFF401. Odwracamy je teraz po dwa znaki od końca i wychodzi nam: 01F4DF45.

Wklejamy więc 01F4DF45 zamiast 4179D145 w tej linijce:

12d3cb8: 262801D200207047312801D2 00B50149884700BD4179D145

i wychodzi nam:
12d3cb8: 262801D200207047312801D2 00B50149884700BD01F4DF45

Teraz mając drugi offset czyli 1CBF44C, dodajemy do niego 44140001, wychodzi 45DFF44D - odwracamy go po dwa znaki. Wychodzi nam jump 4DF4DF45. Wklejamy go w tej linijce niżej zamiast 8D79D145:

12d3ce4: 042810D801A1095C8F44C046 00B50149884700BD8D79D145

I wychodzi nam:

12d3ce4: 042810D801A1095C8F44C046 00B50149884700BD4DF4DF45


Łączymy wszystko w kupę, zmieniamy wersję oprogramowania w opisie patcha, obok (p) wpisujemy swój nick i powstaje nam przeportowany patch.

;K770 SW-R8BC004
;Alows to adjust brightness from 10 before 100%
;? IronMaster
;(p) mc_kibel
+44140000
12d2a2c: 401D0A21 401C0A21
12d3cb8: 262801D200207047312801D2 00B50149884700BD01F4DF45
12d3ce4: 042810D801A1095C8F44C046 00B50149884700BD4DF4DF45
12d3d32: 0522281C 0922281C
138682c: 242901D22421 0A2901D20A24
1CBF400: 00000000000000000000000000000000 142801D2002070471E2801D201207047
1CBF410: 00000000000000000000000000000000 282801D202207047322801D203207047
1CBF420: 00000000000000000000000000000000 3C2801D204207047462801D205207047
1CBF430: 00000000000000000000000000000000 502801D2062070475A2801D207207047
1CBF440: 00000000000000000000000000000000 642801D2082070470920704708281AD8
1CBF450: 00000000000000000000000000000000 01A1095C8F44C0460A0E12161A1E2226
1CBF460: 00000000000000000000000000000000 2A000A207047142070471E2070472820
1CBF470: 00000000000000000000000000000000 7047322070473C207047462070475020
1CBF480: 00000000000000000000 70475A20704764207047

Portowanie prostych patchy.

Przed zaczęciem, czytamy opisy wyżej: "Wprowadzenie", "Pobieranie / przygotowanie niezbędnych plików" i "Otwieranie plików".

No więc mamy sobie taki o to malutki, prosty patch:

;K770 SW-R8BA024
;Zmienia kolor paska postępu w odtwarzaczu na pomarańczowy.
;? Hussein
;? svinuk
;(p) Zyozya
4507BC00: 04E400FF 0030F6FF

Jako, że patch nie ma bazy, odejmujemy od offseta bazę maina naszego telefonu (w tym przypadku 44140000) i linijkę wyżej dodajemy bazę, poprzedzając ją plusem. Wynik działania 4507BC00-44140000=F3BC00

;K770 SW-R8BA024
;Zmienia kolor paska postępu w odtwarzaczu na pomarańczowy.
;? Hussein
;? svinuk
;(p) Zyozya
+44140000
F3BC00: 04E400FF 0030F6FF

Pokazany patch będzie portowany spod K770i R8ba024 na K770i R8BC004.

No więc zaznaczamy i kopiujemy offset (offset jest to część zaznaczona na pomarańczowo).
W WinHexie przechodzimy do maina, dla którego istnieje patch. Klikamy na dole WinHexa OFFSET i wklejamy nasz offset z patcha ( w tym przypadku będzie to f3bc00 ). Klikamy ENTER. Od miejsca, które wskazał WinHex, zaznaczamy kilka miejsc na prawo. Kopiujemy wartości HEX skrótem klawiaturowym CTRL+SHIFT+C. Przechodzimy do drugiego maina, dla którego chcemy przeportować patcha. Klikamy u góry winhexa SEARCH > Find HEX Values. Wklejamy skopiowaną wartość i wciskamy ENTER. Program powinien znaleźć tą wartość. Naciskamy F3 i jeśli ukaże się kolejna wartość, to przechodzimy do pierwszego maina i kopiujemy więcej wartości. Ogólnie to polecam zaznaczanie czterech do ośmiu wartości (czyli od 8 do 16 znaków). Później ponawiamy szukanie. Musimy doprowadzić do sytuacji, aby ilość wyszukiwań była równa 1.

No i ok, doprowadziliśmy do sytuacji, że ilość wyszukiwań jest równa 1. I co dalej?

Odczytujemy z dołu WinHexa offset. W naszym przypadku jest to F3C8DC. Wstawiamy ją do patcha zamiast oryginalnego offseta. Zmieniamy wersję softa w opisie patcha i obok (p) wpisujemy swój nick. Efekt:

;K770 SW-R8BC004
;Zmienia kolor paska postępu w odtwarzaczu na pomarańczowy.
;? Hussein
;? svinuk
;(p) mc_kibel
+44140000
F3C8DC: 04E400FF 0030F6FF

 BytesReverser.rar   7.65K   3 downloads

Witam

Dzisiaj przedstawię poradnik tworzenia sterowników dźwięku w formacie ZAPF. Poradnik o tworzeniu sterowników APF napiszę w niedalekiej przyszłości

1. Musimy przygotować kilka plików:

• Pierwszy będzie to WinHex. Potrzebna jest nam pełna wersja. Bez niej nic nie zdziałamy, bo nie obsługuje template-ów.
• Kolejnym będzie APFSuite. Do pobrania w załączniku.
• Zdobycie oryginalnych sterowników ZAPF od jakiegoś telefonu (do wyjęcia z rozpakowanego FSa). Standardowe od W880 do pobrania w załączniku.
• Plik TEMPLATE dla WinHexa wyświetlający dokładnie co za co odpowiada w ZAPFie. Do pobrania w załączniku.

2. Pobieramy Zapf_Template z załączników. Wypakowujemy z niego plik ZAPF.tpl i umieszczamy w folderze z WinHexem.

3. Pobieramy oryginalne niemodyfikowane sterowniki dźwięku np. z załącznika ( Original_W880_acoustic.rar ).

4. Pobieramy APFSuite, wypakowujemy do nowego folderu. W folderze z APFSuite umieszczamy pliki, które chcemy modyfikować. Tutaj tabelka co za co jest odpowiedzialne:

• BT - Słuchawkowy zestaw BT
• BTC - samochodowy zestaw BT
• Farfield - zewnętrzny głośnik (lub głośnik przy odtwarzaniu muzyki)
• Handset - głośnik od rozmów
• PHF - Dźwięk na słuchawkach
• LO_Play - dźwięk na dołączanych głośnikach MPS

Tak więc aby modyfikować pliki odpowiedzialne za dźwięk za słuchawkach, bierzemy wszystkie pliki .zapf rozpoczynające się od PHF, kopiujemy je i wklejamy do folderu z APFSuite.

5. Otwieramy APF Suite. Wybieramy opcję DECOMPRESS. Zaznaczamy myszą wszystkie pliki ZAPF. Po chwili program w logu pokaże DONE! - zamykamy go.

6. Usuwamy wszystkie pliki ZAPF z folderu APF Suite i zostawiamy tylko pozostawione przez niego pliki APF.

7. Uruchamiamy WinHexa. Otwieramy pliki utworzone przez APFSuite.

8. Mając otwarty plik w WinHexie, wciskamy na klawiaturze kombinację ALT+F12. Wybieramy ZAPF Editor i dajemy Apply.

9. Otwiera nam się nowe okienko:



Widzimy tutaj m.in:

• Enchanced Echo Canceller - w wolnym tłumaczeniu z j. ang. - rozbudowany 'reduktor' echa - ustawienie parametru na 00 wyłącza tą funkcję, a na 01 - włącza.
• Noise Reduction - Redukcja szumów - ustawienie parametru na 00 wyłącza tą funkcję, a na 01 - włącza.
• Whining Noise Filter - Whining noise oznacza "Pojękiwanie", a co oznacza "Filter" tłumaczyć nie muszę - ustawienie parametru na 00 wyłącza tą funkcję, a na 01 - włącza.

W tej części ekranu będzie to wszystko co potrafię do tej pory powiedzieć o ZAPFach.
Zjedźmy jednak z "Zapf Editorze" trochę niżej, aż ujrzymy parametry TXPGA, RXPGA i RXVOL:



O parametrach widocznych na tym screenie mogę powiedzieć natomiast tyle:

• TXPGA - odpowiedzialne za soprany. Ustawienie na 00 spowoduje maksymalne podbicie sopranów, ustawienie wartości większych będzie redukowało soprany, tak więc na 02 soprany będą mniej słyszalne.
• RXPGA - odpowiedzialne za basy. Ustawienie na 00 spowoduje maksymalne podbicie basów, a ustawianie wartości większych będzie te basy redukowało.
• RXVOL - głośność. I tutaj tak samo jak wyżej. Wartość 00 da nam najgłośniejszy dźwięk wyjściowy. Większe wartości będą w efekcie dawały cichszy dźwięk
• Uwaga! - widoczne są te parametry podwójnie, to znaczy widać dla przykładu TXPGA02 i TXPGA01. To samo tyczy się kolejnych wartości. Tak więc wartości w 02 i w 01 powinny być takie same.

Kombinacja przedstawiona na screenie przedstawia kombinację z akustyki PowerBass v3 v.FullMod mojego autorstwa z modułu odpowiedzialnego za słuchawki. Tak więc nie życzę sobie powielania kombinacji tych wartości i używania ich w swojej akustyce. Jeśli chcesz użyć akustyki o tych parametrach to zerknij do mojej sygnaturki i kliknij w link tematu o akustyce PowerBass i po prostu ją ściągnij.

No dobra, postraszyłem Was, więc możemy jechać dalej .

10. Oczywiście modyfikujemy sterowniki po swojemu. Gdy już poustawiamy wszystkie parametry tak jak sobie życzymy, zamykamy ZAPF editora klikając na krzyżyk. W okienku:



Klikamy YES.

Później zamykamy plik w WinHexie:



I w nowym okienku klikamy YES.

11. Modyfikujemy kolejne pliki. Gdy już to zrobimy, zamykamy WinHexa, uruchamiamy ApfSuite.

12. W ApfSuite klikamy Compress, wybieramy wszystkie APF-y, po chwili będzie DONE! - zamykamy program.

13. Usuwamy wszystkie .apf z folderu APFSuite. Zostawiamy pliki ZAPF. Utworzone pliki ZAPF podmieniamy z oryginalnymi w telefonie I testujemy swoje sterowniki.



To chyba na tyle, pozdrawiam

 ZAPF_Template.rar   786bytes   8 downloads

 APFSuite.rar   170.72K   8 downloads

 Original_W880_acoustic.rar   55.9K   4 downloads

Witam!

Pokażę Wam, jak można w prosty sposób wczytać innego elfa z poziomu drugiego.

1. Pierwszym krokiem będzie dodanie hooka dla klawiatury w int main ():

ModifyKeyHook(NewKey,1);

2. Pod includami umieszczamy:

int NewKey (int key, int r1, int mode)
{
  if(key==0x1A && mode==0x00) //krótkie wciśnięcie siódemki w K770i.
  {
	    elfload(L"/tpa/user/other/ZBin/Elf2.elf",0,0,0); //Wczytaj plik Elf2.elf ze ścieżki /tpa/user/other/ZBin/
  }
  return 0;
}

W ten sposób po wciśnięciu w tym przypadku siódemki uruchamiany jest elf z podanej ścieżki, czyli z: /tpa/user/other/ZBin/Elf2.elf

Można się pokusić teraz o to, żeby elf był otwierany dopiero pod pewnym warunkiem.
Doprowadźmy więc do sytuacji, w której elf zostanie otwarty tylko wtedy, gdy włączony jest aparat:

int NewKey (int key, int r1, int mode)
{
  if(key==0x1A && mode==0x00)
  {
	    BOOK * TopBook = DISPLAY_GetTopBook(0);
	    if ((!strcmp(TopBook->xbook->name,"CameraBook"))==1)
//Gdy włączony jest aparat/camera...
	    {
		  elfload(L"/tpa/user/other/ZBin/Elf2.elf",0,0,0); //...wczytaj plik Elf2.elf ze ścieżki /tpa/user/other/ZBin/
	    }
  }
  return 0;
}

I możemy sobie tak kombinować w nieskończoność ;-)
W przypadku mojego ostatniego elfa takie coś było koniecznością - inaczej nic by z tego nie wyszło. Oczywiście mowa o elfie do zamykania muzyki po podanym czasie, który nie ujrzał jeszcze światła dziennego.

Pozdr.

Poradnik od początku do końca został napisany przeze mnie i jest moją własnością. Kopiowanie, rozprzestrzenianie lub jakakolwiek modyfikacja jest zabroniona!

Witam

Przedstawiam opis portowania funkcji bibliotek elfpacka.
Jest dużo pisania, jednak przeportowanie jednej funkcji biblioteki zajmuje mi teraz około 30 sekund (mając już otwarty main w IDA). Tak więc nie taki diabeł straszny....

Uwaga!
W poradniku są użyte przypisy. Gdy zobaczysz gwiazdki na końcu zdania, to zobacz do przypisów na końcu poradnika

Przygotowanie.

Pobieranie niezbędnych plików

1. Kluczem jest IDA Pro. Program waży w granicach 70-100 MB. Do zdobycia na własną rękę. Po ściągnięciu instalujemy.
2. Main2Raw
3. BytesReverser
4. PatSearchNT

Otwieranie maina w IDA (Disassembling)

1. Otwieramy main w IDA według tego opisu:
http://sony.yt/index...-disassembling/

Portowanie funkcji

1. Uwaga! Na początek zalecam portować ten sam fragment, aby zrozumieć "co i jak". Gdy się uda, można portować inne funkcje
Będziemy portować funkcję oznaczoną jako 348 spod k770 r8ba024 do k770 r8bc004.
Jest to ta funkcja:

0D20: 00000000 99294545; 348: void GUIonMessage_SetLineSeparator(GUI_MESSAGE *,int _unk1);

• Część oznaczona kursywą to jump adress. TYLKO TA CZĘŚĆ BĘDZIE SIĘ ZMIENIAĆ!
• Część pogrubiona to oznaczenie funkcji (ta część się nie zmienia)
• Część podkreślona to opis funkcji (ta część się nie zmienia)
• Część w żaden sposób nie oznaczona (offset i wartość z zerami) NIE BĘDZIE SIĘ ZMIENIAĆ - to bardzo ważne.

2. Main w IDA mamy już otwarty. Odpalamy więc BytesReverser.
3. Przytoczę fragment z pierwszego punktu w tej sekcji:

0D20: 00000000 99294545; 348: void GUIonMessage_SetLineSeparator(GUI_MESSAGE *,int _unk1);

Zaznaczamy część oznaczoną kursywą (jump adress: 99294545) i kopiujemy ją.
4. W polu Bytes To Reverse wklejamy skopiowaną wartość. Opcja "Jump to the reversed adress in IDA" ma być zaznaczona.


5. Klikamy Reverse Them!
6. Po kliknięciu reverse them zostaniemy przeniesieni do IDA i będzie tam zaznaczony na niebiesko ten ROM:


7. Myszką klikamy na rom znajdujący się o jeden wyżej (czyli zamiast 45452999 klikamy na 45452998).
8. Wciskamy Alt+G i robimy tak:


9. Wciskamy na klawiaturze "C". Naszym oczom ukazuje się:


10. Jest to dość mały kod, tak więc będzie ogromna ilość wyników. Dlatego trzeba skonwertować do kodu troche więcej offsetów. Tak więc w tym przypadku klikamy na ROM 454529A2 i klikamy "C". Kod dalej jest mały - tak więc klikamy dalej na ROM 454529AE i wciskamy "C". Kod dalej nie należy do ogromnych w tym przypadku. Klikamy więc na kolejny offset nie skonwertowany do kodu (czyli pierwszy "żółty" ROM pod czerwonymi). Ja pokuszę sie o skonwertowanie do kodu kolejnego romu, 454529C6, 454529D2, 454529DE, 454529EA, 454529FA oraz 45452A08.
Gdy kod na początku jest długi, wystarczy skonwertować tylko kolejne dwa-trzy "żółte" romy znajdujące się pod czerwonymi. Pewnie dziwicie się, że aż tyle offsetów konwertuję - to wszystko dlatego, że kod się powtarza i są to bardzo krótkie "sekwencje" kodu.
Wygląda to tak:


11. Cofamy się do romu, gdzie zaczęliśmy konwertować część maina do kodu. W moim przypadku jest to: 45452998
12. Zaznaczamy wszystkie ROMy, które są czerwone i kopiujemy je skrótem Ctrl+Insert.
W moim przypadku cały kod wygląda tak:

ROM:45452998 00 B5					   PUSH    {LR}
ROM:4545299A C0 68					   LDR	 R0, [R0,#0xC]
ROM:4545299C EE F7 4C F8				 BL	  sub_45440A38
ROM:454529A0 00 BD					   POP	 {PC}
ROM:454529A2			 ; ---------------------------------------------------------------------------
ROM:454529A2 00 00					   LSLS    R0, R0, #0
ROM:454529A4 00 B5					   PUSH    {LR}
ROM:454529A6 C0 68					   LDR	 R0, [R0,#0xC]
ROM:454529A8 EE F7 58 F8				 BL	  sub_45440A5C
ROM:454529AC 00 BD					   POP	 {PC}
ROM:454529AE			 ; ---------------------------------------------------------------------------
ROM:454529AE 00 00					   LSLS    R0, R0, #0
ROM:454529B0 00 B5					   PUSH    {LR}
ROM:454529B2 C0 68					   LDR	 R0, [R0,#0xC]
ROM:454529B4 EE F7 AA F8				 BL	  sub_45440B0C
ROM:454529B8 00 BD					   POP	 {PC}
ROM:454529BA			 ; ---------------------------------------------------------------------------
ROM:454529BA 00 00					   LSLS    R0, R0, #0
ROM:454529BC 00 B5					   PUSH    {LR}
ROM:454529BE C0 68					   LDR	 R0, [R0,#0xC]
ROM:454529C0 EE F7 AE F8				 BL	  sub_45440B20
ROM:454529C4 00 BD					   POP	 {PC}
ROM:454529C6			 ; ---------------------------------------------------------------------------
ROM:454529C6 00 00					   LSLS    R0, R0, #0
ROM:454529C8 00 B5					   PUSH    {LR}
ROM:454529CA C0 68					   LDR	 R0, [R0,#0xC]
ROM:454529CC EE F7 B4 F8				 BL	  sub_45440B38
ROM:454529D0 00 BD					   POP	 {PC}
ROM:454529D2			 ; ---------------------------------------------------------------------------
ROM:454529D2 00 00					   LSLS    R0, R0, #0
ROM:454529D4 00 B5					   PUSH    {LR}
ROM:454529D6 C0 68					   LDR	 R0, [R0,#0xC]
ROM:454529D8 EE F7 B8 F8				 BL	  sub_45440B4C
ROM:454529DC 00 BD					   POP	 {PC}
ROM:454529DE			 ; ---------------------------------------------------------------------------
ROM:454529DE 00 00					   LSLS    R0, R0, #0
ROM:454529E0 00 B5					   PUSH    {LR}
ROM:454529E2 C0 68					   LDR	 R0, [R0,#0xC]
ROM:454529E4 EE F7 BC F8				 BL	  sub_45440B60
ROM:454529E8 00 BD					   POP	 {PC}
ROM:454529EA			 ; ---------------------------------------------------------------------------
ROM:454529EA 00 00					   LSLS    R0, R0, #0
ROM:454529EC 00 B5					   PUSH    {LR}
ROM:454529EE C0 68					   LDR	 R0, [R0,#0xC]
ROM:454529F0 0A 1C					   ADDS    R2, R1, #0
ROM:454529F2 00 21					   MOVS    R1, #0
ROM:454529F4 EE F7 C0 F8				 BL	  sub_45440B78
ROM:454529F8 00 BD					   POP	 {PC}
ROM:454529FA			 ; ---------------------------------------------------------------------------
ROM:454529FA 00 00					   LSLS    R0, R0, #0
ROM:454529FC 00 B5					   PUSH    {LR}
ROM:454529FE C0 68					   LDR	 R0, [R0,#0xC]
ROM:45452A00 00 21					   MOVS    R1, #0
ROM:45452A02 EE F7 D1 F8				 BL	  sub_45440BA8
ROM:45452A06 00 BD					   POP	 {PC}
ROM:45452A08			 ; ---------------------------------------------------------------------------
ROM:45452A08 00 B5					   PUSH    {LR}
ROM:45452A0A 00 23					   MOVS    R3, #0
ROM:45452A0C 01 29					   CMP	 R1, #1
ROM:45452A0E 08 D0					   BEQ	 loc_45452A22
ROM:45452A10 02 29					   CMP	 R1, #2
ROM:45452A12 08 D0					   BEQ	 loc_45452A26
ROM:45452A14 03 29					   CMP	 R1, #3
ROM:45452A16 08 D0					   BEQ	 loc_45452A2A
ROM:45452A18 04 29					   CMP	 R1, #4
ROM:45452A1A 08 D0					   BEQ	 loc_45452A2E
ROM:45452A1C 05 29					   CMP	 R1, #5
ROM:45452A1E 08 D0					   BEQ	 loc_45452A32
ROM:45452A20 08 E0					   B	   loc_45452A34
ROM:45452A22			 ; ---------------------------------------------------------------------------
ROM:45452A22
ROM:45452A22			 loc_45452A22						    ; CODE XREF: ROM:45452A0Ej
ROM:45452A22 01 23					   MOVS    R3, #1
ROM:45452A24 06 E0					   B	   loc_45452A34
ROM:45452A26			 ; ---------------------------------------------------------------------------
ROM:45452A26
ROM:45452A26			 loc_45452A26						    ; CODE XREF: ROM:45452A12j
ROM:45452A26 02 23					   MOVS    R3, #2
ROM:45452A28 04 E0					   B	   loc_45452A34
ROM:45452A2A			 ; ---------------------------------------------------------------------------
ROM:45452A2A
ROM:45452A2A			 loc_45452A2A						    ; CODE XREF: ROM:45452A16j
ROM:45452A2A 06 23					   MOVS    R3, #6
ROM:45452A2C 02 E0					   B	   loc_45452A34
ROM:45452A2E			 ; ---------------------------------------------------------------------------
ROM:45452A2E
ROM:45452A2E			 loc_45452A2E						    ; CODE XREF: ROM:45452A1Aj
ROM:45452A2E 07 23					   MOVS    R3, #7
ROM:45452A30 00 E0					   B	   loc_45452A34
ROM:45452A32			 ; ---------------------------------------------------------------------------
ROM:45452A32
ROM:45452A32			 loc_45452A32						    ; CODE XREF: ROM:45452A1Ej
ROM:45452A32 08 23					   MOVS    R3, #8
ROM:45452A34
ROM:45452A34			 loc_45452A34						    ; CODE XREF: ROM:45452A20j
ROM:45452A34													 ; ROM:45452A24j ...
ROM:45452A34 C0 68					   LDR	 R0, [R0,#0xC]
ROM:45452A36 19 1C					   ADDS    R1, R3, #0
ROM:45452A38 EE F7 D0 F8				 BL	  sub_45440BDC
ROM:45452A3C 00 BD					   POP	 {PC}

13. Uruchamiamy PatSearchNT. Klikamy load FF i wybieramy MAIN, dla którego chcemy przeportować funkcję, oczywiście w formacie RAW. Ja wybieram K770 r8bc004.
14. W PatSearch, w miejscu gdzie widzimy

??,B5
??,68
??,??,??,F8
??,BD
??,00
??,B5
??,68
??,??,??,F8
??,BD
??,00
??,B5
??,68
??,??,??,F8
??,BD
??,00
??,B5
??,68
??,??,??,F8
??,BD
??,00
??,B5
??,68
??,??,??,F8
??,BD
??,00
??,B5
??,68
??,??,??,F8
??,BD
??,00
??,B5
??,68
??,??,??,F8
??,BD
??,00
??,B5
??,68
??,1C
??,21
??,??,??,F8
??,BD
??,00
??,B5
??,68
??,21
??,??,??,F8
??,BD
??,B5
??,23
??,29
??,D0
??,29
??,D0
??,29
??,D0
??,29
??,D0
??,29
??,D0
??,E0
??,23
??,E0
??,23
??,E0
??,23
??,E0
??,23
??,E0
??,23
??,68
??,1C
??,??,??,F8
??,BD

17. Teraz WSZYSTKIE miejsca, gdzie jest 8 znaków (nie licząc przecinków), zamieniamy na ??,??,??,??. Wygląda to teraz tak:

??,B5
??,68
??,??,??,??
??,BD
??,00
??,B5
??,68
??,??,??,??
??,BD
??,00
??,B5
??,68
??,??,??,??
??,BD
??,00
??,B5
??,68
??,??,??,??
??,BD
??,00
??,B5
??,68
??,??,??,??
??,BD
??,00
??,B5
??,68
??,??,??,??
??,BD
??,00
??,B5
??,68
??,??,??,??
??,BD
??,00
??,B5
??,68
??,1C
??,21
??,??,??,??
??,BD
??,00
??,B5
??,68
??,21
??,??,??,??
??,BD
??,B5
??,23
??,29
??,D0
??,29
??,D0
??,29
??,D0
??,29
??,D0
??,29
??,D0
??,E0
??,23
??,E0
??,23
??,E0
??,23
??,E0
??,23
??,E0
??,23
??,68
??,1C
??,??,??,??
??,BD

18. Klikamy SEARCH.
19. W okienku po prawej stronie ukazuje nam się: 45454544


20. Kopiujemy tą wartość (zaznaczona na obrazku).
21. Odpalamy windowsowski kalkulator, wybieramy widok > naukowy, później klikamy widok > szesnastkowy.
22. Wklejamy wynik z PatSearchNT, czyli 45454544. Klikamy na "+", wpisujemy "1" i dajemy ENTER. **
23. Otrzymujemy wynik 45454545, kopiujemy go (to tylko przypadek że widzimy same czwórki i piątki )
24. Otwieramy Bytes reverser, odznaczamy ptaszka przy "Jump to the reversed adress in IDA". W pole bytes to reverse wklejamy wynik z kalkulatora i klikamy Reverse Bytes. Kopiujemy wynik z pola Reversed bytes.***
25. Mając tą linijkę z k770 r8ba024:

0D20: 00000000 99294545; 348: void GUIonMessage_SetLineSeparator(GUI_MESSAGE *,int _unk1);

Zmieniamy więc 99294545 na wynik z bytes reversera, czyli zaznaczamy 99294545 i wklejamy 45454545. Mamy więc już przeportowaną jedną funkcję biblioteki Wygląda to tak:

0D20: 00000000 45454545; 348: void GUIonMessage_SetLineSeparator(GUI_MESSAGE *,int _unk1)

Tak więc aby wgrać tą funkcję do biblioteki elfpacka, otwieramy patch biblioteki dla naszego telefonu i wklejamy tą linijkę w patchu Później wystarczy wgrać bibliotekę do telefonu.

26. Gdy już będziemy zamykać IDA, przy okienku, które wyskoczy robimy tak:


Później przy otwieraniu tego samego maina wybieramy plik IDB, ważący w granicach 100mb

(Screeny od zylka, dzięki bardzo )
Dzięki temu nie musimy czekać za każdym razem na otwarcie maina i nie musimy wpisywać wartości w rom size itp.

Info: Tym sposobem w okolicach 10 minut przeportowałem 28 nowych funkcji z biblioteki spod k770 r8ba024 na r8bc004:

;K770 SW-R8BC004
;Update for elfpack library (funcs. 336-353)
;(p) mc_kibel
+45D2FC00
0CD8: 00000000 EDC50845; 336: void VideoPlayerControl(BOOK *VideoPlayerBook, int);
0CDC: 00000000 69BC0845; 337: void Video_ActionBack(BOOK*,void*)
0CE0: 00000000 45D60845; 338: void Video_ExtractFrame(BOOK *VideoPlayerBook)
0CE4: 00000000 21C00845; 339: void Video_ZoomOn(BOOK*,void*)
0CE8: 00000000 E5084C45; 33A: void RightNow_Active(int flag /*0-1*/)
0CEC: 00000000 75BF0845; 33B: void VideoResize_AutomateMode(BOOK*,u16,u16,u16*,u16*)
0CF0: 00000000 0DBF0845; 33C: void VideoResize_AllScreenMode(BOOK*,u16,u16,u16*,u16*)
0CF4: 00000000 F5CF0845; 33D: int Video_GetCurrentSkinID(BOOK*)
0CF8: 00000000 49A30845; 33E: void Video_SetSkin(GUI*,int)
0CFC: 00000000 9DBE0845; 33F: int Video_SetPermit(BOOK*,u16,u16)
0D00: 00000000 39BA0845; 340: int Video_Refresh(BOOK*,GUI*)
0D04: 00000000 E9BC0845; 341: void Video_Play(BOOK*,void*)
0D08: 00000000 21BE0845; 342: void Video_Pause(BOOK*,void*)
0D0C: 00000000 EDBD0845; 343: void Video_Stop(BOOK*,void*)
0D10: 00000000 812A0745; 344: void Audio_Pause(BOOK *)
0D14: 00000000 C5270745; 345: void Audio_Play(BOOK *)
0D18: 00000000 958F4A45; 346: GUI * CreatePercentInputVA(int zero, ...)
0D1C: 00000000 35914A45; 347: int PercentInput_GetPercent(GUI * PercentInput)
0D20: 00000000 45454545; 348: void GUIonMessage_SetLineSeparator(GUI_MESSAGE *,int _unk1)
0D2C: 00000000 694B4545; 34B: void GUIObject_Softkeys_RemoveBackground(void *gui)
0D30: 00000000 693B4545; 34C: void GUIObject_Softkeys_RestoreBackground(void *gui)
0D34: 00000000 11993F45; 34D: void SetTrayIcon(wchar_t iconID, char mode)
0D38: 00000000 D9A64145; 34E: int REQUEST_SETTING_RINGVOLUME_SET(const int *sync, int unk, int null, int vol)
0D3C: 00000000 0DAF4145; 34F: int REQUEST_SETTING_VIBRATOR_SET(const int *sync, int unk, int mode)
0D40: 00000000 C9A84145; 350: int REQUEST_SETTING_RINGTYPESOUNDFILE_SET(const int *sync, int null, wchar_t *path, wchar_t *name)
0D44: 00000000 65AE4145; 351: int REQUEST_SETTING_ANSWERINGMODE_SET(const int *sync, int unk, int mode)
0D48: 00000000 95A74145; 352: int REQUEST_SETTING_INCREASINGRING_SET(const int *sync, int unk, int unk2, int mode)
0D4C: 00000000 0DAF4145; 353: int REQUEST_SETTING_ALLOWEDCALLERS_SET(const int *sync, int unk, int mode)

Tak więc wystarczy przeczytać to kilka razy ze zrozumieniem - ja już to wszystko robię z pamięci i zajmuje to naprawdę chwilkę Najwięcej czasu zajmuje otwarcie maina w IDA

Przypisy:

* - Jeśli wynik jest równy 10, to dodajemy "1" do znaku wcześniej, a trzeci znak po "0x" zmieniamy na 0.

** - Dla niektórych wyda to się głupie, ale nie wszyscy pojmują system szesnastkowy i przy dodawaniu "1" do "F" "w pamięci" mogą sie pogubić, tak więc lepiej będzie jeśli zrobi to kalkulator - a wszystko będzie w stu procentach dobrze zrobione.

*** - Wprawdzie tutaj wynikiem był 45454545, tak więc po odwróceniu to również będzie 45454545. Jednak opisuje tą procedurę, gdyż w innych przypadkach i tak trzeba ją wykonać.

Zmęczyłem się trochę... No ale myślę, że się przyda. Tak więc pozdrawiam i dziękuję za uwagę

Witam.
W tym temacie wrzucamy opis funkcji elfpacka, według schematu:

Zastosowanie:
...
Funkcja:
... (fragment z lib)
Parametry:
...
Przykład użycia
+opis, jeśli wymagany.

Tak więc najpierw skieruje podziękowania w stronę se-developers, a w szczególności dla Edgpaez, gdyż akurat informacje nt. tych funkcji, które opisuję w tym poście pochodzą z tamtego forum, a zdecydowaną większość opisał właśnie on.

No więc zaczynam:

_________________________________________________

Zastosowanie:
Konwersja "String" (czyli po ludzku dowolnego tekstu) na StringID (identyfikator tekstu)

Funkcja:

; 15D: int Str2ID(const void * wstr , int  flag , int len);

Parametry:
const void * wstr - to, co chcemy przekonwertować na StringID
int flag - określa rodzaj stringa:
- 0 = Unicode
- 2 = numer telefonu
- 6 = ASCI
int len - długość stringa
- SID_ANY_LEN = uniwersalne, czyli działa dla każdej długości

Zwraca:
String ID

Przykład:

int Przyklad;
Przyklad = Str2ID(L"CentrumSE", 0, SID_ANY_LEN);

____________________________________________________

Zastosowanie:
Pokazanie na ekranie okienka z informacją.

Funkcja:

; 257: void MessageBox(int HeaderStrID,int MessageStrID,wchar_t IconID, int style /*1 or 2*/,int time,BOOK * unk);

Parametry:

• int HeaderStrID - StringID tytułu okienka, jeśli niepotrzebne wpisujemy 0x6FFFFFFF
• int MessageStrID - StringID wiadomości, która ma pokazać się w okienku
• int IconID - ID obrazka wyświetlanego w MSGBoxie, 0 gdy niepotrzebne
• int style - może być 1 lub 2. Gdy jest jeden, widzimy coś w stylu okienka wyskakującego przy blokowaniu klawiatury, a jeśli 2, to coś w stylu "statusu telefonu".
• int time - czas w milisekundach, przez który ma wyświetlać się okienko
  -dotyczy tylko wtedy, gdy int style = 1;
  -gdy int style = 2, czas musi być ustawiony na 0, inaczej restart.
• BOOK * unk - wskaźnik, gdzie wiadomość ma być wyświetlona
  -najlepiej / najłatwiej wpisać 0, żeby nie utrudniać sobie życia

Zwraca:
Nic

Przykład:

int tytul, int wiadomosc;
tytul = Str2ID(L"Dowolny tytul", 0, SID_ANY_LEN);
wiadomosc = Str2ID(L"Tekst wiadomosci", 0, SID_ANY_LEN);
void MessageBox (tytul, wiadomosc, 0, 2, 0, 0);

Przykład powyżej spowoduje wyświetlenie okienka wyglądającego jak "Status telefonu", z tytułem "Dowolny tytul" oraz trescia "Tekst wiadomosci".

int wiadomosc2;
wiadomosc2 = Str2ID(L"CentrumSE.pl",0,SID_ANY_LEN);
void MessageBox (0x6FFFFFFF, wiadomosc2 , 0 , 1 , 3000 , 0);

A powyższy kod, spowoduje wyświetlenie okienka wyglądającego jak te przy usuwaniu pliku/blokowaniu klawiatury, o treści "CentrumSE.pl", które zniknie po 3000milisekund (czyli po trzech sekundach).

Używanie Str2ID ma sens w sumie tylko wtedy, gdy jednego stringa używamy kilkukrotnie w kodzie, bo gdy chcemy wyświetlić takie samo okienko jak powyżej, możemy zaoszczędzić trochę kodu robiąc to w ten sposób:

void MessageBox (0x6FFFFFFF, STR("CentrumSE.pl") , 0 , 1 , 3000 , 0);

Efekt ten sam, dwie linijki kodu mniej.

______________________________________________________

Zastosowanie:
Pobranie obecnego profilu

Funkcja:

; 1B4: int REQUEST_PROFILE_GETACTIVEPROFILE(const int *__zero , int *level);

Parametry:

• const int * __zero - zamiast tego wpisujemy SYNC
• int * level - wskaźnik, gdzie numer obecnego profilu ma być zapisywany
  -Tak więc gdy zamiast int * level wpiszemy &Profil, informacje na temat numeru obecnego profilu będą zapisywane w zmiennej Profil.

Zwraca:
Numer profilu (int, liczba całkowita, od 0 do 6)

Przykład:

int profil;
REQUEST_PROFILE_GETACTIVEPROFILE(SYNC , &profil);
if (profil == 0 )
{
//Kod do wykonania, gdy numer profilu jest równy 0 (czyli podstawowy)
} else if (profil == 1)
{
//Kod do wykonania, gdy numer profilu jest równy 1 (spotkanie)
}

____________________________________________________

Zastosowanie:
Ustawienie profilu

Funkcja:

; 1B5: int Profile_SetActive(int NUMprof,int set_in_gdfs_flag);

Parametry:

• int NUMprof - wystarczy wpisać 0
• int set_in_gdfs_flag - liczba całkowita od 0 do 6, odpowiedzialna za profil. Tak więc wpisanie 5 ustawi nam profil "Dom".

Przykład:

int numer_profilu = 5;
Profile_SetActive(0 , numer_profilu); //ustawia profil "Dom"

________________________________________________________

Zastosowanie:
Sprawdzenie, czy klawiatura jest zablokowana.

Funkcja:

; 1B7: int  isKeylocked(void);

Parametry:

• brak

Zwraca:
0 - gdy klawiatura nie jest zablokowana
1 - gdy klawiatura jest zablokowana

Przykład:

if(isKeylocked() == 0)
{
//kod do wykonania, gdy klawiatura jest odblokowana
}

if (isKeylocked() == 1)
{
//kod do wykonania, gdy klawiatura jest zablokowana
}

Tutaj znajdziesz podstawowe informacje o strukturze pliku VKP

;K800 SW-R8BF003
;Advanced softkeys handling
;Add-on to AdvSoftkeys elf
;? UltraShot
;(p) michlantecuhtli
+44140000
131652a: 021C2B1C0020215E381C 014A904701E001BDD145
1316984: 3BF090F9021C3B1C211C301C C046014A904701E00DBDD145
1316aa0: 021C2B1C6F460020395E301C 014A904702E0FFFF17BDD145
1340620: 0DFA4745 49BDD145
1bdbd00: 00000000000000000000000000000000 021C2B1C0020215E381C0AE03B1C021C
1bdbd10: 00000000000000000000000000000000 211C301C05E0021C2B1C6F460020395E
1bdbd20: 00000000000000000000000000000000 301C01B5081C00F002F8011C01BDFEB5
1bdbd30: 00000000000000000000000000000000 071C1948164EB047002803D08569381C
1bdbd40: 00000000000000000000000000000000 A847FEBD381CFEBDB0B5051C104C1248
1bdbd50: 00000000000000000000000000000000 A047002803D10D4C281CA047B0BD071C
1bdbd60: 00000000000000000000000000000000 281CFC69A0470028F5D0281CB0BD00B5
1bdbd70: 00000000000000000000000000000000 002806D00068406808A1064B98470028
1bdbd80: 00000000000000000000000000000000 01D0002000BD012000BDFFFF0DFA4745
1bdbd90: 00000000000000000000000000000000 95CE3A4541A667446FBDD145536F6674
1bdbda0: 0000000000 6B65797300

W tej części znajdują się komentarze, czyli informacje na temat patcha, jakie jest jego zadanie, na jaki model telefonu i jaką wersję softa patch jest przeznaczony oraz informacja, kto jest autorem patcha. Tekst poprzedzony jest średnikami, tak więc nie jest brany pod uwage przez żadne programy.

Fragment oznaczony tym kolorem to "Base Addres", czyli baza patcha.

Część oznaczona tym kolorem to część, w której oryginalne wartości w mainie podmieniane są na nowe.
Rzeczy oznaczone kursywą to offsety, rzeczy nieoznaczone w żaden sposób oryginalne wartości w mainie, a rzeczy pogrubione to nowe wartości, które są wprowadzane do maina zamiast oryginalnych.

Tym kolorem oznaczona jest część, nazywana "Patch Body". Jest to część, która używa wolnych miejsc w mainie, które są na samym jego końcu. Do tego miejsca odwołują się jump adresy.*

*Jump adresy to ciąg ośmiu znaków, zakończonych na 44/45 (a w przypadku A2 są to 11/12). Są one odwrócone bajtami (czyli po dwa znaki, gdyż jest to system szesnastkowy [gdzie dwa znaki oznaczają jeden bajt] ). Tak więc 01BDD145 odwołuje się do 45D1BD01 - i odejmujemy od tego jeszcze "1", aby znać rzeczywiste miejsce, do którego odwołuje się jump - tak więc jump 01BDD145 odwołuje się do 45D1BD00.

Info: jest to kontynuacja tematu "Portowanie adresów w ASM".

• Uruchamiamy Arm Patch Compiler.
• Zaznaczamy kropkę przy bazie jaką mamy, w arm patch compilerze.
• Zaznaczamy "Base adress no added to offsets"
• Zaznaczamy kropkę przy DEFAULT.
• W ASM file path podajemy ścieżkę do pliku asm z przeportowanymi adresami.
• W raw file path podajemy ścieżkę do pliku raw softa dla którego chcemy utworzyć patcha.
• Klikamy CREATE.

W folderze, gdzie znajdywał się plik ASM, ukaże nam się plik VKP. Jego zawartość:

+44140000
12d2a2c: 401D0A21 401C0A21
12d3cb8: 262801D200207047312801D2 00B50149884700BD01F4DF45
12d3ce4: 042810D801A1095C8F44C046 00B50149884700BD4DF4DF45
12d3d32: 0522281C 0922281C
138682c: 242901D22421 0A2901D20A24
1cbf400: 0000000000000000 142801D200207047
1cbf408: 0000000000000000 1E2801D201207047
1cbf410: 0000000000000000 282801D202207047
1cbf418: 0000000000000000 322801D203207047
1cbf420: 0000000000000000 3C2801D204207047
1cbf428: 0000000000000000 462801D205207047
1cbf430: 0000000000000000 502801D206207047
1cbf438: 0000000000000000 5A2801D207207047
1cbf440: 0000000000000000 642801D208207047
1cbf448: 00000000000000000000000000000000 0920704708281AD801A1095C8F44C046
1cbf458: 00000000000000000000000000000000 0A0E12161A1E22262A000A2070471420
1cbf468: 00000000000000000000000000000000 70471E20704728207047322070473C20
1cbf478: 0000000000000000000000000000 704746207047502070475A207047
1cbf486: 00000000 64207047

Teraz kopiujemy komentarze z oryginalnego patcha, czyli:

;K770 SW-R8BA024
;Alows to adjust brightness from 10 before 100%
;(c) IronMaster

i wklejamy na samej górze utworzonego patcha.
-Zmieniamy wersję softa i model telefonu (w naszym przypadku tylko wersję softa )
-pod ? robimy nową linijkę, komentujemy ją średnikiem ( ; ), bierzemy "p" w nawias i obok wpisujemy swój nick:

;K770 SW-R8BC0004
;Alows to adjust brightness from 10 before 100%
;(c) IronMaster
;(p) mc_kibel

Efekt :

;K770 SW-R8BC0004
;Alows to adjust brightness from 10 before 100%
;(c) IronMaster
;(p) mc_kibel
; INFO: First patch ported with IDA by me <img src='http://sony.yt/public/style_emoticons/default/smile.png' class='bbc_emoticon' alt=':)' />
+44140000
12d2a2c: 401D0A21 401C0A21
12d3cb8: 262801D200207047312801D2 00B50149884700BD01F4DF45
12d3ce4: 042810D801A1095C8F44C046 00B50149884700BD4DF4DF45
12d3d32: 0522281C 0922281C
138682c: 242901D22421 0A2901D20A24
1cbf400: 0000000000000000 142801D200207047
1cbf408: 0000000000000000 1E2801D201207047
1cbf410: 0000000000000000 282801D202207047
1cbf418: 0000000000000000 322801D203207047
1cbf420: 0000000000000000 3C2801D204207047
1cbf428: 0000000000000000 462801D205207047
1cbf430: 0000000000000000 502801D206207047
1cbf438: 0000000000000000 5A2801D207207047
1cbf440: 0000000000000000 642801D208207047
1cbf448: 00000000000000000000000000000000 0920704708281AD801A1095C8F44C046
1cbf458: 00000000000000000000000000000000 0A0E12161A1E22262A000A2070471420
1cbf468: 00000000000000000000000000000000 70471E20704728207047322070473C20
1cbf478: 0000000000000000000000000000 704746207047502070475A207047
1cbf486: 00000000 64207047

The end

not found: Poprawiłem emoticon, gdyż się nie wyświetlał.

Jest to kontynuacja tematu "Tworzenie skryptów ASM" - trzecia część poradnika dotyczącego zaawansowanego portowania patchy.

1. Pozostało nam przeportowanie adresów zdefiniowanych na początku, czyli:

branch1 equ 0x4506E588
branch2 equ 0x45490F5C
branch3 equ 0x45BFD14C
branch4 equ 0x4507F0F8
hook1 equ 0x4506E578
hook2 equ 0x4507F0EE
icon1 equ 0xED14
patchbody equ 0x45D19464

• Bierzemy na początek pierwszy adres spod branch1, czyli wartość po 0x, jest to 4506E588. Kopiujemy go.
• W IDA klikamy G, wklejamy i klikamy OK.
• Konwertujemy rom do kodu, wciskając "C".
• Kod wygląda tak:
  
  

  ROM:4506E588 18 20	  MOVS	R0, #0x18
  ROM:4506E58A 29 5E	  LDRSH R1, [R5,R0]
  ROM:4506E58C 14 20	  MOVS	R0, #0x14
  ROM:4506E58E 28 5E	  LDRSH R0, [R5,R0]
  ROM:4506E590 17 1C	  ADDS	R7, R2, #0
  ROM:4506E592 3E 4A	  LDR	 R2, dword_4506E68C
  ROM:4506E594 E8 F0 9C F8		BL	  sub_451566D0
  ROM:4506E598 00 20	  MOVS	R0, #0
  ROM:4506E59A 38 5E	  LDRSH R0, [R7,R0]
  ROM:4506E59C 24 21	  MOVS	R1, #0x24
  ROM:4506E59E 69 5E	  LDRSH R1, [R5,R1]
  ROM:4506E5A0 26 22	  MOVS	R2, #0x26
  ROM:4506E5A2 AA 5E	  LDRSH R2, [R5,R2]
  ROM:4506E5A4 46 18	  ADDS	R6, R0, R1
  ROM:4506E5A6 04 21	  MOVS	R1, #4
  ROM:4506E5A8 79 5E	  LDRSH R1, [R7,R1]
  

• Uruchamiamy PatSearchNT. Klikamy load FF i wybieramy MAIN, dla którego chcemy przeportować funkcję, oczywiście w formacie RAW. Ja wybieram K770 r8bc004.
• W PatSearch, w miejscu gdzie widzimy
  
  

  0xA0000000 Sie (SGOLD, NEWSGOLD, ELKA)
  

  wpisujemy bazę naszego telefonu, poprzedzając ją "0x". Ja wybrałem 0x44140000 SE z rozwijanej listy, gdyż taką bazę ma K770 i inne fony z platformy db2020.
• W duże pole tekstowe wklejamy skopiowaną część kodu z IDA i klikamy Convert.
  W polu, w które wklejaliśmy tekst, widzimy teraz:
  

  ??,20
  ??,5E
  ??,20
  ??,5E
  ??,1C
  ??,4A
  ??,??,??,F8
  ??,20
  ??,5E
  ??,21
  ??,5E
  ??,22
  ??,5E
  ??,18
  ??,21
  ??,5E
  

• Teraz wszystkie miejsca, w których mamy ??,??,??,Fx (gdzie zamiast x jest dowolny znak), zamieniamy na ??,??,??,F?
• We wszystkich innych przypadkach, kiedy nie ma tego Fx na końcu, całe ??,??,??,yz (gdzie y to znak inny od F, a z to dowolny inny znak) zamieniamy na ??,??,??,??.
• W efekcie mamy:
  

  	??,20
  	??,5E
  	??,20
  	??,5E
  	??,1C
  	??,4A
  	??,??,??,F?
  	??,20
  	??,5E
  	??,21
  	??,5E
  	??,22
  	??,5E
  	??,18
  	??,21
  	??,5E
  

2. Klikamy SEARCH.

3. Otrzymujemy w prawym okienku prześliczny adresik "4506F268". Więc zamiast 'branch1 equ 0x4506E588' wpisujemy 'branch1 equ 0x4506F268'.

4. To samo robimy z resztą adresów nazwanych jako branch, to samo robimy z adresami hook. Poprawnie przeportowane adresy branch i hook:

branch1 equ 0x4506F268
branch2 equ 0x45492B00
branch3 equ 0x45BFFECC
branch4 equ 0x4507FDD4
hook1 equ 0x4506F258
hook2 equ 0x4507FDCA

5. Weźmy pod uwagę adres 'patchbody'. Zaczniemy od niego, gdyż jest najprościej Cała filozofia polega na znalezieniu w mainie wolnego miejsca - rozpiski miejsc używanych przez inne patche można znaleźć w tematach z patchami na np. mobilefree.ru, wolne miejsca są często pomiędzy nimi. Wolne miejsca w DB2020 są na samym końcu pliku raw, wystarczy więc taki otworzyć w winhexie i przewinąć na sam dół - później dodać bazę telefonu (czyli w tym przypadku 44140000) i mamy wolny adres. Ja sobie upatrzyłem w mainie K770 R8BC004 taki adres do patchbody: 45DFFC20. Więc teraz linijka ta wygląda: patchbody equ 0x45DFFC20.

6. Teraz adres do ikony. Też prosty Otwieramy w DB2020 IMG tool-u main, dla którego jest patch zrobiony. Szukamy ikonki, w tym przypadku ED14. Zapamiętujemy jak ona wygląda xD Otwieramy teraz main telefonu, dla którego chcemy przeportować patcha (czyli k770 r8bc004) w IMG toolu. Szukamy takiej samej ikonki (będzie znajdowała się w pobliżu tego adresu ). W K770 R8BC004 jest to ED16 - więc 0xED14 w pliku zamieniamy na 0xED16.

7. Ok, adresy branch, hook, icon i patchbody zrobione. Wszystkie adresy poprawnie przeportowane:

branch1 equ 0x4506F268
branch2 equ 0x45492B00
branch3 equ 0x45BFFECC
branch4 equ 0x4507FDD4
hook1 equ 0x4506F258
hook2 equ 0x4507FDCA
icon1 equ 0xED16
patchbody equ 0x45DFFC20

8. Przeportowany plik .asm w załączniku.

4. Kompilacja ASM do VKP

Jest to kontynuacja tematu "Otwieranie maina w IDA" - druga część poradnika dotyczącego zaawansowanego portowania patchy.

1. Mając otwarty main, dla którego istnieje patch, musimy go wgrać we właśnie ten firmware w programie IDA - używając skryptów IDC (kierunek: FAQ w dziale developerskim). Osobiście maina spatchuję patchem "Show MegaBass image when Bass EQ is selected", przeznaczonym dla K770i R8BA024. Nie pamiętam już, czy pisałem o tym wcześniej, czy nie - ale jeśli nie pisałem, to zaopatrzcie się w main K770i R8BA024 i K770i R8BC004 oraz ściągnijcie patch z załącznika - przećwiczcie najpierw na tym samym przykładzie, co ja.

2.

• Rozpakowujemy archiwum IDC
• W IDA klikamy File > IDC File.
• Wybieramy plik ApplyPatch.idc.
• W nowym oknie wybieramy plik patcha dla otwartego softa.
• Wyskoczy okienko, w którym klikamy YES.
  - Jeśli wyskoczy więcej okienek, oznacza to mismatch. Przerywamy operację, klikając NO.

Ok, jeśli mismatch nie wyskoczył, to main mamy spatchowany

3. No więc musimy stworzyć skrypt ASM naszego patcha. Jeśli już mamy dzielić patche na jakieś rodzaje, to są dwa: z bazą i bez. Patche z bazą rozpoznajemy po +xxxxxxxx (gdzie zamiast x są dowolne liczby) występującym zaraz po komentarzach w patchu (lub gdy ich nie ma na samym początku). Nasz patch z załącznika posiada bazę - przez co mamy minimalnie więcej roboty - ale ten przykład jest wybrany specjalnie Później z patchami bez bazy poradzicie sobie bez problemu.

4. Otwieramy nasz patch z załącznika. Pierwszy offset to F2E578, a baza patcha +44140000. Więc: Menu start > wszystkie programy > akcesoria > kalkulator > widok > naukowy > zaznaczamy kropkę przy HEX.
Teraz kopiujemy pierwszy offset, dodajemy do niego bazę patcha. Otrzymujemy: 4506E578.
* gdy patch nie ma bazy, to nic nie dodajemy - po prostu kopiujemy offset i tyle

5. W IDA klikamy "G" i wklejamy otrzymane "4506E578". Teraz wciskamy ALT+G, a w polu VALUE (gdzie domyślnie mamy ROM) wpisujemy 1 po czym klikamy enter.

6. No i naciskamy "C"...

7. Widzimy

ROM:4506E578 00 49 LDR  R1, off_4506E57C
ROM:4506E57A 08 47 BX   R1
ROM:4506E57A	 ; ---------------------------------------------------------------------------
ROM:4506E57C 65 94 D1 45 off_4506E57C DCD loc_45D19464+1		; DATA XREF: ROM:4506E578r

8. Trzeba będzie więc wpisać to w ASM. Ok, teraz krótka i tania lekcja podrywu o tajemniczej nazwie "Po czym poznać ile tego 'czegoś' trzeba wpisać w plik ASM?" Krótko mówiąc...
Początek patcha:

+44140000
F2E578: F1B5041C051C1430 004908476594D145

Interesują nas tylko nowe wartości, czyli: 004908476594D145 (jeśli nie wiesz skąd to wziąłem, to cofnij się stronkę wcześniej i zerknij w temacik 'Struktura pliku VKP'). Dobra, liczymy ile to znaków 1,2,3..... o, 16 ! Dzielimy na dwa i mamy 8
Pozwolicię, że pokażę screen z IDA. Podzielmy sobie to na poszczególne kolumny.


No więc... jest 8 wartości (czyli tyle, ile sobie policzyliśmy, że jest w patchu) ? Odpowiem za was - jest Gdy IDA do kodu skonwertuje mniej (Offsety skonwertowane do kodu są bordowe, czarne lub szare, nieskonwertowane - żółte. To ważne! ) to schodzimy na następny żółty adres i znowu wciskamy "C". Gdy skonwertuje do kodu więcej - nie przejmujemy się i wpisujemy tylko tyle ile potrzeba. U mnie skonwertowała dokładnie tyle, ile nam było potrzebne.

9. Dobra, od tych pięciu minut które wykonujecie punkt ósmy nie zmieniło się nic (no, może wiecie trochę więcej ) - w IDA dalej widzimy to co w punkcie siódmym. Trzeba więc wpisać to do pliku ASM:

• Otwieramy notatnik
• Na samym początku wpisujemy: include "x.inc"

i w końcu jedziemy z tym skryptem
Po dodaniu bazy do pierwszego offseta (punkt 4) otrzymaliśmy ten adres: 4506E578. Trzeba więc zdefiniować go w pliku.

• Pod include "x.inc" wpisujemy: hook1 equ 0x4506E578
• hook1 jest tutaj nazwą (której będziemy używać dalej), equ znaczy tyle co 'jest równe', a 0x4506E578 to nasz otrzymany adres, poprzedzony kombinacją '0x'.

Teraz, w adresie 'hook1' będziemy wpisywać instrukcje z trzeciej kolumny na screenie, czyli poniżej hook1 equ.... dodajemy:

org hook1
LDR	R1, off_4506E57C
BX	 R1
off_4506E57C	DCD loc_45D19464+1

org hook1 oznacza, że instrukcje występują właśnie pod adresem zdefiniowanym jako 'hook1'. Cała reszta niżej to instrukcje.
Widzimy tam jakieś off_ , jakieś loc_ , które już pewnie zdążyło was zmylić - to, że występują tam cyferki, nic nie znaczy. 'Adresy' (a właściwie nie adresy, bardziej ciągi znaków) poprzedzone takimi rzeczami jak loc_ , sub_ , locret_ , off_ , dword_ , pełnią rolę TYLKO I WYŁĄCZNIE NAZW!. Nie portujemy ich - to są nazwy, które będą używane później w skrypcie.

10. To samo robimy z drugim offsetem - dam wam pole do popisu i nie będę tłumaczył jeszcze raz tego samego co w punkcie 9. Powiem tylko, że nowy adres należy zdefiniować zaraz pod hook1 equ 0x.... , jako np. hook2.

11. Tak więc powiem rzeczy oczywiste, które wynikły w punkcie dziesiątym. Otrzymaliśmy adres '4507F0EE', który zdefiniowaliśmy w ten sposób: hook2 equ 0x4507F0EE i do ASM dodaliśmy:

org hook2
LDR	R2, off_4507F0F4
BX	 R2
DCB 0xFF
DCB 0xFF
off_4507F0F4	DCD loc_45D194AC+1

Nasz ASM wygląda tak:

include "x.inc"
hook1 equ 0x4506E578
hook2 equ 0x4507F0EE
org hook1
LDR	R1, off_4506E57C
BX	 R1
off_4506E57C	DCD loc_45D19464+1
org hook2
LDR	R2, off_4507F0F4
BX	 R2
DCB 0xFF
DCB 0xFF
off_4507F0F4	DCD loc_45D194AC+1

Czyli już jakoś zaczyna wyglądać Adresy podmieniające oryginalne funkcje w mainie mamy porobione, teraz trzeba zająć się 'patchbody', czyli adresami wykorzystującymi wolne miejsca. W tym patchu zaczynają się one w trzecim offsecie. Bierzemy go, dodajemy do niego bazę i otrzymujemy 45D19464. Definiujemy ten adres jako patchbody, czyli: patchbody equ 0x45D19464.

12. W IDA klikamy "G" i wklejamy adres patchbody (powtórzę się: 45D19464). Jeśli widzimy, że offsety nie są skonwertowane do kodu, wciskamy C. Zjeżdżamy niżej. Jeśli obok któregoś ROMu (i romów niżej) są wartości różne od zera (np. F0 B5 itd) i widzimy, że są one nieskonwertowane do kodu, to klikamy C, znowu. Zjeżdżamy znowu niżej i jeśli znowu zobaczymy jakieś różne wartości przy ROMach nieskonwertowane do kodu, naciskamy C. I tak do momentu, gdy żółte ROMy pod ostatnim ROMem skonwertowanym do kodu, będą miały obok siebie same zera (to tak na przyszłość tylko - akurat w tym patchu od razu skonwertowało mi całe patchbody, więc "C" nacisnąłem tylko na początku adresu 'patchbody').

13. W szczęśliwym punkcie trzynastym jeszcze raz wciskamy "G" i wklepujemy adres zdefiniowany jako 'patchbody'.
Od samego początku zaznaczamy myszką obszar patchbody: od 45D19464 do ostatniego romu skonwertowanego do kodu (w tym przypadku jest taki pod adresem: 45D194C8).

14. Wciskamy ALT+F10 i sobie gdzieś zapisujemy ten plik Otwieramy go, ściągamy program 'ASM Cleaner' z załącznika. Odpalamy go, wklejamy tam całą zawartość pliku asm i wciskamy cleanup. Zaznaczamy wszystko z programu, kopiujemy i wklejamy w plik, który zapisała IDA. Usuwamy jednak linijkę 'include "x.inc"' na początku - gdyż mamy ją w naszym skrypcie. Zapisujemy plik.

15. Powracamy do naszego pliku (przez 'naszego' mam na myśli ten, do którego wpisywaliśmy kod ręcznie). Dodajemy tam org patchbody i wklejamy pod to całą zawartość pliku, który oczyścił nam ASM Cleaner.
Zaczyna się tak:

org patchbody
loc_45D19464		  
					  
PUSH {R0,R4-R7,LR}
ADD R4, R0, 0
ADD R5, R4, 0

po loc_xxxxxxxx musimy dać dwukropek. Ale dodajemy je TYLKO WTEDY, gdy ten loc_xxxxxxxx (lub sub_xxxxxxxx lub locret_xxxxxxxx) są wyrównane skrajnie do lewej strony. Nie robimy tego z adresami off_xxxxxxxx ani dword_xxxxxxxx.

16. Jednak przy linijkach zaczynających się od off_xxxxxxxx mamy zawsze coś w tym stylu:
off_xxxxxxxx dw loc_yyyyyyyy+1

Gdy te linijki występują pod adresem 'patchbody', to tutaj akurat musimy zamienić te loc_ na 0x, w efekcie mamy:
off_xxxxxxxx dw 0x........+1

17. Przeglądając skrypt od 'patchbody' w dół, widzimy więc kilka takich miejsc, zacznijmy od tego:
off_45D19494 dw loc_4506E588+1

i według tego co napisałem otrzymujemy:
off_45D19494 dw 0x4506E588+1

Polecam zaznaczyć te 0x4506E588 i wyciąć. Po wycięciu od razu w tym miejscu piszemy np. branch1, dzięki czemu mamy:
off_45D19494 dw branch1+1

Adres, który wycięliśmy, jest teraz w schowku, przesuwamy więc na początek naszego pliku ASM i przed hook1 dajemy:
branch1 equ 0x4506E588

18. To samo robimy z następnymi takimi miejscami. Mamy tam off_xxxxxxxx dw sub_...... oraz ~dw unk_ - w każdym przypadku robimy tak samo - zamieniamy tutaj te ciągi znakami 0x i kopiujemy je, definiując na początku.

19. Jest też taki fragment, trochę niżej niż w połowie patchbody:
dword_45D194A8 dw 0xED14

Wiemy, że patch ma wyświetlić obrazek w jednym miejscu - w korektorze, przy ustawieniu "basy". 0xED14 to kod hex ikonki w mainie (o tym później). Zamienimy więc tutaj 0xED14 na icon1, definiując te icon1 na początku.

20. Dwadzieścia króciutkich punktów zaawansowanego, ale krótkiego patcha, zawierającego chyba wszystkie przykłady, z jakimi spotkacie się przy portowaniu trudniejszych patchy.
Należy jeszcze usunąć patcha z software w IDA:

• W IDA klikamy File > IDC File.
• Wybieramy plik UndoPatch.idc.
• W nowym oknie wybieramy plik patcha, którego wgrywaliśmy.
• Wyskoczy okienko, w którym klikamy YES.

Gotowy skrypt ASM dla K770 R8BA024 dla patcha "Show mega bass image when Bass EQ is selected" wygląda tak:

include "x.inc"
branch1 equ 0x4506E588
branch2 equ 0x45490F5C
branch3 equ 0x45BFD14C
branch4 equ 0x4507F0F8
hook1 equ 0x4506E578
hook2 equ 0x4507F0EE
icon1 equ 0xED14
patchbody equ 0x45D19464
org hook1
LDR	R1, off_4506E57C
BX	 R1
off_4506E57C	DCD loc_45D19464+1
org hook2
LDR	R2, off_4507F0F4
BX	 R2
DCB 0xFF
DCB 0xFF
off_4507F0F4	DCD loc_45D194AC+1
org patchbody
loc_45D19464:  
					  
PUSH {R0,R4-R7,LR}
ADD R4, R0, 0
ADD R5, R4, 0
ADD R5, 0xB4
ADD R7, R2, 0
ADD R0, 0x14
LDR R3, dword_45D194C4
LDRB R1, [R3]
CMP R1, 1
LDR R1, [R0,4]
PUSH {R1}
LDR R3, [R0]
BNE loc_45D19490
LDR R2, dword_45D194A8
MOV R0, 0x18
LDRSH R1, [R5,R0]
MOV R0, 0x14
LDRSH R0, [R5,R0]
BL sub_45D19498
ADD SP, SP, 4
POP {R3-R7,PC}

loc_45D19490:		  
LDR R3, off_45D19494
BX R3
off_45D19494 dw branch1+1


sub_45D19498:		  
PUSH {R3}
LDR R3, off_45D194A4
MOV R12, R3
POP {R3}
BX R12

align 4
off_45D194A4 dw branch2+1
dword_45D194A8 dw icon1

loc_45D194AC:		  
					  
LDR R2, off_45D194C0
LDR R4, dword_45D194C4
STRB R3, [R4]
MOV R4, 5
MUL R3, R4
LDRSB R3, [R2,R3]
STRB R3, [R1]
LDR R3, off_45D194C8
BX R3
align 4
off_45D194C0 dw branch3
dword_45D194C4 dw 0x200A68B0
					  
off_45D194C8 dw branch4+1

ASM mamy zrobiony - pora na portowanie adresów - przejdźmy do trzeciej części poradnika.

3. Portowanie adresów w ASM

Każdy skrypt ASM tutaj zamieszczony jest wygenerowany / przeportowany przeze mnie.
Zachęcam do wrzucania tutaj skryptów ASM, które wygenerujecie


Tutaj wrzucamy tylko skrypty ASM. Pytania na temat problemów z portowaniem zadajemy w temacie
http://sony.yt/index...owaniem-patchy/

Zmiana pozycji "Play" i "Record new" w rejestratorze dźwięku - Adresy dla W850i R1KG001:

include "x.inc"
hook1 equ 0x4507E4E0
branch1 equ 0x4507E5A4
branch2 equ 0x4507E5A8
branch3 equ 0x4507EADC
branch4 equ 0x4507E598
branch5 equ 0x4507E59C
org hook1
				LDR	 R3, branch1
				LDR	 R2, branch2
				MOV	 R0, 1
				PUSH	{R0}
				LDR	 R0, [R5]
				BL	  branch3
				LDR	 R3, branch4
				LDR	 R2, branch5
				MOV	 R0, 1
				NOP

Podświetlenie od 10 do 100% - adresy dla K770 R8BC004:

include "x.inc"
hook1 equ 0x45412A2C
hook2 equ 0x45413CB8
hook3 equ 0x45413CE4
hook4 equ 0x45413D32
hook5 equ 0x454C682C
branch1 equ 0x45413CEC
branch2 equ 0x454C6834
branch3 equ 0x45413CC0
patch equ 0x45DFF400
patch2 = patch+0x08
patch3 = patch+0x10
patch4 = patch+0x18
patch5 = patch+0x20
patch6 = patch+0x28
patch7 = patch+0x30
patch8 = patch+0x38
patch9 = patch+0x40
patch10 = patch+0x48
patch11 = patch+0x58
patch12 = patch+0x86
patch13 = patch+0x4D
org hook1
				ADD	 R0, R0, 1
				MOV	 R1, 0xA
org hook2
				PUSH	{LR}
				LDR	 R1, branch3
				BLX	 R1
				POP	 {PC}
				DCD	 patch+1
org hook3
				PUSH	{LR}
				LDR	 R1, branch1
				BLX	 R1
				POP	 {PC}
				DCD	 patch13
org hook4
				MOV	 R2, 9
				ADD	 R0, R5, 0
org hook5
				CMP	 R1, 0xA
				BCS	 branch2
				MOV	 R4, 0xA
org patch
				CMP	 R0, 0x14
				BCS	 patch2
				MOV	 R0, 0
				BX	  LR
org patch2							
				CMP	 R0, 0x1E
				BCS	 patch3
				MOV	 R0, 1
				BX	  LR
org patch3
				CMP	 R0, 0x28
				BCS	 patch4
				MOV	 R0, 2
				BX	  LR
org patch4
				CMP	 R0, 0x32
				BCS	 patch5
				MOV	 R0, 3
				BX	  LR
org patch5
				CMP	 R0, 0x3C
				BCS	 patch6
				MOV	 R0, 4
				BX	  LR
org patch6
				CMP	 R0, 0x46
				BCS	 patch7
				MOV	 R0, 5
				BX	  LR
org patch7
				CMP	 R0, 0x50
				BCS	 patch8
				MOV	 R0, 6
				BX	  LR
org patch8
				CMP	 R0, 0x5A
				BCS	 patch9
				MOV	 R0, 7
				BX	  LR
org patch9
				CMP	 R0, 0x64
				BCS	 patch10
				MOV	 R0, 8
				BX	  LR
org patch10
				MOV	 R0, 9
				BX	  LR
				CMP	 R0, 8
				BHI	 patch12
				adr	 R1, patch11
				LDRB	R1, [R1,R0]
				ADD	 PC, R1
				NOP
org patch11
				LSR	 R2, R1, 0x18
				ASR	 R2, R2, 0x18
				SUB	 R2, R3, 0
				MOV	 R6, 0x22
				LSL	 R2, R5, 0
				MOV	 R0, 0xA
				BX	  LR
				MOV	 R0, 0x14
				BX	  LR
				MOV	 R0, 0x1E
				BX	  LR
				MOV	 R0, 0x28
				BX	  LR
				MOV	 R0, 0x32
				BX	  LR
				MOV	 R0, 0x3C
				BX	  LR
				MOV	 R0, 0x46
				BX	  LR
				MOV	 R0, 0x50
				BX	  LR
				MOV	 R0, 0x5A
				BX	  LR
org patch12
				MOV	 R0, 0x64
				BX	  LR

Podświetlenie od 10 do 100% - adresy dla K770 R8BA024:

include "x.inc"
hook1 equ 0x45410E7C
hook2 equ 0x45412110
hook3 equ 0x4541213C
hook4 equ 0x4541218A
hook5 equ 0x454C4C78
branch1 equ 0x45412144
branch2 equ 0x454C4C80
branch3 equ 0x45412118
patch equ 0x45D17940
patch2 = patch+0x08
patch3 = patch+0x10
patch4 = patch+0x18
patch5 = patch+0x20
patch6 = patch+0x28
patch7 = patch+0x30
patch8 = patch+0x38
patch9 = patch+0x40
patch10 = patch+0x48
patch11 = patch+0x58
patch12 = patch+0x86
patch13 = patch+0x4D
org hook1
				ADD	 R0, R0, 1
				MOV	 R1, 0xA
org hook2
				PUSH	{LR}
				LDR	 R1, branch3
				BLX	 R1
				POP	 {PC}
				DCD	 patch+1
org hook3
				PUSH	{LR}
				LDR	 R1, branch1
				BLX	 R1
				POP	 {PC}
				DCD	 patch13
org hook4
				MOV	 R2, 9
				ADD	 R0, R5, 0
org hook5
				CMP	 R1, 0xA
				BCS	 branch2
				MOV	 R4, 0xA
org patch
				CMP	 R0, 0x14
				BCS	 patch2
				MOV	 R0, 0
				BX	  LR
org patch2							
				CMP	 R0, 0x1E
				BCS	 patch3
				MOV	 R0, 1
				BX	  LR
org patch3
				CMP	 R0, 0x28
				BCS	 patch4
				MOV	 R0, 2
				BX	  LR
org patch4
				CMP	 R0, 0x32
				BCS	 patch5
				MOV	 R0, 3
				BX	  LR
org patch5
				CMP	 R0, 0x3C
				BCS	 patch6
				MOV	 R0, 4
				BX	  LR
org patch6
				CMP	 R0, 0x46
				BCS	 patch7
				MOV	 R0, 5
				BX	  LR
org patch7
				CMP	 R0, 0x50
				BCS	 patch8
				MOV	 R0, 6
				BX	  LR
org patch8
				CMP	 R0, 0x5A
				BCS	 patch9
				MOV	 R0, 7
				BX	  LR
org patch9
				CMP	 R0, 0x64
				BCS	 patch10
				MOV	 R0, 8
				BX	  LR
org patch10
				MOV	 R0, 9
				BX	  LR
				CMP	 R0, 8
				BHI	 patch12
				adr	 R1, patch11
				LDRB	R1, [R1,R0]
				ADD	 PC, R1
				NOP
org patch11
				LSR	 R2, R1, 0x18
				ASR	 R2, R2, 0x18
				SUB	 R2, R3, 0
				MOV	 R6, 0x22
				LSL	 R2, R5, 0
				MOV	 R0, 0xA
				BX	  LR
				MOV	 R0, 0x14
				BX	  LR
				MOV	 R0, 0x1E
				BX	  LR
				MOV	 R0, 0x28
				BX	  LR
				MOV	 R0, 0x32
				BX	  LR
				MOV	 R0, 0x3C
				BX	  LR
				MOV	 R0, 0x46
				BX	  LR
				MOV	 R0, 0x50
				BX	  LR
				MOV	 R0, 0x5A
				BX	  LR
org patch12
				MOV	 R0, 0x64
				BX	  LR

Zmiana koloru tła w symbolach w SMS - adresy dla K810i R8BA024:

include "x.inc"
hook1 equ 0x453FF2CC
hook2 equ 0x453FF2D0
patch equ 0x45CB6D90
patch2 equ 0x45CB6D9E
patch3 equ 0x45CB6DA4
patch4 equ 0x45CB6DA8
patch5 equ 0x45CB6DAC
branch1 equ 0x453FF2D6
branch2 equ 0x45466804
color equ 0xFF3A3A3A

org hook1
				LDR	 R1, hook2
				BLX	 R1

org hook2
				DCD	 patch+1
				NOP

org patch
				LDR	 R1, patch5
				ADD	 R0, R4, 0
				BL	  patch2
				LDRB	R0, [R6,0x10]
				LDR	 R3, patch3
				BX	  R3


org patch2
				LDR	 R3, patch4
				BX	  R3
align 4

off_45CB6DA4	DCD branch1+1
off_45CB6DA8	DCD branch2+1
dword_45CB6DAC  DCD color

Zmiana koloru tła w symbolach w SMS - adresy dla K770 R8BC004:

include "x.inc"
hook1 equ 0x4542A900
hook2 equ 0x4542A904
patch equ 0x45D1B650
patch2 equ 0x45D1B65E
patch3 equ 0x45D1B664
patch4 equ 0x45D1B668
patch5 equ 0x45D1B66C
branch1 equ 0x4542A90A
branch2 equ 0x45491DCC
color equ 0xFF3A3A3A

org hook1
				LDR	 R1, hook2
				BLX	 R1

org hook2
				DCD	 patch+1
				NOP

org patch
				LDR	 R1, patch5
				ADD	 R0, R4, 0
				BL	  patch2
				LDRB	R0, [R6,0x10]
				LDR	 R3, patch3
				BX	  R3


org patch2
				LDR	 R3, patch4
				BX	  R3
align 4

off_45D1B664	DCD branch1+1
off_45D1B668	DCD branch2+1
dword_45D1B66C  DCD color

K770 R8BA024 - pokazuje obrazek MegaBass, gdy zaznaczone jest ustawienie Basy:

include "x.inc"
hook1 equ 0x4506E578
hook2 equ 0x4507F0EE
patch1 equ 0x45D19464
patch2 = patch1+0x2C
patch3 = patch2+0x04
patch4 = patch3+0x04
patch5 = patch4+0x0C
patch9 = patch5+0x04
patch11 = patch9+0x04
patch6 = patch11+0x14
patch7 = patch6+0x04
patch8 = patch7+0x04
branch1 equ 0x4506E588
branch2 equ 0x45490F5C
branch3 equ 0x45BFD14C
branch4 equ 0x4507F0F8
branch5 equ 0x4506E57C
branch6 equ 0x4507F0F4
icon equ 0xED14

org hook1
				LDR	 R1, branch5
				BX	  R1
off_4506E57C	DCD	 patch1+1

org hook2
				LDR	 R2, branch6
				BX	  R2
align 4
off_4507F0F4	DCD	 patch11+1

org patch1
				PUSH	{R0,R4-R7,LR}
				ADD	 R4, R0, 0
				ADD	 R5, R4, 0
				ADD	 R5, 0xB4
				ADD	 R7, R2, 0
				ADD	 R0,  0x14
				LDR	 R3, patch7
				LDRB	R1, [R3]
				CMP	 R1,  1
				LDR	 R1, [R0,4]
				PUSH	{R1}
				LDR	 R3, [R0]
				BNE	 patch2
				LDR	 R2, patch9
				MOV	 R0, 0x18
				LDRSH   R1, [R5,R0]
				MOV	 R0, 0x14
				LDRSH   R0, [R5,R0]
				BL	  patch4
				ADD	 SP, SP, 4
				POP	 {R3-R7,PC}
org patch2
				LDR	 R3, patch3
				BX	  R3

off_45D19494	DCD	 branch1+1

org patch4
				PUSH	{R3}
				LDR	 R3, patch5
				MOV	 R12, R3
				POP	 {R3}
				BX	  R12
align 4
off_45D194A4	DCD	 branch2+1
dword_45D194A8  DCD	 icon

				LDR	 R2, patch6
				LDR	 R4, patch7
				STRB	R3, [R4]
				MOV	 R4, 5
				MUL	 R3, R4
				LDRSB   R3, [R2,R3]
				STRB	R3, [R1]
				LDR	 R3, patch8
				BX	  R3
align 4
off_45D194C0	DCD branch3
dword_45D194C4  DCD 0x200A68B0
off_45D194C8	DCD branch4+1

Pewnego dnia byłem chory i znudzony, więc zrobiłem 'małe' narzędzie,
dzięki tej aplikacji możemy zmieniać funkcje klawiszy w SE DB2020 / DB3210.
To tylko BETA, nie wiem czy projekt jest warty kontynuacji.

.NET Framework 2.0 wymagany!

 screentl.png   14.27K   7 downloads

Użycie:
1. UWAGA! Wczytany plik musi być pozbawiony headera -> dla db3210 należy użyć programu cxc2raw mojego autorstwa (jest w tym dziale). W przypadku DB2020 po prostu trzeba użyć main2raw.
2. Klikamy file -> load firmware.
3. Wybieramy stary i nowy klawisz. [Zalecane jest nie używanie klawiszy numerycznych jako 'old key'. To tylko beta, algorytm odnajdywania tych klawiszy musi być poprawiony.]
4. W polu destination platform wybieramy platformę, dla której będziemy generować patch.
5. Wciskamy generate. Program może zawiesić się na minutkę lub dwie. Nie należy się tym przejmować, gdyż program cały czas pracuje.
6. Po wszystkim klikamy file -> save .vkp.

Miłej zabawy

Pobierz:  SE KeyReplacer.rar   23.17K   5 downloads