Re: Help with TypeLoadException (marshaling unmanaged code) - C# Discussion Boards

Re: Help with TypeLoadException (marshaling unmanaged code)

30-Jun-07 5:10

AFAIK value types in CLR must be "naturally aligned", meaning their address (and hence
also their offset within a struct or class) must be a multiple of their size.

So you cant put an int at an offset of 5.

But on the other hand structs in C/C++ get padding bytes by default to achieve also
"natural alignment".
(I think there is a switch to turn this off, but one normally does not do that).
You should be able to check this either by printing some actual addresses (in hex!),
or by showing some offsetof() results, in your C/C++ code.

If so, this means sIntra in vc1_sBlk is actually at offset 8.
Lucky for you, now you can have C# and C/C++ agree and work together.

Smile | :)

Luc Pattyn

[My Articles] [Forum Guidelines]

TomWolfstein30-Jun-07 6:05

Re: Help with TypeLoadException (marshaling unmanaged code)

30-Jun-07 6:05

Hi Luc.
Thanks for the replay, but it brings up some new questions.
First about the offset. The way I figured it was that offset is the number of bytes to offset. So for one int and one short the offset should be 5 bytes.. Am I getting this wrong.

I also tried changing the offset to 8, but now I am getting this error
"Cannot marshal field 'sPosition' of type 'vc1DEC_sState': The type definition of this field has layout information but has an invalid managed/unmanaged type combination or is unmarshalable."
when I am trying to marshal the IntPtr that points to the structure type 'vc1DEC_sState' in the VC1 decoder. This structure hold the structure 'sPosition' which holds another structure, which in turn holds the 'vc1_sBlk' structure in which I changed the offset of 'sIntra'.

So my C# and C have yet to agree, but I will try to somehow get the size of 'vc1_sBlk' and of 'sIntra' from the C code.
If you (or of course anyone else) have more ideas, I really need them.

10x

Luc Pattyn30-Jun-07 6:57

Re: Help with TypeLoadException (marshaling unmanaged code)

30-Jun-07 6:57

TomWolfstein wrote:
that offset is the number of bytes to offset

correct

TomWolfstein wrote:
So for one int and one short the offset should be 5 bytes

wrong. short is 2B.

Anyway, keep comparing/checking the offsets on both sides until they agree.
And of course, if you dont want to transfer some sub-struct from one side to the other,
just make it an IntPtr.
One more warning: long on CLR means 8B, not 4B (and IntPtr is either 4B or 8B depending
on Win32/Win64).

One more thought: maybe it is wise to fill the alignment gaps with explicit variables,
something like byte myReserved1; byte myReserved2;...

Sorry that's it for now; I am not available tonight...

Smile | :)

Luc Pattyn

[My Articles] [Forum Guidelines]

TomWolfstein30-Jun-07 8:51

Re: Help with TypeLoadException (marshaling unmanaged code)

30-Jun-07 8:51

Hi.
You are right about the short of course. I meant byte and got confused with the marsahlled arrays.
The problem with IntPtr (and with padding) is that if the managed struct is not defined exactly as the unmanaged struct, it gets garbled when marshaling the IntPtr to struct and I can't get the data I need.

Thankss for your help so far.
If you think of anything else later, I'll be happy to hear (read) it.
Smile | :)

Luc Pattyn30-Jun-07 14:27

Re: Help with TypeLoadException (marshaling unmanaged code)

30-Jun-07 14:27

Hi Tom,

1.
please read again my earlier post about the padding bytes, and check it for the C side.
I am rather sure it is true C/C++ inserts them. You should verify to make absolutely sure.
My claim is: a C struct {char; int;} will have a size of 8, and probably
a C struct {int; char;} will too. Please check both.

2.
where you write
[FieldOffset(5), MarshalAs(UnmanagedType.Struct, SizeConst=64)]
I would replace 5 by 8 as explained before,
and I would drop the SizeConst=64 since that applies only to arrays and strings, not structs
(so I guess you could drop the MarshalAs(UnmanagedType.Struct too since that does not
add any information)

3.
my remark about IntPtr was not to the point; it applies to classes (in case you dont need
them), it does not apply to structs. For structs whose value you dont need you can omit them,
as long as you keep the FieldOffset values correct.

(Temporarily) omitting some substructs may help you in verifying that the Marshaling of
the remainder succeeds (before you got all the details right in those omitted substructs).

4.
You can always instantiate a struct and get its Marshal.Sizeof() which means the number
of bytes that will cross the border given the current information (as in FieldOffset
and MarshalAs attributes). This sizeof should match the C-side sizeof() value.
So I suggest you add logging to both sides to actually see them.

Smile | :)

Luc Pattyn

[My Articles] [Forum Guidelines]

TomWolfstein1-Jul-07 7:16

Re: Help with TypeLoadException (marshaling unmanaged code)

1-Jul-07 7:16

Hi.
I tried what you suggested and came up with the conclusion that there is no extra padding for structs.
The 64 bytes I calculated is the same size i got from Marshal.SizeOf and from the C code.

What I also found out is that you cannot use LayoutKind.Explicit and FieldOffset in a struct that has both values and refrences (or with refrences at all).
Check out Mattias Sjögren reply here:
http://www.dotnet247.com/247reference/msgs/5/27796.aspx[^]

So I worked around (I hope) the union problem by creating a struct that contains those two fields, and now it looks like this:

/** Description: Structure defining the state required for a block.*/<br />
        [StructLayout(LayoutKind.Sequential)]<br />
        public unsafe struct vc1_sBlk<br />
            {<br />
               public vc1_eBlkType eBlkType;       /** Block type */<br />
               public byte Coded;          /** Non zero AC coefficients for Intra, non zero AC/DC for Inter */<br />
               public union u; //a workaround<br />
            };<br />
        <br />
/** A workaround for the union defined in the vc1_sBlk structure*/<br />
        [StructLayout(LayoutKind.Sequential)]<br />
        public unsafe struct union<br />
            {<br />
            <br />
                public vc1_sBlkIntra sIntra;         /** Intra block state information */<br />
                public vc1_sBlkIntra sInter;         /** Inter block state information */<br />
            };

So now these structs are completely managed and there is no need for the explicit layout anymore. Hwever, this didn't dolve the problem, which leads me to belive that I have asked the wrong question.

The original problem came up when I tried to do this:
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 6)] public vc1_sBlk[] sBlk;
And no matter what I tried to marshal 'vc1_sBlk' or 'vc1_sBlkIntra', I kept getting the exception. So i tried removing the structures (which are refrences AFAIK) from 'vc1_sBlk' and it worked. Then I returned the structures, but changed the decleration to
public vc1_sBlk sBlk;
and it also worked. Everything is accessible and works fine.
So the question is can I declare a marshalled array that has refrences in it, and if not (which I assume is the case), how can I work around it?

Tom
(Sorry I am pouring all this data on you. I am just trying to be detailed to help you help me, and anyone else who should encounter this problem).

Luc Pattyn1-Jul-07 8:34

Re: Help with TypeLoadException (marshaling unmanaged code)

1-Jul-07 8:34

Hi Tom,

I am afraid you've lost me somehow.

1.
For unions the only way out I know in C# is by using FieldOffset.
Your "struct union" is not a union at all, it is a struct with two (sequential) members.

Of course, if the members are small, and the other side is flexible (i.e. no set of registers
cast in hardware, and no software in OBJ/EXE-only form, and no implicit conversion, see below)
then you could change it in this way, but it is a change, it is no longer what was intended
originally.

If you rely on union members to occupy the same memory (e.g. when you write to one member
then read the other to obtain a bit-wise translation, such as 4 bytes to 1 int), then you
need real unions of course.

2.

TomWolfstein wrote:
The 64 bytes I calculated is the same size i got ...

I dont know which struct you refer to. If it is struct vc1_sBlkIntra, then we agree that
the size is 64B; and there is no need for padding, every member is short/ushort so they
all automatically align. If however it is vc1_sBlk from your original post

typedef struct
{
vc1_eBlkType eBlkType; /** Block type */
FLAG Coded; /** Non zero AC coefficients for Intra,
non zero AC/DC for Inter */
union
{
vc1_sBlkIntra sIntra; /** Intra block state information */
vc1_sBlkInter sInter; /** Inter block state information */
} u; /** Intra/Inter union */
} vc1_sBlk;

then depending on the size of vc1_eBlkType (lets say multiple of 4B) and FLAG (1B?)
I expect padding bytes to get the union aligned to a 4B multiple on the C/C++ side,
and also on the C# side (assuming Sequential, otherwise everything may get reordered).

3.
structs are value types, not references.
arrays are references, unless they are in a struct and carry marshaling info to tell
otherwise (ByValArray and SizeConst).

Marshaling references is complex, each pointer points to some memory block that
sooner or later may have to be a managed object. When given the choice, I tend to keep
things as simple as possible in marshaling, e.g. by putting everything as values in
one (big) struct, and by passing reference types one by one, using function calls
instead of struct members; and by avoiding structs/classes that contain references
all together (if needed, one can pass a null reference, then call a function to
accept a reference type and adapt the reference).

4.
I am getting confused about your structs; there are an unknown number of them, and they
have difficult names. So if you want detailed help, please be as specific and complete
as you can (and show both C and C# side as you did in your original post).

5.
it has been my experience one must build up the p/invoke and marshaling knowledge
by starting of with simple cases, observe them in detail, and get them to work
(compile, run without exception, pass the right data, checked by logging and/or
returning as a function result what was passed in).

And then gradually try more complex things. It is in general a bad idea to throw in all
the structs and classes at once, and have limited observability: it keeps you guessing
and probably wasting lots of time.

I tend to include logging code that dumps all the values that cross the borders,
I switch it on or off with one flag, and I leave the code in after I got it working,
so as soon as a functional change is required, it is there to help...

Hope this helps.

Smile | :)

Luc Pattyn

[My Articles] [Forum Guidelines]

TomWolfstein4-Jul-07 21:57

Re: Help with TypeLoadException (marshaling unmanaged code)

4-Jul-07 21:57

Hi.
Sorry it took me so long to answer. It's exam period..

I'll start with the end. I completley agree that it's best to learn P/Invoke and the principles of marshaling unmanaged code to managed code, and that simple examples should come before diving into a project like this.
I wish I knew all this 3 month ago when I started this. I didn't, and didn't have much choice as I am not writing this for my pleasure but as a final project for my degree. I am as unhappy with this as much as you can imagine. I want to thank you again for taking the time to explain all of this to a newbie like me.
Besides, don't they always say the best way to learn to swim is to just dive in Smile | :)

Now back to the fun (?).
1. I understand the structure I created to replace the union is not a good idea. I tried it as a way of getting the structure containing to occupy the same size it would have, had I used a union.
Now that I think the problem is somewhere else I can probably (hopefuly) change it back.

2. You are probably right here again. When I tried to offset the union 8 bytes, the alignment error disappeared and was replaced by the error caused by trying to marshal an array of structs.
Maybe this is because some of these structs have marshaled arrays in them.

4. Trust me, you are not the only obe confused by these structs, but as I said at the begining, the C source code is not mine. It is an open source implementation of the VC1 video standart. I'll be happy to send it to you if you are interested.
Meanwhile, I'll try to be clearer. I imported all of structs from the C code to C#, and marshalled all of them.
Basicaly there are two structures who contain in them, by way of value, reference and other, all of the other structures in the code.
I am sending an IntPtr from the C# code to the VC1 decoder (C code), and return that IntPtr with the address of the structure I want to access (I do it with 'out' rather than actually returning it, but the result is the same).
Right now some of the fields in the super struct (int C#) are garbage, and some are perfectly accessible. I think (and please correct me if I am wrong. there is a good chance I am), that this is because I did not import and marshall ALL of the structs, and this is causing an alignment error in the C# super struct, making it not the same size as the C code struct.

I have this struct 'vc1_sMB':

/** Description: A structure to hold macroblock data.*/<br />
        [StructLayout(LayoutKind.Sequential)]<br />
<br />
        public unsafe struct vc1_sMB<br />
        {<br />
            vc1_eMBType eMBType;            /** Macroblock type */<br />
            vc1_eACPred eACPred;            /** AC prediction status */<br />
            vc1_eBlkType eBlkType;           /** One of 8x8,8x4,4x8,4x4, or Any<br />
                                                    (Any=block based choice) */<br />
            byte OverlapFilter;      /** Overlap filter active for this macroblock */<br />
            byte Skipped;            /** Indicated macroblock is motion predicted only */<br />
            byte CBPCY;              /** Coded  block pattern, where:<br />
                                                  *  - bit 5 set means Y0 is coded<br />
                                                  *  - bit 4 set means Y1 is coded<br />
                                                  *  - bit 3 set means Y2 is coded<br />
                                                  *  - bit 2 set means Y3 is coded<br />
                                                  *  - bit 1 set means Cb is coded<br />
                                                  *  - bit 0 set means Cr is coded<br />
                                                  */<br />
            byte MVBP;               /** Motion vector block pattern, with:<br />
                                                  *  - bit3 set if dmv!=0 for Y0<br />
                                                  *  - bit2 set if dmv!=0 for Y1<br />
                                                  *  - bit1 set if dmv!=0 for Y2<br />
                                                  *  - bit0 set if dmv!=0 for Y3<br />
                                                  */<br />
            vc1_sQuant sQuant;             /** Macroblock Quantizer information */<br />
            <br />
            /***vc1_sBlk sBlk[VC1_BLOCKS_PER_MB];    /** Block level information */<br />
            [MarshalAs(UnmanagedType.ByValArray, SizeConst = 6)] public vc1_sBlk[] sBlk; <br />
            /** Block level information */<br />
            <br />
        };

As you can see in the last line, there is a marshaled array of 'vc1_sBlk' structs.
The C version of this struct is exactly the same apart ftom the marshaled array, and I left the arrays original definition commented.

'vc1_sBlk' looks like this (now marshaled like you said to implement the union):

/** Description: Structure defining the state required for a block.*/<br />
        [StructLayout(LayoutKind.Explicit, CharSet=CharSet.Ansi)]<br />
        public unsafe struct vc1_sBlk<br />
            {<br />
               [FieldOffset(0), MarshalAs(UnmanagedType.I4)] public vc1_eBlkType eBlkType;<br />
               /** Block type */<br />
               <br />
               [FieldOffset(4), MarshalAs(UnmanagedType.U1)] public byte Coded; <br />
               /** Non zero AC coefficients for Intra, non zero AC/DC for Inter */<br />
<br />
               [FieldOffset(8)] public vc1_sBlkIntra sIntra; /** Intra block state information */<br />
               [FieldOffset(8)] public vc1_sBlkIntra sInter; /** Inter block state information */<br />
            };

While it's original definition in the C code is this (FLAG is a 1B short):

typedef struct<br />
{<br />
    vc1_eBlkType        eBlkType;       /** Block type */<br />
    FLAG                Coded;          /** Non zero AC coefficients for Intra,<br />
                                            non zero AC/DC for Inter */<br />
    union<br />
    {<br />
        vc1_sBlkIntra   sIntra;         /** Intra block state information */<br />
        vc1_sBlkInter   sInter;         /** Inter block state information */<br />
    }                   u;              /** Intra/Inter union */<br />
} vc1_sBlk;

And as you've seen before 'vc1_sBlkIntra' looks like this in c#(the C code is in comments):

/** Description: Structure defining the state required for intra blocks.*/<br />
      [StructLayout(LayoutKind.Sequential)]<br />
      public unsafe struct vc1_sBlkIntra<br />
          {<br />
              ushort NZC;            /** NUMZERO and NUMCOEF (excludes DC) */ <br />
              /**** ushort was originally 'vc1_NumZeroCoef' which is a typedef in the decoder***/<br />
              short DC;             /** Quantized DC for prediction */<br />
              /***short ACTop[7];       /** Quantized AC top row for prediction */<br />
              [MarshalAs(UnmanagedType.ByValArray, SizeConst = 7)] public short[] ACTop; <br />
              /** Quantized AC top row for prediction */<br />
              /***short ACLeft[7];      /** Quantized AC left column for prediction */<br />
              [MarshalAs(UnmanagedType.ByValArray, SizeConst = 7)] public short[] ACLeft; <br />
              /** Quantized AC left column for prediction */<br />
              /***short moothRows[16]; /** Bottom two rows kept for overlap smoothing */<br />
              [MarshalAs(UnmanagedType.ByValArray, SizeConst = 16)] public short[] moothRows;<br />
              /** Bottom two rows kept for overlap smoothing */<br />
          };

And 'vc1_sBlkInter' looks like this:

/** Description: Structure defining the state required for inter blocks.*/<br />
      [StructLayout(LayoutKind.Sequential)]<br />
      public unsafe struct vc1_sBlkInter<br />
      {<br />
          /***vc1_NumZeroCoef NZC[4]; /** NUMZERO and NUMCOEF for sub-blocks (includes DC) */ <br />
          /**** ushort was originally 'vc1_NumZeroCoef' which is a typedef in the decoder***/<br />
          [MarshalAs(UnmanagedType.ByValArray, SizeConst = 4)] public ushort[] NZC; <br />
          /** NUMZERO and NUMCOEF for sub-blocks (includes DC) */<br />
          <br />
          /***vc1_sMotion sMotion[2];     /** Forward and Backward motion parameters */<br />
          [MarshalAs(UnmanagedType.ByValArray, SizeConst = 2)] public vc1_sMotion[]  sMotion;<br />
          /** Forward and Backward motion parameters */<br />
      } ;

I will not bother you with all the definitions of the other structures (everything that starts with an s, since there is nothing interesting there but normal type variables).

So 'vc1_sBlk' has in it structures that contain marshaled arrays (which like you said are references, if it matters).

All of this compiles without problem, but after I changed the offset to what you suggested, the error I got is this:
Cannot marshal field 'sPosition' of type 'vc1DEC_sState': The type definition of this field has layout information but has an invalid managed/unmanaged type combination or is unmarshalable.

(I apologize. This really is never ending)

'vc1DEC_sState' is this (only the first line is important, but I pasted all of it):

  /** Description:Structure containing the state of the decoder.**/<br />
        [StructLayout(LayoutKind.Sequential)]<br />
        public unsafe struct vc1DEC_sState<br />
        {<br />
            public vc1_sPosition sPosition;     /** Macroblock position structure */<br />
            vc1_sPicture pPicture;              /** Picture information */<br />
<br />
            public int FrameNum;               /** Current frame number */<br />
<br />
            /* Pointer to other data structures */<br />
            vc1_sMB pMB;                   /** Pointer to macroblock data */<br />
            <br />
            /* Limits */<br />
<br />
            int NumFields;              /** Number of fields per frame */<br />
            int MaxMBs;                 /** Maximum number of macroblocks */<br />
            vc1_sLevelLimit pLevelLimit;           /** Limits for current level and profile */<br />
<br />
            /* Configuration */<br />
            vc1_sSequenceLayer sSeqParams;             /** Data from the sequence layer */<br />
            vc1DEC_sPictureLayerParams sPicParams;          /** Data from the current picture layer */<br />
<br />
            byte NotFirstMode3InFrame;   /** 1 if not first mode 3 escape in frame */<br />
            /* (8.1.1.10 AC coef decoder) */<br />
            byte LevelCodeSize;          /** Level code size for mode 3 escape,<br />
                                                                per frame */<br />
            byte RunCodeSize;            /** Run code size for mode 3 escape, <br />
                                                                per frame */<br />
<br />
            byte ZigZagTableIndex;       /** Index to select zigzag table */<br />
            byte FirstFrameInStream;     /** Non-zero if this is the first frame */<br />
            byte BitplaneCodingUsed;     /** Non-zero if bitplane coding is in use */<br />
<br />
            byte FirstCodedBlock;        /** First coded block in current macroblock */<br />
<br />
            public vc1_sReferencePicture pCurrentRef;     <br />
            /** Pointer to the current reference picture into which blocks are decoded */<br />
<br />
            vc1_sMotionHist pMVHistBuffer;         /** Pointer to the motion vector history buffer */<br />
            uint FieldCount;             /** Number of fields present in the current picture */<br />
<br />
        }

And inside it, the 'sPosition' mentioned is this (again just notice that vc1_sMB is defined here):

  /** Description:<br />
         * Current position structure describing the macroblock being<br />
         * processed and the slice, field, and picture it lies in.<br />
         */<br />
        [StructLayout(LayoutKind.Sequential)]<br />
        public unsafe struct vc1_sPosition<br />
        {<br />
            vc1_ePictureType ePictureType;   /** Picture type: I, P, B or BI */<br />
            vc1_ePictureFormat ePictureFormat; /** Picture format: Progressive, Interlace Field/frame */<br />
            vc1_eProfile eProfile;       /** Profile Simple/Main/Advanced */<br />
            vc1_eMVMode eMVMode;        /** Motion vector mode for this picture */<br />
            vc1_eMVRange eMVRange;       /** Motion vector range setting for this picture */<br />
            byte BottomField;    /** 0=Top Field, 1=Bottom Field */<br />
            byte SecondField;    /** 0=First Field, 1=Second Field */<br />
            vc1_sMB pCurMB;        /** Pointer to the current macroblock */<br />
            vc1_sMB pStartMB;      /** Pointer to start of macroblock circular buffer */<br />
            vc1_sMotionHist pMVHist;       /** Current position in motion vector history buffer */<br />
            uint SizeMB;         /** Circular buffer size in macroblocks */<br />
            ushort X;              /** X macroblock offset in current slice */<br />
            ushort Y;              /** Y macroblock offset in current slice */<br />
            ushort SliceY;         /** Y macroblock offset of slice in picture */<br />
            ushort WidthMB;        /** Width in macroblocks of coded picture */<br />
            ushort HeightMB;       /** Height in macroblocks of coded picture */<br />
            public uint CodedWidth;     /** Width in pixels of coded picture */<br />
            public uint CodedHeight;    /** Height in pixels of coded picture */<br />
            uint MaxCodedWidth;  /** Max Width in pixels of coded picture */<br />
            uint MaxCodedHeight; /** Max Height in pixels of coded picture */<br />
            byte PQuant;         /** Picture quantizer */<br />
            byte BFraction;      /** BFRACTION syntax element */<br />
            byte NumRef;         /** Number of reference fields-1 */<br />
            byte RefField;       /** Reference field when NumRef==0 */<br />
            byte IntraBias;      /** Bias to add to intra blocks post transform */<br />
            byte RangeYScale;    /** Y scaling factor times 8 */<br />
            byte RangeUVScale;   /** UV scaling factor times 8 */<br />
            byte FastUVMC;       /** Fast U,V motion compensation byte */<br />
            vc1_ePictureRes ePictureRes;    /** Picture resolution scale mode */<br />
            vc1_sReferencePicture pReferenceOld;  /** Pointer to old I/P reference picture */<br />
            vc1_sReferencePicture pReferenceNew;  /** Pointer to new/current I/P */<br />
            vc1_sReferencePicture pReferenceB;    /** Reconstructed B picture */<br />
            vc1_sReferencePicture pReferenceNoIC; <br />
            /** Backup copy of reference before intensity compensation applied */<br />
<br />
            /***vc1_sScaleMV pScaleMV[2];        /** MV scaling (forward, backward) */<br />
            [MarshalAs(UnmanagedType.ByValArray, SizeConst = 2)]<br />
            public vc1_sScaleMV[] pScaleMV;        /** MV scaling (forward, backward) */<br />
            /***short pSmooth[6][64]; /** Overlap smoothing macroblock history (left) */<br />
            [MarshalAs(UnmanagedType.ByValArray, SizeConst = 6*64)] public short[] pSmooth;<br />
        } ;

All of this brings us back to the begining (did I apologize already for the length of this?)
If you remember in the begining of this post, 1e100000000000 lines above, I said that the last line of 'vc1_sMB' is the declaration of a marshaled array of 'vc1_sBlk'.
If instead of this array I declare this:
public vc1_sBlk sBlk; /** Block level information */ Then there is no error.
I can't get access to all of the fields in all of the structs, but at least there is no error.

So, finally, I suspect this array.
Am I right to suspect it?
Am I on the right way to gain normal access to the structs fields?
Would it help if I sent you the C code?

I did not intend for this to be the longest post ever. I am deeply thankful for the time you are putting into just reading all of this, not to mention trying to understand and come up with solutions.

Thanks.
Tom.

Luc Pattyn5-Jul-07 0:17

Re: Help with TypeLoadException (marshaling unmanaged code)

5-Jul-07 0:17

Hi Tom,

1.
yes I would like to have the C code in a compilable and runnable form. Please email it
using the email button below. Have some questions:
1.1. Which tool do you use to build it ? (I hope Visual Studio 6)
1.2. Does it use "normal" sizes (1B byte, 2B short, 3B int, ...) ?
1.3. Where did you get the source exactly ?
1.4. Did you change anything ? If so did you comment that in the source ?
1.5. Did you add code to print out:
- struct sizes ?
- and field offsets ? Are they what you expected ?
- field values ?

2.
I entered your C# code in a C# project, but I am missing a lot:
several vcl_### types such as vc1_eMBType; I hope most of them are int enums.
I think you best also send me the source of C# class that is supposed to call the C stuff.

3.
to access vc1DEC_sState.sPosition one must get all its members marshalled (almost) correctly;
as long as something is wrong in say vc1_sPicture, it will continue to give that kind
of run-time errors.
And that's exactly why I tend to build a marshalling job from bottom to top,
so you get something working and this gives you the energy to continue...

4.
Are you sure you need the unsafe keyword ? what is it supposed to bring you ?

5.
some of your fields are public, most of them not. Why is this ?
If you dont need to access most of the fields in C#, you can replace them by something simpler
having the same size (such as vc1_sMB in vc1DEC_sState !?!?

Greetings

Luc Pattyn

[My Articles] [Forum Guidelines]

Luc Pattyn1-Jul-07 9:14

Re: DataGrid with checkbox

1-Jul-07 9:14

Hi Tom,

FYI: in C# the following struct

[StructLayout(LayoutKind.Sequential)]<br />
public struct ccc {<br />
    int a1;<br />
    byte b1;<br />
    int a2;<br />
    byte b2;<br />
    int a3;<br />
    byte b3;<br />
}

has a Marshal.Sizeof of 24 as I expected; each byte gets followed by 3 padding bytes
to align the next int.
And that is also how I recall it from C (I did not test that now).

Smile | :)

Luc Pattyn

[My Articles] [Forum Guidelines]

validating a formula

Bojja Lakshmi30-Jun-07 2:50

Bojja Lakshmi

30-Jun-07 2:50

how i can validate a formula.

formula contains column names of a table..

pls help for this

Lakshmi

Re: validating a formula

User 665830-Jun-07 3:32

User 6658

30-Jun-07 3:32

What formula?

modified 12-Sep-18 21:01pm.

DataGrid with checkbox

-spy-30-Jun-07 2:40

-spy-

30-Jun-07 2:40

hi guyz..

Any one know how to make a datagrid with checkbox in each row(email style),
I will use it for multiple selection, I'm using c#.net 2003.. I want my application to have this feature..

tnx in advance n_n

DanB198330-Jun-07 8:24

DanB1983

30-Jun-07 8:24

Hey

Try this link for some hints:

http://www.asp.net/learn/dataaccess/tutorial12cs.aspx?tabid=63

Hope it helps

Dan

Invalid Argument exception?

$uresh $hanmugam30-Jun-07 1:58

$uresh $hanmugam

30-Jun-07 1:58

Hi all,
I have try to convert a pdf to tiff file.My below the code snippet is working fine when i open a tiff file and convert some other format..But it didn't work when i open the pdf file,it will be thrown error like "Parameter is not valid" from below the code at bold line "Image image = Image.FromStream(fromImageStream, false,true);" please help me what i did wrong.

private void button4_Click(object sender, System.EventArgs e)<br />
        {<br />
           <br />
            FileStream fstPersons = new FileStream(@"c:\\toto.tiff",<br />
                  FileMode.Create,FileAccess.Write);<br />
            BinaryWriter wrtPersons = new BinaryWriter(fstPersons);<br />
<br />
            FileStream fStream = new FileStream(@"c:\\Sample.pdf", FileMode.Open,<br />
             FileAccess.Read);<br />
            BinaryReader reader = new BinaryReader(fStream);<br />
<br />
            FileInfo info = new FileInfo(@"c:\\sample.pdf");<br />
<br />
            byte[] fromImage = null;<br />
          <br />
                fromImage = reader.ReadBytes((int)info.Length);<br />
<br />
                reader.Close();<br />
                fStream.Close();<br />
<br />
                // Read the image from the byte variable into a bitmap variable<br />
                MemoryStream fromImageStream = new MemoryStream();<br />
                fromImageStream.Write(fromImage, 0, fromImage.Length);<br />
                Image image = Image.FromStream(fromImageStream, false,true);<br />
                Bitmap bitmap = (Bitmap)image;<br />
                // Instantiate the encoder<br />
                EncoderParameters encoderParams = new EncoderParameters();<br />
                encoderParams.Param[0] = new EncoderParameter(Encoder.Quality, 50L);<br />
                ImageCodecInfo codecInfo = GetEncoderInfo("image/tiff");<br />
                MemoryStream newImage = new MemoryStream();<br />
                // Convert the image to the new format<br />
                bitmap.Save(newImage, codecInfo, encoderParams);<br />
                // Read the new image into a byte variable<br />
                byte[] data = newImage.ToArray();<br />
<br />
                wrtPersons.Write(data);<br />
<br />
                fstPersons.Close();<br />
                wrtPersons.Close();<br />
     <br />
        }<br />
<br />
 <br />
<br />
       private static ImageCodecInfo GetEncoderInfo(String mimeType)<br />
        {<br />
           int j;<br />
           ImageCodecInfo[] encoders;<br />
           encoders = ImageCodecInfo.GetImageEncoders();<br />
           for(j = 0; j < encoders.Length; ++j)<br />
           {<br />
            if(encoders[j].MimeType == mimeType)<br />
             return encoders[j];<br />
           }<br />
           return null;<br />
        }<br />

thanks in advance

Re: Invalid Argument exception? [modified]

Luc Pattyn30-Jun-07 3:07

30-Jun-07 3:07

Stream operations are very much like good old file operations:
if you write a file, then want to read what has been written, you must either close and reopen,
OR somehow "rewind" the file. Look for an appropriate stream method
(or property) to do this...

Smile | :)

Luc Pattyn

[My Articles] [Forum Guidelines]

reading file error

tauras8130-Jun-07 1:41

tauras81

30-Jun-07 1:41

hi while reading a file named with underscore i am having error illegal characters found how can i remove it and how to find the particular position in a file

Re: reading file error

Luc Pattyn30-Jun-07 1:58

30-Jun-07 1:58

please be specific, show the error messages and Exception.ToString(), show the code,
tell us which parts work and which dont...

(so read and apply the forum guidelines !)

Smile | :)

Luc Pattyn

[My Articles] [Forum Guidelines]

array of type label

Glen Harvy29-Jun-07 23:47

Glen Harvy

29-Jun-07 23:47

Hi,

I have the following hardcoded labels:

this.labelAWeekAgo1.Text = lastWeek.ToString();
this.labelAWeekAgo2.Text = lastWeek.ToString();
..
this.labelAWeekAgo10.Text = lastWeek.ToString();

with each individual label contained within a loop that contains a function with the result generating "lastweek".

How can I code the label variable that changes programatically ie the number at the end of the labels name depending on which pass thru the loop I'm in eg

for i=0 etc
this.labelAWeekAgo[i].Text = lastweek.ToString();

Glen Harvy

Sathesh Sakthivel29-Jun-07 23:53

Sathesh Sakthivel

29-Jun-07 23:53

Use For loop

for(i=0;i<9;i++)
{
//your code
}

or you can use foreach which is more easy.

Details[^]

Regards,

Satips. Rose | [Rose]

Glen Harvy30-Jun-07 0:09

Glen Harvy

30-Jun-07 0:09

Thanks for the prompt reply.

I'm trying to avoid having to do the following for each hardcoded label:

Label[] lbThisWeek = new Label[10];
for (int i = 0; i < lbThisWeek.Length; i++)
{
lbThisWeek[i] = new Label();
}
lbThisWeek[0] = this.labelThisweek1;
lbThisWeek[1] = this.labelThisweek2;
lbThisWeek[2] = this.labelThisweek3;
lbThisWeek[3] = this.labelThisweek4;
lbThisWeek[4] = this.labelThisweek5;
lbThisWeek[5] = this.labelThisweek6;
lbThisWeek[6] = this.labelThisweek7;
lbThisWeek[7] = this.labelThisweek8;
lbThisWeek[8] = this.labelThisweek9;
lbThisWeek[9] = this.labelThisweek10;

Doing this allows me to use the loop to perform my actions but it seems I have to create separate arrays for each item as I can't see how you pass [i] to a hardcoded control name.

Glen Harvy

Luc Pattyn29-Jun-07 23:57

29-Jun-07 23:57

Hi,

create a collection of your labels (an array, an ArrayList, a List, whatever),
and foreach them.

If its all the labels on a form, you could also foreach your form's controls as in:

foreach (Control c in myForm.Controls) {
    Label lbl=c as Label;
    if (lbl!=null) doSomethingToLabel(lbl);
}

Finally you could use reflection to find all the labels with a specific name syntax,
but that seems overkill (and expensive) in this case.

Smile | :)

Luc Pattyn

[My Articles] [Forum Guidelines]

Glen Harvy30-Jun-07 0:11

Glen Harvy

30-Jun-07 0:11

Thanks,

Yes - it looks like an array for each label concerned is the easiest - thank heavens for search & replace.

Glen Harvy

Re: no Replace !!

Luc Pattyn30-Jun-07 1:14