C# to VB6

[Chris001]

Hello, the past few weeks I have been looking for a way to find out whether an AVI video has been encoded with options like Quarter Pixel, S(GMC)-VOP, B-VOP, etc. Unfortunately there is no information or example code in VB6 that shows how to get this information from an AVI video.

On doom9.org the author of an application named MPEG4 Modifier told me to look at the source code, but it's written in C# and I don't understand that language. Spending months on learning a new language (which I will probably never use) just to get some source code is a bit too much.

Is there somebody here who knows both languages and maybe wants to translate the parts I need to VB6 ?

The parts I need are ParseVOL() and ParseVOP(). The flag for Quarter Pixel is stored in vol.quarterpel, and the frame type is in vop.vop_type.

Thank you.

[Pirate]

(which I will probably never use)

Sorry but this is NOT true . If you learn C# , you'd forget VB6 at all . I know this never answered your question but i just couldn't ignore this .

[jmcilhinney]

There's a link to a C# to VB.NET converter in my sig. Once you have VB.NET code you may well be able to convert a lot of it to VB6 yourself.

[dee-u]

Sorry but this is NOT true . If you learn C# , you'd forget VB6 at all . I know this never answered your question but i just couldn't ignore this .

Perhaps you are right since I am already using // to comment in VB6.0!

[Chris001]

Thanks jmcilhinney, I tried the C# to VB.NET converter, but it gives me this error message:

An error occured while processing your code: The number style AllowHexSpecifier is not supported on floating point data types.

I have no idea what it means.

[jmcilhinney]

Where in the code does this occur? Post the relevant code, but post just the relevant section in VBCODE tags so it's visible in your post rather than downloading a file.

[Chris001]

Sorry, I should have mentioned that. It shows the error message on the C# to VB.NET converter webpage.



The problem is also that I don't really know which part of the code I exactly need. C# is like Chinese to me, that's why I posted the complete code.

I think this is what I need. It's still a lot of code though.

private byte[] ParseVOP(byte[] data, bool modify) {
            BitStream bits, bitsOut;
            VOLInfo vol = _vol;
            VOPInfo vop = new VOPInfo();
 
            bits = new BitStream(data);
            if (modify) {
                bitsOut = new BitStream(data.Length);
                bits.CopyDest = bitsOut;
            }
            else {
                bitsOut = null;
            }
 
            bits.Copy(32);
            vop.coding_type = bits.Copy(2);
 
            while (bits.Copy(1) == 1) {
                vop.modulo_time_base++;
            }
            bits.Copy(1);
 
            vop.time_inc = bits.Copy(vol.time_inc_bits);
            bits.Copy(1);
 
            vop.coded = ToBool(bits.Copy(1));
            vop.vop_type = vop.coded ? (VOPType)vop.coding_type : VOPType.N_VOP;
            vop.is_reference_vop = vop.coded && (vop.vop_type != VOPType.B_VOP);
            if (vop.coded) {
                if (vol.newpred_enable) {
                    int vop_id_bits = Math.Min(vol.time_inc_bits + 3, 15);
 
                    bits.Copy(vop_id_bits);
                    if (bits.Copy(1) == 1) {
                        bits.Copy(vop_id_bits);
                    }
                    bits.Copy(1);
                }
 
                if ( (vol.shape != (uint)VOLShape.BinaryOnly) &&
                    ( (vop.coding_type == (uint)VOPType.P_VOP) ||
                    ( (vop.coding_type == (uint)VOPType.S_VOP) && (vol.sprite_enable == (uint)Sprite.GMC) ) ) )
                {
                    bits.Copy(1);
                }
 
                if ( vol.reduced_resolution_enable &&
                    (vol.shape == (uint)VOLShape.Rectangular) &&
                    ( (vop.coding_type == (uint)VOPType.P_VOP) || (vop.coding_type == (uint)VOPType.I_VOP) ) )
                {
 
                    bits.Copy(1);
                }
 
                if (vol.shape != (uint)VOLShape.Rectangular) {
                    if ( !( (vol.sprite_enable == (uint)Sprite.Static) &&
                        (vop.coding_type == (uint)VOPType.I_VOP) ) )
                    {
                        // 56 bits
                        bits.Copy(32);
                        bits.Copy(24);
                    }
                    bits.Copy(1);
                    if (bits.Copy(1) == 1) {
                        bits.Copy(8);
                    }
                }
 
                if (vol.shape != (uint)VOLShape.BinaryOnly) {
                    bits.Copy(3);
                    if (vol.interlaced) {
                        vop.top_field_first = ToBool(bits.Read(1));
                        if (modify) {
                            bitsOut.Write( (_tff ? 1U : 0U) , 1);
                        }
                        bits.Copy(1);
                    }
                }
 
                if ( (vol.sprite_enable != (uint)Sprite.None) &&
                    (vop.coding_type == (uint)VOPType.S_VOP) )
                {
                    vop.warping_points_used = 0;
 
                    for (int i = 1; i <= vol.sprite_warping_points; i++) {
                        bool x_used = CopyWarpingCode(bits);
                        bool y_used = CopyWarpingCode(bits);
 
                        if (x_used || y_used) {
                            vop.warping_points_used = (uint)i;
                        }
                    }
                }
            }
 
            if (modify) {
                while (bits.Remaining > 0) {
                    bits.Copy(Math.Min(bits.Remaining, 32));
                }
            }
 
            _vop = vop;
            return modify ? bitsOut.GetBytes(bitsOut.Position / 8) : null;
        }
 
        private byte[] ParseVOL(byte[] data, bool modify) {
            BitStream bits, bitsOut;
            VOLInfo vol = new VOLInfo();
 
            bits = new BitStream(data);
            if (modify) {
                bitsOut = new BitStream(data.Length + 16);
                bits.CopyDest = bitsOut;
            }
            else {
                bitsOut = null;
            }
 
            bits.Copy(32);
            bits.Copy(9);
 
            if (bits.Copy(1) == 1) {
                vol.ver_id = bits.Copy(4);
                bits.Copy(3);
            }
            else {
                vol.ver_id = 1;
            }
 
            // Read PAR info
            vol.aspect_ratio = bits.Read(4);
            if (vol.aspect_ratio == (uint)PARType.Custom) {
                vol.par_width  = bits.Read(8);
                vol.par_height = bits.Read(8);
            }
 
            // Write new PAR info
            if (modify) {
                bitsOut.Write((uint)_parInfo.Type, 4);
                if (_parInfo.Type == PARType.Custom) {
                    bitsOut.Write(_parInfo.Width, 8);
                    bitsOut.Write(_parInfo.Height, 8);
                }
            }
 
            if (bits.Copy(1) == 1) {
                bits.Copy(3);
                if (bits.Copy(1) == 1) {
                    // 79 bits
                    bits.Copy(32);
                    bits.Copy(32);
                    bits.Copy(15);
                }
            }
 
            vol.shape = bits.Copy(2);
            if ((vol.ver_id != 1) && (vol.shape == (uint)VOLShape.Grayscale)) {
                bits.Copy(4);
            }
            bits.Copy(1);
 
            vol.time_inc_res = bits.Copy(16);
            vol.time_inc_bits = Math.Max(BitsUsed(vol.time_inc_res - 1), 1);
            bits.Copy(1);
 
            if (bits.Copy(1) == 1) {
                bits.Copy(vol.time_inc_bits);
            }
 
            if (vol.shape != (uint)VOLShape.BinaryOnly) {
                if (vol.shape == (uint)VOLShape.Rectangular) {
                    bits.Copy(29);
                }
 
                vol.interlaced = ToBool(bits.Copy(1));
                bits.Copy(1);
 
                vol.sprite_enable = bits.Copy( vol.ver_id == 1 ? 1 : 2 );
                if (vol.sprite_enable != (uint)Sprite.None) {
                    if (vol.sprite_enable == (uint)Sprite.Static) {
                        // 56 bits
                        bits.Copy(32);
                        bits.Copy(24);
                    }
 
                    vol.sprite_warping_points = bits.Copy(6);
                    if (vol.sprite_warping_points > 4) {
                        throw new Exception("Invalid VOL (too many warping points)");
                    }
 
                    bits.Copy(3);
                    if (vol.sprite_enable == (uint)Sprite.Static) {
                        bits.Copy(1);
                    }
                }
 
                if ((vol.ver_id != 1) && (vol.shape != (uint)VOLShape.Rectangular)) {
                    bits.Copy(1);
                }
 
                if (bits.Copy(1) == 1) {
                    bits.Copy(8);
                }
 
                if (vol.shape == (uint)VOLShape.Grayscale) {
                    bits.Copy(3);
                }
 
                vol.mpeg_quant = ToBool(bits.Copy(1));
                if (vol.mpeg_quant) {
                    vol.load_intra_quant_mat = ToBool(bits.Copy(1));
                    if (vol.load_intra_quant_mat) {
                        vol.intra_quant_mat = CopyQuantMatrix(bits);
                    }
 
                    vol.load_inter_quant_mat = ToBool(bits.Copy(1));
                    if (vol.load_inter_quant_mat) {
                        vol.inter_quant_mat = CopyQuantMatrix(bits);
                    }
 
                    if (vol.shape == (uint)VOLShape.Grayscale) {
                        throw new Exception("Grayscale matrix isn't supported");
                    }
                }
 
                if (vol.ver_id != 1) {
                    vol.quarterpel = ToBool(bits.Copy(1));
                }
 
                if (bits.Copy(1) == 0) {
                    throw new Exception("Complexity estimation isn't supported");
                }
                bits.Copy(1);
 
                if (bits.Copy(1) == 1) {
                    bits.Copy(1);
                }
 
                if (vol.ver_id != 1) {
                    vol.newpred_enable = ToBool(bits.Copy(1));
                    if (vol.newpred_enable) {
                        bits.Copy(3);
                    }
                    vol.reduced_resolution_enable = ToBool(bits.Copy(1));
                }
 
                if (bits.Copy(1) == 1) {
                    throw new Exception("Scalability isn't supported");
                }
            }
            else {
                if (vol.ver_id != 1) {
                    if (bits.Copy(1) == 1) {
                        throw new Exception("Scalability isn't supported");
                    }
                }
                bits.Copy(1);
            }
 
            // Check padding (padding should be present even if the data already ends on
            // a byte boundary, but if there's no padding we will just ignore it)
            if ((bits.Remaining < 0) || (bits.Remaining > 8)) {
                throw new Exception("Invalid VOL");
            }
            bits.Copy(bits.Remaining);
 
            _vol = vol;
            return modify ? bitsOut.GetBytes(bitsOut.Position / 8) : null;
        }

[jmcilhinney]

I suggest that you just try to convert small chunks at a time on those converters. First of you could remove the contents of the method and just convert the declaration, then the variable declarations at the top, then each little chunk one at a time. That way you can build up your VB.NET code bit by bit and deal with each specific issue as it arises. Honestly, C# is not really all that different to VB.NET, or at least the translation from one to the other is relatively clear once you know a few basic rules. Like so many things, you just need to break the large problem down into a series of smaller problems.

[Chris001]

Thanks for your help, jmcilhinney

[Slaine]

You could always try compiling it then decompiling it to VB.Net using something like Reflector

That should get you something to start from.

[Windblossom]

hi, I'm having the exact sample problem converting from C# to VB.NET...
An error occured while processing your code: The number style AllowHexSpecifier is not supported on floating point data types

It's failing at these two lines:
int data_len = (waveInput.Length - 0x2c);
Buffer.BlockCopy(waveInput, 0x2c, data, 0, data_len);

I don't know C#.NET at all and not much of VB.NET
Can anyone help me?

[Windblossom]

sorry, same problem*