bei v1 hat das auch noch super geklapp,
da das ganze eine feste structur hat und hier sehr gut erläutert ist http://de.wikipedia.org/wiki/ID3-Tag#ID3v1..

bei v2 bin ich dann hängen geblieben... ich bin auf die www.id3.org gestoßen, allerdings rafe ich das nicht so ganz.

Kann mir nochmal jemand tipps geben, (in deutsch bitte) wie die id3v2 aufgebaut sind?

Danke schön

Viel Spaß

ID3 hab ich schon mal erfolgreich ausgelesen (3 chars) dannach 2 ints (41 kommt zwar net ganz hin aber okay)... doch danach wirds dann naja ... weiß auch net

okay ich glaube ich komme so langsamm dahinter

naja das mit den bytetypen könnt ihr mir tortzdem nochmal sagen

Hab hier eine gute Anleitung über den Aufbau von mp3-Headern gefunden.

Aber was du für den Anfang erstmal brauchst, ist glaube ich so etwas wie eine CBitSet-Klasse, die dir hilft, die einzelnen Bits auszulesen.

Ansonsten: Kennst du sowas?:

struct Mp3Header
{
    unsigned long SyncWord : 12;
    unsigned long MpegVersion : 1;
    unsigned long MpegLayer : 2;
    unsigned long ProtectionBit : 1;
    unsigned long BitRate : 4;
};

Die Zahlen hinter dem Variablen-Namen geben die Bitzahl an, die die Variable einnimmt. Hier ein bisschen von Microsoft erklärt.

Wie ich das sehe, ist der Mp3-Header 32 Byte lang. Ich glaub, du brauchst echt so eine BitSet-Klasse. Hatte mal eine gemacht, ist aber weg...
Kleiner Ansatz:

class CBitSet
{
    public:
		CBitSet()
		{
			m_iSize = 0;
			m_iCurBit = 0;
			m_pData = NULL;
		}

		CBitSet( CHAR* pData, ULONG Size )
		{
			m_iSize = Size;
            m_iCurBit = 0;
            m_pData = new char [m_iSize];
            CopyMemory( m_pData, pData, m_iSize );
		}

		~CBitSet()
		{
			Reset();
		}

        void Reset()
        {
            delete [] m_pData;
			m_pData = NULL;
            m_iSize = 0;
            m_iCurBit = 0;
        }

        void Set( CHAR* pData, ULONG Size )
        {
            Reset();
            m_iSize = Size;
            m_iCurBit = 0;
            m_pData = new char [m_iSize];
            CopyMemory( m_pData, pData, m_iSize );
        }

        BOOL Seek( ULONG BitNr )
        {
            if ( BitNr >= m_iSize*8 )
                return FALSE;
            m_iCurBit = BitNr;
            return TRUE;
        }

        ULONG GetBits( ULONG BitCount )
        {
            ...
        }

		ULONG Skip( ULONG BitCount )
		{
			m_iCurBit += BitCount;
			if ( m_iCurBit >= m_iSize*8 )
				m_iCurBit = m_iSize*8;
			return m_iCurBit;
		}

    protected:
        ULONG m_iSize;
        ULONG* m_pData;
        ULONG m_iCurBit;
};

...

ULONG SnycWord = BitSet.GetBits( 4 );
ULONG MpegVersion = BitSet.GetBits( 1 );
ULONG MpegLayer = BitSet.GetBits( 2 );
...

Zu mehr bin ich grad nicht in der Lage, es ist schließlich erst *gähn* kurz nach neun.
Wenn du nicht weiterkommst, sag nochmaluzzzzzzzzzzzzzzzzzdddddddddddddddddddd Bescheid (ups, meine Katze ist übers 'z' und 'd' gelaufen... 8 Wochen alt, seit gestern Abend meine... )

Edit: Auf Codeproject gibts guten Source! http://codeproject.com/audio/mp3fileinfo.asp

*warum kann man ID3v2 nicht mal einfach für die progger machen :-P*

hehe^^ find ich auch Aber die Mp3-Datei soll halt möglichst klein und flexibel sein.

download123 schrieb:

wie ist das jetzt mit dem bit

Naja... Den Post über dir hast du schon gesehen, oder?

ID3v2 wäre mal ne anregung für ein tutorial... (wie mache ichs richtig am besten noch mit beispiel code)

Mal sehen ob ichs halbwegs verstanden habe...
die zahlen hinter dem struct geben die größe davon in bit an ... der rest wird mit nullen gefüllt richtig?..

nochmal edit....

wie lese ich das ganze in mein struct ein
bzw. wie kriege ich das da rein...
ach ist das ein müll

jetzt muss ich nur noch die doofe doku raffen... und das wie ichs gescheit
einlese... und dann hab ichs (was ne hoffnung :-P)

edit x tausend..

langsam komm ich dahinter :p

Du weißt ja bestimmt, dass im Arbeitsspeicher gaaaaanz viele 0en und 1en aneinanderliegen. Eine 0 bzw. eine 1 ist dabei ein Bit. 8 Bit fasst man zu einem Char zusammen, 16 Bit zu einem Word und 32 Bit zu einem Long.

Angenommen, du deklarierst eine 8-Bit-Variable und setzt sie auf 0, etwa so:

char a;
a = 0;

Dann sehen diese 8 Bit im Arbeitsspeicher (dick markiert) so aus:
...0101011010100100000000010101000100110101...
Setzt du sie auf 67, sehen sie so aus (nur der Ausschnitt mit den 8 Bit):
01000011
Das bekommst du raus, indem du den Windows-Rechner startest, im Modus Dez die Zahl 67 eingibst und in den Modus Binschaltest.

So.
Wie irgendwo schon gesagt, besteht der Mp3-Header aus 32 Bit. und könnte z.B. so aussehen:
11101010101010101101010010110010
Praktischerweise passen diese Bits alle genau in eine Variable vom Typ Long.
Also liest du als erstes aus der Datei die 32 Bit, die als Header fungieren, in eine Long-Variable ein.

Btw: Hast du schon mal was vom Shiften gehört? Und vom &-Operator?
Wenn nicht:
Wenn du die Bits oben um 3 nach rechts shiftest, sehen sie so aus: 00011101010101010101101010010110.
Wenn du den 8-Bit-Wert 01101010 mit 00001111 &-operierst, kommt 00001010 raus.

Also, du liest den Header ein, und willst die Mpeg-Version haben (Bit 12).
Also nimmst du deinen Long-Wert (=Header), shiftest ihn 12 nach rechts und operierst ihn mit & 1.

long Header;
long MpegVersion = (Header>>12)&1.

So, keine Lust mehr... Verstanden?

der IDEv2 Header besteht aus 80 bit (10 byte :-P) klugscheiß...

ich habe schon ne menge rausbekommen ich kann schon bist unsynchronisation auslesen...
bisher habe ich erstmal den gesamten header... (alle 10 byte) in einen string eingelesen...

dann die ersten 3 char auf "IDE" überprüft .. danach weggeschmissen...
die nächsten zwei in ints getan, (versionsnummer 4.0) passt... den nächsten char besorg ich mir die ersten zwei bit (mit (c & 0x01) ) etc. (um zu checken ob unsynchronisation)...

jetzt ist die frage ob ich die size in ints packen kann

in der doku heißt es

ID3 size 4 * %0xxxxxxx

das heißt 4 byte size...

nur sind das int? bzw. kann ich den inhalt "%0xxxxxxx" einfach in einen int reinschmeißen?(ich kanns halt leider nicht überprüfen)

habs einfach mal ausprobiert...

0 0 17 49 also so vom gefühl her könntes meiner Meinung nach hinkommen

aber klärt mich auf...

mit der 1 seite des gesamttags,

und mit der framesize
zitate
"and
one three byte size field"... schmeiße ich das auch in einfach in 3 ints

... kann mir jemand helfen ... wie mache ich das mti den sizen

... naja okay ... die size des gesamt headers könnte ich (4 x 8 bit = 32 ) in einen unsignet long packen

aber wie mach ich das momentan ist es in 4 chars wie pack ich die in einen long... und was mache ich mit den 3 byte size angabe einer frame?

Aber ich habe jetzt wirklich ein problem was ich nicht hinbekomme

die size
ich habe 4 byte ... in 4 char eingelesen...
jetzt muss ich die info irgendwie zur verarbeitung in eine zahl (einen int) verwandeln

problem 1. die bytes fangen jeweils mit null an (die null scheint nicht zur info zu gehören) [ 4 * %0xxxxxxx]
wie berücksichtige ich das bzw. generell wie packe ich 4 char in ein int?

und das ganze nochmal mit den frame hedern [ one three byte size field] da sinds 3 byte... wie packe ich das in einen header...

Danke wenn mir jemand helfen kann *ich verzweifle*

char Bytes[4];
int Big;

//Entweder...
CopyMemory( &Big, Bytes, 4 );

// oder...
Big = *((int*)Bytes);

// oder...
Big = Big[3]<<24 | Big[2]<<16 | Big[1]<<8 | Big[0];

und wie mach ich das mit nur 3 byte size bereich?..

ich bin mir da noch net so ganz sicher ob das für id3 so geht.. (gerade auch wegen den vorgegeben 0 en an jedem byteanfang im 4byte header

Hier die Ausschnitte

The ID3v2 tag header, which should be the first information in the
file, is 10 bytes as follows:

ID3/file identifier "ID3"
ID3 version $02 00
ID3 flags %xx000000
ID3 size 4 * %0xxxxxxx

The headers of the frames are similar in their construction. They
consist of one three character identifier (capital A-Z and 0-9) and
one three byte size field, making a total of six bytes.

*ich hoffe das wars was du meinstes

Gut, jetzt wüsste ich gerne, wie weit du mit dem Einlesen gekommen bist. Soweit ich das verstanden hab, kannst du schon das "ID3" einlesen, die ID3-Version und die ID3-Flags.

The ID3v2 tag header, which should be the first information in the
file, is 10 bytes as follows:

ID3/file identifier "ID3"
ID3 version $02 00
ID3 flags %xx000000
ID3 size 4 * %0xxxxxxx

Zum Einlesen würde ich eine Struktur festlegen, und da reinlesen.

#pragma strict

struct ID3V2HEADER
{
    char ID[3];
    char MajorVersion;
    char MinorVersion;
    char Flags;
    char Size[4];
};

ID3V2HEADER Header;
ReadFile( hFile, &Header, 10, &Dummy, NULL );

Die Berechnung der Size ist nicht so einfach. Das oberste Bit jedes Bytes ist 0 und wird ignoriert.
Ich würds so machen (keine Garantie auf Richtigkeit ):

ULONG RealTagSize = Header.Size[0] | Header.Size[1]<<7 | Header.Size[2]<<14 | Header.Size[3]<<21;

Dann haste immerhin schonmal den Header. Wo kommst du jetzt nicht weiter?

Und bitte benutze für deine Fragen deutliche, eindeutige deutsche Sätze!

struct ID3v2_Header
{
    int version[2];
    bool unsynchronisation;
    bool compression;
    int size;
};

in der Funktion lese ich die ersten 10 byte aus und schreibe sie in einen String

//ifs ist ein ifstream mit geöffnerter Datei
string tag;
    for(int i=1; i <= 10; i++)
    {
        char abl;
        ifs >> abl;
        tag+=abl;
    }

danach werte ich die chars nach und nach aus und "fülle" das Struct, und lösche die char's aus dem string.
Das klappt bis zur Size. Die bekomme ich irgendwie nicht so ganz.

ich habe jetzt versucht es nach deinem Code in Nummern zu packen.

ULONG RealTagSize = Header.Size[0] | Header.Size[1]<<7 | Header.Size[2]<<14 | Header.Size[3]<<21;

Was ist ein ULONG? ein unsigned long? bei mir erkennt der Compiler das nicht.

Sieht in meinem Code so aus

Data.size = tag[1] | tag[2]<<7 | tag[3]<<14 | tag[4]<<21;

Data ist ein object des oberen ID3v2_Header structs.

Allerdings bekomme ich dann einen Wert a la 103038976

Badestrand schrieb:

struct ID3V2HEADER
{
char ID[3];
char MajorVersion;
char MinorVersion;
char Flags;
char Size[4];
};

Warum liest du nicht einfach die ersten 10 Bytes in diese Struktur ein? Dann kannst du sofort die einzelnen Member-Variablen ansprechen und weißt, welches Byte welche Bedeutung hat.

Ja, ULONG steht für unsigned long. Halt einfach eine 32-Bit-Variable für die positiven Zahlenwerte. Was kommt denn dabei raus, wenn du das mit meiner Methode machst?

kommt aber die selbe zahl als size raus,
Ich wills deshalb nicht gleich in ein struct reinlesen, weil ich dann 2 structs bräuchte was es nicht übersichtlicher macht.

aber letztlich machts auch keinen unterschied ob mans in 10 char oder in ein struct das aus 10 char besteht oder?

Also es besteht leider weiterhin das problem, das die Zahl für die Size zu groß ist es ist immernoch 103038976
bzw. ist das zu viel?

Kannst du mal die Hauptteile deines Codes posten? Einlesen, und size-Berechnung?

Edit: Btw: Ist definitiv zu viel!

ifstream ifs(path,ios_base::binary); //,ios_base::binary
    if (! ifs)
    {
        return -2;
    }

char tag[10];
    for(int i=0; i < 10; i++)
    {
        ifs >> tag[i];
    }
if((tag[0]=='I') && (tag[1]=='D') && (tag[2]=='3'))
    {
        cout << "ID3v2 tag"<< endl;
        ID3v2_Header Data;
...

und dann etwas weiter unten size
data.size ist ein unsigned long

Data.size = tag[6] | tag[7]<<7 | tag[8]<<14 | tag[9]<<21;

Allerdings stimmt es "zusammengefasst"(in einen int bzw. unsigned int gemacht) halt nicht. Werden die Miteinander multipliziert... oder wie ergibt sich die Size?

?

immernoch etwas hoch oder?