Sponsored Links

Sponsored Links

Page 1 of 2 12 LastLast
Results 1 to 10 of 16



  1. #1
    Forum Moderator PS3 News's Avatar
    Join Date
    Apr 2005
    Posts
    27,811
    Sponsored Links

    NetCheat for PS3 v2.0 by Veritassdg Arrives for DEX Consoles

    Sponsored Links
    Today PlayStation 3 homebrew developer Dnawrkshp shared his creation released through veritassdg (aka Renton) dubbed NetCheat PS3 v2.0 for PlayStation 3 DEX consoles with details below.

    Download: [Register or Login to view links]

    To quote: Today I bring to you NetCheat for PS3.

    NetCheat PS3
    Written in C# by Dnawrkshp
    #Idea from Veritassdg

    Requirements:
    • DEX PS3
    • ProDG Target Manger and Debugger

    Find the ps3tmapi_net.dll somewhere on the web, or move it from Program Files\SN Systems\PS3\bin (if you installed the PRoDG Debugger), and put it in the same directory as NetCheat PS3.

    Whats New?

    Added Range where you set the debugger range you want to scan. Double click on the range to edit it or hit add to make a new one. you can also save them into a .ncm (net cheat memory) which can be loaded every time you restart NetCheat. An .ncm file would look like this.

    It goes Start address. end address. So far I have not found any bugs but if you do please post in the thread. The RAR/ZIP will come with everything you need to know to get started *not the ps3tmapi_net.dll* Also Codes are in the format of:

    2 12345678 9ABCDEF0
    2 = code type 12345678 = debugger address (most end in 0,4,8,C)
    9ABCDEF0 is what you want written to that debugger address

    There are many code types but I won't explain them here. There's a Read Me that has them all. Enjoy. Source will come at another time.

    This download comes with its own Read me to help you understand how it works. And JokerThat for PS3 all you do it input your code along with the joker address at the top and it'll make a joker code for you (comes with Read me).

    Credits Go to:
    • Dnawrkshp
    • Veritassdg/Renton
    • And iMCSx for his thread on the PS3 debugger API located here (nextgenupdate.com/forums/ps3-cheats-customization/634548-release-development-application-ps3tmapi_net-dll-c-c-vbulletin-net.html) note this takes you to another forum.

    Any ideas feel free to post or pm me too. If you see this released on another forum under the user name Renton its me.

    NetCheat for PS3 v2.0 by Veritassdg Arrives for DEX Consoles

    NetCheat for PS3 v2.0 by Veritassdg Arrives for DEX Consoles

    NetCheat for PS3 v2.0 by Veritassdg Arrives for DEX Consoles

    More PlayStation 3 News...
    Attached Thumbnails<br><br> Attached Thumbnails

    ss (2013-08-23 at 04.59.59).png   ss (2013-08-23 at 05.00.21).png   ss (2013-08-23 at 05.00.38).png   ss (2013-08-23 at 05.00.53).png   ss (2013-08-23 at 05.01.41).png   ss (2013-08-23 at 05.05.40).png  

    ss (2013-08-23 at 05.32.34).png  

  2. #2
    Registered User iMCSx's Avatar
    Join Date
    Oct 2012
    Posts
    2
    Sponsored Links
    Sponsored Links
    Cool, you could also use my PS3Lib v3 , i added a function for load automatically the ps3tmapi_net.dll , it's helpful.

  3. #3
    Registered User veritassdg's Avatar
    Join Date
    Jul 2013
    Posts
    5
    Sponsored Links
    Sponsored Links
    I'm not sure how i feel about the watermarks on the OP... also this wasn't by me it was by Dnawrkshp. i just released it.

  4. #4
    Forum Moderator PS3 News's Avatar
    Join Date
    Apr 2005
    Posts
    27,811
    Unfortunately they are necessary on all news articles as countless sites lift and hotlink the images we host here. I will add Dnawrkshp to the main post now though.

  5. #5
    Senior Member dyceast's Avatar
    Join Date
    Oct 2006
    Posts
    313
    Why is Target Manager needed? Can this be used to RTE? Or mainly editing eboot.elf files?

  6. #6
    Registered User veritassdg's Avatar
    Join Date
    Jul 2013
    Posts
    5
    target manager is needed to connect to the ps3

    its for REAL TIME EDIT not editing the eboot. but you do need a DEBUG eboot in the game for it to attach process

  7. #7
    Forum Moderator PS3 News's Avatar
    Join Date
    Apr 2005
    Posts
    27,811

    NetCheat for PS3 v3.0 by Dnawrkshp Arrives for DEX Consoles

    Following up on the previous version, today PlayStation 3 homebrew developer Dnawrkshp has updated NetCheat for PS3 DEX Consoles to version 3.0 with the changes outlined below.

    Download: [Register or Login to view links] / [Register or Login to view links] / [Register or Login to view links]

    To quote: NetCheat PS3 is a DEX Real Time Editing tool that takes advantage of the ps3tmapi_net.dll that comes with the PRoDG Debugger. This doesn't come with that dll, so you have to get it yourself and place it in the same directory as NetCheat. NC supports codes (similar to RAW PS2 codes), searching, dumping, memory ranges, and user made plugins. Here is a list of the new stuff since the last release:
    • Faster results list refreshing
    • Multiple searching bug fixes
    • Faster dumping
    • Keybinding
    • Theme selection
    • Custom plugins
    • Search stopping (keeps the results in the results list and allows Next Scan)
    • Deleting results

    Plugins:

    Plugins are just User Controls compiled into a dll that NetCheat puts on a form and utilizes. It has the ability to read from, write to, and constantly write to the memory. It also has a few functions that may be useful for certain situations.

    Creating a plugin is fairly easy. Since this is messy and no one likes text tutorials, I will make a video soon. You should also look at the Kingdom Hearts 1.5 plugin for help.
    • Create a new Class Library in VS 2008+.
    • Set the .NET framework to 3.5.
    • Add a reference to PluginInterface.dll and import the Plugin.cs from the Plugin Default directory.
    • Modify the Plugin.cs accordingly and then add a User Control.
    • Call the User Control ctlMain and in it add the following declaration "public static IPluginHost NCInterface = null;".
    • Then at the top of ctlMain, add the following namespace: "using PluginInterface;".
    • Make sure that the namespace in Plugin.cs matches the namespace of ctlMain.
    • Otherwise they won't be able to interact.
    • From there you can just make a GUI and such just like a windows form.
    • Be sure to change the output directory to NetCheat PS3's plugins folder!
    • Also, every time you build the plugin.dll you must close NetCheat.

    Memory Ranges:

    Each game uses different regions of the memory so, for full optimization, it is best to document these regions. As far as I know the only way to do this is to go through the memory in the Debugger and find the regions with a ton of 0xD's.

    Pad format (jokers):

    JokerThat PS3 outputs only one way: ab00cd. Some games have different formats, and others a different order. For now, if your game has its pad format something like 00abcd, then you will have to change the order yourself. Sorry.
    • The format and codetypes are better explained in the Code types.txt.
    • In fact I'm not going to explain it at all since you can just read that text file.
    • Keep in mind jokers have to be constantly written to work.

    Searching:
    • Searching (scanning) has the ability to store all the results in a listview so that you can search again (Next Scan) through those results for an updated value. You can then delete, refresh, and copy those results.
    • NetCheat PS3 also supports dumping. Unlike the debugger, you can dump outside of the game's memory without error.

    Refreshing:

    There are two ways that you can refresh the results. One is to refresh each item by getting the values from the PS3. The other is to update the values by getting them from the dump.txt. For the most part you will only need to refresh the results from the PS3 (hence the big button to refresh from the PS3). The only use I know of for the refresh from dump.txt is the following trick:
    • Say you want to save your search results so that you can return to looking for that value you want to find later.
    • What you'd do is copy the dump.txt file in the directory of NetCheatPS3.exe and rename it to something more descriptive.
    • When you want to load it back up you'd open NetCheat and then copy the saved file back to the directory of NetCheat.
    • Rename it to dump.txt and go back to NC PS3.
    • From there you would click on the results listview and press Ctrl-R.
    • That will load the dump into the listview and all will be well.
    • NOTE: NetCheat deletes the dump.txt when it closes so save it before you close the tool.

    Scan comparison types:
    • Equal
    • Not Equal
    • Less Than
    • Less Than Or Equal
    • Greater Than
    • Greater Than Or Equal
    • Value Between -- Next Scan Only --
    • Increased By
    • Decreased By

    Scan value types:
    • 1 byte
    • 2 bytes
    • 4 bytes
    • 8 bytes
    • Text (String)

    If you want to search for a value greater than 8 bytes, you can just convert the value to a string and search for that.

    Credits:
    • Written by Dnawrkshp
    • Concept by Veritassdg / Renton
    • Help from Badger41




    NetCheat for PS3 v3.0 by Dnawrkshp Arrives for DEX Consoles

    More PlayStation 3 News...
    Attached Thumbnails<br><br> Attached Thumbnails

    ss (2013-09-09 at 07.37.13).png   ss (2013-09-09 at 07.37.26).png   ss (2013-09-09 at 07.37.37).png   ss (2013-09-09 at 07.37.52).png   ss (2013-09-09 at 07.38.14).png   ss (2013-09-09 at 07.38.47).png  

    ss (2013-09-09 at 07.38.57).png   ss (2013-09-09 at 07.39.16).png   ss (2013-09-09 at 07.40.26).png  

  8. #8
    Forum Moderator PS3 News's Avatar
    Join Date
    Apr 2005
    Posts
    27,811

    NetCheat for PS3 v4.0 by Dnawrkshp Arrives for DEX Consoles

    Following up on the previous version, today PlayStation 3 homebrew developer Dnawrkshp has updated NetCheat for PS3 DEX Consoles to version 4.0 followed by v4.1, v4.23, v4.30 and v4.31 with the changes outlined below.

    Download: [Register or Login to view links] / [Register or Login to view links] / [Register or Login to view links] / [Register or Login to view links] / [Register or Login to view links] / [Register or Login to view links] / [Register or Login to view links] / [Register or Login to view links] (Mirror) / [Register or Login to view links] (NetCheat DLLs for CEX - GT6 and Legos Marvels) by flynhigh09 / [Register or Login to view links] (4.33 by Dnawrkshp [CEX/DEX]) via kristijan1001 / [Register or Login to view links] (Latest) / [Register or Login to view links] / [Register or Login to view links]

    To quote: NetCheat PS3 is a DEX Real Time Editing tool that takes advantage of the ps3tmapi_net.dll that comes with the PRoDG Debugger. This doesn’t come with that dll, so you have to get it yourself and place it in the same directory as NetCheat.

    NC supports codes (similar to RAW PS2 codes), searching, dumping, memory ranges, and user made plugins. Here is a list of the new stuff since the last release:

    NOTE: All plugins must be updated to use the new PluginInterface.dll otherwise NetCheat will fail to load them.

    Implementations:
    • Colored status button for connection state
    • Load and Store search results
    • Search for X byte alignment (where X is and positive integer)
    • Search for changed value and unchanged value
    • Recent memory ranges menu
    • A few new plugin features
    • Plugin icons

    Bug fixes:
    • Faster searching
    • Fixed color bug in codes tab
    • Fixed cheat file having a bunch of extra ‘/n’
    • Fixed labels in codes beginning with “//” disappearing

    Plugins:

    Plugins are just User Controls compiled into a dll that NetCheat puts on a form and utilizes. It has the ability to read from, write to, and constantly write to the memory. It also has a few functions that may be useful for certain situations.

    Creating a plugin is fairly easy and here is a video I made to help:




    You should also look at the Kingdom Hearts 1.5 plugin for help (now added in .rar as of v4).

    Memory Ranges:

    Each game uses different regions of the memory so, for full optimization, it is best to document these regions. As far as I know the only way to do this is to go through the memory in the Debugger and find the regions with a ton of 0xD’s.

    Pad format (jokers):

    JokerThat PS3 outputs only one way: ab00cd. Some games have different formats, and others a different order. For now, if your game has its pad format something like 00abcd, then you will have to change the order yourself. Sorry.

    Codes:

    The format and codetypes are better explained in the Code types.txt. In fact I’m not going to explain it at all since you can just read that text file. Keep in mind jokers have to be constantly written to work.

    Searching:

    Searching (scanning) has the ability to store all the results in a listview so that you can search again (Next Scan) through those results for an updated value. You can then delete, refresh, and copy those results.

    NetCheat PS3 also supports dumping. Unlike the debugger, you can dump outside of the game’s memory without error.

    If you want to search for something and the number of results slows the search down exponentially, then you can use CompDump and dumps to find differences. Then with the outputted results from CompDump you can convert and load it into NC’s search results list view by using the Conversion plugin. In the plugin there is an empty text box at the bottom with a browse button next to it.

    Direct the file browser to the outputted CompDump results (leave the dump.txt below the same unless you want to load it up via the Load Scan Results button) and click Start. Once it is done, go to the search tab, click on the search results list view, and press Ctrl-R to load them into the list view and you are good to go.

    This allows the initial scanning of 0 without displaying 10 billion results (good for timers).

    Refreshing:

    There are two ways that you can refresh the results. One is to refresh each item by getting the values from the PS3. The other is to update the values by getting them from the dump.txt. For the most part you will only need to refresh the results from the PS3 (hence the big button to refresh from the PS3). The only use I know of for the refresh from dump.txt is for the CompDump search result import.

    Scan comparison types:

    Equal
    Not Equal
    Less Than
    Less Than Or Equal
    Greater Than
    Greater Than Or Equal
    Value Between
    – Next Scan Only –
    Increased By
    Decreased By
    Changed Value
    Unchanged Value

    Scan value types:

    1 byte
    2 bytes
    4 bytes
    8 bytes
    X bytes
    Text (String)

    Credits:

    Written by Dnawrkshp
    Concept by Veritassdg / Renton
    Help from Badger41

    Update: Badger41 also released a Grand Theft Auto Online - Garage Editor Plugin with details below, as follows:

    This GTA: O modding tool is designed as a plugin used with the popular tool NetCheat - By Dnarkshp.This is just an early version I decided to push out, more features will come as I develop this plugin more.

    Features:
    • Scanning for the online garage and populating a list with names of associated vehicles.
    • Changing the vehicle type for selected garage slot.
    • Changing the 3 paint types in any way desired.
    • Changing the wheel category and type accordingly
    • Changing of wheel color
    • Fully customizable tire smoke, any RGB color
    • Fully customizable license plate
    • Simple on/off toggles for Custom Tires, Bulletproof Tires, Turbo, and Xenon Lights
    • Region selecting

    Known Issues/Bugs
    • Changing wheel color messes up the car's paint - Not sure why this happens, nothing with the car's paint is being edited
    • Incomplete paint color list - I need some help documenting the colors, feel free to contribute

    Be sure to report all issues/bugs to me so I can work at fixing them!

    Change Log:

    1.0.0 - Initial Release - October 24th, 2013 - Time to collect information!

    Credits:
    • Tusin (NGU)
    • Dnawrkshp
    • Veritassdg

    NOTE: All plugins must be updated to use the new PluginInterface.dll otherwise NetCheat will fail to load them.

    Version 4.1:
    • Fixed X byte searching only allowing up to 8 bytes
    • Fixed 1 byte searching
    • Fixed 2 byte searching
    • Fixed Value Between

    Implementations:
    • Colored status button for connection state
    • Load and Store search results
    • Search for X byte alignment (where X is a positive integer)
    • Search for changed value and unchanged value
    • Recent memory ranges menu
    • A few new plugin features
    • Plugin icons

    Bug fixes:
    • Faster searching
    • Fixed color bug in codes tab
    • Fixed cheat file having a bunch of extra '/n'
    • Fixed labels in codes beginning with "//" disappearing

    Update #2: Updated to version 4.23. The ones between 4.1 and 4.23 were private updates.

    I've added the ability to check for new NetCheat updates on start-up and manually at will. This should hopefully be more convenient for everyone. Thanks to my friend ORCXodus for letting me host the update files on his site (cod-orc.com). I've also added a function to find the memory regions automatically. Keep in mind everything in the C0000000 region should not be touched and everything in the D0000000 region (stack) should not be touched either.

    All of the updates from version 4.1 to version 4.23:
    • Fixed 1, 2, and 8 byte decimal scanning
    • Fixed Value Between decimal scanning
    • Added changelog to update
    • Added Find Ranges in the Ranges tab
    • Fixed Update bug
    • Fixed Greater, Greater + Equal, Less, Less + Equal, and Value Between scanning
    • Added Pause and Continue Game in the status drop down
    • Added Update ability

    Update #3: Updated to 4.30. If you already have NetCheat, you can just boot it up and it will ask if you'd like to update. Among other things, CCAPI support has been added through PS3Lib.

    NetCheat is now version 4.31:
    • Added PowerOff function to PS3Lib
    • Fixed range list bug (shows extra ncm)
    • Fixed importing multiple codes coloring bug
    • Lowered PS3Lib to .NET v4.0 for WinXP support

    Decided to downgrade everything to .NET 3.5 (which was what NetCheat used to be on). The only issue is that CCAPI is on a newer version. When Enstone is available I will ask for a version specially made for NetCheat and hope that will fix the rest of the bugs that people are encountering... Sorry for the messed up updates.

    Okay there is a new update available that will hopefully work for everyone. Here you go: [Register or Login to view links]

    Finally, from kristijan1001: Here is a net cheat for cex I didn't made this! credits to the one he made it. I saw this on nextgen update which was made private for elite members only probably so though I share it I am not elite there but I sneak it out I wasn't able to find this anywhere else I searched with no result.

    This is actually netcheat v.4.33 by dnawrkshp, as you go in to the options menu you will see ccapi and ps3tmapi so you can chose between dex and cex (including gta v garage editor).

    NetCheat Grand Theft Auto Online - Garage Editor Plugin by badger41

    This GTA: Online modding tool is designed as a plugin used with the popular tool NetCheat - By Dnawrkshp. This is just an early version I decided to push out, more features will come as I develop this plugin more.

    Features:
    • Scanning for the online garage and populating a list with names of associated vehicles.
    • Changing the vehicle type for selected garage slot.
    • Changing the 3 paint types in any way desired.
    • Changing the wheel category and type accordingly
    • Changing of wheel color
    • Changing of Drivetrain upgrades - Engine, Transmission, Suspension, and Brakes
    • Changing of armor upgrades
    • Changing of Window Tint
    • Changing of vehicle aesthetics
    • Fully customizable tire smoke, any RGB color
    • Fully customizable license plate
    • Simple on/off toggles for Custom Tires, Bulletproof Tires, Turbo, Xenon Lights, Crew Emblem,
    • Ability to save and load cars to/from files
    • Region selecting

    Change Log:

    1.3.1 - March 4th, 2014
    • Fixed new vehicles not showing
    • Removed Nitrous
    • Turbo has been changed to allow both normal and twin
    • Added Green Window Tint

    1.3.0 - March 4th, 2014
    • Fixed BLUS Pointer for 1.11
    • Fixed BLES Pointer for 1.11
    • Added Option for Nitrous
    • Added Option for Default Radio Station
    • Added new vehicle (Roosevelt)
    • Added new vehicle (Jester)
    • Added new vehicle (Turismo)
    • Added new vehicle (Alpha)
    • Added new vehicle (Vestra)
    • Added 5 new classical horns
    • Added feature to save and load cars to/from files
    • Added Aesthetics modifiers (primitive)
    • Added Ability to show or hide the vehicle hashes (Right Click)
    • Slightly more detailed vehicle names
    • Turbo upgraded to Twin Turbo
    • Removed hashes from car names
    • Vehicles sell for maximum value
    • New layout

    1.2.7 - January 28th, 2014
    • Fixed BLUS Pointer
    • Added option for custom Pointer

    1.2.6 - January 11th, 2014
    • Fixed Pointers for 1.09

    1.2.5 - January 7th, 2014
    • Added Option for Horns
    • Selecting the Motorcycle Wheel Type displays 2 options, front and back

    1.2.4 - December 19th, 2013
    • Fixed Pointers for 1.08

    1.2.3 - December 11th, 2013
    • Fixed Pointers for 1.07

    1.2.2 - December 8th, 2013
    • Fixed Crew Emblem checkbox not updating
    • Fixed Bug with bulletproof tires editing the wrong line
    • Enabled Insurance

    1.2.1 - November 21st, 2013
    • Fixed for 1.06
    • Completed Paint List (Thanks to rightful creator)
    • Added the 4 new vehicles

    1.2.0 - November 1st, 2013
    • Tweaked vehicle selecting, should update better now
    • Fixed Wheel color bugging out vehicle paint
    • Fixed vehicle paint bugging out when selecting vehicles
    • Fixed suspension not working
    • Fixed brakes not working
    • Fixed crew emblem not working
    • Added Armor Options
    • Added Window Tint Options

    1.1.0 - October 28th, 2013
    • Added Drivetrain Group with Engine,Transmission,Suspension,and Brakes
    • Moved Turbo checkbox into Drivetrain group
    • Added Yankton option to license plate

    1.0.1 - October 26th, 2013
    • Fixed BLUS pointer

    1.0.0 - October 24th, 2013
    • Initial Release -Time to collect information!

    NetCheat for PS3 v4.0 by Dnawrkshp Arrives for DEX Consoles

    NetCheat for PS3 v4.0 by Dnawrkshp Arrives for DEX Consoles

    NetCheat for PS3 v4.0 by Dnawrkshp Arrives for DEX Consoles

    More PlayStation 3 News...
    Attached Thumbnails<br><br> Attached Thumbnails

    ss (2013-10-24 at 11.16.11).png   ss (2013-10-24 at 11.32.09).jpg   ss (2013-10-24 at 11.35.20).jpg   ss (2013-11-24 at 04.12.29).png   ss (2013-12-07 at 08.46.46).png  

  9. #9
    Registered User weeze6969's Avatar
    Join Date
    Oct 2010
    Posts
    3

    Cool Assassin's Creed 4 Offsets

    Thought this might help cause took me hours trying to figure it out myself...

    Money Offsets ($999999)
    2 1074B008 000F423F
    2 10841698 000F423F
    2 108417C8 000F423F
    2 108417FC 000F423F
    2 11E16F68 000F423F
    2 12265A18 000F423F
    2 14459B34 000F423F

    All Are (QTY.9999)

    Cloth Offests
    2 11E16F74 0000270F

    Metal Offset
    2 11E16F80 0000270F
    2 1445884C 0000270F

    Wood Offsets
    2 11E16FA4 0000270F
    2 144587D4 0000270F

    Thanks,
    Weeze

  10. #10
    Forum Moderator PS3 News's Avatar
    Join Date
    Apr 2005
    Posts
    27,811

    CodeWizard PS3 1.2.1 (PPC Assembler) by Dnawrkshp is Released

    Following up on his NetCheat for PS3 updates, today PlayStation 3 homebrew developer Dnawrkshp has released what he calls CodeWizard PS3 1.2.1 (PPC Assembler) followed by v1.2.4 with details below.

    Download: [Register or Login to view links] / [Register or Login to view links]

    To quote: CodeWizard PS3 is a makeshift PowerPC Assembly assembler, disassembler, and emulator (emulates the supported instructions).

    It allows you to write the assembly and assemble it into NetCheat format, byte array (C#), and a hex string array. It allows for multiple tabs, coloring, labels, custom psuedo instructions, and an auto complete menu.

    Assembly:

    Format:

    Instructions must be lowercase (addi, not ADDI).
    Psuedo instructions must be laid out like so:
    Code:
    Name: sub (what is called)
    Format: %rD, %rA, %rB (variables in order, can be registers or immediate or labels)
    Code: subf %rD, %rB, %rA
    
    Usage: sub r3, r3, r4
    Translation: subf r3, r4, r3
    Registers prefixes are % and $, but you can have no prefix. Registers must be lowercase.
    Decimal values must have no prefix.
    Hexadecimal values must have a 0x or $ prefix.
    Single line comments start with //
    Multiline comments start with /* and end with */
    Label declarations must end with : and label referring is just the label name
    Code:
    label1:
    bl label1
    CodeWizard supports a limited number of operations (this is why it is in beta):
    Code:
    addis
    addi
    add
    blr
    bl
    beq
    bne
    ble
    bge
    bgt
    blt
    b
    cmpwi
    cmplwi
    cmpw
    cmplw
    fadd
    fdiv
    fmr
    fmul
    fsub
    fsqrt
    lbz
    ld
    lfs
    lhz
    lis
    li
    lwz
    mfspr
    mtspr
    mullw
    mulli
    nop
    ori
    slwi
    srwi
    stb
    stdu
    std
    stfs
    sth
    stw
    stwu
    subf
    Conditional branches use labels or offsets. The offsets are relative to the current address. Unconditional branches use labels or addresses. The addresses are not relative.

    label1:

    beq 0x4 //Branches if cr0 is equal to the next line
    bl 0x001ADCC0

    beq label1
    bl label1

    Instructions like stw (stw rA, 0xXXXX(rD)) must be laid out like shown. You can't write "stw rA, rD, 0xXXXX" or anything similar.

    Special Instructions:

    "address 0xXXXXXXXX" - Sets the current address in the assembler.
    "hook 0xXXXXXXXX" - One time use, sets the passed address to a *branch* to the first "address" instruction (hooks the beginning of the sub to the passed argument).
    "hookl 0xXXXXXXXX" - One time use, sets the passed address to a *branch and link* to the first "address" instruction (hooks the beginning of the sub to the passed argument).
    "setreg rD, 0xXXXXXXXX" - Sets the register rD to the passed 32 bit immediate. Doesn't have to be hexadecimal.
    "hexcode 0xXXXXXXXX" - In the assembled code, the value will be equal to the passed 32 bit value. This is great for unsupported instructions.
    "import [PATH]" - Imports the file at [PATH] into the subroutine at assemble time. Puts it after the already loaded imports.
    "float [FLOAT]" - Inserts into the assembled code as assemble time the hexadecimal version of the float specified. Ex: float 1.23 => 3F9D70A4
    "string [STRING]" - Converts the string into a hex version and inserts it into the code at assemble time. Ex: string aBbCcd => 61426243 :: 63640000

    Output Type:

    NetCheat format; 2 ADDR8 VAL8.
    Byte array: byte[] NAME = { 0xBYTES ... }
    Hex string array: BYTES ...
    Code:
    address 0x01020304
    li r5, 0x9876
    ---
    NC: 2 01020304 38A09876
    BA: byte[] NAME = { 0x38, 0xA0, 0x98, 0x76 };
    Hex: 38 A0 98 76
    Disassembly:

    The format must be in NetCheat PS3 format. If it is not then you must use the Conversion form under Tools. Labels and address instructions will be used as much as possible. Only other thing is that it erases the currently open tab if you accept the prompt.

    Emulation:

    Images:

    Please understand that the emulator is very basic and is just to find errors in the assembly. It only emulates the assembly.

    Registers are completely modifiable during execution and turn red when they are modified by the code. You may switch between the register types by clicking on the lable above the register list. The stack pointer (register 1) is set in the options menu and is defaulted to 02000000.

    Controls are fairly simple. Aside from the buttons, you may press F11 to step into. The debug box just displays any errors that occur like unsupported op or invalid memory access.




    So I am releasing this as beta to get some feedback as to what instructions should be added. Also if you have find any bugs or have questions please don't be afraid to reply.

    1.2.4 Changelog:

    Fixed a bunch of assembling bugs that were caused by new NC format
    Fixed bug where new tab wouldn't have autocomplete
    Fixed bug caused when a pseudo instruction has no arguments can't be used
    Cleaned up emulator and assembler a bit
    Added AutoIndent
    Added tab support (cleaner formatting)
    Added new instructions: divw, lwzx, stwx, ldx, stdx, lfd, stfd
    Added Updater (identical to NetCheat PS3)

    Below is a Hooking Methods Guide from therifboy, as follows:

    Note: you will need some knowledge of ppc for this. I'll try to explain some methods of hooking as good as possible. But it still can be hard without knowledge of ppc since you will need to reverse the number of arguments and also the type. I will not explain this process.

    Download: [Register or Login to view links]

    METHOD 1: Intercepting calls of separate functions

    This method is really simple. All it does is edit the call to make it branch to a subroutine you have written inside the .self. Note that the difference between the address of the call and your subroutine can't be bigger than 0x1FFFFFC. That's the range of a 'bl'.



    If I press X on that call I can see that subroutine is referenced multiple times, but we will be intercepting only the calls coming from the subroutine i'm currently in. In this case sub_23286C. The function I will be hooking is cellHttpSendRequest btw.



    This method is not the best one. You will either need to write the subroutine by hand and then copy it somewhere into memory where it can be executed, or write it in C/C++, compile the code and then edit the addresses by hand. Your code should look like this:
    Code:
    void Hook(uint64_t r3, uint64_t r4, uint64_t r5, uint64_t r6)
    {
        printf("r3 = 0x%llx | r4 = 0x%llx | r5 = 0x%llx | r6 = 0x%llx", r3, r4, r5, r6);
    	void(*hooked_func)(uint64_t, uint64_t, uint64_t, uint64_t) = (void(*)(uint64_t, uint64_t, uint64_t, uint64_t))0x006F84A0; <-- 0x006F84A0 is the OPD_s of the function I am hooking.
    	hooked_func(r3, r4, r5, r6);
    }
    What I mean by edit addresses by hand is that you will need to edit the opcodes for the call to printf to make it call the printf function inside the .self.

    METHOD 2: Intercepting calls of separate functions using a sprx and a stub. (I will explain this using the same subroutine as previous method.)

    This method is I think the easiest one. I will make it branch to a stub which will then branch to a function inside my sprx. This method has 4 arguments: r3 - r6. The first thing to do in the stub is to save these arguments and the link register.
    Code:
    stdu r1, -0x60(r1) 
    mflr r0 //move link register to r0
    std r0, 0x70(r1) // save link register
    std r3, 0x40(r1) // save r3
    std r4, 0x48(r1) // save r4
    std r5, 0x50(r1) // save r5
    std r6, 0x58(r1) // save r6
    nop//we will rewrite this using our sprx. If you're using a static address then you can replace that by lis r11, [your_sub_address_high]
    nop // ori r11, r11, [your_sub_address_low]
    mtctr r11
    bctrl  // this is where the stub will jump to the sprx.
    ...
    Copy this code in your plugin. This code willl replace the call on the first image to make it branch to our stub.
    Code:
    sys_pid_t get_process_id()
    {
    	system_call_0(1);
    	return_to_user_prog(sys_pid_t);
    }
    
    int32_t write_process(uint64_t ea, const void * data, uint32_t size)
    {
    	sys_pid_t pid = get_process_id();
    	system_call_4(0x389, (uint64_t)pid, ea, (uint64_t)data, size);
    	return_to_user_prog(int32_t);
    }
    
    void branch_link(uint32_t branchTo, uint32_t branchFrom)
    {
    	uint32_t branch;
    	if (branchTo > branchFrom)
    	{
    		branch = 0x48000001 + (branchTo - branchFrom);
    	}
    	else
    	{
    		branch = 0x4C000001 - (branchFrom - branchTo);
    	}
    	write_process(branchFrom, &branch, 4);
    }
    Copy this code aswell. It will replace the nops inside your stub to make it branch to your sprx. This is done at runtime because the sprx has no fixed address.
    Code:
    void hook_function(uint64_t r3, uint64_t r4, uint64_t r5, uint64_t r6) <--- Notice how this function has the same amount of arguments as the subroutine i'm hooking. The types can be wrong though. It might be any integer argument. int32_t, char*, float*,...
    {
    	printf("r3 = 0x%llx.\nr4 = 0x%llx.\nr5 = 0x%llx.\nr6 = 0x%llx", r3, r4, r5, r6);
    }
    
    void write_stub_hook(uint32_t address, uint32_t function)
    {
    	uint32_t opcode[2];
    	opcode[0] = 0x3D600000 + ((function >> 16) & 0xFFFF);  // lis r11, function@high
    	opcode[1] = 0x616B0000 + (function & 0xFFFF);  // ori r11, r11, function@low
    	write_process(address, &opcode, 8);
    }
    When our hook_function returns to the stub, we will then need to forward the call to the original subroutine. For me it is sub_56FA7.
    Code:
    seg001:00500000    stdu r1, -0x60(r1)   // 0x00500000 is not the best address to write the stub at.
    seg001:00500004    mflr r0
    seg001:00500008    std r0, 0x70(r1)
    seg001:0050000C    std r3, 0x40(r1)
    seg001:00500010    std r4, 0x48(r1)
    seg001:00500014    std r5, 0x50(r1)
    seg001:00500018    std r6, 0x58(r1)
    seg001:0050001C    nop
    seg001:00500020    nop
    seg001:00500024    mtctr r11
    seg001:00500028    bctrl
    seg001:0050002C    ld r3, 0x40(r1)
    seg001:00500030    ld r4, 0x40(r1)
    seg001:00500034    ld r5, 0x40(r1)
    seg001:00500038    ld r6, 0x40(r1)
    seg001:0050003C    nop // we will replace this by "bl sub_56FA7" using the sprx.
    seg001:00500040    ld r0, 0x70(r1)
    seg001:00500044    mtlr r0
    seg001:00500048    addi r1, r1, 0x60
    seg001:0050004C    blr
    This is our stub. You can write it into vsh.elf and then encrypt it back to .self or just write it in asm and copy it into memory using our sprx. (You will need to calculate the size yourself)
    Code:
    void hook_stub()
    {
    	__asm__
    		(
    		"stdu 1, -0x60(1);"
    		"mflr 0;"
    		"std 0, 0x70(1);"
    		"std 3, 0x40(1);"
    		"std 4, 0x48(1);"
    		"std 5, 0x50(1);"
    		"std 6, 0x58(1);"
    		"nop;"
    		"nop;"
    		"mtctr 11;"
    		"bctrl;"
    		"ld 3, 0x40(1);"
    		"ld 4, 0x40(1);"
    		"ld 5, 0x40(1);"
    		"ld 6, 0x40(1);"
    		"nop;"
    		"ld 0, 0x70(1);"
    		"mtlr 0;"
    		"addi 1, 1, 0x60;"
    		"blr;"
    		);
    }
    Everything is now setup. All we need to do now is write the code inside our sprx.
    Code:
    extern "C" int _Project_prx_entry(void)
    {
    	write_process(0x00500000/*the address of the stub*/, (void*)&hook_stub, 0x50/*size of hook_stub*/);
    	write_stub_hook(0x0050001C/*the address of the first nop*/, *(uint32_t*)&hook_function);
    	branch_link(0x0056FA74/*the address of the sub i'm hooking*/, 0x0050003C/*the address of the third nop in my stub*/);
    	branch_link(0x00500000/*the address of the stub*/, 0x00232DF0/*the original call to the function i'm hooking*/);
            return SYS_PRX_RESIDENT;
    }
    PS: you can forward other functions calling 0x0056FA74 to the stub too.

    Download: [Register or Login to view links]

    METHOD 3: Intercepting every call to a function.

    This method will require some hand edits but it can also be tricky sometimes. It overwrites the 4 beginning opcodes of a function (often the stack setup) to branch to our own code. This subroutine is an example of when it won't work.



    I'll explain this method using this subroutine.



    You will need these scripts.
    Code:
    sys_pid_t get_process_id()
    {
    	system_call_0(1);
    	return_to_user_prog(sys_pid_t);
    }
    
    int32_t write_process(uint64_t ea, const void * data, uint32_t size)
    {
    	sys_pid_t pid = get_process_id();
    	system_call_4(0x389, (uint64_t)pid, ea, (uint64_t)data, size);
    	return_to_user_prog(int32_t);
    }
    
    void branch_ctr(uint32_t address, uint32_t function)
    {
    	uint32_t opcode[4];
    	opcode[0] = 0x3D600000 + ((function >> 16) & 0xFFFF);  // lis r11, function@high
    	opcode[1] = 0x616B0000 + (function & 0xFFFF);  // ori r11, r11, function@low
    	opcode[2] = 0x7D6903A6; // mtctr r11
    	opcode[3] = 0x4E800420; // bctrl
    	write_process(address, &opcode, 16);
    }
    This is how the function you hook to should look like. The function has 5 arguments. So we will need to move those 5 arguments back to r3, r4, r5, r6 and r7 before we can return to the function we hooked. The asm is where we will do our edits.
    Code:
    void hook_function(uint64_t r3, uint64_t r4, uint64_t r5, uint64_t r6, uint64_t r7)
    {
    	printf("r3 = 0x%llx.\nr4 = 0x%llx.\nr5 = 0x%llx.\nr6 = 0x%llx.\nr7 = 0x%llx", r3, r4, r5, r6, r7);
    	__asm__(  
    		"mr 3, %0;"
    		"mr 4, %1;"
    		"mr 5, %2;"
    		"mr 6, %3;"
    		"mr 7, %4;"
    		: :
    		"b"((r3)),
    		"b"((r4)),
    		"b"((r5)),
    		"b"((r6)),
    		"b"((r7))
    		: "memory"
    		);
    }
    We then need to copy the 4 beginning opcodes of the function we're hooking and load the address we're branching back into CTR using r11. For me it is 0x0063983C
    Code:
    void hook_function(uint64_t r3, uint64_t r4, uint64_t r5, uint64_t r6, uint64_t r7)
    {
    	printf("r3 = 0x%llx.\nr4 = 0x%llx.\nr5 = 0x%llx.\nr6 = 0x%llx.\nr7 = 0x%llx", r3, r4, r5, r6, r7);
    	__asm__(  
    		"mr 3, %0;"
    		"mr 4, %1;"
    		"mr 5, %2;"
    		"mr 6, %3;"
    		"mr 7, %4;"
    		"stdu 1, -0xD0(1);"
    		"mflr 0;"
    		"std 25, 0x98(1);"
    		"std 0, 0xE0(1);"
    		"lis 11, 0x63;"
                    "ori 11, 11, 0x983C;"
                    "mtctr 11;"
    		: :
    		"b"((r3)),
    		"b"((r4)),
    		"b"((r5)),
    		"b"((r6)),
    		"b"((r7))
    		: "memory"
    		);
    }
    Now add this line somewhere in your plugin to enable the hook.
    Code:
    branch_ctr(0x63982C, *(uint32_t*)&hook_function);
    This is how it looks like when compiled. Using HxD we will move the opcodes generated by the compiler on top of the beginning opcodes we copied.



    Decrypt your plugin to .prx and open it up using HxD. Then locate the address inside HxD by adding 0xF0 to the address in IDA. For me it is 0x1F4 + 0xF0 = 0x2E4.



    Go to that address by pressing CTRL + G or Search->Goto. Cut the bytes and paste them at the right address. Also change the blr (4E 80 00 20) to bctr (4E 80 04 20). When that is done save your file, you should end up with this.



    Download VS2010 Project: [Register or Login to view links]

    METHOD 4: Intercepting every call to a function using a stub and a sprx.

    From Flat_z: Nice reading, I've used similar methods to dump SSL premaster secrets from PS3.

    Finally, below are some PlayStation 3 Application Controller PS3 POC videos from Dnawrkshp as follows:

    I read this idea from somewhere and I thought it was a really cool concept. So I decided to at least try to create it for the PS3. The result isn't usable as it probably runs at 3 fps, but it is just a proof of concept.





    In more detail, there is a PS3 program and a PC program. The PC program requests the controller data from the PS3 and uses that with config from the user to interact with a program (probably an emulator). Then the PC will send the current screen to the PS3 and the PS3 will display that image on the TV. At this point, the image is sent as an uncompressed png file (probably one of the problems) to the PS3.

    The video shows the PC program working exclusively with VBA and a hard-coded input config. It also doesn't have support for joysticks (yet, it won't be hard).

    I don't think I can take this program any farther than it is, but maybe there is someone that can. It is completely private, but if people still want it (even for just the controller capability) I can release it. If someone wants to actually work on the source I can also release the source code for everyone.

    As for NetCheat (since someone will ask in this thread), I'm still taking a break from it. Given I'm pretty much the only developer, it can be very stress inducing and I don't like that. I have a few bugs to fix and then I can push the update (CCAPI 2.5, results list locking up, and probably more).

    Yeah you're right. A 549 kb png converted to a 137 kb jpg. I'll definitely change it to use JPEG and post an update. Oh yeah that definitely sped it up:





    Yeah then the thing I read was probably from you. Therifboy sent me a list of things that were being requested as a plugin. I saw this one and thought that it would be a lot more practical as a full on program. Thanks for the great idea.





    My AV was scanning in the background which accounted for all the random lag spikes. Otherwise I can get a reasonable 15 fps or so from this. At this point beta testing could/should occur. Anyone feeling up to testing for me? Yeah this exact text was in the thing:

    Run the emulator on the PC.
    Video/sound transferred to the PS3 from PC
    Controls from PS3 to PC.

    Anyway here's the link: Download: [Register or Login to view links]

    It's pretty straight forward. Important to note that HD TV's stretch the image so much that you need a high quality to see anything. Also using a cross-over cable is the best method.

    I'm definitely interested in sending the PS3's frame buffer over to the PC at a good FPS. But I think it'll be delayed (displaying on PC) and simulating controller input wouldn't be possible. At least I have no idea how to do it.

    Regarding AC, I'm thinking of using UDP instead of TCP since it would be faster. Though since it isn't as reliable I wonder if that could cause the PS3 to freeze from the corrupt image. Definitely worth a try though. And thanks for testing

    Couldn't get UDP to work right so I gave up.

    Download: [Register or Login to view links]

    I've changed a few things, namely the input simulator works with Project64 and probably more emulators. Though for some reason the arrow keys don't work... So just remap the controller to use something else and you should good to go.

    The source code for the PS3 app can be found here: [Register or Login to view links]

    The source code for the PC app can be found here: [Register or Login to view links]





    I recorded myself playing SSB64 with my capture card so you can properly see it working. Also, Link4Life.

    I'm using GDI. I implemented that DX method but it seems slower than my current GDI screen capturer. Using JPEG is definitely better than BMP. The issue isn't processing power (unless you are on a really crappy computer), but net speed. A 1.8 mb file will take more time to send than compressing it down to 50kb and sending that.

    I'm going to stick with TCP just because I don't have any experience with UDP. Updating the screen only when stuff changes should work but actually calculating changes and applying them is slow... So the result is around half the speed of the regular. Here is my code on the PS3; there might be something to speed it up:
    Code:
    typedef struct
    {
    	short x;
    	short y;
    	char R;
    	char G;
    	char B;
    	
    } PixelChange;
    
    // pixels contains an array of the PixelChange struct. Size indicates the size of the array in bytes (not # of elements in array)
    void UpdateTextureJPG(char * pixels, int size)
    {
    	int pixIndex = 0;
    	PixelChange * pixel = NULL;
    	
    	//Allocate a new array to hold the pixels and copy the old bitmap into the new array
    	char * newImagePixels = malloc(sizedJPG.pitch * sizedJPG.height);
    	memcpy(newImagePixels, sizedJPG.bmp_out, sizedJPG.pitch * sizedJPG.height);
    	
    	//Loop through the pixels and apply the changes
    	for (pixIndex = 0; pixIndex < size; pixIndex += 7)
    	{
    		pixel = (PixelChange *)&pixels[pixIndex];
    		
    		u32 off = (pixel->y * sizedJPG.pitch) + (pixel->x * 4);
    		
    		newImagePixels[off + 1] = pixel->R;
    		newImagePixels[off + 2] = pixel->G;
    		newImagePixels[off + 3] = pixel->B;
    	}
    	
    	//Copy the new image into the old one. Free the new one since it's not needed
    	memcpy(sizedJPG.bmp_out, newImagePixels, sizedJPG.pitch * sizedJPG.height);
    	free(newImagePixels);
    	
    	//Resize and load the bitmap into the texture
    	texture_jpg = ResizeJPG(sizedJPG, 848, 512);
    	memcpy(jpg_texture_mem, texture_jpg.bmp_out, texture_jpg.pitch * texture_jpg.height);
            free(texture_jpg.bmp_out);
            texture_jpg_offset = tiny3d_TextureOffset(jpg_texture_mem);
    }
    I'm using GDI. I implemented that DX method but it seems slower than my current GDI screen capturer.

    Using JPEG is definitely better than BMP. The issue isn't processing power (unless you are on a really crappy computer), but net speed. A 1.8 mb file will take more time to send than compressing it down to 50kb and sending that.

    I'm going to stick with TCP just because I don't have any experience with UDP. Updating the screen only when stuff changes should work but actually calculating changes and applying them is slow... So the result is around half the speed of the regular. Here is my code on the PS3; there might be something to speed it up:
    Code:
    typedef struct
    {
    	short x;
    	short y;
    	char R;
    	char G;
    	char B;
    	
    } PixelChange;
    
    // pixels contains an array of the PixelChange struct. Size indicates the size of the array in bytes (not # of elements in array)
    void UpdateTextureJPG(char * pixels, int size)
    {
    	int pixIndex = 0;
    	PixelChange * pixel = NULL;
    	
    	//Allocate a new array to hold the pixels and copy the old bitmap into the new array
    	char * newImagePixels = malloc(sizedJPG.pitch * sizedJPG.height);
    	memcpy(newImagePixels, sizedJPG.bmp_out, sizedJPG.pitch * sizedJPG.height);
    	
    	//Loop through the pixels and apply the changes
    	for (pixIndex = 0; pixIndex < size; pixIndex += 7)
    	{
    		pixel = (PixelChange *)&pixels[pixIndex];
    		
    		u32 off = (pixel->y * sizedJPG.pitch) + (pixel->x * 4);
    		
    		newImagePixels[off + 1] = pixel->R;
    		newImagePixels[off + 2] = pixel->G;
    		newImagePixels[off + 3] = pixel->B;
    	}
    	
    	//Copy the new image into the old one. Free the new one since it's not needed
    	memcpy(sizedJPG.bmp_out, newImagePixels, sizedJPG.pitch * sizedJPG.height);
    	free(newImagePixels);
    	
    	//Resize and load the bitmap into the texture
    	texture_jpg = ResizeJPG(sizedJPG, 848, 512);
    	memcpy(jpg_texture_mem, texture_jpg.bmp_out, texture_jpg.pitch * texture_jpg.height);
            free(texture_jpg.bmp_out);
            texture_jpg_offset = tiny3d_TextureOffset(jpg_texture_mem);
    }
    From therifboy: Getting rid of the for loop should massively improve the speed. (I did not test the code)

    Also, poking one byte at a time is a waste of time. Just set alpha to be 0xFF from the pc program and poke 32 bit at once.
    Code:
    typedef struct
    {
    	int16_t x;
    	int16_t y;
    	union
    	{
    		struct
    		{
    			uint8_t r;
    			uint8_t g;
    			uint8_t b;
    			uint8_t a;
    		};
    		uint32_t rgba;
    	};
    } PixelChange;
    
    // pixels contains an array of the PixelChange struct. Size indicates the size of the array in bytes (not # of elements in array)
    void UpdateTextureJPG(char * pixels, int size)
    {
    
    	PixelChange * pixel = NULL;
    	
    	//Allocate a new array to hold the pixels and copy the old bitmap into the new array
    	char * newImagePixels = malloc(sizedJPG.pitch * sizedJPG.height);
    	memcpy(newImagePixels, sizedJPG.bmp_out, sizedJPG.pitch * sizedJPG.height);
    	
    	while (size > 0)
    	{
    		if (size >= 0x50)
    		{
    			goto bigSize;
    		}
    		else if (size >= 0x28)
    		{
    			goto mediumSize;
    		}
    		else if (size >= 0x8)
    		{
    			goto smallSize;
    		}
    		break;
    		
    	bigSize;
    		pixel = (PixelChange *)&pixels[size - 0x28];
    		u32 off = (pixel->y * sizedJPG.pitch) + (pixel->x * 4);	
    		*(uint32_t*)(newImagePixels[off] = pixel.rgba;
    		
    		pixel = (PixelChange *)&pixels[size - 0x20];
    		u32 off = (pixel->y * sizedJPG.pitch) + (pixel->x * 4);
    		*(uint32_t*)(newImagePixels[off] = pixel.rgba;
    		
    		pixel = (PixelChange *)&pixels[size - 0x18];
    		u32 off = (pixel->y * sizedJPG.pitch) + (pixel->x * 4);
    		*(uint32_t*)(newImagePixels[off] = pixel.rgba;
    		
    		pixel = (PixelChange *)&pixels[size - 0x10];
    		u32 off = (pixel->y * sizedJPG.pitch) + (pixel->x * 4);
    		*(uint32_t*)(newImagePixels[off] = pixel.rgba;
    		
    		pixel = (PixelChange *)&pixels[size - 0x8];
    		u32 off = (pixel->y * sizedJPG.pitch) + (pixel->x * 4);
    		*(uint32_t*)(newImagePixels[off] = pixel.rgba;
    		
    		size -= 0x28;
    		
    	mediumSize:
    		pixel = (PixelChange *)&pixels[size - 0x20];
    		u32 off = (pixel->y * sizedJPG.pitch) + (pixel->x * 4);
    		*(uint32_t*)(newImagePixels[off] = pixel.rgba;
    		
    		pixel = (PixelChange *)&pixels[size - 0x18];
    		u32 off = (pixel->y * sizedJPG.pitch) + (pixel->x * 4);
    		*(uint32_t*)(newImagePixels[off] = pixel.rgba;
    		
    		pixel = (PixelChange *)&pixels[size - 0x10];
    		u32 off = (pixel->y * sizedJPG.pitch) + (pixel->x * 4);
    		*(uint32_t*)(newImagePixels[off] = pixel.rgba;
    		
    		pixel = (PixelChange *)&pixels[size - 0x08];
    		u32 off = (pixel->y * sizedJPG.pitch) + (pixel->x * 4);
    		*(uint32_t*)(newImagePixels[off] = pixel.rgba;
    		
    		size -= 0x20;
    		
    	smallSize;
    		pixel = (PixelChange *)&pixels[size - 0x08];
    		u32 off = (pixel->y * sizedJPG.pitch) + (pixel->x * 4);
    		*(uint32_t*)(newImagePixels[off] = pixel.rgba;
    		
    		size -= 0x8;
    	}
    	
    	
    	//Copy the new image into the old one. Free the new one since it's not needed
    	memcpy(sizedJPG.bmp_out, newImagePixels, sizedJPG.pitch * sizedJPG.height);
    	free(newImagePixels);
    	
    	//Resize and load the bitmap into the texture
    	texture_jpg = ResizeJPG(sizedJPG, 848, 512);
    	memcpy(jpg_texture_mem, texture_jpg.bmp_out, texture_jpg.pitch * texture_jpg.height);
    	free(texture_jpg.bmp_out);
    	texture_jpg_offset = tiny3d_TextureOffset(jpg_texture_mem);
    }
    From Dnawrkshp: The results show that the issue lies on the PC side. Calculating the difference between images is very time consuming. Otherwise this will definitely work better.

    I got this off of some site. I didn't document it for some reason so I can't link it. I did the caching of the actual changes.
    Code:
            public struct PixelChange
            {
                public short x;
                public short y;
                public byte A;
                public byte R;
                public byte G;
                public byte B;
            }
    
            public static List<ImageCompare.PixelChange> CompareImages(Bitmap b1, Bitmap b2)
            {
                List<ImageCompare.PixelChange> ret = new List<ImageCompare.PixelChange>();
    
                if ((b1 == null) != (b2 == null)) return ret;
                if (b1.Size != b2.Size) return ret;
    
                Rectangle bounds = new Rectangle(0, 0, b1.Width, b2.Height);
                var bmpDataA = b1.LockBits(bounds, ImageLockMode.ReadWrite, b1.PixelFormat);
                var bmpDataB = b2.LockBits(bounds, ImageLockMode.ReadWrite, b2.PixelFormat);
    
                int height = b1.Height;
                int npixels = height * bmpDataA.Stride / 4;
    
                int x = 0, y = 0;
                unsafe
                {
                    int* pPixelsA = (int*)bmpDataA.Scan0.ToPointer();
                    int* pPixelsB = (int*)bmpDataB.Scan0.ToPointer();
    
                    for (int i = 0; i < npixels; ++i)
                    {
                        if (pPixelsA[i] != pPixelsB[i])
                        {
                            PixelChange pc = new PixelChange();
                            pc.x = x;
                            pc.y = y;
                            pc.A = (byte)(pPixelsA[i] >> 24);
                            pc.R = (byte)(pPixelsA[i] >> 16);
                            pc.G = (byte)(pPixelsA[i] >> 08);
                            pc.B = (byte)(pPixelsA[i] >> 00);
                            ret.Add(pc);
                        }
                        x++;
                        if (x == (bmpDataA.Stride / 4))
                        {
                            x = 0;
                            y++;
                        }
                    }
                }
                b1.UnlockBits(bmpDataA);
                b2.UnlockBits(bmpDataB);
    
                return ret;
            }
    This is all because Bitmap.GetPixel() is very slow.

    CodeWizard PS3 1.2.1 (PPC Assembler) by Dnawrkshp is Released

    CodeWizard PS3 1.2.1 (PPC Assembler) by Dnawrkshp is Released

    CodeWizard PS3 1.2.1 (PPC Assembler) by Dnawrkshp is Released

    More PlayStation 3 News...
    Attached Thumbnails<br><br> Attached Thumbnails

    ss (2013-12-10 at 06.31.42).png   ss (2013-12-10 at 07.27.42).png   ss (2013-12-10 at 07.28.05).png   ss (2013-12-10 at 07.28.18).png   boKOcxz.png   jON9pkO.png  

    LVZDa9Ra.png   RbFdQBrb.png   WKmfNjXc.png   BVz8NGmd.png  

 

Sponsored Links
Page 1 of 2 12 LastLast
Affiliates - Contact Us - PS3 Downloads - Privacy Statement - Site Rules - Top - © 2014 PlayStation 3 News