GH1 firmware research volunteers required

I have been doing tests with low GOP settings for AVCHD. I have found that, though I can get fairly reliable recording with the FHD, setting lower GOP for 720p (no matter the bitrate, or if it is HD, H, or L, both PAL and NTSC) can always be made to crash by shooting extremely low light (I get a reliable crash by shooting a dark room with the television on). This makes me think that the crash is related to one of two bugs in reducing GOP numbers for 720p: either it is related to noise reduction operation, or it is related to the large amount of similarity in frames-- I would guess the former. But it is interesting that I can only force this crash in 720p modes, but not with similar low GOP settings for FHD.
 
Vitally is it possible to add the old change fps function in mjpeg mode. I know it skips frames but I intend to use is for timelapse (2fps). Mabey it could be a timelapse only option, changing the header of the file from 30fps to xfps so it wont need post work.
I don´t know if I got the terms right hope you understand.
I know modulr played with this option but in an old release.
 
I believe without experients it is impossible to say if it works good enought or not.
And 3D sync is a good target :-)

We've done quite a bit of work using the wired remote and other means to try and sync two GH1's. I've started a new thread to share all of our work so far. The good news is, when it works, the 3D from the GH1's (with the GH13 firmware, of course) is very high quality.
 
Last edited:
Vitally is it possible to add the old change fps function in mjpeg mode. I know it skips frames but I intend to use is for timelapse (2fps). Mabey it could be a timelapse only option, changing the header of the file from 30fps to xfps so it wont need post work.
I don´t know if I got the terms right hope you understand.
I know modulr played with this option but in an old release.


I just noticed that function exists for gh1, It is the GF1 (that I have) that is missing that :(
bummer, know I don´t even recall if it ever had it for the GF1.
I´ll recapitulate the question, is it possible to ad the 30fps to xfps to the GF1 as well?
if so it would be nice to focus it as a timelapse function.
thanks
 
Back from small vacation.
First, we need to fix few very small things.
Plus add user patches.
Next, we'll wait for some results on AVCHD part.
As soon as some positive things will be done, MJPEG part will be open.
I'll start to make many HDMI experiments as soon as I'll get my small HDMI screen.
 
Back from small vacation.
First, we need to fix few very small things.
Plus add user patches.
Next, we'll wait for some results on AVCHD part.
As soon as some positive things will be done, MJPEG part will be open.
I'll start to make many HDMI experiments as soon as I'll get my small HDMI screen.

Hope your vacation went well. Is that small HDMI screen 60 inches or 65 inches?:laugh:
 
I did think about new firmware problem. It is possible if you have microcontroller programmer for AM3. One of problem it will be disassembling your camera. (You lose your warranty).

PS: I will search People who have this device. (And really possible download new firmware for microcontroler).
 
Last edited:
Looking to compile simple thing like
.org 0x0004D5DD
.global _start
.type _start, @function
.equ Example_Function, 0x0004D000
_start:
mov 0x100, D0
call Example_Function, [D2,A2], 0xC
ret [], 4

Unfortunately you can't set actual start address by
.org directive (it is only offset from file start, and start is 0x00).
Same thing with calls. Example_Function is external function and assembler do not generate proper address (as it must be realtive to current address) and place constant in instruction opcode as it is.

May be right approach is:

.global _start
.type _start, @function
.equ Example_Function, 0x0004D000
.equ Our_Function_Start, 0x0004D5DD
_start:
mov 0x100, D0
call .+Example_Function-Our_Function_Start, [D2,A2], 0xC
ret [], 4

"." must return current assembling address. But it act very strange.
 
Last edited:
I didn't ask for the keys yet, so I didn't see disassembled code... it's also my first look at the mn103 manual (that I believe it is OCRed and contains some errors...)

MOVM A0,(SP) //save A0
reg A0 = Example_Function
call jumper_function,[Ax...],0x28
MOVM (SP),A0 // restore A0
jumper_function: jmp( A0 )

Example_Function is absolute but CALL is relative only
since jumper_function is known address to the assembler it can calculate the offset.
jmp( A0 ) is absolute

of course you lose A0 (or other register) value...

it is not possible to use CALLS since it needs RETS, while you probably will have a RET or RETF...

Another trick (in order to not waste a register) can be to manipulate the stack...

But I'm confident that there is a way to tell the assembler that Example_Function is an address

PS: these were the problems I referred in a previous message with the term of "linking"...
 
I didn't ask for the keys yet, so I didn't see disassembled code... it's also my first look at the mn103 manual (that I believe it is OCRed and contains some errors...)

I completely don't get your point.
All I need is correct call argument calculation (as it is relative in MN assembler).
 
JMP (Ax), CALLS (Ax) and JSR (Ax) are absolute and not relative, according to the manual...

My idea is that since the assembler can't calculate the Example_Function relative address we can call a function the assembler knows and then force a absolute jmp to the address whose value is in A0.

Unfortunately, the only way to have an absolute JMP is using a address...

JMP (An)
An→PC
Stores the contents of register An in program counter(PC).

Using a JMP you don't touch the stack and so the terminating RET/RETF finds the correct values in place...
the only problem is that you lose one register

PS: from your sample code it seems that you must know, for each routine you want to call, which registers to save and how much space to reserve...
 
Again.
I need working call adress calculation.
Any JMP (), CALLS (). are not an option.

All I can see right now is that assembler do not work correctly.

call 0x100 + . , [], 0
mov 0x100 + . , D1;

Second operator argument work normally and adds current address to 0x100, while first do not work as expected and ignores current address.

This is more GNU assembler thing then MN specific.

"The Special Dot Symbol
The special symbol . refers to the current address that as is assembling into. Thus, the expression melvin: .long . defines melvin to contain its own address. Assigning a value to . is treated the same as a .org directive. Thus, the expression .=.+4 is the same as saying .space 4."
 
Last edited:
Code:
.org 0x00000000
_baseAddress:
.equ Example_Function,_baseAddress+0x0004D000

.org 0x0004D5DD
.global _start
.type _start, @function
_start:
mov 0x100, D0
call Example_Function, [D2,A2], 0x0C
call 0x100 + . , [], 0
ret [], 4
produces (loaded with offset 0x40000000 as main firmware) :

Code:
ROM:4004D5DD 2C 00 01                                mov     0x100, D0
ROM:4004D5E0 CD 20 FA A0 0C                          call    sub_4004D000, [D2,A2], 0xC
ROM:4004D5E5 CD 00 01 00 00                          call    0x4004D6E5, [], 0
ROM:4004D5EA DF 00 04                                ret     [], 4
 
Last edited:
DaLiV - your approach do not work in reality.
.org instruction set offset inside current section.
And I need to call function that is very far from my current location (do not look at exact address values in my example).
Your approach do not work with 0x40010000 and 0x70030000 addresses, for example. :-)
So, I need universal approach to calculate call address.
May be it won't work without changes in call operand processing in GNU assembler for MN.
 
Code:
.org 0x00000000
_baseAddress:
.equ Example_Function,_baseAddress+0x0004D000
.equ _baseDataAddress,_baseAddress+0x70030000 # (base for 0x70030000)
.equ _baseDirectAddress,_baseAddress+0x40000000 # (base for 0x40000000)
.equ var1, _baseDataAddress+0x65432
.equ var2, _baseDirectAddress+0x12345

.org 0x0004D5DD
.global _start
.type _start, @function
_start:
mov 0x100, D0
call Example_Function, [D2,A2], 0x0C
call 0x100 + . , [], 0
mov (var1), D0
mov (var2), A0
ret [], 4
result:
Code:
ROM:4004D5DD 2C 00 01                                mov     0x100, D0
ROM:4004D5E0 CD 20 FA A0 0C                          call    sub_4004D000, [D2,A2], 0xC
ROM:4004D5E5 CD 00 01 00 00                          call    0x4004D6E5, [], 0
ROM:4004D5EA FC A4 32 54 09 70                       mov     (0x70095432), D0
ROM:4004D5F0 FC A0 45 23 01 40                       mov     (dword_40012345), A0
ROM:4004D5F6 DF 00 04                                ret     [], 4

simple don't forget about relative and direct adressing
 
Last edited:
And?
What do you want to show by this?
I need proper address calculation in call instructions.
And stop using this .org things, they are useless (.org 0 can be used, if you need one :-) ).

Show me how this will be working with my routine address = 0x40010000 and function address 0x70030000.

P.S. "0x100 + ." in call actually do not work. Same generated binary code will be if you leave only 0x100.
 
show what code you want to get exactly

second org you need to postion your function at needed address (if can't understand why i'm usse that)

need call to function @0x70030000 ?

P.S. mine code exactly as shown compiled to what yoou see - and that "call 0x100 +. "compiled correctly (look at ROM:4004D5E5) - or you want something other code ?
 
Last edited:
Back
Top