move the sources from the dead coreforge server

git-svn-id: https://matroska.svn.sourceforge.net/svnroot/matroska/trunk/libmatroska@1 a6f86f6d-0131-4f8e-9e7b-e335508773d5
This commit is contained in:
Steve Lhomme 2010-02-18 08:13:06 +00:00
commit 2ad6f1d24b
118 changed files with 23703 additions and 0 deletions

1944
ChangeLog Normal file

File diff suppressed because it is too large Load Diff

504
LICENSE.LGPL Normal file
View File

@ -0,0 +1,504 @@
GNU LESSER GENERAL PUBLIC LICENSE
Version 2.1, February 1999
Copyright (C) 1991, 1999 Free Software Foundation, Inc.
59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
Everyone is permitted to copy and distribute verbatim copies
of this license document, but changing it is not allowed.
[This is the first released version of the Lesser GPL. It also counts
as the successor of the GNU Library Public License, version 2, hence
the version number 2.1.]
Preamble
The licenses for most software are designed to take away your
freedom to share and change it. By contrast, the GNU General Public
Licenses are intended to guarantee your freedom to share and change
free software--to make sure the software is free for all its users.
This license, the Lesser General Public License, applies to some
specially designated software packages--typically libraries--of the
Free Software Foundation and other authors who decide to use it. You
can use it too, but we suggest you first think carefully about whether
this license or the ordinary General Public License is the better
strategy to use in any particular case, based on the explanations below.
When we speak of free software, we are referring to freedom of use,
not price. Our General Public Licenses are designed to make sure that
you have the freedom to distribute copies of free software (and charge
for this service if you wish); that you receive source code or can get
it if you want it; that you can change the software and use pieces of
it in new free programs; and that you are informed that you can do
these things.
To protect your rights, we need to make restrictions that forbid
distributors to deny you these rights or to ask you to surrender these
rights. These restrictions translate to certain responsibilities for
you if you distribute copies of the library or if you modify it.
For example, if you distribute copies of the library, whether gratis
or for a fee, you must give the recipients all the rights that we gave
you. You must make sure that they, too, receive or can get the source
code. If you link other code with the library, you must provide
complete object files to the recipients, so that they can relink them
with the library after making changes to the library and recompiling
it. And you must show them these terms so they know their rights.
We protect your rights with a two-step method: (1) we copyright the
library, and (2) we offer you this license, which gives you legal
permission to copy, distribute and/or modify the library.
To protect each distributor, we want to make it very clear that
there is no warranty for the free library. Also, if the library is
modified by someone else and passed on, the recipients should know
that what they have is not the original version, so that the original
author's reputation will not be affected by problems that might be
introduced by others.
Finally, software patents pose a constant threat to the existence of
any free program. We wish to make sure that a company cannot
effectively restrict the users of a free program by obtaining a
restrictive license from a patent holder. Therefore, we insist that
any patent license obtained for a version of the library must be
consistent with the full freedom of use specified in this license.
Most GNU software, including some libraries, is covered by the
ordinary GNU General Public License. This license, the GNU Lesser
General Public License, applies to certain designated libraries, and
is quite different from the ordinary General Public License. We use
this license for certain libraries in order to permit linking those
libraries into non-free programs.
When a program is linked with a library, whether statically or using
a shared library, the combination of the two is legally speaking a
combined work, a derivative of the original library. The ordinary
General Public License therefore permits such linking only if the
entire combination fits its criteria of freedom. The Lesser General
Public License permits more lax criteria for linking other code with
the library.
We call this license the "Lesser" General Public License because it
does Less to protect the user's freedom than the ordinary General
Public License. It also provides other free software developers Less
of an advantage over competing non-free programs. These disadvantages
are the reason we use the ordinary General Public License for many
libraries. However, the Lesser license provides advantages in certain
special circumstances.
For example, on rare occasions, there may be a special need to
encourage the widest possible use of a certain library, so that it becomes
a de-facto standard. To achieve this, non-free programs must be
allowed to use the library. A more frequent case is that a free
library does the same job as widely used non-free libraries. In this
case, there is little to gain by limiting the free library to free
software only, so we use the Lesser General Public License.
In other cases, permission to use a particular library in non-free
programs enables a greater number of people to use a large body of
free software. For example, permission to use the GNU C Library in
non-free programs enables many more people to use the whole GNU
operating system, as well as its variant, the GNU/Linux operating
system.
Although the Lesser General Public License is Less protective of the
users' freedom, it does ensure that the user of a program that is
linked with the Library has the freedom and the wherewithal to run
that program using a modified version of the Library.
The precise terms and conditions for copying, distribution and
modification follow. Pay close attention to the difference between a
"work based on the library" and a "work that uses the library". The
former contains code derived from the library, whereas the latter must
be combined with the library in order to run.
GNU LESSER GENERAL PUBLIC LICENSE
TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
0. This License Agreement applies to any software library or other
program which contains a notice placed by the copyright holder or
other authorized party saying it may be distributed under the terms of
this Lesser General Public License (also called "this License").
Each licensee is addressed as "you".
A "library" means a collection of software functions and/or data
prepared so as to be conveniently linked with application programs
(which use some of those functions and data) to form executables.
The "Library", below, refers to any such software library or work
which has been distributed under these terms. A "work based on the
Library" means either the Library or any derivative work under
copyright law: that is to say, a work containing the Library or a
portion of it, either verbatim or with modifications and/or translated
straightforwardly into another language. (Hereinafter, translation is
included without limitation in the term "modification".)
"Source code" for a work means the preferred form of the work for
making modifications to it. For a library, complete source code means
all the source code for all modules it contains, plus any associated
interface definition files, plus the scripts used to control compilation
and installation of the library.
Activities other than copying, distribution and modification are not
covered by this License; they are outside its scope. The act of
running a program using the Library is not restricted, and output from
such a program is covered only if its contents constitute a work based
on the Library (independent of the use of the Library in a tool for
writing it). Whether that is true depends on what the Library does
and what the program that uses the Library does.
1. You may copy and distribute verbatim copies of the Library's
complete source code as you receive it, in any medium, provided that
you conspicuously and appropriately publish on each copy an
appropriate copyright notice and disclaimer of warranty; keep intact
all the notices that refer to this License and to the absence of any
warranty; and distribute a copy of this License along with the
Library.
You may charge a fee for the physical act of transferring a copy,
and you may at your option offer warranty protection in exchange for a
fee.
2. You may modify your copy or copies of the Library or any portion
of it, thus forming a work based on the Library, and copy and
distribute such modifications or work under the terms of Section 1
above, provided that you also meet all of these conditions:
a) The modified work must itself be a software library.
b) You must cause the files modified to carry prominent notices
stating that you changed the files and the date of any change.
c) You must cause the whole of the work to be licensed at no
charge to all third parties under the terms of this License.
d) If a facility in the modified Library refers to a function or a
table of data to be supplied by an application program that uses
the facility, other than as an argument passed when the facility
is invoked, then you must make a good faith effort to ensure that,
in the event an application does not supply such function or
table, the facility still operates, and performs whatever part of
its purpose remains meaningful.
(For example, a function in a library to compute square roots has
a purpose that is entirely well-defined independent of the
application. Therefore, Subsection 2d requires that any
application-supplied function or table used by this function must
be optional: if the application does not supply it, the square
root function must still compute square roots.)
These requirements apply to the modified work as a whole. If
identifiable sections of that work are not derived from the Library,
and can be reasonably considered independent and separate works in
themselves, then this License, and its terms, do not apply to those
sections when you distribute them as separate works. But when you
distribute the same sections as part of a whole which is a work based
on the Library, the distribution of the whole must be on the terms of
this License, whose permissions for other licensees extend to the
entire whole, and thus to each and every part regardless of who wrote
it.
Thus, it is not the intent of this section to claim rights or contest
your rights to work written entirely by you; rather, the intent is to
exercise the right to control the distribution of derivative or
collective works based on the Library.
In addition, mere aggregation of another work not based on the Library
with the Library (or with a work based on the Library) on a volume of
a storage or distribution medium does not bring the other work under
the scope of this License.
3. You may opt to apply the terms of the ordinary GNU General Public
License instead of this License to a given copy of the Library. To do
this, you must alter all the notices that refer to this License, so
that they refer to the ordinary GNU General Public License, version 2,
instead of to this License. (If a newer version than version 2 of the
ordinary GNU General Public License has appeared, then you can specify
that version instead if you wish.) Do not make any other change in
these notices.
Once this change is made in a given copy, it is irreversible for
that copy, so the ordinary GNU General Public License applies to all
subsequent copies and derivative works made from that copy.
This option is useful when you wish to copy part of the code of
the Library into a program that is not a library.
4. You may copy and distribute the Library (or a portion or
derivative of it, under Section 2) in object code or executable form
under the terms of Sections 1 and 2 above provided that you accompany
it with the complete corresponding machine-readable source code, which
must be distributed under the terms of Sections 1 and 2 above on a
medium customarily used for software interchange.
If distribution of object code is made by offering access to copy
from a designated place, then offering equivalent access to copy the
source code from the same place satisfies the requirement to
distribute the source code, even though third parties are not
compelled to copy the source along with the object code.
5. A program that contains no derivative of any portion of the
Library, but is designed to work with the Library by being compiled or
linked with it, is called a "work that uses the Library". Such a
work, in isolation, is not a derivative work of the Library, and
therefore falls outside the scope of this License.
However, linking a "work that uses the Library" with the Library
creates an executable that is a derivative of the Library (because it
contains portions of the Library), rather than a "work that uses the
library". The executable is therefore covered by this License.
Section 6 states terms for distribution of such executables.
When a "work that uses the Library" uses material from a header file
that is part of the Library, the object code for the work may be a
derivative work of the Library even though the source code is not.
Whether this is true is especially significant if the work can be
linked without the Library, or if the work is itself a library. The
threshold for this to be true is not precisely defined by law.
If such an object file uses only numerical parameters, data
structure layouts and accessors, and small macros and small inline
functions (ten lines or less in length), then the use of the object
file is unrestricted, regardless of whether it is legally a derivative
work. (Executables containing this object code plus portions of the
Library will still fall under Section 6.)
Otherwise, if the work is a derivative of the Library, you may
distribute the object code for the work under the terms of Section 6.
Any executables containing that work also fall under Section 6,
whether or not they are linked directly with the Library itself.
6. As an exception to the Sections above, you may also combine or
link a "work that uses the Library" with the Library to produce a
work containing portions of the Library, and distribute that work
under terms of your choice, provided that the terms permit
modification of the work for the customer's own use and reverse
engineering for debugging such modifications.
You must give prominent notice with each copy of the work that the
Library is used in it and that the Library and its use are covered by
this License. You must supply a copy of this License. If the work
during execution displays copyright notices, you must include the
copyright notice for the Library among them, as well as a reference
directing the user to the copy of this License. Also, you must do one
of these things:
a) Accompany the work with the complete corresponding
machine-readable source code for the Library including whatever
changes were used in the work (which must be distributed under
Sections 1 and 2 above); and, if the work is an executable linked
with the Library, with the complete machine-readable "work that
uses the Library", as object code and/or source code, so that the
user can modify the Library and then relink to produce a modified
executable containing the modified Library. (It is understood
that the user who changes the contents of definitions files in the
Library will not necessarily be able to recompile the application
to use the modified definitions.)
b) Use a suitable shared library mechanism for linking with the
Library. A suitable mechanism is one that (1) uses at run time a
copy of the library already present on the user's computer system,
rather than copying library functions into the executable, and (2)
will operate properly with a modified version of the library, if
the user installs one, as long as the modified version is
interface-compatible with the version that the work was made with.
c) Accompany the work with a written offer, valid for at
least three years, to give the same user the materials
specified in Subsection 6a, above, for a charge no more
than the cost of performing this distribution.
d) If distribution of the work is made by offering access to copy
from a designated place, offer equivalent access to copy the above
specified materials from the same place.
e) Verify that the user has already received a copy of these
materials or that you have already sent this user a copy.
For an executable, the required form of the "work that uses the
Library" must include any data and utility programs needed for
reproducing the executable from it. However, as a special exception,
the materials to be distributed need not include anything that is
normally distributed (in either source or binary form) with the major
components (compiler, kernel, and so on) of the operating system on
which the executable runs, unless that component itself accompanies
the executable.
It may happen that this requirement contradicts the license
restrictions of other proprietary libraries that do not normally
accompany the operating system. Such a contradiction means you cannot
use both them and the Library together in an executable that you
distribute.
7. You may place library facilities that are a work based on the
Library side-by-side in a single library together with other library
facilities not covered by this License, and distribute such a combined
library, provided that the separate distribution of the work based on
the Library and of the other library facilities is otherwise
permitted, and provided that you do these two things:
a) Accompany the combined library with a copy of the same work
based on the Library, uncombined with any other library
facilities. This must be distributed under the terms of the
Sections above.
b) Give prominent notice with the combined library of the fact
that part of it is a work based on the Library, and explaining
where to find the accompanying uncombined form of the same work.
8. You may not copy, modify, sublicense, link with, or distribute
the Library except as expressly provided under this License. Any
attempt otherwise to copy, modify, sublicense, link with, or
distribute the Library is void, and will automatically terminate your
rights under this License. However, parties who have received copies,
or rights, from you under this License will not have their licenses
terminated so long as such parties remain in full compliance.
9. You are not required to accept this License, since you have not
signed it. However, nothing else grants you permission to modify or
distribute the Library or its derivative works. These actions are
prohibited by law if you do not accept this License. Therefore, by
modifying or distributing the Library (or any work based on the
Library), you indicate your acceptance of this License to do so, and
all its terms and conditions for copying, distributing or modifying
the Library or works based on it.
10. Each time you redistribute the Library (or any work based on the
Library), the recipient automatically receives a license from the
original licensor to copy, distribute, link with or modify the Library
subject to these terms and conditions. You may not impose any further
restrictions on the recipients' exercise of the rights granted herein.
You are not responsible for enforcing compliance by third parties with
this License.
11. If, as a consequence of a court judgment or allegation of patent
infringement or for any other reason (not limited to patent issues),
conditions are imposed on you (whether by court order, agreement or
otherwise) that contradict the conditions of this License, they do not
excuse you from the conditions of this License. If you cannot
distribute so as to satisfy simultaneously your obligations under this
License and any other pertinent obligations, then as a consequence you
may not distribute the Library at all. For example, if a patent
license would not permit royalty-free redistribution of the Library by
all those who receive copies directly or indirectly through you, then
the only way you could satisfy both it and this License would be to
refrain entirely from distribution of the Library.
If any portion of this section is held invalid or unenforceable under any
particular circumstance, the balance of the section is intended to apply,
and the section as a whole is intended to apply in other circumstances.
It is not the purpose of this section to induce you to infringe any
patents or other property right claims or to contest validity of any
such claims; this section has the sole purpose of protecting the
integrity of the free software distribution system which is
implemented by public license practices. Many people have made
generous contributions to the wide range of software distributed
through that system in reliance on consistent application of that
system; it is up to the author/donor to decide if he or she is willing
to distribute software through any other system and a licensee cannot
impose that choice.
This section is intended to make thoroughly clear what is believed to
be a consequence of the rest of this License.
12. If the distribution and/or use of the Library is restricted in
certain countries either by patents or by copyrighted interfaces, the
original copyright holder who places the Library under this License may add
an explicit geographical distribution limitation excluding those countries,
so that distribution is permitted only in or among countries not thus
excluded. In such case, this License incorporates the limitation as if
written in the body of this License.
13. The Free Software Foundation may publish revised and/or new
versions of the Lesser General Public License from time to time.
Such new versions will be similar in spirit to the present version,
but may differ in detail to address new problems or concerns.
Each version is given a distinguishing version number. If the Library
specifies a version number of this License which applies to it and
"any later version", you have the option of following the terms and
conditions either of that version or of any later version published by
the Free Software Foundation. If the Library does not specify a
license version number, you may choose any version ever published by
the Free Software Foundation.
14. If you wish to incorporate parts of the Library into other free
programs whose distribution conditions are incompatible with these,
write to the author to ask for permission. For software which is
copyrighted by the Free Software Foundation, write to the Free
Software Foundation; we sometimes make exceptions for this. Our
decision will be guided by the two goals of preserving the free status
of all derivatives of our free software and of promoting the sharing
and reuse of software generally.
NO WARRANTY
15. BECAUSE THE LIBRARY IS LICENSED FREE OF CHARGE, THERE IS NO
WARRANTY FOR THE LIBRARY, TO THE EXTENT PERMITTED BY APPLICABLE LAW.
EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR
OTHER PARTIES PROVIDE THE LIBRARY "AS IS" WITHOUT WARRANTY OF ANY
KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE
LIBRARY IS WITH YOU. SHOULD THE LIBRARY PROVE DEFECTIVE, YOU ASSUME
THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
16. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN
WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY
AND/OR REDISTRIBUTE THE LIBRARY AS PERMITTED ABOVE, BE LIABLE TO YOU
FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR
CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE
LIBRARY (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING
RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A
FAILURE OF THE LIBRARY TO OPERATE WITH ANY OTHER SOFTWARE), EVEN IF
SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH
DAMAGES.
END OF TERMS AND CONDITIONS
How to Apply These Terms to Your New Libraries
If you develop a new library, and you want it to be of the greatest
possible use to the public, we recommend making it free software that
everyone can redistribute and change. You can do so by permitting
redistribution under these terms (or, alternatively, under the terms of the
ordinary General Public License).
To apply these terms, attach the following notices to the library. It is
safest to attach them to the start of each source file to most effectively
convey the exclusion of warranty; and each file should have at least the
"copyright" line and a pointer to where the full notice is found.
<one line to give the library's name and a brief idea of what it does.>
Copyright (C) <year> <name of author>
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
Also add information on how to contact you by electronic and paper mail.
You should also get your employer (if you work as a programmer) or your
school, if any, to sign a "copyright disclaimer" for the library, if
necessary. Here is a sample; alter the names:
Yoyodyne, Inc., hereby disclaims all copyright interest in the
library `Frob' (a library for tweaking knobs) written by James Random Hacker.
<signature of Ty Coon>, 1 April 1990
Ty Coon, President of Vice
That's all there is to it!

174
debian/changelog vendored Normal file
View File

@ -0,0 +1,174 @@
libmatroska (0.8.1-1) unstable; urgency=low
* New version.
-- Moritz Bunkus <moritz@bunkus.org> Mon, 16 Jan 2007 17:00:30 +0100
libmatroska (0.8.0-1) unstable; urgency=low
* New version.
-- Moritz Bunkus <moritz@bunkus.org> Tue, 18 Oct 2005 20:00:18 +0200
libmatroska (0.7.7-2) unstable; urgency=low
* Rebuilt with g++ 4.0.2.
-- Moritz Bunkus <moritz@bunkus.org> Sat, 15 Oct 2005 14:25:46 +0200
libmatroska (0.7.7-1) unstable; urgency=low
* New version.
-- Moritz Bunkus <moritz@bunkus.org> Fri, 20 May 2005 16:28:21 +0200
libmatroska (0.7.6-1) unstable; urgency=low
* New version.
-- Moritz Bunkus <moritz@bunkus.org> Sat, 16 Apr 2005 13:24:30 +0200
libmatroska (0.7.5-1) unstable; urgency=low
* New version.
-- Moritz Bunkus <moritz@bunkus.org> Sun, 6 Feb 2005 21:02:42 +0100
libmatroska (0.7.4-1) unstable; urgency=low
* New version.
-- Moritz Bunkus <moritz@bunkus.org> Sun, 26 Sep 2004 12:35:05 +0200
libmatroska (0.7.3-1) unstable; urgency=low
* New version.
-- Moritz Bunkus <moritz@bunkus.org> Mon, 16 Aug 2004 22:52:57 +0200
libmatroska (0.7.2-1) unstable; urgency=low
* New version.
-- Moritz Bunkus <moritz@bunkus.org> Wed, 4 Aug 2004 19:49:25 +0200
libmatroska (0.7.1-1) unstable; urgency=low
* New version.
-- Moritz Bunkus <moritz@bunkus.org> Sun, 25 Jul 2004 12:41:11 +0200
libmatroska (0.7.0-1) unstable; urgency=low
* New version.
-- Moritz Bunkus <moritz@bunkus.org> Fri, 23 Apr 2004 18:45:32 +0200
libmatroska (0.6.3-1) unstable; urgency=low
* New version.
-- Moritz Bunkus <moritz@bunkus.org> Mon, 5 Jan 2004 19:55:59 +0100
libmatroska (0.6.2-1) unstable; urgency=low
* New version.
-- Moritz Bunkus <moritz@bunkus.org> Tue, 30 Dec 2003 10:59:47 +0100
libmatroska (0.6.1-1) unstable; urgency=low
* New version.
-- Moritz Bunkus <moritz@bunkus.org> Thu, 30 Oct 2003 13:49:33 +0100
libmatroska (0.6.0-1) unstable; urgency=low
* New version.
-- Moritz Bunkus <moritz@bunkus.org> Tue, 28 Oct 2003 23:09:34 +0100
libmatroska (0.5.3-1) unstable; urgency=low
* New version.
-- Moritz Bunkus <moritz@bunkus.org> Wed, 22 Oct 2003 19:22:10 +0200
libmatroska (0.5.2-1) unstable; urgency=low
* New version.
-- Moritz Bunkus <moritz@bunkus.org> Wed, 17 Sep 2003 22:22:10 +0200
libmatroska (0.5.1-1) unstable; urgency=low
* New version.
-- Moritz Bunkus <moritz@bunkus.org> Mon, 1 Sep 2003 13:42:56 +0200
libmatroska (0.5.0-1) unstable; urgency=low
* New version.
-- Moritz Bunkus <moritz@bunkus.org> Mon, 28 Jul 2003 10:49:27 +0200
libmatroska (0.4.4-2) unstable; urgency=low
* New version.
-- Moritz Bunkus <moritz@bunkus.org> Sat, 14 Jun 2003 17:40:11 +0200
libmatroska (0.4.4-1) unstable; urgency=low
* New version.
-- Moritz Bunkus <moritz@bunkus.org> Wed, 11 Jun 2003 20:32:09 +0200
libmatroska (0.4.3-1) unstable; urgency=low
* New version with API changes.
-- Moritz Bunkus <moritz@bunkus.org> Wed, 21 May 2003 22:35:52 +0200
libmatroska (0.4.2-1) unstable; urgency=low
* New version with API changes.
-- Moritz Bunkus <moritz@bunkus.org> Tue, 6 May 2003 22:33:44 +0200
libmatroska (0.4.1-2) unstable; urgency=low
* Compiled with gcc 3.2.3
-- Moritz Bunkus <moritz@bunkus.org> Sun, 04 May 2003 22:11:33 +0200
libmatroska (0.4.1-1) unstable; urgency=low
* Some bugfixes, memleak fixed.
-- Moritz Bunkus <moritz@bunkus.org> Sat, 03 May 2003 23:07:33 +0200
libmatroska (0.4.0-1) unstable; urgency=low
* First alpha release :)
-- Moritz Bunkus <moritz@bunkus.org> Wed, 30 Apr 2003 10:44:33 +0200
libmatroska (0.2.0.20030425) unstable; urgency=low
* New version with bugfixes by Steve.
-- Moritz Bunkus <moritz@bunkus.org> Fri, 25 Apr 2003 20:01:49 +0200
libmatroska (0.2.0.20030421) unstable; urgency=low
* Separated libebml from libmatroska like in the upstream sources.)
-- Moritz Bunkus <moritz@bunkus.org> Mon, 21 Apr 2003 16:33:36 +0200
libmatroska (0.0.20030225) unstable; urgency=low
* Initial Release.
-- Moritz Bunkus <moritz@bunkus.org> Tue, 25 Feb 2003 18:28:52 +0100

16
debian/control vendored Normal file
View File

@ -0,0 +1,16 @@
Source: libmatroska
Priority: optional
Maintainer: Moritz Bunkus <moritz@bunkus.org>
Build-Depends: debhelper (>> 3.0.0), libebml-dev (>= 0.7.3-1)
Standards-Version: 3.5.8
Package: libmatroska-dev
Section: devel
Architecture: any
Depends: libebml-dev (>= 0.7.2-1)
Description: an extensible open standard Audio/Video container format
Matroska is aiming to become the standard of Multimedia
Container Formats one day. It is based on EBML (Extensible Binary
Meta Language), a kind of binary version of XML. This way the
significant advantages in terms of future format extensability
are gained without breaking file support in old parsers.

26
debian/copyright vendored Normal file
View File

@ -0,0 +1,26 @@
This package was debianized by Moritz Bunkus <moritz@bunkus.org> on
Mon, 21 Apr 2003 12:49:33 +0200.
It was downloaded from http://www.matroska.org/
Upstream Author: Steve Lhomme <steve.lhomme@free.fr>
Copyright (C) 2002-2003 Steve Lhomme. All rights reserved.
This file may be distributed under the terms of the Q Public License
as defined by Trolltech AS of Norway and appearing in the file
LICENSE.QPL included in the packaging of this file.
This proram is also licensed under the GPL. See
/usr/share/common-licenses/GPL for details.
Licensees holding an other license may use this file in accordance with
the Agreement provided with the Software.
This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
See http://www.matroska.org/license/qpl/ for QPL licensing information.
Contact license@matroska.org if any conditions of this licensing are
not clear to you.

2
debian/dirs vendored Normal file
View File

@ -0,0 +1,2 @@
usr/bin
usr/sbin

0
debian/docs vendored Normal file
View File

2
debian/libmatroska-dev.dirs vendored Normal file
View File

@ -0,0 +1,2 @@
usr/lib
usr/include

2
debian/libmatroska-dev.files vendored Normal file
View File

@ -0,0 +1,2 @@
usr/include/*
usr/lib/lib*.a

95
debian/rules vendored Normal file
View File

@ -0,0 +1,95 @@
#!/usr/bin/make -f
# Sample debian/rules that uses debhelper.
# GNU copyright 1997 to 1999 by Joey Hess.
# Uncomment this to turn on verbose mode.
#export DH_VERBOSE=1
# This is the debhelper compatibility version to use.
export DH_COMPAT=4
# shared library versions, option 1
version=2.0.5
major=2
# option 2, assuming the library is created as src/.libs/libfoo.so.2.0.5 or so
#version=`ls src/.libs/lib*.so.* | \
# awk '{if (match($$0,/[0-9]+\.[0-9]+\.[0-9]+$$/)) print substr($$0,RSTART)}'`
#major=`ls src/.libs/lib*.so.* | \
# awk '{if (match($$0,/\.so\.[0-9]+$$/)) print substr($$0,RSTART+4)}'`
# configure: configure-stamp
# configure-stamp:
# dh_testdir
# # Add here commands to configure the package.
# touch configure-stamp
build: build-stamp
build-stamp:
dh_testdir
# Add here commands to compile the package.
$(MAKE) -C make/linux $(DEB_BUILD_OPTIONS) LIBEBML_INCLUDE_DIR=/usr/include/ebml staticlib
touch build-stamp
clean:
dh_testdir
dh_testroot
rm -f build-stamp
# Add here commands to clean up after the build process.
-$(MAKE) -C make/linux $(DEB_BUILD_OPTIONS) clean
dh_clean
install: build
dh_testdir
dh_testroot
dh_clean -k
dh_installdirs
# Add here commands to install the package into debian/tmp
$(MAKE) -C make/linux prefix=$(CURDIR)/debian/tmp/usr \
install_headers install_staticlib
# Build architecture-independent files here.
binary-indep: build install
# We have nothing to do by default.
# Build architecture-dependent files here.
binary-arch: build install
dh_testdir
dh_testroot
dh_movefiles
# dh_installdebconf
dh_installdocs
# dh_installexamples
# dh_installmenu
# dh_installlogrotate
# dh_installemacsen
# dh_installpam
# dh_installmime
# dh_installinit
# dh_installcron
# dh_installman
# dh_installinfo
# dh_undocumented
dh_installchangelogs ChangeLog
dh_link
# dh_strip
dh_compress
dh_fixperms
dh_makeshlibs
dh_installdeb
# dh_perl
dh_shlibdeps
dh_gencontrol
dh_md5sums
dh_builddeb
binary: binary-indep binary-arch
.PHONY: build clean binary-indep binary-arch binary install configure

68
libmatroska.proj Normal file
View File

@ -0,0 +1,68 @@
Include "*/*.proj"
LIB matroska
{
INCLUDE .
INCLUDE ../libebml
USE ebml
// OPTIMIZE_GLOBALLY .
FAVOR_MAX_SPEED .
REDUCE_SIZE .
FASTER_FLOAT .
SOURCE src/FileKax.cpp
SOURCE src/KaxAttached.cpp
SOURCE src/KaxAttachments.cpp
SOURCE src/KaxBlock.cpp
SOURCE src/KaxBlockData.cpp
SOURCE src/KaxChapters.cpp
SOURCE src/KaxCluster.cpp
SOURCE src/KaxClusterData.cpp
SOURCE src/KaxContentEncoding.cpp
SOURCE src/KaxContexts.cpp
SOURCE src/KaxCues.cpp
SOURCE src/KaxCuesData.cpp
SOURCE src/KaxInfo.cpp
SOURCE src/KaxInfoData.cpp
SOURCE src/KaxSeekHead.cpp
SOURCE src/KaxSegment.cpp
SOURCE src/KaxTag.cpp
SOURCE src/KaxTagMulti.cpp
SOURCE src/KaxTags.cpp
SOURCE src/KaxTrackAudio.cpp
SOURCE src/KaxTrackEntryData.cpp
SOURCE src/KaxTrackVideo.cpp
SOURCE src/KaxTracks.cpp
SOURCE src/KaxVersion.cpp
HEADER matroska/FileKax.h
HEADER matroska/KaxAttached.h
HEADER matroska/KaxAttachments.h
HEADER matroska/KaxBlock.h
HEADER matroska/KaxBlockData.h
HEADER matroska/KaxChapters.h
HEADER matroska/KaxCluster.h
HEADER matroska/KaxClusterData.h
HEADER matroska/KaxConfig.h
HEADER matroska/KaxContentEncoding.h
HEADER matroska/KaxContexts.h
HEADER matroska/KaxCues.h
HEADER matroska/KaxCuesData.h
HEADER matroska/KaxInfo.h
HEADER matroska/KaxInfoData.h
HEADER matroska/KaxSeekHead.h
HEADER matroska/KaxSegment.h
HEADER matroska/KaxTag.h
HEADER matroska/KaxTagMulti.h
HEADER matroska/KaxTags.h
HEADER matroska/KaxTrackAudio.h
HEADER matroska/KaxTrackEntryData.h
HEADER matroska/KaxTrackVideo.h
HEADER matroska/KaxTracks.h
HEADER matroska/KaxTypes.h
HEADER matroska/KaxVersion.h
HEADER matroska/c/libmatroska_t.h
HEADER matroska/c/libmatroska.h
}

211
make/Doxyfile Normal file
View File

@ -0,0 +1,211 @@
# Doxyfile 1.3
#---------------------------------------------------------------------------
# General configuration options
#---------------------------------------------------------------------------
PROJECT_NAME = libmatroska
PROJECT_NUMBER = 0.5.0
OUTPUT_DIRECTORY = ../../doc/src
OUTPUT_LANGUAGE = English
USE_WINDOWS_ENCODING = YES
EXTRACT_ALL = YES
EXTRACT_PRIVATE = NO
EXTRACT_STATIC = YES
EXTRACT_LOCAL_CLASSES = YES
HIDE_UNDOC_MEMBERS = NO
HIDE_UNDOC_CLASSES = NO
HIDE_FRIEND_COMPOUNDS = NO
HIDE_IN_BODY_DOCS = NO
BRIEF_MEMBER_DESC = YES
REPEAT_BRIEF = YES
ALWAYS_DETAILED_SEC = NO
INLINE_INHERITED_MEMB = YES
FULL_PATH_NAMES = NO
STRIP_FROM_PATH =
INTERNAL_DOCS = NO
CASE_SENSE_NAMES = YES
SHORT_NAMES = NO
HIDE_SCOPE_NAMES = NO
VERBATIM_HEADERS = YES
SHOW_INCLUDE_FILES = NO
JAVADOC_AUTOBRIEF = YES
MULTILINE_CPP_IS_BRIEF = NO
DETAILS_AT_TOP = YES
INHERIT_DOCS = YES
INLINE_INFO = YES
SORT_MEMBER_DOCS = NO
DISTRIBUTE_GROUP_DOC = NO
TAB_SIZE = 2
GENERATE_TODOLIST = YES
GENERATE_TESTLIST = YES
GENERATE_BUGLIST = YES
GENERATE_DEPRECATEDLIST= YES
ALIASES =
ENABLED_SECTIONS =
MAX_INITIALIZER_LINES = 30
OPTIMIZE_OUTPUT_FOR_C = NO
OPTIMIZE_OUTPUT_JAVA = NO
SHOW_USED_FILES = YES
#---------------------------------------------------------------------------
# configuration options related to warning and progress messages
#---------------------------------------------------------------------------
QUIET = NO
WARNINGS = YES
WARN_IF_UNDOCUMENTED = YES
WARN_IF_DOC_ERROR = YES
WARN_FORMAT = "$file:$line: $text"
WARN_LOGFILE =
#---------------------------------------------------------------------------
# configuration options related to the input files
#---------------------------------------------------------------------------
INPUT = ../../libebml/src \
../../libebml/src/platform/win32 \
../../libebml/ebml \
../../libebml/ebml/c \
../src \
../matroska \
../matroska/c
FILE_PATTERNS = *.cpp \
*.h
RECURSIVE = NO
EXCLUDE =
EXCLUDE_SYMLINKS = NO
EXCLUDE_PATTERNS =
EXAMPLE_PATH =
EXAMPLE_PATTERNS =
EXAMPLE_RECURSIVE = NO
IMAGE_PATH =
INPUT_FILTER =
FILTER_SOURCE_FILES = NO
#---------------------------------------------------------------------------
# configuration options related to source browsing
#---------------------------------------------------------------------------
SOURCE_BROWSER = YES
INLINE_SOURCES = NO
STRIP_CODE_COMMENTS = YES
REFERENCED_BY_RELATION = NO
REFERENCES_RELATION = YES
#---------------------------------------------------------------------------
# configuration options related to the alphabetical class index
#---------------------------------------------------------------------------
ALPHABETICAL_INDEX = NO
COLS_IN_ALPHA_INDEX = 5
IGNORE_PREFIX =
#---------------------------------------------------------------------------
# configuration options related to the HTML output
#---------------------------------------------------------------------------
GENERATE_HTML = YES
HTML_OUTPUT = html
HTML_FILE_EXTENSION = .html
HTML_HEADER =
HTML_FOOTER =
HTML_STYLESHEET = libmatroska.css
HTML_ALIGN_MEMBERS = YES
GENERATE_HTMLHELP = NO
CHM_FILE =
HHC_LOCATION =
GENERATE_CHI = NO
BINARY_TOC = NO
TOC_EXPAND = NO
DISABLE_INDEX = NO
ENUM_VALUES_PER_LINE = 4
GENERATE_TREEVIEW = NO
TREEVIEW_WIDTH = 250
#---------------------------------------------------------------------------
# configuration options related to the LaTeX output
#---------------------------------------------------------------------------
GENERATE_LATEX = YES
LATEX_OUTPUT = latex
LATEX_CMD_NAME = latex
MAKEINDEX_CMD_NAME = makeindex
COMPACT_LATEX = YES
PAPER_TYPE = a4wide
EXTRA_PACKAGES =
LATEX_HEADER =
PDF_HYPERLINKS = YES
USE_PDFLATEX = YES
LATEX_BATCHMODE = NO
LATEX_HIDE_INDICES = NO
#---------------------------------------------------------------------------
# configuration options related to the RTF output
#---------------------------------------------------------------------------
GENERATE_RTF = YES
RTF_OUTPUT = rtf
COMPACT_RTF = NO
RTF_HYPERLINKS = YES
RTF_STYLESHEET_FILE =
RTF_EXTENSIONS_FILE =
#---------------------------------------------------------------------------
# configuration options related to the man page output
#---------------------------------------------------------------------------
GENERATE_MAN = NO
MAN_OUTPUT = man
MAN_EXTENSION = .3
MAN_LINKS = YES
#---------------------------------------------------------------------------
# configuration options related to the XML output
#---------------------------------------------------------------------------
GENERATE_XML = NO
XML_SCHEMA =
XML_DTD =
#---------------------------------------------------------------------------
# configuration options for the AutoGen Definitions output
#---------------------------------------------------------------------------
GENERATE_AUTOGEN_DEF = NO
#---------------------------------------------------------------------------
# configuration options related to the Perl module output
#---------------------------------------------------------------------------
GENERATE_PERLMOD = NO
PERLMOD_LATEX = NO
PERLMOD_PRETTY = YES
PERLMOD_MAKEVAR_PREFIX =
#---------------------------------------------------------------------------
# Configuration options related to the preprocessor
#---------------------------------------------------------------------------
ENABLE_PREPROCESSING = YES
MACRO_EXPANSION = NO
EXPAND_ONLY_PREDEF = NO
SEARCH_INCLUDES = YES
INCLUDE_PATH =
INCLUDE_FILE_PATTERNS =
PREDEFINED =
EXPAND_AS_DEFINED =
SKIP_FUNCTION_MACROS = YES
#---------------------------------------------------------------------------
# Configuration::addtions related to external references
#---------------------------------------------------------------------------
TAGFILES =
GENERATE_TAGFILE =
ALLEXTERNALS = NO
EXTERNAL_GROUPS = YES
PERL_PATH = /usr/bin/perl
#---------------------------------------------------------------------------
# Configuration options related to the dot tool
#---------------------------------------------------------------------------
CLASS_DIAGRAMS = YES
HIDE_UNDOC_RELATIONS = YES
HAVE_DOT = NO
CLASS_GRAPH = YES
COLLABORATION_GRAPH = YES
TEMPLATE_RELATIONS = YES
INCLUDE_GRAPH = YES
INCLUDED_BY_GRAPH = YES
GRAPHICAL_HIERARCHY = YES
DOT_IMAGE_FORMAT = png
DOT_PATH =
DOTFILE_DIRS =
MAX_DOT_GRAPH_WIDTH = 1024
MAX_DOT_GRAPH_HEIGHT = 1024
MAX_DOT_GRAPH_DEPTH = 0
GENERATE_LEGEND = YES
DOT_CLEANUP = YES
#---------------------------------------------------------------------------
# Configuration::addtions related to the search engine
#---------------------------------------------------------------------------
SEARCHENGINE = NO
CGI_NAME = search.cgi
CGI_URL =
DOC_URL =
DOC_ABSPATH =
BIN_ABSPATH = /usr/local/bin/
EXT_DOC_PATHS =

60
make/cygwin/Makefile Normal file
View File

@ -0,0 +1,60 @@
# libmatroska core Makefile (used in cygwin)
# $Id: Makefile 640 2004-07-09 21:05:36Z mosu $
# Options
EXTENSION=.cpp
CXXFLAGS=-g -DDEBUG -Wall -Wno-unknown-pragmas -DWIN32 -DNO_NAMESPACE
LDFLAGS=
SRC_DIR=../../src/
# Programs
CXX=g++ -c
LD=g++
DEP=$(CXX) -MM
DEPEND = makedepend
AR = ar rcvu
RANLIB = ranlib
# Librarires
INCLUDE=
LIBS=
# Names
PROGRAM=libmatroska.a
# source-files
sources:=$(wildcard ${SRC_DIR}*$(EXTENSION))
# header files; replace .cxx extension with .h
headers:=$(patsubst %$(EXTENSION),%.hpp,$(sources))
# files holding dependency information; replace .cxx extension with .dep
dependencies:=$(patsubst %$(EXTENSION),%.dep,$(sources))
# object files; replace .cxx extension with .o
objects:=$(patsubst %$(EXTENSION),%.o,$(sources))
DEPENDFLAGS = ${CXXFLAGS} ${INCLUDE}
# Build rules
%.o: %$(EXTENSION)
$(CXX) $(CXXFLAGS) $(INCLUDE) -o $@ $<
$(PROGRAM): $(objects)
$(AR) $@ $(objects)
$(RANLIB) $@
# $(LD) $(LDFLAGS) -o $@ $^ $(LIBS)
# ${LD} -o $@ ${LDFLAGS} ${OBJS} ${LIBS} ${EXTRA_LIBS}
clean:
rm -f ${SRC_DIR}$(objects)
rm -f ${SRC_DIR}$(dependencies)
rm -f ${SRC_DIR}$(PROGRAM)
rm -f CORE
# what are the source dependencies
depend: $(sources)
$(DEPEND) $(DEPENDFLAGS) $(sources)
# DO NOT DELETE

98
make/cygwin/Makefile.rule Normal file
View File

@ -0,0 +1,98 @@
##
## This Makefile is made for cygwin, but might probably work on any standard UNIX too
##
#****************************************************************************
# DEBUG can be set to YES to include debugging info, or NO otherwise
DEBUG = YES
# PROFILE can be set to YES to include profiling info, or NO otherwise
PROFILE = NO
#****************************************************************************
CC = gcc
CXX = g++
LD = gcc
AR = ar rcvu
RANLIB = ranlib
DEPEND = makedepend
INDENT =indent --gnu-style -ut -ts6 -br -npsl -npcs
DELETE =rm -f
GLOBAL_CFLAGS = -Wall -Wno-unknown-pragmas -Wno-format
DEBUG_CFLAGS = -g -O0 -DDEBUG ${GLOBAL_CFLAGS}
RELEASE_CFLAGS = -O2 ${GLOBAL_CFLAGS}
P_OPTIONS = -pedantic
LIBS =
DEBUG_CXXFLAGS = ${DEBUG_CFLAGS}
RELEASE_CXXFLAGS = ${RELEASE_CFLAGS}
DEBUG_LDFLAGS = -g
RELEASE_LDFLAGS =
ifeq (YES, ${DEBUG})
CFLAGS = ${DEBUG_CFLAGS} ${INCS} ${P_OPTIONS}
CXXFLAGS = ${DEBUG_CXXFLAGS} ${INCS} ${P_OPTIONS}
LDFLAGS = ${DEBUG_LDFLAGS}
DEPENDFLAGS = ${DEBUG_CFLAGS} ${INCS}
else
CFLAGS = ${RELEASE_CFLAGS} ${INCS} ${P_OPTIONS}
CXXFLAGS = ${RELEASE_CXXFLAGS} ${INCS} ${P_OPTIONS}
LDFLAGS = ${RELEASE_LDFLAGS}
DEPENDFLAGS = ${RELEASE_CFLAGS} ${INCS}
endif
ifeq (YES, ${PROFILE})
CFLAGS := ${CFLAGS} -pg
CXXFLAGS := ${CXXFLAGS} -pg
LDFLAGS := ${LDFLAGS} -pg
endif
#****************************************************************************
# Preprocessor directives
#****************************************************************************
ifeq (YES, ${PROFILE})
DEFS =
else
DEFS =
endif
#****************************************************************************
# Include paths
#****************************************************************************
#INCS := -I/usr/include/g++-2 -I/usr/local/include
#INCS =
#****************************************************************************
# Makefile code common to all platforms
#****************************************************************************
CFLAGS := ${CFLAGS} ${DEFS}
CXXFLAGS := ${CXXFLAGS} ${DEFS}
#****************************************************************************
# General rules
#****************************************************************************
indent:
$(INDENT) --line-length 100 ${SRCS} ${SRCS_HEADERS}
$(DELETE) *.*~
indent80:
$(INDENT) --line-length 80 ${SRCS} ${SRCS_HEADERS}
$(DELETE) *.*~
clean:
rm -f core *.o *.so *.a *.exe
# what are the source dependencies
depend: $(SRCS)
$(DEPEND) $(DEPENDFLAGS) $(SRCS)

181
make/linux/Makefile Normal file
View File

@ -0,0 +1,181 @@
# libmatroska core Makefile (used in cygwin)
# $Id: Makefile 1254 2006-06-02 14:32:52Z mosu $
# Author: Steve Lhomme <robux4 @ users.sf.net>
# Author: Moritz Bunkus <moritz @ bunkus.org>
#
# The library is built without debug information. If you want
# debug information to be included then compile with
# 'make DEBUG=yes'.
#
# Paths
# BeOS wants the libs and headers in /boot/home/config
ifeq (BeOS,$(shell uname -s))
prefix=/boot/home/config
else
prefix=/usr/local
endif
libdir=$(prefix)/lib
includedir=$(prefix)/include/matroska
# Programs
CXX=g++
LD=$(CXX)
AR = ar rcvu
RANLIB = ranlib
INSTALL = install
INSTALL_OPTS = -m 644
INSTALL_OPTS_LIB = -m 644
INSTALL_DIR_OPTS = -m 755
ifneq (,$(shell $(CXX) -v 2>&1 | tail -n 1 | grep -i mingw))
$(error Please use the Makefile in ../mingw32)
endif
CWD=$(shell pwd)
# Options
LIBEBML_INCLUDE_DIR=$(CWD)/../../../libebml
LIBEBML_LIB_DIR=$(CWD)/../../../libebml/make/linux
EXTENSION=.cpp
ifeq (yes,$(DEBUG))
DEBUGFLAGS=-g -DDEBUG
endif
SRC_DIR=$(CWD)/../../src/
INCLUDE_DIR=$(CWD)/../../matroska
MUX_SRC_DIR=$(CWD)/../../test/mux/
TAG_SRC_DIR=$(CWD)/../../test/tags/
# Librarires
INCLUDE=-I$(CWD)/../.. -I$(LIBEBML_INCLUDE_DIR)
LIBS=
MUX_LIBS=-lmatroska -lebml $(LIBICONV)
# Names
LIBRARY=libmatroska.a
LIBRARY_SO=libmatroska.so
LIBRARY_SO_VER=libmatroska.so.0
# source-files
sources:=$(wildcard ${SRC_DIR}*$(EXTENSION))
# header files; replace .cxx extension with .h
headers:=$(patsubst %$(EXTENSION),%.h,$(sources))
# object files; replace .cxx extension with .o
objects:=$(patsubst %$(EXTENSION),%.o,$(sources))
objects_so:=$(patsubst %$(EXTENSION),%.lo,$(sources))
WARNINGFLAGS=-Wall -Wno-unknown-pragmas -ansi -fno-gnu-keywords -D_GNU_SOURCE \
-Wshadow
COMPILEFLAGS=$(DEBUGFLAGS) $(CXXFLAGS) $(CPPFLAGS) $(WARNINGFLAGS) $(INCLUDE)
LINKFLAGS=-L. -L$(LIBEBML_LIB_DIR) $(LDFLAGS)
DEPENDFLAGS = $(CXXFLAGS) $(INCLUDE)
ifeq (Darwin,$(shell uname -s))
all: staticlib
else
all: staticlib sharedlib
endif
staticlib: $(LIBRARY)
sharedlib: $(LIBRARY_SO)
lib:
@echo "Use the 'staticlib', 'sharedlib' or 'all' targets."
@false
# Build rules
%.o: %$(EXTENSION)
$(CXX) -c $(COMPILEFLAGS) -o $@ $<
%.lo: %$(EXTENSION)
$(CXX) -c $(COMPILEFLAGS) -fPIC -o $@ $<
$(LIBRARY): $(objects)
$(AR) $@ $(objects)
$(RANLIB) $@
$(LIBRARY_SO): $(objects_so)
$(CXX) -shared -Wl,-soname,$(LIBRARY_SO_VER) -o $(LIBRARY_SO_VER) $(objects_so) -lebml
rm -f $(LIBRARY_SO)
ln -s $(LIBRARY_SO_VER) $(LIBRARY_SO)
clean: cleantest
rm -f $(objects) $(objects_so)
rm -f $(LIBRARY)
rm -f $(LIBRARY_SO)
rm -f $(LIBRARY_SO_VER)
rm -f CORE
cleantest:
rm -f test6 test8 test9 test6.o test8.o test9.o
distclean dist-clean: clean
rm -f .depend
depend:
@echo Calculating dependecies:
@rm -f .depend
@touch .depend
@for i in $(sources); do \
o="`echo $$i | sed -e 's/\.c$$/.o/' -e 's/\.cpp$$/.o/'`" ; \
echo ' ' $$i: $$o ; \
$(CXX) $(DEPENDFLAGS) -MM -MT $$o $$i >> .depend ; \
done
test: test6 test9
test6: test6.o $(LIBRARY) $(LIBRARY_SO)
$(LD) -o $@ $(LINKFLAGS) $< $(MUX_LIBS)
test6.o: $(MUX_SRC_DIR)test6.cpp
$(CXX) -c $(COMPILEFLAGS) -o $@ $<
test8: test8.o $(LIBRARY) $(LIBRARY_SO)
$(LD) -o $@ $(LINKFLAGS) $< $(MUX_LIBS)
test8.o: $(MUX_SRC_DIR)test8.cpp
$(CXX) -c $(COMPILEFLAGS) -o $@ $<
test9: test9.o $(LIBRARY) $(LIBRARY_SO)
$(LD) -o $@ $(LINKFLAGS) $< $(MUX_LIBS)
test9.o: $(TAG_SRC_DIR)test9.cpp
$(CXX) -c $(COMPILEFLAGS) -o $@ $<
ifeq (Darwin,$(shell uname -s))
install: install_staticlib install_headers
else
install: install_staticlib install_sharedlib install_headers
endif
install_headers:
$(INSTALL) $(INSTALL_DIR_OPTS) -d $(includedir)
for i in $(INCLUDE_DIR)/*.h; do \
$(INSTALL) $(INSTALL_OPTS) $$i $(includedir) ; \
done
$(INSTALL) $(INSTALL_DIR_OPTS) -d $(includedir)/c
for i in $(INCLUDE_DIR)/c/*.h; do \
$(INSTALL) $(INSTALL_OPTS) $$i $(includedir)/c ; \
done
install_staticlib: $(LIBRARY)
$(INSTALL) $(INSTALL_DIR_OPTS) -d $(libdir)
$(INSTALL) $(INSTALL_OPTS_LIB) $(LIBRARY) $(libdir)
install_sharedlib: $(LIBRARY_SO)
$(INSTALL) $(INSTALL_DIR_OPTS) -d $(libdir)
$(INSTALL) $(INSTALL_OPTS_LIB) $(LIBRARY_SO_VER) $(libdir)
ln -fs $(LIBRARY_SO_VER) $(libdir)/$(LIBRARY_SO)
ifneq ($(wildcard .depend),)
include .depend
endif
# DO NOT DELETE

98
make/linux/Makefile.rule Normal file
View File

@ -0,0 +1,98 @@
##
## This Makefile is made for cygwin, but might probably work on any standard UNIX too
##
#****************************************************************************
# DEBUG can be set to YES to include debugging info, or NO otherwise
DEBUG = YES
# PROFILE can be set to YES to include profiling info, or NO otherwise
PROFILE = NO
#****************************************************************************
CC = gcc
CXX = g++
LD = gcc
AR = ar rcvu
RANLIB = ranlib
DEPEND = makedepend
INDENT =indent --gnu-style -ut -ts6 -br -npsl -npcs
DELETE =rm -f
GLOBAL_CFLAGS = -Wall -Wno-unknown-pragmas -Wno-format
DEBUG_CFLAGS = -g -O0 -DDEBUG ${GLOBAL_CFLAGS}
RELEASE_CFLAGS = -O2 ${GLOBAL_CFLAGS}
P_OPTIONS = -pedantic
LIBS =
DEBUG_CXXFLAGS = ${DEBUG_CFLAGS}
RELEASE_CXXFLAGS = ${RELEASE_CFLAGS}
DEBUG_LDFLAGS = -g
RELEASE_LDFLAGS =
ifeq (YES, ${DEBUG})
CFLAGS = ${DEBUG_CFLAGS} ${INCS} ${P_OPTIONS}
CXXFLAGS = ${DEBUG_CXXFLAGS} ${INCS} ${P_OPTIONS}
LDFLAGS = ${DEBUG_LDFLAGS}
DEPENDFLAGS = ${DEBUG_CFLAGS} ${INCS}
else
CFLAGS = ${RELEASE_CFLAGS} ${INCS} ${P_OPTIONS}
CXXFLAGS = ${RELEASE_CXXFLAGS} ${INCS} ${P_OPTIONS}
LDFLAGS = ${RELEASE_LDFLAGS}
DEPENDFLAGS = ${RELEASE_CFLAGS} ${INCS}
endif
ifeq (YES, ${PROFILE})
CFLAGS := ${CFLAGS} -pg
CXXFLAGS := ${CXXFLAGS} -pg
LDFLAGS := ${LDFLAGS} -pg
endif
#****************************************************************************
# Preprocessor directives
#****************************************************************************
ifeq (YES, ${PROFILE})
DEFS =
else
DEFS =
endif
#****************************************************************************
# Include paths
#****************************************************************************
#INCS := -I/usr/include/g++-2 -I/usr/local/include
#INCS =
#****************************************************************************
# Makefile code common to all platforms
#****************************************************************************
CFLAGS := ${CFLAGS} ${DEFS}
CXXFLAGS := ${CXXFLAGS} ${DEFS}
#****************************************************************************
# General rules
#****************************************************************************
indent:
$(INDENT) --line-length 100 ${SRCS} ${SRCS_HEADERS}
$(DELETE) *.*~
indent80:
$(INDENT) --line-length 80 ${SRCS} ${SRCS_HEADERS}
$(DELETE) *.*~
clean:
rm -f core *.o *.so *.a *.exe
# what are the source dependencies
depend: $(SRCS)
$(DEPEND) $(DEPENDFLAGS) $(SRCS)

18
make/linux/check_ids Normal file
View File

@ -0,0 +1,18 @@
#!/bin/sh
# A small script that looks for duplicate EBML IDs in all of libmatroska's
# source files.
echo 'Duplicate IDs:'
grep -h '^EbmlId.*_TheId' ../../src/*cpp | \
sed -e 's/TheId/TheId /' | \
awk '{ print $3 }' | \
sed -e 's/(//' -e 's/,//' | \
sort | \
uniq -d | \
( while read id ; do
echo ''
echo ${id}:
grep -i $id ../../src/*cpp
done )

View File

@ -0,0 +1,61 @@
# SPEC file for (at least) Fedora Core 1, 2, 3
Name: libmatroska
Version: 0.8.1
Release: 1
License: LGPL
Summary: Matroska Video Container
Group: System Environment/Libraries
URL: http://www.matroska.org/
Vendor: Moritz Bunkus <moritz@bunkus.org>
Source: http://dl.matroska.org/downloads/%{name}/%{name}-%{version}.tar.bz2
BuildRoot: %{_tmppath}/%{name}-root
%description
Matroska aims to become THE Standard of Multimedia Container Formats.
It was derived from a project called MCF, but differentiates from it
significantly because it is based on EBML (Extensible Binary Meta
Language), a binary derivative of XML. EBML enables the Matroska
Development Team to gain significant advantages in terms of future
format extensibility, without breaking file support in old parsers.
%package devel
Summary: Matroska Video Container headers/development files
Group: Development/Libraries
%description devel
Headers for libmatroska.
%prep
%setup -q
%build
cd make/linux
CFLAGS="$RPM_OPT_FLAGS" \
make \
prefix="%{_prefix}" \
LIBEBML_INCLUDE_DIR=%{_includedir} \
LIBEBML_LIB_DIR=%{_libdir} \
staticlib
cd ../..
%install
[ "$RPM_BUILD_ROOT" != "/" ] && rm -rf $RPM_BUILD_ROOT
cd make/linux
make prefix=$RPM_BUILD_ROOT/%{_prefix} install_staticlib install_headers
cd ../..
%clean
[ "$RPM_BUILD_ROOT" != "/" ] && rm -rf $RPM_BUILD_ROOT
%files devel
%defattr(-, root, root)
%{_includedir}/matroska/*.h
%{_includedir}/matroska/c/*.h
%{_libdir}/libmatroska.a
%changelog
* Sat Apr 16 2005 Moritz Bunkus <moritz@bunkus.org>
- updated for the new libmatroska build targets
* Fri May 15 2003 Ronald Bultje <rbultje@ronald.bitfreak.net>
- create spec file

View File

@ -0,0 +1,14 @@
--- libmatroska-0.7.3/make/linux/Makefile~ 2004-07-19 18:43:44.000000000 +0200
+++ libmatroska-0.7.3/make/linux/Makefile 2004-09-01 22:36:35.696238264 +0200
@@ -14,9 +14,9 @@
ifeq (BeOS,$(shell uname -s))
prefix=/boot/home/config
else
-prefix=/usr/local
+prefix=$(PREFIX)
endif
-libdir=$(prefix)/lib
+libdir=$(LIBDIR)
includedir=$(prefix)/include/matroska
# Programs

75
make/linux/suse.spec Normal file
View File

@ -0,0 +1,75 @@
#
# spec file for package libmatroska for (at least) SuSE 9.0, 9.1
#
# Copyright (c) 2004 SUSE LINUX AG, Nuernberg, Germany.
# This file and all modifications and additions to the pristine
# package are under the same license as the package itself.
#
# Please submit bugfixes or comments via http://www.suse.de/feedback/
#
# neededforbuild gcc-c++ libebml libstdc++-devel
BuildRequires: bzip2 cpp libebml make patch tar zlib zlib-devel binutils gcc gcc-c++ libstdc++-devel perl rpm
Name: libmatroska
URL: http://dl.matroska.org/downloads/libmatroska/
Version: 0.8.1
Release: 1
Summary: library to deal with matroska files.
License: LGPL
Group: Development/Libraries/Other
Source: %{name}-%{version}.tar.bz2
Patch: suse-libmatroska-makefile.diff
Summary: library to deal with matroska files.
BuildRoot: %{_tmppath}/%{name}-%{version}-build
Prefix: /usr
%description
libmatroska is a C++ libary to parse Matroska files (.mkv and .mka). It
depends on libebml to work. You only need this package to compile your
own applications.
Authors:
--------
Steve Lhomme <steve.lhomme@free.fr>
Moritz Bunkus <moritz@bunkus.org>
%prep
rm -rf $RPM_BUILD_ROOT
%setup
%patch -p1
%build
export CFLAGS="$RPM_OPT_FLAGS"
cd make/linux
make PREFIX=$RPM_BUILD_ROOT/usr LIBDIR=%{_libdir} staticlib
%install
cd make/linux
make install_staticlib install_headers PREFIX=$RPM_BUILD_ROOT/usr LIBDIR=$RPM_BUILD_ROOT/%{_libdir}
%clean
rm -rf $RPM_BUILD_ROOT
%post
%run_ldconfig
%postun
%run_ldconfig
%files
%defattr (-,root,root)
%{_libdir}/libmatroska.a
/usr/include/matroska
# /usr/include/ebml/*
%changelog -n libmatroska
* Sat Apr 16 2005 - moritz@bunkus.org
- updated for the new libmatroska build targets
* Thu Sep 02 2004 - seife@suse.de
- add libebml to neededforbuild
* Wed Sep 01 2004 - seife@suse.de
- initial submission

File diff suppressed because it is too large Load Diff

8
make/makedoc.bat Normal file
View File

@ -0,0 +1,8 @@
@echo off
rem you should have DOXYGEN.EXE in your path
rem http://www.doxygen.org/
echo make Documentation
doxygen Doxyfile > Doxygen.log.txt 2> Doxygen.err.txt

7
make/makedoc.sh Normal file
View File

@ -0,0 +1,7 @@
#!/usr/bin/sh
# you should have "doxygen" in your path
# http://www.doxygen.org/
echo make Documentation
doxygen Doxyfile > Doxygen.log.txt 2> Doxygen.err.txt

106
make/mingw32/Makefile Normal file
View File

@ -0,0 +1,106 @@
# Project: libmatroska
# Makefile created by Dev-C++ 4.9.7.0
# Normally libmatroska is built as a static library.
# Uncomment this if you want a shared library instead.
# ATTENTION: Your app has to define MATROSKA_DLL !
SHARED = yes
# Compile with debug information?
#DEBUG = yes
# Where libebml resides
EBML_DIR = ../../../libebml
# Has libebml been compiled as a DLL?
EBML_DLL = yes
#
# Don't change anything below this line.
#
ifeq (yes,$(DEBUG))
DEBUGFLAGS=-g -DDEBUG
endif
CXX = g++.exe
LD = g++.exe
WINDRES = windres.exe
RES =
SRC = $(wildcard ../../src/*.cpp)
OBJ = $(patsubst %.cpp,%.o,$(SRC))
ifeq (yes,$(SHARED))
LIBS = libmatroska.dll
CXXFLAGS = -DMATROSKA_DLL
DLLFLAGS = -DMATROSKA_DLL_EXPORT
else
LIBS = libmatroska.a
endif
ifeq (yes,$(EBML_DLL))
CXXFLAGS += -DEBML_DLL
endif
INCS = -I../.. -I$(EBML_DIR)
LDFLAGS = -L. -L$(EBML_DIR)/make/mingw32
CXXFLAGS += $(DEBUGFLAGS) $(INCS)
TESTS = test6 test8 test9
.PHONY: all all-before all-after clean clean-custom
.cpp.o:
$(CXX) $(DLLFLAGS) $(CXXFLAGS) -c -o $@ $<
all: lib
lib: $(LIBS)
tests: $(TESTS)
clean:
rm -f $(OBJ) libmatroska.a libmatroska.dll.a libmatroska.dll *.exe \
../../test/mux/*.o ../../test/tags/*.o
distclean dist-clean: clean
rm -f .depend
libmatroska.a: $(OBJ)
ar r $@ $(OBJ)
ranlib $@
libmatroska.dll: $(OBJ)
$(CXX) -shared -Wl,--export-all -Wl,--out-implib=$@.a -o $@ $(OBJ) \
$(LDFLAGS) -lebml
# Explicitely list these object files because for them
# MATROSKA_DLL_EXPORT must NOT be defined.
../../test/mux/test6.o: ../../test/mux/test6.cpp
$(CXX) $(CXXFLAGS) -c -o $@ $<
test6: ../../test/mux/test6.o $(LIBS)
$(LD) -o $@ $(LDFLAGS) $< -lmatroska -lebml
../../test/mux/test8.o: ../../test/mux/test8.cpp
$(CXX) $(CXXFLAGS) -c -o $@ $<
test8: ../../test/mux/test8.o $(LIBS)
$(LD) -o $@ $(LDFLAGS) $< -lmatroska -lebml
../../test/tags/test9.o: ../../test/tags/test9.cpp
$(CXX) $(CXXFLAGS) -c -o $@ $<
test9: ../../test/tags/test9.o $(LIBS)
$(LD) -o $@ $(LDFLAGS) $< -lmatroska -lebml
depend:
@echo Calculating dependecies:
@rm -f .depend
@touch .depend
@for i in $(SRC); do \
o="`echo $$i | sed -e 's/\.c$$/.o/' -e 's/\.cpp$$/.o/'`" ; \
echo ' ' $$i: $$o ; \
$(CXX) $(CXXFLAGS) -MM -MT $$o $$i >> .depend ; \
done
#
# include dependency files if they exist
#
ifneq ($(wildcard .depend),)
include .depend
endif

View File

@ -0,0 +1,390 @@
[Project]
FileName=libmatroska.dev
Name=libmatroska
UnitCount=43
Type=2
Ver=1
ObjFiles=
Includes=..\..\..\libebml\src
Libs=
PrivateResource=
ResourceIncludes=
MakeIncludes=
Resources=
Compiler=
Linker=
IsCpp=1
Icon=
ExeOutput=
ObjectOutput=
OverrideOutput=0
OverrideOutputName=libmatroska.a
HostApplication=
Folders=
CommandLine=
IncludeVersionInfo=0
SupportXPThemes=0
CompilerSet=0
CompilerSettings=000000000000000000
[Unit1]
FileName=..\..\src\StdInclude.h
Folder=libmatroska
Compile=1
CompileCpp=1
OverrideBuildCmd=0
BuildCmd=
[Unit2]
FileName=..\..\src\FileKax.h
Folder=libmatroska
Compile=1
CompileCpp=1
OverrideBuildCmd=0
BuildCmd=
[Unit3]
FileName=..\..\src\KaxAttached.cpp
Folder=libmatroska
Compile=1
CompileCpp=1
OverrideBuildCmd=0
BuildCmd=
[Unit4]
FileName=..\..\src\KaxAttached.h
Folder=libmatroska
Compile=1
CompileCpp=1
OverrideBuildCmd=0
BuildCmd=
[Unit5]
FileName=..\..\src\KaxAttachements.cpp
Folder=libmatroska
Compile=1
CompileCpp=1
OverrideBuildCmd=0
BuildCmd=
[Unit6]
FileName=..\..\src\KaxAttachements.h
Folder=libmatroska
Compile=1
CompileCpp=1
OverrideBuildCmd=0
BuildCmd=
[Unit7]
FileName=..\..\src\KaxBlock.cpp
Folder=libmatroska
Compile=1
CompileCpp=1
OverrideBuildCmd=0
BuildCmd=
[Unit8]
FileName=..\..\src\KaxBlock.h
Folder=libmatroska
Compile=1
CompileCpp=1
OverrideBuildCmd=0
BuildCmd=
[Unit9]
FileName=..\..\src\KaxBlockAdditional.cpp
Folder=libmatroska
Compile=1
CompileCpp=1
OverrideBuildCmd=0
BuildCmd=
[Unit10]
FileName=..\..\src\KaxBlockAdditional.h
Folder=libmatroska
Compile=1
CompileCpp=1
OverrideBuildCmd=0
BuildCmd=
[Unit11]
FileName=..\..\src\KaxChapters.cpp
Folder=libmatroska
Compile=1
CompileCpp=1
OverrideBuildCmd=0
BuildCmd=
[Unit12]
FileName=..\..\src\KaxChapters.h
Folder=libmatroska
Compile=1
CompileCpp=1
OverrideBuildCmd=0
BuildCmd=
[Unit13]
FileName=..\..\src\KaxCluster.cpp
Folder=libmatroska
Compile=1
CompileCpp=1
OverrideBuildCmd=0
BuildCmd=
[Unit14]
FileName=..\..\src\KaxCluster.h
Folder=libmatroska
Compile=1
CompileCpp=1
OverrideBuildCmd=0
BuildCmd=
[Unit15]
FileName=..\..\src\KaxClusterData.cpp
Folder=libmatroska
Compile=1
CompileCpp=1
OverrideBuildCmd=0
BuildCmd=
[Unit16]
FileName=..\..\src\KaxClusterData.h
Folder=libmatroska
Compile=1
CompileCpp=1
OverrideBuildCmd=0
BuildCmd=
[Unit17]
FileName=..\..\src\KaxConfig.h
Folder=libmatroska
Compile=1
CompileCpp=1
OverrideBuildCmd=0
BuildCmd=
[Unit18]
FileName=..\..\src\KaxContexts.cpp
Folder=libmatroska
Compile=1
CompileCpp=1
OverrideBuildCmd=0
BuildCmd=
[Unit19]
FileName=..\..\src\KaxContexts.h
Folder=libmatroska
Compile=1
CompileCpp=1
OverrideBuildCmd=0
BuildCmd=
[Unit20]
FileName=..\..\src\KaxCues.cpp
Folder=libmatroska
Compile=1
CompileCpp=1
OverrideBuildCmd=0
BuildCmd=
[Unit21]
FileName=..\..\src\KaxCues.h
Folder=libmatroska
Compile=1
CompileCpp=1
OverrideBuildCmd=0
BuildCmd=
[Unit22]
FileName=..\..\src\KaxCuesData.cpp
Folder=libmatroska
Compile=1
CompileCpp=1
OverrideBuildCmd=0
BuildCmd=
[Unit23]
FileName=..\..\src\KaxCuesData.h
Folder=libmatroska
Compile=1
CompileCpp=1
OverrideBuildCmd=0
BuildCmd=
[Unit24]
FileName=..\..\src\KaxInfo.cpp
Folder=libmatroska
Compile=1
CompileCpp=1
OverrideBuildCmd=0
BuildCmd=
[Unit25]
FileName=..\..\src\KaxInfo.h
Folder=libmatroska
Compile=1
CompileCpp=1
OverrideBuildCmd=0
BuildCmd=
[Unit26]
FileName=..\..\src\KaxInfoData.cpp
Folder=libmatroska
Compile=1
CompileCpp=1
OverrideBuildCmd=0
BuildCmd=
[Unit27]
FileName=..\..\src\KaxInfoData.h
Folder=libmatroska
Compile=1
CompileCpp=1
OverrideBuildCmd=0
BuildCmd=
[Unit28]
FileName=..\..\src\KaxSeekHead.cpp
Folder=libmatroska
Compile=1
CompileCpp=1
OverrideBuildCmd=0
BuildCmd=
[Unit29]
FileName=..\..\src\KaxSeekHead.h
Folder=libmatroska
Compile=1
CompileCpp=1
OverrideBuildCmd=0
BuildCmd=
[Unit30]
FileName=..\..\src\KaxSegment.cpp
Folder=libmatroska
Compile=1
CompileCpp=1
OverrideBuildCmd=0
BuildCmd=
[Unit31]
FileName=..\..\src\KaxSegment.h
Folder=libmatroska
Compile=1
CompileCpp=1
OverrideBuildCmd=0
BuildCmd=
[Unit32]
FileName=..\..\src\KaxTrackAudio.cpp
Folder=libmatroska
Compile=1
CompileCpp=1
OverrideBuildCmd=0
BuildCmd=
[Unit33]
FileName=..\..\src\KaxTrackAudio.h
Folder=libmatroska
Compile=1
CompileCpp=1
OverrideBuildCmd=0
BuildCmd=
[Unit34]
FileName=..\..\src\KaxTrackEntryData.cpp
Folder=libmatroska
Compile=1
CompileCpp=1
OverrideBuildCmd=0
BuildCmd=
[Unit35]
FileName=..\..\src\KaxTrackEntryData.h
Folder=libmatroska
Compile=1
CompileCpp=1
OverrideBuildCmd=0
BuildCmd=
[Unit36]
FileName=..\..\src\KaxTracks.cpp
Folder=libmatroska
Compile=1
CompileCpp=1
OverrideBuildCmd=0
BuildCmd=
[Unit37]
FileName=..\..\src\KaxTracks.h
Folder=libmatroska
Compile=1
CompileCpp=1
OverrideBuildCmd=0
BuildCmd=
[Unit38]
FileName=..\..\src\KaxTrackVideo.cpp
Folder=libmatroska
Compile=1
CompileCpp=1
OverrideBuildCmd=0
BuildCmd=
[Unit39]
FileName=..\..\src\KaxTrackVideo.h
Folder=libmatroska
Compile=1
CompileCpp=1
OverrideBuildCmd=0
BuildCmd=
[Unit40]
FileName=..\..\src\KaxTypes.h
Folder=libmatroska
Compile=1
CompileCpp=1
OverrideBuildCmd=0
BuildCmd=
[Unit41]
FileName=..\..\src\KaxVersion.cpp
Folder=libmatroska
Compile=1
CompileCpp=1
OverrideBuildCmd=0
BuildCmd=
[Unit42]
FileName=..\..\src\KaxVersion.h
Folder=libmatroska
Compile=1
CompileCpp=1
OverrideBuildCmd=0
BuildCmd=
[Unit43]
FileName=..\..\src\FileKax.cpp
Folder=libmatroska
Compile=1
CompileCpp=1
OverrideBuildCmd=0
BuildCmd=
[VersionInfo]
Major=0
Minor=1
Release=1
Build=1
LanguageID=1033
CharsetID=1252
CompanyName=
FileVersion=
FileDescription=Developed using the Dev-C++ IDE
InternalName=
LegalCopyright=
LegalTrademarks=
OriginalFilename=
ProductName=
ProductVersion=

View File

@ -0,0 +1,27 @@
# Project: test6
# Makefile created by Dev-C++ 4.9.7.0
CPP = g++.exe
CC = gcc.exe
WINDRES = windres.exe
RES =
OBJ = ../../../test/mux/test6.o $(RES)
LIBS = -L"D:/DEV-CPP/lib" "../libmatroska.a" "../../../../libebml/make/mingw32/libebml.a"
INCS = -I"D:/DEV-CPP/include" -I"D:/DEV-CPP/include/c++" -I"D:/DEV-CPP/include" -I"D:/Dev-Cpp/include/c++/mingw32" -I"../../../../libebml/src" -I"../../../src"
BIN = test6.exe
CXXFLAGS = $(INCS)
CFLAGS = $(INCS)
.PHONY: all all-before all-after clean clean-custom
all: all-before test6.exe all-after
clean: clean-custom
rm -f $(OBJ) $(BIN)
$(BIN): $(OBJ)
$(CPP) $(OBJ) -o "test6.exe" $(LIBS) $(CXXFLAGS)
../../../test/mux/test6.o: ../../../test/mux/test6.cpp
$(CPP) -c ../../../test/mux/test6.cpp -o ../../../test/mux/test6.o $(CXXFLAGS)

View File

@ -0,0 +1,54 @@
[Project]
FileName=test6.dev
Name=test6
UnitCount=1
Type=1
Ver=1
ObjFiles=
Includes=..\..\..\..\libebml\src;..\..\..\src
Libs=
PrivateResource=
ResourceIncludes=
MakeIncludes=
Resources=
Compiler=
Linker="..\libmatroska.a" "..\..\..\..\libebml\make\mingw32\libebml.a"
IsCpp=1
Icon=
ExeOutput=
ObjectOutput=
OverrideOutput=0
OverrideOutputName=test6.exe
HostApplication=
Folders=
CommandLine=
IncludeVersionInfo=0
SupportXPThemes=0
CompilerSet=0
CompilerSettings=000000000000000000
[Unit1]
FileName=..\..\..\test\mux\test6.cpp
Folder=test6
Compile=1
CompileCpp=1
OverrideBuildCmd=0
BuildCmd=
[VersionInfo]
Major=0
Minor=1
Release=1
Build=1
LanguageID=1033
CharsetID=1252
CompanyName=
FileVersion=
FileDescription=Developed using the Dev-C++ IDE
InternalName=
LegalCopyright=
LegalTrademarks=
OriginalFilename=
ProductName=
ProductVersion=

View File

@ -0,0 +1,54 @@
[Project]
FileName=test8.dev
Name=test8
UnitCount=1
Type=1
Ver=1
ObjFiles=
Includes=..\..\..\..\libebml\src;..\..\..\src
Libs=
PrivateResource=
ResourceIncludes=
MakeIncludes=
Resources=
Compiler=
Linker="..\libmatroska.a" "..\..\..\..\libebml\make\mingw32\libebml.a"
IsCpp=1
Icon=
ExeOutput=
ObjectOutput=
OverrideOutput=0
OverrideOutputName=test8.exe
HostApplication=
Folders=
CommandLine=
IncludeVersionInfo=0
SupportXPThemes=0
CompilerSet=0
CompilerSettings=000000000000000000
[Unit1]
FileName=..\..\..\test\mux\test8.cpp
Folder=test8
Compile=1
CompileCpp=1
OverrideBuildCmd=0
BuildCmd=
[VersionInfo]
Major=0
Minor=1
Release=1
Build=1
LanguageID=1033
CharsetID=1252
CompanyName=
FileVersion=
FileDescription=Developed using the Dev-C++ IDE
InternalName=
LegalCopyright=
LegalTrademarks=
OriginalFilename=
ProductName=
ProductVersion=

View File

@ -0,0 +1,292 @@
# Microsoft Developer Studio Project File - Name="libmatroska" - Package Owner=<4>
# Microsoft Developer Studio Generated Build File, Format Version 6.00
# ** DO NOT EDIT **
# TARGTYPE "Win32 (x86) Static Library" 0x0104
CFG=libmatroska - Win32 Debug
!MESSAGE This is not a valid makefile. To build this project using NMAKE,
!MESSAGE use the Export Makefile command and run
!MESSAGE
!MESSAGE NMAKE /f "libmatroska.mak".
!MESSAGE
!MESSAGE You can specify a configuration when running NMAKE
!MESSAGE by defining the macro CFG on the command line. For example:
!MESSAGE
!MESSAGE NMAKE /f "libmatroska.mak" CFG="libmatroska - Win32 Debug"
!MESSAGE
!MESSAGE Possible choices for configuration are:
!MESSAGE
!MESSAGE "libmatroska - Win32 Release" (based on "Win32 (x86) Static Library")
!MESSAGE "libmatroska - Win32 Debug" (based on "Win32 (x86) Static Library")
!MESSAGE
# Begin Project
# PROP AllowPerConfigDependencies 0
# PROP Scc_ProjName ""
# PROP Scc_LocalPath ""
CPP=cl.exe
RSC=rc.exe
!IF "$(CFG)" == "libmatroska - Win32 Release"
# PROP BASE Use_MFC 0
# PROP BASE Use_Debug_Libraries 0
# PROP BASE Output_Dir "Release"
# PROP BASE Intermediate_Dir "Release"
# PROP BASE Target_Dir ""
# PROP Use_MFC 0
# PROP Use_Debug_Libraries 0
# PROP Output_Dir "Release"
# PROP Intermediate_Dir "Release"
# PROP Target_Dir ""
# ADD BASE CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_MBCS" /D "_LIB" /YX /FD /c
# ADD CPP /nologo /MT /W3 /GX /O2 /I "../../../../../libebml" /I "../../../.." /D "WIN32" /D "NDEBUG" /D "_MBCS" /D "_LIB" /YX /FD /c
# ADD BASE RSC /l 0x40c /d "NDEBUG"
# ADD RSC /l 0x809 /d "NDEBUG"
BSC32=bscmake.exe
# ADD BASE BSC32 /nologo
# ADD BSC32 /nologo
LIB32=link.exe -lib
# ADD BASE LIB32 /nologo
# ADD LIB32 /nologo
!ELSEIF "$(CFG)" == "libmatroska - Win32 Debug"
# PROP BASE Use_MFC 0
# PROP BASE Use_Debug_Libraries 1
# PROP BASE Output_Dir "Debug"
# PROP BASE Intermediate_Dir "Debug"
# PROP BASE Target_Dir ""
# PROP Use_MFC 0
# PROP Use_Debug_Libraries 1
# PROP Output_Dir "Debug"
# PROP Intermediate_Dir "Debug"
# PROP Target_Dir ""
# ADD BASE CPP /nologo /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_MBCS" /D "_LIB" /YX /FD /GZ /c
# ADD CPP /nologo /MTd /W3 /Gm /GR /GX /ZI /Od /I "../../../../../libebml" /I "../../../.." /D "WIN32" /D "_DEBUG" /D "_MBCS" /D "_LIB" /YX /FD /GZ /c
# ADD BASE RSC /l 0x40c /d "_DEBUG"
# ADD RSC /l 0x809 /d "_DEBUG"
BSC32=bscmake.exe
# ADD BASE BSC32 /nologo
# ADD BSC32 /nologo
LIB32=link.exe -lib
# ADD BASE LIB32 /nologo
# ADD LIB32 /nologo
!ENDIF
# Begin Target
# Name "libmatroska - Win32 Release"
# Name "libmatroska - Win32 Debug"
# Begin Group "Source Files"
# PROP Default_Filter "cpp;c;cxx;rc;def;r;odl;idl;hpj;bat"
# Begin Source File
SOURCE=..\..\..\..\src\FileKax.cpp
# End Source File
# Begin Source File
SOURCE=..\..\..\..\src\KaxAttached.cpp
# End Source File
# Begin Source File
SOURCE=..\..\..\..\src\KaxAttachments.cpp
# End Source File
# Begin Source File
SOURCE=..\..\..\..\src\KaxBlock.cpp
# End Source File
# Begin Source File
SOURCE=..\..\..\..\src\KaxBlockData.cpp
# End Source File
# Begin Source File
SOURCE=..\..\..\..\src\KaxChapters.cpp
# End Source File
# Begin Source File
SOURCE=..\..\..\..\src\KaxCluster.cpp
# End Source File
# Begin Source File
SOURCE=..\..\..\..\src\KaxClusterData.cpp
# End Source File
# Begin Source File
SOURCE=..\..\..\..\src\KaxContentEncoding.cpp
# End Source File
# Begin Source File
SOURCE=..\..\..\..\src\KaxContexts.cpp
# End Source File
# Begin Source File
SOURCE=..\..\..\..\src\KaxCues.cpp
# End Source File
# Begin Source File
SOURCE=..\..\..\..\src\KaxCuesData.cpp
# End Source File
# Begin Source File
SOURCE=..\..\..\..\src\KaxInfo.cpp
# End Source File
# Begin Source File
SOURCE=..\..\..\..\src\KaxInfoData.cpp
# End Source File
# Begin Source File
SOURCE=..\..\..\..\src\KaxSeekHead.cpp
# End Source File
# Begin Source File
SOURCE=..\..\..\..\src\KaxSegment.cpp
# End Source File
# Begin Source File
SOURCE=..\..\..\..\src\KaxTag.cpp
# End Source File
# Begin Source File
SOURCE=..\..\..\..\src\KaxTagMulti.cpp
# End Source File
# Begin Source File
SOURCE=..\..\..\..\src\KaxTags.cpp
# End Source File
# Begin Source File
SOURCE=..\..\..\..\src\KaxTrackAudio.cpp
# End Source File
# Begin Source File
SOURCE=..\..\..\..\src\KaxTrackEntryData.cpp
# End Source File
# Begin Source File
SOURCE=..\..\..\..\src\KaxTracks.cpp
# End Source File
# Begin Source File
SOURCE=..\..\..\..\src\KaxTrackVideo.cpp
# End Source File
# Begin Source File
SOURCE=..\..\..\..\src\KaxVersion.cpp
# End Source File
# End Group
# Begin Group "Header Files"
# PROP Default_Filter "h;hpp;hxx;hm;inl"
# Begin Source File
SOURCE=..\..\..\..\matroska\FileKax.h
# End Source File
# Begin Source File
SOURCE=..\..\..\..\matroska\KaxAttached.h
# End Source File
# Begin Source File
SOURCE=..\..\..\..\matroska\KaxAttachments.h
# End Source File
# Begin Source File
SOURCE=..\..\..\..\matroska\KaxBlock.h
# End Source File
# Begin Source File
SOURCE=..\..\..\..\matroska\KaxBlockData.h
# End Source File
# Begin Source File
SOURCE=..\..\..\..\matroska\KaxChapters.h
# End Source File
# Begin Source File
SOURCE=..\..\..\..\matroska\KaxCluster.h
# End Source File
# Begin Source File
SOURCE=..\..\..\..\matroska\KaxClusterData.h
# End Source File
# Begin Source File
SOURCE=..\..\..\..\matroska\KaxConfig.h
# End Source File
# Begin Source File
SOURCE=..\..\..\..\matroska\KaxContentEncoding.h
# End Source File
# Begin Source File
SOURCE=..\..\..\..\matroska\KaxContexts.h
# End Source File
# Begin Source File
SOURCE=..\..\..\..\matroska\KaxCues.h
# End Source File
# Begin Source File
SOURCE=..\..\..\..\matroska\KaxCuesData.h
# End Source File
# Begin Source File
SOURCE=..\..\..\..\matroska\KaxInfo.h
# End Source File
# Begin Source File
SOURCE=..\..\..\..\matroska\KaxInfoData.h
# End Source File
# Begin Source File
SOURCE=..\..\..\..\matroska\KaxSeekHead.h
# End Source File
# Begin Source File
SOURCE=..\..\..\..\matroska\KaxSegment.h
# End Source File
# Begin Source File
SOURCE=..\..\..\..\matroska\KaxTag.h
# End Source File
# Begin Source File
SOURCE=..\..\..\..\matroska\KaxTagMulti.h
# End Source File
# Begin Source File
SOURCE=..\..\..\..\matroska\KaxTags.h
# End Source File
# Begin Source File
SOURCE=..\..\..\..\matroska\KaxTrackAudio.h
# End Source File
# Begin Source File
SOURCE=..\..\..\..\matroska\KaxTrackEntryData.h
# End Source File
# Begin Source File
SOURCE=..\..\..\..\matroska\KaxTracks.h
# End Source File
# Begin Source File
SOURCE=..\..\..\..\matroska\KaxTrackVideo.h
# End Source File
# Begin Source File
SOURCE=..\..\..\..\matroska\KaxTypes.h
# End Source File
# Begin Source File
SOURCE=..\..\..\..\matroska\KaxVersion.h
# End Source File
# End Group
# End Target
# End Project

100
make/vc6/test/test0.dsp Normal file
View File

@ -0,0 +1,100 @@
# Microsoft Developer Studio Project File - Name="test0" - Package Owner=<4>
# Microsoft Developer Studio Generated Build File, Format Version 6.00
# ** DO NOT EDIT **
# TARGTYPE "Win32 (x86) Console Application" 0x0103
CFG=test0 - Win32 Debug
!MESSAGE This is not a valid makefile. To build this project using NMAKE,
!MESSAGE use the Export Makefile command and run
!MESSAGE
!MESSAGE NMAKE /f "test0.mak".
!MESSAGE
!MESSAGE You can specify a configuration when running NMAKE
!MESSAGE by defining the macro CFG on the command line. For example:
!MESSAGE
!MESSAGE NMAKE /f "test0.mak" CFG="test0 - Win32 Debug"
!MESSAGE
!MESSAGE Possible choices for configuration are:
!MESSAGE
!MESSAGE "test0 - Win32 Release" (based on "Win32 (x86) Console Application")
!MESSAGE "test0 - Win32 Debug" (based on "Win32 (x86) Console Application")
!MESSAGE
# Begin Project
# PROP AllowPerConfigDependencies 0
# PROP Scc_ProjName ""
# PROP Scc_LocalPath ""
CPP=cl.exe
RSC=rc.exe
!IF "$(CFG)" == "test0 - Win32 Release"
# PROP BASE Use_MFC 0
# PROP BASE Use_Debug_Libraries 0
# PROP BASE Output_Dir "Release"
# PROP BASE Intermediate_Dir "Release"
# PROP BASE Target_Dir ""
# PROP Use_MFC 0
# PROP Use_Debug_Libraries 0
# PROP Output_Dir "Release"
# PROP Intermediate_Dir "Release"
# PROP Target_Dir ""
# ADD BASE CPP /nologo /MT /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /c
# ADD CPP /nologo /MT /W3 /GX /O2 /I "../../../src" /I "../../../../libebml/src" /D "WIN32" /D "NDEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /c
# ADD BASE RSC /l 0x40c /d "NDEBUG"
# ADD RSC /l 0x40c /d "NDEBUG"
BSC32=bscmake.exe
# ADD BASE BSC32 /nologo
# ADD BSC32 /nologo
LINK32=link.exe
# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /machine:I386
# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /machine:I386
!ELSEIF "$(CFG)" == "test0 - Win32 Debug"
# PROP BASE Use_MFC 0
# PROP BASE Use_Debug_Libraries 1
# PROP BASE Output_Dir "Debug"
# PROP BASE Intermediate_Dir "Debug"
# PROP BASE Target_Dir ""
# PROP Use_MFC 0
# PROP Use_Debug_Libraries 1
# PROP Output_Dir "Debug"
# PROP Intermediate_Dir "Debug"
# PROP Target_Dir ""
# ADD BASE CPP /nologo /MTd /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /GZ /c
# ADD CPP /nologo /MTd /W3 /Gm /GR /GX /ZI /Od /I "../../../src" /I "../../../../libebml/src" /D "WIN32" /D "_DEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /GZ /c
# ADD BASE RSC /l 0x40c /d "_DEBUG"
# ADD RSC /l 0x40c /d "_DEBUG"
BSC32=bscmake.exe
# ADD BASE BSC32 /nologo
# ADD BSC32 /nologo
LINK32=link.exe
# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /debug /machine:I386 /pdbtype:sept
# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /debug /machine:I386 /pdbtype:sept
!ENDIF
# Begin Target
# Name "test0 - Win32 Release"
# Name "test0 - Win32 Debug"
# Begin Group "Source Files"
# PROP Default_Filter "cpp;c;cxx;rc;def;r;odl;idl;hpj;bat"
# Begin Source File
SOURCE=..\..\..\test\ebml\test0.cpp
# End Source File
# End Group
# Begin Group "Header Files"
# PROP Default_Filter "h;hpp;hxx;hm;inl"
# End Group
# Begin Group "Resource Files"
# PROP Default_Filter "ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe"
# End Group
# End Target
# End Project

100
make/vc6/test/test00.dsp Normal file
View File

@ -0,0 +1,100 @@
# Microsoft Developer Studio Project File - Name="test00" - Package Owner=<4>
# Microsoft Developer Studio Generated Build File, Format Version 6.00
# ** DO NOT EDIT **
# TARGTYPE "Win32 (x86) Console Application" 0x0103
CFG=test00 - Win32 Debug
!MESSAGE This is not a valid makefile. To build this project using NMAKE,
!MESSAGE use the Export Makefile command and run
!MESSAGE
!MESSAGE NMAKE /f "test00.mak".
!MESSAGE
!MESSAGE You can specify a configuration when running NMAKE
!MESSAGE by defining the macro CFG on the command line. For example:
!MESSAGE
!MESSAGE NMAKE /f "test00.mak" CFG="test00 - Win32 Debug"
!MESSAGE
!MESSAGE Possible choices for configuration are:
!MESSAGE
!MESSAGE "test00 - Win32 Release" (based on "Win32 (x86) Console Application")
!MESSAGE "test00 - Win32 Debug" (based on "Win32 (x86) Console Application")
!MESSAGE
# Begin Project
# PROP AllowPerConfigDependencies 0
# PROP Scc_ProjName ""
# PROP Scc_LocalPath ""
CPP=cl.exe
RSC=rc.exe
!IF "$(CFG)" == "test00 - Win32 Release"
# PROP BASE Use_MFC 0
# PROP BASE Use_Debug_Libraries 0
# PROP BASE Output_Dir "Release"
# PROP BASE Intermediate_Dir "Release"
# PROP BASE Target_Dir ""
# PROP Use_MFC 0
# PROP Use_Debug_Libraries 0
# PROP Output_Dir "Release"
# PROP Intermediate_Dir "Release"
# PROP Target_Dir ""
# ADD BASE CPP /nologo /MT /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /c
# ADD CPP /nologo /MT /W3 /GX /O2 /I "../../../src" /I "../../../../libebml/src" /D "WIN32" /D "NDEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /c
# ADD BASE RSC /l 0x40c /d "NDEBUG"
# ADD RSC /l 0x40c /d "NDEBUG"
BSC32=bscmake.exe
# ADD BASE BSC32 /nologo
# ADD BSC32 /nologo
LINK32=link.exe
# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /machine:I386
# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /machine:I386
!ELSEIF "$(CFG)" == "test00 - Win32 Debug"
# PROP BASE Use_MFC 0
# PROP BASE Use_Debug_Libraries 1
# PROP BASE Output_Dir "Debug"
# PROP BASE Intermediate_Dir "Debug"
# PROP BASE Target_Dir ""
# PROP Use_MFC 0
# PROP Use_Debug_Libraries 1
# PROP Output_Dir "Debug"
# PROP Intermediate_Dir "Debug"
# PROP Target_Dir ""
# ADD BASE CPP /nologo /MTd /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /GZ /c
# ADD CPP /nologo /MTd /W3 /Gm /GR /GX /ZI /Od /I "../../../src" /I "../../../../libebml/src" /D "WIN32" /D "_DEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /GZ /c
# ADD BASE RSC /l 0x40c /d "_DEBUG"
# ADD RSC /l 0x40c /d "_DEBUG"
BSC32=bscmake.exe
# ADD BASE BSC32 /nologo
# ADD BSC32 /nologo
LINK32=link.exe
# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /debug /machine:I386 /pdbtype:sept
# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /debug /machine:I386 /pdbtype:sept
!ENDIF
# Begin Target
# Name "test00 - Win32 Release"
# Name "test00 - Win32 Debug"
# Begin Group "Source Files"
# PROP Default_Filter "cpp;c;cxx;rc;def;r;odl;idl;hpj;bat"
# Begin Source File
SOURCE=..\..\..\test\ebml\test00.cpp
# End Source File
# End Group
# Begin Group "Header Files"
# PROP Default_Filter "h;hpp;hxx;hm;inl"
# End Group
# Begin Group "Resource Files"
# PROP Default_Filter "ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe"
# End Group
# End Target
# End Project

100
make/vc6/test/test1.dsp Normal file
View File

@ -0,0 +1,100 @@
# Microsoft Developer Studio Project File - Name="test1" - Package Owner=<4>
# Microsoft Developer Studio Generated Build File, Format Version 6.00
# ** DO NOT EDIT **
# TARGTYPE "Win32 (x86) Console Application" 0x0103
CFG=test1 - Win32 Debug
!MESSAGE This is not a valid makefile. To build this project using NMAKE,
!MESSAGE use the Export Makefile command and run
!MESSAGE
!MESSAGE NMAKE /f "test1.mak".
!MESSAGE
!MESSAGE You can specify a configuration when running NMAKE
!MESSAGE by defining the macro CFG on the command line. For example:
!MESSAGE
!MESSAGE NMAKE /f "test1.mak" CFG="test1 - Win32 Debug"
!MESSAGE
!MESSAGE Possible choices for configuration are:
!MESSAGE
!MESSAGE "test1 - Win32 Release" (based on "Win32 (x86) Console Application")
!MESSAGE "test1 - Win32 Debug" (based on "Win32 (x86) Console Application")
!MESSAGE
# Begin Project
# PROP AllowPerConfigDependencies 0
# PROP Scc_ProjName ""
# PROP Scc_LocalPath ""
CPP=xicl6.exe
RSC=rc.exe
!IF "$(CFG)" == "test1 - Win32 Release"
# PROP BASE Use_MFC 0
# PROP BASE Use_Debug_Libraries 0
# PROP BASE Output_Dir "Release"
# PROP BASE Intermediate_Dir "Release"
# PROP BASE Target_Dir ""
# PROP Use_MFC 0
# PROP Use_Debug_Libraries 0
# PROP Output_Dir "Release"
# PROP Intermediate_Dir "Release"
# PROP Target_Dir ""
# ADD BASE CPP /nologo /MT /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /c
# ADD CPP /nologo /MT /W3 /GX /O2 /I "../../../src" /D "WIN32" /D "NDEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /c
# ADD BASE RSC /l 0x40c /d "NDEBUG"
# ADD RSC /l 0x40c /d "NDEBUG"
BSC32=bscmake.exe
# ADD BASE BSC32 /nologo
# ADD BSC32 /nologo
LINK32=xilink6.exe
# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /machine:I386
# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /machine:I386
!ELSEIF "$(CFG)" == "test1 - Win32 Debug"
# PROP BASE Use_MFC 0
# PROP BASE Use_Debug_Libraries 1
# PROP BASE Output_Dir "Debug"
# PROP BASE Intermediate_Dir "Debug"
# PROP BASE Target_Dir ""
# PROP Use_MFC 0
# PROP Use_Debug_Libraries 1
# PROP Output_Dir "Debug"
# PROP Intermediate_Dir "Debug"
# PROP Target_Dir ""
# ADD BASE CPP /nologo /MTd /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /GZ /c
# ADD CPP /nologo /MTd /W3 /Gm /GX /ZI /Od /I "../../../src" /D "WIN32" /D "_DEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /GZ /c
# ADD BASE RSC /l 0x40c /d "_DEBUG"
# ADD RSC /l 0x40c /d "_DEBUG"
BSC32=bscmake.exe
# ADD BASE BSC32 /nologo
# ADD BSC32 /nologo
LINK32=xilink6.exe
# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /debug /machine:I386 /pdbtype:sept
# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /debug /machine:I386 /pdbtype:sept
!ENDIF
# Begin Target
# Name "test1 - Win32 Release"
# Name "test1 - Win32 Debug"
# Begin Group "Source Files"
# PROP Default_Filter "cpp;c;cxx;rc;def;r;odl;idl;hpj;bat"
# Begin Source File
SOURCE=..\..\..\test\block\test1.cpp
# End Source File
# End Group
# Begin Group "Header Files"
# PROP Default_Filter "h;hpp;hxx;hm;inl"
# End Group
# Begin Group "Resource Files"
# PROP Default_Filter "ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe"
# End Group
# End Target
# End Project

100
make/vc6/test/test2.dsp Normal file
View File

@ -0,0 +1,100 @@
# Microsoft Developer Studio Project File - Name="test2" - Package Owner=<4>
# Microsoft Developer Studio Generated Build File, Format Version 6.00
# ** DO NOT EDIT **
# TARGTYPE "Win32 (x86) Console Application" 0x0103
CFG=test2 - Win32 Debug
!MESSAGE This is not a valid makefile. To build this project using NMAKE,
!MESSAGE use the Export Makefile command and run
!MESSAGE
!MESSAGE NMAKE /f "test2.mak".
!MESSAGE
!MESSAGE You can specify a configuration when running NMAKE
!MESSAGE by defining the macro CFG on the command line. For example:
!MESSAGE
!MESSAGE NMAKE /f "test2.mak" CFG="test2 - Win32 Debug"
!MESSAGE
!MESSAGE Possible choices for configuration are:
!MESSAGE
!MESSAGE "test2 - Win32 Release" (based on "Win32 (x86) Console Application")
!MESSAGE "test2 - Win32 Debug" (based on "Win32 (x86) Console Application")
!MESSAGE
# Begin Project
# PROP AllowPerConfigDependencies 0
# PROP Scc_ProjName ""
# PROP Scc_LocalPath ""
CPP=xicl6.exe
RSC=rc.exe
!IF "$(CFG)" == "test2 - Win32 Release"
# PROP BASE Use_MFC 0
# PROP BASE Use_Debug_Libraries 0
# PROP BASE Output_Dir "Release"
# PROP BASE Intermediate_Dir "Release"
# PROP BASE Target_Dir ""
# PROP Use_MFC 0
# PROP Use_Debug_Libraries 0
# PROP Output_Dir "Release"
# PROP Intermediate_Dir "Release"
# PROP Target_Dir ""
# ADD BASE CPP /nologo /MT /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /c
# ADD CPP /nologo /MT /W3 /GX /O2 /I "../../../src" /D "WIN32" /D "NDEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /c
# ADD BASE RSC /l 0x40c /d "NDEBUG"
# ADD RSC /l 0x40c /d "NDEBUG"
BSC32=bscmake.exe
# ADD BASE BSC32 /nologo
# ADD BSC32 /nologo
LINK32=xilink6.exe
# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /machine:I386
# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /machine:I386
!ELSEIF "$(CFG)" == "test2 - Win32 Debug"
# PROP BASE Use_MFC 0
# PROP BASE Use_Debug_Libraries 1
# PROP BASE Output_Dir "Debug"
# PROP BASE Intermediate_Dir "Debug"
# PROP BASE Target_Dir ""
# PROP Use_MFC 0
# PROP Use_Debug_Libraries 1
# PROP Output_Dir "Debug"
# PROP Intermediate_Dir "Debug"
# PROP Target_Dir ""
# ADD BASE CPP /nologo /MTd /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /GZ /c
# ADD CPP /nologo /MTd /W3 /Gm /GX /ZI /Od /I "../../../src" /D "WIN32" /D "_DEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /GZ /c
# ADD BASE RSC /l 0x40c /d "_DEBUG"
# ADD RSC /l 0x40c /d "_DEBUG"
BSC32=bscmake.exe
# ADD BASE BSC32 /nologo
# ADD BSC32 /nologo
LINK32=xilink6.exe
# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /debug /machine:I386 /pdbtype:sept
# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /debug /machine:I386 /pdbtype:sept
!ENDIF
# Begin Target
# Name "test2 - Win32 Release"
# Name "test2 - Win32 Debug"
# Begin Group "Source Files"
# PROP Default_Filter "cpp;c;cxx;rc;def;r;odl;idl;hpj;bat"
# Begin Source File
SOURCE=..\..\..\test\cluster\test2.cpp
# End Source File
# End Group
# Begin Group "Header Files"
# PROP Default_Filter "h;hpp;hxx;hm;inl"
# End Group
# Begin Group "Resource Files"
# PROP Default_Filter "ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe"
# End Group
# End Target
# End Project

100
make/vc6/test/test3.dsp Normal file
View File

@ -0,0 +1,100 @@
# Microsoft Developer Studio Project File - Name="test3" - Package Owner=<4>
# Microsoft Developer Studio Generated Build File, Format Version 6.00
# ** DO NOT EDIT **
# TARGTYPE "Win32 (x86) Console Application" 0x0103
CFG=test3 - Win32 Debug
!MESSAGE This is not a valid makefile. To build this project using NMAKE,
!MESSAGE use the Export Makefile command and run
!MESSAGE
!MESSAGE NMAKE /f "test3.mak".
!MESSAGE
!MESSAGE You can specify a configuration when running NMAKE
!MESSAGE by defining the macro CFG on the command line. For example:
!MESSAGE
!MESSAGE NMAKE /f "test3.mak" CFG="test3 - Win32 Debug"
!MESSAGE
!MESSAGE Possible choices for configuration are:
!MESSAGE
!MESSAGE "test3 - Win32 Release" (based on "Win32 (x86) Console Application")
!MESSAGE "test3 - Win32 Debug" (based on "Win32 (x86) Console Application")
!MESSAGE
# Begin Project
# PROP AllowPerConfigDependencies 0
# PROP Scc_ProjName ""
# PROP Scc_LocalPath ""
CPP=xicl6.exe
RSC=rc.exe
!IF "$(CFG)" == "test3 - Win32 Release"
# PROP BASE Use_MFC 0
# PROP BASE Use_Debug_Libraries 0
# PROP BASE Output_Dir "Release"
# PROP BASE Intermediate_Dir "Release"
# PROP BASE Target_Dir ""
# PROP Use_MFC 0
# PROP Use_Debug_Libraries 0
# PROP Output_Dir "Release"
# PROP Intermediate_Dir "Release"
# PROP Target_Dir ""
# ADD BASE CPP /nologo /MT /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /c
# ADD CPP /nologo /MT /W3 /GX /O2 /I "../../../src" /D "WIN32" /D "NDEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /c
# ADD BASE RSC /l 0x40c /d "NDEBUG"
# ADD RSC /l 0x40c /d "NDEBUG"
BSC32=bscmake.exe
# ADD BASE BSC32 /nologo
# ADD BSC32 /nologo
LINK32=xilink6.exe
# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /machine:I386
# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /machine:I386
!ELSEIF "$(CFG)" == "test3 - Win32 Debug"
# PROP BASE Use_MFC 0
# PROP BASE Use_Debug_Libraries 1
# PROP BASE Output_Dir "Debug"
# PROP BASE Intermediate_Dir "Debug"
# PROP BASE Target_Dir ""
# PROP Use_MFC 0
# PROP Use_Debug_Libraries 1
# PROP Output_Dir "Debug"
# PROP Intermediate_Dir "Debug"
# PROP Target_Dir ""
# ADD BASE CPP /nologo /MTd /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /GZ /c
# ADD CPP /nologo /MTd /W3 /Gm /GX /ZI /Od /I "../../../src" /D "WIN32" /D "_DEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /GZ /c
# ADD BASE RSC /l 0x40c /d "_DEBUG"
# ADD RSC /l 0x40c /d "_DEBUG"
BSC32=bscmake.exe
# ADD BASE BSC32 /nologo
# ADD BSC32 /nologo
LINK32=xilink6.exe
# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /debug /machine:I386 /pdbtype:sept
# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /debug /machine:I386 /pdbtype:sept
!ENDIF
# Begin Target
# Name "test3 - Win32 Release"
# Name "test3 - Win32 Debug"
# Begin Group "Source Files"
# PROP Default_Filter "cpp;c;cxx;rc;def;r;odl;idl;hpj;bat"
# Begin Source File
SOURCE=..\..\..\test\endian\test3.cpp
# End Source File
# End Group
# Begin Group "Header Files"
# PROP Default_Filter "h;hpp;hxx;hm;inl"
# End Group
# Begin Group "Resource Files"
# PROP Default_Filter "ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe"
# End Group
# End Target
# End Project

100
make/vc6/test/test4.dsp Normal file
View File

@ -0,0 +1,100 @@
# Microsoft Developer Studio Project File - Name="test4" - Package Owner=<4>
# Microsoft Developer Studio Generated Build File, Format Version 6.00
# ** DO NOT EDIT **
# TARGTYPE "Win32 (x86) Console Application" 0x0103
CFG=test4 - Win32 Debug
!MESSAGE This is not a valid makefile. To build this project using NMAKE,
!MESSAGE use the Export Makefile command and run
!MESSAGE
!MESSAGE NMAKE /f "test4.mak".
!MESSAGE
!MESSAGE You can specify a configuration when running NMAKE
!MESSAGE by defining the macro CFG on the command line. For example:
!MESSAGE
!MESSAGE NMAKE /f "test4.mak" CFG="test4 - Win32 Debug"
!MESSAGE
!MESSAGE Possible choices for configuration are:
!MESSAGE
!MESSAGE "test4 - Win32 Release" (based on "Win32 (x86) Console Application")
!MESSAGE "test4 - Win32 Debug" (based on "Win32 (x86) Console Application")
!MESSAGE
# Begin Project
# PROP AllowPerConfigDependencies 0
# PROP Scc_ProjName ""
# PROP Scc_LocalPath ""
CPP=xicl6.exe
RSC=rc.exe
!IF "$(CFG)" == "test4 - Win32 Release"
# PROP BASE Use_MFC 0
# PROP BASE Use_Debug_Libraries 0
# PROP BASE Output_Dir "Release"
# PROP BASE Intermediate_Dir "Release"
# PROP BASE Target_Dir ""
# PROP Use_MFC 0
# PROP Use_Debug_Libraries 0
# PROP Output_Dir "Release"
# PROP Intermediate_Dir "Release"
# PROP Target_Dir ""
# ADD BASE CPP /nologo /MT /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /c
# ADD CPP /nologo /MT /W3 /GX /O2 /I "../../../src" /D "WIN32" /D "NDEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /c
# ADD BASE RSC /l 0x40c /d "NDEBUG"
# ADD RSC /l 0x40c /d "NDEBUG"
BSC32=bscmake.exe
# ADD BASE BSC32 /nologo
# ADD BSC32 /nologo
LINK32=xilink6.exe
# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /machine:I386
# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /machine:I386
!ELSEIF "$(CFG)" == "test4 - Win32 Debug"
# PROP BASE Use_MFC 0
# PROP BASE Use_Debug_Libraries 1
# PROP BASE Output_Dir "Debug"
# PROP BASE Intermediate_Dir "Debug"
# PROP BASE Target_Dir ""
# PROP Use_MFC 0
# PROP Use_Debug_Libraries 1
# PROP Output_Dir "Debug"
# PROP Intermediate_Dir "Debug"
# PROP Target_Dir ""
# ADD BASE CPP /nologo /MTd /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /GZ /c
# ADD CPP /nologo /MTd /W3 /Gm /GX /ZI /Od /I "../../../src" /D "WIN32" /D "_DEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /GZ /c
# ADD BASE RSC /l 0x40c /d "_DEBUG"
# ADD RSC /l 0x40c /d "_DEBUG"
BSC32=bscmake.exe
# ADD BASE BSC32 /nologo
# ADD BSC32 /nologo
LINK32=xilink6.exe
# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /debug /machine:I386 /pdbtype:sept
# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /debug /machine:I386 /pdbtype:sept
!ENDIF
# Begin Target
# Name "test4 - Win32 Release"
# Name "test4 - Win32 Debug"
# Begin Group "Source Files"
# PROP Default_Filter "cpp;c;cxx;rc;def;r;odl;idl;hpj;bat"
# Begin Source File
SOURCE=..\..\..\test\header\test4.cpp
# End Source File
# End Group
# Begin Group "Header Files"
# PROP Default_Filter "h;hpp;hxx;hm;inl"
# End Group
# Begin Group "Resource Files"
# PROP Default_Filter "ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe"
# End Group
# End Target
# End Project

100
make/vc6/test/test5.dsp Normal file
View File

@ -0,0 +1,100 @@
# Microsoft Developer Studio Project File - Name="test5" - Package Owner=<4>
# Microsoft Developer Studio Generated Build File, Format Version 6.00
# ** DO NOT EDIT **
# TARGTYPE "Win32 (x86) Console Application" 0x0103
CFG=test5 - Win32 Debug
!MESSAGE This is not a valid makefile. To build this project using NMAKE,
!MESSAGE use the Export Makefile command and run
!MESSAGE
!MESSAGE NMAKE /f "test5.mak".
!MESSAGE
!MESSAGE You can specify a configuration when running NMAKE
!MESSAGE by defining the macro CFG on the command line. For example:
!MESSAGE
!MESSAGE NMAKE /f "test5.mak" CFG="test5 - Win32 Debug"
!MESSAGE
!MESSAGE Possible choices for configuration are:
!MESSAGE
!MESSAGE "test5 - Win32 Release" (based on "Win32 (x86) Console Application")
!MESSAGE "test5 - Win32 Debug" (based on "Win32 (x86) Console Application")
!MESSAGE
# Begin Project
# PROP AllowPerConfigDependencies 0
# PROP Scc_ProjName ""
# PROP Scc_LocalPath ""
CPP=xicl6.exe
RSC=rc.exe
!IF "$(CFG)" == "test5 - Win32 Release"
# PROP BASE Use_MFC 0
# PROP BASE Use_Debug_Libraries 0
# PROP BASE Output_Dir "Release"
# PROP BASE Intermediate_Dir "Release"
# PROP BASE Target_Dir ""
# PROP Use_MFC 0
# PROP Use_Debug_Libraries 0
# PROP Output_Dir "Release"
# PROP Intermediate_Dir "Release"
# PROP Target_Dir ""
# ADD BASE CPP /nologo /MT /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /c
# ADD CPP /nologo /MT /W3 /GX /O2 /I "../../../src" /D "WIN32" /D "NDEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /c
# ADD BASE RSC /l 0x40c /d "NDEBUG"
# ADD RSC /l 0x40c /d "NDEBUG"
BSC32=bscmake.exe
# ADD BASE BSC32 /nologo
# ADD BSC32 /nologo
LINK32=xilink6.exe
# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /machine:I386
# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /machine:I386
!ELSEIF "$(CFG)" == "test5 - Win32 Debug"
# PROP BASE Use_MFC 0
# PROP BASE Use_Debug_Libraries 1
# PROP BASE Output_Dir "Debug"
# PROP BASE Intermediate_Dir "Debug"
# PROP BASE Target_Dir ""
# PROP Use_MFC 0
# PROP Use_Debug_Libraries 1
# PROP Output_Dir "Debug"
# PROP Intermediate_Dir "Debug"
# PROP Target_Dir ""
# ADD BASE CPP /nologo /MTd /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /GZ /c
# ADD CPP /nologo /MTd /W3 /Gm /GX /ZI /Od /I "../../../src" /D "WIN32" /D "_DEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /GZ /c
# ADD BASE RSC /l 0x40c /d "_DEBUG"
# ADD RSC /l 0x40c /d "_DEBUG"
BSC32=bscmake.exe
# ADD BASE BSC32 /nologo
# ADD BSC32 /nologo
LINK32=xilink6.exe
# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /debug /machine:I386 /pdbtype:sept
# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /debug /machine:I386 /pdbtype:sept
!ENDIF
# Begin Target
# Name "test5 - Win32 Release"
# Name "test5 - Win32 Debug"
# Begin Group "Source Files"
# PROP Default_Filter "cpp;c;cxx;rc;def;r;odl;idl;hpj;bat"
# Begin Source File
SOURCE=..\..\..\test\utf8\test5.cpp
# End Source File
# End Group
# Begin Group "Header Files"
# PROP Default_Filter "h;hpp;hxx;hm;inl"
# End Group
# Begin Group "Resource Files"
# PROP Default_Filter "ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe"
# End Group
# End Target
# End Project

101
make/vc6/test/test6.dsp Normal file
View File

@ -0,0 +1,101 @@
# Microsoft Developer Studio Project File - Name="test6" - Package Owner=<4>
# Microsoft Developer Studio Generated Build File, Format Version 6.00
# ** DO NOT EDIT **
# TARGTYPE "Win32 (x86) Console Application" 0x0103
CFG=test6 - Win32 Debug
!MESSAGE This is not a valid makefile. To build this project using NMAKE,
!MESSAGE use the Export Makefile command and run
!MESSAGE
!MESSAGE NMAKE /f "test6.mak".
!MESSAGE
!MESSAGE You can specify a configuration when running NMAKE
!MESSAGE by defining the macro CFG on the command line. For example:
!MESSAGE
!MESSAGE NMAKE /f "test6.mak" CFG="test6 - Win32 Debug"
!MESSAGE
!MESSAGE Possible choices for configuration are:
!MESSAGE
!MESSAGE "test6 - Win32 Release" (based on "Win32 (x86) Console Application")
!MESSAGE "test6 - Win32 Debug" (based on "Win32 (x86) Console Application")
!MESSAGE
# Begin Project
# PROP AllowPerConfigDependencies 0
# PROP Scc_ProjName ""
# PROP Scc_LocalPath ""
CPP=cl.exe
RSC=rc.exe
!IF "$(CFG)" == "test6 - Win32 Release"
# PROP BASE Use_MFC 0
# PROP BASE Use_Debug_Libraries 0
# PROP BASE Output_Dir "Release"
# PROP BASE Intermediate_Dir "Release"
# PROP BASE Target_Dir ""
# PROP Use_MFC 0
# PROP Use_Debug_Libraries 0
# PROP Output_Dir "Release"
# PROP Intermediate_Dir "Release"
# PROP Ignore_Export_Lib 0
# PROP Target_Dir ""
# ADD BASE CPP /nologo /MT /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /c
# ADD CPP /nologo /MT /W3 /GX /O2 /I "../../.." /I "../../../../libebml" /D "WIN32" /D "NDEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /c
# ADD BASE RSC /l 0x40c /d "NDEBUG"
# ADD RSC /l 0x40c /d "NDEBUG"
BSC32=bscmake.exe
# ADD BASE BSC32 /nologo
# ADD BSC32 /nologo
LINK32=link.exe
# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /machine:I386
# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /machine:I386
!ELSEIF "$(CFG)" == "test6 - Win32 Debug"
# PROP BASE Use_MFC 0
# PROP BASE Use_Debug_Libraries 1
# PROP BASE Output_Dir "Debug"
# PROP BASE Intermediate_Dir "Debug"
# PROP BASE Target_Dir ""
# PROP Use_MFC 0
# PROP Use_Debug_Libraries 1
# PROP Output_Dir "Debug"
# PROP Intermediate_Dir "Debug"
# PROP Target_Dir ""
# ADD BASE CPP /nologo /MTd /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /GZ /c
# ADD CPP /nologo /MTd /W3 /Gm /GR /GX /ZI /Od /I "../../.." /I "../../../../libebml" /D "WIN32" /D "_DEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /GZ /c
# ADD BASE RSC /l 0x40c /d "_DEBUG"
# ADD RSC /l 0x40c /d "_DEBUG"
BSC32=bscmake.exe
# ADD BASE BSC32 /nologo
# ADD BSC32 /nologo
LINK32=link.exe
# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /debug /machine:I386 /pdbtype:sept
# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /debug /machine:I386 /pdbtype:sept
!ENDIF
# Begin Target
# Name "test6 - Win32 Release"
# Name "test6 - Win32 Debug"
# Begin Group "Source Files"
# PROP Default_Filter "cpp;c;cxx;rc;def;r;odl;idl;hpj;bat"
# Begin Source File
SOURCE=..\..\..\test\mux\test6.cpp
# End Source File
# End Group
# Begin Group "Header Files"
# PROP Default_Filter "h;hpp;hxx;hm;inl"
# End Group
# Begin Group "Resource Files"
# PROP Default_Filter "ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe"
# End Group
# End Target
# End Project

100
make/vc6/test/test6c.dsp Normal file
View File

@ -0,0 +1,100 @@
# Microsoft Developer Studio Project File - Name="test6c" - Package Owner=<4>
# Microsoft Developer Studio Generated Build File, Format Version 6.00
# ** DO NOT EDIT **
# TARGTYPE "Win32 (x86) Console Application" 0x0103
CFG=test6c - Win32 Debug
!MESSAGE This is not a valid makefile. To build this project using NMAKE,
!MESSAGE use the Export Makefile command and run
!MESSAGE
!MESSAGE NMAKE /f "test6c.mak".
!MESSAGE
!MESSAGE You can specify a configuration when running NMAKE
!MESSAGE by defining the macro CFG on the command line. For example:
!MESSAGE
!MESSAGE NMAKE /f "test6c.mak" CFG="test6c - Win32 Debug"
!MESSAGE
!MESSAGE Possible choices for configuration are:
!MESSAGE
!MESSAGE "test6c - Win32 Release" (based on "Win32 (x86) Console Application")
!MESSAGE "test6c - Win32 Debug" (based on "Win32 (x86) Console Application")
!MESSAGE
# Begin Project
# PROP AllowPerConfigDependencies 0
# PROP Scc_ProjName ""
# PROP Scc_LocalPath ""
CPP=xicl6.exe
RSC=rc.exe
!IF "$(CFG)" == "test6c - Win32 Release"
# PROP BASE Use_MFC 0
# PROP BASE Use_Debug_Libraries 0
# PROP BASE Output_Dir "Release"
# PROP BASE Intermediate_Dir "Release"
# PROP BASE Target_Dir ""
# PROP Use_MFC 0
# PROP Use_Debug_Libraries 0
# PROP Output_Dir "Release"
# PROP Intermediate_Dir "Release"
# PROP Target_Dir ""
# ADD BASE CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /c
# ADD CPP /nologo /W3 /GX /O2 /I "../../../src/api/c" /D "WIN32" /D "NDEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /c
# ADD BASE RSC /l 0x40c /d "NDEBUG"
# ADD RSC /l 0x40c /d "NDEBUG"
BSC32=bscmake.exe
# ADD BASE BSC32 /nologo
# ADD BSC32 /nologo
LINK32=xilink6.exe
# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /machine:I386
# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /machine:I386
!ELSEIF "$(CFG)" == "test6c - Win32 Debug"
# PROP BASE Use_MFC 0
# PROP BASE Use_Debug_Libraries 1
# PROP BASE Output_Dir "Debug"
# PROP BASE Intermediate_Dir "Debug"
# PROP BASE Target_Dir ""
# PROP Use_MFC 0
# PROP Use_Debug_Libraries 1
# PROP Output_Dir "Debug"
# PROP Intermediate_Dir "Debug"
# PROP Target_Dir ""
# ADD BASE CPP /nologo /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /GZ /c
# ADD CPP /nologo /W3 /Gm /GX /ZI /Od /I "../../../src/api/c" /D "WIN32" /D "_DEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /GZ /c
# ADD BASE RSC /l 0x40c /d "_DEBUG"
# ADD RSC /l 0x40c /d "_DEBUG"
BSC32=bscmake.exe
# ADD BASE BSC32 /nologo
# ADD BSC32 /nologo
LINK32=xilink6.exe
# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /debug /machine:I386 /pdbtype:sept
# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /debug /machine:I386 /pdbtype:sept
!ENDIF
# Begin Target
# Name "test6c - Win32 Release"
# Name "test6c - Win32 Debug"
# Begin Group "Source Files"
# PROP Default_Filter "cpp;c;cxx;rc;def;r;odl;idl;hpj;bat"
# Begin Source File
SOURCE="..\..\..\test\mux\test6.c"
# End Source File
# End Group
# Begin Group "Header Files"
# PROP Default_Filter "h;hpp;hxx;hm;inl"
# End Group
# Begin Group "Resource Files"
# PROP Default_Filter "ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe"
# End Group
# End Target
# End Project

100
make/vc6/test/test7.dsp Normal file
View File

@ -0,0 +1,100 @@
# Microsoft Developer Studio Project File - Name="test7" - Package Owner=<4>
# Microsoft Developer Studio Generated Build File, Format Version 6.00
# ** DO NOT EDIT **
# TARGTYPE "Win32 (x86) Console Application" 0x0103
CFG=test7 - Win32 Debug
!MESSAGE This is not a valid makefile. To build this project using NMAKE,
!MESSAGE use the Export Makefile command and run
!MESSAGE
!MESSAGE NMAKE /f "test7.mak".
!MESSAGE
!MESSAGE You can specify a configuration when running NMAKE
!MESSAGE by defining the macro CFG on the command line. For example:
!MESSAGE
!MESSAGE NMAKE /f "test7.mak" CFG="test7 - Win32 Debug"
!MESSAGE
!MESSAGE Possible choices for configuration are:
!MESSAGE
!MESSAGE "test7 - Win32 Release" (based on "Win32 (x86) Console Application")
!MESSAGE "test7 - Win32 Debug" (based on "Win32 (x86) Console Application")
!MESSAGE
# Begin Project
# PROP AllowPerConfigDependencies 0
# PROP Scc_ProjName ""
# PROP Scc_LocalPath ""
CPP=xicl6.exe
RSC=rc.exe
!IF "$(CFG)" == "test7 - Win32 Release"
# PROP BASE Use_MFC 0
# PROP BASE Use_Debug_Libraries 0
# PROP BASE Output_Dir "Release"
# PROP BASE Intermediate_Dir "Release"
# PROP BASE Target_Dir ""
# PROP Use_MFC 0
# PROP Use_Debug_Libraries 0
# PROP Output_Dir "Release"
# PROP Intermediate_Dir "Release"
# PROP Target_Dir ""
# ADD BASE CPP /nologo /MT /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /c
# ADD CPP /nologo /MT /W3 /GX /O2 /I "../../../src" /D "WIN32" /D "NDEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /c
# ADD BASE RSC /l 0x40c /d "NDEBUG"
# ADD RSC /l 0x40c /d "NDEBUG"
BSC32=bscmake.exe
# ADD BASE BSC32 /nologo
# ADD BSC32 /nologo
LINK32=xilink6.exe
# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /machine:I386
# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /machine:I386
!ELSEIF "$(CFG)" == "test7 - Win32 Debug"
# PROP BASE Use_MFC 0
# PROP BASE Use_Debug_Libraries 1
# PROP BASE Output_Dir "Debug"
# PROP BASE Intermediate_Dir "Debug"
# PROP BASE Target_Dir ""
# PROP Use_MFC 0
# PROP Use_Debug_Libraries 1
# PROP Output_Dir "Debug"
# PROP Intermediate_Dir "Debug"
# PROP Target_Dir ""
# ADD BASE CPP /nologo /MTd /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /GZ /c
# ADD CPP /nologo /MTd /W3 /Gm /GX /ZI /Od /I "../../../src" /D "WIN32" /D "_DEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /GZ /c
# ADD BASE RSC /l 0x40c /d "_DEBUG"
# ADD RSC /l 0x40c /d "_DEBUG"
BSC32=bscmake.exe
# ADD BASE BSC32 /nologo
# ADD BSC32 /nologo
LINK32=xilink6.exe
# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /debug /machine:I386 /pdbtype:sept
# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /debug /machine:I386 /pdbtype:sept
!ENDIF
# Begin Target
# Name "test7 - Win32 Release"
# Name "test7 - Win32 Debug"
# Begin Group "Source Files"
# PROP Default_Filter "cpp;c;cxx;rc;def;r;odl;idl;hpj;bat"
# Begin Source File
SOURCE=..\..\..\test\mux\test7.cpp
# End Source File
# End Group
# Begin Group "Header Files"
# PROP Default_Filter "h;hpp;hxx;hm;inl"
# End Group
# Begin Group "Resource Files"
# PROP Default_Filter "ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe"
# End Group
# End Target
# End Project

100
make/vc6/test/test8.dsp Normal file
View File

@ -0,0 +1,100 @@
# Microsoft Developer Studio Project File - Name="test8" - Package Owner=<4>
# Microsoft Developer Studio Generated Build File, Format Version 6.00
# ** DO NOT EDIT **
# TARGTYPE "Win32 (x86) Console Application" 0x0103
CFG=test8 - Win32 Debug
!MESSAGE This is not a valid makefile. To build this project using NMAKE,
!MESSAGE use the Export Makefile command and run
!MESSAGE
!MESSAGE NMAKE /f "test8.mak".
!MESSAGE
!MESSAGE You can specify a configuration when running NMAKE
!MESSAGE by defining the macro CFG on the command line. For example:
!MESSAGE
!MESSAGE NMAKE /f "test8.mak" CFG="test8 - Win32 Debug"
!MESSAGE
!MESSAGE Possible choices for configuration are:
!MESSAGE
!MESSAGE "test8 - Win32 Release" (based on "Win32 (x86) Console Application")
!MESSAGE "test8 - Win32 Debug" (based on "Win32 (x86) Console Application")
!MESSAGE
# Begin Project
# PROP AllowPerConfigDependencies 0
# PROP Scc_ProjName ""
# PROP Scc_LocalPath ""
CPP=cl.exe
RSC=rc.exe
!IF "$(CFG)" == "test8 - Win32 Release"
# PROP BASE Use_MFC 0
# PROP BASE Use_Debug_Libraries 0
# PROP BASE Output_Dir "Release"
# PROP BASE Intermediate_Dir "Release"
# PROP BASE Target_Dir ""
# PROP Use_MFC 0
# PROP Use_Debug_Libraries 0
# PROP Output_Dir "Release"
# PROP Intermediate_Dir "Release"
# PROP Target_Dir ""
# ADD BASE CPP /nologo /MT /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /c
# ADD CPP /nologo /MT /W3 /GX /O2 /I "../../.." /I "../../../../libebml" /D "WIN32" /D "NDEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /c
# ADD BASE RSC /l 0x40c /d "NDEBUG"
# ADD RSC /l 0x40c /d "NDEBUG"
BSC32=bscmake.exe
# ADD BASE BSC32 /nologo
# ADD BSC32 /nologo
LINK32=link.exe
# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /machine:I386
# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /machine:I386
!ELSEIF "$(CFG)" == "test8 - Win32 Debug"
# PROP BASE Use_MFC 0
# PROP BASE Use_Debug_Libraries 1
# PROP BASE Output_Dir "Debug"
# PROP BASE Intermediate_Dir "Debug"
# PROP BASE Target_Dir ""
# PROP Use_MFC 0
# PROP Use_Debug_Libraries 1
# PROP Output_Dir "Debug"
# PROP Intermediate_Dir "Debug"
# PROP Target_Dir ""
# ADD BASE CPP /nologo /MTd /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /GZ /c
# ADD CPP /nologo /MTd /W3 /Gm /GR /GX /ZI /Od /I "../../.." /I "../../../../libebml" /D "WIN32" /D "_DEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /GZ /c
# ADD BASE RSC /l 0x40c /d "_DEBUG"
# ADD RSC /l 0x40c /d "_DEBUG"
BSC32=bscmake.exe
# ADD BASE BSC32 /nologo
# ADD BSC32 /nologo
LINK32=link.exe
# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /debug /machine:I386 /pdbtype:sept
# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /debug /machine:I386 /pdbtype:sept
!ENDIF
# Begin Target
# Name "test8 - Win32 Release"
# Name "test8 - Win32 Debug"
# Begin Group "Source Files"
# PROP Default_Filter "cpp;c;cxx;rc;def;r;odl;idl;hpj;bat"
# Begin Source File
SOURCE=..\..\..\test\mux\test8.cpp
# End Source File
# End Group
# Begin Group "Header Files"
# PROP Default_Filter "h;hpp;hxx;hm;inl"
# End Group
# Begin Group "Resource Files"
# PROP Default_Filter "ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe"
# End Group
# End Target
# End Project

100
make/vc6/test/test8c.dsp Normal file
View File

@ -0,0 +1,100 @@
# Microsoft Developer Studio Project File - Name="test8c" - Package Owner=<4>
# Microsoft Developer Studio Generated Build File, Format Version 6.00
# ** DO NOT EDIT **
# TARGTYPE "Win32 (x86) Console Application" 0x0103
CFG=test8c - Win32 Debug
!MESSAGE This is not a valid makefile. To build this project using NMAKE,
!MESSAGE use the Export Makefile command and run
!MESSAGE
!MESSAGE NMAKE /f "test8c.mak".
!MESSAGE
!MESSAGE You can specify a configuration when running NMAKE
!MESSAGE by defining the macro CFG on the command line. For example:
!MESSAGE
!MESSAGE NMAKE /f "test8c.mak" CFG="test8c - Win32 Debug"
!MESSAGE
!MESSAGE Possible choices for configuration are:
!MESSAGE
!MESSAGE "test8c - Win32 Release" (based on "Win32 (x86) Console Application")
!MESSAGE "test8c - Win32 Debug" (based on "Win32 (x86) Console Application")
!MESSAGE
# Begin Project
# PROP AllowPerConfigDependencies 0
# PROP Scc_ProjName ""
# PROP Scc_LocalPath ""
CPP=xicl6.exe
RSC=rc.exe
!IF "$(CFG)" == "test8c - Win32 Release"
# PROP BASE Use_MFC 0
# PROP BASE Use_Debug_Libraries 0
# PROP BASE Output_Dir "Release"
# PROP BASE Intermediate_Dir "Release"
# PROP BASE Target_Dir ""
# PROP Use_MFC 0
# PROP Use_Debug_Libraries 0
# PROP Output_Dir "Release"
# PROP Intermediate_Dir "Release"
# PROP Target_Dir ""
# ADD BASE CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /c
# ADD CPP /nologo /W3 /GX /O2 /I "../../../src/api/c" /D "WIN32" /D "NDEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /c
# ADD BASE RSC /l 0x40c /d "NDEBUG"
# ADD RSC /l 0x40c /d "NDEBUG"
BSC32=bscmake.exe
# ADD BASE BSC32 /nologo
# ADD BSC32 /nologo
LINK32=xilink6.exe
# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /machine:I386
# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /machine:I386
!ELSEIF "$(CFG)" == "test8c - Win32 Debug"
# PROP BASE Use_MFC 0
# PROP BASE Use_Debug_Libraries 1
# PROP BASE Output_Dir "Debug"
# PROP BASE Intermediate_Dir "Debug"
# PROP BASE Target_Dir ""
# PROP Use_MFC 0
# PROP Use_Debug_Libraries 1
# PROP Output_Dir "Debug"
# PROP Intermediate_Dir "Debug"
# PROP Target_Dir ""
# ADD BASE CPP /nologo /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /GZ /c
# ADD CPP /nologo /W3 /Gm /GX /ZI /Od /I "../../../src/api/c" /D "WIN32" /D "_DEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /GZ /c
# ADD BASE RSC /l 0x40c /d "_DEBUG"
# ADD RSC /l 0x40c /d "_DEBUG"
BSC32=bscmake.exe
# ADD BASE BSC32 /nologo
# ADD BSC32 /nologo
LINK32=xilink6.exe
# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /debug /machine:I386 /pdbtype:sept
# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /debug /machine:I386 /pdbtype:sept
!ENDIF
# Begin Target
# Name "test8c - Win32 Release"
# Name "test8c - Win32 Debug"
# Begin Group "Source Files"
# PROP Default_Filter "cpp;c;cxx;rc;def;r;odl;idl;hpj;bat"
# Begin Source File
SOURCE="..\..\..\test\mux\test8.c"
# End Source File
# End Group
# Begin Group "Header Files"
# PROP Default_Filter "h;hpp;hxx;hm;inl"
# End Group
# Begin Group "Resource Files"
# PROP Default_Filter "ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe"
# End Group
# End Target
# End Project

100
make/vc6/test/test9.dsp Normal file
View File

@ -0,0 +1,100 @@
# Microsoft Developer Studio Project File - Name="test9" - Package Owner=<4>
# Microsoft Developer Studio Generated Build File, Format Version 6.00
# ** DO NOT EDIT **
# TARGTYPE "Win32 (x86) Console Application" 0x0103
CFG=test9 - Win32 Debug
!MESSAGE This is not a valid makefile. To build this project using NMAKE,
!MESSAGE use the Export Makefile command and run
!MESSAGE
!MESSAGE NMAKE /f "test9.mak".
!MESSAGE
!MESSAGE You can specify a configuration when running NMAKE
!MESSAGE by defining the macro CFG on the command line. For example:
!MESSAGE
!MESSAGE NMAKE /f "test9.mak" CFG="test9 - Win32 Debug"
!MESSAGE
!MESSAGE Possible choices for configuration are:
!MESSAGE
!MESSAGE "test9 - Win32 Release" (based on "Win32 (x86) Console Application")
!MESSAGE "test9 - Win32 Debug" (based on "Win32 (x86) Console Application")
!MESSAGE
# Begin Project
# PROP AllowPerConfigDependencies 0
# PROP Scc_ProjName ""
# PROP Scc_LocalPath ""
CPP=cl.exe
RSC=rc.exe
!IF "$(CFG)" == "test9 - Win32 Release"
# PROP BASE Use_MFC 0
# PROP BASE Use_Debug_Libraries 0
# PROP BASE Output_Dir "Release"
# PROP BASE Intermediate_Dir "Release"
# PROP BASE Target_Dir ""
# PROP Use_MFC 0
# PROP Use_Debug_Libraries 0
# PROP Output_Dir "Release"
# PROP Intermediate_Dir "Release"
# PROP Target_Dir ""
# ADD BASE CPP /nologo /MT /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /c
# ADD CPP /nologo /MT /W3 /GX /O2 /I "../../.." /I "../../../../libebml" /D "WIN32" /D "NDEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /c
# ADD BASE RSC /l 0x40c /d "NDEBUG"
# ADD RSC /l 0x40c /d "NDEBUG"
BSC32=bscmake.exe
# ADD BASE BSC32 /nologo
# ADD BSC32 /nologo
LINK32=link.exe
# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /machine:I386
# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /machine:I386
!ELSEIF "$(CFG)" == "test9 - Win32 Debug"
# PROP BASE Use_MFC 0
# PROP BASE Use_Debug_Libraries 1
# PROP BASE Output_Dir "Debug"
# PROP BASE Intermediate_Dir "Debug"
# PROP BASE Target_Dir ""
# PROP Use_MFC 0
# PROP Use_Debug_Libraries 1
# PROP Output_Dir "Debug"
# PROP Intermediate_Dir "Debug"
# PROP Target_Dir ""
# ADD BASE CPP /nologo /MTd /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /GZ /c
# ADD CPP /nologo /MTd /W3 /Gm /GR /GX /ZI /Od /I "../../.." /I "../../../../libebml" /D "WIN32" /D "_DEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /GZ /c
# ADD BASE RSC /l 0x40c /d "_DEBUG"
# ADD RSC /l 0x40c /d "_DEBUG"
BSC32=bscmake.exe
# ADD BASE BSC32 /nologo
# ADD BSC32 /nologo
LINK32=link.exe
# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /debug /machine:I386 /pdbtype:sept
# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /debug /machine:I386 /pdbtype:sept
!ENDIF
# Begin Target
# Name "test9 - Win32 Release"
# Name "test9 - Win32 Debug"
# Begin Group "Source Files"
# PROP Default_Filter "cpp;c;cxx;rc;def;r;odl;idl;hpj;bat"
# Begin Source File
SOURCE=..\..\..\test\tags\test9.cpp
# End Source File
# End Group
# Begin Group "Header Files"
# PROP Default_Filter "h;hpp;hxx;hm;inl"
# End Group
# Begin Group "Resource Files"
# PROP Default_Filter "ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe"
# End Group
# End Target
# End Project

134
make/vc6/vc6.dsw Normal file
View File

@ -0,0 +1,134 @@
Microsoft Developer Studio Workspace File, Format Version 6.00
# WARNING: DO NOT EDIT OR DELETE THIS WORKSPACE FILE!
###############################################################################
Project: "libebml"=..\..\..\libebml\make\vc6\lib\static\libebml.dsp - Package Owner=<4>
Package=<5>
{{{
}}}
Package=<4>
{{{
}}}
###############################################################################
Project: "libmatroska"=.\lib\static\libmatroska.dsp - Package Owner=<4>
Package=<5>
{{{
}}}
Package=<4>
{{{
Begin Project Dependency
Project_Dep_Name libebml
End Project Dependency
}}}
###############################################################################
Project: "test0"=test\test0.dsp - Package Owner=<4>
Package=<5>
{{{
}}}
Package=<4>
{{{
Begin Project Dependency
Project_Dep_Name libebml
End Project Dependency
Begin Project Dependency
Project_Dep_Name libmatroska
End Project Dependency
}}}
###############################################################################
Project: "test00"=test\test00.dsp - Package Owner=<4>
Package=<5>
{{{
}}}
Package=<4>
{{{
Begin Project Dependency
Project_Dep_Name libebml
End Project Dependency
Begin Project Dependency
Project_Dep_Name libmatroska
End Project Dependency
}}}
###############################################################################
Project: "test6"=test\test6.dsp - Package Owner=<4>
Package=<5>
{{{
}}}
Package=<4>
{{{
Begin Project Dependency
Project_Dep_Name libebml
End Project Dependency
Begin Project Dependency
Project_Dep_Name libmatroska
End Project Dependency
}}}
###############################################################################
Project: "test8"=test\test8.dsp - Package Owner=<4>
Package=<5>
{{{
}}}
Package=<4>
{{{
Begin Project Dependency
Project_Dep_Name libebml
End Project Dependency
Begin Project Dependency
Project_Dep_Name libmatroska
End Project Dependency
}}}
###############################################################################
Project: "test9"=test\test9.dsp - Package Owner=<4>
Package=<5>
{{{
}}}
Package=<4>
{{{
Begin Project Dependency
Project_Dep_Name libebml
End Project Dependency
Begin Project Dependency
Project_Dep_Name libmatroska
End Project Dependency
}}}
###############################################################################
Global:
Package=<5>
{{{
}}}
Package=<3>
{{{
}}}
###############################################################################

60
make/vc7/Makefile Normal file
View File

@ -0,0 +1,60 @@
# Project: libmatroska
# Makefile to use the Free Visual C++ 2003 compiler from Microsoft with GNU Make
# Compile with debug information?
#DEBUG = yes
# Where libebml resides
EBML_DIR = ../../../libebml
#
# Don't change anything below this line.
#
CXX = cl /Tp
CC = cl /Tc
SRC = $(wildcard ../../src/*.cpp)
OBJ = $(patsubst %.cpp,%.obj,$(SRC))
INCS = /I../.. /I$(EBML_DIR)
LDFLAGS = /NOLOGO /DLL /MAP:libmatroska.map /LIBPATH:$(EBML_DIR)/make/vc7 /VERSION:0.7
OPTMIZ = /G6 /O2 /Oi /GL /Wp64
CXXFLAGS = $(INCS) /DWIN32 /nologo /DEBML_DLL
ifeq (yes,$(DEBUG))
CXXFLAGS += /Zi /DDEBUG /D_DEBUG /MTd /RTC1
LDFLAGS += /DEBUG
else
CXXFLAGS += /MT
LDFLAGS += /OPT:REF
endif
LIBS = libmatroska.dll
.PHONY: all all-before all-after clean clean-custom
%.obj : %.cpp
$(CXX) $< /c $(CXXFLAGS) /Fo$@
all: lib
lib: $(LIBS)
clean:
$(RM) $(OBJ) libmatroska.lib libmatroska.dll
libmatroska.lib: $(OBJ)
lib /OUT:$@ /NODEFAULTLIB $(OBJ)
libmatroska.dll: $(OBJ)
link $(LDFLAGS) /OUT:$@ $(OBJ) libebml.lib
# user32.lib
depend:
$(CXX) $(CXXFLAGS) -MM $(SRC) > .depend
#
# include dependency files if they exist
#
ifneq ($(wildcard .depend),)
include .depend
endif

View File

@ -0,0 +1,277 @@
<?xml version="1.0" encoding="Windows-1252"?>
<VisualStudioProject
ProjectType="Visual C++"
Version="7.10"
Name="libmatroskadll"
ProjectGUID="{B227AC03-C69E-46B1-B91E-A77BE4C6F83A}"
Keyword="Win32Proj">
<Platforms>
<Platform
Name="Win32"/>
</Platforms>
<Configurations>
<Configuration
Name="Debug|Win32"
OutputDirectory="Debug"
IntermediateDirectory="Debug"
ConfigurationType="2"
CharacterSet="2">
<Tool
Name="VCCLCompilerTool"
Optimization="0"
AdditionalIncludeDirectories="../../../../../libebml;../../../.."
PreprocessorDefinitions="WIN32;_DEBUG;_WINDOWS;_USRDLL;EBML_DLL;MATROSKA_DLL;MATROSKA_DLL_EXPORT"
MinimalRebuild="TRUE"
BasicRuntimeChecks="3"
RuntimeLibrary="1"
UsePrecompiledHeader="0"
WarningLevel="3"
Detect64BitPortabilityProblems="TRUE"
DebugInformationFormat="4"/>
<Tool
Name="VCCustomBuildTool"/>
<Tool
Name="VCLinkerTool"
OutputFile="$(OutDir)/libmatroska.dll"
LinkIncremental="2"
GenerateDebugInformation="TRUE"
ProgramDatabaseFile="$(OutDir)/libmatroska.pdb"
SubSystem="2"
ImportLibrary="$(OutDir)/libmatroska.lib"
TargetMachine="1"/>
<Tool
Name="VCMIDLTool"/>
<Tool
Name="VCPostBuildEventTool"/>
<Tool
Name="VCPreBuildEventTool"/>
<Tool
Name="VCPreLinkEventTool"/>
<Tool
Name="VCResourceCompilerTool"/>
<Tool
Name="VCWebServiceProxyGeneratorTool"/>
<Tool
Name="VCXMLDataGeneratorTool"/>
<Tool
Name="VCWebDeploymentTool"/>
<Tool
Name="VCManagedWrapperGeneratorTool"/>
<Tool
Name="VCAuxiliaryManagedWrapperGeneratorTool"/>
</Configuration>
<Configuration
Name="Release|Win32"
OutputDirectory="Release"
IntermediateDirectory="Release"
ConfigurationType="2"
CharacterSet="2">
<Tool
Name="VCCLCompilerTool"
AdditionalIncludeDirectories="../../../../../libebml;../../../.."
PreprocessorDefinitions="WIN32;NDEBUG;_WINDOWS;_USRDLL;EBML_DLL;MATROSKA_DLL;MATROSKA_DLL_EXPORT"
RuntimeLibrary="0"
UsePrecompiledHeader="0"
WarningLevel="3"
Detect64BitPortabilityProblems="TRUE"
DebugInformationFormat="3"/>
<Tool
Name="VCCustomBuildTool"/>
<Tool
Name="VCLinkerTool"
OutputFile="$(OutDir)/libmatroska.dll"
LinkIncremental="1"
GenerateDebugInformation="TRUE"
SubSystem="2"
OptimizeReferences="2"
EnableCOMDATFolding="2"
ImportLibrary="$(OutDir)/libmatroska.lib"
TargetMachine="1"/>
<Tool
Name="VCMIDLTool"/>
<Tool
Name="VCPostBuildEventTool"/>
<Tool
Name="VCPreBuildEventTool"/>
<Tool
Name="VCPreLinkEventTool"/>
<Tool
Name="VCResourceCompilerTool"/>
<Tool
Name="VCWebServiceProxyGeneratorTool"/>
<Tool
Name="VCXMLDataGeneratorTool"/>
<Tool
Name="VCWebDeploymentTool"/>
<Tool
Name="VCManagedWrapperGeneratorTool"/>
<Tool
Name="VCAuxiliaryManagedWrapperGeneratorTool"/>
</Configuration>
</Configurations>
<References>
</References>
<Files>
<Filter
Name="Source Files"
Filter="cpp;c;cxx;def;odl;idl;hpj;bat;asm;asmx"
UniqueIdentifier="{4FC737F1-C7A5-4376-A066-2A32D752A2FF}">
<File
RelativePath="..\..\..\..\src\KaxAttached.cpp">
</File>
<File
RelativePath="..\..\..\..\src\KaxAttachments.cpp">
</File>
<File
RelativePath="..\..\..\..\src\KaxBlock.cpp">
</File>
<File
RelativePath="..\..\..\..\src\KaxBlockData.cpp">
</File>
<File
RelativePath="..\..\..\..\src\KaxChapters.cpp">
</File>
<File
RelativePath="..\..\..\..\src\KaxCluster.cpp">
</File>
<File
RelativePath="..\..\..\..\src\KaxClusterData.cpp">
</File>
<File
RelativePath="..\..\..\..\src\KaxContentEncoding.cpp">
</File>
<File
RelativePath="..\..\..\..\src\KaxContexts.cpp">
</File>
<File
RelativePath="..\..\..\..\src\KaxCues.cpp">
</File>
<File
RelativePath="..\..\..\..\src\KaxCuesData.cpp">
</File>
<File
RelativePath="..\..\..\..\src\KaxInfo.cpp">
</File>
<File
RelativePath="..\..\..\..\src\KaxInfoData.cpp">
</File>
<File
RelativePath="..\..\..\..\src\KaxSeekHead.cpp">
</File>
<File
RelativePath="..\..\..\..\src\KaxSegment.cpp">
</File>
<File
RelativePath="..\..\..\..\src\KaxTag.cpp">
</File>
<File
RelativePath="..\..\..\..\src\KaxTagMulti.cpp">
</File>
<File
RelativePath="..\..\..\..\src\KaxTags.cpp">
</File>
<File
RelativePath="..\..\..\..\src\KaxTrackAudio.cpp">
</File>
<File
RelativePath="..\..\..\..\src\KaxTrackEntryData.cpp">
</File>
<File
RelativePath="..\..\..\..\src\KaxTracks.cpp">
</File>
<File
RelativePath="..\..\..\..\src\KaxTrackVideo.cpp">
</File>
<File
RelativePath="..\..\..\..\src\KaxVersion.cpp">
</File>
</Filter>
<Filter
Name="Header Files"
Filter="h;hpp;hxx;hm;inl;inc;xsd"
UniqueIdentifier="{93995380-89BD-4b04-88EB-625FBE52EBFB}">
<File
RelativePath="..\..\..\..\matroska\KaxAttached.h">
</File>
<File
RelativePath="..\..\..\..\matroska\KaxAttachments.h">
</File>
<File
RelativePath="..\..\..\..\matroska\KaxBlock.h">
</File>
<File
RelativePath="..\..\..\..\matroska\KaxBlockData.h">
</File>
<File
RelativePath="..\..\..\..\matroska\KaxChapters.h">
</File>
<File
RelativePath="..\..\..\..\matroska\KaxCluster.h">
</File>
<File
RelativePath="..\..\..\..\matroska\KaxClusterData.h">
</File>
<File
RelativePath="..\..\..\..\matroska\KaxConfig.h">
</File>
<File
RelativePath="..\..\..\..\matroska\KaxContentEncoding.h">
</File>
<File
RelativePath="..\..\..\..\matroska\KaxContexts.h">
</File>
<File
RelativePath="..\..\..\..\matroska\KaxCues.h">
</File>
<File
RelativePath="..\..\..\..\matroska\KaxCuesData.h">
</File>
<File
RelativePath="..\..\..\..\matroska\KaxInfo.h">
</File>
<File
RelativePath="..\..\..\..\matroska\KaxInfoData.h">
</File>
<File
RelativePath="..\..\..\..\matroska\KaxSeekHead.h">
</File>
<File
RelativePath="..\..\..\..\matroska\KaxSegment.h">
</File>
<File
RelativePath="..\..\..\..\matroska\KaxTag.h">
</File>
<File
RelativePath="..\..\..\..\matroska\KaxTagMulti.h">
</File>
<File
RelativePath="..\..\..\..\matroska\KaxTags.h">
</File>
<File
RelativePath="..\..\..\..\matroska\KaxTrackAudio.h">
</File>
<File
RelativePath="..\..\..\..\matroska\KaxTrackEntryData.h">
</File>
<File
RelativePath="..\..\..\..\matroska\KaxTracks.h">
</File>
<File
RelativePath="..\..\..\..\matroska\KaxTrackVideo.h">
</File>
<File
RelativePath="..\..\..\..\matroska\KaxTypes.h">
</File>
<File
RelativePath="..\..\..\..\matroska\KaxVersion.h">
</File>
</Filter>
<Filter
Name="Resource Files"
Filter="rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx"
UniqueIdentifier="{67DA6AB6-F800-4c08-8B7A-83BB121AAD01}">
</Filter>
</Files>
<Globals>
</Globals>
</VisualStudioProject>

View File

@ -0,0 +1,283 @@
<?xml version="1.0" encoding="Windows-1252"?>
<VisualStudioProject
ProjectType="Visual C++"
Version="7.10"
Name="libmatroska"
SccProjectName=""
SccLocalPath="">
<Platforms>
<Platform
Name="Win32"/>
</Platforms>
<Configurations>
<Configuration
Name="Release|Win32"
OutputDirectory=".\Release"
IntermediateDirectory=".\Release"
ConfigurationType="4"
UseOfMFC="0"
ATLMinimizesCRunTimeLibraryUsage="FALSE"
CharacterSet="2">
<Tool
Name="VCCLCompilerTool"
InlineFunctionExpansion="1"
AdditionalIncludeDirectories="../../../../../libebml;../../../.."
PreprocessorDefinitions="WIN32,NDEBUG,_LIB"
StringPooling="TRUE"
RuntimeLibrary="0"
EnableFunctionLevelLinking="TRUE"
UsePrecompiledHeader="2"
PrecompiledHeaderFile=".\Release/libmatroska.pch"
AssemblerListingLocation=".\Release/"
ObjectFile=".\Release/"
ProgramDataBaseFileName=".\Release/"
WarningLevel="3"
SuppressStartupBanner="TRUE"
CompileAs="0"/>
<Tool
Name="VCCustomBuildTool"/>
<Tool
Name="VCLibrarianTool"
OutputFile=".\Release\libmatroska.lib"
SuppressStartupBanner="TRUE"/>
<Tool
Name="VCMIDLTool"/>
<Tool
Name="VCPostBuildEventTool"/>
<Tool
Name="VCPreBuildEventTool"/>
<Tool
Name="VCPreLinkEventTool"/>
<Tool
Name="VCResourceCompilerTool"
PreprocessorDefinitions="NDEBUG"
Culture="2057"/>
<Tool
Name="VCWebServiceProxyGeneratorTool"/>
<Tool
Name="VCXMLDataGeneratorTool"/>
<Tool
Name="VCManagedWrapperGeneratorTool"/>
<Tool
Name="VCAuxiliaryManagedWrapperGeneratorTool"/>
</Configuration>
<Configuration
Name="Debug|Win32"
OutputDirectory=".\Debug"
IntermediateDirectory=".\Debug"
ConfigurationType="4"
UseOfMFC="0"
ATLMinimizesCRunTimeLibraryUsage="FALSE"
CharacterSet="2">
<Tool
Name="VCCLCompilerTool"
Optimization="0"
AdditionalIncludeDirectories="../../../../../libebml;../../../.."
PreprocessorDefinitions="WIN32,_DEBUG,_LIB"
BasicRuntimeChecks="3"
RuntimeLibrary="1"
UsePrecompiledHeader="2"
PrecompiledHeaderFile=".\Debug/libmatroska.pch"
AssemblerListingLocation=".\Debug/"
ObjectFile=".\Debug/"
ProgramDataBaseFileName=".\Debug/"
WarningLevel="3"
SuppressStartupBanner="TRUE"
DebugInformationFormat="4"
CompileAs="0"/>
<Tool
Name="VCCustomBuildTool"/>
<Tool
Name="VCLibrarianTool"
OutputFile=".\Debug\libmatroska.lib"
SuppressStartupBanner="TRUE"/>
<Tool
Name="VCMIDLTool"/>
<Tool
Name="VCPostBuildEventTool"/>
<Tool
Name="VCPreBuildEventTool"/>
<Tool
Name="VCPreLinkEventTool"/>
<Tool
Name="VCResourceCompilerTool"
PreprocessorDefinitions="_DEBUG"
Culture="2057"/>
<Tool
Name="VCWebServiceProxyGeneratorTool"/>
<Tool
Name="VCXMLDataGeneratorTool"/>
<Tool
Name="VCManagedWrapperGeneratorTool"/>
<Tool
Name="VCAuxiliaryManagedWrapperGeneratorTool"/>
</Configuration>
</Configurations>
<References>
</References>
<Files>
<Filter
Name="Source Files"
Filter="cpp;c;cxx;rc;def;r;odl;idl;hpj;bat">
<File
RelativePath="..\..\..\..\src\FileKax.cpp">
</File>
<File
RelativePath="..\..\..\..\src\KaxAttached.cpp">
</File>
<File
RelativePath="..\..\..\..\src\KaxAttachments.cpp">
</File>
<File
RelativePath="..\..\..\..\src\KaxBlock.cpp">
</File>
<File
RelativePath="..\..\..\..\src\KaxBlockData.cpp">
</File>
<File
RelativePath="..\..\..\..\src\KaxChapters.cpp">
</File>
<File
RelativePath="..\..\..\..\src\KaxCluster.cpp">
</File>
<File
RelativePath="..\..\..\..\src\KaxClusterData.cpp">
</File>
<File
RelativePath="..\..\..\..\src\KaxContentEncoding.cpp">
</File>
<File
RelativePath="..\..\..\..\src\KaxContexts.cpp">
</File>
<File
RelativePath="..\..\..\..\src\KaxCues.cpp">
</File>
<File
RelativePath="..\..\..\..\src\KaxCuesData.cpp">
</File>
<File
RelativePath="..\..\..\..\src\KaxInfo.cpp">
</File>
<File
RelativePath="..\..\..\..\src\KaxInfoData.cpp">
</File>
<File
RelativePath="..\..\..\..\src\KaxSeekHead.cpp">
</File>
<File
RelativePath="..\..\..\..\src\KaxSegment.cpp">
</File>
<File
RelativePath="..\..\..\..\src\KaxTag.cpp">
</File>
<File
RelativePath="..\..\..\..\src\KaxTagMulti.cpp">
</File>
<File
RelativePath="..\..\..\..\src\KaxTags.cpp">
</File>
<File
RelativePath="..\..\..\..\src\KaxTrackAudio.cpp">
</File>
<File
RelativePath="..\..\..\..\src\KaxTrackEntryData.cpp">
</File>
<File
RelativePath="..\..\..\..\src\KaxTracks.cpp">
</File>
<File
RelativePath="..\..\..\..\src\KaxTrackVideo.cpp">
</File>
<File
RelativePath="..\..\..\..\src\KaxVersion.cpp">
</File>
</Filter>
<Filter
Name="Header Files"
Filter="h;hpp;hxx;hm;inl">
<File
RelativePath="..\..\..\..\matroska\FileKax.h">
</File>
<File
RelativePath="..\..\..\..\matroska\KaxAttached.h">
</File>
<File
RelativePath="..\..\..\..\matroska\KaxAttachments.h">
</File>
<File
RelativePath="..\..\..\..\matroska\KaxBlock.h">
</File>
<File
RelativePath="..\..\..\..\matroska\KaxBlockData.h">
</File>
<File
RelativePath="..\..\..\..\matroska\KaxChapters.h">
</File>
<File
RelativePath="..\..\..\..\matroska\KaxCluster.h">
</File>
<File
RelativePath="..\..\..\..\matroska\KaxClusterData.h">
</File>
<File
RelativePath="..\..\..\..\matroska\KaxConfig.h">
</File>
<File
RelativePath="..\..\..\..\matroska\KaxContentEncoding.h">
</File>
<File
RelativePath="..\..\..\..\matroska\KaxContexts.h">
</File>
<File
RelativePath="..\..\..\..\matroska\KaxCues.h">
</File>
<File
RelativePath="..\..\..\..\matroska\KaxCuesData.h">
</File>
<File
RelativePath="..\..\..\..\matroska\KaxInfo.h">
</File>
<File
RelativePath="..\..\..\..\matroska\KaxInfoData.h">
</File>
<File
RelativePath="..\..\..\..\matroska\KaxSeekHead.h">
</File>
<File
RelativePath="..\..\..\..\matroska\KaxSegment.h">
</File>
<File
RelativePath="..\..\..\..\matroska\KaxTag.h">
</File>
<File
RelativePath="..\..\..\..\matroska\KaxTagMulti.h">
</File>
<File
RelativePath="..\..\..\..\matroska\KaxTags.h">
</File>
<File
RelativePath="..\..\..\..\matroska\KaxTrackAudio.h">
</File>
<File
RelativePath="..\..\..\..\matroska\KaxTrackEntryData.h">
</File>
<File
RelativePath="..\..\..\..\matroska\KaxTracks.h">
</File>
<File
RelativePath="..\..\..\..\matroska\KaxTrackVideo.h">
</File>
<File
RelativePath="..\..\..\..\matroska\KaxTypes.h">
</File>
<File
RelativePath="..\..\..\..\matroska\KaxVersion.h">
</File>
<File
RelativePath="..\..\..\..\matroska\StdInclude.h">
</File>
</Filter>
</Files>
<Globals>
</Globals>
</VisualStudioProject>

View File

@ -0,0 +1,269 @@
<?xml version="1.0" encoding = "Windows-1252"?>
<VisualStudioProject
ProjectType="Visual C++"
Version="7.00"
Name="libmatroska"
SccProjectName=""
SccLocalPath="">
<Platforms>
<Platform
Name="Win32"/>
</Platforms>
<Configurations>
<Configuration
Name="Release|Win32"
OutputDirectory=".\Release"
IntermediateDirectory=".\Release"
ConfigurationType="4"
UseOfMFC="0"
ATLMinimizesCRunTimeLibraryUsage="FALSE"
CharacterSet="2">
<Tool
Name="VCCLCompilerTool"
InlineFunctionExpansion="1"
AdditionalIncludeDirectories="../../../../../libebml;../../../.."
PreprocessorDefinitions="WIN32,NDEBUG,_LIB"
StringPooling="TRUE"
RuntimeLibrary="0"
EnableFunctionLevelLinking="TRUE"
UsePrecompiledHeader="2"
PrecompiledHeaderFile=".\Release/libmatroska.pch"
AssemblerListingLocation=".\Release/"
ObjectFile=".\Release/"
ProgramDataBaseFileName=".\Release/"
WarningLevel="3"
SuppressStartupBanner="TRUE"
CompileAs="0"/>
<Tool
Name="VCCustomBuildTool"/>
<Tool
Name="VCLibrarianTool"
OutputFile=".\Release\libmatroska.lib"
SuppressStartupBanner="TRUE"/>
<Tool
Name="VCMIDLTool"/>
<Tool
Name="VCPostBuildEventTool"/>
<Tool
Name="VCPreBuildEventTool"/>
<Tool
Name="VCPreLinkEventTool"/>
<Tool
Name="VCResourceCompilerTool"
PreprocessorDefinitions="NDEBUG"
Culture="2057"/>
<Tool
Name="VCWebServiceProxyGeneratorTool"/>
</Configuration>
<Configuration
Name="Debug|Win32"
OutputDirectory=".\Debug"
IntermediateDirectory=".\Debug"
ConfigurationType="4"
UseOfMFC="0"
ATLMinimizesCRunTimeLibraryUsage="FALSE"
CharacterSet="2">
<Tool
Name="VCCLCompilerTool"
Optimization="0"
AdditionalIncludeDirectories="../../../../../libebml;../../../.."
PreprocessorDefinitions="WIN32,_DEBUG,_LIB"
BasicRuntimeChecks="3"
RuntimeLibrary="1"
UsePrecompiledHeader="2"
PrecompiledHeaderFile=".\Debug/libmatroska.pch"
AssemblerListingLocation=".\Debug/"
ObjectFile=".\Debug/"
ProgramDataBaseFileName=".\Debug/"
WarningLevel="3"
SuppressStartupBanner="TRUE"
DebugInformationFormat="4"
CompileAs="0"/>
<Tool
Name="VCCustomBuildTool"/>
<Tool
Name="VCLibrarianTool"
OutputFile=".\Debug\libmatroska.lib"
SuppressStartupBanner="TRUE"/>
<Tool
Name="VCMIDLTool"/>
<Tool
Name="VCPostBuildEventTool"/>
<Tool
Name="VCPreBuildEventTool"/>
<Tool
Name="VCPreLinkEventTool"/>
<Tool
Name="VCResourceCompilerTool"
PreprocessorDefinitions="_DEBUG"
Culture="2057"/>
<Tool
Name="VCWebServiceProxyGeneratorTool"/>
</Configuration>
</Configurations>
<Files>
<Filter
Name="Source Files"
Filter="cpp;c;cxx;rc;def;r;odl;idl;hpj;bat">
<File
RelativePath="..\..\..\..\src\FileKax.cpp">
</File>
<File
RelativePath="..\..\..\..\src\KaxAttached.cpp">
</File>
<File
RelativePath="..\..\..\..\src\KaxAttachments.cpp">
</File>
<File
RelativePath="..\..\..\..\src\KaxBlock.cpp">
</File>
<File
RelativePath="..\..\..\..\src\KaxBlockData.cpp">
</File>
<File
RelativePath="..\..\..\..\src\KaxChapters.cpp">
</File>
<File
RelativePath="..\..\..\..\src\KaxCluster.cpp">
</File>
<File
RelativePath="..\..\..\..\src\KaxClusterData.cpp">
</File>
<File
RelativePath="..\..\..\..\src\KaxContentEncoding.cpp">
</File>
<File
RelativePath="..\..\..\..\src\KaxContexts.cpp">
</File>
<File
RelativePath="..\..\..\..\src\KaxCues.cpp">
</File>
<File
RelativePath="..\..\..\..\src\KaxCuesData.cpp">
</File>
<File
RelativePath="..\..\..\..\src\KaxInfo.cpp">
</File>
<File
RelativePath="..\..\..\..\src\KaxInfoData.cpp">
</File>
<File
RelativePath="..\..\..\..\src\KaxSeekHead.cpp">
</File>
<File
RelativePath="..\..\..\..\src\KaxSegment.cpp">
</File>
<File
RelativePath="..\..\..\..\src\KaxTag.cpp">
</File>
<File
RelativePath="..\..\..\..\src\KaxTagMulti.cpp">
</File>
<File
RelativePath="..\..\..\..\src\KaxTags.cpp">
</File>
<File
RelativePath="..\..\..\..\src\KaxTrackAudio.cpp">
</File>
<File
RelativePath="..\..\..\..\src\KaxTrackEntryData.cpp">
</File>
<File
RelativePath="..\..\..\..\src\KaxTrackVideo.cpp">
</File>
<File
RelativePath="..\..\..\..\src\KaxTracks.cpp">
</File>
<File
RelativePath="..\..\..\..\src\KaxVersion.cpp">
</File>
</Filter>
<Filter
Name="Header Files"
Filter="h;hpp;hxx;hm;inl">
<File
RelativePath="..\..\..\..\matroska\FileKax.h">
</File>
<File
RelativePath="..\..\..\..\matroska\KaxAttached.h">
</File>
<File
RelativePath="..\..\..\..\matroska\KaxAttachments.h">
</File>
<File
RelativePath="..\..\..\..\matroska\KaxBlock.h">
</File>
<File
RelativePath="..\..\..\..\matroska\KaxBlockData.h">
</File>
<File
RelativePath="..\..\..\..\matroska\KaxChapters.h">
</File>
<File
RelativePath="..\..\..\..\matroska\KaxCluster.h">
</File>
<File
RelativePath="..\..\..\..\matroska\KaxClusterData.h">
</File>
<File
RelativePath="..\..\..\..\matroska\KaxConfig.h">
</File>
<File
RelativePath="..\..\..\..\matroska\KaxContentEncoding.h">
</File>
<File
RelativePath="..\..\..\..\matroska\KaxContexts.h">
</File>
<File
RelativePath="..\..\..\..\matroska\KaxCues.h">
</File>
<File
RelativePath="..\..\..\..\matroska\KaxCuesData.h">
</File>
<File
RelativePath="..\..\..\..\matroska\KaxInfo.h">
</File>
<File
RelativePath="..\..\..\..\matroska\KaxInfoData.h">
</File>
<File
RelativePath="..\..\..\..\matroska\KaxSeekHead.h">
</File>
<File
RelativePath="..\..\..\..\matroska\KaxSegment.h">
</File>
<File
RelativePath="..\..\..\..\matroska\KaxTag.h">
</File>
<File
RelativePath="..\..\..\..\matroska\KaxTagMulti.h">
</File>
<File
RelativePath="..\..\..\..\matroska\KaxTags.h">
</File>
<File
RelativePath="..\..\..\..\matroska\KaxTrackAudio.h">
</File>
<File
RelativePath="..\..\..\..\matroska\KaxTrackEntryData.h">
</File>
<File
RelativePath="..\..\..\..\matroska\KaxTrackVideo.h">
</File>
<File
RelativePath="..\..\..\..\matroska\KaxTracks.h">
</File>
<File
RelativePath="..\..\..\..\matroska\KaxTypes.h">
</File>
<File
RelativePath="..\..\..\..\matroska\KaxVersion.h">
</File>
<File
RelativePath="..\..\..\..\matroska\StdInclude.h">
</File>
</Filter>
</Files>
<Globals>
</Globals>
</VisualStudioProject>

143
make/vc7/test/test0.vcproj Normal file
View File

@ -0,0 +1,143 @@
<?xml version="1.0" encoding = "Windows-1252"?>
<VisualStudioProject
ProjectType="Visual C++"
Version="7.00"
Name="test0"
SccProjectName=""
SccLocalPath="">
<Platforms>
<Platform
Name="Win32"/>
</Platforms>
<Configurations>
<Configuration
Name="Debug|Win32"
OutputDirectory=".\Debug"
IntermediateDirectory=".\Debug"
ConfigurationType="1"
UseOfMFC="0"
ATLMinimizesCRunTimeLibraryUsage="FALSE"
CharacterSet="2">
<Tool
Name="VCCLCompilerTool"
Optimization="0"
AdditionalIncludeDirectories="../../../src,../../../../libebml/src"
PreprocessorDefinitions="WIN32,_DEBUG,_CONSOLE"
BasicRuntimeChecks="3"
RuntimeLibrary="1"
UsePrecompiledHeader="2"
PrecompiledHeaderFile=".\Debug/test0.pch"
AssemblerListingLocation=".\Debug/"
ObjectFile=".\Debug/"
ProgramDataBaseFileName=".\Debug/"
WarningLevel="3"
SuppressStartupBanner="TRUE"
DebugInformationFormat="4"
CompileAs="0"/>
<Tool
Name="VCCustomBuildTool"/>
<Tool
Name="VCLinkerTool"
AdditionalOptions="/MACHINE:I386"
AdditionalDependencies="odbc32.lib odbccp32.lib"
OutputFile=".\Debug/test0.exe"
LinkIncremental="2"
SuppressStartupBanner="TRUE"
GenerateDebugInformation="TRUE"
ProgramDatabaseFile=".\Debug/test0.pdb"
SubSystem="1"/>
<Tool
Name="VCMIDLTool"
TypeLibraryName=".\Debug/test0.tlb"/>
<Tool
Name="VCPostBuildEventTool"/>
<Tool
Name="VCPreBuildEventTool"/>
<Tool
Name="VCPreLinkEventTool"/>
<Tool
Name="VCResourceCompilerTool"
PreprocessorDefinitions="_DEBUG"
Culture="1036"/>
<Tool
Name="VCWebServiceProxyGeneratorTool"/>
<Tool
Name="VCWebDeploymentTool"/>
</Configuration>
<Configuration
Name="Release|Win32"
OutputDirectory=".\Release"
IntermediateDirectory=".\Release"
ConfigurationType="1"
UseOfMFC="0"
ATLMinimizesCRunTimeLibraryUsage="FALSE"
CharacterSet="2">
<Tool
Name="VCCLCompilerTool"
InlineFunctionExpansion="1"
AdditionalIncludeDirectories="../../../src,../../../../libebml/src"
PreprocessorDefinitions="WIN32,NDEBUG,_CONSOLE"
StringPooling="TRUE"
RuntimeLibrary="0"
EnableFunctionLevelLinking="TRUE"
UsePrecompiledHeader="2"
PrecompiledHeaderFile=".\Release/test0.pch"
AssemblerListingLocation=".\Release/"
ObjectFile=".\Release/"
ProgramDataBaseFileName=".\Release/"
WarningLevel="3"
SuppressStartupBanner="TRUE"
CompileAs="0"/>
<Tool
Name="VCCustomBuildTool"/>
<Tool
Name="VCLinkerTool"
AdditionalOptions="/MACHINE:I386"
AdditionalDependencies="odbc32.lib odbccp32.lib"
OutputFile=".\Release/test0.exe"
LinkIncremental="1"
SuppressStartupBanner="TRUE"
ProgramDatabaseFile=".\Release/test0.pdb"
SubSystem="1"/>
<Tool
Name="VCMIDLTool"
TypeLibraryName=".\Release/test0.tlb"/>
<Tool
Name="VCPostBuildEventTool"/>
<Tool
Name="VCPreBuildEventTool"/>
<Tool
Name="VCPreLinkEventTool"/>
<Tool
Name="VCResourceCompilerTool"
PreprocessorDefinitions="NDEBUG"
Culture="1036"/>
<Tool
Name="VCWebServiceProxyGeneratorTool"/>
<Tool
Name="VCWebDeploymentTool"/>
</Configuration>
</Configurations>
<Files>
<Filter
Name="Source Files"
Filter="cpp;c;cxx;rc;def;r;odl;idl;hpj;bat">
<File
RelativePath="..\..\..\test\ebml\test0.cpp">
</File>
</Filter>
<Filter
Name="Header Files"
Filter="h;hpp;hxx;hm;inl">
</Filter>
<Filter
Name="Resource Files"
Filter="ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe">
</Filter>
</Files>
<Globals>
<Global
Name="DevPartner_IsInstrumented"
Value="0"/>
</Globals>
</VisualStudioProject>

143
make/vc7/test/test00.vcproj Normal file
View File

@ -0,0 +1,143 @@
<?xml version="1.0" encoding = "Windows-1252"?>
<VisualStudioProject
ProjectType="Visual C++"
Version="7.00"
Name="test00"
SccProjectName=""
SccLocalPath="">
<Platforms>
<Platform
Name="Win32"/>
</Platforms>
<Configurations>
<Configuration
Name="Debug|Win32"
OutputDirectory=".\Debug"
IntermediateDirectory=".\Debug"
ConfigurationType="1"
UseOfMFC="0"
ATLMinimizesCRunTimeLibraryUsage="FALSE"
CharacterSet="2">
<Tool
Name="VCCLCompilerTool"
Optimization="0"
AdditionalIncludeDirectories="../../../src,../../../../libebml/src"
PreprocessorDefinitions="WIN32,_DEBUG,_CONSOLE"
BasicRuntimeChecks="3"
RuntimeLibrary="1"
UsePrecompiledHeader="2"
PrecompiledHeaderFile=".\Debug/test00.pch"
AssemblerListingLocation=".\Debug/"
ObjectFile=".\Debug/"
ProgramDataBaseFileName=".\Debug/"
WarningLevel="3"
SuppressStartupBanner="TRUE"
DebugInformationFormat="4"
CompileAs="0"/>
<Tool
Name="VCCustomBuildTool"/>
<Tool
Name="VCLinkerTool"
AdditionalOptions="/MACHINE:I386"
AdditionalDependencies="odbc32.lib odbccp32.lib"
OutputFile=".\Debug/test00.exe"
LinkIncremental="2"
SuppressStartupBanner="TRUE"
GenerateDebugInformation="TRUE"
ProgramDatabaseFile=".\Debug/test00.pdb"
SubSystem="1"/>
<Tool
Name="VCMIDLTool"
TypeLibraryName=".\Debug/test00.tlb"/>
<Tool
Name="VCPostBuildEventTool"/>
<Tool
Name="VCPreBuildEventTool"/>
<Tool
Name="VCPreLinkEventTool"/>
<Tool
Name="VCResourceCompilerTool"
PreprocessorDefinitions="_DEBUG"
Culture="1036"/>
<Tool
Name="VCWebServiceProxyGeneratorTool"/>
<Tool
Name="VCWebDeploymentTool"/>
</Configuration>
<Configuration
Name="Release|Win32"
OutputDirectory=".\Release"
IntermediateDirectory=".\Release"
ConfigurationType="1"
UseOfMFC="0"
ATLMinimizesCRunTimeLibraryUsage="FALSE"
CharacterSet="2">
<Tool
Name="VCCLCompilerTool"
InlineFunctionExpansion="1"
AdditionalIncludeDirectories="../../../src,../../../../libebml/src"
PreprocessorDefinitions="WIN32,NDEBUG,_CONSOLE"
StringPooling="TRUE"
RuntimeLibrary="0"
EnableFunctionLevelLinking="TRUE"
UsePrecompiledHeader="2"
PrecompiledHeaderFile=".\Release/test00.pch"
AssemblerListingLocation=".\Release/"
ObjectFile=".\Release/"
ProgramDataBaseFileName=".\Release/"
WarningLevel="3"
SuppressStartupBanner="TRUE"
CompileAs="0"/>
<Tool
Name="VCCustomBuildTool"/>
<Tool
Name="VCLinkerTool"
AdditionalOptions="/MACHINE:I386"
AdditionalDependencies="odbc32.lib odbccp32.lib"
OutputFile=".\Release/test00.exe"
LinkIncremental="1"
SuppressStartupBanner="TRUE"
ProgramDatabaseFile=".\Release/test00.pdb"
SubSystem="1"/>
<Tool
Name="VCMIDLTool"
TypeLibraryName=".\Release/test00.tlb"/>
<Tool
Name="VCPostBuildEventTool"/>
<Tool
Name="VCPreBuildEventTool"/>
<Tool
Name="VCPreLinkEventTool"/>
<Tool
Name="VCResourceCompilerTool"
PreprocessorDefinitions="NDEBUG"
Culture="1036"/>
<Tool
Name="VCWebServiceProxyGeneratorTool"/>
<Tool
Name="VCWebDeploymentTool"/>
</Configuration>
</Configurations>
<Files>
<Filter
Name="Source Files"
Filter="cpp;c;cxx;rc;def;r;odl;idl;hpj;bat">
<File
RelativePath="..\..\..\test\ebml\test00.cpp">
</File>
</Filter>
<Filter
Name="Header Files"
Filter="h;hpp;hxx;hm;inl">
</Filter>
<Filter
Name="Resource Files"
Filter="ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe">
</Filter>
</Files>
<Globals>
<Global
Name="DevPartner_IsInstrumented"
Value="0"/>
</Globals>
</VisualStudioProject>

140
make/vc7/test/test6.vcproj Normal file
View File

@ -0,0 +1,140 @@
<?xml version="1.0" encoding = "Windows-1252"?>
<VisualStudioProject
ProjectType="Visual C++"
Version="7.00"
Name="test6"
SccProjectName=""
SccLocalPath="">
<Platforms>
<Platform
Name="Win32"/>
</Platforms>
<Configurations>
<Configuration
Name="Debug|Win32"
OutputDirectory=".\Debug"
IntermediateDirectory=".\Debug"
ConfigurationType="1"
UseOfMFC="0"
ATLMinimizesCRunTimeLibraryUsage="FALSE"
CharacterSet="2">
<Tool
Name="VCCLCompilerTool"
Optimization="0"
AdditionalIncludeDirectories="../../..,../../../../libebml"
PreprocessorDefinitions="WIN32,_DEBUG,_CONSOLE"
BasicRuntimeChecks="3"
RuntimeLibrary="1"
UsePrecompiledHeader="2"
PrecompiledHeaderFile=".\Debug/test6.pch"
AssemblerListingLocation=".\Debug/"
ObjectFile=".\Debug/"
ProgramDataBaseFileName=".\Debug/"
WarningLevel="3"
SuppressStartupBanner="TRUE"
DebugInformationFormat="4"
CompileAs="0"/>
<Tool
Name="VCCustomBuildTool"/>
<Tool
Name="VCLinkerTool"
AdditionalOptions="/MACHINE:I386"
AdditionalDependencies="odbc32.lib odbccp32.lib"
OutputFile=".\Debug/test6.exe"
LinkIncremental="2"
SuppressStartupBanner="TRUE"
GenerateDebugInformation="TRUE"
ProgramDatabaseFile=".\Debug/test6.pdb"
SubSystem="1"/>
<Tool
Name="VCMIDLTool"
TypeLibraryName=".\Debug/test6.tlb"/>
<Tool
Name="VCPostBuildEventTool"/>
<Tool
Name="VCPreBuildEventTool"/>
<Tool
Name="VCPreLinkEventTool"/>
<Tool
Name="VCResourceCompilerTool"
PreprocessorDefinitions="_DEBUG"
Culture="1036"/>
<Tool
Name="VCWebServiceProxyGeneratorTool"/>
<Tool
Name="VCWebDeploymentTool"/>
</Configuration>
<Configuration
Name="Release|Win32"
OutputDirectory=".\Release"
IntermediateDirectory=".\Release"
ConfigurationType="1"
UseOfMFC="0"
ATLMinimizesCRunTimeLibraryUsage="FALSE"
CharacterSet="2">
<Tool
Name="VCCLCompilerTool"
InlineFunctionExpansion="1"
AdditionalIncludeDirectories="../../..,../../../../libebml"
PreprocessorDefinitions="WIN32,NDEBUG,_CONSOLE"
StringPooling="TRUE"
RuntimeLibrary="0"
EnableFunctionLevelLinking="TRUE"
UsePrecompiledHeader="2"
PrecompiledHeaderFile=".\Release/test6.pch"
AssemblerListingLocation=".\Release/"
ObjectFile=".\Release/"
ProgramDataBaseFileName=".\Release/"
WarningLevel="3"
SuppressStartupBanner="TRUE"
CompileAs="0"/>
<Tool
Name="VCCustomBuildTool"/>
<Tool
Name="VCLinkerTool"
AdditionalOptions="/MACHINE:I386"
AdditionalDependencies="odbc32.lib odbccp32.lib"
OutputFile=".\Release/test6.exe"
LinkIncremental="1"
SuppressStartupBanner="TRUE"
ProgramDatabaseFile=".\Release/test6.pdb"
SubSystem="1"/>
<Tool
Name="VCMIDLTool"
TypeLibraryName=".\Release/test6.tlb"/>
<Tool
Name="VCPostBuildEventTool"/>
<Tool
Name="VCPreBuildEventTool"/>
<Tool
Name="VCPreLinkEventTool"/>
<Tool
Name="VCResourceCompilerTool"
PreprocessorDefinitions="NDEBUG"
Culture="1036"/>
<Tool
Name="VCWebServiceProxyGeneratorTool"/>
<Tool
Name="VCWebDeploymentTool"/>
</Configuration>
</Configurations>
<Files>
<Filter
Name="Source Files"
Filter="cpp;c;cxx;rc;def;r;odl;idl;hpj;bat">
<File
RelativePath="..\..\..\test\mux\test6.cpp">
</File>
</Filter>
<Filter
Name="Header Files"
Filter="h;hpp;hxx;hm;inl">
</Filter>
<Filter
Name="Resource Files"
Filter="ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe">
</Filter>
</Files>
<Globals>
</Globals>
</VisualStudioProject>

140
make/vc7/test/test8.vcproj Normal file
View File

@ -0,0 +1,140 @@
<?xml version="1.0" encoding = "Windows-1252"?>
<VisualStudioProject
ProjectType="Visual C++"
Version="7.00"
Name="test8"
SccProjectName=""
SccLocalPath="">
<Platforms>
<Platform
Name="Win32"/>
</Platforms>
<Configurations>
<Configuration
Name="Release|Win32"
OutputDirectory=".\Release"
IntermediateDirectory=".\Release"
ConfigurationType="1"
UseOfMFC="0"
ATLMinimizesCRunTimeLibraryUsage="FALSE"
CharacterSet="2">
<Tool
Name="VCCLCompilerTool"
InlineFunctionExpansion="1"
AdditionalIncludeDirectories="../../..,../../../../libebml"
PreprocessorDefinitions="WIN32,NDEBUG,_CONSOLE"
StringPooling="TRUE"
RuntimeLibrary="0"
EnableFunctionLevelLinking="TRUE"
UsePrecompiledHeader="2"
PrecompiledHeaderFile=".\Release/test8.pch"
AssemblerListingLocation=".\Release/"
ObjectFile=".\Release/"
ProgramDataBaseFileName=".\Release/"
WarningLevel="3"
SuppressStartupBanner="TRUE"
CompileAs="0"/>
<Tool
Name="VCCustomBuildTool"/>
<Tool
Name="VCLinkerTool"
AdditionalOptions="/MACHINE:I386"
AdditionalDependencies="odbc32.lib odbccp32.lib"
OutputFile=".\Release/test8.exe"
LinkIncremental="1"
SuppressStartupBanner="TRUE"
ProgramDatabaseFile=".\Release/test8.pdb"
SubSystem="1"/>
<Tool
Name="VCMIDLTool"
TypeLibraryName=".\Release/test8.tlb"/>
<Tool
Name="VCPostBuildEventTool"/>
<Tool
Name="VCPreBuildEventTool"/>
<Tool
Name="VCPreLinkEventTool"/>
<Tool
Name="VCResourceCompilerTool"
PreprocessorDefinitions="NDEBUG"
Culture="1036"/>
<Tool
Name="VCWebServiceProxyGeneratorTool"/>
<Tool
Name="VCWebDeploymentTool"/>
</Configuration>
<Configuration
Name="Debug|Win32"
OutputDirectory=".\Debug"
IntermediateDirectory=".\Debug"
ConfigurationType="1"
UseOfMFC="0"
ATLMinimizesCRunTimeLibraryUsage="FALSE"
CharacterSet="2">
<Tool
Name="VCCLCompilerTool"
Optimization="0"
AdditionalIncludeDirectories="../../..,../../../../libebml"
PreprocessorDefinitions="WIN32,_DEBUG,_CONSOLE"
BasicRuntimeChecks="3"
RuntimeLibrary="1"
UsePrecompiledHeader="2"
PrecompiledHeaderFile=".\Debug/test8.pch"
AssemblerListingLocation=".\Debug/"
ObjectFile=".\Debug/"
ProgramDataBaseFileName=".\Debug/"
WarningLevel="3"
SuppressStartupBanner="TRUE"
DebugInformationFormat="4"
CompileAs="0"/>
<Tool
Name="VCCustomBuildTool"/>
<Tool
Name="VCLinkerTool"
AdditionalOptions="/MACHINE:I386"
AdditionalDependencies="odbc32.lib odbccp32.lib"
OutputFile=".\Debug/test8.exe"
LinkIncremental="2"
SuppressStartupBanner="TRUE"
GenerateDebugInformation="TRUE"
ProgramDatabaseFile=".\Debug/test8.pdb"
SubSystem="1"/>
<Tool
Name="VCMIDLTool"
TypeLibraryName=".\Debug/test8.tlb"/>
<Tool
Name="VCPostBuildEventTool"/>
<Tool
Name="VCPreBuildEventTool"/>
<Tool
Name="VCPreLinkEventTool"/>
<Tool
Name="VCResourceCompilerTool"
PreprocessorDefinitions="_DEBUG"
Culture="1036"/>
<Tool
Name="VCWebServiceProxyGeneratorTool"/>
<Tool
Name="VCWebDeploymentTool"/>
</Configuration>
</Configurations>
<Files>
<Filter
Name="Source Files"
Filter="cpp;c;cxx;rc;def;r;odl;idl;hpj;bat">
<File
RelativePath="..\..\..\test\mux\test8.cpp">
</File>
</Filter>
<Filter
Name="Header Files"
Filter="h;hpp;hxx;hm;inl">
</Filter>
<Filter
Name="Resource Files"
Filter="ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe">
</Filter>
</Files>
<Globals>
</Globals>
</VisualStudioProject>

141
make/vc7/test/test9.vcproj Normal file
View File

@ -0,0 +1,141 @@
<?xml version="1.0" encoding = "Windows-1252"?>
<VisualStudioProject
ProjectType="Visual C++"
Version="7.00"
Name="test9"
ProjectGUID="{F294A3C5-D355-49E7-A8B8-B9692345A5E0}"
SccProjectName=""
SccLocalPath="">
<Platforms>
<Platform
Name="Win32"/>
</Platforms>
<Configurations>
<Configuration
Name="Release|Win32"
OutputDirectory=".\Release"
IntermediateDirectory=".\Release"
ConfigurationType="1"
UseOfMFC="0"
ATLMinimizesCRunTimeLibraryUsage="FALSE"
CharacterSet="2">
<Tool
Name="VCCLCompilerTool"
InlineFunctionExpansion="1"
AdditionalIncludeDirectories="../../..,../../../../libebml"
PreprocessorDefinitions="WIN32,NDEBUG,_CONSOLE"
StringPooling="TRUE"
RuntimeLibrary="0"
EnableFunctionLevelLinking="TRUE"
UsePrecompiledHeader="2"
PrecompiledHeaderFile=".\Release/test9.pch"
AssemblerListingLocation=".\Release/"
ObjectFile=".\Release/"
ProgramDataBaseFileName=".\Release/"
WarningLevel="3"
SuppressStartupBanner="TRUE"
CompileAs="0"/>
<Tool
Name="VCCustomBuildTool"/>
<Tool
Name="VCLinkerTool"
AdditionalOptions="/MACHINE:I386"
AdditionalDependencies="odbc32.lib odbccp32.lib"
OutputFile=".\Release/test9.exe"
LinkIncremental="1"
SuppressStartupBanner="TRUE"
ProgramDatabaseFile=".\Release/test9.pdb"
SubSystem="1"/>
<Tool
Name="VCMIDLTool"
TypeLibraryName=".\Release/test9.tlb"/>
<Tool
Name="VCPostBuildEventTool"/>
<Tool
Name="VCPreBuildEventTool"/>
<Tool
Name="VCPreLinkEventTool"/>
<Tool
Name="VCResourceCompilerTool"
PreprocessorDefinitions="NDEBUG"
Culture="1036"/>
<Tool
Name="VCWebServiceProxyGeneratorTool"/>
<Tool
Name="VCWebDeploymentTool"/>
</Configuration>
<Configuration
Name="Debug|Win32"
OutputDirectory=".\Debug"
IntermediateDirectory=".\Debug"
ConfigurationType="1"
UseOfMFC="0"
ATLMinimizesCRunTimeLibraryUsage="FALSE"
CharacterSet="2">
<Tool
Name="VCCLCompilerTool"
Optimization="0"
AdditionalIncludeDirectories="../../..,../../../../libebml"
PreprocessorDefinitions="WIN32,_DEBUG,_CONSOLE"
BasicRuntimeChecks="3"
RuntimeLibrary="1"
UsePrecompiledHeader="2"
PrecompiledHeaderFile=".\Debug/test9.pch"
AssemblerListingLocation=".\Debug/"
ObjectFile=".\Debug/"
ProgramDataBaseFileName=".\Debug/"
WarningLevel="3"
SuppressStartupBanner="TRUE"
DebugInformationFormat="4"
CompileAs="0"/>
<Tool
Name="VCCustomBuildTool"/>
<Tool
Name="VCLinkerTool"
AdditionalOptions="/MACHINE:I386"
AdditionalDependencies="odbc32.lib odbccp32.lib"
OutputFile=".\Debug/test9.exe"
LinkIncremental="2"
SuppressStartupBanner="TRUE"
GenerateDebugInformation="TRUE"
ProgramDatabaseFile=".\Debug/test9.pdb"
SubSystem="1"/>
<Tool
Name="VCMIDLTool"
TypeLibraryName=".\Debug/test9.tlb"/>
<Tool
Name="VCPostBuildEventTool"/>
<Tool
Name="VCPreBuildEventTool"/>
<Tool
Name="VCPreLinkEventTool"/>
<Tool
Name="VCResourceCompilerTool"
PreprocessorDefinitions="_DEBUG"
Culture="1036"/>
<Tool
Name="VCWebServiceProxyGeneratorTool"/>
<Tool
Name="VCWebDeploymentTool"/>
</Configuration>
</Configurations>
<Files>
<Filter
Name="Source Files"
Filter="cpp;c;cxx;rc;def;r;odl;idl;hpj;bat">
<File
RelativePath="..\..\..\test\tags\test9.cpp">
</File>
</Filter>
<Filter
Name="Header Files"
Filter="h;hpp;hxx;hm;inl">
</Filter>
<Filter
Name="Resource Files"
Filter="ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe">
</Filter>
</Files>
<Globals>
</Globals>
</VisualStudioProject>

73
make/vc7/vc7.sln Normal file
View File

@ -0,0 +1,73 @@
Microsoft Visual Studio Solution File, Format Version 7.00
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "libebml", "..\..\..\libebml\make\vc7\lib\libebml.vcproj", "{C6902997-CF7C-42B5-AD42-5B7C11F4CFE6}"
EndProject
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "libebmldll", "..\..\..\libebml\make\vc7\dll\libebmldll.v71.vcproj", "{83136D19-2749-4640-AC38-33E0B1F0DCC2}"
EndProject
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "libmatroska", "lib\static\libmatroska.vcproj", "{061EEA22-F7D5-4477-AB15-0DCE85EA038A}"
EndProject
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "test0", "test\test0.vcproj", "{8380F3AF-9E4A-4D5F-900F-991978CE44E1}"
EndProject
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "test00", "test\test00.vcproj", "{78DA23EF-794A-4311-9B99-8C71D44CC749}"
EndProject
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "test6", "test\test6.vcproj", "{4770FB10-8B2F-4E29-BA0B-517031ABC0F5}"
EndProject
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "test8", "test\test8.vcproj", "{EAE085B0-7FD7-48DA-ABFE-A706DACC3794}"
EndProject
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "test9", "test\test9.vcproj", "{F294A3C5-D355-49E7-A8B8-B9692345A5E0}"
EndProject
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "libmatroskadll", "lib\dll\libmatroskadll.v71.vcproj", "{B227AC03-C69E-46B1-B91E-A77BE4C6F83A}"
EndProject
Global
GlobalSection(DPCodeReviewSolutionGUID) = preSolution
DPCodeReviewSolutionGUID = {00000000-0000-0000-0000-000000000000}
EndGlobalSection
GlobalSection(DevPartner Solution Properties) = postSolution
EndGlobalSection
GlobalSection(SolutionConfiguration) = preSolution
ConfigName.0 = Debug
ConfigName.1 = Release
EndGlobalSection
EndGlobalSection
GlobalSection(ProjectConfiguration) = postSolution
{C6902997-CF7C-42B5-AD42-5B7C11F4CFE6}.Debug.ActiveCfg = Debug|Win32
{C6902997-CF7C-42B5-AD42-5B7C11F4CFE6}.Debug.Build.0 = Debug|Win32
{C6902997-CF7C-42B5-AD42-5B7C11F4CFE6}.Release.ActiveCfg = Release|Win32
{C6902997-CF7C-42B5-AD42-5B7C11F4CFE6}.Release.Build.0 = Release|Win32
{061EEA22-F7D5-4477-AB15-0DCE85EA038A}.Debug.ActiveCfg = Debug|Win32
{061EEA22-F7D5-4477-AB15-0DCE85EA038A}.Debug.Build.0 = Debug|Win32
{061EEA22-F7D5-4477-AB15-0DCE85EA038A}.Release.ActiveCfg = Release|Win32
{061EEA22-F7D5-4477-AB15-0DCE85EA038A}.Release.Build.0 = Release|Win32
{8380F3AF-9E4A-4D5F-900F-991978CE44E1}.Debug.ActiveCfg = Debug|Win32
{8380F3AF-9E4A-4D5F-900F-991978CE44E1}.Release.ActiveCfg = Release|Win32
{78DA23EF-794A-4311-9B99-8C71D44CC749}.Debug.ActiveCfg = Debug|Win32
{78DA23EF-794A-4311-9B99-8C71D44CC749}.Release.ActiveCfg = Release|Win32
{4770FB10-8B2F-4E29-BA0B-517031ABC0F5}.Debug.ActiveCfg = Debug|Win32
{4770FB10-8B2F-4E29-BA0B-517031ABC0F5}.Debug.Build.0 = Debug|Win32
{4770FB10-8B2F-4E29-BA0B-517031ABC0F5}.Release.ActiveCfg = Release|Win32
{4770FB10-8B2F-4E29-BA0B-517031ABC0F5}.Release.Build.0 = Release|Win32
{EAE085B0-7FD7-48DA-ABFE-A706DACC3794}.Debug.ActiveCfg = Debug|Win32
{EAE085B0-7FD7-48DA-ABFE-A706DACC3794}.Debug.Build.0 = Debug|Win32
{EAE085B0-7FD7-48DA-ABFE-A706DACC3794}.Release.ActiveCfg = Release|Win32
{EAE085B0-7FD7-48DA-ABFE-A706DACC3794}.Release.Build.0 = Release|Win32
{F294A3C5-D355-49E7-A8B8-B9692345A5E0}.Debug.ActiveCfg = Debug|Win32
{F294A3C5-D355-49E7-A8B8-B9692345A5E0}.Debug.Build.0 = Debug|Win32
{F294A3C5-D355-49E7-A8B8-B9692345A5E0}.Release.ActiveCfg = Release|Win32
{F294A3C5-D355-49E7-A8B8-B9692345A5E0}.Release.Build.0 = Release|Win32
{B227AC03-C69E-46B1-B91E-A77BE4C6F83A}.Debug.ActiveCfg = Debug|Win32
{B227AC03-C69E-46B1-B91E-A77BE4C6F83A}.Debug.Build.0 = Debug|Win32
{B227AC03-C69E-46B1-B91E-A77BE4C6F83A}.Release.ActiveCfg = Release|Win32
{B227AC03-C69E-46B1-B91E-A77BE4C6F83A}.Release.Build.0 = Release|Win32
{83136D19-2749-4640-AC38-33E0B1F0DCC2}.Debug.ActiveCfg = Debug|Win32
{83136D19-2749-4640-AC38-33E0B1F0DCC2}.Debug.Build.0 = Debug|Win32
{83136D19-2749-4640-AC38-33E0B1F0DCC2}.Release.ActiveCfg = Release|Win32
{83136D19-2749-4640-AC38-33E0B1F0DCC2}.Release.Build.0 = Release|Win32
EndGlobalSection
GlobalSection(ExtensibilityGlobals) = postSolution
EndGlobalSection
GlobalSection(ExtensibilityAddIns) = postSolution
EndGlobalSection
GlobalSection(DevPartner) = postSolution
EndGlobalSection
GlobalSection(DevPartner) = postSolution
EndGlobalSection
EndGlobal

152
matroska/FileKax.h Normal file
View File

@ -0,0 +1,152 @@
/****************************************************************************
** libmatroska : parse Matroska files, see http://www.matroska.org/
**
** <file/class description>
**
** Copyright (C) 2002-2004 Steve Lhomme. All rights reserved.
**
** This file is part of libmatroska.
**
** This library is free software; you can redistribute it and/or
** modify it under the terms of the GNU Lesser General Public
** License as published by the Free Software Foundation; either
** version 2.1 of the License, or (at your option) any later version.
**
** This library is distributed in the hope that it will be useful,
** but WITHOUT ANY WARRANTY; without even the implied warranty of
** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
** Lesser General Public License for more details.
**
** You should have received a copy of the GNU Lesser General Public
** License along with this library; if not, write to the Free Software
** Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
**
** See http://www.matroska.org/license/lgpl/ for LGPL licensing information.**
** Contact license@matroska.org if any conditions of this licensing are
** not clear to you.
**
**********************************************************************/
/*!
\file
\version \$Id: FileKax.h,v 1.5 2004/04/14 23:26:17 robux4 Exp $
\author Steve Lhomme <robux4 @ users.sf.net>
*/
#ifndef LIBMATROSKA_FILE_H
#define LIBMATROSKA_FILE_H
//#include <vector>
#include "matroska/KaxTypes.h"
#include "ebml/IOCallback.h"
//#include "MainHeader.h"
//#include "TrackType.h"
//#include "StreamInfo.h"
//#include "Cluster.h"
//#include "CodecHeader.h"
using namespace LIBEBML_NAMESPACE;
START_LIBMATROSKA_NAMESPACE
//class Track;
//class Frame;
/*!
\class MATROSKA_DLL_API FileMatroska
\brief General container of all the parameters and data of an Matroska file
\todo Handle the filename and next filename
\todo Handle the IOCallback selection/type
*/
class MATROSKA_DLL_API FileMatroska {
public:
FileMatroska(IOCallback & output);
~FileMatroska();
#ifdef OLD
uint32 RenderHead(const std::string & aEncoderApp);
uint32 ReadHead();
uint32 ReadTracks();
uint32 ReadCodec();
void Close(const uint32 aTimeLength);
inline void type_SetInfo(const std::string & aStr) {myMainHeader.type_SetInfo(aStr);}
inline void type_SetAds(const std::string & aStr) {myMainHeader.type_SetAds(aStr);}
inline void type_SetSize(const std::string & aStr) {myMainHeader.type_SetSize(aStr);}
inline void type_SetSize(const uint64 aSize) {myMainHeader.type_SetSize(aSize);}
inline uint8 GetTrackNumber() const { return myTracks.size(); }
void track_SetName(Track * aTrack, const std::string & aName);
void track_SetLaced(Track * aTrack, const bool bLaced = true);
Track * CreateTrack(const track_type aType);
inline Track * GetTrack(const uint8 aTrackNb) const
{
if (aTrackNb > myTracks.size())
return NULL;
else
return myTracks[aTrackNb-1];
}
void Track_GetInfo(const Track * aTrack, TrackInfo & aTrackInfo) const;
void Track_SetInfo_Audio(Track * aTrack, const TrackInfoAudio & aTrackInfo);
void Track_GetInfo_Audio(const Track * aTrack, TrackInfoAudio & aTrackInfo) const;
void Track_SetInfo_Video(Track * aTrack, const TrackInfoVideo & aTrackInfo);
void Track_GetInfo_Video(const Track * aTrack, TrackInfoVideo & aTrackInfo) const;
void SelectReadingTrack(Track * aTrack, bool select = true);
/*!
\return wether the frame has been added or not
*/
bool AddFrame(Track * aTrack, const uint32 aTimecode, const binary *aFrame, const uint32 aFrameSize,
const bool aKeyFrame = true, const bool aBFrame = false);
/*!
\return wether the frame has been read or not
*/
bool ReadFrame(Track * & aTrack, uint32 & aTimecode, const binary * & aFrame, uint32 & aFrameSize,
bool & aKeyFrame, bool & aBFrame);
/*
Render the pending cluster to file
*/
void Flush();
void SetMaxClusterSize(const uint32 value);
void SetMinClusterSize(const uint32 value) {myMinClusterSize = value;}
protected:
MainHeader myMainHeader;
std::vector<Track *> myTracks;
std::vector<uint8> mySelectedTracks;
// Track *findTrack(Track * aTrack) const;
Cluster myCurrWriteCluster; /// \todo merge with the write one ?
uint32 myReadBlockNumber;
Cluster myCurrReadCluster;
binary * myCurrReadBlock; ///< The buffer containing the current read block
uint32 myCurrReadBlockSize; ///< The size of the buffer containing the current read block
uint8 myCurrReadBlockTrack; ///< The track number of the current track to read
uint32 myMaxClusterSize;
uint32 myMinClusterSize;
StreamInfo myStreamInfo;
CodecHeader myCodecHeader;
inline bool IsMyTrack(const Track * aTrack) const;
inline bool IsReadingTrack(const uint8 aTrackNum) const;
#endif // OLD
IOCallback & myFile;
};
END_LIBMATROSKA_NAMESPACE
#endif // FILE_KAX_HPP

142
matroska/KaxAttached.h Normal file
View File

@ -0,0 +1,142 @@
/****************************************************************************
** libmatroska : parse Matroska files, see http://www.matroska.org/
**
** <file/class MATROSKA_DLL_API description>
**
** Copyright (C) 2002-2004 Steve Lhomme. All rights reserved.
**
** This file is part of libmatroska.
**
** This library is free software; you can redistribute it and/or
** modify it under the terms of the GNU Lesser General Public
** License as published by the Free Software Foundation; either
** version 2.1 of the License, or (at your option) any later version.
**
** This library is distributed in the hope that it will be useful,
** but WITHOUT ANY WARRANTY; without even the implied warranty of
** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
** Lesser General Public License for more details.
**
** You should have received a copy of the GNU Lesser General Public
** License along with this library; if not, write to the Free Software
** Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
**
** See http://www.matroska.org/license/lgpl/ for LGPL licensing information.**
** Contact license@matroska.org if any conditions of this licensing are
** not clear to you.
**
**********************************************************************/
/*!
\file
\version \$Id: KaxAttached.h,v 1.8 2004/04/14 23:26:17 robux4 Exp $
\author Steve Lhomme <robux4 @ users.sf.net>
*/
#ifndef LIBMATROSKA_ATTACHED_H
#define LIBMATROSKA_ATTACHED_H
#include "matroska/KaxTypes.h"
#include "ebml/EbmlMaster.h"
#include "ebml/EbmlUnicodeString.h"
#include "ebml/EbmlString.h"
#include "ebml/EbmlBinary.h"
#include "ebml/EbmlUInteger.h"
using namespace LIBEBML_NAMESPACE;
START_LIBMATROSKA_NAMESPACE
class MATROSKA_DLL_API KaxAttached : public EbmlMaster {
public:
KaxAttached();
KaxAttached(const KaxAttached & ElementToClone) : EbmlMaster(ElementToClone) {}
static EbmlElement & Create() {return *(new KaxAttached);}
const EbmlCallbacks & Generic() const {return ClassInfos;}
static const EbmlCallbacks ClassInfos;
operator const EbmlId &() const {return ClassInfos.GlobalId;}
bool IsYourId(const EbmlId & TestId) const;
EbmlElement * Clone() const {return new KaxAttached(*this);}
};
class MATROSKA_DLL_API KaxFileDescription : public EbmlUnicodeString {
public:
KaxFileDescription() {}
KaxFileDescription(const KaxFileDescription & ElementToClone) : EbmlUnicodeString(ElementToClone) {}
static EbmlElement & Create() {return *(new KaxFileDescription);}
const EbmlCallbacks & Generic() const {return ClassInfos;}
static const EbmlCallbacks ClassInfos;
operator const EbmlId &() const {return ClassInfos.GlobalId;}
bool IsYourId(const EbmlId & TestId) const;
EbmlElement * Clone() const {return new KaxFileDescription(*this);}
};
class MATROSKA_DLL_API KaxFileName : public EbmlUnicodeString {
public:
KaxFileName() {}
KaxFileName(const KaxFileName & ElementToClone) : EbmlUnicodeString(ElementToClone) {}
static EbmlElement & Create() {return *(new KaxFileName);}
const EbmlCallbacks & Generic() const {return ClassInfos;}
static const EbmlCallbacks ClassInfos;
operator const EbmlId &() const {return ClassInfos.GlobalId;}
bool IsYourId(const EbmlId & TestId) const;
EbmlElement * Clone() const {return new KaxFileName(*this);}
};
class MATROSKA_DLL_API KaxMimeType : public EbmlString {
public:
KaxMimeType() {}
KaxMimeType(const KaxMimeType & ElementToClone) : EbmlString(ElementToClone) {}
static EbmlElement & Create() {return *(new KaxMimeType);}
const EbmlCallbacks & Generic() const {return ClassInfos;}
static const EbmlCallbacks ClassInfos;
operator const EbmlId &() const {return ClassInfos.GlobalId;}
bool IsYourId(const EbmlId & TestId) const;
EbmlElement * Clone() const {return new KaxMimeType(*this);}
};
class MATROSKA_DLL_API KaxFileData : public EbmlBinary {
public:
KaxFileData() {}
KaxFileData(const KaxFileData & ElementToClone) :EbmlBinary(ElementToClone){}
static EbmlElement & Create() {return *(new KaxFileData);}
const EbmlCallbacks & Generic() const {return ClassInfos;}
bool ValidateSize() const {return true;} // we don't mind about what's inside
static const EbmlCallbacks ClassInfos;
operator const EbmlId &() const {return ClassInfos.GlobalId;}
bool IsYourId(const EbmlId & TestId) const;
EbmlElement * Clone() const {return new KaxFileData(*this);}
};
class MATROSKA_DLL_API KaxFileReferral : public EbmlBinary {
public:
KaxFileReferral() {}
KaxFileReferral(const KaxFileReferral & ElementToClone) :EbmlBinary(ElementToClone){}
static EbmlElement & Create() {return *(new KaxFileReferral);}
const EbmlCallbacks & Generic() const {return ClassInfos;}
bool ValidateSize() const {return true;} // we don't mind about what's inside
static const EbmlCallbacks ClassInfos;
operator const EbmlId &() const {return ClassInfos.GlobalId;}
EbmlElement * Clone() const {return new KaxFileReferral(*this);}
};
class MATROSKA_DLL_API KaxFileUID : public EbmlUInteger {
public:
KaxFileUID() {}
KaxFileUID(const KaxFileUID & ElementToClone) : EbmlUInteger(ElementToClone) {}
static EbmlElement & Create() {return *(new KaxFileUID);}
const EbmlCallbacks & Generic() const {return ClassInfos;}
static const EbmlCallbacks ClassInfos;
operator const EbmlId &() const {return ClassInfos.GlobalId;}
bool IsYourId(const EbmlId & TestId) const;
EbmlElement * Clone() const {return new KaxFileUID(*this);}
};
END_LIBMATROSKA_NAMESPACE
#endif // LIBMATROSKA_ATTACHED_H

58
matroska/KaxAttachments.h Normal file
View File

@ -0,0 +1,58 @@
/****************************************************************************
** libmatroska : parse Matroska files, see http://www.matroska.org/
**
** <file/class description>
**
** Copyright (C) 2002-2004 Steve Lhomme. All rights reserved.
**
** This file is part of libmatroska.
**
** This library is free software; you can redistribute it and/or
** modify it under the terms of the GNU Lesser General Public
** License as published by the Free Software Foundation; either
** version 2.1 of the License, or (at your option) any later version.
**
** This library is distributed in the hope that it will be useful,
** but WITHOUT ANY WARRANTY; without even the implied warranty of
** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
** Lesser General Public License for more details.
**
** You should have received a copy of the GNU Lesser General Public
** License along with this library; if not, write to the Free Software
** Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
**
** See http://www.matroska.org/license/lgpl/ for LGPL licensing information.**
** Contact license@matroska.org if any conditions of this licensing are
** not clear to you.
**
**********************************************************************/
/*!
\file
\version \$Id: KaxAttachments.h,v 1.8 2004/04/14 23:26:17 robux4 Exp $
\author Steve Lhomme <robux4 @ users.sf.net>
*/
#ifndef LIBMATROSKA_ATTACHEMENTS_H
#define LIBMATROSKA_ATTACHEMENTS_H
#include "matroska/KaxTypes.h"
#include "ebml/EbmlMaster.h"
using namespace LIBEBML_NAMESPACE;
START_LIBMATROSKA_NAMESPACE
class MATROSKA_DLL_API KaxAttachments : public EbmlMaster {
public:
KaxAttachments();
KaxAttachments(const KaxAttachments & ElementToClone) : EbmlMaster(ElementToClone) {}
static EbmlElement & Create() {return *(new KaxAttachments);}
const EbmlCallbacks & Generic() const {return ClassInfos;}
static const EbmlCallbacks ClassInfos;
operator const EbmlId &() const {return ClassInfos.GlobalId;}
EbmlElement * Clone() const {return new KaxAttachments(*this);}
};
END_LIBMATROSKA_NAMESPACE
#endif // LIBMATROSKA_ATTACHEMENTS_H

455
matroska/KaxBlock.h Normal file
View File

@ -0,0 +1,455 @@
/****************************************************************************
** libmatroska : parse Matroska files, see http://www.matroska.org/
**
** <file/class description>
**
** Copyright (C) 2002-2005 Steve Lhomme. All rights reserved.
**
** This library is free software; you can redistribute it and/or
** modify it under the terms of the GNU Lesser General Public
** License as published by the Free Software Foundation; either
** version 2.1 of the License, or (at your option) any later version.
**
** This library is distributed in the hope that it will be useful,
** but WITHOUT ANY WARRANTY; without even the implied warranty of
** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
** Lesser General Public License for more details.
**
** You should have received a copy of the GNU Lesser General Public
** License along with this library; if not, write to the Free Software
** Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
**
** See http://www.matroska.org/license/lgpl/ for LGPL licensing information.**
** Contact license@matroska.org if any conditions of this licensing are
** not clear to you.
**
**********************************************************************/
/*!
\file
\todo add a PureBlock class to group functionalities between Block and BlockVirtual
\version \$Id: KaxBlock.h,v 1.24 2004/04/14 23:26:17 robux4 Exp $
\author Steve Lhomme <robux4 @ users.sf.net>
\author Julien Coloos <suiryc @ users.sf.net>
*/
#ifndef LIBMATROSKA_BLOCK_H
#define LIBMATROSKA_BLOCK_H
#include <vector>
#include "matroska/KaxTypes.h"
#include "ebml/EbmlBinary.h"
#include "ebml/EbmlMaster.h"
#include "matroska/KaxTracks.h"
using namespace LIBEBML_NAMESPACE;
START_LIBMATROSKA_NAMESPACE
class KaxCluster;
class KaxReferenceBlock;
class KaxInternalBlock;
class KaxBlockBlob;
class MATROSKA_DLL_API DataBuffer {
protected:
binary * myBuffer;
uint32 mySize;
bool bValidValue;
bool (*myFreeBuffer)(const DataBuffer & aBuffer); // method to free the internal buffer
public:
DataBuffer(binary * aBuffer, uint32 aSize, bool (*aFreeBuffer)(const DataBuffer & aBuffer) = NULL)
:myBuffer(aBuffer)
,mySize(aSize)
,bValidValue(true)
,myFreeBuffer(aFreeBuffer)
{}
virtual ~DataBuffer() {}
virtual binary * Buffer() {return myBuffer;}
virtual uint32 & Size() {return mySize;};
virtual const binary * Buffer() const {return myBuffer;}
virtual const uint32 Size() const {return mySize;};
bool FreeBuffer(const DataBuffer & aBuffer) {
bool bResult = true;
if (myBuffer != NULL && myFreeBuffer != NULL && bValidValue) {
bResult = myFreeBuffer(aBuffer);
myBuffer = NULL;
bValidValue = false;
}
return bResult;
}
virtual DataBuffer * Clone();
};
class MATROSKA_DLL_API SimpleDataBuffer : public DataBuffer {
public:
SimpleDataBuffer(binary * aBuffer, uint32 aSize, uint32 aOffset, bool (*aFreeBuffer)(const DataBuffer & aBuffer) = myFreeBuffer)
:DataBuffer(aBuffer + aOffset, aSize, aFreeBuffer)
,Offset(aOffset)
,BaseBuffer(aBuffer)
{}
virtual ~SimpleDataBuffer() {}
DataBuffer * Clone() {return new SimpleDataBuffer(*this);}
protected:
uint32 Offset;
binary * BaseBuffer;
static bool myFreeBuffer(const DataBuffer & aBuffer)
{
binary *_Buffer = static_cast<const SimpleDataBuffer*>(&aBuffer)->BaseBuffer;
if (_Buffer != NULL)
free(_Buffer);
return true;
}
SimpleDataBuffer(const SimpleDataBuffer & ToClone);
};
/*!
\note the data is copied locally, it can be freed right away
* /
class MATROSKA_DLL_API NotSoSimpleDataBuffer : public SimpleDataBuffer {
public:
NotSoSimpleDataBuffer(binary * aBuffer, uint32 aSize, uint32 aOffset)
:SimpleDataBuffer(new binary[aSize - aOffset], aSize, 0)
{
memcpy(BaseBuffer, aBuffer + aOffset, aSize - aOffset);
}
};
*/
class MATROSKA_DLL_API KaxBlockGroup : public EbmlMaster {
public:
KaxBlockGroup();
KaxBlockGroup(const KaxBlockGroup & ElementToClone) :EbmlMaster(ElementToClone) {}
static EbmlElement & Create() {return *(new KaxBlockGroup);}
const EbmlCallbacks & Generic() const {return ClassInfos;}
static const EbmlCallbacks ClassInfos;
operator const EbmlId &() const {return ClassInfos.GlobalId;}
EbmlElement * Clone() const {return new KaxBlockGroup(*this);}
~KaxBlockGroup();
/*!
\brief Addition of a frame without references
*/
bool AddFrame(const KaxTrackEntry & track, uint64 timecode, DataBuffer & buffer, LacingType lacing = LACING_AUTO);
/*!
\brief Addition of a frame with a backward reference (P frame)
*/
bool AddFrame(const KaxTrackEntry & track, uint64 timecode, DataBuffer & buffer, const KaxBlockGroup & PastBlock, LacingType lacing = LACING_AUTO);
/*!
\brief Addition of a frame with a backward+forward reference (B frame)
*/
bool AddFrame(const KaxTrackEntry & track, uint64 timecode, DataBuffer & buffer, const KaxBlockGroup & PastBlock, const KaxBlockGroup & ForwBlock, LacingType lacing = LACING_AUTO);
bool AddFrame(const KaxTrackEntry & track, uint64 timecode, DataBuffer & buffer, const KaxBlockBlob * PastBlock, const KaxBlockBlob * ForwBlock, LacingType lacing = LACING_AUTO);
void SetParent(KaxCluster & aParentCluster);
void SetParentTrack(const KaxTrackEntry & aParentTrack) {
ParentTrack = &aParentTrack;
}
/*!
\brief Set the duration of the contained frame(s) (for the total number of frames)
*/
void SetBlockDuration(uint64 TimeLength);
bool GetBlockDuration(uint64 &TheTimecode) const;
/*!
\return the global timecode of this Block (not just the delta to the Cluster)
*/
uint64 GlobalTimecode() const;
uint64 GlobalTimecodeScale() const {
assert(ParentTrack != NULL);
return ParentTrack->GlobalTimecodeScale();
}
uint16 TrackNumber() const;
uint64 ClusterPosition() const;
/*!
\return the number of references to other frames
*/
unsigned int ReferenceCount() const;
const KaxReferenceBlock & Reference(unsigned int Index) const;
/*!
\brief release all the frames of all Blocks
*/
void ReleaseFrames();
operator KaxInternalBlock &();
const KaxCluster *GetParentCluster() const { return ParentCluster; }
protected:
KaxCluster * ParentCluster;
const KaxTrackEntry * ParentTrack;
};
class KaxInternalBlock : public EbmlBinary {
public:
KaxInternalBlock( bool bSimple ) :bLocalTimecodeUsed(false), mLacing(LACING_AUTO), mInvisible(false)
,ParentCluster(NULL), bIsSimple(bSimple), bIsKeyframe(true), bIsDiscardable(false)
{}
KaxInternalBlock(const KaxInternalBlock & ElementToClone);
~KaxInternalBlock();
bool ValidateSize() const;
uint16 TrackNum() const {return TrackNumber;}
/*!
\todo !!!! This method needs to be changes !
*/
uint64 GlobalTimecode() const {return Timecode;}
/*!
\note override this function to generate the Data/Size on the fly, unlike the usual binary elements
*/
uint64 UpdateSize(bool bSaveDefault = false, bool bForceRender = false);
uint64 ReadData(IOCallback & input, ScopeMode ReadFully = SCOPE_ALL_DATA);
/*!
\brief Only read the head of the Block (not internal data)
\note convenient when you are parsing the file quickly
*/
uint64 ReadInternalHead(IOCallback & input);
unsigned int NumberFrames() const { return SizeList.size();}
DataBuffer & GetBuffer(unsigned int iIndex) {return *myBuffers[iIndex];}
bool AddFrame(const KaxTrackEntry & track, uint64 timecode, DataBuffer & buffer, LacingType lacing = LACING_AUTO, bool invisible = false);
/*!
\brief release all the frames of all Blocks
*/
void ReleaseFrames();
void SetParent(KaxCluster & aParentCluster);
/*!
\return Returns the lacing type that produces the smallest footprint.
*/
LacingType GetBestLacingType() const;
/*!
\param FrameNumber 0 for the first frame
\return the position in the stream for a given frame
\note return -1 if the position doesn't exist
*/
int64 GetDataPosition(size_t FrameNumber = 0);
/*!
\param FrameNumber 0 for the first frame
\return the size of a given frame
\note return -1 if the position doesn't exist
*/
int64 GetFrameSize(size_t FrameNumber = 0);
bool IsInvisible() const { return mInvisible; }
uint64 ClusterPosition() const;
protected:
std::vector<DataBuffer *> myBuffers;
std::vector<int32> SizeList;
uint64 Timecode; // temporary timecode of the first frame, non scaled
int16 LocalTimecode;
bool bLocalTimecodeUsed;
uint16 TrackNumber;
LacingType mLacing;
bool mInvisible;
uint64 FirstFrameLocation;
uint32 RenderData(IOCallback & output, bool bForceRender, bool bSaveDefault = false);
KaxCluster * ParentCluster;
bool bIsSimple;
bool bIsKeyframe;
bool bIsDiscardable;
};
class MATROSKA_DLL_API KaxBlock : public KaxInternalBlock {
public:
KaxBlock() :KaxInternalBlock(false) {}
static EbmlElement & Create() {return *(new KaxBlock);}
static const EbmlCallbacks ClassInfos;
operator const EbmlId &() const {return ClassInfos.GlobalId;}
const EbmlCallbacks & Generic() const {return ClassInfos;}
EbmlElement * Clone() const {return new KaxBlock(*this);}
};
#if MATROSKA_VERSION >= 2
class MATROSKA_DLL_API KaxSimpleBlock : public KaxInternalBlock {
public:
KaxSimpleBlock() :KaxInternalBlock(true) {}
static EbmlElement & Create() {return *(new KaxSimpleBlock);}
static const EbmlCallbacks ClassInfos;
operator const EbmlId &() const {return ClassInfos.GlobalId;}
const EbmlCallbacks & Generic() const {return ClassInfos;}
EbmlElement * Clone() const {return new KaxSimpleBlock(*this);}
void SetKeyframe(bool b_keyframe) { bIsKeyframe = b_keyframe; }
void SetDiscardable(bool b_discard) { bIsDiscardable = b_discard; }
bool IsKeyframe() const { return bIsKeyframe; }
bool IsDiscardable() const { return bIsDiscardable; }
operator KaxInternalBlock &() { return *this; }
};
#endif // MATROSKA_VERSION
class MATROSKA_DLL_API KaxBlockBlob {
public:
KaxBlockBlob(BlockBlobType sblock_mode) :ParentCluster(NULL), SimpleBlockMode(sblock_mode) {
bUseSimpleBlock = (sblock_mode != BLOCK_BLOB_NO_SIMPLE);
Block.group = NULL;
}
~KaxBlockBlob() {
#if MATROSKA_VERSION >= 2
if (bUseSimpleBlock)
delete Block.simpleblock;
else
#endif // MATROSKA_VERSION
delete Block.group;
}
operator KaxBlockGroup &();
operator const KaxBlockGroup &() const;
#if MATROSKA_VERSION >= 2
operator KaxSimpleBlock &();
#endif
operator KaxInternalBlock &();
operator const KaxInternalBlock &() const;
void SetBlockGroup( KaxBlockGroup &BlockRef );
void SetBlockDuration(uint64 TimeLength);
void SetParent(KaxCluster & aParentCluster);
bool AddFrameAuto(const KaxTrackEntry & track, uint64 timecode, DataBuffer & buffer, LacingType lacing = LACING_AUTO, const KaxBlockBlob * PastBlock = NULL, const KaxBlockBlob * ForwBlock = NULL);
bool IsSimpleBlock() const {return bUseSimpleBlock;}
bool ReplaceSimpleByGroup();
protected:
KaxCluster * ParentCluster;
union {
KaxBlockGroup *group;
#if MATROSKA_VERSION >= 2
KaxSimpleBlock *simpleblock;
#endif // MATROSKA_VERSION
} Block;
bool bUseSimpleBlock;
BlockBlobType SimpleBlockMode;
};
class MATROSKA_DLL_API KaxBlockDuration : public EbmlUInteger {
public:
KaxBlockDuration() {}
KaxBlockDuration(const KaxBlockDuration & ElementToClone) :EbmlUInteger(ElementToClone) {}
static EbmlElement & Create() {return *(new KaxBlockDuration);}
const EbmlCallbacks & Generic() const {return ClassInfos;}
static const EbmlCallbacks ClassInfos;
operator const EbmlId &() const {return ClassInfos.GlobalId;}
EbmlElement * Clone() const {return new KaxBlockDuration(*this);}
};
#if MATROSKA_VERSION >= 2
class MATROSKA_DLL_API KaxBlockVirtual : public EbmlBinary {
public:
KaxBlockVirtual() :ParentCluster(NULL) {Data = DataBlock; Size = countof(DataBlock);}
KaxBlockVirtual(const KaxBlockVirtual & ElementToClone);
static EbmlElement & Create() {return *(new KaxBlockVirtual);}
const EbmlCallbacks & Generic() const {return ClassInfos;}
static const EbmlCallbacks ClassInfos;
operator const EbmlId &() const {return ClassInfos.GlobalId;}
bool ValidateSize() const {return true;}
/*!
\note override this function to generate the Data/Size on the fly, unlike the usual binary elements
*/
uint64 UpdateSize(bool bSaveDefault = false, bool bForceRender = false);
void SetParent(const KaxCluster & aParentCluster) {ParentCluster = &aParentCluster;}
EbmlElement * Clone() const {return new KaxBlockVirtual(*this);}
protected:
uint64 Timecode; // temporary timecode of the first frame if there are more than one
uint16 TrackNumber;
binary DataBlock[5];
const KaxCluster * ParentCluster;
};
#endif // MATROSKA_VERSION
class MATROSKA_DLL_API KaxBlockAdditional : public EbmlBinary {
public:
KaxBlockAdditional() {}
KaxBlockAdditional(const KaxBlockAdditional & ElementToClone) :EbmlBinary(ElementToClone){}
static EbmlElement & Create() {return *(new KaxBlockAdditional);}
const EbmlCallbacks & Generic() const {return ClassInfos;}
static const EbmlCallbacks ClassInfos;
operator const EbmlId &() const {return ClassInfos.GlobalId;}
bool ValidateSize() const {return true;}
EbmlElement * Clone() const {return new KaxBlockAdditional(*this);}
};
class MATROSKA_DLL_API KaxBlockAdditions : public EbmlMaster {
public:
KaxBlockAdditions();
KaxBlockAdditions(const KaxBlockAdditions & ElementToClone) :EbmlMaster(ElementToClone) {}
static EbmlElement & Create() {return *(new KaxBlockAdditions);}
const EbmlCallbacks & Generic() const {return ClassInfos;}
static const EbmlCallbacks ClassInfos;
operator const EbmlId &() const {return ClassInfos.GlobalId;}
EbmlElement * Clone() const {return new KaxBlockAdditions(*this);}
};
class MATROSKA_DLL_API KaxBlockMore : public EbmlMaster {
public:
KaxBlockMore();
KaxBlockMore(const KaxBlockMore & ElementToClone) :EbmlMaster(ElementToClone) {}
static EbmlElement & Create() {return *(new KaxBlockMore);}
const EbmlCallbacks & Generic() const {return ClassInfos;}
static const EbmlCallbacks ClassInfos;
operator const EbmlId &() const {return ClassInfos.GlobalId;}
EbmlElement * Clone() const {return new KaxBlockMore(*this);}
};
class MATROSKA_DLL_API KaxBlockAddID : public EbmlUInteger {
public:
KaxBlockAddID() :EbmlUInteger(1) {}
KaxBlockAddID(const KaxBlockAddID & ElementToClone) :EbmlUInteger(ElementToClone) {}
static EbmlElement & Create() {return *(new KaxBlockAddID);}
const EbmlCallbacks & Generic() const {return ClassInfos;}
static const EbmlCallbacks ClassInfos;
operator const EbmlId &() const {return ClassInfos.GlobalId;}
EbmlElement * Clone() const {return new KaxBlockAddID(*this);}
};
class MATROSKA_DLL_API KaxCodecState : public EbmlBinary {
public:
KaxCodecState() {}
KaxCodecState(const KaxCodecState & ElementToClone) :EbmlBinary(ElementToClone){}
static EbmlElement & Create() {return *(new KaxCodecState);}
const EbmlCallbacks & Generic() const {return ClassInfos;}
static const EbmlCallbacks ClassInfos;
operator const EbmlId &() const {return ClassInfos.GlobalId;}
bool ValidateSize() const {return true;}
EbmlElement * Clone() const {return new KaxCodecState(*this);}
};
END_LIBMATROSKA_NAMESPACE
#endif // LIBMATROSKA_BLOCK_H

182
matroska/KaxBlockData.h Normal file
View File

@ -0,0 +1,182 @@
/****************************************************************************
** libmatroska : parse Matroska files, see http://www.matroska.org/
**
** <file/class description>
**
** Copyright (C) 2002-2005 Steve Lhomme. All rights reserved.
**
** This library is free software; you can redistribute it and/or
** modify it under the terms of the GNU Lesser General Public
** License as published by the Free Software Foundation; either
** version 2.1 of the License, or (at your option) any later version.
**
** This library is distributed in the hope that it will be useful,
** but WITHOUT ANY WARRANTY; without even the implied warranty of
** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
** Lesser General Public License for more details.
**
** You should have received a copy of the GNU Lesser General Public
** License along with this library; if not, write to the Free Software
** Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
**
** See http://www.matroska.org/license/lgpl/ for LGPL licensing information.**
** Contact license@matroska.org if any conditions of this licensing are
** not clear to you.
**
**********************************************************************/
/*!
\file
\version \$Id: KaxBlockData.h,v 1.10 2004/04/14 23:26:17 robux4 Exp $
\author Steve Lhomme <robux4 @ users.sf.net>
*/
#ifndef LIBMATROSKA_BLOCK_ADDITIONAL_H
#define LIBMATROSKA_BLOCK_ADDITIONAL_H
#include "matroska/KaxTypes.h"
#include "ebml/EbmlMaster.h"
#include "ebml/EbmlUInteger.h"
#include "ebml/EbmlSInteger.h"
using namespace LIBEBML_NAMESPACE;
START_LIBMATROSKA_NAMESPACE
class KaxReferenceBlock;
class KaxBlockGroup;
class KaxBlockBlob;
class MATROSKA_DLL_API KaxReferencePriority : public EbmlUInteger {
public:
KaxReferencePriority() :EbmlUInteger(0) {}
KaxReferencePriority(const KaxReferencePriority & ElementToClone) :EbmlUInteger(ElementToClone) {}
static EbmlElement & Create() {return *(new KaxReferencePriority);}
const EbmlCallbacks & Generic() const {return ClassInfos;}
static const EbmlCallbacks ClassInfos;
operator const EbmlId &() const {return ClassInfos.GlobalId;}
EbmlElement * Clone() const {return new KaxReferencePriority(*this);}
};
/*!
\brief element used for B frame-likes
*/
class MATROSKA_DLL_API KaxReferenceBlock : public EbmlSInteger {
public:
KaxReferenceBlock() :RefdBlock(NULL), ParentBlock(NULL) {bTimecodeSet = false;}
KaxReferenceBlock(const KaxReferenceBlock & ElementToClone) :EbmlSInteger(ElementToClone), bTimecodeSet(ElementToClone.bTimecodeSet) {}
static EbmlElement & Create() {return *(new KaxReferenceBlock);}
const EbmlCallbacks & Generic() const {return ClassInfos;}
static const EbmlCallbacks ClassInfos;
operator const EbmlId &() const {return ClassInfos.GlobalId;}
EbmlElement * Clone() const {return new KaxReferenceBlock(*this);}
/*!
\brief override this method to compute the timecode value
*/
virtual uint64 UpdateSize(bool bSaveDefault = false, bool bForceRender = false);
const KaxBlockBlob & RefBlock() const;
void SetReferencedBlock(const KaxBlockBlob * aRefdBlock);
void SetReferencedBlock(const KaxBlockGroup & aRefdBlock);
void SetParentBlock(const KaxBlockGroup & aParentBlock) {ParentBlock = &aParentBlock;}
protected:
const KaxBlockBlob * RefdBlock;
const KaxBlockGroup * ParentBlock;
void SetReferencedTimecode(int64 refTimecode) {Value = refTimecode; bTimecodeSet = true; bValueIsSet = true;};
bool bTimecodeSet;
};
#if MATROSKA_VERSION >= 2
class MATROSKA_DLL_API KaxReferenceVirtual : public EbmlSInteger {
public:
KaxReferenceVirtual() {}
KaxReferenceVirtual(const KaxReferenceVirtual & ElementToClone) :EbmlSInteger(ElementToClone) {}
static EbmlElement & Create() {return *(new KaxReferenceVirtual);}
const EbmlCallbacks & Generic() const {return ClassInfos;}
static const EbmlCallbacks ClassInfos;
operator const EbmlId &() const {return ClassInfos.GlobalId;}
EbmlElement * Clone() const {return new KaxReferenceVirtual(*this);}
};
#endif // MATROSKA_VERSION
class MATROSKA_DLL_API KaxTimeSlice : public EbmlMaster {
public:
KaxTimeSlice();
KaxTimeSlice(const KaxTimeSlice & ElementToClone) :EbmlMaster(ElementToClone) {}
static EbmlElement & Create() {return *(new KaxTimeSlice);}
const EbmlCallbacks & Generic() const {return ClassInfos;}
static const EbmlCallbacks ClassInfos;
operator const EbmlId &() const {return ClassInfos.GlobalId;}
EbmlElement * Clone() const {return new KaxTimeSlice(*this);}
};
class MATROSKA_DLL_API KaxSlices : public EbmlMaster {
public:
KaxSlices();
KaxSlices(const KaxSlices & ElementToClone) :EbmlMaster(ElementToClone) {}
static EbmlElement & Create() {return *(new KaxSlices);}
const EbmlCallbacks & Generic() const {return ClassInfos;}
static const EbmlCallbacks ClassInfos;
operator const EbmlId &() const {return ClassInfos.GlobalId;}
EbmlElement * Clone() const {return new KaxSlices(*this);}
};
class MATROSKA_DLL_API KaxSliceLaceNumber : public EbmlUInteger {
public:
KaxSliceLaceNumber() :EbmlUInteger(0) {}
KaxSliceLaceNumber(const KaxSliceLaceNumber & ElementToClone) :EbmlUInteger(ElementToClone) {}
static EbmlElement & Create() {return *(new KaxSliceLaceNumber);}
const EbmlCallbacks & Generic() const {return ClassInfos;}
static const EbmlCallbacks ClassInfos;
operator const EbmlId &() const {return ClassInfos.GlobalId;}
EbmlElement * Clone() const {return new KaxSliceLaceNumber(*this);}
};
class MATROSKA_DLL_API KaxSliceFrameNumber : public EbmlUInteger {
public:
KaxSliceFrameNumber() :EbmlUInteger(0) {}
KaxSliceFrameNumber(const KaxSliceFrameNumber & ElementToClone) :EbmlUInteger(ElementToClone) {}
static EbmlElement & Create() {return *(new KaxSliceFrameNumber);}
const EbmlCallbacks & Generic() const {return ClassInfos;}
static const EbmlCallbacks ClassInfos;
operator const EbmlId &() const {return ClassInfos.GlobalId;}
EbmlElement * Clone() const {return new KaxSliceFrameNumber(*this);}
};
class MATROSKA_DLL_API KaxSliceBlockAddID : public EbmlUInteger {
public:
KaxSliceBlockAddID() :EbmlUInteger(0) {}
KaxSliceBlockAddID(const KaxSliceBlockAddID & ElementToClone) :EbmlUInteger(ElementToClone) {}
static EbmlElement & Create() {return *(new KaxSliceBlockAddID);}
const EbmlCallbacks & Generic() const {return ClassInfos;}
static const EbmlCallbacks ClassInfos;
operator const EbmlId &() const {return ClassInfos.GlobalId;}
EbmlElement * Clone() const {return new KaxSliceBlockAddID(*this);}
};
class MATROSKA_DLL_API KaxSliceDelay : public EbmlUInteger {
public:
KaxSliceDelay() :EbmlUInteger(0) {}
KaxSliceDelay(const KaxSliceDelay & ElementToClone) :EbmlUInteger(ElementToClone) {}
static EbmlElement & Create() {return *(new KaxSliceDelay);}
const EbmlCallbacks & Generic() const {return ClassInfos;}
static const EbmlCallbacks ClassInfos;
operator const EbmlId &() const {return ClassInfos.GlobalId;}
EbmlElement * Clone() const {return new KaxSliceDelay(*this);}
};
class MATROSKA_DLL_API KaxSliceDuration : public EbmlUInteger {
public:
KaxSliceDuration() {}
KaxSliceDuration(const KaxSliceDuration & ElementToClone) :EbmlUInteger(ElementToClone) {}
static EbmlElement & Create() {return *(new KaxSliceDuration);}
const EbmlCallbacks & Generic() const {return ClassInfos;}
static const EbmlCallbacks ClassInfos;
operator const EbmlId &() const {return ClassInfos.GlobalId;}
EbmlElement * Clone() const {return new KaxSliceDuration(*this);}
};
END_LIBMATROSKA_NAMESPACE
#endif // LIBMATROSKA_BLOCK_ADDITIONAL_H

352
matroska/KaxChapters.h Normal file
View File

@ -0,0 +1,352 @@
/****************************************************************************
** libmatroska : parse Matroska files, see http://www.matroska.org/
**
** <file/class description>
**
** Copyright (C) 2002-2005 Steve Lhomme. All rights reserved.
**
** This file is part of libmatroska.
**
** This library is free software; you can redistribute it and/or
** modify it under the terms of the GNU Lesser General Public
** License as published by the Free Software Foundation; either
** version 2.1 of the License, or (at your option) any later version.
**
** This library is distributed in the hope that it will be useful,
** but WITHOUT ANY WARRANTY; without even the implied warranty of
** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
** Lesser General Public License for more details.
**
** You should have received a copy of the GNU Lesser General Public
** License along with this library; if not, write to the Free Software
** Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
**
** See http://www.matroska.org/license/lgpl/ for LGPL licensing information.**
** Contact license@matroska.org if any conditions of this licensing are
** not clear to you.
**
**********************************************************************/
/*!
\file
\version \$Id: KaxChapters.h,v 1.9 2004/04/14 23:26:17 robux4 Exp $
\author Steve Lhomme <robux4 @ users.sf.net>
*/
#ifndef LIBMATROSKA_CHAPTERS_H
#define LIBMATROSKA_CHAPTERS_H
#include "matroska/KaxTypes.h"
#include "ebml/EbmlMaster.h"
#include "ebml/EbmlUInteger.h"
#include "ebml/EbmlUnicodeString.h"
#include "ebml/EbmlString.h"
#include "ebml/EbmlBinary.h"
using namespace LIBEBML_NAMESPACE;
START_LIBMATROSKA_NAMESPACE
class MATROSKA_DLL_API KaxChapters : public EbmlMaster {
public:
KaxChapters();
KaxChapters(const KaxChapters & ElementToClone) :EbmlMaster(ElementToClone) {}
static EbmlElement & Create() {return *(new KaxChapters);}
const EbmlCallbacks & Generic() const {return ClassInfos;}
static const EbmlCallbacks ClassInfos;
operator const EbmlId &() const {return ClassInfos.GlobalId;}
EbmlElement * Clone() const {return new KaxChapters(*this);}
};
class MATROSKA_DLL_API KaxEditionEntry : public EbmlMaster {
public:
KaxEditionEntry();
KaxEditionEntry(const KaxEditionEntry & ElementToClone) :EbmlMaster(ElementToClone) {}
static EbmlElement & Create() {return *(new KaxEditionEntry);}
const EbmlCallbacks & Generic() const {return ClassInfos;}
static const EbmlCallbacks ClassInfos;
operator const EbmlId &() const {return ClassInfos.GlobalId;}
EbmlElement * Clone() const {return new KaxEditionEntry(*this);}
};
class MATROSKA_DLL_API KaxEditionUID : public EbmlUInteger {
public:
KaxEditionUID() {}
KaxEditionUID(const KaxEditionUID & ElementToClone) :EbmlUInteger(ElementToClone) {}
static EbmlElement & Create() {return *(new KaxEditionUID);}
const EbmlCallbacks & Generic() const {return ClassInfos;}
static const EbmlCallbacks ClassInfos;
operator const EbmlId &() const {return ClassInfos.GlobalId;}
EbmlElement * Clone() const {return new KaxEditionUID(*this);}
};
class MATROSKA_DLL_API KaxEditionFlagHidden : public EbmlUInteger {
public:
KaxEditionFlagHidden(): EbmlUInteger(0) {}
KaxEditionFlagHidden(const KaxEditionFlagHidden & ElementToClone) :EbmlUInteger(ElementToClone) {}
static EbmlElement & Create() {return *(new KaxEditionFlagHidden);}
const EbmlCallbacks & Generic() const {return ClassInfos;}
static const EbmlCallbacks ClassInfos;
operator const EbmlId &() const {return ClassInfos.GlobalId;}
EbmlElement * Clone() const {return new KaxEditionFlagHidden(*this);}
};
class MATROSKA_DLL_API KaxEditionFlagDefault : public EbmlUInteger {
public:
KaxEditionFlagDefault(): EbmlUInteger(0) {}
KaxEditionFlagDefault(const KaxEditionFlagDefault & ElementToClone) :EbmlUInteger(ElementToClone) {}
static EbmlElement & Create() {return *(new KaxEditionFlagDefault);}
const EbmlCallbacks & Generic() const {return ClassInfos;}
static const EbmlCallbacks ClassInfos;
operator const EbmlId &() const {return ClassInfos.GlobalId;}
EbmlElement * Clone() const {return new KaxEditionFlagDefault(*this);}
};
class MATROSKA_DLL_API KaxEditionFlagOrdered : public EbmlUInteger {
public:
KaxEditionFlagOrdered(): EbmlUInteger(0) {}
KaxEditionFlagOrdered(const KaxEditionFlagOrdered & ElementToClone) :EbmlUInteger(ElementToClone) {}
static EbmlElement & Create() {return *(new KaxEditionFlagOrdered);}
const EbmlCallbacks & Generic() const {return ClassInfos;}
static const EbmlCallbacks ClassInfos;
operator const EbmlId &() const {return ClassInfos.GlobalId;}
EbmlElement * Clone() const {return new KaxEditionFlagOrdered(*this);}
};
class MATROSKA_DLL_API KaxChapterAtom : public EbmlMaster {
public:
KaxChapterAtom();
KaxChapterAtom(const KaxChapterAtom & ElementToClone) :EbmlMaster(ElementToClone) {}
static EbmlElement & Create() {return *(new KaxChapterAtom);}
const EbmlCallbacks & Generic() const {return ClassInfos;}
static const EbmlCallbacks ClassInfos;
operator const EbmlId &() const {return ClassInfos.GlobalId;}
EbmlElement * Clone() const {return new KaxChapterAtom(*this);}
};
class MATROSKA_DLL_API KaxChapterUID : public EbmlUInteger {
public:
KaxChapterUID() {}
KaxChapterUID(const KaxChapterUID & ElementToClone) :EbmlUInteger(ElementToClone) {}
static EbmlElement & Create() {return *(new KaxChapterUID);}
const EbmlCallbacks & Generic() const {return ClassInfos;}
static const EbmlCallbacks ClassInfos;
operator const EbmlId &() const {return ClassInfos.GlobalId;}
EbmlElement * Clone() const {return new KaxChapterUID(*this);}
};
class MATROSKA_DLL_API KaxChapterTimeStart : public EbmlUInteger {
public:
KaxChapterTimeStart() {}
KaxChapterTimeStart(const KaxChapterTimeStart & ElementToClone) :EbmlUInteger(ElementToClone) {}
static EbmlElement & Create() {return *(new KaxChapterTimeStart);}
const EbmlCallbacks & Generic() const {return ClassInfos;}
static const EbmlCallbacks ClassInfos;
operator const EbmlId &() const {return ClassInfos.GlobalId;}
EbmlElement * Clone() const {return new KaxChapterTimeStart(*this);}
};
class MATROSKA_DLL_API KaxChapterTimeEnd : public EbmlUInteger {
public:
KaxChapterTimeEnd() {}
KaxChapterTimeEnd(const KaxChapterTimeEnd & ElementToClone) :EbmlUInteger(ElementToClone) {}
static EbmlElement & Create() {return *(new KaxChapterTimeEnd);}
const EbmlCallbacks & Generic() const {return ClassInfos;}
static const EbmlCallbacks ClassInfos;
operator const EbmlId &() const {return ClassInfos.GlobalId;}
EbmlElement * Clone() const {return new KaxChapterTimeEnd(*this);}
};
class MATROSKA_DLL_API KaxChapterFlagHidden : public EbmlUInteger {
public:
KaxChapterFlagHidden(): EbmlUInteger(0) {}
KaxChapterFlagHidden(const KaxChapterFlagHidden & ElementToClone) :EbmlUInteger(ElementToClone) {}
static EbmlElement & Create() {return *(new KaxChapterFlagHidden);}
const EbmlCallbacks & Generic() const {return ClassInfos;}
static const EbmlCallbacks ClassInfos;
operator const EbmlId &() const {return ClassInfos.GlobalId;}
EbmlElement * Clone() const {return new KaxChapterFlagHidden(*this);}
};
class MATROSKA_DLL_API KaxChapterFlagEnabled : public EbmlUInteger {
public:
KaxChapterFlagEnabled(): EbmlUInteger(1) {}
KaxChapterFlagEnabled(const KaxChapterFlagEnabled & ElementToClone) :EbmlUInteger(ElementToClone) {}
static EbmlElement & Create() {return *(new KaxChapterFlagEnabled);}
const EbmlCallbacks & Generic() const {return ClassInfos;}
static const EbmlCallbacks ClassInfos;
operator const EbmlId &() const {return ClassInfos.GlobalId;}
EbmlElement * Clone() const {return new KaxChapterFlagEnabled(*this);}
};
class MATROSKA_DLL_API KaxChapterSegmentUID : public EbmlBinary {
public:
KaxChapterSegmentUID() {}
KaxChapterSegmentUID(const KaxChapterSegmentUID & ElementToClone) :EbmlBinary(ElementToClone) {}
static EbmlElement & Create() {return *(new KaxChapterSegmentUID);}
const EbmlCallbacks & Generic() const {return ClassInfos;}
static const EbmlCallbacks ClassInfos;
operator const EbmlId &() const {return ClassInfos.GlobalId;}
EbmlElement * Clone() const {return new KaxChapterSegmentUID(*this);}
bool ValidateSize() const { return (Size == 16);}
};
class MATROSKA_DLL_API KaxChapterSegmentEditionUID : public EbmlBinary {
public:
KaxChapterSegmentEditionUID() {}
KaxChapterSegmentEditionUID(const KaxChapterSegmentEditionUID & ElementToClone) :EbmlBinary(ElementToClone) {}
static EbmlElement & Create() {return *(new KaxChapterSegmentEditionUID);}
const EbmlCallbacks & Generic() const {return ClassInfos;}
static const EbmlCallbacks ClassInfos;
operator const EbmlId &() const {return ClassInfos.GlobalId;}
EbmlElement * Clone() const {return new KaxChapterSegmentEditionUID(*this);}
bool ValidateSize() const { return (Size == 16);}
};
class MATROSKA_DLL_API KaxChapterPhysicalEquiv : public EbmlUInteger {
public:
KaxChapterPhysicalEquiv(): EbmlUInteger() {}
KaxChapterPhysicalEquiv(const KaxChapterPhysicalEquiv & ElementToClone) :EbmlUInteger(ElementToClone) {}
static EbmlElement & Create() {return *(new KaxChapterPhysicalEquiv);}
const EbmlCallbacks & Generic() const {return ClassInfos;}
static const EbmlCallbacks ClassInfos;
operator const EbmlId &() const {return ClassInfos.GlobalId;}
EbmlElement * Clone() const {return new KaxChapterPhysicalEquiv(*this);}
};
class MATROSKA_DLL_API KaxChapterTrack : public EbmlMaster {
public:
KaxChapterTrack();
KaxChapterTrack(const KaxChapterTrack & ElementToClone) :EbmlMaster(ElementToClone) {}
static EbmlElement & Create() {return *(new KaxChapterTrack);}
const EbmlCallbacks & Generic() const {return ClassInfos;}
static const EbmlCallbacks ClassInfos;
operator const EbmlId &() const {return ClassInfos.GlobalId;}
EbmlElement * Clone() const {return new KaxChapterTrack(*this);}
};
class MATROSKA_DLL_API KaxChapterTrackNumber : public EbmlUInteger {
public:
KaxChapterTrackNumber() {}
KaxChapterTrackNumber(const KaxChapterTrackNumber & ElementToClone) :EbmlUInteger(ElementToClone) {}
static EbmlElement & Create() {return *(new KaxChapterTrackNumber);}
const EbmlCallbacks & Generic() const {return ClassInfos;}
static const EbmlCallbacks ClassInfos;
operator const EbmlId &() const {return ClassInfos.GlobalId;}
EbmlElement * Clone() const {return new KaxChapterTrackNumber(*this);}
};
class MATROSKA_DLL_API KaxChapterDisplay : public EbmlMaster {
public:
KaxChapterDisplay();
KaxChapterDisplay(const KaxChapterDisplay & ElementToClone) :EbmlMaster(ElementToClone) {}
static EbmlElement & Create() {return *(new KaxChapterDisplay);}
const EbmlCallbacks & Generic() const {return ClassInfos;}
static const EbmlCallbacks ClassInfos;
operator const EbmlId &() const {return ClassInfos.GlobalId;}
EbmlElement * Clone() const {return new KaxChapterDisplay(*this);}
};
class MATROSKA_DLL_API KaxChapterString : public EbmlUnicodeString {
public:
KaxChapterString() {}
KaxChapterString(const KaxChapterString & ElementToClone) :EbmlUnicodeString(ElementToClone) {}
static EbmlElement & Create() {return *(new KaxChapterString);}
const EbmlCallbacks & Generic() const {return ClassInfos;}
static const EbmlCallbacks ClassInfos;
operator const EbmlId &() const {return ClassInfos.GlobalId;}
EbmlElement * Clone() const {return new KaxChapterString(*this);}
};
class MATROSKA_DLL_API KaxChapterLanguage : public EbmlString {
public:
KaxChapterLanguage() :EbmlString("eng") {}
KaxChapterLanguage(const KaxChapterLanguage & ElementToClone) :EbmlString(ElementToClone) {}
static EbmlElement & Create() {return *(new KaxChapterLanguage);}
const EbmlCallbacks & Generic() const {return ClassInfos;}
static const EbmlCallbacks ClassInfos;
operator const EbmlId &() const {return ClassInfos.GlobalId;}
EbmlElement * Clone() const {return new KaxChapterLanguage(*this);}
};
class MATROSKA_DLL_API KaxChapterCountry : public EbmlString {
public:
KaxChapterCountry() :EbmlString() {}
KaxChapterCountry(const KaxChapterCountry & ElementToClone) :EbmlString(ElementToClone) {}
static EbmlElement & Create() {return *(new KaxChapterCountry);}
const EbmlCallbacks & Generic() const {return ClassInfos;}
static const EbmlCallbacks ClassInfos;
operator const EbmlId &() const {return ClassInfos.GlobalId;}
EbmlElement * Clone() const {return new KaxChapterCountry(*this);}
};
class MATROSKA_DLL_API KaxChapterProcess : public EbmlMaster {
public:
KaxChapterProcess();
KaxChapterProcess(const KaxChapterProcess & ElementToClone) :EbmlMaster(ElementToClone) {}
static EbmlElement & Create() {return *(new KaxChapterProcess);}
const EbmlCallbacks & Generic() const {return ClassInfos;}
static const EbmlCallbacks ClassInfos;
operator const EbmlId &() const {return ClassInfos.GlobalId;}
EbmlElement * Clone() const {return new KaxChapterProcess(*this);}
};
class MATROSKA_DLL_API KaxChapterProcessCodecID : public EbmlUInteger {
public:
KaxChapterProcessCodecID() :EbmlUInteger(0) {}
KaxChapterProcessCodecID(const KaxChapterProcessCodecID & ElementToClone) :EbmlUInteger(ElementToClone) {}
static EbmlElement & Create() {return *(new KaxChapterProcessCodecID);}
const EbmlCallbacks & Generic() const {return ClassInfos;}
static const EbmlCallbacks ClassInfos;
operator const EbmlId &() const {return ClassInfos.GlobalId;}
EbmlElement * Clone() const {return new KaxChapterProcessCodecID(*this);}
};
class MATROSKA_DLL_API KaxChapterProcessPrivate : public EbmlBinary {
public:
KaxChapterProcessPrivate() {}
KaxChapterProcessPrivate(const KaxChapterProcessPrivate & ElementToClone) :EbmlBinary(ElementToClone) {}
static EbmlElement & Create() {return *(new KaxChapterProcessPrivate);}
const EbmlCallbacks & Generic() const {return ClassInfos;}
static const EbmlCallbacks ClassInfos;
operator const EbmlId &() const {return ClassInfos.GlobalId;}
EbmlElement * Clone() const {return new KaxChapterProcessPrivate(*this);}
bool ValidateSize() const {return true;}
};
class MATROSKA_DLL_API KaxChapterProcessCommand : public EbmlMaster {
public:
KaxChapterProcessCommand();
KaxChapterProcessCommand(const KaxChapterProcessCommand & ElementToClone) :EbmlMaster(ElementToClone) {}
static EbmlElement & Create() {return *(new KaxChapterProcessCommand);}
const EbmlCallbacks & Generic() const {return ClassInfos;}
static const EbmlCallbacks ClassInfos;
operator const EbmlId &() const {return ClassInfos.GlobalId;}
EbmlElement * Clone() const {return new KaxChapterProcessCommand(*this);}
};
class MATROSKA_DLL_API KaxChapterProcessTime : public EbmlUInteger {
public:
KaxChapterProcessTime() {}
KaxChapterProcessTime(const KaxChapterProcessTime & ElementToClone) :EbmlUInteger(ElementToClone) {}
static EbmlElement & Create() {return *(new KaxChapterProcessTime);}
const EbmlCallbacks & Generic() const {return ClassInfos;}
static const EbmlCallbacks ClassInfos;
operator const EbmlId &() const {return ClassInfos.GlobalId;}
EbmlElement * Clone() const {return new KaxChapterProcessTime(*this);}
};
class MATROSKA_DLL_API KaxChapterProcessData : public EbmlBinary {
public:
KaxChapterProcessData() {}
KaxChapterProcessData(const KaxChapterProcessData & ElementToClone) :EbmlBinary(ElementToClone) {}
static EbmlElement & Create() {return *(new KaxChapterProcessData);}
const EbmlCallbacks & Generic() const {return ClassInfos;}
static const EbmlCallbacks ClassInfos;
operator const EbmlId &() const {return ClassInfos.GlobalId;}
EbmlElement * Clone() const {return new KaxChapterProcessData(*this);}
bool ValidateSize() const {return true;}
};
END_LIBMATROSKA_NAMESPACE
#endif // LIBMATROSKA_CHAPTERS_H

168
matroska/KaxCluster.h Normal file
View File

@ -0,0 +1,168 @@
/****************************************************************************
** libmatroska : parse Matroska files, see http://www.matroska.org/
**
** <file/class description>
**
** Copyright (C) 2002-2004 Steve Lhomme. All rights reserved.
**
** This library is free software; you can redistribute it and/or
** modify it under the terms of the GNU Lesser General Public
** License as published by the Free Software Foundation; either
** version 2.1 of the License, or (at your option) any later version.
**
** This library is distributed in the hope that it will be useful,
** but WITHOUT ANY WARRANTY; without even the implied warranty of
** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
** Lesser General Public License for more details.
**
** You should have received a copy of the GNU Lesser General Public
** License along with this library; if not, write to the Free Software
** Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
**
** See http://www.matroska.org/license/lgpl/ for LGPL licensing information.**
** Contact license@matroska.org if any conditions of this licensing are
** not clear to you.
**
**********************************************************************/
/*!
\file
\version \$Id: KaxCluster.h,v 1.10 2004/04/14 23:26:17 robux4 Exp $
\author Steve Lhomme <robux4 @ users.sf.net>
\author Julien Coloos <suiryc @ users.sf.net>
*/
#ifndef LIBMATROSKA_CLUSTER_H
#define LIBMATROSKA_CLUSTER_H
#include "matroska/KaxTypes.h"
#include "ebml/EbmlMaster.h"
#include "matroska/KaxTracks.h"
#include "matroska/KaxBlock.h"
#include "matroska/KaxCues.h"
#include "matroska/KaxClusterData.h"
using namespace LIBEBML_NAMESPACE;
START_LIBMATROSKA_NAMESPACE
class KaxSegment;
class MATROSKA_DLL_API KaxCluster : public EbmlMaster {
public:
KaxCluster();
KaxCluster(const KaxCluster & ElementToClone);
static EbmlElement & Create() {return *(new KaxCluster);}
const EbmlCallbacks & Generic() const {return ClassInfos;}
static const EbmlCallbacks ClassInfos;
operator const EbmlId &() const {return ClassInfos.GlobalId;}
EbmlElement * Clone() const {return new KaxCluster(*this);}
/*!
\brief Addition of a frame without references
\param the timecode is expressed in nanoseconds, relative to the beggining of the Segment
*/
bool AddFrame(const KaxTrackEntry & track, uint64 timecode, DataBuffer & buffer, KaxBlockGroup * & MyNewBlock, LacingType lacing = LACING_AUTO);
/*!
\brief Addition of a frame with a backward reference (P frame)
\param the timecode is expressed in nanoseconds, relative to the beggining of the Segment
*/
bool AddFrame(const KaxTrackEntry & track, uint64 timecode, DataBuffer & buffer, KaxBlockGroup * & MyNewBlock, const KaxBlockGroup & PastBlock, LacingType lacing = LACING_AUTO);
/*!
\brief Addition of a frame with a backward+forward reference (B frame)
\param the timecode is expressed in nanoseconds, relative to the beggining of the Segment
*/
bool AddFrame(const KaxTrackEntry & track, uint64 timecode, DataBuffer & buffer, KaxBlockGroup * & MyNewBlock, const KaxBlockGroup & PastBlock, const KaxBlockGroup & ForwBlock, LacingType lacing = LACING_AUTO);
/*!
\brief Render the data to the stream and retrieve the position of BlockGroups for later cue entries
*/
uint32 Render(IOCallback & output, KaxCues & CueToUpdate, bool bSaveDefault = false);
/*!
\return the global timecode of this Cluster
*/
uint64 GlobalTimecode() const;
KaxBlockGroup & GetNewBlock();
/*!
\brief release all the frames of all Blocks
\note this is a convenience to be able to keep Clusters+Blocks in memory (for future reference) withouht being a memory hog
*/
void ReleaseFrames();
/*!
\brief return the position offset compared to the beggining of the Segment
*/
uint64 GetPosition() const;
void SetParent(const KaxSegment & aParentSegment) {ParentSegment = &aParentSegment;}
void SetPreviousTimecode(uint64 aPreviousTimecode, int64 aTimecodeScale) {
bPreviousTimecodeIsSet = true;
PreviousTimecode = aPreviousTimecode;
SetGlobalTimecodeScale(aTimecodeScale);
}
/*!
\note dirty hack to get the mandatory data back after reading
\todo there should be a better way to get mandatory data
*/
void InitTimecode(uint64 aTimecode, int64 aTimecodeScale) {
SetGlobalTimecodeScale(aTimecodeScale);
MinTimecode = MaxTimecode = PreviousTimecode = aTimecode * TimecodeScale;
bFirstFrameInside = bPreviousTimecodeIsSet = true;
}
int16 GetBlockLocalTimecode(uint64 GlobalTimecode) const;
uint64 GetBlockGlobalTimecode(int16 LocalTimecode);
void SetGlobalTimecodeScale(uint64 aGlobalTimecodeScale) {
TimecodeScale = aGlobalTimecodeScale;
bTimecodeScaleIsSet = true;
}
uint64 GlobalTimecodeScale() const {
assert(bTimecodeScaleIsSet);
return TimecodeScale;
}
bool SetSilentTrackUsed()
{
bSilentTracksUsed = true;
return FindFirstElt(KaxClusterSilentTracks::ClassInfos, true) != NULL;
}
bool AddBlockBlob(KaxBlockBlob * NewBlob);
const KaxSegment *GetParentSegment() const { return ParentSegment; }
protected:
KaxBlockBlob * currentNewBlob;
std::vector<KaxBlockBlob*> Blobs;
KaxBlockGroup * currentNewBlock;
const KaxSegment * ParentSegment;
uint64 MinTimecode, MaxTimecode, PreviousTimecode;
int64 TimecodeScale;
bool bFirstFrameInside; // used to speed research
bool bPreviousTimecodeIsSet;
bool bTimecodeScaleIsSet;
bool bSilentTracksUsed;
/*!
\note method used internally
*/
bool AddFrameInternal(const KaxTrackEntry & track, uint64 timecode, DataBuffer & buffer, KaxBlockGroup * & MyNewBlock, const KaxBlockGroup * PastBlock, const KaxBlockGroup * ForwBlock, LacingType lacing);
};
END_LIBMATROSKA_NAMESPACE
#endif // LIBMATROSKA_CLUSTER_H

103
matroska/KaxClusterData.h Normal file
View File

@ -0,0 +1,103 @@
/****************************************************************************
** libmatroska : parse Matroska files, see http://www.matroska.org/
**
** <file/class MATROSKA_DLL_API description>
**
** Copyright (C) 2002-2004 Steve Lhomme. All rights reserved.
**
** This file is part of libmatroska.
**
** This library is free software; you can redistribute it and/or
** modify it under the terms of the GNU Lesser General Public
** License as published by the Free Software Foundation; either
** version 2.1 of the License, or (at your option) any later version.
**
** This library is distributed in the hope that it will be useful,
** but WITHOUT ANY WARRANTY; without even the implied warranty of
** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
** Lesser General Public License for more details.
**
** You should have received a copy of the GNU Lesser General Public
** License along with this library; if not, write to the Free Software
** Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
**
** See http://www.matroska.org/license/lgpl/ for LGPL licensing information.**
** Contact license@matroska.org if any conditions of this licensing are
** not clear to you.
**
**********************************************************************/
/*!
\file
\version \$Id: KaxClusterData.h,v 1.9 2004/04/21 19:50:10 mosu Exp $
\author Steve Lhomme <robux4 @ users.sf.net>
*/
#ifndef LIBMATROSKA_CLUSTER_DATA_H
#define LIBMATROSKA_CLUSTER_DATA_H
#include "matroska/KaxTypes.h"
#include "ebml/EbmlMaster.h"
#include "ebml/EbmlUInteger.h"
using namespace LIBEBML_NAMESPACE;
START_LIBMATROSKA_NAMESPACE
class MATROSKA_DLL_API KaxClusterTimecode : public EbmlUInteger {
public:
KaxClusterTimecode() {}
KaxClusterTimecode(const KaxClusterTimecode & ElementToClone) :EbmlUInteger(ElementToClone) {}
static EbmlElement & Create() {return *(new KaxClusterTimecode);}
const EbmlCallbacks & Generic() const {return ClassInfos;}
static const EbmlCallbacks ClassInfos;
operator const EbmlId &() const {return ClassInfos.GlobalId;}
EbmlElement * Clone() const {return new KaxClusterTimecode(*this);}
};
class MATROSKA_DLL_API KaxClusterSilentTracks : public EbmlMaster {
public:
KaxClusterSilentTracks();
KaxClusterSilentTracks(const KaxClusterSilentTracks & ElementToClone) :EbmlMaster(ElementToClone) {}
static EbmlElement & Create() {return *(new KaxClusterSilentTracks);}
const EbmlCallbacks & Generic() const {return ClassInfos;}
static const EbmlCallbacks ClassInfos;
operator const EbmlId &() const {return ClassInfos.GlobalId;}
EbmlElement * Clone() const {return new KaxClusterSilentTracks(*this);}
};
class MATROSKA_DLL_API KaxClusterSilentTrackNumber : public EbmlUInteger {
public:
KaxClusterSilentTrackNumber() {}
KaxClusterSilentTrackNumber(const KaxClusterSilentTrackNumber & ElementToClone) :EbmlUInteger(ElementToClone) {}
static EbmlElement & Create() {return *(new KaxClusterSilentTrackNumber);}
const EbmlCallbacks & Generic() const {return ClassInfos;}
static const EbmlCallbacks ClassInfos;
operator const EbmlId &() const {return ClassInfos.GlobalId;}
EbmlElement * Clone() const {return new KaxClusterSilentTrackNumber(*this);}
};
class MATROSKA_DLL_API KaxClusterPosition : public EbmlUInteger {
public:
KaxClusterPosition() {}
KaxClusterPosition(const KaxClusterPosition & ElementToClone) :EbmlUInteger(ElementToClone) {}
static EbmlElement & Create() {return *(new KaxClusterPosition);}
const EbmlCallbacks & Generic() const {return ClassInfos;}
static const EbmlCallbacks ClassInfos;
operator const EbmlId &() const {return ClassInfos.GlobalId;}
EbmlElement * Clone() const {return new KaxClusterPosition(*this);}
};
class MATROSKA_DLL_API KaxClusterPrevSize : public EbmlUInteger {
public:
KaxClusterPrevSize() {}
KaxClusterPrevSize(const KaxClusterPrevSize & ElementToClone) :EbmlUInteger(ElementToClone) {}
static EbmlElement & Create() {return *(new KaxClusterPrevSize);}
const EbmlCallbacks & Generic() const {return ClassInfos;}
static const EbmlCallbacks ClassInfos;
operator const EbmlId &() const {return ClassInfos.GlobalId;}
EbmlElement * Clone() const {return new KaxClusterPrevSize(*this);}
};
END_LIBMATROSKA_NAMESPACE
#endif // LIBMATROSKA_CLUSTER_DATA_H

70
matroska/KaxConfig.h Normal file
View File

@ -0,0 +1,70 @@
/****************************************************************************
** libmatroska : parse Matroska files, see http://www.matroska.org/
**
** <file/class description>
**
** Copyright (C) 2002-2005 Steve Lhomme. All rights reserved.
**
** This library is free software; you can redistribute it and/or
** modify it under the terms of the GNU Lesser General Public
** License as published by the Free Software Foundation; either
** version 2.1 of the License, or (at your option) any later version.
**
** This library is distributed in the hope that it will be useful,
** but WITHOUT ANY WARRANTY; without even the implied warranty of
** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
** Lesser General Public License for more details.
**
** You should have received a copy of the GNU Lesser General Public
** License along with this library; if not, write to the Free Software
** Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
**
** See http://www.matroska.org/license/lgpl/ for LGPL licensing information.**
** Contact license@matroska.org if any conditions of this licensing are
** not clear to you.
**
**********************************************************************/
/*!
\file
\version \$Id: KaxConfig.h,v 1.7 2004/04/14 23:26:17 robux4 Exp $
\author Steve Lhomme <robux4 @ users.sf.net>
\author Moritz Bunkus <moritz @ bunkus.org>
*/
#ifndef LIBMATROSKA_CONFIG_H
#define LIBMATROSKA_CONFIG_H
#define LIBMATROSKA_NAMESPACE libmatroska
#if defined(NO_NAMESPACE) // for older GCC
# define START_LIBMATROSKA_NAMESPACE
# define END_LIBMATROSKA_NAMESPACE
#else // NO_NAMESPACE
# define START_LIBMATROSKA_NAMESPACE namespace LIBMATROSKA_NAMESPACE {
# define END_LIBMATROSKA_NAMESPACE };
#endif // NO_NAMESPACE
// There are special implementations for certain platforms. For example on Windows
// we use the Win32 file API. here we set the appropriate macros.
#if defined(_WIN32)||defined(WIN32)
# if defined(MATROSKA_DLL)
# if defined(MATROSKA_DLL_EXPORT)
# define MATROSKA_DLL_API __declspec(dllexport)
# else // MATROSKA_DLL_EXPORT
# define MATROSKA_DLL_API __declspec(dllimport)
# endif // MATROSKA_DLL_EXPORT
# else // MATROSKA_DLL
# define MATROSKA_DLL_API
# endif // MATROSKA_DLL
#else
# define MATROSKA_DLL_API
#endif
#if !defined(MATROSKA_VERSION)
#define MATROSKA_VERSION 2
#endif // MATROSKA_VERSION
#endif // LIBMATROSKA_CONFIG_H

View File

@ -0,0 +1,250 @@
/****************************************************************************
** libmatroska : parse Matroska files, see http://www.matroska.org/
**
** <file/class description>
**
** Copyright (C) 2002-2004 Steve Lhomme. All rights reserved.
**
** This file is part of libmatroska.
**
** This library is free software; you can redistribute it and/or
** modify it under the terms of the GNU Lesser General Public
** License as published by the Free Software Foundation; either
** version 2.1 of the License, or (at your option) any later version.
**
** This library is distributed in the hope that it will be useful,
** but WITHOUT ANY WARRANTY; without even the implied warranty of
** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
** Lesser General Public License for more details.
**
** You should have received a copy of the GNU Lesser General Public
** License along with this library; if not, write to the Free Software
** Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
**
** See http://www.matroska.org/license/lgpl/ for LGPL licensing information.**
** Contact license@matroska.org if any conditions of this licensing are
** not clear to you.
**
**********************************************************************/
/*!
\file
\version \$Id: KaxContentEncoding.h,v 1.7 2004/04/14 23:26:17 robux4 Exp $
\author Moritz Bunkus <moritz @ bunkus.org>
*/
#ifndef LIBMATROSKA_CONTENT_ENCODING_H
#define LIBMATROSKA_CONTENT_ENCODING_H
#include "matroska/KaxTypes.h"
#include "ebml/EbmlMaster.h"
#include "ebml/EbmlUInteger.h"
#include "ebml/EbmlBinary.h"
using namespace LIBEBML_NAMESPACE;
START_LIBMATROSKA_NAMESPACE
class MATROSKA_DLL_API KaxContentEncodings: public EbmlMaster {
public:
static const EbmlCallbacks ClassInfos;
KaxContentEncodings();
KaxContentEncodings(const KaxContentEncodings &ElementToClone):
EbmlMaster(ElementToClone) {}
static EbmlElement &Create() { return *(new KaxContentEncodings); }
const EbmlCallbacks &Generic() const { return ClassInfos; }
operator const EbmlId &() const { return ClassInfos.GlobalId; }
EbmlElement *Clone() const { return new KaxContentEncodings(*this); }
};
class MATROSKA_DLL_API KaxContentEncoding: public EbmlMaster {
public:
static const EbmlCallbacks ClassInfos;
KaxContentEncoding();
KaxContentEncoding(const KaxContentEncoding &ElementToClone):
EbmlMaster(ElementToClone) {}
static EbmlElement &Create() { return *(new KaxContentEncoding); }
const EbmlCallbacks &Generic() const { return ClassInfos; }
operator const EbmlId &() const { return ClassInfos.GlobalId; }
EbmlElement *Clone() const { return new KaxContentEncoding(*this); }
};
class MATROSKA_DLL_API KaxContentEncodingOrder: public EbmlUInteger {
public:
static const EbmlCallbacks ClassInfos;
KaxContentEncodingOrder(): EbmlUInteger(0) {}
KaxContentEncodingOrder(const KaxContentEncodingOrder &ElementToClone):
EbmlUInteger(ElementToClone) {}
static EbmlElement &Create() { return *(new KaxContentEncodingOrder); }
const EbmlCallbacks &Generic() const { return ClassInfos; }
operator const EbmlId &() const { return ClassInfos.GlobalId; }
EbmlElement *Clone() const { return new KaxContentEncodingOrder(*this); }
};
class MATROSKA_DLL_API KaxContentEncodingScope: public EbmlUInteger {
public:
static const EbmlCallbacks ClassInfos;
KaxContentEncodingScope(): EbmlUInteger(1) {}
KaxContentEncodingScope(const KaxContentEncodingScope &ElementToClone):
EbmlUInteger(ElementToClone) {}
static EbmlElement &Create() { return *(new KaxContentEncodingScope); }
const EbmlCallbacks &Generic() const { return ClassInfos; }
operator const EbmlId &() const { return ClassInfos.GlobalId; }
EbmlElement *Clone() const { return new KaxContentEncodingScope(*this); }
};
class MATROSKA_DLL_API KaxContentEncodingType: public EbmlUInteger {
public:
static const EbmlCallbacks ClassInfos;
KaxContentEncodingType(): EbmlUInteger(0) {}
KaxContentEncodingType(const KaxContentEncodingType &ElementToClone):
EbmlUInteger(ElementToClone) {}
static EbmlElement &Create() { return *(new KaxContentEncodingType); }
const EbmlCallbacks &Generic() const { return ClassInfos; }
operator const EbmlId &() const { return ClassInfos.GlobalId; }
EbmlElement *Clone() const { return new KaxContentEncodingType(*this); }
};
class MATROSKA_DLL_API KaxContentCompression: public EbmlMaster {
public:
static const EbmlCallbacks ClassInfos;
KaxContentCompression();
KaxContentCompression(const KaxContentCompression &ElementToClone):
EbmlMaster(ElementToClone) {}
static EbmlElement &Create() { return *(new KaxContentCompression); }
const EbmlCallbacks &Generic() const { return ClassInfos; }
operator const EbmlId &() const { return ClassInfos.GlobalId; }
EbmlElement *Clone() const { return new KaxContentCompression(*this); }
};
class MATROSKA_DLL_API KaxContentCompAlgo: public EbmlUInteger {
public:
static const EbmlCallbacks ClassInfos;
KaxContentCompAlgo(): EbmlUInteger(0) {}
KaxContentCompAlgo(const KaxContentCompAlgo &ElementToClone):
EbmlUInteger(ElementToClone) {}
static EbmlElement &Create() { return *(new KaxContentCompAlgo); }
const EbmlCallbacks &Generic() const { return ClassInfos; }
operator const EbmlId &() const { return ClassInfos.GlobalId; }
EbmlElement *Clone() const { return new KaxContentCompAlgo(*this); }
};
class MATROSKA_DLL_API KaxContentCompSettings: public EbmlBinary {
public:
static const EbmlCallbacks ClassInfos;
KaxContentCompSettings() {}
KaxContentCompSettings(const KaxContentCompSettings &ElementToClone):
EbmlBinary(ElementToClone) {}
static EbmlElement &Create() { return *(new KaxContentCompSettings); }
const EbmlCallbacks &Generic() const { return ClassInfos; }
operator const EbmlId &() const { return ClassInfos.GlobalId; }
EbmlElement *Clone() const {
return new KaxContentCompSettings(*this);
}
bool ValidateSize(void) const { return true; }
};
class MATROSKA_DLL_API KaxContentEncryption: public EbmlMaster {
public:
static const EbmlCallbacks ClassInfos;
KaxContentEncryption();
KaxContentEncryption(const KaxContentEncryption &ElementToClone):
EbmlMaster(ElementToClone) {}
static EbmlElement &Create() { return *(new KaxContentEncryption); }
const EbmlCallbacks &Generic() const { return ClassInfos; }
operator const EbmlId &() const { return ClassInfos.GlobalId; }
EbmlElement *Clone() const { return new KaxContentEncryption(*this); }
};
class MATROSKA_DLL_API KaxContentEncAlgo: public EbmlUInteger {
public:
static const EbmlCallbacks ClassInfos;
KaxContentEncAlgo(): EbmlUInteger(0) {}
KaxContentEncAlgo(const KaxContentEncAlgo &ElementToClone):
EbmlUInteger(ElementToClone) {}
static EbmlElement &Create() { return *(new KaxContentEncAlgo); }
const EbmlCallbacks &Generic() const { return ClassInfos; }
operator const EbmlId &() const { return ClassInfos.GlobalId; }
EbmlElement *Clone() const { return new KaxContentEncAlgo(*this); }
};
class MATROSKA_DLL_API KaxContentEncKeyID: public EbmlBinary {
public:
static const EbmlCallbacks ClassInfos;
KaxContentEncKeyID() {}
KaxContentEncKeyID(const KaxContentEncKeyID &ElementToClone):
EbmlBinary(ElementToClone) {}
static EbmlElement &Create() { return *(new KaxContentEncKeyID); }
const EbmlCallbacks &Generic() const { return ClassInfos; }
operator const EbmlId &() const { return ClassInfos.GlobalId; }
EbmlElement *Clone() const { return new KaxContentEncKeyID(*this); }
bool ValidateSize(void) const { return true; }
};
class MATROSKA_DLL_API KaxContentSignature: public EbmlBinary {
public:
static const EbmlCallbacks ClassInfos;
KaxContentSignature() {}
KaxContentSignature(const KaxContentSignature &ElementToClone):
EbmlBinary(ElementToClone) {}
static EbmlElement &Create() { return *(new KaxContentSignature); }
const EbmlCallbacks &Generic() const { return ClassInfos; }
operator const EbmlId &() const { return ClassInfos.GlobalId; }
EbmlElement *Clone() const { return new KaxContentSignature(*this); }
bool ValidateSize(void) const { return true; }
};
class MATROSKA_DLL_API KaxContentSigKeyID: public EbmlBinary {
public:
static const EbmlCallbacks ClassInfos;
KaxContentSigKeyID() {}
KaxContentSigKeyID(const KaxContentSigKeyID &ElementToClone):
EbmlBinary(ElementToClone) {}
static EbmlElement &Create() { return *(new KaxContentSigKeyID); }
const EbmlCallbacks &Generic() const { return ClassInfos; }
operator const EbmlId &() const { return ClassInfos.GlobalId; }
EbmlElement *Clone() const { return new KaxContentSigKeyID(*this); }
bool ValidateSize(void) const { return true; }
};
class MATROSKA_DLL_API KaxContentSigAlgo: public EbmlUInteger {
public:
static const EbmlCallbacks ClassInfos;
KaxContentSigAlgo() {}
KaxContentSigAlgo(const KaxContentSigAlgo &ElementToClone):
EbmlUInteger(ElementToClone) {}
static EbmlElement &Create() { return *(new KaxContentSigAlgo); }
const EbmlCallbacks &Generic() const { return ClassInfos; }
operator const EbmlId &() const { return ClassInfos.GlobalId; }
EbmlElement *Clone() const { return new KaxContentSigAlgo(*this); }
};
class MATROSKA_DLL_API KaxContentSigHashAlgo: public EbmlUInteger {
public:
static const EbmlCallbacks ClassInfos;
KaxContentSigHashAlgo() {}
KaxContentSigHashAlgo(const KaxContentSigHashAlgo &ElementToClone):
EbmlUInteger(ElementToClone) {}
static EbmlElement &Create() { return *(new KaxContentSigHashAlgo); }
const EbmlCallbacks &Generic() const { return ClassInfos; }
operator const EbmlId &() const { return ClassInfos.GlobalId; }
EbmlElement *Clone() const { return new KaxContentSigHashAlgo(*this); }
};
END_LIBMATROSKA_NAMESPACE
#endif // LIBMATROSKA_CONTENT_ENCODING_H

87
matroska/KaxContexts.h Normal file
View File

@ -0,0 +1,87 @@
/****************************************************************************
** libmatroska : parse Matroska files, see http://www.matroska.org/
**
** <file/class description>
**
** Copyright (C) 2002-2004 Steve Lhomme. All rights reserved.
**
** This file is part of libmatroska.
**
** This library is free software; you can redistribute it and/or
** modify it under the terms of the GNU Lesser General Public
** License as published by the Free Software Foundation; either
** version 2.1 of the License, or (at your option) any later version.
**
** This library is distributed in the hope that it will be useful,
** but WITHOUT ANY WARRANTY; without even the implied warranty of
** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
** Lesser General Public License for more details.
**
** You should have received a copy of the GNU Lesser General Public
** License along with this library; if not, write to the Free Software
** Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
**
** See http://www.matroska.org/license/lgpl/ for LGPL licensing information.**
** Contact license@matroska.org if any conditions of this licensing are
** not clear to you.
**
**********************************************************************/
/*!
\file
\version \$Id: KaxContexts.h,v 1.6 2004/04/14 23:26:17 robux4 Exp $
\author Steve Lhomme <robux4 @ users.sf.net>
*/
#ifndef LIBMATROSKA_CONTEXTS_H
#define LIBMATROSKA_CONTEXTS_H
#include "matroska/KaxTypes.h"
#include "ebml/EbmlElement.h"
using namespace LIBEBML_NAMESPACE;
START_LIBMATROSKA_NAMESPACE
extern const EbmlSemanticContext MATROSKA_DLL_API KaxMatroska_Context;
extern const EbmlSemanticContext MATROSKA_DLL_API KaxSegment_Context;
extern const EbmlSemanticContext MATROSKA_DLL_API KaxAttachments_Context;
extern const EbmlSemanticContext MATROSKA_DLL_API KaxAttached_Context;
extern const EbmlSemanticContext MATROSKA_DLL_API KaxFileDescription_Context;
extern const EbmlSemanticContext MATROSKA_DLL_API KaxFileName_Context;
extern const EbmlSemanticContext MATROSKA_DLL_API KaxMimeType_Context;
extern const EbmlSemanticContext MATROSKA_DLL_API KaxFileData_Context;
extern const EbmlSemanticContext MATROSKA_DLL_API KaxChapters_Context;
extern const EbmlSemanticContext MATROSKA_DLL_API KaxCluster_Context;
extern const EbmlSemanticContext MATROSKA_DLL_API KaxTags_Context;
extern const EbmlSemanticContext MATROSKA_DLL_API KaxTag_Context;
extern const EbmlSemanticContext MATROSKA_DLL_API KaxBlockGroup_Context;
extern const EbmlSemanticContext MATROSKA_DLL_API KaxReferencePriority_Context;
extern const EbmlSemanticContext MATROSKA_DLL_API KaxReferenceBlock_Context;
extern const EbmlSemanticContext MATROSKA_DLL_API KaxReferenceVirtual_Context;
extern const EbmlSemanticContext MATROSKA_DLL_API KaxCues_Context;
extern const EbmlSemanticContext MATROSKA_DLL_API KaxInfo_Context;
extern const EbmlSemanticContext MATROSKA_DLL_API KaxSeekHead_Context;
extern const EbmlSemanticContext MATROSKA_DLL_API KaxTracks_Context;
extern const EbmlSemanticContext MATROSKA_DLL_API KaxTrackEntry_Context;
extern const EbmlSemanticContext MATROSKA_DLL_API KaxTrackNumber_Context;
extern const EbmlSemanticContext MATROSKA_DLL_API KaxTrackType_Context;
extern const EbmlSemanticContext MATROSKA_DLL_API KaxTrackFlagEnabled_Context;
extern const EbmlSemanticContext MATROSKA_DLL_API KaxTrackFlagDefault_Context;
extern const EbmlSemanticContext MATROSKA_DLL_API KaxTrackFlagLacing_Context;
extern const EbmlSemanticContext MATROSKA_DLL_API KaxTrackName_Context;
extern const EbmlSemanticContext MATROSKA_DLL_API KaxTrackLanguage_Context;
extern const EbmlSemanticContext MATROSKA_DLL_API KaxCodecID_Context;
extern const EbmlSemanticContext MATROSKA_DLL_API KaxCodecPrivate_Context;
extern const EbmlSemanticContext MATROSKA_DLL_API KaxCodecName_Context;
extern const EbmlSemanticContext MATROSKA_DLL_API KaxCodecSettings_Context;
extern const EbmlSemanticContext MATROSKA_DLL_API KaxCodecInfoURL_Context;
extern const EbmlSemanticContext MATROSKA_DLL_API KaxCodecDownloadURL_Context;
extern const EbmlSemanticContext MATROSKA_DLL_API KaxCodecDecodeAll_Context;
extern const EbmlSemanticContext MATROSKA_DLL_API KaxTrackOverlay_Context;
extern const EbmlSemanticContext & MATROSKA_DLL_API GetKaxGlobal_Context();
extern const EbmlSemanticContext & MATROSKA_DLL_API GetKaxTagsGlobal_Context();
END_LIBMATROSKA_NAMESPACE
#endif // LIBMATROSKA_CONTEXTS_H

98
matroska/KaxCues.h Normal file
View File

@ -0,0 +1,98 @@
/****************************************************************************
** libmatroska : parse Matroska files, see http://www.matroska.org/
**
** <file/class description>
**
** Copyright (C) 2002-2004 Steve Lhomme. All rights reserved.
**
** This file is part of libmatroska.
**
** This library is free software; you can redistribute it and/or
** modify it under the terms of the GNU Lesser General Public
** License as published by the Free Software Foundation; either
** version 2.1 of the License, or (at your option) any later version.
**
** This library is distributed in the hope that it will be useful,
** but WITHOUT ANY WARRANTY; without even the implied warranty of
** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
** Lesser General Public License for more details.
**
** You should have received a copy of the GNU Lesser General Public
** License along with this library; if not, write to the Free Software
** Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
**
** See http://www.matroska.org/license/lgpl/ for LGPL licensing information.**
** Contact license@matroska.org if any conditions of this licensing are
** not clear to you.
**
**********************************************************************/
/*!
\file
\version \$Id: KaxCues.h,v 1.7 2004/04/14 23:26:17 robux4 Exp $
\author Steve Lhomme <robux4 @ users.sf.net>
*/
#ifndef LIBMATROSKA_CUES_H
#define LIBMATROSKA_CUES_H
#include <vector>
#include "matroska/KaxTypes.h"
#include "ebml/EbmlMaster.h"
#include "matroska/KaxBlock.h"
using namespace LIBEBML_NAMESPACE;
START_LIBMATROSKA_NAMESPACE
class KaxCuePoint;
class MATROSKA_DLL_API KaxCues : public EbmlMaster {
public:
KaxCues();
KaxCues(const KaxCues & ElementToClone) :EbmlMaster(ElementToClone) {}
~KaxCues();
static EbmlElement & Create() {return *(new KaxCues);}
const EbmlCallbacks & Generic() const {return ClassInfos;}
static const EbmlCallbacks ClassInfos;
operator const EbmlId &() const {return ClassInfos.GlobalId;}
EbmlElement * Clone() const {return new KaxCues(*this);}
bool AddBlockGroup(const KaxBlockGroup & BlockReference);
bool AddBlockBlob(const KaxBlockBlob & BlockReference);
/*!
\brief Indicate that the position for this Block is set
*/
void PositionSet(const KaxBlockGroup & BlockReference);
void PositionSet(const KaxBlockBlob & BlockReference);
/*!
\brief override to sort by timecode/track
*/
uint32 Render(IOCallback & output, bool bSaveDefault = false) {
Sort();
return EbmlMaster::Render(output, bSaveDefault);
}
uint64 GetTimecodePosition(uint64 aTimecode) const;
const KaxCuePoint * GetTimecodePoint(uint64 aTimecode) const;
void SetGlobalTimecodeScale(uint64 aGlobalTimecodeScale) {
mGlobalTimecodeScale = aGlobalTimecodeScale;
bGlobalTimecodeScaleIsSet = true;
}
uint64 GlobalTimecodeScale() const {
assert(bGlobalTimecodeScaleIsSet);
return mGlobalTimecodeScale;
}
protected:
std::vector<const KaxBlockBlob *> myTempReferences;
bool bGlobalTimecodeScaleIsSet;
uint64 mGlobalTimecodeScale;
};
END_LIBMATROSKA_NAMESPACE
#endif // LIBMATROSKA_CUES_H

198
matroska/KaxCuesData.h Normal file
View File

@ -0,0 +1,198 @@
/****************************************************************************
** libmatroska : parse Matroska files, see http://www.matroska.org/
**
** <file/class description>
**
** Copyright (C) 2002-2005 Steve Lhomme. All rights reserved.
**
** This library is free software; you can redistribute it and/or
** modify it under the terms of the GNU Lesser General Public
** License as published by the Free Software Foundation; either
** version 2.1 of the License, or (at your option) any later version.
**
** This library is distributed in the hope that it will be useful,
** but WITHOUT ANY WARRANTY; without even the implied warranty of
** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
** Lesser General Public License for more details.
**
** You should have received a copy of the GNU Lesser General Public
** License along with this library; if not, write to the Free Software
** Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
**
** See http://www.matroska.org/license/lgpl/ for LGPL licensing information.**
** Contact license@matroska.org if any conditions of this licensing are
** not clear to you.
**
**********************************************************************/
/*!
\file
\version \$Id: KaxCuesData.h,v 1.8 2004/04/14 23:26:17 robux4 Exp $
\author Steve Lhomme <robux4 @ users.sf.net>
*/
#ifndef LIBMATROSKA_CUES_DATA_H
#define LIBMATROSKA_CUES_DATA_H
#include "matroska/KaxTypes.h"
#include "ebml/EbmlUInteger.h"
#include "ebml/EbmlMaster.h"
using namespace LIBEBML_NAMESPACE;
START_LIBMATROSKA_NAMESPACE
class KaxBlockGroup;
class KaxBlockBlob;
class KaxCueTrackPositions;
class KaxInternalBlock;
class MATROSKA_DLL_API KaxCuePoint : public EbmlMaster {
public:
KaxCuePoint();
KaxCuePoint(const KaxCuePoint & ElementToClone) :EbmlMaster(ElementToClone) {}
static EbmlElement & Create() {return *(new KaxCuePoint);}
const EbmlCallbacks & Generic() const {return ClassInfos;}
static const EbmlCallbacks ClassInfos;
operator const EbmlId &() const {return ClassInfos.GlobalId;}
EbmlElement * Clone() const {return new KaxCuePoint(*this);}
void PositionSet(const KaxBlockGroup & BlockReference, uint64 GlobalTimecodeScale);
void PositionSet(const KaxBlockBlob & BlobReference, uint64 GlobalTimecodeScale);
bool operator<(const EbmlElement & EltB) const;
const KaxCueTrackPositions * GetSeekPosition() const;
bool Timecode(uint64 & aTimecode, uint64 GlobalTimecodeScale) const;
};
class MATROSKA_DLL_API KaxCueTime : public EbmlUInteger {
public:
KaxCueTime() {}
KaxCueTime(const KaxCueTime & ElementToClone) :EbmlUInteger(ElementToClone) {}
static EbmlElement & Create() {return *(new KaxCueTime);}
const EbmlCallbacks & Generic() const {return ClassInfos;}
static const EbmlCallbacks ClassInfos;
operator const EbmlId &() const {return ClassInfos.GlobalId;}
EbmlElement * Clone() const {return new KaxCueTime(*this);}
};
class MATROSKA_DLL_API KaxCueTrackPositions : public EbmlMaster {
public:
KaxCueTrackPositions();
KaxCueTrackPositions(const KaxCueTrackPositions & ElementToClone) :EbmlMaster(ElementToClone) {}
static EbmlElement & Create() {return *(new KaxCueTrackPositions);}
const EbmlCallbacks & Generic() const {return ClassInfos;}
static const EbmlCallbacks ClassInfos;
operator const EbmlId &() const {return ClassInfos.GlobalId;}
EbmlElement * Clone() const {return new KaxCueTrackPositions(*this);}
uint64 ClusterPosition() const;
uint16 TrackNumber() const;
};
class MATROSKA_DLL_API KaxCueTrack : public EbmlUInteger {
public:
KaxCueTrack() {}
KaxCueTrack(const KaxCueTrack & ElementToClone) :EbmlUInteger(ElementToClone) {}
static EbmlElement & Create() {return *(new KaxCueTrack);}
const EbmlCallbacks & Generic() const {return ClassInfos;}
static const EbmlCallbacks ClassInfos;
operator const EbmlId &() const {return ClassInfos.GlobalId;}
EbmlElement * Clone() const {return new KaxCueTrack(*this);}
};
class MATROSKA_DLL_API KaxCueClusterPosition : public EbmlUInteger {
public:
KaxCueClusterPosition() {}
KaxCueClusterPosition(const KaxCueClusterPosition & ElementToClone) :EbmlUInteger(ElementToClone) {}
static EbmlElement & Create() {return *(new KaxCueClusterPosition);}
const EbmlCallbacks & Generic() const {return ClassInfos;}
static const EbmlCallbacks ClassInfos;
operator const EbmlId &() const {return ClassInfos.GlobalId;}
EbmlElement * Clone() const {return new KaxCueClusterPosition(*this);}
};
class MATROSKA_DLL_API KaxCueBlockNumber : public EbmlUInteger {
public:
KaxCueBlockNumber() :EbmlUInteger(1) {}
KaxCueBlockNumber(const KaxCueBlockNumber & ElementToClone) :EbmlUInteger(ElementToClone) {}
static EbmlElement & Create() {return *(new KaxCueBlockNumber);}
const EbmlCallbacks & Generic() const {return ClassInfos;}
static const EbmlCallbacks ClassInfos;
operator const EbmlId &() const {return ClassInfos.GlobalId;}
EbmlElement * Clone() const {return new KaxCueBlockNumber(*this);}
};
#if MATROSKA_VERSION >= 2
class MATROSKA_DLL_API KaxCueCodecState : public EbmlUInteger {
public:
KaxCueCodecState() :EbmlUInteger(0) {}
KaxCueCodecState(const KaxCueCodecState & ElementToClone) :EbmlUInteger(ElementToClone) {}
static EbmlElement & Create() {return *(new KaxCueCodecState);}
const EbmlCallbacks & Generic() const {return ClassInfos;}
static const EbmlCallbacks ClassInfos;
operator const EbmlId &() const {return ClassInfos.GlobalId;}
EbmlElement * Clone() const {return new KaxCueCodecState(*this);}
};
class MATROSKA_DLL_API KaxCueReference : public EbmlMaster {
public:
KaxCueReference();
KaxCueReference(const KaxCueReference & ElementToClone) :EbmlMaster(ElementToClone) {}
static EbmlElement & Create() {return *(new KaxCueReference);}
const EbmlCallbacks & Generic() const {return ClassInfos;}
static const EbmlCallbacks ClassInfos;
operator const EbmlId &() const {return ClassInfos.GlobalId;}
EbmlElement * Clone() const {return new KaxCueReference(*this);}
void AddReference(const KaxBlockGroup & BlockReferenced, uint64 GlobalTimecodeScale);
void AddReference(const KaxBlockBlob & BlockReferenced, uint64 GlobalTimecodeScale);
};
class MATROSKA_DLL_API KaxCueRefTime : public EbmlUInteger {
public:
KaxCueRefTime() {}
KaxCueRefTime(const KaxCueRefTime & ElementToClone) :EbmlUInteger(ElementToClone) {}
static EbmlElement & Create() {return *(new KaxCueRefTime);}
const EbmlCallbacks & Generic() const {return ClassInfos;}
static const EbmlCallbacks ClassInfos;
operator const EbmlId &() const {return ClassInfos.GlobalId;}
EbmlElement * Clone() const {return new KaxCueRefTime(*this);}
};
class MATROSKA_DLL_API KaxCueRefCluster : public EbmlUInteger {
public:
KaxCueRefCluster() {}
KaxCueRefCluster(const KaxCueRefCluster & ElementToClone) :EbmlUInteger(ElementToClone) {}
static EbmlElement & Create() {return *(new KaxCueRefCluster);}
const EbmlCallbacks & Generic() const {return ClassInfos;}
static const EbmlCallbacks ClassInfos;
operator const EbmlId &() const {return ClassInfos.GlobalId;}
EbmlElement * Clone() const {return new KaxCueRefCluster(*this);}
};
class MATROSKA_DLL_API KaxCueRefNumber : public EbmlUInteger {
public:
KaxCueRefNumber() :EbmlUInteger(1) {}
KaxCueRefNumber(const KaxCueRefNumber & ElementToClone) :EbmlUInteger(ElementToClone) {}
static EbmlElement & Create() {return *(new KaxCueRefNumber);}
const EbmlCallbacks & Generic() const {return ClassInfos;}
static const EbmlCallbacks ClassInfos;
operator const EbmlId &() const {return ClassInfos.GlobalId;}
EbmlElement * Clone() const {return new KaxCueRefNumber(*this);}
};
class MATROSKA_DLL_API KaxCueRefCodecState : public EbmlUInteger {
public:
KaxCueRefCodecState() :EbmlUInteger(0) {}
KaxCueRefCodecState(const KaxCueRefCodecState & ElementToClone) :EbmlUInteger(ElementToClone) {}
static EbmlElement & Create() {return *(new KaxCueRefCodecState);}
const EbmlCallbacks & Generic() const {return ClassInfos;}
static const EbmlCallbacks ClassInfos;
operator const EbmlId &() const {return ClassInfos.GlobalId;}
EbmlElement * Clone() const {return new KaxCueRefCodecState(*this);}
};
#endif // MATROSKA_VERSION
END_LIBMATROSKA_NAMESPACE
#endif // LIBMATROSKA_CUES_DATA_H

81
matroska/KaxInfo.h Normal file
View File

@ -0,0 +1,81 @@
/****************************************************************************
** libmatroska : parse Matroska files, see http://www.matroska.org/
**
** <file/class MATROSKA_DLL_API description>
**
** Copyright (C) 2002-2004 Steve Lhomme. All rights reserved.
**
** This file is part of libmatroska.
**
** This library is free software; you can redistribute it and/or
** modify it under the terms of the GNU Lesser General Public
** License as published by the Free Software Foundation; either
** version 2.1 of the License, or (at your option) any later version.
**
** This library is distributed in the hope that it will be useful,
** but WITHOUT ANY WARRANTY; without even the implied warranty of
** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
** Lesser General Public License for more details.
**
** You should have received a copy of the GNU Lesser General Public
** License along with this library; if not, write to the Free Software
** Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
**
** See http://www.matroska.org/license/lgpl/ for LGPL licensing information.**
** Contact license@matroska.org if any conditions of this licensing are
** not clear to you.
**
**********************************************************************/
/*!
\file
\version \$Id: KaxInfo.h,v 1.7 2004/04/14 23:26:17 robux4 Exp $
\author Steve Lhomme <robux4 @ users.sf.net>
*/
#ifndef LIBMATROSKA_INFO_H
#define LIBMATROSKA_INFO_H
#include "matroska/KaxTypes.h"
#include "ebml/EbmlMaster.h"
#include "ebml/EbmlUnicodeString.h"
using namespace LIBEBML_NAMESPACE;
START_LIBMATROSKA_NAMESPACE
class MATROSKA_DLL_API KaxInfo : public EbmlMaster {
public:
KaxInfo();
KaxInfo(const KaxInfo & ElementToClone) :EbmlMaster(ElementToClone) {}
static EbmlElement & Create() {return *(new KaxInfo);}
const EbmlCallbacks & Generic() const {return ClassInfos;}
static const EbmlCallbacks ClassInfos;
operator const EbmlId &() const {return ClassInfos.GlobalId;}
EbmlElement * Clone() const {return new KaxInfo(*this);}
};
class MATROSKA_DLL_API KaxMuxingApp : public EbmlUnicodeString {
public:
KaxMuxingApp() {}
KaxMuxingApp(const KaxMuxingApp & ElementToClone) :EbmlUnicodeString(ElementToClone) {}
static EbmlElement & Create() {return *(new KaxMuxingApp);}
const EbmlCallbacks & Generic() const {return ClassInfos;}
static const EbmlCallbacks ClassInfos;
operator const EbmlId &() const {return ClassInfos.GlobalId;}
EbmlElement * Clone() const {return new KaxMuxingApp(*this);}
};
class MATROSKA_DLL_API KaxWritingApp : public EbmlUnicodeString {
public:
KaxWritingApp() {}
KaxWritingApp(const KaxWritingApp & ElementToClone) :EbmlUnicodeString(ElementToClone) {}
static EbmlElement & Create() {return *(new KaxWritingApp);}
const EbmlCallbacks & Generic() const {return ClassInfos;}
static const EbmlCallbacks ClassInfos;
operator const EbmlId &() const {return ClassInfos.GlobalId;}
EbmlElement * Clone() const {return new KaxWritingApp(*this);}
};
END_LIBMATROSKA_NAMESPACE
#endif // LIBMATROSKA_INFO_H

224
matroska/KaxInfoData.h Normal file
View File

@ -0,0 +1,224 @@
/****************************************************************************
** libmatroska : parse Matroska files, see http://www.matroska.org/
**
** <file/class description>
**
** Copyright (C) 2002-2005 Steve Lhomme. All rights reserved.
**
** This file is part of libmatroska.
**
** This library is free software; you can redistribute it and/or
** modify it under the terms of the GNU Lesser General Public
** License as published by the Free Software Foundation; either
** version 2.1 of the License, or (at your option) any later version.
**
** This library is distributed in the hope that it will be useful,
** but WITHOUT ANY WARRANTY; without even the implied warranty of
** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
** Lesser General Public License for more details.
**
** You should have received a copy of the GNU Lesser General Public
** License along with this library; if not, write to the Free Software
** Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
**
** See http://www.matroska.org/license/lgpl/ for LGPL licensing information.**
** Contact license@matroska.org if any conditions of this licensing are
** not clear to you.
**
**********************************************************************/
/*!
\file
\version \$Id: KaxInfoData.h,v 1.7 2004/04/14 23:26:17 robux4 Exp $
\author Steve Lhomme <robux4 @ users.sf.net>
\author John Cannon <spyder2555 @ users.sf.net>
\author Moritz Bunkus <moritz @ bunkus.org>
*/
#ifndef LIBMATROSKA_INFO_DATA_H
#define LIBMATROSKA_INFO_DATA_H
#include "matroska/KaxTypes.h"
#include "ebml/EbmlUInteger.h"
#include "ebml/EbmlFloat.h"
#include "ebml/EbmlUnicodeString.h"
#include "ebml/EbmlBinary.h"
#include "ebml/EbmlDate.h"
#include "ebml/EbmlMaster.h"
using namespace LIBEBML_NAMESPACE;
START_LIBMATROSKA_NAMESPACE
class MATROSKA_DLL_API KaxSegmentUID : public EbmlBinary {
public:
KaxSegmentUID() {}
KaxSegmentUID(const KaxSegmentUID & ElementToClone) :EbmlBinary(ElementToClone){}
static EbmlElement & Create() {return *(new KaxSegmentUID);}
bool ValidateSize() const { return (Size == 16);}
const EbmlCallbacks & Generic() const {return ClassInfos;}
static const EbmlCallbacks ClassInfos;
operator const EbmlId &() const {return ClassInfos.GlobalId;}
EbmlElement * Clone() const {return new KaxSegmentUID(*this);}
};
class MATROSKA_DLL_API KaxSegmentFilename : public EbmlUnicodeString {
public:
KaxSegmentFilename() {}
KaxSegmentFilename(const KaxSegmentFilename & ElementToClone) :EbmlUnicodeString(ElementToClone){}
static EbmlElement & Create() {return *(new KaxSegmentFilename);}
const EbmlCallbacks & Generic() const {return ClassInfos;}
static const EbmlCallbacks ClassInfos;
operator const EbmlId &() const {return ClassInfos.GlobalId;}
EbmlElement * Clone() const {return new KaxSegmentFilename(*this);}
};
class MATROSKA_DLL_API KaxPrevUID : public KaxSegmentUID {
public:
KaxPrevUID() {}
KaxPrevUID(const KaxPrevUID & ElementToClone) :KaxSegmentUID(ElementToClone){}
static EbmlElement & Create() {return *(new KaxPrevUID);}
bool ValidateSize() const { return (Size == 16);}
const EbmlCallbacks & Generic() const {return ClassInfos;}
static const EbmlCallbacks ClassInfos;
operator const EbmlId &() const {return ClassInfos.GlobalId;}
EbmlElement * Clone() const {return new KaxPrevUID(*this);}
};
class MATROSKA_DLL_API KaxPrevFilename : public EbmlUnicodeString {
public:
KaxPrevFilename() :EbmlUnicodeString() {}
KaxPrevFilename(const KaxPrevFilename & ElementToClone) :EbmlUnicodeString(ElementToClone) {}
static EbmlElement & Create() {return *(new KaxPrevFilename);}
const EbmlCallbacks & Generic() const {return ClassInfos;}
static const EbmlCallbacks ClassInfos;
operator const EbmlId &() const {return ClassInfos.GlobalId;}
EbmlElement * Clone() const {return new KaxPrevFilename(*this);}
};
class MATROSKA_DLL_API KaxNextUID : public KaxSegmentUID {
public:
KaxNextUID() {}
KaxNextUID(const KaxNextUID & ElementToClone) :KaxSegmentUID(ElementToClone){}
static EbmlElement & Create() {return *(new KaxNextUID);}
bool ValidateSize() const { return (Size == 16);}
const EbmlCallbacks & Generic() const {return ClassInfos;}
static const EbmlCallbacks ClassInfos;
operator const EbmlId &() const {return ClassInfos.GlobalId;}
EbmlElement * Clone() const {return new KaxNextUID(*this);}
};
class MATROSKA_DLL_API KaxNextFilename : public EbmlUnicodeString {
public:
KaxNextFilename() {}
KaxNextFilename(const KaxNextFilename & ElementToClone) :EbmlUnicodeString(ElementToClone) {}
static EbmlElement & Create() {return *(new KaxNextFilename);}
const EbmlCallbacks & Generic() const {return ClassInfos;}
static const EbmlCallbacks ClassInfos;
operator const EbmlId &() const {return ClassInfos.GlobalId;}
EbmlElement * Clone() const {return new KaxNextFilename(*this);}
};
class MATROSKA_DLL_API KaxSegmentFamily : public EbmlBinary {
public:
KaxSegmentFamily() {}
KaxSegmentFamily(const KaxSegmentFamily & ElementToClone) :EbmlBinary(ElementToClone){}
static EbmlElement & Create() {return *(new KaxSegmentFamily);}
bool ValidateSize() const { return (Size == 16);}
const EbmlCallbacks & Generic() const {return ClassInfos;}
static const EbmlCallbacks ClassInfos;
operator const EbmlId &() const {return ClassInfos.GlobalId;}
EbmlElement * Clone() const {return new KaxSegmentFamily(*this);}
};
class MATROSKA_DLL_API KaxChapterTranslate : public EbmlMaster {
public:
KaxChapterTranslate();
KaxChapterTranslate(const KaxChapterTranslate & ElementToClone) :EbmlMaster(ElementToClone) {}
static EbmlElement & Create() {return *(new KaxChapterTranslate);}
const EbmlCallbacks & Generic() const {return ClassInfos;}
static const EbmlCallbacks ClassInfos;
operator const EbmlId &() const {return ClassInfos.GlobalId;}
EbmlElement * Clone() const {return new KaxChapterTranslate(*this);}
};
class MATROSKA_DLL_API KaxChapterTranslateCodec : public EbmlUInteger {
public:
KaxChapterTranslateCodec() {}
KaxChapterTranslateCodec(const KaxChapterTranslateCodec & ElementToClone) :EbmlUInteger(ElementToClone) {}
static EbmlElement & Create() {return *(new KaxChapterTranslateCodec);}
const EbmlCallbacks & Generic() const {return ClassInfos;}
static const EbmlCallbacks ClassInfos;
operator const EbmlId &() const {return ClassInfos.GlobalId;}
EbmlElement * Clone() const {return new KaxChapterTranslateCodec(*this);}
};
class MATROSKA_DLL_API KaxChapterTranslateEditionUID : public EbmlUInteger {
public:
KaxChapterTranslateEditionUID() {}
KaxChapterTranslateEditionUID(const KaxChapterTranslateEditionUID & ElementToClone) :EbmlUInteger(ElementToClone) {}
static EbmlElement & Create() {return *(new KaxChapterTranslateEditionUID);}
const EbmlCallbacks & Generic() const {return ClassInfos;}
static const EbmlCallbacks ClassInfos;
operator const EbmlId &() const {return ClassInfos.GlobalId;}
EbmlElement * Clone() const {return new KaxChapterTranslateEditionUID(*this);}
};
class MATROSKA_DLL_API KaxChapterTranslateID : public EbmlBinary {
public:
KaxChapterTranslateID() {}
KaxChapterTranslateID(const KaxChapterTranslateID & ElementToClone) :EbmlBinary(ElementToClone){}
static EbmlElement & Create() {return *(new KaxChapterTranslateID);}
bool ValidateSize() const { return true;}
const EbmlCallbacks & Generic() const {return ClassInfos;}
static const EbmlCallbacks ClassInfos;
operator const EbmlId &() const {return ClassInfos.GlobalId;}
EbmlElement * Clone() const {return new KaxChapterTranslateID(*this);}
};
class MATROSKA_DLL_API KaxTimecodeScale : public EbmlUInteger {
public:
KaxTimecodeScale() :EbmlUInteger(1000000) {}
KaxTimecodeScale(const KaxTimecodeScale & ElementToClone) :EbmlUInteger(ElementToClone) {}
static EbmlElement & Create() {return *(new KaxTimecodeScale);}
const EbmlCallbacks & Generic() const {return ClassInfos;}
static const EbmlCallbacks ClassInfos;
operator const EbmlId &() const {return ClassInfos.GlobalId;}
EbmlElement * Clone() const {return new KaxTimecodeScale(*this);}
};
class MATROSKA_DLL_API KaxDuration : public EbmlFloat {
public:
KaxDuration(): EbmlFloat(FLOAT_64) {}
KaxDuration(const KaxDuration & ElementToClone) :EbmlFloat(ElementToClone) {}
static EbmlElement & Create() {return *(new KaxDuration);}
const EbmlCallbacks & Generic() const {return ClassInfos;}
static const EbmlCallbacks ClassInfos;
operator const EbmlId &() const {return ClassInfos.GlobalId;}
EbmlElement * Clone() const {return new KaxDuration(*this);}
};
class MATROSKA_DLL_API KaxDateUTC : public EbmlDate {
public:
KaxDateUTC() {}
KaxDateUTC(const KaxDateUTC & ElementToClone) :EbmlDate(ElementToClone) {}
static EbmlElement & Create() {return *(new KaxDateUTC);}
const EbmlCallbacks & Generic() const {return ClassInfos;}
static const EbmlCallbacks ClassInfos;
operator const EbmlId &() const {return ClassInfos.GlobalId;}
EbmlElement * Clone() const {return new KaxDateUTC(*this);}
};
class MATROSKA_DLL_API KaxTitle : public EbmlUnicodeString {
public:
KaxTitle() {}
KaxTitle(const KaxTitle & ElementToClone) :EbmlUnicodeString(ElementToClone) {}
static EbmlElement & Create() {return *(new KaxTitle);}
const EbmlCallbacks & Generic() const {return ClassInfos;}
static const EbmlCallbacks ClassInfos;
operator const EbmlId &() const {return ClassInfos.GlobalId;}
EbmlElement * Clone() const {return new KaxTitle(*this);}
};
END_LIBMATROSKA_NAMESPACE
#endif // LIBMATROSKA_INFO_DATA_H

110
matroska/KaxSeekHead.h Normal file
View File

@ -0,0 +1,110 @@
/****************************************************************************
** libmatroska : parse Matroska files, see http://www.matroska.org/
**
** <file/class description>
**
** Copyright (C) 2002-2004 Steve Lhomme. All rights reserved.
**
** This file is part of libmatroska.
**
** This library is free software; you can redistribute it and/or
** modify it under the terms of the GNU Lesser General Public
** License as published by the Free Software Foundation; either
** version 2.1 of the License, or (at your option) any later version.
**
** This library is distributed in the hope that it will be useful,
** but WITHOUT ANY WARRANTY; without even the implied warranty of
** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
** Lesser General Public License for more details.
**
** You should have received a copy of the GNU Lesser General Public
** License along with this library; if not, write to the Free Software
** Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
**
** See http://www.matroska.org/license/lgpl/ for LGPL licensing information.**
** Contact license@matroska.org if any conditions of this licensing are
** not clear to you.
**
**********************************************************************/
/*!
\file
\version \$Id: KaxSeekHead.h,v 1.7 2004/04/14 23:26:17 robux4 Exp $
\author Steve Lhomme <robux4 @ users.sf.net>
*/
#ifndef LIBMATROSKA_SEEK_HEAD_H
#define LIBMATROSKA_SEEK_HEAD_H
#include "matroska/KaxTypes.h"
#include "ebml/EbmlMaster.h"
#include "ebml/EbmlBinary.h"
#include "ebml/EbmlUInteger.h"
using namespace LIBEBML_NAMESPACE;
START_LIBMATROSKA_NAMESPACE
class KaxSegment;
class KaxSeek;
class MATROSKA_DLL_API KaxSeekHead : public EbmlMaster {
public:
KaxSeekHead();
KaxSeekHead(const KaxSeekHead & ElementToClone) :EbmlMaster(ElementToClone) {}
static EbmlElement & Create() {return *(new KaxSeekHead);}
const EbmlCallbacks & Generic() const {return ClassInfos;}
static const EbmlCallbacks ClassInfos;
operator const EbmlId &() const {return ClassInfos.GlobalId;}
EbmlElement * Clone() const {return new KaxSeekHead(*this);}
/*!
\brief add an element to index in the Meta Seek data
\note the element should already be written in the file
*/
void IndexThis(const EbmlElement & aElt, const KaxSegment & ParentSegment);
KaxSeek * FindFirstOf(const EbmlCallbacks & Callbacks) const;
KaxSeek * FindNextOf(const KaxSeek &aPrev) const;
};
class MATROSKA_DLL_API KaxSeek : public EbmlMaster {
public:
KaxSeek();
KaxSeek(const KaxSeek & ElementToClone) :EbmlMaster(ElementToClone) {}
static EbmlElement & Create() {return *(new KaxSeek);}
const EbmlCallbacks & Generic() const {return ClassInfos;}
static const EbmlCallbacks ClassInfos;
operator const EbmlId &() const {return ClassInfos.GlobalId;}
EbmlElement * Clone() const {return new KaxSeek(*this);}
int64 Location() const;
bool IsEbmlId(const EbmlId & aId) const;
bool IsEbmlId(const KaxSeek & aPoint) const;
};
class MATROSKA_DLL_API KaxSeekID : public EbmlBinary {
public:
KaxSeekID() {}
KaxSeekID(const KaxSeekID & ElementToClone) :EbmlBinary(ElementToClone){}
static EbmlElement & Create() {return *(new KaxSeekID);}
const EbmlCallbacks & Generic() const {return ClassInfos;}
static const EbmlCallbacks ClassInfos;
operator const EbmlId &() const {return ClassInfos.GlobalId;}
bool ValidateSize() const {return Size <= 4;}
EbmlElement * Clone() const {return new KaxSeekID(*this);}
};
class MATROSKA_DLL_API KaxSeekPosition : public EbmlUInteger {
public:
KaxSeekPosition() {}
KaxSeekPosition(const KaxSeekPosition & ElementToClone) :EbmlUInteger(ElementToClone) {}
static EbmlElement & Create() {return *(new KaxSeekPosition);}
const EbmlCallbacks & Generic() const {return ClassInfos;}
static const EbmlCallbacks ClassInfos;
operator const EbmlId &() const {return ClassInfos.GlobalId;}
EbmlElement * Clone() const {return new KaxSeekPosition(*this);}
};
END_LIBMATROSKA_NAMESPACE
#endif // LIBMATROSKA_SEEK_HEAD_H

69
matroska/KaxSegment.h Normal file
View File

@ -0,0 +1,69 @@
/****************************************************************************
** libmatroska : parse Matroska files, see http://www.matroska.org/
**
** <file/class MATROSKA_DLL_API description>
**
** Copyright (C) 2002-2004 Steve Lhomme. All rights reserved.
**
** This file is part of libmatroska.
**
** This library is free software; you can redistribute it and/or
** modify it under the terms of the GNU Lesser General Public
** License as published by the Free Software Foundation; either
** version 2.1 of the License, or (at your option) any later version.
**
** This library is distributed in the hope that it will be useful,
** but WITHOUT ANY WARRANTY; without even the implied warranty of
** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
** Lesser General Public License for more details.
**
** You should have received a copy of the GNU Lesser General Public
** License along with this library; if not, write to the Free Software
** Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
**
** See http://www.matroska.org/license/lgpl/ for LGPL licensing information.**
** Contact license@matroska.org if any conditions of this licensing are
** not clear to you.
**
**********************************************************************/
/*!
\file
\version \$Id: KaxSegment.h,v 1.8 2004/04/14 23:26:17 robux4 Exp $
\author Steve Lhomme <robux4 @ users.sf.net>
*/
#ifndef LIBMATROSKA_SEGMENT_H
#define LIBMATROSKA_SEGMENT_H
#include "matroska/KaxTypes.h"
#include "ebml/EbmlMaster.h"
using namespace LIBEBML_NAMESPACE;
START_LIBMATROSKA_NAMESPACE
class MATROSKA_DLL_API KaxSegment : public EbmlMaster {
public:
KaxSegment();
KaxSegment(const KaxSegment & ElementToClone);
static EbmlElement & Create() {return *(new KaxSegment);}
const EbmlCallbacks & Generic() const {return ClassInfos;}
static const EbmlCallbacks ClassInfos;
operator const EbmlId &() const {return ClassInfos.GlobalId;}
EbmlElement * Clone() const {return new KaxSegment(*this);}
/*!
\brief give the position of the element in the segment
*/
uint64 GetRelativePosition(const EbmlElement & Elt) const;
uint64 GetRelativePosition(uint64 aGlobalPosition) const;
/*!
\brief give the position of the element in the file
*/
uint64 GetGlobalPosition(uint64 aRelativePosition) const;
};
END_LIBMATROSKA_NAMESPACE
#endif // LIBMATROSKA_SEGMENT_H

699
matroska/KaxTag.h Normal file
View File

@ -0,0 +1,699 @@
/****************************************************************************
** libmatroska : parse Matroska files, see http://www.matroska.org/
**
** <file/class MATROSKA_DLL_API description>
**
** Copyright (C) 2002-2004 Steve Lhomme. All rights reserved.
**
** This file is part of libmatroska.
**
** This library is free software; you can redistribute it and/or
** modify it under the terms of the GNU Lesser General Public
** License as published by the Free Software Foundation; either
** version 2.1 of the License, or (at your option) any later version.
**
** This library is distributed in the hope that it will be useful,
** but WITHOUT ANY WARRANTY; without even the implied warranty of
** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
** Lesser General Public License for more details.
**
** You should have received a copy of the GNU Lesser General Public
** License along with this library; if not, write to the Free Software
** Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
**
** See http://www.matroska.org/license/lgpl/ for LGPL licensing information.**
** Contact license@matroska.org if any conditions of this licensing are
** not clear to you.
**
**********************************************************************/
/*!
\file
\version \$Id: KaxTag.h,v 1.9 2004/04/14 23:26:17 robux4 Exp $
\author Jory Stone <jcsston @ toughguy.net>
\author Steve Lhomme <robux4 @ users.sf.net>
*/
#ifndef LIBMATROSKA_TAG_H
#define LIBMATROSKA_TAG_H
#include "matroska/KaxTypes.h"
#include "ebml/EbmlMaster.h"
#include "ebml/EbmlFloat.h"
#include "ebml/EbmlSInteger.h"
#include "ebml/EbmlUInteger.h"
#include "ebml/EbmlString.h"
#include "ebml/EbmlUnicodeString.h"
#include "ebml/EbmlBinary.h"
using namespace LIBEBML_NAMESPACE;
START_LIBMATROSKA_NAMESPACE
class MATROSKA_DLL_API KaxTag : public EbmlMaster {
public:
KaxTag();
KaxTag(const KaxTag & ElementToClone) :EbmlMaster(ElementToClone) {}
static EbmlElement & Create() {return *(new KaxTag);}
const EbmlCallbacks & Generic() const {return ClassInfos;}
static const EbmlCallbacks ClassInfos;
operator const EbmlId &() const {return ClassInfos.GlobalId;}
EbmlElement * Clone() const {return new KaxTag(*this);}
};
class MATROSKA_DLL_API KaxTagTargets : public EbmlMaster {
public:
KaxTagTargets();
KaxTagTargets(const KaxTagTargets & ElementToClone) :EbmlMaster(ElementToClone) {}
static EbmlElement & Create() {return *(new KaxTagTargets);}
const EbmlCallbacks & Generic() const {return ClassInfos;}
static const EbmlCallbacks ClassInfos;
operator const EbmlId &() const {return ClassInfos.GlobalId;}
EbmlElement * Clone() const {return new KaxTagTargets(*this);}
};
class MATROSKA_DLL_API KaxTagGeneral : public EbmlMaster {
public:
KaxTagGeneral();
KaxTagGeneral(const KaxTagGeneral & ElementToClone) :EbmlMaster(ElementToClone) {}
static EbmlElement & Create() {return *(new KaxTagGeneral);}
const EbmlCallbacks & Generic() const {return ClassInfos;}
static const EbmlCallbacks ClassInfos;
operator const EbmlId &() const {return ClassInfos.GlobalId;}
EbmlElement * Clone() const {return new KaxTagGeneral(*this);}
};
class MATROSKA_DLL_API KaxTagGenres : public EbmlMaster {
public:
KaxTagGenres();
KaxTagGenres(const KaxTagGenres & ElementToClone) :EbmlMaster(ElementToClone) {}
static EbmlElement & Create() {return *(new KaxTagGenres);}
const EbmlCallbacks & Generic() const {return ClassInfos;}
static const EbmlCallbacks ClassInfos;
operator const EbmlId &() const {return ClassInfos.GlobalId;}
EbmlElement * Clone() const {return new KaxTagGenres(*this);}
};
class MATROSKA_DLL_API KaxTagAudioSpecific : public EbmlMaster {
public:
KaxTagAudioSpecific();
KaxTagAudioSpecific(const KaxTagAudioSpecific & ElementToClone) :EbmlMaster(ElementToClone) {}
static EbmlElement & Create() {return *(new KaxTagAudioSpecific);}
const EbmlCallbacks & Generic() const {return ClassInfos;}
static const EbmlCallbacks ClassInfos;
operator const EbmlId &() const {return ClassInfos.GlobalId;}
EbmlElement * Clone() const {return new KaxTagAudioSpecific(*this);}
};
class MATROSKA_DLL_API KaxTagImageSpecific : public EbmlMaster {
public:
KaxTagImageSpecific();
KaxTagImageSpecific(const KaxTagImageSpecific & ElementToClone) :EbmlMaster(ElementToClone) {}
static EbmlElement & Create() {return *(new KaxTagImageSpecific);}
const EbmlCallbacks & Generic() const {return ClassInfos;}
static const EbmlCallbacks ClassInfos;
operator const EbmlId &() const {return ClassInfos.GlobalId;}
EbmlElement * Clone() const {return new KaxTagImageSpecific(*this);}
};
class MATROSKA_DLL_API KaxTagTargetTypeValue : public EbmlUInteger {
public:
KaxTagTargetTypeValue() :EbmlUInteger(50) {}
KaxTagTargetTypeValue(const KaxTagTargetTypeValue & ElementToClone) :EbmlUInteger(ElementToClone) {}
static EbmlElement & Create() {return *(new KaxTagTargetTypeValue);}
const EbmlCallbacks & Generic() const {return ClassInfos;}
static const EbmlCallbacks ClassInfos;
operator const EbmlId &() const {return ClassInfos.GlobalId;}
EbmlElement * Clone() const {return new KaxTagTargetTypeValue(*this);}
};
class MATROSKA_DLL_API KaxTagTargetType : public EbmlString {
public:
KaxTagTargetType() {}
KaxTagTargetType(const KaxTagTargetType & ElementToClone) :EbmlString(ElementToClone) {}
static EbmlElement & Create() {return *(new KaxTagTargetType);}
const EbmlCallbacks & Generic() const {return ClassInfos;}
static const EbmlCallbacks ClassInfos;
operator const EbmlId &() const {return ClassInfos.GlobalId;}
EbmlElement * Clone() const {return new KaxTagTargetType(*this);}
};
class MATROSKA_DLL_API KaxTagTrackUID : public EbmlUInteger {
public:
KaxTagTrackUID() :EbmlUInteger(0) {}
KaxTagTrackUID(const KaxTagTrackUID & ElementToClone) :EbmlUInteger(ElementToClone) {}
static EbmlElement & Create() {return *(new KaxTagTrackUID);}
const EbmlCallbacks & Generic() const {return ClassInfos;}
static const EbmlCallbacks ClassInfos;
operator const EbmlId &() const {return ClassInfos.GlobalId;}
EbmlElement * Clone() const {return new KaxTagTrackUID(*this);}
};
class MATROSKA_DLL_API KaxTagEditionUID : public EbmlUInteger {
public:
KaxTagEditionUID() :EbmlUInteger(0) {}
KaxTagEditionUID(const KaxTagEditionUID & ElementToClone) :EbmlUInteger(ElementToClone) {}
static EbmlElement & Create() {return *(new KaxTagEditionUID);}
const EbmlCallbacks & Generic() const {return ClassInfos;}
static const EbmlCallbacks ClassInfos;
operator const EbmlId &() const {return ClassInfos.GlobalId;}
EbmlElement * Clone() const {return new KaxTagEditionUID(*this);}
};
class MATROSKA_DLL_API KaxTagChapterUID : public EbmlUInteger {
public:
KaxTagChapterUID() :EbmlUInteger(0) {}
KaxTagChapterUID(const KaxTagChapterUID & ElementToClone) :EbmlUInteger(ElementToClone) {}
static EbmlElement & Create() {return *(new KaxTagChapterUID);}
const EbmlCallbacks & Generic() const {return ClassInfos;}
static const EbmlCallbacks ClassInfos;
operator const EbmlId &() const {return ClassInfos.GlobalId;}
EbmlElement * Clone() const {return new KaxTagChapterUID(*this);}
};
class MATROSKA_DLL_API KaxTagAttachmentUID : public EbmlUInteger {
public:
KaxTagAttachmentUID() :EbmlUInteger(0) {}
KaxTagAttachmentUID(const KaxTagAttachmentUID & ElementToClone) :EbmlUInteger(ElementToClone) {}
static EbmlElement & Create() {return *(new KaxTagAttachmentUID);}
const EbmlCallbacks & Generic() const {return ClassInfos;}
static const EbmlCallbacks ClassInfos;
operator const EbmlId &() const {return ClassInfos.GlobalId;}
EbmlElement * Clone() const {return new KaxTagAttachmentUID(*this);}
};
class MATROSKA_DLL_API KaxTagArchivalLocation : public EbmlUnicodeString {
public:
KaxTagArchivalLocation() {}
KaxTagArchivalLocation(const KaxTagArchivalLocation & ElementToClone) :EbmlUnicodeString(ElementToClone) {}
static EbmlElement & Create() {return *(new KaxTagArchivalLocation);}
const EbmlCallbacks & Generic() const {return ClassInfos;}
static const EbmlCallbacks ClassInfos;
operator const EbmlId &() const {return ClassInfos.GlobalId;}
EbmlElement * Clone() const {return new KaxTagArchivalLocation(*this);}
};
class MATROSKA_DLL_API KaxTagAudioEncryption : public EbmlBinary {
public:
KaxTagAudioEncryption() {}
KaxTagAudioEncryption(const KaxTagAudioEncryption & ElementToClone) :EbmlBinary(ElementToClone){}
static EbmlElement & Create() {return *(new KaxTagAudioEncryption);}
bool ValidateSize() const {return true;} // we don't mind about what's inside
const EbmlCallbacks & Generic() const {return ClassInfos;}
static const EbmlCallbacks ClassInfos;
operator const EbmlId &() const {return ClassInfos.GlobalId;}
EbmlElement * Clone() const {return new KaxTagAudioEncryption(*this);}
};
class MATROSKA_DLL_API KaxTagAudioGain : public EbmlFloat {
public:
KaxTagAudioGain() {}
KaxTagAudioGain(const KaxTagAudioGain & ElementToClone) :EbmlFloat(ElementToClone) {}
static EbmlElement & Create() {return *(new KaxTagAudioGain);}
const EbmlCallbacks & Generic() const {return ClassInfos;}
static const EbmlCallbacks ClassInfos;
operator const EbmlId &() const {return ClassInfos.GlobalId;}
EbmlElement * Clone() const {return new KaxTagAudioGain(*this);}
};
class MATROSKA_DLL_API KaxTagAudioGenre : public EbmlString {
public:
KaxTagAudioGenre() {}
KaxTagAudioGenre(const KaxTagAudioGenre & ElementToClone) :EbmlString(ElementToClone) {}
static EbmlElement & Create() {return *(new KaxTagAudioGenre);}
const EbmlCallbacks & Generic() const {return ClassInfos;}
static const EbmlCallbacks ClassInfos;
operator const EbmlId &() const {return ClassInfos.GlobalId;}
EbmlElement * Clone() const {return new KaxTagAudioGenre(*this);}
};
class MATROSKA_DLL_API KaxTagAudioPeak : public EbmlFloat {
public:
KaxTagAudioPeak() {}
KaxTagAudioPeak(const KaxTagAudioPeak & ElementToClone) :EbmlFloat(ElementToClone) {}
static EbmlElement & Create() {return *(new KaxTagAudioPeak);}
const EbmlCallbacks & Generic() const {return ClassInfos;}
static const EbmlCallbacks ClassInfos;
operator const EbmlId &() const {return ClassInfos.GlobalId;}
EbmlElement * Clone() const {return new KaxTagAudioPeak(*this);}
};
class MATROSKA_DLL_API KaxTagBibliography : public EbmlUnicodeString {
public:
KaxTagBibliography() {}
KaxTagBibliography(const KaxTagBibliography & ElementToClone) :EbmlUnicodeString(ElementToClone) {}
static EbmlElement & Create() {return *(new KaxTagBibliography);}
const EbmlCallbacks & Generic() const {return ClassInfos;}
static const EbmlCallbacks ClassInfos;
operator const EbmlId &() const {return ClassInfos.GlobalId;}
EbmlElement * Clone() const {return new KaxTagBibliography(*this);}
};
class MATROSKA_DLL_API KaxTagBPM : public EbmlFloat {
public:
KaxTagBPM() {}
KaxTagBPM(const KaxTagBPM & ElementToClone) :EbmlFloat(ElementToClone) {}
static EbmlElement & Create() {return *(new KaxTagBPM);}
const EbmlCallbacks & Generic() const {return ClassInfos;}
static const EbmlCallbacks ClassInfos;
operator const EbmlId &() const {return ClassInfos.GlobalId;}
EbmlElement * Clone() const {return new KaxTagBPM(*this);}
};
class MATROSKA_DLL_API KaxTagCaptureDPI : public EbmlUInteger {
public:
KaxTagCaptureDPI() {}
KaxTagCaptureDPI(const KaxTagCaptureDPI & ElementToClone) :EbmlUInteger(ElementToClone) {}
static EbmlElement & Create() {return *(new KaxTagCaptureDPI);}
const EbmlCallbacks & Generic() const {return ClassInfos;}
static const EbmlCallbacks ClassInfos;
operator const EbmlId &() const {return ClassInfos.GlobalId;}
EbmlElement * Clone() const {return new KaxTagCaptureDPI(*this);}
};
class MATROSKA_DLL_API KaxTagCaptureLightness : public EbmlBinary {
public:
KaxTagCaptureLightness() {}
KaxTagCaptureLightness(const KaxTagCaptureLightness & ElementToClone) :EbmlBinary(ElementToClone){}
static EbmlElement & Create() {return *(new KaxTagCaptureLightness);}
bool ValidateSize() const {return true;} // we don't mind about what's inside
const EbmlCallbacks & Generic() const {return ClassInfos;}
static const EbmlCallbacks ClassInfos;
operator const EbmlId &() const {return ClassInfos.GlobalId;}
EbmlElement * Clone() const {return new KaxTagCaptureLightness(*this);}
};
class MATROSKA_DLL_API KaxTagCapturePaletteSetting : public EbmlUInteger {
public:
KaxTagCapturePaletteSetting() {}
KaxTagCapturePaletteSetting(const KaxTagCapturePaletteSetting & ElementToClone) :EbmlUInteger(ElementToClone) {}
static EbmlElement & Create() {return *(new KaxTagCapturePaletteSetting);}
const EbmlCallbacks & Generic() const {return ClassInfos;}
static const EbmlCallbacks ClassInfos;
operator const EbmlId &() const {return ClassInfos.GlobalId;}
EbmlElement * Clone() const {return new KaxTagCapturePaletteSetting(*this);}
};
class MATROSKA_DLL_API KaxTagCaptureSharpness : public EbmlBinary {
public:
KaxTagCaptureSharpness() {}
KaxTagCaptureSharpness(const KaxTagCaptureSharpness & ElementToClone) :EbmlBinary(ElementToClone){}
static EbmlElement & Create() {return *(new KaxTagCaptureSharpness);}
bool ValidateSize() const {return true;} // we don't mind about what's inside
const EbmlCallbacks & Generic() const {return ClassInfos;}
static const EbmlCallbacks ClassInfos;
operator const EbmlId &() const {return ClassInfos.GlobalId;}
EbmlElement * Clone() const {return new KaxTagCaptureSharpness(*this);}
};
class MATROSKA_DLL_API KaxTagCropped : public EbmlUnicodeString {
public:
KaxTagCropped() {}
KaxTagCropped(const KaxTagCropped & ElementToClone) :EbmlUnicodeString(ElementToClone) {}
static EbmlElement & Create() {return *(new KaxTagCropped);}
const EbmlCallbacks & Generic() const {return ClassInfos;}
static const EbmlCallbacks ClassInfos;
operator const EbmlId &() const {return ClassInfos.GlobalId;}
EbmlElement * Clone() const {return new KaxTagCropped(*this);}
};
class MATROSKA_DLL_API KaxTagDiscTrack : public EbmlUInteger {
public:
KaxTagDiscTrack() {}
KaxTagDiscTrack(const KaxTagDiscTrack & ElementToClone) :EbmlUInteger(ElementToClone) {}
static EbmlElement & Create() {return *(new KaxTagDiscTrack);}
const EbmlCallbacks & Generic() const {return ClassInfos;}
static const EbmlCallbacks ClassInfos;
operator const EbmlId &() const {return ClassInfos.GlobalId;}
EbmlElement * Clone() const {return new KaxTagDiscTrack(*this);}
};
class MATROSKA_DLL_API KaxTagEncoder : public EbmlUnicodeString {
public:
KaxTagEncoder() {}
KaxTagEncoder(const KaxTagEncoder & ElementToClone) :EbmlUnicodeString(ElementToClone) {}
static EbmlElement & Create() {return *(new KaxTagEncoder);}
const EbmlCallbacks & Generic() const {return ClassInfos;}
static const EbmlCallbacks ClassInfos;
operator const EbmlId &() const {return ClassInfos.GlobalId;}
EbmlElement * Clone() const {return new KaxTagEncoder(*this);}
};
class MATROSKA_DLL_API KaxTagEncodeSettings : public EbmlUnicodeString {
public:
KaxTagEncodeSettings() {}
KaxTagEncodeSettings(const KaxTagEncodeSettings & ElementToClone) :EbmlUnicodeString(ElementToClone) {}
static EbmlElement & Create() {return *(new KaxTagEncodeSettings);}
const EbmlCallbacks & Generic() const {return ClassInfos;}
static const EbmlCallbacks ClassInfos;
operator const EbmlId &() const {return ClassInfos.GlobalId;}
EbmlElement * Clone() const {return new KaxTagEncodeSettings(*this);}
};
class MATROSKA_DLL_API KaxTagEqualisation : public EbmlBinary {
public:
KaxTagEqualisation() {}
KaxTagEqualisation(const KaxTagEqualisation & ElementToClone) :EbmlBinary(ElementToClone){}
static EbmlElement & Create() {return *(new KaxTagEqualisation);}
bool ValidateSize() const {return true;} // we don't mind about what's inside
const EbmlCallbacks & Generic() const {return ClassInfos;}
static const EbmlCallbacks ClassInfos;
operator const EbmlId &() const {return ClassInfos.GlobalId;}
EbmlElement * Clone() const {return new KaxTagEqualisation(*this);}
};
class MATROSKA_DLL_API KaxTagFile : public EbmlUnicodeString {
public:
KaxTagFile() {}
KaxTagFile(const KaxTagFile & ElementToClone) :EbmlUnicodeString(ElementToClone) {}
static EbmlElement & Create() {return *(new KaxTagFile);}
const EbmlCallbacks & Generic() const {return ClassInfos;}
static const EbmlCallbacks ClassInfos;
operator const EbmlId &() const {return ClassInfos.GlobalId;}
EbmlElement * Clone() const {return new KaxTagFile(*this);}
};
class MATROSKA_DLL_API KaxTagInitialKey : public EbmlString {
public:
KaxTagInitialKey() {}
KaxTagInitialKey(const KaxTagInitialKey & ElementToClone) :EbmlString(ElementToClone) {}
static EbmlElement & Create() {return *(new KaxTagInitialKey);}
const EbmlCallbacks & Generic() const {return ClassInfos;}
static const EbmlCallbacks ClassInfos;
operator const EbmlId &() const {return ClassInfos.GlobalId;}
EbmlElement * Clone() const {return new KaxTagInitialKey(*this);}
};
class MATROSKA_DLL_API KaxTagKeywords : public EbmlUnicodeString {
public:
KaxTagKeywords() {}
KaxTagKeywords(const KaxTagKeywords & ElementToClone) :EbmlUnicodeString(ElementToClone) {}
static EbmlElement & Create() {return *(new KaxTagKeywords);}
const EbmlCallbacks & Generic() const {return ClassInfos;}
static const EbmlCallbacks ClassInfos;
operator const EbmlId &() const {return ClassInfos.GlobalId;}
EbmlElement * Clone() const {return new KaxTagKeywords(*this);}
};
class MATROSKA_DLL_API KaxTagLanguage : public EbmlString {
public:
KaxTagLanguage() {}
KaxTagLanguage(const KaxTagLanguage & ElementToClone) :EbmlString(ElementToClone) {}
static EbmlElement & Create() {return *(new KaxTagLanguage);}
const EbmlCallbacks & Generic() const {return ClassInfos;}
static const EbmlCallbacks ClassInfos;
operator const EbmlId &() const {return ClassInfos.GlobalId;}
EbmlElement * Clone() const {return new KaxTagLanguage(*this);}
};
class MATROSKA_DLL_API KaxTagLength : public EbmlUInteger {
public:
KaxTagLength() {}
KaxTagLength(const KaxTagLength & ElementToClone) :EbmlUInteger(ElementToClone) {}
static EbmlElement & Create() {return *(new KaxTagLength);}
const EbmlCallbacks & Generic() const {return ClassInfos;}
static const EbmlCallbacks ClassInfos;
operator const EbmlId &() const {return ClassInfos.GlobalId;}
EbmlElement * Clone() const {return new KaxTagLength(*this);}
};
class MATROSKA_DLL_API KaxTagMood : public EbmlUnicodeString {
public:
KaxTagMood() {}
KaxTagMood(const KaxTagMood & ElementToClone) :EbmlUnicodeString(ElementToClone) {}
static EbmlElement & Create() {return *(new KaxTagMood);}
const EbmlCallbacks & Generic() const {return ClassInfos;}
static const EbmlCallbacks ClassInfos;
operator const EbmlId &() const {return ClassInfos.GlobalId;}
EbmlElement * Clone() const {return new KaxTagMood(*this);}
};
class MATROSKA_DLL_API KaxTagOfficialAudioFileURL : public EbmlString {
public:
KaxTagOfficialAudioFileURL() {}
KaxTagOfficialAudioFileURL(const KaxTagOfficialAudioFileURL & ElementToClone) :EbmlString(ElementToClone) {}
static EbmlElement & Create() {return *(new KaxTagOfficialAudioFileURL);}
const EbmlCallbacks & Generic() const {return ClassInfos;}
static const EbmlCallbacks ClassInfos;
operator const EbmlId &() const {return ClassInfos.GlobalId;}
EbmlElement * Clone() const {return new KaxTagOfficialAudioFileURL(*this);}
};
class MATROSKA_DLL_API KaxTagOfficialAudioSourceURL : public EbmlString {
public:
KaxTagOfficialAudioSourceURL() {}
KaxTagOfficialAudioSourceURL(const KaxTagOfficialAudioSourceURL & ElementToClone) :EbmlString(ElementToClone) {}
static EbmlElement & Create() {return *(new KaxTagOfficialAudioSourceURL);}
const EbmlCallbacks & Generic() const {return ClassInfos;}
static const EbmlCallbacks ClassInfos;
operator const EbmlId &() const {return ClassInfos.GlobalId;}
EbmlElement * Clone() const {return new KaxTagOfficialAudioSourceURL(*this);}
};
class MATROSKA_DLL_API KaxTagOriginalDimensions : public EbmlString {
public:
KaxTagOriginalDimensions() {}
KaxTagOriginalDimensions(const KaxTagOriginalDimensions & ElementToClone) :EbmlString(ElementToClone) {}
static EbmlElement & Create() {return *(new KaxTagOriginalDimensions);}
const EbmlCallbacks & Generic() const {return ClassInfos;}
static const EbmlCallbacks ClassInfos;
operator const EbmlId &() const {return ClassInfos.GlobalId;}
EbmlElement * Clone() const {return new KaxTagOriginalDimensions(*this);}
};
class MATROSKA_DLL_API KaxTagOriginalMediaType : public EbmlUnicodeString {
public:
KaxTagOriginalMediaType() {}
KaxTagOriginalMediaType(const KaxTagOriginalMediaType & ElementToClone) :EbmlUnicodeString(ElementToClone) {}
static EbmlElement & Create() {return *(new KaxTagOriginalMediaType);}
const EbmlCallbacks & Generic() const {return ClassInfos;}
static const EbmlCallbacks ClassInfos;
operator const EbmlId &() const {return ClassInfos.GlobalId;}
EbmlElement * Clone() const {return new KaxTagOriginalMediaType(*this);}
};
class MATROSKA_DLL_API KaxTagPlayCounter : public EbmlUInteger {
public:
KaxTagPlayCounter() {}
KaxTagPlayCounter(const KaxTagPlayCounter & ElementToClone) :EbmlUInteger(ElementToClone) {}
static EbmlElement & Create() {return *(new KaxTagPlayCounter);}
const EbmlCallbacks & Generic() const {return ClassInfos;}
static const EbmlCallbacks ClassInfos;
operator const EbmlId &() const {return ClassInfos.GlobalId;}
EbmlElement * Clone() const {return new KaxTagPlayCounter(*this);}
};
class MATROSKA_DLL_API KaxTagPlaylistDelay : public EbmlUInteger {
public:
KaxTagPlaylistDelay() {}
KaxTagPlaylistDelay(const KaxTagPlaylistDelay & ElementToClone) :EbmlUInteger(ElementToClone) {}
static EbmlElement & Create() {return *(new KaxTagPlaylistDelay);}
const EbmlCallbacks & Generic() const {return ClassInfos;}
static const EbmlCallbacks ClassInfos;
operator const EbmlId &() const {return ClassInfos.GlobalId;}
EbmlElement * Clone() const {return new KaxTagPlaylistDelay(*this);}
};
class MATROSKA_DLL_API KaxTagPopularimeter : public EbmlSInteger {
public:
KaxTagPopularimeter() {}
KaxTagPopularimeter(const KaxTagPopularimeter & ElementToClone) :EbmlSInteger(ElementToClone) {}
static EbmlElement & Create() {return *(new KaxTagPopularimeter);}
const EbmlCallbacks & Generic() const {return ClassInfos;}
static const EbmlCallbacks ClassInfos;
operator const EbmlId &() const {return ClassInfos.GlobalId;}
EbmlElement * Clone() const {return new KaxTagPopularimeter(*this);}
};
class MATROSKA_DLL_API KaxTagProduct : public EbmlUnicodeString {
public:
KaxTagProduct() {}
KaxTagProduct(const KaxTagProduct & ElementToClone) :EbmlUnicodeString(ElementToClone) {}
static EbmlElement & Create() {return *(new KaxTagProduct);}
const EbmlCallbacks & Generic() const {return ClassInfos;}
static const EbmlCallbacks ClassInfos;
operator const EbmlId &() const {return ClassInfos.GlobalId;}
EbmlElement * Clone() const {return new KaxTagProduct(*this);}
};
class MATROSKA_DLL_API KaxTagRating : public EbmlBinary {
public:
KaxTagRating() {}
KaxTagRating(const KaxTagRating & ElementToClone) :EbmlBinary(ElementToClone){}
static EbmlElement & Create() {return *(new KaxTagRating);}
bool ValidateSize() const {return true;} // we don't mind about what's inside
const EbmlCallbacks & Generic() const {return ClassInfos;}
static const EbmlCallbacks ClassInfos;
operator const EbmlId &() const {return ClassInfos.GlobalId;}
EbmlElement * Clone() const {return new KaxTagRating(*this);}
};
class MATROSKA_DLL_API KaxTagRecordLocation : public EbmlString {
public:
KaxTagRecordLocation() {}
KaxTagRecordLocation(const KaxTagRecordLocation & ElementToClone) :EbmlString(ElementToClone) {}
static EbmlElement & Create() {return *(new KaxTagRecordLocation);}
const EbmlCallbacks & Generic() const {return ClassInfos;}
static const EbmlCallbacks ClassInfos;
operator const EbmlId &() const {return ClassInfos.GlobalId;}
EbmlElement * Clone() const {return new KaxTagRecordLocation(*this);}
};
class MATROSKA_DLL_API KaxTagSetPart : public EbmlUInteger {
public:
KaxTagSetPart() {}
KaxTagSetPart(const KaxTagSetPart & ElementToClone) :EbmlUInteger(ElementToClone) {}
static EbmlElement & Create() {return *(new KaxTagSetPart);}
const EbmlCallbacks & Generic() const {return ClassInfos;}
static const EbmlCallbacks ClassInfos;
operator const EbmlId &() const {return ClassInfos.GlobalId;}
EbmlElement * Clone() const {return new KaxTagSetPart(*this);}
};
class MATROSKA_DLL_API KaxTagSource : public EbmlUnicodeString {
public:
KaxTagSource() {}
KaxTagSource(const KaxTagSource & ElementToClone) :EbmlUnicodeString(ElementToClone) {}
static EbmlElement & Create() {return *(new KaxTagSource);}
const EbmlCallbacks & Generic() const {return ClassInfos;}
static const EbmlCallbacks ClassInfos;
operator const EbmlId &() const {return ClassInfos.GlobalId;}
EbmlElement * Clone() const {return new KaxTagSource(*this);}
};
class MATROSKA_DLL_API KaxTagSourceForm : public EbmlUnicodeString {
public:
KaxTagSourceForm() {}
KaxTagSourceForm(const KaxTagSourceForm & ElementToClone) :EbmlUnicodeString(ElementToClone) {}
static EbmlElement & Create() {return *(new KaxTagSourceForm);}
const EbmlCallbacks & Generic() const {return ClassInfos;}
static const EbmlCallbacks ClassInfos;
operator const EbmlId &() const {return ClassInfos.GlobalId;}
EbmlElement * Clone() const {return new KaxTagSourceForm(*this);}
};
class MATROSKA_DLL_API KaxTagSubGenre : public EbmlString {
public:
KaxTagSubGenre() {}
KaxTagSubGenre(const KaxTagSubGenre & ElementToClone) :EbmlString(ElementToClone) {}
static EbmlElement & Create() {return *(new KaxTagSubGenre);}
const EbmlCallbacks & Generic() const {return ClassInfos;}
static const EbmlCallbacks ClassInfos;
operator const EbmlId &() const {return ClassInfos.GlobalId;}
EbmlElement * Clone() const {return new KaxTagSubGenre(*this);}
};
class MATROSKA_DLL_API KaxTagSubject : public EbmlUnicodeString {
public:
KaxTagSubject() {}
KaxTagSubject(const KaxTagSubject & ElementToClone) :EbmlUnicodeString(ElementToClone) {}
static EbmlElement & Create() {return *(new KaxTagSubject);}
const EbmlCallbacks & Generic() const {return ClassInfos;}
static const EbmlCallbacks ClassInfos;
operator const EbmlId &() const {return ClassInfos.GlobalId;}
EbmlElement * Clone() const {return new KaxTagSubject(*this);}
};
class MATROSKA_DLL_API KaxTagUnsynchronisedText : public EbmlUnicodeString {
public:
KaxTagUnsynchronisedText() {}
KaxTagUnsynchronisedText(const KaxTagUnsynchronisedText & ElementToClone) :EbmlUnicodeString(ElementToClone) {}
static EbmlElement & Create() {return *(new KaxTagUnsynchronisedText);}
const EbmlCallbacks & Generic() const {return ClassInfos;}
static const EbmlCallbacks ClassInfos;
operator const EbmlId &() const {return ClassInfos.GlobalId;}
EbmlElement * Clone() const {return new KaxTagUnsynchronisedText(*this);}
};
class MATROSKA_DLL_API KaxTagUserDefinedURL : public EbmlString {
public:
KaxTagUserDefinedURL() {}
KaxTagUserDefinedURL(const KaxTagUserDefinedURL & ElementToClone) :EbmlString(ElementToClone) {}
static EbmlElement & Create() {return *(new KaxTagUserDefinedURL);}
const EbmlCallbacks & Generic() const {return ClassInfos;}
static const EbmlCallbacks ClassInfos;
operator const EbmlId &() const {return ClassInfos.GlobalId;}
EbmlElement * Clone() const {return new KaxTagUserDefinedURL(*this);}
};
class MATROSKA_DLL_API KaxTagVideoGenre : public EbmlBinary {
public:
KaxTagVideoGenre() {}
KaxTagVideoGenre(const KaxTagVideoGenre & ElementToClone) :EbmlBinary(ElementToClone){}
static EbmlElement & Create() {return *(new KaxTagVideoGenre);}
bool ValidateSize() const {return (Size >= 2);}
const EbmlCallbacks & Generic() const {return ClassInfos;}
static const EbmlCallbacks ClassInfos;
operator const EbmlId &() const {return ClassInfos.GlobalId;}
EbmlElement * Clone() const {return new KaxTagVideoGenre(*this);}
};
class MATROSKA_DLL_API KaxTagSimple : public EbmlMaster {
public:
KaxTagSimple();
KaxTagSimple(const KaxTagSimple & ElementToClone) :EbmlMaster(ElementToClone) {}
static EbmlElement & Create() {return *(new KaxTagSimple);}
const EbmlCallbacks & Generic() const {return ClassInfos;}
static const EbmlCallbacks ClassInfos;
operator const EbmlId &() const {return ClassInfos.GlobalId;}
EbmlElement * Clone() const {return new KaxTagSimple(*this);}
};
class MATROSKA_DLL_API KaxTagName : public EbmlUnicodeString {
public:
KaxTagName() {}
KaxTagName(const KaxTagName & ElementToClone) :EbmlUnicodeString(ElementToClone) {}
static EbmlElement & Create() {return *(new KaxTagName);}
const EbmlCallbacks & Generic() const {return ClassInfos;}
static const EbmlCallbacks ClassInfos;
operator const EbmlId &() const {return ClassInfos.GlobalId;}
EbmlElement * Clone() const {return new KaxTagName(*this);}
};
class MATROSKA_DLL_API KaxTagLangue : public EbmlString {
public:
KaxTagLangue(): EbmlString("und") {}
KaxTagLangue(const KaxTagLangue & ElementToClone) :EbmlString(ElementToClone) {}
static EbmlElement & Create() {return *(new KaxTagLangue);}
const EbmlCallbacks & Generic() const {return ClassInfos;}
static const EbmlCallbacks ClassInfos;
operator const EbmlId &() const {return ClassInfos.GlobalId;}
EbmlElement * Clone() const {return new KaxTagLangue(*this);}
};
class MATROSKA_DLL_API KaxTagDefault : public EbmlUInteger {
public:
KaxTagDefault() :EbmlUInteger(1) {}
KaxTagDefault(const KaxTagTrackUID & ElementToClone) :EbmlUInteger(ElementToClone) {}
static EbmlElement & Create() {return *(new KaxTagDefault);}
const EbmlCallbacks & Generic() const {return ClassInfos;}
static const EbmlCallbacks ClassInfos;
operator const EbmlId &() const {return ClassInfos.GlobalId;}
EbmlElement * Clone() const {return new KaxTagDefault(*this);}
};
class MATROSKA_DLL_API KaxTagString : public EbmlUnicodeString {
public:
KaxTagString() {}
KaxTagString(const KaxTagString & ElementToClone) :EbmlUnicodeString(ElementToClone) {}
static EbmlElement & Create() {return *(new KaxTagString);}
const EbmlCallbacks & Generic() const {return ClassInfos;}
static const EbmlCallbacks ClassInfos;
operator const EbmlId &() const {return ClassInfos.GlobalId;}
EbmlElement * Clone() const {return new KaxTagString(*this);}
};
class MATROSKA_DLL_API KaxTagBinary : public EbmlBinary {
public:
KaxTagBinary() {}
KaxTagBinary(const KaxTagBinary & ElementToClone) :EbmlBinary(ElementToClone){}
static EbmlElement & Create() {return *(new KaxTagBinary);}
bool ValidateSize() const {return (Size >= 0);}
const EbmlCallbacks & Generic() const {return ClassInfos;}
static const EbmlCallbacks ClassInfos;
operator const EbmlId &() const {return ClassInfos.GlobalId;}
EbmlElement * Clone() const {return new KaxTagBinary(*this);}
};
END_LIBMATROSKA_NAMESPACE
#endif // LIBMATROSKA_TAG_H

745
matroska/KaxTagMulti.h Normal file
View File

@ -0,0 +1,745 @@
/****************************************************************************
** libmatroska : parse Matroska files, see http://www.matroska.org/
**
** <file/class MATROSKA_DLL_API description>
**
** Copyright (C) 2002-2004 Steve Lhomme. All rights reserved.
**
** This file is part of libmatroska.
**
** This library is free software; you can redistribute it and/or
** modify it under the terms of the GNU Lesser General Public
** License as published by the Free Software Foundation; either
** version 2.1 of the License, or (at your option) any later version.
**
** This library is distributed in the hope that it will be useful,
** but WITHOUT ANY WARRANTY; without even the implied warranty of
** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
** Lesser General Public License for more details.
**
** You should have received a copy of the GNU Lesser General Public
** License along with this library; if not, write to the Free Software
** Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
**
** See http://www.matroska.org/license/lgpl/ for LGPL licensing information.**
** Contact license@matroska.org if any conditions of this licensing are
** not clear to you.
**
**********************************************************************/
/*!
\file
\version \$Id: KaxTagMulti.h,v 1.9 2004/04/14 23:26:17 robux4 Exp $
\author Jory Stone <jcsston @ toughguy.net>
\author Steve Lhomme <robux4 @ users.sf.net>
*/
#ifndef LIBMATROSKA_TAGMULTI_H
#define LIBMATROSKA_TAGMULTI_H
#include "matroska/KaxTypes.h"
#include "ebml/EbmlMaster.h"
#include "ebml/EbmlDate.h"
#include "ebml/EbmlFloat.h"
#include "ebml/EbmlSInteger.h"
#include "ebml/EbmlUInteger.h"
#include "ebml/EbmlString.h"
#include "ebml/EbmlUnicodeString.h"
#include "ebml/EbmlBinary.h"
using namespace LIBEBML_NAMESPACE;
START_LIBMATROSKA_NAMESPACE
enum KaxTagMultiCommercialTypes {
KaxTagMultiCommercialType_FilePurchase = 1, //Information on where to purchase this file. This is akin to the WPAY tag in ID3.
KaxTagMultiCommercialType_ItemPurchase, //Information on where to purchase this album. This is akin to the WCOM tag in ID3.
KaxTagMultiCommercialType_Owner //Information on the purchase that occurred for this file. This is akin to the OWNE tag in ID3.
};
enum KaxTagMultiDateTypes {
KaxTagMultiDateType_EncodingDate = 1, //The time that the encoding of this item was completed. This is akin to the TDEN tag in ID3.
KaxTagMultiDateType_RecordingDate, //The time that the recording began, and finished. This is akin to the TDRC tag in ID3.
KaxTagMultiDateType_ReleaseDate, //The time that the item was originaly released. This is akin to the TDRL tag in ID3.
KaxTagMultiDateType_OriginalReleaseDate, //The time that the item was originaly released if it is a remake. This is akin to the TDOR tag in ID3.
KaxTagMultiDateType_TaggingDate, //The time that the tags were done for this item. This is akin to the TDTG tag in ID3.
KaxTagMultiDateType_DigitizingDate //The time that the item was tranfered to a digital medium. This is akin to the IDIT tag in RIFF
};
enum KaxTagMultiEntitiesTypes {
KaxTagMultiEntitiesType_LyricistTextWriter = 1, //The person that wrote the words/script for this item. This is akin to the TEXT tag in ID3.
KaxTagMultiEntitiesType_Composer, //The name of the composer of this item. This is akin to the TCOM tag in ID3.
KaxTagMultiEntitiesType_LeadPerformerSoloist, //This is akin to the TPE1 tag in ID3.
KaxTagMultiEntitiesType_BandOrchestraAccompaniment, //This is akin to the TPE2 tag in ID3.
KaxTagMultiEntitiesType_OriginalLyricistTextWriter, //This is akin to the TOLY tag in ID3.
KaxTagMultiEntitiesType_OriginalArtistPerformer, //This is akin to the TOPE tag in ID3.
KaxTagMultiEntitiesType_OriginalAlbumMovieShowTitle, //This is akin to the TOAL tag in ID3.
KaxTagMultiEntitiesType_ConductorPerformerRefinement, //This is akin to the TPE3 tag in ID3.
KaxTagMultiEntitiesType_InterpretedRemixedBy, //This is akin to the TPE4 tag in ID3.
KaxTagMultiEntitiesType_Director, //This is akin to the IART tag in RIFF
KaxTagMultiEntitiesType_ProducedBy, //This is akin to the IPRO tag in Extended RIFF
KaxTagMultiEntitiesType_Cinematographer, //This is akin to the ICNM tag in Extended RIFF
KaxTagMultiEntitiesType_ProductionDesigner, //This is akin to the IPDS tag in Extended RIFF
KaxTagMultiEntitiesType_CostumeDesigner, //This is akin to the ICDS tag in Extended RIFF
KaxTagMultiEntitiesType_ProductionStudio, //This is akin to the ISTD tag in Extended RIFF
KaxTagMultiEntitiesType_DistributedBy, //This is akin to the IDST tag in Extended RIFF
KaxTagMultiEntitiesType_CommissionedBy, //This is akin to the ICMS tag in RIFF
KaxTagMultiEntitiesType_Engineer, //This is akin to the IENG tag in RIFF
KaxTagMultiEntitiesType_EditedBy, //This is akin to the IEDT tag in Extended RIFF
KaxTagMultiEntitiesType_EncodedBy, //This is akin to the TENC tag in ID3.
KaxTagMultiEntitiesType_RippedBy, //This is akin to the IRIP tag in Extended RIFF
KaxTagMultiEntitiesType_InvolvedPeopleList, //A very general tag for everyone else that wants to be listed. This is akin to the TMCL tag in ID3.
KaxTagMultiEntitiesType_InternetRadioStationName, //This is akin to the TSRN tag in ID3.
KaxTagMultiEntitiesType_Publisher //This is akin to the TPUB tag in ID3.
};
enum KaxTagMultiIdentifierTypes {
KaxTagMultiIdentifierType_ISRC = 1, //String, The International Standard Recording Code
KaxTagMultiIdentifierType_CDIdentifier, //Binary, This is a binary dump of the TOC of the CDROM that this item was taken from. This holds the same information as the MCDI in ID3.
KaxTagMultiIdentifierType_ISBN, //String, International Standard Book Number
KaxTagMultiIdentifierType_Catalog, //String, sometimes the EAN/UPC, often some letters followed by some numbers
KaxTagMultiIdentifierType_EAN, //String, EAN-13 bar code identifier
KaxTagMultiIdentifierType_UPC, //String, UPC-A bar code identifier
KaxTagMultiIdentifierType_LabelCode, //String, Typically printed as ________ (LC) xxxx) ~~~~~~~~ or _________ (LC) 0xxxx) ~~~~~~~~~ on CDs medias or covers, where xxxx is a 4-digit number.
KaxTagMultiIdentifierType_LCCN, //String, Library of Congress Control Number
KaxTagMultiIdentifierType_UniqueFileIdentifier, //Binary, This used for a dump of the UFID field in ID3. This field would only be used if the item was pulled from an MP3.
CDROM_CD_TEXT_PACK_TOC_INFO2 //Binary
};
enum KaxTagMultiLegalTypes {
KaxTagMultiLegalType_Copyright = 1, //The copyright information as per the copyright holder. This is akin to the TCOP tag in ID3.
KaxTagMultiLegalType_ProductionCopyright, //The copyright information as per the production copyright holder. This is akin to the TPRO tag in ID3.
KaxTagMultiLegalType_TermsOfUse //The terms of use for this item. This is akin to the USER tag in ID3.
};
enum KaxTagMultiTitleTypes {
KaxTagMultiTitleType_TrackTitle = 1,
//The title of this item. In the case of a track, the Name element should be identical to the Name element.
//For example, for music you might label this "Canon in D", or for video's audio track you might use "English 5.1" This is akin to the TIT2 tag in ID3.
KaxTagMultiTitleType_AlbumMovieShowTitle,
//This is the name given to a grouping of tracks and/or chapters.
//For example, all video, audio, and subtitle tracks for a movie would be grouped under this and be given the name of the movie.
//All tracks for a particular CD would be grouped together under the title of the CD, or if all tracks for a CD were recorded as a single track, seperated by chapters, the same would apply.
//You could use this to label episode 3 of The Simpsons. This is akin to the TALB tag in ID3.
KaxTagMultiTitleType_SetTitle, //This would be used to label a set of ID 2. For example, season 13 of The Simpsons.
KaxTagMultiTitleType_Series //This would be used to label a set of ID 3. For example, The Simpsons.
};
class MATROSKA_DLL_API KaxTagMultiComment : public EbmlMaster {
public:
KaxTagMultiComment();
KaxTagMultiComment(const KaxTagMultiComment & ElementToClone) :EbmlMaster(ElementToClone) {}
static EbmlElement & Create() {return *(new KaxTagMultiComment);}
const EbmlCallbacks & Generic() const {return ClassInfos;}
static const EbmlCallbacks ClassInfos;
operator const EbmlId &() const {return ClassInfos.GlobalId;}
EbmlElement * Clone() const {return new KaxTagMultiComment(*this);}
};
class MATROSKA_DLL_API KaxTagMultiCommentName : public EbmlString {
public:
KaxTagMultiCommentName() {}
KaxTagMultiCommentName(const KaxTagMultiCommentName & ElementToClone) :EbmlString(ElementToClone) {}
static EbmlElement & Create() {return *(new KaxTagMultiCommentName);}
const EbmlCallbacks & Generic() const {return ClassInfos;}
static const EbmlCallbacks ClassInfos;
operator const EbmlId &() const {return ClassInfos.GlobalId;}
EbmlElement * Clone() const {return new KaxTagMultiCommentName(*this);}
};
class MATROSKA_DLL_API KaxTagMultiCommentComments : public EbmlUnicodeString {
public:
KaxTagMultiCommentComments() {}
KaxTagMultiCommentComments(const KaxTagMultiCommentComments & ElementToClone) :EbmlUnicodeString(ElementToClone) {}
static EbmlElement & Create() {return *(new KaxTagMultiCommentComments);}
const EbmlCallbacks & Generic() const {return ClassInfos;}
static const EbmlCallbacks ClassInfos;
operator const EbmlId &() const {return ClassInfos.GlobalId;}
EbmlElement * Clone() const {return new KaxTagMultiCommentComments(*this);}
};
class MATROSKA_DLL_API KaxTagMultiCommentLanguage : public EbmlString {
public:
KaxTagMultiCommentLanguage() {}
KaxTagMultiCommentLanguage(const KaxTagMultiCommentLanguage & ElementToClone) :EbmlString(ElementToClone) {}
static EbmlElement & Create() {return *(new KaxTagMultiCommentLanguage);}
const EbmlCallbacks & Generic() const {return ClassInfos;}
static const EbmlCallbacks ClassInfos;
operator const EbmlId &() const {return ClassInfos.GlobalId;}
EbmlElement * Clone() const {return new KaxTagMultiCommentLanguage(*this);}
};
class MATROSKA_DLL_API KaxTagMultiCommercial : public EbmlMaster {
public:
KaxTagMultiCommercial();
KaxTagMultiCommercial(const KaxTagMultiCommercial & ElementToClone) :EbmlMaster(ElementToClone) {}
static EbmlElement & Create() {return *(new KaxTagMultiCommercial);}
const EbmlCallbacks & Generic() const {return ClassInfos;}
static const EbmlCallbacks ClassInfos;
operator const EbmlId &() const {return ClassInfos.GlobalId;}
EbmlElement * Clone() const {return new KaxTagMultiCommercial(*this);}
};
class MATROSKA_DLL_API KaxTagCommercial : public EbmlMaster {
public:
KaxTagCommercial();
KaxTagCommercial(const KaxTagCommercial & ElementToClone) :EbmlMaster(ElementToClone) {}
static EbmlElement & Create() {return *(new KaxTagCommercial);}
const EbmlCallbacks & Generic() const {return ClassInfos;}
static const EbmlCallbacks ClassInfos;
operator const EbmlId &() const {return ClassInfos.GlobalId;}
EbmlElement * Clone() const {return new KaxTagCommercial(*this);}
};
class MATROSKA_DLL_API KaxTagMultiCommercialType : public EbmlUInteger {
public:
KaxTagMultiCommercialType() {}
KaxTagMultiCommercialType(const KaxTagMultiCommercialType & ElementToClone) :EbmlUInteger(ElementToClone) {}
static EbmlElement & Create() {return *(new KaxTagMultiCommercialType);}
const EbmlCallbacks & Generic() const {return ClassInfos;}
static const EbmlCallbacks ClassInfos;
operator const EbmlId &() const {return ClassInfos.GlobalId;}
EbmlElement * Clone() const {return new KaxTagMultiCommercialType(*this);}
};
class MATROSKA_DLL_API KaxTagMultiCommercialAddress : public EbmlUnicodeString {
public:
KaxTagMultiCommercialAddress() {}
KaxTagMultiCommercialAddress(const KaxTagMultiCommercialAddress & ElementToClone) :EbmlUnicodeString(ElementToClone) {}
static EbmlElement & Create() {return *(new KaxTagMultiCommercialAddress);}
const EbmlCallbacks & Generic() const {return ClassInfos;}
static const EbmlCallbacks ClassInfos;
operator const EbmlId &() const {return ClassInfos.GlobalId;}
EbmlElement * Clone() const {return new KaxTagMultiCommercialAddress(*this);}
};
class MATROSKA_DLL_API KaxTagMultiCommercialURL : public EbmlString {
public:
KaxTagMultiCommercialURL() {}
KaxTagMultiCommercialURL(const KaxTagMultiCommercialURL & ElementToClone) :EbmlString(ElementToClone) {}
static EbmlElement & Create() {return *(new KaxTagMultiCommercialURL);}
const EbmlCallbacks & Generic() const {return ClassInfos;}
static const EbmlCallbacks ClassInfos;
operator const EbmlId &() const {return ClassInfos.GlobalId;}
EbmlElement * Clone() const {return new KaxTagMultiCommercialURL(*this);}
};
class MATROSKA_DLL_API KaxTagMultiCommercialEmail : public EbmlString {
public:
KaxTagMultiCommercialEmail() {}
KaxTagMultiCommercialEmail(const KaxTagMultiCommercialEmail & ElementToClone) :EbmlString(ElementToClone) {}
static EbmlElement & Create() {return *(new KaxTagMultiCommercialEmail);}
const EbmlCallbacks & Generic() const {return ClassInfos;}
static const EbmlCallbacks ClassInfos;
operator const EbmlId &() const {return ClassInfos.GlobalId;}
EbmlElement * Clone() const {return new KaxTagMultiCommercialEmail(*this);}
};
class MATROSKA_DLL_API KaxTagMultiPrice : public EbmlMaster {
public:
KaxTagMultiPrice();
KaxTagMultiPrice(const KaxTagMultiPrice & ElementToClone) :EbmlMaster(ElementToClone) {}
static EbmlElement & Create() {return *(new KaxTagMultiPrice);}
const EbmlCallbacks & Generic() const {return ClassInfos;}
static const EbmlCallbacks ClassInfos;
operator const EbmlId &() const {return ClassInfos.GlobalId;}
EbmlElement * Clone() const {return new KaxTagMultiPrice(*this);}
};
class MATROSKA_DLL_API KaxTagMultiPriceCurrency : public EbmlString {
public:
KaxTagMultiPriceCurrency() {}
KaxTagMultiPriceCurrency(const KaxTagMultiPriceCurrency & ElementToClone) :EbmlString(ElementToClone) {}
static EbmlElement & Create() {return *(new KaxTagMultiPriceCurrency);}
const EbmlCallbacks & Generic() const {return ClassInfos;}
static const EbmlCallbacks ClassInfos;
operator const EbmlId &() const {return ClassInfos.GlobalId;}
EbmlElement * Clone() const {return new KaxTagMultiPriceCurrency(*this);}
};
class MATROSKA_DLL_API KaxTagMultiPriceAmount : public EbmlFloat {
public:
KaxTagMultiPriceAmount() :EbmlFloat() {}
KaxTagMultiPriceAmount(const KaxTagMultiPriceAmount & ElementToClone) :EbmlFloat(ElementToClone) {}
static EbmlElement & Create() {return *(new KaxTagMultiPriceAmount);}
const EbmlCallbacks & Generic() const {return ClassInfos;}
static const EbmlCallbacks ClassInfos;
operator const EbmlId &() const {return ClassInfos.GlobalId;}
EbmlElement * Clone() const {return new KaxTagMultiPriceAmount(*this);}
};
class MATROSKA_DLL_API KaxTagMultiPricePriceDate : public EbmlDate {
public:
KaxTagMultiPricePriceDate() :EbmlDate() {}
KaxTagMultiPricePriceDate(const KaxTagMultiPricePriceDate & ElementToClone) :EbmlDate(ElementToClone) {}
static EbmlElement & Create() {return *(new KaxTagMultiPricePriceDate);}
const EbmlCallbacks & Generic() const {return ClassInfos;}
static const EbmlCallbacks ClassInfos;
operator const EbmlId &() const {return ClassInfos.GlobalId;}
EbmlElement * Clone() const {return new KaxTagMultiPricePriceDate(*this);}
};
class MATROSKA_DLL_API KaxTagMultiDate : public EbmlMaster {
public:
KaxTagMultiDate();
KaxTagMultiDate(const KaxTagMultiDate & ElementToClone) :EbmlMaster(ElementToClone) {}
static EbmlElement & Create() {return *(new KaxTagMultiDate);}
const EbmlCallbacks & Generic() const {return ClassInfos;}
static const EbmlCallbacks ClassInfos;
operator const EbmlId &() const {return ClassInfos.GlobalId;}
EbmlElement * Clone() const {return new KaxTagMultiDate(*this);}
};
class MATROSKA_DLL_API KaxTagDate : public EbmlMaster {
public:
KaxTagDate();
KaxTagDate(const KaxTagDate & ElementToClone) :EbmlMaster(ElementToClone) {}
static EbmlElement & Create() {return *(new KaxTagDate);}
const EbmlCallbacks & Generic() const {return ClassInfos;}
static const EbmlCallbacks ClassInfos;
operator const EbmlId &() const {return ClassInfos.GlobalId;}
EbmlElement * Clone() const {return new KaxTagDate(*this);}
};
class MATROSKA_DLL_API KaxTagMultiDateType : public EbmlUInteger {
public:
KaxTagMultiDateType() {}
KaxTagMultiDateType(const KaxTagMultiDateType & ElementToClone) :EbmlUInteger(ElementToClone) {}
static EbmlElement & Create() {return *(new KaxTagMultiDateType);}
const EbmlCallbacks & Generic() const {return ClassInfos;}
static const EbmlCallbacks ClassInfos;
operator const EbmlId &() const {return ClassInfos.GlobalId;}
EbmlElement * Clone() const {return new KaxTagMultiDateType(*this);}
};
class MATROSKA_DLL_API KaxTagMultiDateDateBegin : public EbmlDate {
public:
KaxTagMultiDateDateBegin() :EbmlDate() {}
KaxTagMultiDateDateBegin(const KaxTagMultiDateDateBegin & ElementToClone) :EbmlDate(ElementToClone) {}
static EbmlElement & Create() {return *(new KaxTagMultiDateDateBegin);}
const EbmlCallbacks & Generic() const {return ClassInfos;}
static const EbmlCallbacks ClassInfos;
operator const EbmlId &() const {return ClassInfos.GlobalId;}
EbmlElement * Clone() const {return new KaxTagMultiDateDateBegin(*this);}
};
class MATROSKA_DLL_API KaxTagMultiDateDateEnd : public EbmlDate {
public:
KaxTagMultiDateDateEnd() :EbmlDate() {}
KaxTagMultiDateDateEnd(const KaxTagMultiDateDateEnd & ElementToClone) :EbmlDate(ElementToClone) {}
static EbmlElement & Create() {return *(new KaxTagMultiDateDateEnd);}
const EbmlCallbacks & Generic() const {return ClassInfos;}
static const EbmlCallbacks ClassInfos;
operator const EbmlId &() const {return ClassInfos.GlobalId;}
EbmlElement * Clone() const {return new KaxTagMultiDateDateEnd(*this);}
};
class MATROSKA_DLL_API KaxTagMultiEntity : public EbmlMaster {
public:
KaxTagMultiEntity();
KaxTagMultiEntity(const KaxTagMultiEntity & ElementToClone) :EbmlMaster(ElementToClone) {}
static EbmlElement & Create() {return *(new KaxTagMultiEntity);}
const EbmlCallbacks & Generic() const {return ClassInfos;}
static const EbmlCallbacks ClassInfos;
operator const EbmlId &() const {return ClassInfos.GlobalId;}
EbmlElement * Clone() const {return new KaxTagMultiEntity(*this);}
};
class MATROSKA_DLL_API KaxTagEntity : public EbmlMaster {
public:
KaxTagEntity();
KaxTagEntity(const KaxTagEntity & ElementToClone) :EbmlMaster(ElementToClone) {}
static EbmlElement & Create() {return *(new KaxTagEntity);}
const EbmlCallbacks & Generic() const {return ClassInfos;}
static const EbmlCallbacks ClassInfos;
operator const EbmlId &() const {return ClassInfos.GlobalId;}
EbmlElement * Clone() const {return new KaxTagEntity(*this);}
};
class MATROSKA_DLL_API KaxTagMultiEntityType : public EbmlUInteger {
public:
KaxTagMultiEntityType() {}
KaxTagMultiEntityType(const KaxTagMultiEntityType & ElementToClone) :EbmlUInteger(ElementToClone) {}
static EbmlElement & Create() {return *(new KaxTagMultiEntityType);}
const EbmlCallbacks & Generic() const {return ClassInfos;}
static const EbmlCallbacks ClassInfos;
operator const EbmlId &() const {return ClassInfos.GlobalId;}
EbmlElement * Clone() const {return new KaxTagMultiEntityType(*this);}
};
class MATROSKA_DLL_API KaxTagMultiEntityName : public EbmlUnicodeString {
public:
KaxTagMultiEntityName() {}
KaxTagMultiEntityName(const KaxTagMultiEntityName & ElementToClone) :EbmlUnicodeString(ElementToClone) {}
static EbmlElement & Create() {return *(new KaxTagMultiEntityName);}
const EbmlCallbacks & Generic() const {return ClassInfos;}
static const EbmlCallbacks ClassInfos;
operator const EbmlId &() const {return ClassInfos.GlobalId;}
EbmlElement * Clone() const {return new KaxTagMultiEntityName(*this);}
};
class MATROSKA_DLL_API KaxTagMultiEntityAddress : public EbmlUnicodeString {
public:
KaxTagMultiEntityAddress() {}
KaxTagMultiEntityAddress(const KaxTagMultiEntityAddress & ElementToClone) :EbmlUnicodeString(ElementToClone) {}
static EbmlElement & Create() {return *(new KaxTagMultiEntityAddress);}
const EbmlCallbacks & Generic() const {return ClassInfos;}
static const EbmlCallbacks ClassInfos;
operator const EbmlId &() const {return ClassInfos.GlobalId;}
EbmlElement * Clone() const {return new KaxTagMultiEntityAddress(*this);}
};
class MATROSKA_DLL_API KaxTagMultiEntityURL : public EbmlString {
public:
KaxTagMultiEntityURL() {}
KaxTagMultiEntityURL(const KaxTagMultiEntityURL & ElementToClone) :EbmlString(ElementToClone) {}
static EbmlElement & Create() {return *(new KaxTagMultiEntityURL);}
const EbmlCallbacks & Generic() const {return ClassInfos;}
static const EbmlCallbacks ClassInfos;
operator const EbmlId &() const {return ClassInfos.GlobalId;}
EbmlElement * Clone() const {return new KaxTagMultiEntityURL(*this);}
};
class MATROSKA_DLL_API KaxTagMultiEntityEmail : public EbmlString {
public:
KaxTagMultiEntityEmail() {}
KaxTagMultiEntityEmail(const KaxTagMultiEntityEmail & ElementToClone) :EbmlString(ElementToClone) {}
static EbmlElement & Create() {return *(new KaxTagMultiEntityEmail);}
const EbmlCallbacks & Generic() const {return ClassInfos;}
static const EbmlCallbacks ClassInfos;
operator const EbmlId &() const {return ClassInfos.GlobalId;}
EbmlElement * Clone() const {return new KaxTagMultiEntityEmail(*this);}
};
class MATROSKA_DLL_API KaxTagMultiIdentifier : public EbmlMaster {
public:
KaxTagMultiIdentifier();
KaxTagMultiIdentifier(const KaxTagMultiIdentifier & ElementToClone) :EbmlMaster(ElementToClone) {}
static EbmlElement & Create() {return *(new KaxTagMultiIdentifier);}
const EbmlCallbacks & Generic() const {return ClassInfos;}
static const EbmlCallbacks ClassInfos;
operator const EbmlId &() const {return ClassInfos.GlobalId;}
EbmlElement * Clone() const {return new KaxTagMultiIdentifier(*this);}
};
class MATROSKA_DLL_API KaxTagIdentifier : public EbmlMaster {
public:
KaxTagIdentifier();
KaxTagIdentifier(const KaxTagIdentifier & ElementToClone) :EbmlMaster(ElementToClone) {}
static EbmlElement & Create() {return *(new KaxTagIdentifier);}
const EbmlCallbacks & Generic() const {return ClassInfos;}
static const EbmlCallbacks ClassInfos;
operator const EbmlId &() const {return ClassInfos.GlobalId;}
EbmlElement * Clone() const {return new KaxTagIdentifier(*this);}
};
class MATROSKA_DLL_API KaxTagMultiIdentifierType : public EbmlUInteger {
public:
KaxTagMultiIdentifierType() {}
KaxTagMultiIdentifierType(const KaxTagMultiIdentifierType & ElementToClone) :EbmlUInteger(ElementToClone) {}
static EbmlElement & Create() {return *(new KaxTagMultiIdentifierType);}
const EbmlCallbacks & Generic() const {return ClassInfos;}
static const EbmlCallbacks ClassInfos;
operator const EbmlId &() const {return ClassInfos.GlobalId;}
EbmlElement * Clone() const {return new KaxTagMultiIdentifierType(*this);}
};
class MATROSKA_DLL_API KaxTagMultiIdentifierBinary : public EbmlBinary {
public:
KaxTagMultiIdentifierBinary() {}
KaxTagMultiIdentifierBinary(const KaxTagMultiIdentifierBinary & ElementToClone) :EbmlBinary(ElementToClone){}
static EbmlElement & Create() {return *(new KaxTagMultiIdentifierBinary);}
bool ValidateSize() const {return true;} // we don't mind about what's inside
const EbmlCallbacks & Generic() const {return ClassInfos;}
static const EbmlCallbacks ClassInfos;
operator const EbmlId &() const {return ClassInfos.GlobalId;}
EbmlElement * Clone() const {return new KaxTagMultiIdentifierBinary(*this);}
};
class MATROSKA_DLL_API KaxTagMultiIdentifierString : public EbmlUnicodeString {
public:
KaxTagMultiIdentifierString() {}
KaxTagMultiIdentifierString(const KaxTagMultiIdentifierString & ElementToClone) :EbmlUnicodeString(ElementToClone) {}
static EbmlElement & Create() {return *(new KaxTagMultiIdentifierString);}
const EbmlCallbacks & Generic() const {return ClassInfos;}
static const EbmlCallbacks ClassInfos;
operator const EbmlId &() const {return ClassInfos.GlobalId;}
EbmlElement * Clone() const {return new KaxTagMultiIdentifierString(*this);}
};
class MATROSKA_DLL_API KaxTagMultiLegal : public EbmlMaster {
public:
KaxTagMultiLegal();
KaxTagMultiLegal(const KaxTagMultiLegal & ElementToClone) :EbmlMaster(ElementToClone) {}
static EbmlElement & Create() {return *(new KaxTagMultiLegal);}
const EbmlCallbacks & Generic() const {return ClassInfos;}
static const EbmlCallbacks ClassInfos;
operator const EbmlId &() const {return ClassInfos.GlobalId;}
EbmlElement * Clone() const {return new KaxTagMultiLegal(*this);}
};
class MATROSKA_DLL_API KaxTagLegal : public EbmlMaster {
public:
KaxTagLegal();
KaxTagLegal(const KaxTagLegal & ElementToClone) :EbmlMaster(ElementToClone) {}
static EbmlElement & Create() {return *(new KaxTagLegal);}
const EbmlCallbacks & Generic() const {return ClassInfos;}
static const EbmlCallbacks ClassInfos;
operator const EbmlId &() const {return ClassInfos.GlobalId;}
EbmlElement * Clone() const {return new KaxTagLegal(*this);}
};
class MATROSKA_DLL_API KaxTagMultiLegalType : public EbmlUInteger {
public:
KaxTagMultiLegalType() {}
KaxTagMultiLegalType(const KaxTagMultiLegalType & ElementToClone) :EbmlUInteger(ElementToClone) {}
static EbmlElement & Create() {return *(new KaxTagMultiLegalType);}
const EbmlCallbacks & Generic() const {return ClassInfos;}
static const EbmlCallbacks ClassInfos;
operator const EbmlId &() const {return ClassInfos.GlobalId;}
EbmlElement * Clone() const {return new KaxTagMultiLegalType(*this);}
};
class MATROSKA_DLL_API KaxTagMultiLegalContent : public EbmlUnicodeString {
public:
KaxTagMultiLegalContent() {}
KaxTagMultiLegalContent(const KaxTagMultiLegalContent & ElementToClone) :EbmlUnicodeString(ElementToClone) {}
static EbmlElement & Create() {return *(new KaxTagMultiLegalContent);}
const EbmlCallbacks & Generic() const {return ClassInfos;}
static const EbmlCallbacks ClassInfos;
operator const EbmlId &() const {return ClassInfos.GlobalId;}
EbmlElement * Clone() const {return new KaxTagMultiLegalContent(*this);}
};
class MATROSKA_DLL_API KaxTagMultiLegalURL : public EbmlString {
public:
KaxTagMultiLegalURL() {}
KaxTagMultiLegalURL(const KaxTagMultiLegalURL & ElementToClone) :EbmlString(ElementToClone) {}
static EbmlElement & Create() {return *(new KaxTagMultiLegalURL);}
const EbmlCallbacks & Generic() const {return ClassInfos;}
static const EbmlCallbacks ClassInfos;
operator const EbmlId &() const {return ClassInfos.GlobalId;}
EbmlElement * Clone() const {return new KaxTagMultiLegalURL(*this);}
};
class MATROSKA_DLL_API KaxTagMultiLegalAddress : public EbmlUnicodeString {
public:
KaxTagMultiLegalAddress() {}
KaxTagMultiLegalAddress(const KaxTagMultiLegalAddress & ElementToClone) :EbmlUnicodeString(ElementToClone) {}
static EbmlElement & Create() {return *(new KaxTagMultiLegalAddress);}
const EbmlCallbacks & Generic() const {return ClassInfos;}
static const EbmlCallbacks ClassInfos;
operator const EbmlId &() const {return ClassInfos.GlobalId;}
EbmlElement * Clone() const {return new KaxTagMultiLegalAddress(*this);}
};
class MATROSKA_DLL_API KaxTagMultiTitle : public EbmlMaster {
public:
KaxTagMultiTitle();
KaxTagMultiTitle(const KaxTagMultiTitle & ElementToClone) :EbmlMaster(ElementToClone) {}
static EbmlElement & Create() {return *(new KaxTagMultiTitle);}
const EbmlCallbacks & Generic() const {return ClassInfos;}
static const EbmlCallbacks ClassInfos;
operator const EbmlId &() const {return ClassInfos.GlobalId;}
EbmlElement * Clone() const {return new KaxTagMultiTitle(*this);}
};
class MATROSKA_DLL_API KaxTagTitle : public EbmlMaster {
public:
KaxTagTitle();
KaxTagTitle(const KaxTagTitle & ElementToClone) :EbmlMaster(ElementToClone) {}
static EbmlElement & Create() {return *(new KaxTagTitle);}
const EbmlCallbacks & Generic() const {return ClassInfos;}
static const EbmlCallbacks ClassInfos;
operator const EbmlId &() const {return ClassInfos.GlobalId;}
EbmlElement * Clone() const {return new KaxTagTitle(*this);}
};
class MATROSKA_DLL_API KaxTagMultiTitleType : public EbmlUInteger {
public:
KaxTagMultiTitleType() {}
KaxTagMultiTitleType(const KaxTagMultiTitleType & ElementToClone) :EbmlUInteger(ElementToClone) {}
static EbmlElement & Create() {return *(new KaxTagMultiTitleType);}
const EbmlCallbacks & Generic() const {return ClassInfos;}
static const EbmlCallbacks ClassInfos;
operator const EbmlId &() const {return ClassInfos.GlobalId;}
EbmlElement * Clone() const {return new KaxTagMultiTitleType(*this);}
};
class MATROSKA_DLL_API KaxTagMultiTitleName : public EbmlUnicodeString {
public:
KaxTagMultiTitleName() {}
KaxTagMultiTitleName(const KaxTagMultiTitleName & ElementToClone) :EbmlUnicodeString(ElementToClone) {}
static EbmlElement & Create() {return *(new KaxTagMultiTitleName);}
const EbmlCallbacks & Generic() const {return ClassInfos;}
static const EbmlCallbacks ClassInfos;
operator const EbmlId &() const {return ClassInfos.GlobalId;}
EbmlElement * Clone() const {return new KaxTagMultiTitleName(*this);}
};
class MATROSKA_DLL_API KaxTagMultiTitleSubTitle : public EbmlUnicodeString {
public:
KaxTagMultiTitleSubTitle() {}
KaxTagMultiTitleSubTitle(const KaxTagMultiTitleSubTitle & ElementToClone) :EbmlUnicodeString(ElementToClone) {}
static EbmlElement & Create() {return *(new KaxTagMultiTitleSubTitle);}
const EbmlCallbacks & Generic() const {return ClassInfos;}
static const EbmlCallbacks ClassInfos;
operator const EbmlId &() const {return ClassInfos.GlobalId;}
EbmlElement * Clone() const {return new KaxTagMultiTitleSubTitle(*this);}
};
class MATROSKA_DLL_API KaxTagMultiTitleEdition : public EbmlUnicodeString {
public:
KaxTagMultiTitleEdition() {}
KaxTagMultiTitleEdition(const KaxTagMultiTitleEdition & ElementToClone) :EbmlUnicodeString(ElementToClone) {}
static EbmlElement & Create() {return *(new KaxTagMultiTitleEdition);}
const EbmlCallbacks & Generic() const {return ClassInfos;}
static const EbmlCallbacks ClassInfos;
operator const EbmlId &() const {return ClassInfos.GlobalId;}
EbmlElement * Clone() const {return new KaxTagMultiTitleEdition(*this);}
};
class MATROSKA_DLL_API KaxTagMultiTitleAddress : public EbmlUnicodeString {
public:
KaxTagMultiTitleAddress() {}
KaxTagMultiTitleAddress(const KaxTagMultiTitleAddress & ElementToClone) :EbmlUnicodeString(ElementToClone) {}
static EbmlElement & Create() {return *(new KaxTagMultiTitleAddress);}
const EbmlCallbacks & Generic() const {return ClassInfos;}
static const EbmlCallbacks ClassInfos;
operator const EbmlId &() const {return ClassInfos.GlobalId;}
EbmlElement * Clone() const {return new KaxTagMultiTitleAddress(*this);}
};
class MATROSKA_DLL_API KaxTagMultiTitleURL : public EbmlString {
public:
KaxTagMultiTitleURL() {}
KaxTagMultiTitleURL(const KaxTagMultiTitleURL & ElementToClone) :EbmlString(ElementToClone) {}
static EbmlElement & Create() {return *(new KaxTagMultiTitleURL);}
const EbmlCallbacks & Generic() const {return ClassInfos;}
static const EbmlCallbacks ClassInfos;
operator const EbmlId &() const {return ClassInfos.GlobalId;}
EbmlElement * Clone() const {return new KaxTagMultiTitleURL(*this);}
};
class MATROSKA_DLL_API KaxTagMultiTitleEmail : public EbmlString {
public:
KaxTagMultiTitleEmail() {}
KaxTagMultiTitleEmail(const KaxTagMultiTitleEmail & ElementToClone) :EbmlString(ElementToClone) {}
static EbmlElement & Create() {return *(new KaxTagMultiTitleEmail);}
const EbmlCallbacks & Generic() const {return ClassInfos;}
static const EbmlCallbacks ClassInfos;
operator const EbmlId &() const {return ClassInfos.GlobalId;}
EbmlElement * Clone() const {return new KaxTagMultiTitleEmail(*this);}
};
class MATROSKA_DLL_API KaxTagMultiTitleLanguage : public EbmlString {
public:
KaxTagMultiTitleLanguage() {}
KaxTagMultiTitleLanguage(const KaxTagMultiTitleLanguage & ElementToClone) :EbmlString(ElementToClone) {}
static EbmlElement & Create() {return *(new KaxTagMultiTitleLanguage);}
const EbmlCallbacks & Generic() const {return ClassInfos;}
static const EbmlCallbacks ClassInfos;
operator const EbmlId &() const {return ClassInfos.GlobalId;}
EbmlElement * Clone() const {return new KaxTagMultiTitleLanguage(*this);}
};
class MATROSKA_DLL_API KaxTagMultiAttachment : public EbmlMaster {
public:
KaxTagMultiAttachment();
KaxTagMultiAttachment(const KaxTagMultiAttachment & ElementToClone) :EbmlMaster(ElementToClone) {}
static EbmlElement & Create() {return *(new KaxTagMultiAttachment);}
const EbmlCallbacks & Generic() const {return ClassInfos;}
static const EbmlCallbacks ClassInfos;
operator const EbmlId &() const {return ClassInfos.GlobalId;}
EbmlElement * Clone() const {return new KaxTagMultiAttachment(*this);}
};
class MATROSKA_DLL_API KaxTagAttachment : public EbmlMaster {
public:
KaxTagAttachment();
KaxTagAttachment(const KaxTagAttachment & ElementToClone) :EbmlMaster(ElementToClone) {}
static EbmlElement & Create() {return *(new KaxTagAttachment);}
const EbmlCallbacks & Generic() const {return ClassInfos;}
static const EbmlCallbacks ClassInfos;
operator const EbmlId &() const {return ClassInfos.GlobalId;}
EbmlElement * Clone() const {return new KaxTagAttachment(*this);}
};
class MATROSKA_DLL_API KaxTagAttachmentID : public EbmlUInteger {
public:
KaxTagAttachmentID() {}
KaxTagAttachmentID(const KaxTagAttachmentID & ElementToClone) :EbmlUInteger(ElementToClone) {}
static EbmlElement & Create() {return *(new KaxTagAttachmentID);}
const EbmlCallbacks & Generic() const {return ClassInfos;}
static const EbmlCallbacks ClassInfos;
operator const EbmlId &() const {return ClassInfos.GlobalId;}
EbmlElement * Clone() const {return new KaxTagAttachmentID(*this);}
};
/*
class MATROSKA_DLL_API KaxTagBPM : public EbmlFloat {
public:
KaxTagBPM() :EbmlFloat() {}
static EbmlElement & Create() {return *(new KaxTagBPM);}
const EbmlCallbacks & Generic() const {return ClassInfos;}
static const EbmlCallbacks ClassInfos;
operator const EbmlId &() const {return ClassInfos.GlobalId;}
};
class MATROSKA_DLL_API KaxTagPopularimeter : public EbmlSInteger {
public:
KaxTagPopularimeter() {}
static EbmlElement & Create() {return *(new KaxTagPopularimeter);}
const EbmlCallbacks & Generic() const {return ClassInfos;}
static const EbmlCallbacks ClassInfos;
operator const EbmlId &() const {return ClassInfos.GlobalId;}
};
class MATROSKA_DLL_API KaxTagRating : public EbmlBinary {
public:
KaxTagRating() {}
static EbmlElement & Create() {return *(new KaxTagRating);}
bool ValidateSize() const {return true;} // we don't mind about what's inside
const EbmlCallbacks & Generic() const {return ClassInfos;}
static const EbmlCallbacks ClassInfos;
operator const EbmlId &() const {return ClassInfos.GlobalId;}
};
class MATROSKA_DLL_API KaxTagSetPart : public EbmlUInteger {
public:
KaxTagSetPart() {}
static EbmlElement & Create() {return *(new KaxTagSetPart);}
const EbmlCallbacks & Generic() const {return ClassInfos;}
static const EbmlCallbacks ClassInfos;
operator const EbmlId &() const {return ClassInfos.GlobalId;}
};
class MATROSKA_DLL_API KaxTagUserDefinedURL : public EbmlString {
public:
KaxTagUserDefinedURL() {}
static EbmlElement & Create() {return *(new KaxTagUserDefinedURL);}
const EbmlCallbacks & Generic() const {return ClassInfos;}
static const EbmlCallbacks ClassInfos;
operator const EbmlId &() const {return ClassInfos.GlobalId;}
};
class MATROSKA_DLL_API KaxTagVideoSecondaryGenre : public EbmlBinary {
public:
KaxTagVideoSecondaryGenre() {}
static EbmlElement & Create() {return *(new KaxTagVideoSecondaryGenre);}
bool ValidateSize() const {return (Size >= 4);}
const EbmlCallbacks & Generic() const {return ClassInfos;}
static const EbmlCallbacks ClassInfos;
operator const EbmlId &() const {return ClassInfos.GlobalId;}
};
class MATROSKA_DLL_API KaxWritingApp : public EbmlUnicodeString {
public:
KaxWritingApp() {}
static EbmlElement & Create() {return *(new KaxWritingApp);}
const EbmlCallbacks & Generic() const {return ClassInfos;}
static const EbmlCallbacks ClassInfos;
operator const EbmlId &() const {return ClassInfos.GlobalId;}
};*/
END_LIBMATROSKA_NAMESPACE
#endif // LIBMATROSKA_TAGMULTI_H

58
matroska/KaxTags.h Normal file
View File

@ -0,0 +1,58 @@
/****************************************************************************
** libmatroska : parse Matroska files, see http://www.matroska.org/
**
** <file/class MATROSKA_DLL_API description>
**
** Copyright (C) 2002-2004 Steve Lhomme. All rights reserved.
**
** This file is part of libmatroska.
**
** This library is free software; you can redistribute it and/or
** modify it under the terms of the GNU Lesser General Public
** License as published by the Free Software Foundation; either
** version 2.1 of the License, or (at your option) any later version.
**
** This library is distributed in the hope that it will be useful,
** but WITHOUT ANY WARRANTY; without even the implied warranty of
** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
** Lesser General Public License for more details.
**
** You should have received a copy of the GNU Lesser General Public
** License along with this library; if not, write to the Free Software
** Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
**
** See http://www.matroska.org/license/lgpl/ for LGPL licensing information.**
** Contact license@matroska.org if any conditions of this licensing are
** not clear to you.
**
**********************************************************************/
/*!
\file
\version \$Id: KaxTags.h,v 1.7 2004/04/14 23:26:17 robux4 Exp $
\author Steve Lhomme <robux4 @ users.sf.net>
*/
#ifndef LIBMATROSKA_TAGS_H
#define LIBMATROSKA_TAGS_H
#include "matroska/KaxTypes.h"
#include "ebml/EbmlMaster.h"
using namespace LIBEBML_NAMESPACE;
START_LIBMATROSKA_NAMESPACE
class MATROSKA_DLL_API KaxTags : public EbmlMaster {
public:
KaxTags();
KaxTags(const KaxTags & ElementToClone) :EbmlMaster(ElementToClone) {}
static EbmlElement & Create() {return *(new KaxTags);}
const EbmlCallbacks & Generic() const {return ClassInfos;}
static const EbmlCallbacks ClassInfos;
operator const EbmlId &() const {return ClassInfos.GlobalId;}
EbmlElement * Clone() const {return new KaxTags(*this);}
};
END_LIBMATROSKA_NAMESPACE
#endif // LIBMATROSKA_TAGS_H

119
matroska/KaxTrackAudio.h Normal file
View File

@ -0,0 +1,119 @@
/****************************************************************************
** libmatroska : parse Matroska files, see http://www.matroska.org/
**
** <file/class MATROSKA_DLL_API description>
**
** Copyright (C) 2002-2004 Steve Lhomme. All rights reserved.
**
** This file is part of libmatroska.
**
** This library is free software; you can redistribute it and/or
** modify it under the terms of the GNU Lesser General Public
** License as published by the Free Software Foundation; either
** version 2.1 of the License, or (at your option) any later version.
**
** This library is distributed in the hope that it will be useful,
** but WITHOUT ANY WARRANTY; without even the implied warranty of
** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
** Lesser General Public License for more details.
**
** You should have received a copy of the GNU Lesser General Public
** License along with this library; if not, write to the Free Software
** Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
**
** See http://www.matroska.org/license/lgpl/ for LGPL licensing information.**
** Contact license@matroska.org if any conditions of this licensing are
** not clear to you.
**
**********************************************************************/
/*!
\file
\version \$Id: KaxTrackAudio.h,v 1.11 2004/04/14 23:26:17 robux4 Exp $
\author Steve Lhomme <robux4 @ users.sf.net>
*/
#ifndef LIBMATROSKA_TRACK_AUDIO_H
#define LIBMATROSKA_TRACK_AUDIO_H
#include "matroska/KaxTypes.h"
#include "ebml/EbmlMaster.h"
#include "ebml/EbmlFloat.h"
#include "ebml/EbmlUInteger.h"
#include "ebml/EbmlBinary.h"
using namespace LIBEBML_NAMESPACE;
START_LIBMATROSKA_NAMESPACE
class MATROSKA_DLL_API KaxTrackAudio : public EbmlMaster {
public:
KaxTrackAudio();
KaxTrackAudio(const KaxTrackAudio & ElementToClone) :EbmlMaster(ElementToClone) {}
static EbmlElement & Create() {return *(new KaxTrackAudio);}
const EbmlCallbacks & Generic() const {return ClassInfos;}
static const EbmlCallbacks ClassInfos;
operator const EbmlId &() const {return ClassInfos.GlobalId;}
EbmlElement * Clone() const {return new KaxTrackAudio(*this);}
};
class MATROSKA_DLL_API KaxAudioSamplingFreq : public EbmlFloat {
public:
KaxAudioSamplingFreq() :EbmlFloat(8000.0) {}
KaxAudioSamplingFreq(const KaxAudioSamplingFreq & ElementToClone) :EbmlFloat(ElementToClone) {}
static EbmlElement & Create() {return *(new KaxAudioSamplingFreq);}
const EbmlCallbacks & Generic() const {return ClassInfos;}
static const EbmlCallbacks ClassInfos;
operator const EbmlId &() const {return ClassInfos.GlobalId;}
EbmlElement * Clone() const {return new KaxAudioSamplingFreq(*this);}
};
class MATROSKA_DLL_API KaxAudioOutputSamplingFreq : public EbmlFloat {
public:
KaxAudioOutputSamplingFreq() :EbmlFloat() {}
KaxAudioOutputSamplingFreq(const KaxAudioOutputSamplingFreq & ElementToClone) :EbmlFloat(ElementToClone) {}
static EbmlElement & Create() {return *(new KaxAudioOutputSamplingFreq);}
const EbmlCallbacks & Generic() const {return ClassInfos;}
static const EbmlCallbacks ClassInfos;
operator const EbmlId &() const {return ClassInfos.GlobalId;}
EbmlElement * Clone() const {return new KaxAudioOutputSamplingFreq(*this);}
};
class MATROSKA_DLL_API KaxAudioChannels : public EbmlUInteger {
public:
KaxAudioChannels() :EbmlUInteger(1) {}
KaxAudioChannels(const KaxAudioChannels & ElementToClone) :EbmlUInteger(ElementToClone) {}
static EbmlElement & Create() {return *(new KaxAudioChannels);}
const EbmlCallbacks & Generic() const {return ClassInfos;}
static const EbmlCallbacks ClassInfos;
operator const EbmlId &() const {return ClassInfos.GlobalId;}
EbmlElement * Clone() const {return new KaxAudioChannels(*this);}
};
#if MATROSKA_VERSION >= 2
class MATROSKA_DLL_API KaxAudioPosition : public EbmlBinary {
public:
KaxAudioPosition() {}
KaxAudioPosition(const KaxAudioPosition & ElementToClone) :EbmlBinary(ElementToClone){}
static EbmlElement & Create() {return *(new KaxAudioPosition);}
const EbmlCallbacks & Generic() const {return ClassInfos;}
static const EbmlCallbacks ClassInfos;
bool ValidateSize(void) const {return true;}
operator const EbmlId &() const {return ClassInfos.GlobalId;}
EbmlElement * Clone() const {return new KaxAudioPosition(*this);}
};
#endif // MATROSKA_VERSION
class MATROSKA_DLL_API KaxAudioBitDepth : public EbmlUInteger {
public:
KaxAudioBitDepth() {}
KaxAudioBitDepth(const KaxAudioBitDepth & ElementToClone) :EbmlUInteger(ElementToClone) {}
static EbmlElement & Create() {return *(new KaxAudioBitDepth);}
const EbmlCallbacks & Generic() const {return ClassInfos;}
static const EbmlCallbacks ClassInfos;
operator const EbmlId &() const {return ClassInfos.GlobalId;}
EbmlElement * Clone() const {return new KaxAudioBitDepth(*this);}
};
END_LIBMATROSKA_NAMESPACE
#endif // LIBMATROSKA_TRACK_AUDIO_H

View File

@ -0,0 +1,357 @@
/****************************************************************************
** libmatroska : parse Matroska files, see http://www.matroska.org/
**
** <file/class description>
**
** Copyright (C) 2002-2005 Steve Lhomme. All rights reserved.
**
** This file is part of libmatroska.
**
** This library is free software; you can redistribute it and/or
** modify it under the terms of the GNU Lesser General Public
** License as published by the Free Software Foundation; either
** version 2.1 of the License, or (at your option) any later version.
**
** This library is distributed in the hope that it will be useful,
** but WITHOUT ANY WARRANTY; without even the implied warranty of
** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
** Lesser General Public License for more details.
**
** You should have received a copy of the GNU Lesser General Public
** License along with this library; if not, write to the Free Software
** Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
**
** See http://www.matroska.org/license/lgpl/ for LGPL licensing information.**
** Contact license@matroska.org if any conditions of this licensing are
** not clear to you.
**
**********************************************************************/
/*!
\file
\version \$Id: KaxTrackEntryData.h,v 1.9 2004/04/14 23:26:17 robux4 Exp $
\author Steve Lhomme <robux4 @ users.sf.net>
\author John Cannon <spyder2555 @ users.sf.net>
*/
#ifndef LIBMATROSKA_TRACK_ENTRY_DATA_H
#define LIBMATROSKA_TRACK_ENTRY_DATA_H
#include "matroska/KaxTypes.h"
#include "ebml/EbmlUInteger.h"
#include "ebml/EbmlFloat.h"
#include "ebml/EbmlString.h"
#include "ebml/EbmlUnicodeString.h"
#include "ebml/EbmlBinary.h"
#include "ebml/EbmlMaster.h"
using namespace LIBEBML_NAMESPACE;
START_LIBMATROSKA_NAMESPACE
class MATROSKA_DLL_API KaxTrackNumber : public EbmlUInteger {
public:
KaxTrackNumber() {}
KaxTrackNumber(const KaxTrackNumber & ElementToClone) :EbmlUInteger(ElementToClone) {}
static EbmlElement & Create() {return *(new KaxTrackNumber);}
const EbmlCallbacks & Generic() const {return ClassInfos;}
static const EbmlCallbacks ClassInfos;
operator const EbmlId &() const {return ClassInfos.GlobalId;}
EbmlElement * Clone() const {return new KaxTrackNumber(*this);}
};
class MATROSKA_DLL_API KaxTrackUID : public EbmlUInteger {
public:
KaxTrackUID() {}
KaxTrackUID(const KaxTrackUID & ElementToClone) :EbmlUInteger(ElementToClone) {}
static EbmlElement & Create() {return *(new KaxTrackUID);}
const EbmlCallbacks & Generic() const {return ClassInfos;}
static const EbmlCallbacks ClassInfos;
operator const EbmlId &() const {return ClassInfos.GlobalId;}
EbmlElement * Clone() const {return new KaxTrackUID(*this);}
};
class MATROSKA_DLL_API KaxTrackType : public EbmlUInteger {
public:
KaxTrackType() {}
KaxTrackType(const KaxTrackType & ElementToClone) :EbmlUInteger(ElementToClone) {}
static EbmlElement & Create() {return *(new KaxTrackType);}
const EbmlCallbacks & Generic() const {return ClassInfos;}
static const EbmlCallbacks ClassInfos;
operator const EbmlId &() const {return ClassInfos.GlobalId;}
EbmlElement * Clone() const {return new KaxTrackType(*this);}
};
#if MATROSKA_VERSION >= 2
class MATROSKA_DLL_API KaxTrackFlagEnabled : public EbmlUInteger {
public:
KaxTrackFlagEnabled() :EbmlUInteger(1) {}
KaxTrackFlagEnabled(const KaxTrackFlagEnabled & ElementToClone) :EbmlUInteger(ElementToClone) {}
static EbmlElement & Create() {return *(new KaxTrackFlagEnabled);}
const EbmlCallbacks & Generic() const {return ClassInfos;}
static const EbmlCallbacks ClassInfos;
operator const EbmlId &() const {return ClassInfos.GlobalId;}
EbmlElement * Clone() const {return new KaxTrackFlagEnabled(*this);}
};
#endif // MATROSKA_VERSION
class MATROSKA_DLL_API KaxTrackFlagDefault : public EbmlUInteger {
public:
KaxTrackFlagDefault() :EbmlUInteger(1) {}
KaxTrackFlagDefault(const KaxTrackFlagDefault & ElementToClone) :EbmlUInteger(ElementToClone) {}
static EbmlElement & Create() {return *(new KaxTrackFlagDefault);}
const EbmlCallbacks & Generic() const {return ClassInfos;}
static const EbmlCallbacks ClassInfos;
operator const EbmlId &() const {return ClassInfos.GlobalId;}
EbmlElement * Clone() const {return new KaxTrackFlagDefault(*this);}
};
class MATROSKA_DLL_API KaxTrackFlagForced : public EbmlUInteger {
public:
KaxTrackFlagForced() :EbmlUInteger(0) {}
KaxTrackFlagForced(const KaxTrackFlagForced & ElementToClone) :EbmlUInteger(ElementToClone) {}
static EbmlElement & Create() {return *(new KaxTrackFlagForced);}
const EbmlCallbacks & Generic() const {return ClassInfos;}
static const EbmlCallbacks ClassInfos;
operator const EbmlId &() const {return ClassInfos.GlobalId;}
EbmlElement * Clone() const {return new KaxTrackFlagForced(*this);}
};
class MATROSKA_DLL_API KaxTrackFlagLacing : public EbmlUInteger {
public:
KaxTrackFlagLacing() :EbmlUInteger(1) {}
KaxTrackFlagLacing(const KaxTrackFlagLacing & ElementToClone) :EbmlUInteger(ElementToClone) {}
static EbmlElement & Create() {return *(new KaxTrackFlagLacing);}
const EbmlCallbacks & Generic() const {return ClassInfos;}
static const EbmlCallbacks ClassInfos;
operator const EbmlId &() const {return ClassInfos.GlobalId;}
EbmlElement * Clone() const {return new KaxTrackFlagLacing(*this);}
};
class MATROSKA_DLL_API KaxTrackMinCache : public EbmlUInteger {
public:
KaxTrackMinCache() :EbmlUInteger(0) {}
KaxTrackMinCache(const KaxTrackMinCache & ElementToClone) :EbmlUInteger(ElementToClone) {}
static EbmlElement & Create() {return *(new KaxTrackMinCache);}
const EbmlCallbacks & Generic() const {return ClassInfos;}
static const EbmlCallbacks ClassInfos;
operator const EbmlId &() const {return ClassInfos.GlobalId;}
EbmlElement * Clone() const {return new KaxTrackMinCache(*this);}
};
class MATROSKA_DLL_API KaxTrackMaxCache : public EbmlUInteger {
public:
KaxTrackMaxCache() {}
KaxTrackMaxCache(const KaxTrackMaxCache & ElementToClone) :EbmlUInteger(ElementToClone) {}
static EbmlElement & Create() {return *(new KaxTrackMaxCache);}
const EbmlCallbacks & Generic() const {return ClassInfos;}
static const EbmlCallbacks ClassInfos;
operator const EbmlId &() const {return ClassInfos.GlobalId;}
EbmlElement * Clone() const {return new KaxTrackMaxCache(*this);}
};
class MATROSKA_DLL_API KaxTrackDefaultDuration : public EbmlUInteger {
public:
KaxTrackDefaultDuration() {}
KaxTrackDefaultDuration(const KaxTrackDefaultDuration & ElementToClone) :EbmlUInteger(ElementToClone) {}
static EbmlElement & Create() {return *(new KaxTrackDefaultDuration);}
const EbmlCallbacks & Generic() const {return ClassInfos;}
static const EbmlCallbacks ClassInfos;
operator const EbmlId &() const {return ClassInfos.GlobalId;}
EbmlElement * Clone() const {return new KaxTrackDefaultDuration(*this);}
};
class MATROSKA_DLL_API KaxTrackTimecodeScale : public EbmlFloat {
public:
KaxTrackTimecodeScale() :EbmlFloat(1.0) {}
KaxTrackTimecodeScale(const KaxTrackTimecodeScale & ElementToClone) :EbmlFloat(ElementToClone) {}
static EbmlElement & Create() {return *(new KaxTrackTimecodeScale);}
const EbmlCallbacks & Generic() const {return ClassInfos;}
static const EbmlCallbacks ClassInfos;
operator const EbmlId &() const {return ClassInfos.GlobalId;}
EbmlElement * Clone() const {return new KaxTrackTimecodeScale(*this);}
};
class MATROSKA_DLL_API KaxMaxBlockAdditionID : public EbmlUInteger {
public:
KaxMaxBlockAdditionID() :EbmlUInteger(0) {}
KaxMaxBlockAdditionID(const KaxMaxBlockAdditionID & ElementToClone) :EbmlUInteger(ElementToClone) {}
static EbmlElement & Create() {return *(new KaxMaxBlockAdditionID);}
const EbmlCallbacks & Generic() const {return ClassInfos;}
static const EbmlCallbacks ClassInfos;
operator const EbmlId &() const {return ClassInfos.GlobalId;}
EbmlElement * Clone() const {return new KaxMaxBlockAdditionID(*this);}
};
class MATROSKA_DLL_API KaxTrackName : public EbmlUnicodeString {
public:
KaxTrackName() {}
KaxTrackName(const KaxTrackName & ElementToClone) :EbmlUnicodeString(ElementToClone) {}
static EbmlElement & Create() {return *(new KaxTrackName);}
const EbmlCallbacks & Generic() const {return ClassInfos;}
static const EbmlCallbacks ClassInfos;
operator const EbmlId &() const {return ClassInfos.GlobalId;}
EbmlElement * Clone() const {return new KaxTrackName(*this);}
};
class MATROSKA_DLL_API KaxTrackLanguage : public EbmlString {
public:
KaxTrackLanguage() :EbmlString("eng") {}
KaxTrackLanguage(const KaxTrackLanguage & ElementToClone) :EbmlString(ElementToClone) {}
static EbmlElement & Create() {return *(new KaxTrackLanguage);}
const EbmlCallbacks & Generic() const {return ClassInfos;}
static const EbmlCallbacks ClassInfos;
operator const EbmlId &() const {return ClassInfos.GlobalId;}
EbmlElement * Clone() const {return new KaxTrackLanguage(*this);}
};
class MATROSKA_DLL_API KaxCodecID : public EbmlString {
public:
KaxCodecID() {}
KaxCodecID(const KaxCodecID & ElementToClone) :EbmlString(ElementToClone) {}
static EbmlElement & Create() {return *(new KaxCodecID);}
const EbmlCallbacks & Generic() const {return ClassInfos;}
static const EbmlCallbacks ClassInfos;
operator const EbmlId &() const {return ClassInfos.GlobalId;}
EbmlElement * Clone() const {return new KaxCodecID(*this);}
};
class MATROSKA_DLL_API KaxCodecPrivate : public EbmlBinary {
public:
KaxCodecPrivate() {}
KaxCodecPrivate(const KaxCodecPrivate & ElementToClone) :EbmlBinary(ElementToClone){}
static EbmlElement & Create() {return *(new KaxCodecPrivate);}
bool ValidateSize() const {return true;} // we don't mind about what's inside
const EbmlCallbacks & Generic() const {return ClassInfos;}
static const EbmlCallbacks ClassInfos;
operator const EbmlId &() const {return ClassInfos.GlobalId;}
EbmlElement * Clone() const {return new KaxCodecPrivate(*this);}
};
class MATROSKA_DLL_API KaxCodecName : public EbmlUnicodeString {
public:
KaxCodecName() {}
KaxCodecName(const KaxCodecName & ElementToClone) :EbmlUnicodeString(ElementToClone) {}
static EbmlElement & Create() {return *(new KaxCodecName);}
const EbmlCallbacks & Generic() const {return ClassInfos;}
static const EbmlCallbacks ClassInfos;
operator const EbmlId &() const {return ClassInfos.GlobalId;}
EbmlElement * Clone() const {return new KaxCodecName(*this);}
};
class MATROSKA_DLL_API KaxTrackAttachmentLink : public EbmlBinary {
public:
KaxTrackAttachmentLink() {}
KaxTrackAttachmentLink(const KaxTrackAttachmentLink & ElementToClone) :EbmlBinary(ElementToClone){}
static EbmlElement & Create() {return *(new KaxTrackAttachmentLink);}
bool ValidateSize() const {return true;} // we don't mind about what's inside
const EbmlCallbacks & Generic() const {return ClassInfos;}
static const EbmlCallbacks ClassInfos;
operator const EbmlId &() const {return ClassInfos.GlobalId;}
EbmlElement * Clone() const {return new KaxTrackAttachmentLink(*this);}
};
class MATROSKA_DLL_API KaxTrackOverlay : public EbmlUInteger {
public:
KaxTrackOverlay() {}
KaxTrackOverlay(const KaxTrackOverlay & ElementToClone) :EbmlUInteger(ElementToClone) {}
static EbmlElement & Create() {return *(new KaxTrackOverlay);}
const EbmlCallbacks & Generic() const {return ClassInfos;}
static const EbmlCallbacks ClassInfos;
operator const EbmlId &() const {return ClassInfos.GlobalId;}
EbmlElement * Clone() const {return new KaxTrackOverlay(*this);}
};
class MATROSKA_DLL_API KaxTrackTranslate : public EbmlMaster {
public:
KaxTrackTranslate();
KaxTrackTranslate(const KaxTrackTranslate & ElementToClone) :EbmlMaster(ElementToClone) {}
static EbmlElement & Create() {return *(new KaxTrackTranslate);}
const EbmlCallbacks & Generic() const {return ClassInfos;}
static const EbmlCallbacks ClassInfos;
operator const EbmlId &() const {return ClassInfos.GlobalId;}
EbmlElement * Clone() const {return new KaxTrackTranslate(*this);}
};
class MATROSKA_DLL_API KaxTrackTranslateCodec : public EbmlUInteger {
public:
KaxTrackTranslateCodec() {}
KaxTrackTranslateCodec(const KaxTrackTranslateCodec & ElementToClone) :EbmlUInteger(ElementToClone) {}
static EbmlElement & Create() {return *(new KaxTrackTranslateCodec);}
const EbmlCallbacks & Generic() const {return ClassInfos;}
static const EbmlCallbacks ClassInfos;
operator const EbmlId &() const {return ClassInfos.GlobalId;}
EbmlElement * Clone() const {return new KaxTrackTranslateCodec(*this);}
};
class MATROSKA_DLL_API KaxTrackTranslateEditionUID : public EbmlUInteger {
public:
KaxTrackTranslateEditionUID() {}
KaxTrackTranslateEditionUID(const KaxTrackTranslateEditionUID & ElementToClone) :EbmlUInteger(ElementToClone) {}
static EbmlElement & Create() {return *(new KaxTrackTranslateEditionUID);}
const EbmlCallbacks & Generic() const {return ClassInfos;}
static const EbmlCallbacks ClassInfos;
operator const EbmlId &() const {return ClassInfos.GlobalId;}
EbmlElement * Clone() const {return new KaxTrackTranslateEditionUID(*this);}
};
class MATROSKA_DLL_API KaxTrackTranslateTrackID : public EbmlBinary {
public:
KaxTrackTranslateTrackID() {}
KaxTrackTranslateTrackID(const KaxTrackTranslateTrackID & ElementToClone) :EbmlBinary(ElementToClone){}
static EbmlElement & Create() {return *(new KaxTrackTranslateTrackID);}
bool ValidateSize() const { return true;}
const EbmlCallbacks & Generic() const {return ClassInfos;}
static const EbmlCallbacks ClassInfos;
operator const EbmlId &() const {return ClassInfos.GlobalId;}
EbmlElement * Clone() const {return new KaxTrackTranslateTrackID(*this);}
};
#if MATROSKA_VERSION >= 2
class MATROSKA_DLL_API KaxCodecSettings : public EbmlUnicodeString {
public:
KaxCodecSettings() {}
KaxCodecSettings(const KaxCodecSettings & ElementToClone) :EbmlUnicodeString(ElementToClone) {}
static EbmlElement & Create() {return *(new KaxCodecSettings);}
const EbmlCallbacks & Generic() const {return ClassInfos;}
static const EbmlCallbacks ClassInfos;
operator const EbmlId &() const {return ClassInfos.GlobalId;}
EbmlElement * Clone() const {return new KaxCodecSettings(*this);}
};
class MATROSKA_DLL_API KaxCodecInfoURL : public EbmlString {
public:
KaxCodecInfoURL() {}
KaxCodecInfoURL(const KaxCodecInfoURL & ElementToClone) :EbmlString(ElementToClone) {}
static EbmlElement & Create() {return *(new KaxCodecInfoURL);}
const EbmlCallbacks & Generic() const {return ClassInfos;}
static const EbmlCallbacks ClassInfos;
operator const EbmlId &() const {return ClassInfos.GlobalId;}
EbmlElement * Clone() const {return new KaxCodecInfoURL(*this);}
};
class MATROSKA_DLL_API KaxCodecDownloadURL : public EbmlString {
public:
KaxCodecDownloadURL() {}
KaxCodecDownloadURL(const KaxCodecDownloadURL & ElementToClone) :EbmlString(ElementToClone) {}
static EbmlElement & Create() {return *(new KaxCodecDownloadURL);}
const EbmlCallbacks & Generic() const {return ClassInfos;}
static const EbmlCallbacks ClassInfos;
operator const EbmlId &() const {return ClassInfos.GlobalId;}
EbmlElement * Clone() const {return new KaxCodecDownloadURL(*this);}
};
class MATROSKA_DLL_API KaxCodecDecodeAll : public EbmlUInteger {
public:
KaxCodecDecodeAll() :EbmlUInteger(1) {}
KaxCodecDecodeAll(const KaxCodecDecodeAll & ElementToClone) :EbmlUInteger(ElementToClone) {}
static EbmlElement & Create() {return *(new KaxCodecDecodeAll);}
const EbmlCallbacks & Generic() const {return ClassInfos;}
static const EbmlCallbacks ClassInfos;
operator const EbmlId &() const {return ClassInfos.GlobalId;}
EbmlElement * Clone() const {return new KaxCodecDecodeAll(*this);}
};
#endif // MATROSKA_VERSION
END_LIBMATROSKA_NAMESPACE
#endif // LIBMATROSKA_TRACK_ENTRY_DATA_H

235
matroska/KaxTrackVideo.h Normal file
View File

@ -0,0 +1,235 @@
/****************************************************************************
** libmatroska : parse Matroska files, see http://www.matroska.org/
**
** <file/class MATROSKA_DLL_API description>
**
** Copyright (C) 2002-2004 Steve Lhomme. All rights reserved.
**
** This file is part of libmatroska.
**
** This library is free software; you can redistribute it and/or
** modify it under the terms of the GNU Lesser General Public
** License as published by the Free Software Foundation; either
** version 2.1 of the License, or (at your option) any later version.
**
** This library is distributed in the hope that it will be useful,
** but WITHOUT ANY WARRANTY; without even the implied warranty of
** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
** Lesser General Public License for more details.
**
** You should have received a copy of the GNU Lesser General Public
** License along with this library; if not, write to the Free Software
** Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
**
** See http://www.matroska.org/license/lgpl/ for LGPL licensing information.**
** Contact license@matroska.org if any conditions of this licensing are
** not clear to you.
**
**********************************************************************/
/*!
\file
\version \$Id: KaxTrackVideo.h,v 1.9 2004/04/14 23:26:17 robux4 Exp $
\author Steve Lhomme <robux4 @ users.sf.net>
*/
#ifndef LIBMATROSKA_TRACK_VIDEO_H
#define LIBMATROSKA_TRACK_VIDEO_H
#include "matroska/KaxTypes.h"
#include "ebml/EbmlMaster.h"
#include "ebml/EbmlUInteger.h"
#include "ebml/EbmlBinary.h"
#include "ebml/EbmlFloat.h"
using namespace LIBEBML_NAMESPACE;
START_LIBMATROSKA_NAMESPACE
class MATROSKA_DLL_API KaxTrackVideo : public EbmlMaster {
public:
KaxTrackVideo();
KaxTrackVideo(const KaxTrackVideo & ElementToClone) :EbmlMaster(ElementToClone) {}
static EbmlElement & Create() {return *(new KaxTrackVideo);}
const EbmlCallbacks & Generic() const {return ClassInfos;}
static const EbmlCallbacks ClassInfos;
operator const EbmlId &() const {return ClassInfos.GlobalId;}
EbmlElement * Clone() const {return new KaxTrackVideo(*this);}
};
#if MATROSKA_VERSION >= 2
class MATROSKA_DLL_API KaxVideoFlagInterlaced : public EbmlUInteger {
public:
KaxVideoFlagInterlaced() :EbmlUInteger(0) {}
KaxVideoFlagInterlaced(const KaxVideoFlagInterlaced & ElementToClone) :EbmlUInteger(ElementToClone) {}
static EbmlElement & Create() {return *(new KaxVideoFlagInterlaced);}
const EbmlCallbacks & Generic() const {return ClassInfos;}
static const EbmlCallbacks ClassInfos;
operator const EbmlId &() const {return ClassInfos.GlobalId;}
EbmlElement * Clone() const {return new KaxVideoFlagInterlaced(*this);}
};
class MATROSKA_DLL_API KaxVideoStereoMode : public EbmlUInteger {
public:
KaxVideoStereoMode() :EbmlUInteger(0) {}
KaxVideoStereoMode(const KaxVideoStereoMode & ElementToClone) :EbmlUInteger(ElementToClone) {}
static EbmlElement & Create() {return *(new KaxVideoStereoMode);}
const EbmlCallbacks & Generic() const {return ClassInfos;}
static const EbmlCallbacks ClassInfos;
operator const EbmlId &() const {return ClassInfos.GlobalId;}
EbmlElement * Clone() const {return new KaxVideoStereoMode(*this);}
};
#endif // MATROSKA_VERSION
class MATROSKA_DLL_API KaxVideoPixelWidth : public EbmlUInteger {
public:
KaxVideoPixelWidth() {}
KaxVideoPixelWidth(const KaxVideoPixelWidth & ElementToClone) :EbmlUInteger(ElementToClone) {}
static EbmlElement & Create() {return *(new KaxVideoPixelWidth);}
const EbmlCallbacks & Generic() const {return ClassInfos;}
static const EbmlCallbacks ClassInfos;
operator const EbmlId &() const {return ClassInfos.GlobalId;}
EbmlElement * Clone() const {return new KaxVideoPixelWidth(*this);}
};
class MATROSKA_DLL_API KaxVideoPixelHeight : public EbmlUInteger {
public:
KaxVideoPixelHeight() {}
KaxVideoPixelHeight(const KaxVideoPixelHeight & ElementToClone) :EbmlUInteger(ElementToClone) {}
static EbmlElement & Create() {return *(new KaxVideoPixelHeight);}
const EbmlCallbacks & Generic() const {return ClassInfos;}
static const EbmlCallbacks ClassInfos;
operator const EbmlId &() const {return ClassInfos.GlobalId;}
EbmlElement * Clone() const {return new KaxVideoPixelHeight(*this);}
};
class MATROSKA_DLL_API KaxVideoPixelCropBottom : public EbmlUInteger {
public:
KaxVideoPixelCropBottom(): EbmlUInteger(0) {}
KaxVideoPixelCropBottom(const KaxVideoPixelCropBottom & ElementToClone) :EbmlUInteger(ElementToClone) {}
static EbmlElement & Create() {return *(new KaxVideoPixelCropBottom);}
const EbmlCallbacks & Generic() const {return ClassInfos;}
static const EbmlCallbacks ClassInfos;
operator const EbmlId &() const {return ClassInfos.GlobalId;}
EbmlElement * Clone() const {return new KaxVideoPixelCropBottom(*this);}
};
class MATROSKA_DLL_API KaxVideoPixelCropTop : public EbmlUInteger {
public:
KaxVideoPixelCropTop(): EbmlUInteger(0) {}
KaxVideoPixelCropTop(const KaxVideoPixelCropTop & ElementToClone) :EbmlUInteger(ElementToClone) {}
static EbmlElement & Create() {return *(new KaxVideoPixelCropTop);}
const EbmlCallbacks & Generic() const {return ClassInfos;}
static const EbmlCallbacks ClassInfos;
operator const EbmlId &() const {return ClassInfos.GlobalId;}
EbmlElement * Clone() const {return new KaxVideoPixelCropTop(*this);}
};
class MATROSKA_DLL_API KaxVideoPixelCropLeft : public EbmlUInteger {
public:
KaxVideoPixelCropLeft(): EbmlUInteger(0) {}
KaxVideoPixelCropLeft(const KaxVideoPixelCropLeft & ElementToClone) :EbmlUInteger(ElementToClone) {}
static EbmlElement & Create() {return *(new KaxVideoPixelCropLeft);}
const EbmlCallbacks & Generic() const {return ClassInfos;}
static const EbmlCallbacks ClassInfos;
operator const EbmlId &() const {return ClassInfos.GlobalId;}
EbmlElement * Clone() const {return new KaxVideoPixelCropLeft(*this);}
};
class MATROSKA_DLL_API KaxVideoPixelCropRight : public EbmlUInteger {
public:
KaxVideoPixelCropRight(): EbmlUInteger(0) {}
KaxVideoPixelCropRight(const KaxVideoPixelCropRight & ElementToClone) :EbmlUInteger(ElementToClone) {}
static EbmlElement & Create() {return *(new KaxVideoPixelCropRight);}
const EbmlCallbacks & Generic() const {return ClassInfos;}
static const EbmlCallbacks ClassInfos;
operator const EbmlId &() const {return ClassInfos.GlobalId;}
EbmlElement * Clone() const {return new KaxVideoPixelCropRight(*this);}
};
class MATROSKA_DLL_API KaxVideoDisplayWidth : public EbmlUInteger {
public:
KaxVideoDisplayWidth() {}
KaxVideoDisplayWidth(const KaxVideoDisplayWidth & ElementToClone) :EbmlUInteger(ElementToClone) {}
static EbmlElement & Create() {return *(new KaxVideoDisplayWidth);}
const EbmlCallbacks & Generic() const {return ClassInfos;}
static const EbmlCallbacks ClassInfos;
operator const EbmlId &() const {return ClassInfos.GlobalId;}
EbmlElement * Clone() const {return new KaxVideoDisplayWidth(*this);}
};
class MATROSKA_DLL_API KaxVideoDisplayHeight : public EbmlUInteger {
public:
KaxVideoDisplayHeight() {}
KaxVideoDisplayHeight(const KaxVideoDisplayHeight & ElementToClone) :EbmlUInteger(ElementToClone) {}
static EbmlElement & Create() {return *(new KaxVideoDisplayHeight);}
const EbmlCallbacks & Generic() const {return ClassInfos;}
static const EbmlCallbacks ClassInfos;
operator const EbmlId &() const {return ClassInfos.GlobalId;}
EbmlElement * Clone() const {return new KaxVideoDisplayHeight(*this);}
};
#if MATROSKA_VERSION >= 2
class MATROSKA_DLL_API KaxVideoDisplayUnit : public EbmlUInteger {
public:
KaxVideoDisplayUnit() {}
KaxVideoDisplayUnit(const KaxVideoDisplayUnit & ElementToClone) :EbmlUInteger(ElementToClone) {}
static EbmlElement & Create() {return *(new KaxVideoDisplayUnit);}
const EbmlCallbacks & Generic() const {return ClassInfos;}
static const EbmlCallbacks ClassInfos;
operator const EbmlId &() const {return ClassInfos.GlobalId;}
EbmlElement * Clone() const {return new KaxVideoDisplayUnit(*this);}
};
class MATROSKA_DLL_API KaxVideoAspectRatio : public EbmlUInteger {
public:
KaxVideoAspectRatio() {}
KaxVideoAspectRatio(const KaxVideoAspectRatio & ElementToClone) :EbmlUInteger(ElementToClone) {}
static EbmlElement & Create() {return *(new KaxVideoAspectRatio);}
const EbmlCallbacks & Generic() const {return ClassInfos;}
static const EbmlCallbacks ClassInfos;
operator const EbmlId &() const {return ClassInfos.GlobalId;}
EbmlElement * Clone() const {return new KaxVideoAspectRatio(*this);}
};
#endif // MATROSKA_VERSION
class MATROSKA_DLL_API KaxVideoColourSpace : public EbmlBinary {
public:
KaxVideoColourSpace() {}
KaxVideoColourSpace(const KaxVideoColourSpace & ElementToClone) :EbmlBinary(ElementToClone){}
static EbmlElement & Create() {return *(new KaxVideoColourSpace);}
const EbmlCallbacks & Generic() const {return ClassInfos;}
static const EbmlCallbacks ClassInfos;
bool ValidateSize(void) const {return (Size == 4);}
operator const EbmlId &() const {return ClassInfos.GlobalId;}
EbmlElement * Clone() const {return new KaxVideoColourSpace(*this);}
};
#if MATROSKA_VERSION >= 2
class MATROSKA_DLL_API KaxVideoGamma : public EbmlFloat {
public:
KaxVideoGamma() {}
KaxVideoGamma(const KaxVideoGamma & ElementToClone) :EbmlFloat(ElementToClone) {}
static EbmlElement & Create() {return *(new KaxVideoGamma);}
const EbmlCallbacks & Generic() const {return ClassInfos;}
static const EbmlCallbacks ClassInfos;
operator const EbmlId &() const {return ClassInfos.GlobalId;}
EbmlElement * Clone() const {return new KaxVideoGamma(*this);}
};
#endif // MATROSKA_VERSION
class MATROSKA_DLL_API KaxVideoFrameRate : public EbmlFloat {
public:
KaxVideoFrameRate() {}
KaxVideoFrameRate(const KaxVideoFrameRate & ElementToClone) :EbmlFloat(ElementToClone) {}
static EbmlElement & Create() {return *(new KaxVideoFrameRate);}
const EbmlCallbacks & Generic() const {return ClassInfos;}
static const EbmlCallbacks ClassInfos;
operator const EbmlId &() const {return ClassInfos.GlobalId;}
uint32 RenderData(IOCallback & output, bool bForceRender, bool bSaveDefault);
EbmlElement * Clone() const {return new KaxVideoFrameRate(*this);}
};
END_LIBMATROSKA_NAMESPACE
#endif // LIBMATROSKA_TRACK_VIDEO_H

96
matroska/KaxTracks.h Normal file
View File

@ -0,0 +1,96 @@
/****************************************************************************
** libmatroska : parse Matroska files, see http://www.matroska.org/
**
** <file/class description>
**
** Copyright (C) 2002-2004 Steve Lhomme. All rights reserved.
**
** This file is part of libmatroska.
**
** This library is free software; you can redistribute it and/or
** modify it under the terms of the GNU Lesser General Public
** License as published by the Free Software Foundation; either
** version 2.1 of the License, or (at your option) any later version.
**
** This library is distributed in the hope that it will be useful,
** but WITHOUT ANY WARRANTY; without even the implied warranty of
** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
** Lesser General Public License for more details.
**
** You should have received a copy of the GNU Lesser General Public
** License along with this library; if not, write to the Free Software
** Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
**
** See http://www.matroska.org/license/lgpl/ for LGPL licensing information.**
** Contact license@matroska.org if any conditions of this licensing are
** not clear to you.
**
**********************************************************************/
/*!
\file
\version \$Id: KaxTracks.h,v 1.7 2004/04/14 23:26:17 robux4 Exp $
\author Steve Lhomme <robux4 @ users.sf.net>
*/
#ifndef LIBMATROSKA_TRACKS_H
#define LIBMATROSKA_TRACKS_H
#include "matroska/KaxTypes.h"
#include "ebml/EbmlMaster.h"
#include "ebml/EbmlUInteger.h"
#include "matroska/KaxTrackEntryData.h"
using namespace LIBEBML_NAMESPACE;
START_LIBMATROSKA_NAMESPACE
class MATROSKA_DLL_API KaxTracks : public EbmlMaster {
public:
KaxTracks();
KaxTracks(const KaxTracks & ElementToClone) :EbmlMaster(ElementToClone) {}
static EbmlElement & Create() {return *(new KaxTracks);}
const EbmlCallbacks & Generic() const {return ClassInfos;}
static const EbmlCallbacks ClassInfos;
operator const EbmlId &() const {return ClassInfos.GlobalId;}
EbmlElement * Clone() const {return new KaxTracks(*this);}
};
class MATROSKA_DLL_API KaxTrackEntry : public EbmlMaster {
public:
KaxTrackEntry();
KaxTrackEntry(const KaxTrackEntry & ElementToClone) :EbmlMaster(ElementToClone) {}
static EbmlElement & Create() {return *(new KaxTrackEntry);}
const EbmlCallbacks & Generic() const {return ClassInfos;}
static const EbmlCallbacks ClassInfos;
operator const EbmlId &() const {return ClassInfos.GlobalId;}
EbmlElement * Clone() const {return new KaxTrackEntry(*this);}
EbmlUInteger & TrackNumber() const { return *(static_cast<EbmlUInteger *>(FindElt(KaxTrackNumber::ClassInfos))); }
void EnableLacing(bool bEnable = true);
/*!
\note lacing set by default
*/
inline bool LacingEnabled() const {
KaxTrackFlagLacing * myLacing = static_cast<KaxTrackFlagLacing *>(FindFirstElt(KaxTrackFlagLacing::ClassInfos));
return((myLacing == NULL) || (uint8(*myLacing) != 0));
}
void SetGlobalTimecodeScale(uint64 aGlobalTimecodeScale) {
mGlobalTimecodeScale = aGlobalTimecodeScale;
bGlobalTimecodeScaleIsSet = true;
}
uint64 GlobalTimecodeScale() const {
assert(bGlobalTimecodeScaleIsSet);
return mGlobalTimecodeScale;
}
protected:
bool bGlobalTimecodeScaleIsSet;
uint64 mGlobalTimecodeScale;
};
END_LIBMATROSKA_NAMESPACE
#endif // LIBMATROSKA_TRACKS_H

59
matroska/KaxTypes.h Normal file
View File

@ -0,0 +1,59 @@
/****************************************************************************
** libmatroska : parse Matroska files, see http://www.matroska.org/
**
** <file/class description>
**
** Copyright (C) 2002-2005 Steve Lhomme. All rights reserved.
**
** This file is part of libmatroska.
**
** This library is free software; you can redistribute it and/or
** modify it under the terms of the GNU Lesser General Public
** License as published by the Free Software Foundation; either
** version 2.1 of the License, or (at your option) any later version.
**
** This library is distributed in the hope that it will be useful,
** but WITHOUT ANY WARRANTY; without even the implied warranty of
** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
** Lesser General Public License for more details.
**
** You should have received a copy of the GNU Lesser General Public
** License along with this library; if not, write to the Free Software
** Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
**
** See http://www.matroska.org/license/lgpl/ for LGPL licensing information.**
** Contact license@matroska.org if any conditions of this licensing are
** not clear to you.
**
**********************************************************************/
/*!
\file
\version \$Id: KaxTypes.h,v 1.4 2004/04/14 23:26:17 robux4 Exp $
*/
#ifndef LIBMATROSKA_TYPES_H
#define LIBMATROSKA_TYPES_H
#include "matroska/KaxConfig.h"
#include "ebml/EbmlTypes.h"
#include "matroska/c/libmatroska_t.h"
START_LIBMATROSKA_NAMESPACE
enum LacingType {
LACING_NONE = 0,
LACING_XIPH,
LACING_FIXED,
LACING_EBML,
LACING_AUTO
};
enum BlockBlobType {
BLOCK_BLOB_NO_SIMPLE = 0,
BLOCK_BLOB_SIMPLE_AUTO,
BLOCK_BLOB_ALWAYS_SIMPLE,
};
END_LIBMATROSKA_NAMESPACE
#endif // LIBMATROSKA_TYPES_H

54
matroska/KaxVersion.h Normal file
View File

@ -0,0 +1,54 @@
/****************************************************************************
** <file/class description>
**
** Copyright (C) 2002-2005 Steve Lhomme. All rights reserved.
**
** This file is part of libmatroska.
**
** This library is free software; you can redistribute it and/or
** modify it under the terms of the GNU Lesser General Public
** License as published by the Free Software Foundation; either
** version 2.1 of the License, or (at your option) any later version.
**
** This library is distributed in the hope that it will be useful,
** but WITHOUT ANY WARRANTY; without even the implied warranty of
** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
** Lesser General Public License for more details.
**
** You should have received a copy of the GNU Lesser General Public
** License along with this library; if not, write to the Free Software
** Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
**
** See http://www.matroska.org/license/lgpl/ for LGPL licensing information.**
** Contact license@matroska.org if any conditions of this licensing are
** not clear to you.
**
**********************************************************************/
/*!
\file
\version \$Id: KaxVersion.h,v 1.13 2004/04/23 16:46:07 mosu Exp $
\author Steve Lhomme <robux4 @ users.sf.net>
*/
#ifndef LIBMATROSKA_VERSION_H
#define LIBMATROSKA_VERSION_H
#include <string>
#include "ebml/EbmlConfig.h"
#include "matroska/KaxConfig.h"
START_LIBMATROSKA_NAMESPACE
#define LIBMATROSKA_VERSION 0x000801
static const std::string KaxCodeVersion = "0.8.1";
static const std::string KaxCodeDate = __TIMESTAMP__;
/*!
\todo Improve the CRC/ECC system (backward and forward possible ?) to fit streaming/live writing/simple reading
*/
END_LIBMATROSKA_NAMESPACE
#endif // LIBMATROSKA_VERSION_H

119
matroska/c/libmatroska.h Normal file
View File

@ -0,0 +1,119 @@
/****************************************************************************
** libmatroska : parse Matroska files, see http://www.matroska.org/
**
** <file/class description>
**
** Copyright (C) 2002-2003 Steve Lhomme. All rights reserved.
**
** This file is part of libmatroska.
**
** This library is free software; you can redistribute it and/or
** modify it under the terms of the GNU Lesser General Public
** License as published by the Free Software Foundation; either
** version 2.1 of the License, or (at your option) any later version.
**
** This library is distributed in the hope that it will be useful,
** but WITHOUT ANY WARRANTY; without even the implied warranty of
** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
** Lesser General Public License for more details.
**
** You should have received a copy of the GNU Lesser General Public
** License along with this library; if not, write to the Free Software
** Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
**
** See http://www.matroska.org/license/lgpl/ for LGPL licensing information.
**
** Contact license@matroska.org if any conditions of this licensing are
** not clear to you.
**
**********************************************************************/
/*!
\file libmatroska.h
\version \$Id: libmatroska.h,v 1.2 2004/04/14 23:26:17 robux4 Exp $
\author Steve Lhomme <robux4 @ users.sf.net>
\author Ingo Ralf Blum <ingoralfblum @ users.sf.net>
\brief C API to the libmatroska library
\note These are the functions that should be exported (visible from outisde the library)
\todo Put a function here for all the MUST in the Matroska spec
\todo Put a brief description of each function, and a description of the params and return value
\todo Change the int values to sized types
*/
#ifndef _LIBMATROSKA_H_INCLUDED_
#define _LIBMATROSKA_H_INCLUDED_
#include "libmatroska_t.h"
#ifdef __cplusplus
extern "C" {
#endif
#ifdef OLD
/*!
\fn int matroska_plug_log(matroska_error_callback)
\brief Attach a callback to be informed when error occurs
\param callback The callback that will be called when logging occurs \return 0 if successfull
*/
int matroska_plug_log(matroska_error_callback callback);
/*!
\fn int matroska_unplug_log(matroska_error_callback)
\brief Unattach an attached callback to be informed when error occurs
\param callback The callback that was called when logging occurs \return 0 if successfull
*/
int matroska_unplug_log(matroska_error_callback callback);
/*!
\fn matroska_id matroska_open_file(c_string,matroska_file_mode)
\brief Open an instance of an Matroska file
\param string The name of the file to open (including OS depedant path) \param mode The mode to open the file (read, write, etc)
\return NULL if the opening failed or an ID that will be used to access this file from the API
*/
matroska_stream MATROSKA_EXPORT matroska_open_stream_file(c_string string, open_mode mode);
matroska_id MATROSKA_EXPORT matroska_open_stream(matroska_stream a_stream);
/*!
\fn matroska_id matroska_open_url(c_string)
\brief Open an instance of an Matroska file from a URL
\param string The name of the URL to open \return NULL if the opening failed or an ID that will be used to access this file from the API
\warning Open only for reading ?
\note It requires that Curl is compiled or installed
*/
matroska_id matroska_open_url(c_string string);
/*!
\fn int matroska_close(matroska_id)
\brief Close the specified Matroska instance
\param id The instance to close \return 0 if successfull
*/
void MATROSKA_EXPORT matroska_close(matroska_id id);
void MATROSKA_EXPORT matroska_end(matroska_id id, uint32 totaltime);
matroska_track MATROSKA_EXPORT matroska_create_track(matroska_id id, enum track_type type);
void MATROSKA_EXPORT matroska_read_head(matroska_id id);
void MATROSKA_EXPORT matroska_read_tracks(matroska_id id);
uint8 MATROSKA_EXPORT matroska_get_number_track(matroska_id id);
matroska_track MATROSKA_EXPORT matroska_get_track(matroska_id id, uint8 track_index);
void MATROSKA_EXPORT matroska_get_track_info(matroska_id id, matroska_track track, track_info * infos);
/*
int matroska_track_write_block(matroska_track, void* buffer, unsigned int size);
int matroska_track_close(matroska_track);
*/
#endif /* OLD */
#ifdef __cplusplus
}
#endif
#endif /* _LIBMATROSKA_H_INCLUDED_ */

108
matroska/c/libmatroska_t.h Normal file
View File

@ -0,0 +1,108 @@
/****************************************************************************
** libmatroska : parse Matroska files, see http://www.matroska.org/
**
** <file/class description>
**
** Copyright (C) 2002-2003 Steve Lhomme. All rights reserved.
**
** This file is part of libmatroska.
**
** This library is free software; you can redistribute it and/or
** modify it under the terms of the GNU Lesser General Public
** License as published by the Free Software Foundation; either
** version 2.1 of the License, or (at your option) any later version.
**
** This library is distributed in the hope that it will be useful,
** but WITHOUT ANY WARRANTY; without even the implied warranty of
** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
** Lesser General Public License for more details.
**
** You should have received a copy of the GNU Lesser General Public
** License along with this library; if not, write to the Free Software
** Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
**
** See http://www.matroska.org/license/lgpl/ for LGPL licensing information.**
** Contact license@matroska.org if any conditions of this licensing are
** not clear to you.
**
**********************************************************************/
/*!
\file libmatroska_t.h
\version \$Id: libmatroska_t.h,v 1.3 2004/04/14 23:26:17 robux4 Exp $
\author Steve Lhomme <robux4 @ users.sf.net>
\author Ingo Ralf Blum <ingoralfblum @ users.sf.net>
\brief Misc type definitions for the C API of libmatroska
\note These types should be compiler/language independant (just platform dependant)
\todo recover the sized types (uint16, int32, etc) here too (or maybe here only)
*/
#ifndef _LIBMATROSKA_T_H_INCLUDED_
#define _LIBMATROSKA_T_H_INCLUDED_
#include "ebml/c/libebml_t.h"
#ifdef __cplusplus
extern "C" {
#endif
/*!
\enum track_type
*/
typedef enum track_type {
track_video = 0x01, ///< Rectangle-shaped non-transparent pictures aka video
track_audio = 0x02, ///< Anything you can hear
track_complex = 0x03, ///< Audio and video in same track, used by DV
track_logo = 0x10, ///< Overlay-pictures, displayed over video
track_subtitle = 0x11, ///< Text-subtitles. One track contains one language and only one track can be active (player-side configuration)
track_buttons = 0x12, ///< Buttons meta-infos.
track_control = 0x20 ///< Control-codes for menus and other stuff
} track_type;
/*!
\enum matroska_error_t
\brief a callback that the library use to inform of errors happening
\note this should be used by the libmatroska internals
*/
typedef enum {
error_null_pointer ///< NULL pointer where something else is expected
} matroska_error_t;
typedef void *matroska_stream;
/*!
\var void* matroska_id
\brief UID used to access an Matroska file instance
*/
typedef void* matroska_id;
/*!
\var void* matroska_track
\brief UID used to access a track
*/
typedef void* matroska_track;
/*!
\var char* c_string
\brief C-String, ie a buffer with characters terminated by \0
*/
typedef char* c_string;
/*!
\var unsigned int matroska_file_mode
\brief A bit buffer, each bit representing a value for the file opening
\todo replace the unsigned int by a sized type (8 or 16 bits)
*/
typedef char * matroska_file_mode;
/*!
\var void (*matroska_error_callback)(matroska_error_t error_code, char* error_message)
\brief a callback that the library use to inform of errors happening
*/
typedef void (*matroska_error_callback)(matroska_error_t error_code, char* error_message);
#ifdef __cplusplus
}
#endif
#endif /* _LIBMATROSKA_T_H_INCLUDED_ */

449
src/FileKax.cpp Normal file
View File

@ -0,0 +1,449 @@
/****************************************************************************
** libmatroska : parse Matroska files, see http://www.matroska.org/
**
** <file/class description>
**
** Copyright (C) 2002-2003 Steve Lhomme. All rights reserved.
**
** This file is part of libmatroska.
**
** This library is free software; you can redistribute it and/or
** modify it under the terms of the GNU Lesser General Public
** License as published by the Free Software Foundation; either
** version 2.1 of the License, or (at your option) any later version.
**
** This library is distributed in the hope that it will be useful,
** but WITHOUT ANY WARRANTY; without even the implied warranty of
** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
** Lesser General Public License for more details.
**
** You should have received a copy of the GNU Lesser General Public
** License along with this library; if not, write to the Free Software
** Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
**
** See http://www.matroska.org/license/lgpl/ for LGPL licensing information.**
** Contact license@matroska.org if any conditions of this licensing are
** not clear to you.
**
**********************************************************************/
/*!
\file
\version \$Id: FileKax.cpp 640 2004-07-09 21:05:36Z mosu $
\author Steve Lhomme <robux4 @ users.sf.net>
*/
//#include "StdInclude.h"
#include "matroska/FileKax.h"
//#include "Cluster.h"
//#include "Track.h"
//#include "Block.h"
//#include "Frame.h"
//#include "Version.h"
START_LIBMATROSKA_NAMESPACE
//typedef Track *TrackID;
FileMatroska::FileMatroska(IOCallback & output)
:myFile(output)
#ifdef OLD
,myCurrReadBlock(NULL)
,myMinClusterSize(5*1024) // 5KB is the min size of a cluster
,myMaxClusterSize(2*1024*1024) // 2MB is the max size of a cluster
,myCurrReadBlockTrack(0)
,myCurrWriteCluster(2*1024*1024) // myMaxClusterSize
,myCurrReadCluster(NULL)
,myReadBlockNumber(0)
#endif // OLD
{
#ifdef OLD
myStreamInfo.MainHeaderSize = TypeHeader::default_size() +
ActualHeader::default_size() +
ExtendedInfo::default_size() +
ContentInfo::default_size();
myStreamInfo.TrackEntrySize = Track::default_size();
myStreamInfo.BlockHeadSize = BLOCK_HEADER_SIZE;
myStreamInfo.ClusterHeadSize = CLUSTER_HEADER_SIZE;
myStreamInfo.ClusterFootSize = CLUSTER_TRAILER_SIZE;
#endif // OLD
}
FileMatroska::~FileMatroska()
{
// if (myCurrCluster != NULL)
// throw 0; // there are some data left to write
// if (myCurrReadCluster != NULL || myCurrReadBlock != NULL)
// throw 0; // there are some data left to write
}
#ifdef OLD
void FileMatroska::SetMaxClusterSize(const uint32 value)
{
myMaxClusterSize = value;
myCurrWriteCluster.setMaxSize(value);
}
void FileMatroska::Close(const uint32 aTimeLength)
{
Flush();
// get the file size
myFile.setFilePointer(0,seek_end);
myMainHeader.type_SetSize(myFile.getFilePointer());
// rewrite the header at the beginning
myFile.setFilePointer(0,seek_beginning);
// get the Track-entry size
uint32 track_entries_size = 0;
for (size_t i=0; i<myTracks.size(); i++)
{
track_entries_size += myTracks[i]->default_size();
}
myStreamInfo.TrackEntriesSize = track_entries_size;
myStreamInfo.TimeLength = aTimeLength;
myMainHeader.Render(myFile, myStreamInfo);
for (i=0; i<myTracks.size(); i++)
{
delete myTracks[i];
}
}
/*!
\warning after rendering the head, some parameters are locked
*/
uint32 FileMatroska::RenderHead(const std::string & aEncoderApp)
{
try {
uint32 track_entries_size = 0;
for (size_t i=0; i<myTracks.size(); i++)
{
track_entries_size += myTracks[i]->default_size();
}
std::string aStr = LIB_NAME;
aStr += " ";
aStr += VERSION;
myStreamInfo.EncoderLib = aStr;
myStreamInfo.EncoderApp = aEncoderApp;
myStreamInfo.TrackEntryPosition = 0 + myStreamInfo.MainHeaderSize;
myStreamInfo.TrackEntriesSize = myTracks.size() * myStreamInfo.TrackEntrySize;
myStreamInfo.CodecEntryPosition = myStreamInfo.MainHeaderSize + myStreamInfo.TrackEntriesSize;
myStreamInfo.CodecEntrySize = 4;
for (i=0; i<myTracks.size(); i++)
{
myStreamInfo.CodecEntrySize += myTracks[i]->CodecSize();
}
// Main Header
uint32 result = myMainHeader.Render(myFile, myStreamInfo);
// Track Entries
for (i=0; i<myTracks.size(); i++)
{
myTracks[i]->RenderEntry(myFile, i+1);
}
myStreamInfo.ClusterPosition = myStreamInfo.CodecEntryPosition + myStreamInfo.CodecEntrySize;
// Codec Header
result = CodecHeader::Render(myFile, myTracks);
return result;
}
catch (exception & Ex)
{
throw Ex;
}
}
/*!
\return 0 if the track was not created, or a valid track number
*/
Track * FileMatroska::CreateTrack(const track_type aType)
{
myTracks.push_back(new Track(aType));
return myTracks.back();
}
/*Track *FileMatroska::findTrack(Track * aTrack) const
{
for (size_t i=0; i<myTracks.size(); i++)
{
if (myTracks[i] == aTrack)
return myTracks[i];
}
return NULL;
}*/
void FileMatroska::track_SetName(Track * aTrack, const std::string & aName)
{
if (IsMyTrack(aTrack))
{
aTrack->SetName(aName);
}
}
void FileMatroska::track_SetLaced(Track * aTrack, const bool bLaced)
{
if (IsMyTrack(aTrack))
{
aTrack->SetLaced(bLaced);
}
}
bool FileMatroska::AddFrame(Track * aTrack, const uint32 aTimecode, const binary *aFrame, const uint32 aFrameSize,
const bool aKeyFrame, const bool aBFrame)
{
try {
// make sure we know that track
if (IsMyTrack(aTrack))
{
// pass the cluster to the track
// handle the creation of a new cluster if needed
if (aTrack->AddFrame(aTimecode, aFrame, aFrameSize, aKeyFrame, aBFrame))
{
while (!aTrack->SerialiseBlock(myCurrWriteCluster))
{
/// \todo handle errors
uint32 aNbBlock;
myStreamInfo.ClusterSize += myCurrWriteCluster.Render(myFile, aNbBlock);
myStreamInfo.NumberBlock += aNbBlock;
myCurrWriteCluster.Flush();
}
}
return true;
}
return false;
}
catch (exception & Ex)
{
throw Ex;
}
}
void FileMatroska::Flush()
{
uint32 aNbBlock;
myStreamInfo.ClusterSize += myCurrWriteCluster.Render(myFile,aNbBlock);
myStreamInfo.NumberBlock += aNbBlock;
}
uint32 FileMatroska::ReadHead()
{
try {
uint32 result = myMainHeader.Read(myFile, myStreamInfo);
return result;
}
catch (exception & Ex)
{
throw Ex;
}
}
uint32 FileMatroska::ReadTracks()
{
try {
uint32 result = 0;
// seek to the start of the Track Entries
myFile.setFilePointer(myStreamInfo.TrackEntryPosition);
// get the number of Track Entries
uint8 TrackNumber = myStreamInfo.TrackEntriesSize / myStreamInfo.TrackEntrySize;
// read all the Track Entries
myTracks.clear();
for (uint8 TrackIdx = 0; TrackIdx<TrackNumber; TrackIdx ++) {
Track * tmpTrack = Track::ReadEntry(myFile, TrackIdx+1, myStreamInfo);
if (tmpTrack == NULL)
throw 0;
myTracks.push_back(tmpTrack);
}
return result;
}
catch (exception & Ex)
{
throw Ex;
}
}
uint32 FileMatroska::ReadCodec()
{
try {
// seek to the start of the Track Entries
myFile.setFilePointer(myStreamInfo.CodecEntryPosition);
uint32 result = CodecHeader::Read(myFile, myTracks);
return result;
}
catch (exception & Ex)
{
throw Ex;
}
}
inline bool FileMatroska::IsMyTrack(const Track * aTrack) const
{
if (aTrack == 0)
throw 0;
for (std::vector<Track*>::const_iterator i = myTracks.begin(); i != myTracks.end(); i ++)
{
if (*i == aTrack)
break;
}
if (i != myTracks.end())
return true;
else
return false;
}
void FileMatroska::SelectReadingTrack(Track * aTrack, bool select)
{
if (IsMyTrack(aTrack))
{
// here we have the right track
// check if it's not already selected
for (std::vector<uint8>::iterator j = mySelectedTracks.begin();
j != mySelectedTracks.end(); j ++)
{
if (*j == aTrack->TrackNumber())
break;
}
if (select && j == mySelectedTracks.end())
mySelectedTracks.push_back(aTrack->TrackNumber());
else if (!select && j != mySelectedTracks.end())
mySelectedTracks.erase(j);
std::sort(mySelectedTracks.begin(), mySelectedTracks.end());
}
}
inline bool FileMatroska::IsReadingTrack(const uint8 aTrackNumber) const
{
for (std::vector<uint8>::const_iterator trackIdx = mySelectedTracks.begin();
trackIdx != mySelectedTracks.end() && *trackIdx < aTrackNumber;
trackIdx++)
{}
if (trackIdx == mySelectedTracks.end())
return false;
else
return true;
}
//
void FileMatroska::Track_GetInfo(const Track * aTrack, TrackInfo & aTrackInfo) const
{
if (IsMyTrack(aTrack))
{
aTrack->GetInfo(aTrackInfo);
}
}
// Audio related getters/setters
void FileMatroska::Track_GetInfo_Audio(const Track * aTrack, TrackInfoAudio & aTrackInfo) const
{
if (IsMyTrack(aTrack))
{
aTrack->GetInfoAudio(aTrackInfo);
}
}
void FileMatroska::Track_SetInfo_Audio(Track * aTrack, const TrackInfoAudio & aTrackInfo)
{
if (IsMyTrack(aTrack))
{
aTrack->SetInfoAudio(aTrackInfo);
}
}
// Video related getters/setters
void FileMatroska::Track_GetInfo_Video(const Track * aTrack, TrackInfoVideo & aTrackInfo) const
{
if (IsMyTrack(aTrack))
{
aTrack->GetInfoVideo(aTrackInfo);
}
}
void FileMatroska::Track_SetInfo_Video(Track * aTrack, const TrackInfoVideo & aTrackInfo)
{
if (IsMyTrack(aTrack))
{
aTrack->SetInfoVideo(aTrackInfo);
}
}
/*!
\todo exit when there is no Block left
*/
bool FileMatroska::ReadFrame(Track * & aTrack, uint32 & aTimecode, const binary * & aFrame, uint32 & aFrameSize,
bool & aKeyFrame, bool & aBFrame)
{
if (myCurrReadBlockTrack == 0)
{
do {
if (myReadBlockNumber >= myStreamInfo.NumberBlock)
{
// myReadBlockNumber = myStreamInfo.NumberBlock;
return false;
}
// get the next frame in the file
if (!myCurrReadCluster.BlockLeft())
{
myCurrReadCluster.Flush();
try {
myCurrReadCluster.FindHead(myFile);
}
catch (exception & Ex)
{
return false;
}
}
myCurrReadCluster.GetBlock( myCurrReadBlock, myCurrReadBlockSize, myCurrReadBlockTrack );
myReadBlockNumber++;
} while (!IsReadingTrack(myCurrReadBlockTrack));
// get the track associated (normally from myTracks)
aTrack = myTracks[myCurrReadBlockTrack-1];
// get the next frame from the current block
aTrack->HandleBlock(myCurrReadBlock, myCurrReadBlockSize);
}
else
{
// get the track associated (normally from myTracks)
aTrack = myTracks[myCurrReadBlockTrack-1];
}
Frame * myReadFrame;
aTrack->GetNextFrame(aTimecode, myReadFrame, aKeyFrame, aBFrame);
aFrame = myReadFrame->buf();
aFrameSize = myReadFrame->length();
if (aTrack->NoFrameLeft())
{
aTrack->FlushBlock();
myCurrReadBlockTrack = 0;
}
return true;
}
#endif // OLD
END_LIBMATROSKA_NAMESPACE

96
src/KaxAttached.cpp Normal file
View File

@ -0,0 +1,96 @@
/****************************************************************************
** libmatroska : parse Matroska files, see http://www.matroska.org/
**
** <file/class description>
**
** Copyright (C) 2002-2004 Steve Lhomme. All rights reserved.
**
** This file is part of libmatroska.
**
** This library is free software; you can redistribute it and/or
** modify it under the terms of the GNU Lesser General Public
** License as published by the Free Software Foundation; either
** version 2.1 of the License, or (at your option) any later version.
**
** This library is distributed in the hope that it will be useful,
** but WITHOUT ANY WARRANTY; without even the implied warranty of
** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
** Lesser General Public License for more details.
**
** You should have received a copy of the GNU Lesser General Public
** License along with this library; if not, write to the Free Software
** Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
**
** See http://www.matroska.org/license/lgpl/ for LGPL licensing information.**
** Contact license@matroska.org if any conditions of this licensing are
** not clear to you.
**
**********************************************************************/
/*!
\file
\version \$Id: KaxAttached.cpp 1202 2005-08-30 14:39:01Z robux4 $
\author Steve Lhomme <robux4 @ users.sf.net>
*/
#include "matroska/KaxAttached.h"
#include "matroska/KaxContexts.h"
// sub elements
using namespace LIBEBML_NAMESPACE;
START_LIBMATROSKA_NAMESPACE
#if MATROSKA_VERSION == 1
EbmlSemantic KaxAttached_ContextList[5] =
#else // MATROSKA_VERSION
EbmlSemantic KaxAttached_ContextList[6] =
#endif // MATROSKA_VERSION
{
EbmlSemantic(true, true, KaxFileName::ClassInfos),
EbmlSemantic(true, true, KaxMimeType::ClassInfos),
EbmlSemantic(true, true, KaxFileData::ClassInfos),
EbmlSemantic(false, true, KaxFileDescription::ClassInfos),
EbmlSemantic(true, true, KaxFileUID::ClassInfos),
#if MATROSKA_VERSION >= 2
EbmlSemantic(false, true, KaxFileReferral::ClassInfos),
#endif // MATROSKA_VERSION
};
EbmlId KaxAttached_TheId (0x61A7, 2);
EbmlId KaxFileDescription_TheId(0x467E, 2);
EbmlId KaxFileName_TheId (0x466E, 2);
EbmlId KaxMimeType_TheId (0x4660, 2);
EbmlId KaxFileData_TheId (0x465C, 2);
EbmlId KaxFileUID_TheId (0x46AE, 2);
#if MATROSKA_VERSION >= 2
EbmlId KaxFileReferral_TheId (0x4675, 2);
#endif // MATROSKA_VERSION
const EbmlSemanticContext KaxAttached_Context = EbmlSemanticContext(countof(KaxAttached_ContextList), KaxAttached_ContextList, &KaxAttachments_Context, *GetKaxGlobal_Context, &KaxAttached::ClassInfos);
const EbmlSemanticContext KaxFileDescription_Context = EbmlSemanticContext(0, NULL, &KaxAttachments_Context, *GetKaxGlobal_Context, &KaxFileDescription::ClassInfos);
const EbmlSemanticContext KaxFileName_Context = EbmlSemanticContext(0, NULL, &KaxAttachments_Context, *GetKaxGlobal_Context, &KaxFileName::ClassInfos);
const EbmlSemanticContext KaxMimeType_Context = EbmlSemanticContext(0, NULL, &KaxAttachments_Context, *GetKaxGlobal_Context, &KaxMimeType::ClassInfos);
const EbmlSemanticContext KaxFileData_Context = EbmlSemanticContext(0, NULL, &KaxAttachments_Context, *GetKaxGlobal_Context, &KaxFileData::ClassInfos);
const EbmlSemanticContext KaxFileUID_Context = EbmlSemanticContext(0, NULL, &KaxAttachments_Context, *GetKaxGlobal_Context, &KaxFileUID::ClassInfos);
#if MATROSKA_VERSION >= 2
const EbmlSemanticContext KaxFileReferral_Context = EbmlSemanticContext(0, NULL, &KaxAttachments_Context, *GetKaxGlobal_Context, &KaxFileReferral::ClassInfos);
#endif // MATROSKA_VERSION
const EbmlCallbacks KaxAttached::ClassInfos(KaxAttached::Create, KaxAttached_TheId, "AttachedFile", KaxAttached_Context);
const EbmlCallbacks KaxFileDescription::ClassInfos(KaxFileDescription::Create, KaxFileDescription_TheId, "FileDescription", KaxFileDescription_Context);
const EbmlCallbacks KaxFileName::ClassInfos(KaxFileName::Create, KaxFileName_TheId, "FileName", KaxFileName_Context);
const EbmlCallbacks KaxMimeType::ClassInfos(KaxMimeType::Create, KaxMimeType_TheId, "FileMimeType", KaxMimeType_Context);
const EbmlCallbacks KaxFileData::ClassInfos(KaxFileData::Create, KaxFileData_TheId, "FileData", KaxFileData_Context);
const EbmlCallbacks KaxFileUID::ClassInfos(KaxFileUID::Create, KaxFileUID_TheId, "FileUID", KaxFileUID_Context);
#if MATROSKA_VERSION >= 2
const EbmlCallbacks KaxFileReferral::ClassInfos(KaxFileReferral::Create, KaxFileReferral_TheId, "FileReferral", KaxFileReferral_Context);
#endif // MATROSKA_VERSION
KaxAttached::KaxAttached()
:EbmlMaster(KaxAttached_Context)
{
SetSizeLength(2); // mandatory min size support (for easier updating) (2^(7*2)-2 = 16Ko)
}
END_LIBMATROSKA_NAMESPACE

60
src/KaxAttachments.cpp Normal file
View File

@ -0,0 +1,60 @@
/****************************************************************************
** libmatroska : parse Matroska files, see http://www.matroska.org/
**
** <file/class description>
**
** Copyright (C) 2002-2004 Steve Lhomme. All rights reserved.
**
** This file is part of libmatroska.
**
** This library is free software; you can redistribute it and/or
** modify it under the terms of the GNU Lesser General Public
** License as published by the Free Software Foundation; either
** version 2.1 of the License, or (at your option) any later version.
**
** This library is distributed in the hope that it will be useful,
** but WITHOUT ANY WARRANTY; without even the implied warranty of
** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
** Lesser General Public License for more details.
**
** You should have received a copy of the GNU Lesser General Public
** License along with this library; if not, write to the Free Software
** Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
**
** See http://www.matroska.org/license/lgpl/ for LGPL licensing information.**
** Contact license@matroska.org if any conditions of this licensing are
** not clear to you.
**
**********************************************************************/
/*!
\file
\version \$Id: KaxAttachments.cpp 640 2004-07-09 21:05:36Z mosu $
\author Steve Lhomme <robux4 @ users.sf.net>
*/
#include "matroska/KaxAttachments.h"
#include "matroska/KaxAttached.h"
#include "matroska/KaxContexts.h"
using namespace LIBEBML_NAMESPACE;
// sub elements
START_LIBMATROSKA_NAMESPACE
EbmlSemantic KaxAttachments_ContextList[1] =
{
EbmlSemantic(true, false, KaxAttached::ClassInfos), ///< EBMLVersion
};
const EbmlSemanticContext KaxAttachments_Context = EbmlSemanticContext(countof(KaxAttachments_ContextList), KaxAttachments_ContextList, &KaxSegment_Context, *GetKaxGlobal_Context, &KaxAttachments::ClassInfos);
EbmlId KaxAttachments_TheId(0x1941A469, 4);
const EbmlCallbacks KaxAttachments::ClassInfos(KaxAttachments::Create, KaxAttachments_TheId, "Attachments", KaxAttachments_Context);
KaxAttachments::KaxAttachments()
:EbmlMaster(KaxAttachments_Context)
{
SetSizeLength(2); // mandatory min size support (for easier updating) (2^(7*2)-2 = 16Ko)
}
END_LIBMATROSKA_NAMESPACE

1096
src/KaxBlock.cpp Normal file

File diff suppressed because it is too large Load Diff

138
src/KaxBlockData.cpp Normal file
View File

@ -0,0 +1,138 @@
/****************************************************************************
** libmatroska : parse Matroska files, see http://www.matroska.org/
**
** <file/class description>
**
** Copyright (C) 2002-2005 Steve Lhomme. All rights reserved.
**
** This library is free software; you can redistribute it and/or
** modify it under the terms of the GNU Lesser General Public
** License as published by the Free Software Foundation; either
** version 2.1 of the License, or (at your option) any later version.
**
** This library is distributed in the hope that it will be useful,
** but WITHOUT ANY WARRANTY; without even the implied warranty of
** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
** Lesser General Public License for more details.
**
** You should have received a copy of the GNU Lesser General Public
** License along with this library; if not, write to the Free Software
** Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
**
** See http://www.matroska.org/license/lgpl/ for LGPL licensing information.**
** Contact license@matroska.org if any conditions of this licensing are
** not clear to you.
**
**********************************************************************/
/*!
\file
\version \$Id: KaxBlockData.cpp 1226 2005-10-13 21:16:43Z robux4 $
\author Steve Lhomme <robux4 @ users.sf.net>
*/
#include <cassert>
#include "matroska/KaxBlockData.h"
#include "matroska/KaxContexts.h"
#include "matroska/KaxBlock.h"
using namespace LIBEBML_NAMESPACE;
START_LIBMATROSKA_NAMESPACE
const EbmlSemantic KaxSlices_ContextList[1] =
{
EbmlSemantic(false, false, KaxTimeSlice::ClassInfos),
};
const EbmlSemantic KaxTimeSlice_ContextList[5] =
{
EbmlSemantic(false, true, KaxSliceLaceNumber::ClassInfos),
EbmlSemantic(false, true, KaxSliceFrameNumber::ClassInfos),
EbmlSemantic(false, true, KaxSliceBlockAddID::ClassInfos),
EbmlSemantic(false, true, KaxSliceDelay::ClassInfos),
EbmlSemantic(false, true, KaxSliceDuration::ClassInfos),
};
EbmlId KaxReferencePriority_TheId(0xFA, 1);
EbmlId KaxReferenceBlock_TheId (0xFB, 1);
EbmlId KaxSlices_TheId (0x8E, 1);
EbmlId KaxTimeSlice_TheId (0xE8, 1);
EbmlId KaxSliceLaceNumber_TheId (0xCC, 1);
EbmlId KaxSliceFrameNumber_TheId (0xCD, 1);
EbmlId KaxSliceBlockAddID_TheId (0xCB, 1);
EbmlId KaxSliceDelay_TheId (0xCE, 1);
EbmlId KaxSliceDuration_TheId (0xCF, 1);
#if MATROSKA_VERSION >= 2
EbmlId KaxReferenceVirtual_TheId (0xFD, 1);
#endif // MATROSKA_VERSION
const EbmlSemanticContext KaxReferencePriority_Context = EbmlSemanticContext(0, NULL, &KaxBlockGroup_Context, *GetKaxGlobal_Context, &KaxReferencePriority::ClassInfos);
const EbmlSemanticContext KaxReferenceBlock_Context = EbmlSemanticContext(0, NULL, &KaxBlockGroup_Context, *GetKaxGlobal_Context, &KaxReferenceBlock::ClassInfos);
const EbmlSemanticContext KaxSlices_Context = EbmlSemanticContext(countof(KaxSlices_ContextList), KaxSlices_ContextList, &KaxBlockGroup_Context, *GetKaxGlobal_Context, &KaxSlices::ClassInfos);
const EbmlSemanticContext KaxTimeSlice_Context = EbmlSemanticContext(countof(KaxTimeSlice_ContextList), KaxTimeSlice_ContextList, &KaxSlices_Context, *GetKaxGlobal_Context, &KaxTimeSlice::ClassInfos);
const EbmlSemanticContext KaxSliceLaceNumber_Context = EbmlSemanticContext(0, NULL, &KaxTimeSlice_Context, *GetKaxGlobal_Context, &KaxSliceLaceNumber::ClassInfos);
const EbmlSemanticContext KaxSliceFrameNumber_Context = EbmlSemanticContext(0, NULL, &KaxTimeSlice_Context, *GetKaxGlobal_Context, &KaxSliceFrameNumber::ClassInfos);
const EbmlSemanticContext KaxSliceBlockAddID_Context = EbmlSemanticContext(0, NULL, &KaxTimeSlice_Context, *GetKaxGlobal_Context, &KaxSliceBlockAddID::ClassInfos);
const EbmlSemanticContext KaxSliceDelay_Context = EbmlSemanticContext(0, NULL, &KaxTimeSlice_Context, *GetKaxGlobal_Context, &KaxSliceDelay::ClassInfos);
const EbmlSemanticContext KaxSliceDuration_Context = EbmlSemanticContext(0, NULL, &KaxTimeSlice_Context, *GetKaxGlobal_Context, &KaxSliceDuration::ClassInfos);
#if MATROSKA_VERSION >= 2
const EbmlSemanticContext KaxReferenceVirtual_Context = EbmlSemanticContext(0, NULL, &KaxBlockGroup_Context, *GetKaxGlobal_Context, &KaxReferenceVirtual::ClassInfos);
#endif // MATROSKA_VERSION
const EbmlCallbacks KaxReferencePriority::ClassInfos(KaxReferencePriority::Create, KaxReferencePriority_TheId, "FlagReferenced", KaxReferencePriority_Context);
const EbmlCallbacks KaxReferenceBlock::ClassInfos(KaxReferenceBlock::Create, KaxReferenceBlock_TheId, "ReferenceBlock", KaxReferenceBlock_Context);
const EbmlCallbacks KaxSlices::ClassInfos(KaxSlices::Create, KaxSlices_TheId, "Slices", KaxSlices_Context);
const EbmlCallbacks KaxTimeSlice::ClassInfos(KaxTimeSlice::Create, KaxTimeSlice_TheId, "TimeSlice", KaxTimeSlice_Context);
const EbmlCallbacks KaxSliceLaceNumber::ClassInfos(KaxSliceLaceNumber::Create, KaxSliceLaceNumber_TheId, "SliceLaceNumber", KaxSliceLaceNumber_Context);
const EbmlCallbacks KaxSliceFrameNumber::ClassInfos(KaxSliceFrameNumber::Create, KaxSliceFrameNumber_TheId, "SliceFrameNumber", KaxSliceFrameNumber_Context);
const EbmlCallbacks KaxSliceBlockAddID::ClassInfos(KaxSliceBlockAddID::Create, KaxSliceBlockAddID_TheId, "SliceBlockAddID", KaxSliceBlockAddID_Context);
const EbmlCallbacks KaxSliceDelay::ClassInfos(KaxSliceDelay::Create, KaxSliceDelay_TheId, "SliceDelay", KaxSliceDelay_Context);
const EbmlCallbacks KaxSliceDuration::ClassInfos(KaxSliceDuration::Create, KaxSliceDuration_TheId, "SliceDuration", KaxSliceDuration_Context);
#if MATROSKA_VERSION >= 2
const EbmlCallbacks KaxReferenceVirtual::ClassInfos(KaxReferenceVirtual::Create, KaxReferenceVirtual_TheId, "ReferenceVirtual", KaxReferenceVirtual_Context);
#endif // MATROSKA_VERSION
KaxSlices::KaxSlices()
:EbmlMaster(KaxSlices_Context)
{}
KaxTimeSlice::KaxTimeSlice()
:EbmlMaster(KaxTimeSlice_Context)
{}
const KaxBlockBlob & KaxReferenceBlock::RefBlock() const
{
assert(RefdBlock != NULL);
return *RefdBlock;
}
uint64 KaxReferenceBlock::UpdateSize(bool bSaveDefault, bool bForceRender)
{
if (!bTimecodeSet) {
assert(RefdBlock != NULL);
assert(ParentBlock != NULL);
const KaxInternalBlock &block = *RefdBlock;
Value = (int64(block.GlobalTimecode()) - int64(ParentBlock->GlobalTimecode())) / int64(ParentBlock->GlobalTimecodeScale());
}
return EbmlSInteger::UpdateSize(bSaveDefault, bForceRender);
}
void KaxReferenceBlock::SetReferencedBlock(const KaxBlockBlob * aRefdBlock)
{
assert(RefdBlock == NULL);
assert(aRefdBlock != NULL);
RefdBlock = aRefdBlock;
bValueIsSet = true;
}
void KaxReferenceBlock::SetReferencedBlock(const KaxBlockGroup & aRefdBlock)
{
KaxBlockBlob *block_blob = new KaxBlockBlob(BLOCK_BLOB_NO_SIMPLE);
block_blob->SetBlockGroup(*const_cast<KaxBlockGroup*>(&aRefdBlock));
RefdBlock = block_blob;
bValueIsSet = true;
}
END_LIBMATROSKA_NAMESPACE

208
src/KaxChapters.cpp Normal file
View File

@ -0,0 +1,208 @@
/****************************************************************************
** libmatroska : parse Matroska files, see http://www.matroska.org/
**
** <file/class description>
**
** Copyright (C) 2002-2005 Steve Lhomme. All rights reserved.
**
** This file is part of libmatroska.
**
** This library is free software; you can redistribute it and/or
** modify it under the terms of the GNU Lesser General Public
** License as published by the Free Software Foundation; either
** version 2.1 of the License, or (at your option) any later version.
**
** This library is distributed in the hope that it will be useful,
** but WITHOUT ANY WARRANTY; without even the implied warranty of
** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
** Lesser General Public License for more details.
**
** You should have received a copy of the GNU Lesser General Public
** License along with this library; if not, write to the Free Software
** Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
**
** See http://www.matroska.org/license/lgpl/ for LGPL licensing information.**
** Contact license@matroska.org if any conditions of this licensing are
** not clear to you.
**
**********************************************************************/
/*!
\file
\version \$Id: KaxChapters.cpp 1201 2005-08-30 14:28:27Z robux4 $
\author Steve Lhomme <robux4 @ users.sf.net>
*/
#include "matroska/KaxChapters.h"
#include "matroska/KaxContexts.h"
// sub elements
START_LIBMATROSKA_NAMESPACE
EbmlSemantic KaxChapters_ContextList[1] =
{
EbmlSemantic(true, false, KaxEditionEntry::ClassInfos),
};
EbmlSemantic KaxEditionEntry_ContextList[5] =
{
EbmlSemantic(false, true , KaxEditionUID::ClassInfos),
EbmlSemantic(true , true , KaxEditionFlagHidden::ClassInfos),
EbmlSemantic(true , true , KaxEditionFlagDefault::ClassInfos),
EbmlSemantic(false, true , KaxEditionFlagOrdered::ClassInfos),
EbmlSemantic(true , false, KaxChapterAtom::ClassInfos),
};
EbmlSemantic KaxChapterAtom_ContextList[12] =
{
EbmlSemantic(false, false, KaxChapterAtom::ClassInfos),
EbmlSemantic(true, true, KaxChapterUID::ClassInfos),
EbmlSemantic(true, true, KaxChapterTimeStart::ClassInfos),
EbmlSemantic(false, true, KaxChapterTimeEnd::ClassInfos),
EbmlSemantic(true , true, KaxChapterFlagHidden::ClassInfos),
EbmlSemantic(true , true, KaxChapterFlagEnabled::ClassInfos),
EbmlSemantic(false, true, KaxChapterSegmentUID::ClassInfos),
EbmlSemantic(false, true, KaxChapterSegmentEditionUID::ClassInfos),
EbmlSemantic(false, true, KaxChapterPhysicalEquiv::ClassInfos),
EbmlSemantic(false, true, KaxChapterTrack::ClassInfos),
EbmlSemantic(false, false, KaxChapterDisplay::ClassInfos),
EbmlSemantic(false, false, KaxChapterProcess::ClassInfos),
};
EbmlSemantic KaxChapterTrack_ContextList[1] =
{
EbmlSemantic(true, false, KaxChapterTrackNumber::ClassInfos),
};
EbmlSemantic KaxChapterDisplay_ContextList[3] =
{
EbmlSemantic(true, true, KaxChapterString::ClassInfos),
EbmlSemantic(true, false, KaxChapterLanguage::ClassInfos),
EbmlSemantic(false, false, KaxChapterCountry::ClassInfos),
};
EbmlSemantic KaxChapterProcess_ContextList[3] =
{
EbmlSemantic(true, true, KaxChapterProcessCodecID::ClassInfos),
EbmlSemantic(false, true, KaxChapterProcessPrivate::ClassInfos),
EbmlSemantic(false, false, KaxChapterProcessCommand::ClassInfos),
};
EbmlSemantic KaxChapterProcessCommand_ContextList[2] =
{
EbmlSemantic(true, true, KaxChapterProcessTime::ClassInfos),
EbmlSemantic(true, true, KaxChapterProcessData::ClassInfos),
};
const EbmlSemanticContext KaxChapters_Context = EbmlSemanticContext(countof(KaxChapters_ContextList), KaxChapters_ContextList, &KaxSegment_Context, *GetKaxGlobal_Context, &KaxChapters::ClassInfos);
const EbmlSemanticContext KaxEditionEntry_Context = EbmlSemanticContext(countof(KaxEditionEntry_ContextList), KaxEditionEntry_ContextList, &KaxChapters_Context, *GetKaxGlobal_Context, &KaxEditionEntry::ClassInfos);
const EbmlSemanticContext KaxEditionUID_Context = EbmlSemanticContext(0, NULL, &KaxEditionEntry_Context, *GetKaxGlobal_Context, &KaxEditionUID::ClassInfos);
const EbmlSemanticContext KaxEditionFlagHidden_Context = EbmlSemanticContext(0, NULL, &KaxEditionEntry_Context, *GetKaxGlobal_Context, &KaxEditionFlagHidden::ClassInfos);
const EbmlSemanticContext KaxEditionFlagDefault_Context = EbmlSemanticContext(0, NULL, &KaxEditionEntry_Context, *GetKaxGlobal_Context, &KaxEditionFlagDefault::ClassInfos);
const EbmlSemanticContext KaxEditionFlagOrdered_Context = EbmlSemanticContext(0, NULL, &KaxEditionEntry_Context, *GetKaxGlobal_Context, &KaxEditionFlagOrdered::ClassInfos);
const EbmlSemanticContext KaxChapterAtom_Context = EbmlSemanticContext(countof(KaxChapterAtom_ContextList), KaxChapterAtom_ContextList, &KaxEditionEntry_Context, *GetKaxGlobal_Context, &KaxChapterAtom::ClassInfos);
const EbmlSemanticContext KaxChapterTrack_Context = EbmlSemanticContext(countof(KaxChapterTrack_ContextList), KaxChapterTrack_ContextList, &KaxChapterAtom_Context, *GetKaxGlobal_Context, &KaxChapterTrack::ClassInfos);
const EbmlSemanticContext KaxChapterDisplay_Context = EbmlSemanticContext(countof(KaxChapterDisplay_ContextList), KaxChapterDisplay_ContextList, &KaxChapterAtom_Context, *GetKaxGlobal_Context, &KaxChapterDisplay::ClassInfos);
const EbmlSemanticContext KaxChapterUID_Context = EbmlSemanticContext(0, NULL, &KaxChapterAtom_Context, *GetKaxGlobal_Context, &KaxChapterUID::ClassInfos);
const EbmlSemanticContext KaxChapterTimeStart_Context = EbmlSemanticContext(0, NULL, &KaxChapterAtom_Context, *GetKaxGlobal_Context, &KaxChapterTimeStart::ClassInfos);
const EbmlSemanticContext KaxChapterTimeEnd_Context = EbmlSemanticContext(0, NULL, &KaxChapterAtom_Context, *GetKaxGlobal_Context, &KaxChapterTimeEnd::ClassInfos);
const EbmlSemanticContext KaxChapterFlagHidden_Context = EbmlSemanticContext(0, NULL, &KaxChapterAtom_Context, *GetKaxGlobal_Context, &KaxChapterFlagHidden::ClassInfos);
const EbmlSemanticContext KaxChapterFlagEnabled_Context = EbmlSemanticContext(0, NULL, &KaxChapterAtom_Context, *GetKaxGlobal_Context, &KaxChapterFlagEnabled::ClassInfos);
const EbmlSemanticContext KaxChapterSegmentUID_Context = EbmlSemanticContext(0, NULL, &KaxChapterAtom_Context, *GetKaxGlobal_Context, &KaxChapterSegmentUID::ClassInfos);
const EbmlSemanticContext KaxChapterSegmentEditionUID_Context = EbmlSemanticContext(0, NULL, &KaxChapterAtom_Context, *GetKaxGlobal_Context, &KaxChapterSegmentEditionUID::ClassInfos);
const EbmlSemanticContext KaxChapterPhysicalEquiv_Context = EbmlSemanticContext(0, NULL, &KaxChapterAtom_Context, *GetKaxGlobal_Context, &KaxChapterPhysicalEquiv::ClassInfos);
const EbmlSemanticContext KaxChapterTrackNumber_Context = EbmlSemanticContext(0, NULL, &KaxChapterTrack_Context, *GetKaxGlobal_Context, &KaxChapterTrackNumber::ClassInfos);
const EbmlSemanticContext KaxChapterString_Context = EbmlSemanticContext(0, NULL, &KaxChapterDisplay_Context, *GetKaxGlobal_Context, &KaxChapterString::ClassInfos);
const EbmlSemanticContext KaxChapterLanguage_Context = EbmlSemanticContext(0, NULL, &KaxChapterLanguage_Context, *GetKaxGlobal_Context, &KaxChapterLanguage::ClassInfos);
const EbmlSemanticContext KaxChapterCountry_Context = EbmlSemanticContext(0, NULL, &KaxChapterCountry_Context, *GetKaxGlobal_Context, &KaxChapterCountry::ClassInfos);
const EbmlSemanticContext KaxChapterProcess_Context = EbmlSemanticContext(countof(KaxChapterProcess_ContextList), KaxChapterProcess_ContextList, &KaxChapterAtom_Context, *GetKaxGlobal_Context, &KaxChapterProcess::ClassInfos);
const EbmlSemanticContext KaxChapterProcessCodecID_Context = EbmlSemanticContext(0, NULL, &KaxChapterProcess_Context, *GetKaxGlobal_Context, &KaxChapterProcessCodecID::ClassInfos);
const EbmlSemanticContext KaxChapterProcessPrivate_Context = EbmlSemanticContext(0, NULL, &KaxChapterProcess_Context, *GetKaxGlobal_Context, &KaxChapterProcessPrivate::ClassInfos);
const EbmlSemanticContext KaxChapterProcessCommand_Context = EbmlSemanticContext(countof(KaxChapterProcessCommand_ContextList), KaxChapterProcessCommand_ContextList, &KaxChapterProcess_Context, *GetKaxGlobal_Context, &KaxChapterProcessCommand::ClassInfos);
const EbmlSemanticContext KaxChapterProcessTime_Context = EbmlSemanticContext(0, NULL, &KaxChapterProcessCommand_Context, *GetKaxGlobal_Context, &KaxChapterProcessTime::ClassInfos);
const EbmlSemanticContext KaxChapterProcessData_Context = EbmlSemanticContext(0, NULL, &KaxChapterProcessCommand_Context, *GetKaxGlobal_Context, &KaxChapterProcessData::ClassInfos);
EbmlId KaxChapters_TheId (0x1043A770, 4);
EbmlId KaxEditionEntry_TheId (0x45B9, 2);
EbmlId KaxEditionUID_TheId (0x45BC, 2);
EbmlId KaxEditionFlagHidden_TheId (0x45BD, 2);
EbmlId KaxEditionFlagDefault_TheId (0x45DB, 2);
EbmlId KaxEditionFlagOrdered_TheId (0x45DD, 2);
EbmlId KaxChapterAtom_TheId (0xB6, 1);
EbmlId KaxChapterUID_TheId (0x73C4, 2);
EbmlId KaxChapterTimeStart_TheId (0x91, 1);
EbmlId KaxChapterTimeEnd_TheId (0x92, 1);
EbmlId KaxChapterFlagHidden_TheId (0x98, 1);
EbmlId KaxChapterFlagEnabled_TheId (0x4598, 2);
EbmlId KaxChapterSegmentUID_TheId (0x6E67, 2);
EbmlId KaxChapterSegmentEditionUID_TheId(0x6EBC, 2);
EbmlId KaxChapterPhysicalEquiv_TheId (0x63C3, 2);
EbmlId KaxChapterTrack_TheId (0x8F, 1);
EbmlId KaxChapterTrackNumber_TheId (0x89, 1);
EbmlId KaxChapterDisplay_TheId (0x80, 1);
EbmlId KaxChapterString_TheId (0x85, 1);
EbmlId KaxChapterLanguage_TheId (0x437C, 2);
EbmlId KaxChapterCountry_TheId (0x437E, 2);
EbmlId KaxChapterProcess_TheId (0x6944, 2);
EbmlId KaxChapterProcessCodecID_TheId (0x6955, 2);
EbmlId KaxChapterProcessPrivate_TheId (0x450D, 2);
EbmlId KaxChapterProcessCommand_TheId (0x6911, 2);
EbmlId KaxChapterProcessTime_TheId (0x6922, 2);
EbmlId KaxChapterProcessData_TheId (0x6933, 2);
const EbmlCallbacks KaxChapters::ClassInfos(KaxChapters::Create, KaxChapters_TheId, "Chapters", KaxChapters_Context);
const EbmlCallbacks KaxEditionEntry::ClassInfos(KaxEditionEntry::Create, KaxEditionEntry_TheId, "EditionEntry", KaxEditionEntry_Context);
const EbmlCallbacks KaxEditionUID::ClassInfos(KaxEditionUID::Create, KaxEditionUID_TheId, "EditionUID", KaxEditionUID_Context);
const EbmlCallbacks KaxEditionFlagHidden::ClassInfos(KaxEditionFlagHidden::Create, KaxEditionFlagHidden_TheId, "EditionFlagHidden", KaxEditionFlagHidden_Context);
const EbmlCallbacks KaxEditionFlagDefault::ClassInfos(KaxEditionFlagDefault::Create, KaxEditionFlagDefault_TheId, "EditionFlagDefault", KaxEditionFlagDefault_Context);
const EbmlCallbacks KaxEditionFlagOrdered::ClassInfos(KaxEditionFlagOrdered::Create, KaxEditionFlagOrdered_TheId, "EditionFlagOrdered", KaxEditionFlagOrdered_Context);
const EbmlCallbacks KaxChapterAtom::ClassInfos(KaxChapterAtom::Create, KaxChapterAtom_TheId, "ChapterAtom", KaxChapterAtom_Context);
const EbmlCallbacks KaxChapterUID::ClassInfos(KaxChapterUID::Create, KaxChapterUID_TheId, "ChapterUID", KaxChapterUID_Context);
const EbmlCallbacks KaxChapterTimeStart::ClassInfos(KaxChapterTimeStart::Create, KaxChapterTimeStart_TheId, "ChapterTimeStart", KaxChapterTimeStart_Context);
const EbmlCallbacks KaxChapterTimeEnd::ClassInfos(KaxChapterTimeEnd::Create, KaxChapterTimeEnd_TheId, "ChapterTimeEnd", KaxChapterTimeEnd_Context);
const EbmlCallbacks KaxChapterFlagHidden::ClassInfos(KaxChapterFlagHidden::Create, KaxChapterFlagHidden_TheId, "ChapterFlagHidden", KaxChapterFlagHidden_Context);
const EbmlCallbacks KaxChapterFlagEnabled::ClassInfos(KaxChapterFlagEnabled::Create, KaxChapterFlagEnabled_TheId, "ChapterFlagEnabled", KaxChapterFlagEnabled_Context);
const EbmlCallbacks KaxChapterSegmentUID::ClassInfos(KaxChapterSegmentUID::Create, KaxChapterSegmentUID_TheId, "ChapterSegmentUID", KaxChapterSegmentUID_Context);
const EbmlCallbacks KaxChapterSegmentEditionUID::ClassInfos(KaxChapterSegmentEditionUID::Create, KaxChapterSegmentEditionUID_TheId, "ChapterSegmentEditionUID", KaxChapterSegmentEditionUID_Context);
const EbmlCallbacks KaxChapterPhysicalEquiv::ClassInfos(KaxChapterPhysicalEquiv::Create, KaxChapterPhysicalEquiv_TheId, "ChapterPhysicalEquiv", KaxChapterPhysicalEquiv_Context);
const EbmlCallbacks KaxChapterTrack::ClassInfos(KaxChapterTrack::Create, KaxChapterTrack_TheId, "ChapterTrack", KaxChapterTrack_Context);
const EbmlCallbacks KaxChapterTrackNumber::ClassInfos(KaxChapterTrackNumber::Create, KaxChapterTrackNumber_TheId, "ChapterTrackNumber", KaxChapterTrackNumber_Context);
const EbmlCallbacks KaxChapterDisplay::ClassInfos(KaxChapterDisplay::Create, KaxChapterDisplay_TheId, "ChapterDisplay", KaxChapterDisplay_Context);
const EbmlCallbacks KaxChapterString::ClassInfos(KaxChapterString::Create, KaxChapterString_TheId, "ChapterString", KaxChapterString_Context);
const EbmlCallbacks KaxChapterLanguage::ClassInfos(KaxChapterLanguage::Create, KaxChapterLanguage_TheId, "ChapterLanguage", KaxChapterLanguage_Context);
const EbmlCallbacks KaxChapterCountry::ClassInfos(KaxChapterCountry::Create, KaxChapterCountry_TheId, "ChapterCountry", KaxChapterCountry_Context);
const EbmlCallbacks KaxChapterProcess::ClassInfos(KaxChapterProcess::Create, KaxChapterProcess_TheId, "ChapterProcess", KaxChapterProcess_Context);
const EbmlCallbacks KaxChapterProcessCodecID::ClassInfos(KaxChapterProcessCodecID::Create, KaxChapterProcessCodecID_TheId, "ChapterProcessCodecID", KaxChapterProcessCodecID_Context);
const EbmlCallbacks KaxChapterProcessPrivate::ClassInfos(KaxChapterProcessPrivate::Create, KaxChapterProcessPrivate_TheId, "ChapterProcessPrivate", KaxChapterProcessPrivate_Context);
const EbmlCallbacks KaxChapterProcessCommand::ClassInfos(KaxChapterProcessCommand::Create, KaxChapterProcessCommand_TheId, "ChapterProcessCommand", KaxChapterProcessCommand_Context);
const EbmlCallbacks KaxChapterProcessTime::ClassInfos(KaxChapterProcessTime::Create, KaxChapterProcessTime_TheId, "ChapterProcessTime", KaxChapterProcessTime_Context);
const EbmlCallbacks KaxChapterProcessData::ClassInfos(KaxChapterProcessData::Create, KaxChapterProcessData_TheId, "ChapterProcessData", KaxChapterProcessData_Context);
KaxChapters::KaxChapters()
:EbmlMaster(KaxChapters_Context)
{}
KaxEditionEntry::KaxEditionEntry()
:EbmlMaster(KaxEditionEntry_Context)
{}
KaxChapterAtom::KaxChapterAtom()
:EbmlMaster(KaxChapterAtom_Context)
{}
KaxChapterTrack::KaxChapterTrack()
:EbmlMaster(KaxChapterTrack_Context)
{}
KaxChapterDisplay::KaxChapterDisplay()
:EbmlMaster(KaxChapterDisplay_Context)
{}
KaxChapterProcess::KaxChapterProcess()
:EbmlMaster(KaxChapterProcess_Context)
{}
KaxChapterProcessCommand::KaxChapterProcessCommand()
:EbmlMaster(KaxChapterProcessCommand_Context)
{}
END_LIBMATROSKA_NAMESPACE

335
src/KaxCluster.cpp Normal file
View File

@ -0,0 +1,335 @@
/****************************************************************************
** libmatroska : parse Matroska files, see http://www.matroska.org/
**
** <file/class description>
**
** Copyright (C) 2002-2005 Steve Lhomme. All rights reserved.
**
** This library is free software; you can redistribute it and/or
** modify it under the terms of the GNU Lesser General Public
** License as published by the Free Software Foundation; either
** version 2.1 of the License, or (at your option) any later version.
**
** This library is distributed in the hope that it will be useful,
** but WITHOUT ANY WARRANTY; without even the implied warranty of
** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
** Lesser General Public License for more details.
**
** You should have received a copy of the GNU Lesser General Public
** License along with this library; if not, write to the Free Software
** Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
**
** See http://www.matroska.org/license/lgpl/ for LGPL licensing information.**
** Contact license@matroska.org if any conditions of this licensing are
** not clear to you.
**
**********************************************************************/
/*!
\file
\version \$Id: KaxCluster.cpp 1228 2005-10-14 19:36:51Z robux4 $
\author Steve Lhomme <robux4 @ users.sf.net>
*/
#include "matroska/KaxCluster.h"
#include "matroska/KaxClusterData.h"
#include "matroska/KaxBlock.h"
#include "matroska/KaxContexts.h"
#include "matroska/KaxSegment.h"
// sub elements
START_LIBMATROSKA_NAMESPACE
#if MATROSKA_VERSION == 1
EbmlSemantic KaxCluster_ContextList[5] =
#else // MATROSKA_VERSION
EbmlSemantic KaxCluster_ContextList[6] =
#endif // MATROSKA_VERSION
{
EbmlSemantic(true, true, KaxClusterTimecode::ClassInfos),
EbmlSemantic(false, true, KaxClusterSilentTracks::ClassInfos),
EbmlSemantic(false, true, KaxClusterPrevSize::ClassInfos),
EbmlSemantic(false, false, KaxBlockGroup::ClassInfos),
#if MATROSKA_VERSION == 2
EbmlSemantic(false, false, KaxSimpleBlock::ClassInfos),
#endif
EbmlSemantic(false, true, KaxClusterPosition::ClassInfos),
};
const EbmlSemanticContext KaxCluster_Context = EbmlSemanticContext(countof(KaxCluster_ContextList), KaxCluster_ContextList, &KaxSegment_Context, *GetKaxGlobal_Context, &KaxCluster::ClassInfos);
EbmlId KaxCluster_TheId(0x1F43B675, 4);
const EbmlCallbacks KaxCluster::ClassInfos(KaxCluster::Create, KaxCluster_TheId, "Cluster", KaxCluster_Context);
KaxCluster::KaxCluster()
:EbmlMaster(KaxCluster_Context)
,currentNewBlock(NULL)
,ParentSegment(NULL)
,bFirstFrameInside(false)
,bPreviousTimecodeIsSet(false)
,bTimecodeScaleIsSet(false)
,bSilentTracksUsed(false)
{}
KaxCluster::KaxCluster(const KaxCluster & ElementToClone)
:EbmlMaster(ElementToClone)
,bSilentTracksUsed(ElementToClone.bSilentTracksUsed)
{
// update the parent of each children
std::vector<EbmlElement *>::const_iterator Itr = ElementList.begin();
while (Itr != ElementList.end())
{
if (EbmlId(**Itr) == KaxBlockGroup::ClassInfos.GlobalId) {
static_cast<KaxBlockGroup *>(*Itr)->SetParent(*this);
} else if (EbmlId(**Itr) == KaxBlock::ClassInfos.GlobalId) {
static_cast<KaxBlock *>(*Itr)->SetParent(*this);
#if MATROSKA_VERSION >= 2
} else if (EbmlId(**Itr) == KaxBlockVirtual::ClassInfos.GlobalId) {
static_cast<KaxBlockVirtual *>(*Itr)->SetParent(*this);
#endif // MATROSKA_VERSION
}
}
}
bool KaxCluster::AddBlockBlob(KaxBlockBlob * NewBlob)
{
Blobs.push_back(NewBlob);
return true;
}
bool KaxCluster::AddFrameInternal(const KaxTrackEntry & track, uint64 timecode, DataBuffer & buffer, KaxBlockGroup * & MyNewBlock, const KaxBlockGroup * PastBlock, const KaxBlockGroup * ForwBlock, LacingType lacing)
{
if (!bFirstFrameInside) {
bFirstFrameInside = true;
MinTimecode = MaxTimecode = timecode;
} else {
if (timecode < MinTimecode)
MinTimecode = timecode;
if (timecode > MaxTimecode)
MaxTimecode = timecode;
}
MyNewBlock = NULL;
if (lacing == LACING_NONE || !track.LacingEnabled()) {
currentNewBlock = NULL;
}
// force creation of a new block
if (currentNewBlock == NULL || uint32(track.TrackNumber()) != uint32(currentNewBlock->TrackNumber()) || PastBlock != NULL || ForwBlock != NULL) {
KaxBlockGroup & aNewBlock = GetNewBlock();
MyNewBlock = currentNewBlock = &aNewBlock;
currentNewBlock = &aNewBlock;
}
if (PastBlock != NULL) {
if (ForwBlock != NULL) {
if (currentNewBlock->AddFrame(track, timecode, buffer, *PastBlock, *ForwBlock, lacing)) {
// more data are allowed in this Block
return true;
} else {
currentNewBlock = NULL;
return false;
}
} else {
if (currentNewBlock->AddFrame(track, timecode, buffer, *PastBlock, lacing)) {
// more data are allowed in this Block
return true;
} else {
currentNewBlock = NULL;
return false;
}
}
} else {
if (currentNewBlock->AddFrame(track, timecode, buffer, lacing)) {
// more data are allowed in this Block
return true;
} else {
currentNewBlock = NULL;
return false;
}
}
}
bool KaxCluster::AddFrame(const KaxTrackEntry & track, uint64 timecode, DataBuffer & buffer, KaxBlockGroup * & MyNewBlock, LacingType lacing)
{
assert(Blobs.size() == 0); // mutually exclusive for the moment
return AddFrameInternal(track, timecode, buffer, MyNewBlock, NULL, NULL, lacing);
}
bool KaxCluster::AddFrame(const KaxTrackEntry & track, uint64 timecode, DataBuffer & buffer, KaxBlockGroup * & MyNewBlock, const KaxBlockGroup & PastBlock, LacingType lacing)
{
assert(Blobs.size() == 0); // mutually exclusive for the moment
return AddFrameInternal(track, timecode, buffer, MyNewBlock, &PastBlock, NULL, lacing);
}
bool KaxCluster::AddFrame(const KaxTrackEntry & track, uint64 timecode, DataBuffer & buffer, KaxBlockGroup * & MyNewBlock, const KaxBlockGroup & PastBlock, const KaxBlockGroup & ForwBlock, LacingType lacing)
{
assert(Blobs.size() == 0); // mutually exclusive for the moment
return AddFrameInternal(track, timecode, buffer, MyNewBlock, &PastBlock, &ForwBlock, lacing);
}
/*!
\todo only put the Blocks written in the cue entries
*/
uint32 KaxCluster::Render(IOCallback & output, KaxCues & CueToUpdate, bool bSaveDefault)
{
uint32 Result = 0;
size_t TrkIndex, Index;
// update the Timecode of the Cluster before writing
KaxClusterTimecode * Timecode = static_cast<KaxClusterTimecode *>(this->FindElt(KaxClusterTimecode::ClassInfos));
*static_cast<EbmlUInteger *>(Timecode) = GlobalTimecode() / GlobalTimecodeScale();
if (Blobs.size() == 0) {
// old-school direct KaxBlockGroup
// SilentTracks handling
// check the parent cluster for existing tracks and see if they are contained in this cluster or not
if (bSilentTracksUsed)
{
KaxTracks & MyTracks = *static_cast<KaxTracks *>(ParentSegment->FindElt(KaxTracks::ClassInfos));
for (TrkIndex = 0; TrkIndex < MyTracks.ListSize(); TrkIndex++) {
if (EbmlId(*MyTracks[TrkIndex]) == KaxTrackEntry::ClassInfos.GlobalId)
{
KaxTrackEntry & entry = *static_cast<KaxTrackEntry *>(MyTracks[TrkIndex]);
uint32 tracknum = entry.TrackNumber();
for (Index = 0; Index < ElementList.size(); Index++) {
if (EbmlId(*ElementList[Index]) == KaxBlockGroup::ClassInfos.GlobalId) {
KaxBlockGroup & group = *static_cast<KaxBlockGroup *>(ElementList[Index]);
if (group.TrackNumber() == tracknum)
break; // this track is used
}
}
// the track wasn't found in this cluster
if (Index == ElementList.size())
{
KaxClusterSilentTracks * SilentTracks = static_cast<KaxClusterSilentTracks *>(this->FindFirstElt(KaxClusterSilentTracks::ClassInfos));
assert(SilentTracks != NULL); // the flag bSilentTracksUsed should be set when creating the Cluster
KaxClusterSilentTrackNumber * trackelt = static_cast<KaxClusterSilentTrackNumber *>(SilentTracks->AddNewElt(KaxClusterSilentTrackNumber::ClassInfos));
*static_cast<EbmlUInteger *>(trackelt) = tracknum;
}
}
}
}
Result = EbmlMaster::Render(output, bSaveDefault);
// For all Blocks add their position on the CueEntry
for (Index = 0; Index < ElementList.size(); Index++) {
if (EbmlId(*ElementList[Index]) == KaxBlockGroup::ClassInfos.GlobalId) {
CueToUpdate.PositionSet(*static_cast<const KaxBlockGroup *>(ElementList[Index]));
}
}
} else {
// new school, using KaxBlockBlob
for (Index = 0; Index<Blobs.size(); Index++)
{
#if MATROSKA_VERSION >= 2
if (Blobs[Index]->IsSimpleBlock())
ElementList.push_back( &(KaxSimpleBlock&) *Blobs[Index] );
else
#endif
ElementList.push_back( &(KaxBlockGroup&) *Blobs[Index] );
}
// SilentTracks handling
// check the parent cluster for existing tracks and see if they are contained in this cluster or not
if (bSilentTracksUsed)
{
KaxTracks & MyTracks = *static_cast<KaxTracks *>(ParentSegment->FindElt(KaxTracks::ClassInfos));
for (TrkIndex = 0; TrkIndex < MyTracks.ListSize(); TrkIndex++) {
if (EbmlId(*MyTracks[TrkIndex]) == KaxTrackEntry::ClassInfos.GlobalId)
{
KaxTrackEntry & entry = *static_cast<KaxTrackEntry *>(MyTracks[TrkIndex]);
uint32 tracknum = entry.TrackNumber();
for (Index = 0; Index<Blobs.size(); Index++) {
if (((KaxInternalBlock&)*Blobs[Index]).TrackNum() == tracknum)
break; // this track is used
}
// the track wasn't found in this cluster
if (Index == ElementList.size())
{
KaxClusterSilentTracks * SilentTracks = static_cast<KaxClusterSilentTracks *>(this->FindFirstElt(KaxClusterSilentTracks::ClassInfos));
assert(SilentTracks != NULL); // the flag bSilentTracksUsed should be set when creating the Cluster
KaxClusterSilentTrackNumber * trackelt = static_cast<KaxClusterSilentTrackNumber *>(SilentTracks->AddNewElt(KaxClusterSilentTrackNumber::ClassInfos));
*static_cast<EbmlUInteger *>(trackelt) = tracknum;
}
}
}
}
Result = EbmlMaster::Render(output, bSaveDefault);
// For all Blocks add their position on the CueEntry
for (Index = 0; Index<Blobs.size(); Index++) {
CueToUpdate.PositionSet(*Blobs[Index]);
}
Blobs.clear();
}
return Result;
}
/*!
\todo automatically choose valid timecode for the Cluster based on the previous cluster timecode (must be incremental)
*/
uint64 KaxCluster::GlobalTimecode() const
{
assert(bPreviousTimecodeIsSet);
uint64 result = MinTimecode;
if (result < PreviousTimecode)
result = PreviousTimecode + 1;
return result;
}
/*!
\brief retrieve the relative
\todo !!! We need a way to know the TimecodeScale
*/
int16 KaxCluster::GetBlockLocalTimecode(uint64 aGlobalTimecode) const
{
int64 TimecodeDelay = (int64(aGlobalTimecode) - int64(GlobalTimecode())) / int64(GlobalTimecodeScale());
assert(TimecodeDelay >= int16(0x8000) && TimecodeDelay <= int16(0x7FFF));
return int16(TimecodeDelay);
}
uint64 KaxCluster::GetBlockGlobalTimecode(int16 GlobalSavedTimecode)
{
if (!bFirstFrameInside) {
KaxClusterTimecode * Timecode = static_cast<KaxClusterTimecode *>(this->FindElt(KaxClusterTimecode::ClassInfos));
assert (bFirstFrameInside); // use the InitTimecode() hack for now
MinTimecode = MaxTimecode = PreviousTimecode = *static_cast<EbmlUInteger *>(Timecode);
bFirstFrameInside = true;
bPreviousTimecodeIsSet = true;
}
return int64(GlobalSavedTimecode * GlobalTimecodeScale()) + GlobalTimecode();
}
KaxBlockGroup & KaxCluster::GetNewBlock()
{
KaxBlockGroup & MyBlock = AddNewChild<KaxBlockGroup>(*this);
MyBlock.SetParent(*this);
return MyBlock;
}
void KaxCluster::ReleaseFrames()
{
size_t Index;
for (Index = 0; Index < ElementList.size(); Index++) {
if (EbmlId(*ElementList[Index]) == KaxBlockGroup::ClassInfos.GlobalId) {
static_cast<KaxBlockGroup*>(ElementList[Index])->ReleaseFrames();
}
}
}
uint64 KaxCluster::GetPosition() const
{
assert(ParentSegment != NULL);
return ParentSegment->GetRelativePosition(*this);
}
END_LIBMATROSKA_NAMESPACE

67
src/KaxClusterData.cpp Normal file
View File

@ -0,0 +1,67 @@
/****************************************************************************
** libmatroska : parse Matroska files, see http://www.matroska.org/
**
** <file/class description>
**
** Copyright (C) 2002-2004 Steve Lhomme. All rights reserved.
**
** This file is part of libmatroska.
**
** This library is free software; you can redistribute it and/or
** modify it under the terms of the GNU Lesser General Public
** License as published by the Free Software Foundation; either
** version 2.1 of the License, or (at your option) any later version.
**
** This library is distributed in the hope that it will be useful,
** but WITHOUT ANY WARRANTY; without even the implied warranty of
** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
** Lesser General Public License for more details.
**
** You should have received a copy of the GNU Lesser General Public
** License along with this library; if not, write to the Free Software
** Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
**
** See http://www.matroska.org/license/lgpl/ for LGPL licensing information.**
** Contact license@matroska.org if any conditions of this licensing are
** not clear to you.
**
**********************************************************************/
/*!
\file
\version \$Id: KaxClusterData.cpp 955 2004-11-28 15:24:37Z robux4 $
\author Steve Lhomme <robux4 @ users.sf.net>
*/
#include "matroska/KaxClusterData.h"
#include "matroska/KaxContexts.h"
START_LIBMATROSKA_NAMESPACE
EbmlId KaxClusterTimecode_TheId (0xE7, 1);
EbmlId KaxClusterSilentTracks_TheId (0x5854, 2);
EbmlId KaxClusterSilentTrackNumber_TheId(0x58D7, 2);
EbmlId KaxClusterPrevSize_TheId (0xAB, 1);
EbmlId KaxClusterPosition_TheId (0xA7, 1);
EbmlSemantic KaxClusterSilentTracks_ContextList[1] =
{
EbmlSemantic(false, false, KaxClusterSilentTrackNumber::ClassInfos),
};
const EbmlSemanticContext KaxClusterTimecode_Context = EbmlSemanticContext(0, NULL, &KaxCluster_Context, *GetKaxGlobal_Context, &KaxClusterTimecode::ClassInfos);
const EbmlSemanticContext KaxClusterSilentTracks_Context = EbmlSemanticContext(countof(KaxClusterSilentTracks_ContextList), KaxClusterSilentTracks_ContextList, &KaxCluster_Context, *GetKaxGlobal_Context, &KaxClusterSilentTracks::ClassInfos);
const EbmlSemanticContext KaxClusterSilentTrackNumber_Context = EbmlSemanticContext(0, NULL, &KaxClusterSilentTracks_Context, *GetKaxGlobal_Context, &KaxClusterSilentTrackNumber::ClassInfos);
const EbmlSemanticContext KaxClusterPosition_Context = EbmlSemanticContext(0, NULL, &KaxCluster_Context, *GetKaxGlobal_Context, &KaxClusterPosition::ClassInfos);
const EbmlSemanticContext KaxClusterPrevSize_Context = EbmlSemanticContext(0, NULL, &KaxCluster_Context, *GetKaxGlobal_Context, &KaxClusterPrevSize::ClassInfos);
const EbmlCallbacks KaxClusterTimecode::ClassInfos(KaxClusterTimecode::Create, KaxClusterTimecode_TheId, "ClusterTimecode", KaxClusterTimecode_Context);
const EbmlCallbacks KaxClusterSilentTracks::ClassInfos(KaxClusterSilentTracks::Create, KaxClusterSilentTracks_TheId, "ClusterSilentTracks", KaxClusterSilentTracks_Context);
const EbmlCallbacks KaxClusterSilentTrackNumber::ClassInfos(KaxClusterSilentTrackNumber::Create, KaxClusterSilentTrackNumber_TheId, "ClusterSilentTrackNumber", KaxClusterSilentTrackNumber_Context);
const EbmlCallbacks KaxClusterPrevSize::ClassInfos(KaxClusterPrevSize::Create, KaxClusterPrevSize_TheId, "ClusterPrevSize", KaxClusterPrevSize_Context);
const EbmlCallbacks KaxClusterPosition::ClassInfos(KaxClusterPosition::Create, KaxClusterPosition_TheId, "ClusterPosition", KaxClusterPosition_Context);
KaxClusterSilentTracks::KaxClusterSilentTracks()
:EbmlMaster(KaxClusterSilentTracks_Context)
{}
END_LIBMATROSKA_NAMESPACE

254
src/KaxContentEncoding.cpp Normal file
View File

@ -0,0 +1,254 @@
/****************************************************************************
** libmatroska : parse Matroska files, see http://www.matroska.org/
**
** <file/class description>
**
** Copyright (C) 2002-2004 Steve Lhomme. All rights reserved.
**
** This file is part of libmatroska.
**
** This library is free software; you can redistribute it and/or
** modify it under the terms of the GNU Lesser General Public
** License as published by the Free Software Foundation; either
** version 2.1 of the License, or (at your option) any later version.
**
** This library is distributed in the hope that it will be useful,
** but WITHOUT ANY WARRANTY; without even the implied warranty of
** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
** Lesser General Public License for more details.
**
** You should have received a copy of the GNU Lesser General Public
** License along with this library; if not, write to the Free Software
** Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
**
** See http://www.matroska.org/license/lgpl/ for LGPL licensing information.**
** Contact license@matroska.org if any conditions of this licensing are
** not clear to you.
**
**********************************************************************/
/*!
\file
\version \$Id: KaxContentEncoding.cpp 640 2004-07-09 21:05:36Z mosu $
\author Moritz Bunkus <moritz @ bunkus.org>
*/
#include "matroska/KaxContentEncoding.h"
#include "matroska/KaxContexts.h"
START_LIBMATROSKA_NAMESPACE
const EbmlSemantic KaxContentEncodings_ContextList[1] = {
EbmlSemantic(true, true, KaxContentEncoding::ClassInfos),
};
const EbmlSemantic KaxContentEncoding_ContextList[5] = {
EbmlSemantic(true, true, KaxContentEncodingOrder::ClassInfos),
EbmlSemantic(true, true, KaxContentEncodingScope::ClassInfos),
EbmlSemantic(true, true, KaxContentEncodingType::ClassInfos),
EbmlSemantic(false, true, KaxContentCompression::ClassInfos),
EbmlSemantic(false, true, KaxContentEncryption::ClassInfos),
};
const EbmlSemantic KaxContentCompression_ContextList[2] = {
EbmlSemantic(true, true, KaxContentCompAlgo::ClassInfos),
EbmlSemantic(false, true, KaxContentCompSettings::ClassInfos),
};
const EbmlSemantic KaxContentEncryption_ContextList[6] = {
EbmlSemantic(false, true, KaxContentEncAlgo::ClassInfos),
EbmlSemantic(false, true, KaxContentEncKeyID::ClassInfos),
EbmlSemantic(false, true, KaxContentSignature::ClassInfos),
EbmlSemantic(false, true, KaxContentSigKeyID::ClassInfos),
EbmlSemantic(false, true, KaxContentSigAlgo::ClassInfos),
EbmlSemantic(false, true, KaxContentSigHashAlgo::ClassInfos),
};
EbmlId KaxContentEncodings_TheId (0x6d80, 2);
EbmlId KaxContentEncoding_TheId (0x6240, 2);
EbmlId KaxContentEncodingOrder_TheId (0x5031, 2);
EbmlId KaxContentEncodingScope_TheId (0x5032, 2);
EbmlId KaxContentEncodingType_TheId (0x5033, 2);
EbmlId KaxContentCompression_TheId (0x5034, 2);
EbmlId KaxContentCompAlgo_TheId (0x4254, 2);
EbmlId KaxContentCompSettings_TheId (0x4255, 2);
EbmlId KaxContentEncryption_TheId (0x5035, 2);
EbmlId KaxContentEncAlgo_TheId (0x47e1, 2);
EbmlId KaxContentEncKeyID_TheId (0x47e2, 2);
EbmlId KaxContentSignature_TheId (0x47e3, 2);
EbmlId KaxContentSigKeyID_TheId (0x47e4, 2);
EbmlId KaxContentSigAlgo_TheId (0x47e5, 2);
EbmlId KaxContentSigHashAlgo_TheId (0x47e6, 2);
const EbmlSemanticContext KaxContentEncodings_Context =
EbmlSemanticContext(countof(KaxContentEncodings_ContextList),
KaxContentEncodings_ContextList, &KaxTrackEntry_Context,
*GetKaxGlobal_Context,
&KaxContentEncodings::ClassInfos);
const EbmlSemanticContext KaxContentEncoding_Context =
EbmlSemanticContext(countof(KaxContentEncoding_ContextList),
KaxContentEncoding_ContextList,
&KaxContentEncodings_Context,
*GetKaxGlobal_Context,
&KaxContentEncoding::ClassInfos);
const EbmlSemanticContext KaxContentEncodingOrder_Context =
EbmlSemanticContext(0, NULL, &KaxContentEncoding_Context,
*GetKaxGlobal_Context,
&KaxContentEncodingOrder::ClassInfos);
const EbmlSemanticContext KaxContentEncodingScope_Context =
EbmlSemanticContext(0, NULL, &KaxContentEncoding_Context,
*GetKaxGlobal_Context,
&KaxContentEncodingScope::ClassInfos);
const EbmlSemanticContext KaxContentEncodingType_Context =
EbmlSemanticContext(0, NULL, &KaxContentEncoding_Context,
*GetKaxGlobal_Context,
&KaxContentEncodingType::ClassInfos);
const EbmlSemanticContext KaxContentCompression_Context =
EbmlSemanticContext(countof(KaxContentCompression_ContextList),
KaxContentCompression_ContextList,
&KaxContentEncoding_Context, *GetKaxGlobal_Context,
&KaxContentCompression::ClassInfos);
const EbmlSemanticContext KaxContentCompAlgo_Context =
EbmlSemanticContext(0, NULL, &KaxContentCompression_Context,
*GetKaxGlobal_Context,
&KaxContentCompAlgo::ClassInfos);
const EbmlSemanticContext KaxContentCompSettings_Context =
EbmlSemanticContext(0, NULL, &KaxContentCompression_Context,
*GetKaxGlobal_Context,
&KaxContentCompSettings::ClassInfos);
const EbmlSemanticContext KaxContentEncryption_Context =
EbmlSemanticContext(countof(KaxContentEncryption_ContextList),
KaxContentEncryption_ContextList,
&KaxContentEncoding_Context, *GetKaxGlobal_Context,
&KaxContentEncryption::ClassInfos);
const EbmlSemanticContext KaxContentEncAlgo_Context =
EbmlSemanticContext(0, NULL, &KaxContentEncryption_Context,
*GetKaxGlobal_Context,
&KaxContentEncAlgo::ClassInfos);
const EbmlSemanticContext KaxContentEncKeyID_Context =
EbmlSemanticContext(0, NULL, &KaxContentEncryption_Context,
*GetKaxGlobal_Context,
&KaxContentEncKeyID::ClassInfos);
const EbmlSemanticContext KaxContentSignature_Context =
EbmlSemanticContext(0, NULL, &KaxContentEncryption_Context,
*GetKaxGlobal_Context,
&KaxContentSignature::ClassInfos);
const EbmlSemanticContext KaxContentSigAlgo_Context =
EbmlSemanticContext(0, NULL, &KaxContentEncryption_Context,
*GetKaxGlobal_Context,
&KaxContentSigKeyID::ClassInfos);
const EbmlSemanticContext KaxContentSigHashAlgo_Context =
EbmlSemanticContext(0, NULL, &KaxContentEncryption_Context,
*GetKaxGlobal_Context,
&KaxContentSigKeyID::ClassInfos);
const EbmlSemanticContext KaxContentSigKeyID_Context =
EbmlSemanticContext(0, NULL, &KaxContentEncryption_Context,
*GetKaxGlobal_Context,
&KaxContentSigKeyID::ClassInfos);
const EbmlCallbacks
KaxContentEncodings::ClassInfos(KaxContentEncodings::Create,
KaxContentEncodings_TheId,
"ContentEncodings",
KaxContentEncodings_Context);
const EbmlCallbacks
KaxContentEncoding::ClassInfos(KaxContentEncoding::Create,
KaxContentEncoding_TheId,
"ContentEncoding",
KaxContentEncoding_Context);
const EbmlCallbacks
KaxContentEncodingOrder::ClassInfos(KaxContentEncodingOrder::Create,
KaxContentEncodingOrder_TheId,
"ContentEncodingOrder",
KaxContentEncodingOrder_Context);
const EbmlCallbacks
KaxContentEncodingScope::ClassInfos(KaxContentEncodingScope::Create,
KaxContentEncodingScope_TheId,
"ContentEncodingScope",
KaxContentEncodingScope_Context);
const EbmlCallbacks
KaxContentEncodingType::ClassInfos(KaxContentEncodingType::Create,
KaxContentEncodingType_TheId,
"ContentEncodingType",
KaxContentEncodingType_Context);
const EbmlCallbacks
KaxContentCompression::ClassInfos(KaxContentCompression::Create,
KaxContentCompression_TheId,
"ContentCompression",
KaxContentCompression_Context);
const EbmlCallbacks
KaxContentCompAlgo::ClassInfos(KaxContentCompAlgo::Create,
KaxContentCompAlgo_TheId,
"ContentCompAlgo",
KaxContentCompAlgo_Context);
const EbmlCallbacks
KaxContentCompSettings::ClassInfos(KaxContentCompSettings::Create,
KaxContentCompSettings_TheId,
"ContentCompSettings",
KaxContentCompSettings_Context);
const EbmlCallbacks
KaxContentEncryption::ClassInfos(KaxContentEncryption::Create,
KaxContentEncryption_TheId,
"ContentEncryption",
KaxContentEncryption_Context);
const EbmlCallbacks
KaxContentEncAlgo::ClassInfos(KaxContentEncAlgo::Create,
KaxContentEncAlgo_TheId,
"ContentEncAlgo",
KaxContentEncAlgo_Context);
const EbmlCallbacks
KaxContentEncKeyID::ClassInfos(KaxContentEncKeyID::Create,
KaxContentEncKeyID_TheId,
"ContentEncKeyID",
KaxContentEncKeyID_Context);
const EbmlCallbacks
KaxContentSignature::ClassInfos(KaxContentSignature::Create,
KaxContentSignature_TheId,
"ContentSignature",
KaxContentSignature_Context);
const EbmlCallbacks
KaxContentSigAlgo::ClassInfos(KaxContentSigAlgo::Create,
KaxContentSigAlgo_TheId,
"ContentSigAlgo",
KaxContentSigAlgo_Context);
const EbmlCallbacks
KaxContentSigHashAlgo::ClassInfos(KaxContentSigHashAlgo::Create,
KaxContentSigHashAlgo_TheId,
"ContentSigHashAlgo",
KaxContentSigHashAlgo_Context);
const EbmlCallbacks
KaxContentSigKeyID::ClassInfos(KaxContentSigKeyID::Create,
KaxContentSigKeyID_TheId,
"ContentSigKeyID",
KaxContentSigKeyID_Context);
KaxContentEncodings::KaxContentEncodings():
EbmlMaster(KaxContentEncodings_Context) {
}
KaxContentEncoding::KaxContentEncoding():
EbmlMaster(KaxContentEncoding_Context) {
}
KaxContentCompression::KaxContentCompression():
EbmlMaster(KaxContentCompression_Context) {
}
KaxContentEncryption::KaxContentEncryption():
EbmlMaster(KaxContentEncryption_Context) {
}
END_LIBMATROSKA_NAMESPACE

48
src/KaxContexts.cpp Normal file
View File

@ -0,0 +1,48 @@
/****************************************************************************
** libmatroska : parse Matroska files, see http://www.matroska.org/
**
** <file/class description>
**
** Copyright (C) 2002-2004 Steve Lhomme. All rights reserved.
**
** This file is part of libmatroska.
**
** This library is free software; you can redistribute it and/or
** modify it under the terms of the GNU Lesser General Public
** License as published by the Free Software Foundation; either
** version 2.1 of the License, or (at your option) any later version.
**
** This library is distributed in the hope that it will be useful,
** but WITHOUT ANY WARRANTY; without even the implied warranty of
** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
** Lesser General Public License for more details.
**
** You should have received a copy of the GNU Lesser General Public
** License along with this library; if not, write to the Free Software
** Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
**
** See http://www.matroska.org/license/lgpl/ for LGPL licensing information.**
** Contact license@matroska.org if any conditions of this licensing are
** not clear to you.
**
**********************************************************************/
/*!
\file
\version \$Id: KaxContexts.cpp 640 2004-07-09 21:05:36Z mosu $
\author Steve Lhomme <robux4 @ users.sf.net>
*/
#include "ebml/EbmlContexts.h"
#include "matroska/KaxContexts.h"
using namespace LIBEBML_NAMESPACE;
START_LIBMATROSKA_NAMESPACE
// for the moment
const EbmlSemanticContext & GetKaxGlobal_Context()
{
return GetEbmlGlobal_Context();
}
END_LIBMATROSKA_NAMESPACE

172
src/KaxCues.cpp Normal file
View File

@ -0,0 +1,172 @@
/****************************************************************************
** libmatroska : parse Matroska files, see http://www.matroska.org/
**
** <file/class description>
**
** Copyright (C) 2002-2005 Steve Lhomme. All rights reserved.
**
** This library is free software; you can redistribute it and/or
** modify it under the terms of the GNU Lesser General Public
** License as published by the Free Software Foundation; either
** version 2.1 of the License, or (at your option) any later version.
**
** This library is distributed in the hope that it will be useful,
** but WITHOUT ANY WARRANTY; without even the implied warranty of
** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
** Lesser General Public License for more details.
**
** You should have received a copy of the GNU Lesser General Public
** License along with this library; if not, write to the Free Software
** Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
**
** See http://www.matroska.org/license/lgpl/ for LGPL licensing information.**
** Contact license@matroska.org if any conditions of this licensing are
** not clear to you.
**
**********************************************************************/
/*!
\file
\version \$Id: KaxCues.cpp 1265 2007-01-14 17:20:35Z mosu $
\author Steve Lhomme <robux4 @ users.sf.net>
*/
#include <cassert>
#include "matroska/KaxCues.h"
#include "matroska/KaxCuesData.h"
#include "matroska/KaxContexts.h"
#include "ebml/EbmlStream.h"
// sub elements
START_LIBMATROSKA_NAMESPACE
EbmlSemantic KaxCues_ContextList[1] =
{
EbmlSemantic(true, false, KaxCuePoint::ClassInfos),
};
const EbmlSemanticContext KaxCues_Context = EbmlSemanticContext(countof(KaxCues_ContextList), KaxCues_ContextList, &KaxSegment_Context, *GetKaxGlobal_Context, &KaxCues::ClassInfos);
EbmlId KaxCues_TheId(0x1C53BB6B, 4);
const EbmlCallbacks KaxCues::ClassInfos(KaxCues::Create, KaxCues_TheId, "Cues", KaxCues_Context);
KaxCues::KaxCues()
:EbmlMaster(KaxCues_Context)
{}
KaxCues::~KaxCues()
{
assert(myTempReferences.size() == 0); // otherwise that means you have added references and forgot to set the position
}
bool KaxCues::AddBlockGroup(const KaxBlockGroup & BlockRef)
{
// Do not add the element if it's already present.
std::vector<const KaxBlockBlob *>::iterator ListIdx;
KaxBlockBlob &BlockReference = *(new KaxBlockBlob(BLOCK_BLOB_NO_SIMPLE));
BlockReference.SetBlockGroup(*const_cast<KaxBlockGroup*>(&BlockRef));
for (ListIdx = myTempReferences.begin(); ListIdx != myTempReferences.end(); ListIdx++)
if (*ListIdx == &BlockReference)
return true;
myTempReferences.push_back(&BlockReference);
return true;
}
bool KaxCues::AddBlockBlob(const KaxBlockBlob & BlockReference)
{
// Do not add the element if it's already present.
std::vector<const KaxBlockBlob *>::iterator ListIdx;
for (ListIdx = myTempReferences.begin(); ListIdx != myTempReferences.end(); ListIdx++)
if (*ListIdx == &BlockReference)
return true;
myTempReferences.push_back(&BlockReference);
return true;
}
void KaxCues::PositionSet(const KaxBlockBlob & BlockReference)
{
// look for the element in the temporary references
std::vector<const KaxBlockBlob *>::iterator ListIdx;
for (ListIdx = myTempReferences.begin(); ListIdx != myTempReferences.end(); ListIdx++) {
if (*ListIdx == &BlockReference) {
// found, now add the element to the entry list
KaxCuePoint & NewPoint = AddNewChild<KaxCuePoint>(*this);
NewPoint.PositionSet(BlockReference, GlobalTimecodeScale());
myTempReferences.erase(ListIdx);
break;
}
}
}
void KaxCues::PositionSet(const KaxBlockGroup & BlockRef)
{
// look for the element in the temporary references
std::vector<const KaxBlockBlob *>::iterator ListIdx;
for (ListIdx = myTempReferences.begin(); ListIdx != myTempReferences.end(); ListIdx++) {
const KaxInternalBlock &refTmp = **ListIdx;
if (refTmp.GlobalTimecode() == BlockRef.GlobalTimecode() &&
refTmp.TrackNum() == BlockRef.TrackNumber()) {
// found, now add the element to the entry list
KaxCuePoint & NewPoint = AddNewChild<KaxCuePoint>(*this);
NewPoint.PositionSet(**ListIdx, GlobalTimecodeScale());
myTempReferences.erase(ListIdx);
break;
}
}
}
/*!
\warning Assume that the list has been sorted (Sort())
*/
const KaxCuePoint * KaxCues::GetTimecodePoint(uint64 aTimecode) const
{
uint64 TimecodeToLocate = aTimecode / GlobalTimecodeScale();
const KaxCuePoint * aPointPrev = NULL;
uint64 aPrevTime = 0;
const KaxCuePoint * aPointNext = NULL;
uint64 aNextTime = EBML_PRETTYLONGINT(0xFFFFFFFFFFFF);
for (unsigned int i=0; i<ListSize(); i++)
{
if (EbmlId(*(*this)[i]) == KaxCuePoint::ClassInfos.GlobalId) {
const KaxCuePoint *tmp = static_cast<const KaxCuePoint *>((*this)[i]);
// check the tile
const KaxCueTime *aTime = static_cast<const KaxCueTime *>(tmp->FindFirstElt(KaxCueTime::ClassInfos));
if (aTime != NULL)
{
uint64 _Time = uint64(*aTime);
if (_Time > aPrevTime && _Time < TimecodeToLocate) {
aPrevTime = _Time;
aPointPrev = tmp;
}
if (_Time < aNextTime && _Time > TimecodeToLocate) {
aNextTime= _Time;
aPointNext = tmp;
}
}
}
}
return aPointPrev;
}
uint64 KaxCues::GetTimecodePosition(uint64 aTimecode) const
{
const KaxCuePoint * aPoint = GetTimecodePoint(aTimecode);
if (aPoint == NULL)
return 0;
const KaxCueTrackPositions * aTrack = aPoint->GetSeekPosition();
if (aTrack == NULL)
return 0;
return aTrack->ClusterPosition();
}
END_LIBMATROSKA_NAMESPACE

329
src/KaxCuesData.cpp Normal file
View File

@ -0,0 +1,329 @@
/****************************************************************************
** libmatroska : parse Matroska files, see http://www.matroska.org/
**
** <file/class description>
**
** Copyright (C) 2002-2005 Steve Lhomme. All rights reserved.
**
** This library is free software; you can redistribute it and/or
** modify it under the terms of the GNU Lesser General Public
** License as published by the Free Software Foundation; either
** version 2.1 of the License, or (at your option) any later version.
**
** This library is distributed in the hope that it will be useful,
** but WITHOUT ANY WARRANTY; without even the implied warranty of
** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
** Lesser General Public License for more details.
**
** You should have received a copy of the GNU Lesser General Public
** License along with this library; if not, write to the Free Software
** Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
**
** See http://www.matroska.org/license/lgpl/ for LGPL licensing information.**
** Contact license@matroska.org if any conditions of this licensing are
** not clear to you.
**
**********************************************************************/
/*!
\file
\version \$Id: KaxCuesData.cpp 1265 2007-01-14 17:20:35Z mosu $
\author Steve Lhomme <robux4 @ users.sf.net>
*/
#include <cassert>
#include "matroska/KaxCuesData.h"
#include "matroska/KaxContexts.h"
#include "matroska/KaxBlock.h"
#include "matroska/KaxBlockData.h"
#include "matroska/KaxCluster.h"
#include "matroska/KaxSegment.h"
START_LIBMATROSKA_NAMESPACE
EbmlSemantic KaxCuePoint_ContextList[2] =
{
EbmlSemantic(true, true, KaxCueTime::ClassInfos),
EbmlSemantic(true, false, KaxCueTrackPositions::ClassInfos),
};
#if MATROSKA_VERSION == 1
EbmlSemantic KaxCueTrackPositions_ContextList[3] =
#else // MATROSKA_VERSION
EbmlSemantic KaxCueTrackPositions_ContextList[5] =
#endif // MATROSKA_VERSION
{
EbmlSemantic(true, true, KaxCueTrack::ClassInfos),
EbmlSemantic(true, true, KaxCueClusterPosition::ClassInfos),
EbmlSemantic(false, true, KaxCueBlockNumber::ClassInfos),
#if MATROSKA_VERSION >= 2
EbmlSemantic(false, true, KaxCueCodecState::ClassInfos),
EbmlSemantic(false, false, KaxCueReference::ClassInfos),
#endif // MATROSKA_VERSION
};
#if MATROSKA_VERSION >= 2
EbmlSemantic KaxCueReference_ContextList[4] =
{
EbmlSemantic(true, true, KaxCueRefTime::ClassInfos),
EbmlSemantic(true, true, KaxCueRefCluster::ClassInfos),
EbmlSemantic(false, true, KaxCueRefNumber::ClassInfos),
EbmlSemantic(false, true, KaxCueRefCodecState::ClassInfos),
};
#endif // MATROSKA_VERSION
EbmlId KaxCuePoint_TheId (0xBB, 1);
EbmlId KaxCueTime_TheId (0xB3, 1);
EbmlId KaxCueTrackPositions_TheId (0xB7, 1);
EbmlId KaxCueTrack_TheId (0xF7, 1);
EbmlId KaxCueClusterPosition_TheId(0xF1, 1);
EbmlId KaxCueBlockNumber_TheId (0x5378, 2);
#if MATROSKA_VERSION >= 2
EbmlId KaxCueCodecState_TheId (0xEA, 1);
EbmlId KaxCueReference_TheId (0xDB, 1);
EbmlId KaxCueRefTime_TheId (0x96, 1);
EbmlId KaxCueRefCluster_TheId (0x97, 1);
EbmlId KaxCueRefNumber_TheId (0x535F, 2);
EbmlId KaxCueRefCodecState_TheId (0xEB, 1);
#endif // MATROSKA_VERSION
const EbmlSemanticContext KaxCuePoint_Context = EbmlSemanticContext(countof(KaxCuePoint_ContextList), KaxCuePoint_ContextList, &KaxCues_Context, *GetKaxGlobal_Context, &KaxCuePoint::ClassInfos);
const EbmlSemanticContext KaxCueTime_Context = EbmlSemanticContext(0, NULL, &KaxCuePoint_Context, *GetKaxGlobal_Context, &KaxCueTime::ClassInfos);
const EbmlSemanticContext KaxCueTrackPositions_Context = EbmlSemanticContext(countof(KaxCueTrackPositions_ContextList), KaxCueTrackPositions_ContextList, &KaxCuePoint_Context, *GetKaxGlobal_Context, &KaxCueTrackPositions::ClassInfos);
const EbmlSemanticContext KaxCueTrack_Context = EbmlSemanticContext(0, NULL, &KaxCueTrackPositions_Context, *GetKaxGlobal_Context, &KaxCueTrack::ClassInfos);
const EbmlSemanticContext KaxCueClusterPosition_Context = EbmlSemanticContext(0, NULL, &KaxCueTrackPositions_Context, *GetKaxGlobal_Context, &KaxCueClusterPosition::ClassInfos);
const EbmlSemanticContext KaxCueBlockNumber_Context = EbmlSemanticContext(0, NULL, &KaxCueTrackPositions_Context, *GetKaxGlobal_Context, &KaxCueBlockNumber::ClassInfos);
#if MATROSKA_VERSION >= 2
const EbmlSemanticContext KaxCueCodecState_Context = EbmlSemanticContext(0, NULL, &KaxCueTrackPositions_Context, *GetKaxGlobal_Context, &KaxCueCodecState::ClassInfos);
const EbmlSemanticContext KaxCueReference_Context = EbmlSemanticContext(countof(KaxCueReference_ContextList), KaxCueReference_ContextList, &KaxCueTrackPositions_Context, *GetKaxGlobal_Context, &KaxCueReference::ClassInfos);
const EbmlSemanticContext KaxCueRefTime_Context = EbmlSemanticContext(0, NULL, &KaxCueReference_Context, *GetKaxGlobal_Context, &KaxCueRefTime::ClassInfos);
const EbmlSemanticContext KaxCueRefCluster_Context = EbmlSemanticContext(0, NULL, &KaxCueRefTime_Context, *GetKaxGlobal_Context, &KaxCueRefCluster::ClassInfos);
const EbmlSemanticContext KaxCueRefNumber_Context = EbmlSemanticContext(0, NULL, &KaxCueRefTime_Context, *GetKaxGlobal_Context, &KaxCueRefNumber::ClassInfos);
const EbmlSemanticContext KaxCueRefCodecState_Context = EbmlSemanticContext(0, NULL, &KaxCueRefTime_Context, *GetKaxGlobal_Context, &KaxCueRefCodecState::ClassInfos);
#endif // MATROSKA_VERSION
const EbmlCallbacks KaxCuePoint::ClassInfos(KaxCuePoint::Create, KaxCuePoint_TheId, "CuePoint", KaxCuePoint_Context);
const EbmlCallbacks KaxCueTime::ClassInfos(KaxCueTime::Create, KaxCueTime_TheId, "CueTime", KaxCueTime_Context);
const EbmlCallbacks KaxCueTrackPositions::ClassInfos(KaxCueTrackPositions::Create, KaxCueTrackPositions_TheId, "CueTrackPositions", KaxCueTrackPositions_Context);
const EbmlCallbacks KaxCueTrack::ClassInfos(KaxCueTrack::Create, KaxCueTrack_TheId, "CueTrack", KaxCueTrack_Context);
const EbmlCallbacks KaxCueClusterPosition::ClassInfos(KaxCueClusterPosition::Create, KaxCueClusterPosition_TheId, "CueClusterPosition", KaxCueClusterPosition_Context);
const EbmlCallbacks KaxCueBlockNumber::ClassInfos(KaxCueBlockNumber::Create, KaxCueBlockNumber_TheId, "CueBlockNumber", KaxCueBlockNumber_Context);
#if MATROSKA_VERSION >= 2
const EbmlCallbacks KaxCueCodecState::ClassInfos(KaxCueCodecState::Create, KaxCueCodecState_TheId, "CueCodecState", KaxCueCodecState_Context);
const EbmlCallbacks KaxCueReference::ClassInfos(KaxCueReference::Create, KaxCueReference_TheId, "CueReference", KaxCueReference_Context);
const EbmlCallbacks KaxCueRefTime::ClassInfos(KaxCueRefTime::Create, KaxCueRefTime_TheId, "CueRefTime", KaxCueRefTime_Context);
const EbmlCallbacks KaxCueRefCluster::ClassInfos(KaxCueRefCluster::Create, KaxCueRefCluster_TheId, "CueRefCluster", KaxCueRefCluster_Context);
const EbmlCallbacks KaxCueRefNumber::ClassInfos(KaxCueRefNumber::Create, KaxCueRefNumber_TheId, "CueRefNumber", KaxCueRefNumber_Context);
const EbmlCallbacks KaxCueRefCodecState::ClassInfos(KaxCueRefCodecState::Create, KaxCueRefCodecState_TheId, "CueRefCodecState", KaxCueRefCodecState_Context);
#endif // MATROSKA_VERSION
KaxCuePoint::KaxCuePoint()
:EbmlMaster(KaxCuePoint_Context)
{}
KaxCueTrackPositions::KaxCueTrackPositions()
:EbmlMaster(KaxCueTrackPositions_Context)
{}
#if MATROSKA_VERSION >= 2
KaxCueReference::KaxCueReference()
:EbmlMaster(KaxCueReference_Context)
{}
#endif // MATROSKA_VERSION
/*!
\todo handle codec state checking
\todo remove duplicate references (reference to 2 frames that each reference the same frame)
*/
void KaxCuePoint::PositionSet(const KaxBlockGroup & BlockReference, uint64 GlobalTimecodeScale)
{
// fill me
KaxCueTime & NewTime = GetChild<KaxCueTime>(*this);
*static_cast<EbmlUInteger*>(&NewTime) = BlockReference.GlobalTimecode() / GlobalTimecodeScale;
KaxCueTrackPositions & NewPositions = AddNewChild<KaxCueTrackPositions>(*this);
KaxCueTrack & TheTrack = GetChild<KaxCueTrack>(NewPositions);
*static_cast<EbmlUInteger*>(&TheTrack) = BlockReference.TrackNumber();
KaxCueClusterPosition & TheClustPos = GetChild<KaxCueClusterPosition>(NewPositions);
*static_cast<EbmlUInteger*>(&TheClustPos) = BlockReference.ClusterPosition();
#if MATROSKA_VERSION >= 2
// handle reference use
if (BlockReference.ReferenceCount() != 0)
{
unsigned int i;
for (i=0; i<BlockReference.ReferenceCount(); i++) {
KaxCueReference & NewRefs = AddNewChild<KaxCueReference>(NewPositions);
NewRefs.AddReference(BlockReference.Reference(i).RefBlock(), GlobalTimecodeScale);
}
}
KaxCodecState *CodecState = static_cast<KaxCodecState *>(BlockReference.FindFirstElt(KaxCodecState::ClassInfos));
if (CodecState != NULL) {
KaxCueCodecState &CueCodecState = AddNewChild<KaxCueCodecState>(NewPositions);
*static_cast<EbmlUInteger*>(&CueCodecState) = BlockReference.GetParentCluster()->GetParentSegment()->GetRelativePosition(CodecState->GetElementPosition());
}
#endif // MATROSKA_VERSION
bValueIsSet = true;
}
void KaxCuePoint::PositionSet(const KaxBlockBlob & BlobReference, uint64 GlobalTimecodeScale)
{
const KaxInternalBlock &BlockReference = BlobReference;
// fill me
KaxCueTime & NewTime = GetChild<KaxCueTime>(*this);
*static_cast<EbmlUInteger*>(&NewTime) = BlockReference.GlobalTimecode() / GlobalTimecodeScale;
KaxCueTrackPositions & NewPositions = AddNewChild<KaxCueTrackPositions>(*this);
KaxCueTrack & TheTrack = GetChild<KaxCueTrack>(NewPositions);
*static_cast<EbmlUInteger*>(&TheTrack) = BlockReference.TrackNum();
KaxCueClusterPosition & TheClustPos = GetChild<KaxCueClusterPosition>(NewPositions);
*static_cast<EbmlUInteger*>(&TheClustPos) = BlockReference.ClusterPosition();
#if 0 // MATROSKA_VERSION >= 2
// handle reference use
if (BlockReference.ReferenceCount() != 0)
{
unsigned int i;
for (i=0; i<BlockReference.ReferenceCount(); i++) {
KaxCueReference & NewRefs = AddNewChild<KaxCueReference>(NewPositions);
NewRefs.AddReference(BlockReference.Reference(i).RefBlock(), GlobalTimecodeScale);
}
}
#endif // MATROSKA_VERSION
#if MATROSKA_VERSION >= 2
if (!BlobReference.IsSimpleBlock()) {
const KaxBlockGroup &BlockGroup = BlobReference;
const KaxCodecState *CodecState = static_cast<KaxCodecState *>(BlockGroup.FindFirstElt(KaxCodecState::ClassInfos));
if (CodecState != NULL) {
KaxCueCodecState &CueCodecState = AddNewChild<KaxCueCodecState>(NewPositions);
*static_cast<EbmlUInteger*>(&CueCodecState) = BlockGroup.GetParentCluster()->GetParentSegment()->GetRelativePosition(CodecState->GetElementPosition());
}
}
#endif // MATROSKA_VERSION
bValueIsSet = true;
}
#if MATROSKA_VERSION >= 2
/*!
\todo handle codec state checking
*/
void KaxCueReference::AddReference(const KaxBlockBlob & BlockReference, uint64 GlobalTimecodeScale)
{
const KaxInternalBlock & theBlock = BlockReference;
KaxCueRefTime & NewTime = GetChild<KaxCueRefTime>(*this);
*static_cast<EbmlUInteger*>(&NewTime) = theBlock.GlobalTimecode() / GlobalTimecodeScale;
KaxCueRefCluster & TheClustPos = GetChild<KaxCueRefCluster>(*this);
*static_cast<EbmlUInteger*>(&TheClustPos) = theBlock.ClusterPosition();
#ifdef OLD
// handle recursive reference use
if (BlockReference.ReferenceCount() != 0)
{
unsigned int i;
for (i=0; i<BlockReference.ReferenceCount(); i++) {
AddReference(BlockReference.Reference(i).RefBlock());
}
}
#endif /* OLD */
}
#endif
bool KaxCuePoint::operator<(const EbmlElement & EltB) const
{
assert(EbmlId(*this) == KaxCuePoint_TheId);
assert(EbmlId(EltB) == KaxCuePoint_TheId);
const KaxCuePoint & theEltB = *static_cast<const KaxCuePoint *>(&EltB);
// compare timecode
const KaxCueTime * TimeCodeA = static_cast<const KaxCueTime *>(FindElt(KaxCueTime::ClassInfos));
if (TimeCodeA == NULL)
return false;
const KaxCueTime * TimeCodeB = static_cast<const KaxCueTime *>(theEltB.FindElt(KaxCueTime::ClassInfos));
if (TimeCodeB == NULL)
return false;
if (*TimeCodeA < *TimeCodeB)
return true;
if (*TimeCodeB < *TimeCodeA)
return false;
// compare tracks (timecodes are equal)
const KaxCueTrack * TrackA = static_cast<const KaxCueTrack *>(FindElt(KaxCueTrack::ClassInfos));
if (TrackA == NULL)
return false;
const KaxCueTrack * TrackB = static_cast<const KaxCueTrack *>(theEltB.FindElt(KaxCueTrack::ClassInfos));
if (TrackB == NULL)
return false;
if (*TrackA < *TrackB)
return true;
if (*TrackB < *TrackA)
return false;
return false;
}
bool KaxCuePoint::Timecode(uint64 & aTimecode, uint64 GlobalTimecodeScale) const
{
const KaxCueTime *aTime = static_cast<const KaxCueTime *>(FindFirstElt(KaxCueTime::ClassInfos));
if (aTime == NULL)
return false;
aTimecode = uint64(*aTime) * GlobalTimecodeScale;
return true;
}
/*!
\brief return the position of the Cluster to load
*/
const KaxCueTrackPositions * KaxCuePoint::GetSeekPosition() const
{
const KaxCueTrackPositions * result = NULL;
uint64 aPosition = EBML_PRETTYLONGINT(0xFFFFFFFFFFFFFFF);
// find the position of the "earlier" Cluster
const KaxCueTrackPositions *aPoss = static_cast<const KaxCueTrackPositions *>(FindFirstElt(KaxCueTrackPositions::ClassInfos));
while (aPoss != NULL)
{
const KaxCueClusterPosition *aPos = static_cast<const KaxCueClusterPosition *>(aPoss->FindFirstElt(KaxCueClusterPosition::ClassInfos));
if (aPos != NULL && uint64(*aPos) < aPosition) {
aPosition = uint64(*aPos);
result = aPoss;
}
aPoss = static_cast<const KaxCueTrackPositions *>(FindNextElt(*aPoss));
}
return result;
}
uint64 KaxCueTrackPositions::ClusterPosition() const
{
const KaxCueClusterPosition *aPos = static_cast<const KaxCueClusterPosition *>(FindFirstElt(KaxCueClusterPosition::ClassInfos));
if (aPos == NULL)
return 0;
return uint64(*aPos);
}
uint16 KaxCueTrackPositions::TrackNumber() const
{
const KaxCueTrack *aTrack = static_cast<const KaxCueTrack *>(FindFirstElt(KaxCueTrack::ClassInfos));
if (aTrack == NULL)
return 0;
return uint16(*aTrack);
}
END_LIBMATROSKA_NAMESPACE

77
src/KaxInfo.cpp Normal file
View File

@ -0,0 +1,77 @@
/****************************************************************************
** libmatroska : parse Matroska files, see http://www.matroska.org/
**
** <file/class description>
**
** Copyright (C) 2002-2005 Steve Lhomme. All rights reserved.
**
** This file is part of libmatroska.
**
** This library is free software; you can redistribute it and/or
** modify it under the terms of the GNU Lesser General Public
** License as published by the Free Software Foundation; either
** version 2.1 of the License, or (at your option) any later version.
**
** This library is distributed in the hope that it will be useful,
** but WITHOUT ANY WARRANTY; without even the implied warranty of
** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
** Lesser General Public License for more details.
**
** You should have received a copy of the GNU Lesser General Public
** License along with this library; if not, write to the Free Software
** Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
**
** See http://www.matroska.org/license/lgpl/ for LGPL licensing information.**
** Contact license@matroska.org if any conditions of this licensing are
** not clear to you.
**
**********************************************************************/
/*!
\file
\version \$Id: KaxInfo.cpp 1078 2005-03-03 13:13:04Z robux4 $
\author Steve Lhomme <robux4 @ users.sf.net>
*/
#include "matroska/KaxInfo.h"
#include "matroska/KaxInfoData.h"
#include "matroska/KaxContexts.h"
// sub elements
START_LIBMATROSKA_NAMESPACE
const EbmlSemantic KaxInfo_ContextList[14] =
{
EbmlSemantic(false, true, KaxSegmentUID::ClassInfos),
EbmlSemantic(false, true, KaxSegmentFilename::ClassInfos),
EbmlSemantic(false, true, KaxPrevUID::ClassInfos),
EbmlSemantic(false, true, KaxPrevFilename::ClassInfos),
EbmlSemantic(false, true, KaxNextUID::ClassInfos),
EbmlSemantic(false, true, KaxNextFilename::ClassInfos),
EbmlSemantic(false, false, KaxSegmentFamily::ClassInfos),
EbmlSemantic(false, false, KaxChapterTranslate::ClassInfos),
EbmlSemantic(true, true, KaxTimecodeScale::ClassInfos),
EbmlSemantic(false, true, KaxDuration::ClassInfos),
EbmlSemantic(false, true, KaxDateUTC::ClassInfos),
EbmlSemantic(false, true, KaxTitle::ClassInfos),
EbmlSemantic(true, true, KaxMuxingApp::ClassInfos),
EbmlSemantic(true, true, KaxWritingApp::ClassInfos),
};
const EbmlSemanticContext KaxInfo_Context = EbmlSemanticContext(countof(KaxInfo_ContextList), KaxInfo_ContextList, &KaxSegment_Context, *GetKaxGlobal_Context, &KaxInfo::ClassInfos);
const EbmlSemanticContext KaxMuxingApp_Context = EbmlSemanticContext(0, NULL, &KaxInfo_Context, *GetKaxGlobal_Context, &KaxMuxingApp::ClassInfos);
const EbmlSemanticContext KaxWritingApp_Context = EbmlSemanticContext(0, NULL, &KaxInfo_Context, *GetKaxGlobal_Context, &KaxWritingApp::ClassInfos);
EbmlId KaxInfo_TheId (0x1549A966, 4);
EbmlId KaxMuxingApp_TheId (0x4D80, 2);
EbmlId KaxWritingApp_TheId(0x5741, 2);
const EbmlCallbacks KaxInfo::ClassInfos(KaxInfo::Create, KaxInfo_TheId, "Info", KaxInfo_Context);
const EbmlCallbacks KaxMuxingApp::ClassInfos(KaxMuxingApp::Create, KaxMuxingApp_TheId, "MuxingApp", KaxMuxingApp_Context);
const EbmlCallbacks KaxWritingApp::ClassInfos(KaxWritingApp::Create, KaxWritingApp_TheId, "WritingApp", KaxWritingApp_Context);
KaxInfo::KaxInfo()
:EbmlMaster(KaxInfo_Context)
{}
END_LIBMATROSKA_NAMESPACE

101
src/KaxInfoData.cpp Normal file
View File

@ -0,0 +1,101 @@
/****************************************************************************
** libmatroska : parse Matroska files, see http://www.matroska.org/
**
** <file/class description>
**
** Copyright (C) 2002-2005 Steve Lhomme. All rights reserved.
**
** This file is part of libmatroska.
**
** This library is free software; you can redistribute it and/or
** modify it under the terms of the GNU Lesser General Public
** License as published by the Free Software Foundation; either
** version 2.1 of the License, or (at your option) any later version.
**
** This library is distributed in the hope that it will be useful,
** but WITHOUT ANY WARRANTY; without even the implied warranty of
** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
** Lesser General Public License for more details.
**
** You should have received a copy of the GNU Lesser General Public
** License along with this library; if not, write to the Free Software
** Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
**
** See http://www.matroska.org/license/lgpl/ for LGPL licensing information.**
** Contact license@matroska.org if any conditions of this licensing are
** not clear to you.
**
**********************************************************************/
/*!
\file
\version \$Id: KaxInfoData.cpp 1078 2005-03-03 13:13:04Z robux4 $
\author Steve Lhomme <robux4 @ users.sf.net>
\author John Cannon <spyder2555 @ users.sf.net>
*/
#include "matroska/KaxInfoData.h"
#include "matroska/KaxContexts.h"
START_LIBMATROSKA_NAMESPACE
const EbmlSemantic KaxChapterTranslate_ContextList[3] =
{
EbmlSemantic(false, false, KaxChapterTranslateEditionUID::ClassInfos),
EbmlSemantic(true, true, KaxChapterTranslateCodec::ClassInfos),
EbmlSemantic(true, true, KaxChapterTranslateID::ClassInfos),
};
EbmlId KaxSegmentUID_TheId (0x73A4, 2);
EbmlId KaxSegmentFilename_TheId (0x7384, 2);
EbmlId KaxPrevUID_TheId (0x3CB923, 3);
EbmlId KaxPrevFilename_TheId (0x3C83AB, 3);
EbmlId KaxNextUID_TheId (0x3EB923, 3);
EbmlId KaxNextFilename_TheId (0x3E83BB, 3);
EbmlId KaxSegmentFamily_TheId (0x4444, 2);
EbmlId KaxChapterTranslate_TheId(0x6924, 2);
EbmlId KaxChapterTranslateEditionUID_TheId(0x69FC, 2);
EbmlId KaxChapterTranslateCodec_TheId(0x69BF, 2);
EbmlId KaxChapterTranslateID_TheId(0x69A5, 2);
EbmlId KaxTimecodeScale_TheId (0x2AD7B1, 3);
EbmlId KaxDuration_TheId (0x4489, 2);
EbmlId KaxDateUTC_TheId (0x4461, 2);
EbmlId KaxTitle_TheId (0x7BA9, 2);
const EbmlSemanticContext KaxSegmentUID_Context = EbmlSemanticContext(0, NULL, &KaxInfo_Context, *GetKaxGlobal_Context, &KaxSegmentUID::ClassInfos);
const EbmlSemanticContext KaxSegmentFilename_Context = EbmlSemanticContext(0, NULL, &KaxInfo_Context, *GetKaxGlobal_Context, &KaxSegmentFilename::ClassInfos);
const EbmlSemanticContext KaxPrevUID_Context = EbmlSemanticContext(0, NULL, &KaxInfo_Context, *GetKaxGlobal_Context, &KaxPrevUID::ClassInfos);
const EbmlSemanticContext KaxPrevFilename_Context = EbmlSemanticContext(0, NULL, &KaxInfo_Context, *GetKaxGlobal_Context, &KaxPrevFilename::ClassInfos);
const EbmlSemanticContext KaxNextUID_Context = EbmlSemanticContext(0, NULL, &KaxInfo_Context, *GetKaxGlobal_Context, &KaxNextUID::ClassInfos);
const EbmlSemanticContext KaxNextFilename_Context = EbmlSemanticContext(0, NULL, &KaxInfo_Context, *GetKaxGlobal_Context, &KaxNextFilename::ClassInfos);
const EbmlSemanticContext KaxSegmentFamily_Context = EbmlSemanticContext(0, NULL, &KaxInfo_Context, *GetKaxGlobal_Context, &KaxSegmentFamily::ClassInfos);
const EbmlSemanticContext KaxChapterTranslate_Context = EbmlSemanticContext(countof(KaxChapterTranslate_ContextList), KaxChapterTranslate_ContextList, &KaxInfo_Context, *GetKaxGlobal_Context, &KaxChapterTranslate::ClassInfos);
const EbmlSemanticContext KaxChapterTranslateEditionUID_Context = EbmlSemanticContext(0, NULL, &KaxChapterTranslate_Context, *GetKaxGlobal_Context, &KaxChapterTranslateEditionUID::ClassInfos);
const EbmlSemanticContext KaxChapterTranslateCodec_Context = EbmlSemanticContext(0, NULL, &KaxChapterTranslate_Context, *GetKaxGlobal_Context, &KaxChapterTranslateCodec::ClassInfos);
const EbmlSemanticContext KaxChapterTranslateID_Context = EbmlSemanticContext(0, NULL, &KaxChapterTranslate_Context, *GetKaxGlobal_Context, &KaxChapterTranslateID::ClassInfos);
const EbmlSemanticContext KaxTimecodeScale_Context = EbmlSemanticContext(0, NULL, &KaxInfo_Context, *GetKaxGlobal_Context, &KaxTimecodeScale::ClassInfos);
const EbmlSemanticContext KaxDuration_Context = EbmlSemanticContext(0, NULL, &KaxInfo_Context, *GetKaxGlobal_Context, &KaxDuration::ClassInfos);
const EbmlSemanticContext KaxDateUTC_Context = EbmlSemanticContext(0, NULL, &KaxInfo_Context, *GetKaxGlobal_Context, &KaxDateUTC::ClassInfos);
const EbmlSemanticContext KaxTitle_Context = EbmlSemanticContext(0, NULL, &KaxInfo_Context, *GetKaxGlobal_Context, &KaxTitle::ClassInfos);
const EbmlCallbacks KaxSegmentUID::ClassInfos(KaxSegmentUID::Create, KaxSegmentUID_TheId, "SegmentUID", KaxSegmentUID_Context);
const EbmlCallbacks KaxSegmentFilename::ClassInfos(KaxSegmentFilename::Create, KaxSegmentFilename_TheId, "SegmentFilename", KaxSegmentFilename_Context);
const EbmlCallbacks KaxPrevUID::ClassInfos(KaxPrevUID::Create, KaxPrevUID_TheId, "PrevUID", KaxPrevUID_Context);
const EbmlCallbacks KaxPrevFilename::ClassInfos(KaxPrevFilename::Create, KaxPrevFilename_TheId, "PrevFilename", KaxPrevFilename_Context);
const EbmlCallbacks KaxNextUID::ClassInfos(KaxNextUID::Create, KaxNextUID_TheId, "NextUID", KaxNextUID_Context);
const EbmlCallbacks KaxNextFilename::ClassInfos(KaxNextFilename::Create, KaxNextFilename_TheId, "NextFilename", KaxNextFilename_Context);
const EbmlCallbacks KaxSegmentFamily::ClassInfos(KaxSegmentFamily::Create, KaxSegmentFamily_TheId, "SegmentFamily", KaxSegmentFamily_Context);
const EbmlCallbacks KaxChapterTranslate::ClassInfos(KaxChapterTranslate::Create, KaxChapterTranslate_TheId, "ChapterTranslate", KaxChapterTranslate_Context);
const EbmlCallbacks KaxChapterTranslateEditionUID::ClassInfos(KaxChapterTranslateEditionUID::Create, KaxChapterTranslateEditionUID_TheId, "ChapterTranslateEditionUID", KaxChapterTranslateEditionUID_Context);
const EbmlCallbacks KaxChapterTranslateCodec::ClassInfos(KaxChapterTranslateCodec::Create, KaxChapterTranslateCodec_TheId, "ChapterTranslateCodec", KaxChapterTranslateCodec_Context);
const EbmlCallbacks KaxChapterTranslateID::ClassInfos(KaxChapterTranslateID::Create, KaxChapterTranslateID_TheId, "ChapterTranslateID", KaxChapterTranslateID_Context);
const EbmlCallbacks KaxTimecodeScale::ClassInfos(KaxTimecodeScale::Create, KaxTimecodeScale_TheId, "TimecodeScale", KaxTimecodeScale_Context);
const EbmlCallbacks KaxDuration::ClassInfos(KaxDuration::Create, KaxDuration_TheId, "Duration", KaxDuration_Context);
const EbmlCallbacks KaxDateUTC::ClassInfos(KaxDateUTC::Create, KaxDateUTC_TheId, "DateUTC", KaxDateUTC_Context);
const EbmlCallbacks KaxTitle::ClassInfos(KaxTitle::Create, KaxTitle_TheId, "Title", KaxTitle_Context);
KaxChapterTranslate::KaxChapterTranslate()
:EbmlMaster(KaxChapterTranslate_Context)
{}
END_LIBMATROSKA_NAMESPACE

181
src/KaxSeekHead.cpp Normal file
View File

@ -0,0 +1,181 @@
/****************************************************************************
** libmatroska : parse Matroska files, see http://www.matroska.org/
**
** <file/class description>
**
** Copyright (C) 2002-2004 Steve Lhomme. All rights reserved.
**
** This file is part of libmatroska.
**
** This library is free software; you can redistribute it and/or
** modify it under the terms of the GNU Lesser General Public
** License as published by the Free Software Foundation; either
** version 2.1 of the License, or (at your option) any later version.
**
** This library is distributed in the hope that it will be useful,
** but WITHOUT ANY WARRANTY; without even the implied warranty of
** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
** Lesser General Public License for more details.
**
** You should have received a copy of the GNU Lesser General Public
** License along with this library; if not, write to the Free Software
** Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
**
** See http://www.matroska.org/license/lgpl/ for LGPL licensing information.**
** Contact license@matroska.org if any conditions of this licensing are
** not clear to you.
**
**********************************************************************/
/*!
\file
\version \$Id: KaxSeekHead.cpp 640 2004-07-09 21:05:36Z mosu $
\author Steve Lhomme <robux4 @ users.sf.net>
*/
#include "matroska/KaxSeekHead.h"
#include "matroska/KaxContexts.h"
#include "matroska/KaxSegment.h"
#include "matroska/KaxCues.h"
using namespace LIBEBML_NAMESPACE;
// sub elements
START_LIBMATROSKA_NAMESPACE
EbmlSemantic KaxSeekHead_ContextList[1] =
{
EbmlSemantic(true, false, KaxSeek::ClassInfos),
};
EbmlSemantic KaxSeek_ContextList[2] =
{
EbmlSemantic(true, true, KaxSeekID::ClassInfos),
EbmlSemantic(true, true, KaxSeekPosition::ClassInfos),
};
const EbmlSemanticContext KaxSeekHead_Context = EbmlSemanticContext(countof(KaxSeekHead_ContextList), KaxSeekHead_ContextList, &KaxSegment_Context, *GetKaxGlobal_Context, &KaxSeekHead::ClassInfos);
const EbmlSemanticContext KaxSeek_Context = EbmlSemanticContext(countof(KaxSeek_ContextList), KaxSeek_ContextList, &KaxSeekHead_Context, *GetKaxGlobal_Context, &KaxSeek::ClassInfos);
const EbmlSemanticContext KaxSeekID_Context = EbmlSemanticContext(0, NULL, &KaxSeek_Context, *GetKaxGlobal_Context, &KaxSeekID::ClassInfos);
const EbmlSemanticContext KaxSeekPosition_Context = EbmlSemanticContext(0, NULL, &KaxSeek_Context, *GetKaxGlobal_Context, &KaxSeekPosition::ClassInfos);
EbmlId KaxSeekHead_TheId (0x114D9B74, 4);
EbmlId KaxSeek_TheId (0x4DBB, 2);
EbmlId KaxSeekID_TheId (0x53AB, 2);
EbmlId KaxSeekPosition_TheId(0x53AC, 2);
const EbmlCallbacks KaxSeekHead::ClassInfos(KaxSeekHead::Create, KaxSeekHead_TheId, "SeekHeader", KaxSeekHead_Context);
const EbmlCallbacks KaxSeek::ClassInfos(KaxSeek::Create, KaxSeek_TheId, "SeekPoint", KaxSeek_Context);
const EbmlCallbacks KaxSeekID::ClassInfos(KaxSeekID::Create, KaxSeekID_TheId, "SeekID", KaxSeekID_Context);
const EbmlCallbacks KaxSeekPosition::ClassInfos(KaxSeekPosition::Create, KaxSeekPosition_TheId, "SeekPosition", KaxSeekPosition_Context);
KaxSeekHead::KaxSeekHead()
:EbmlMaster(KaxSeekHead_Context)
{}
KaxSeek::KaxSeek()
:EbmlMaster(KaxSeek_Context)
{}
/*!
\todo verify that the element is not already in the list
*/
void KaxSeekHead::IndexThis(const EbmlElement & aElt, const KaxSegment & ParentSegment)
{
// create a new point
KaxSeek & aNewPoint = AddNewChild<KaxSeek>(*this);
// add the informations to this element
KaxSeekPosition & aNewPos = GetChild<KaxSeekPosition>(aNewPoint);
*static_cast<EbmlUInteger *>(&aNewPos) = ParentSegment.GetRelativePosition(aElt);
KaxSeekID & aNewID = GetChild<KaxSeekID>(aNewPoint);
binary ID[4];
for (int i=aElt.Generic().GlobalId.Length; i>0; i--) {
ID[4-i] = (aElt.Generic().GlobalId.Value >> 8*(i-1)) & 0xFF;
}
aNewID.CopyBuffer(ID, aElt.Generic().GlobalId.Length);
}
KaxSeek * KaxSeekHead::FindFirstOf(const EbmlCallbacks & Callbacks) const
{
// parse all the Entries and find the first to match the type
KaxSeek * aElt = static_cast<KaxSeek *>(FindFirstElt(KaxSeek::ClassInfos));
while (aElt != NULL)
{
KaxSeekID * aId = NULL;
for (unsigned int i = 0; i<aElt->ListSize(); i++) {
if (EbmlId(*(*aElt)[i]) == KaxSeekID::ClassInfos.GlobalId) {
aId = static_cast<KaxSeekID*>((*aElt)[i]);
EbmlId aEbmlId(aId->GetBuffer(), aId->GetSize());
if (aEbmlId == Callbacks.GlobalId)
{
return aElt;
}
break;
}
}
aElt = static_cast<KaxSeek *>(FindNextElt(*aElt));
}
return NULL;
}
KaxSeek * KaxSeekHead::FindNextOf(const KaxSeek &aPrev) const
{
unsigned int iIndex;
KaxSeek *tmp;
// look for the previous in the list
for (iIndex = 0; iIndex<ElementList.size(); iIndex++)
{
if (ElementList[iIndex] == static_cast<const EbmlElement*>(&aPrev))
break;
}
if (iIndex <ElementList.size()) {
iIndex++;
for (; iIndex<ElementList.size(); iIndex++)
{
if (EbmlId(*(ElementList[iIndex])) == KaxSeek::ClassInfos.GlobalId)
{
tmp = static_cast<KaxSeek *>(ElementList[iIndex]);
if (tmp->IsEbmlId(aPrev))
return tmp;
}
}
}
return NULL;
}
int64 KaxSeek::Location() const
{
KaxSeekPosition *aPos = static_cast<KaxSeekPosition*>(FindFirstElt(KaxSeekPosition::ClassInfos));
if (aPos == NULL)
return 0;
return uint64(*aPos);
}
bool KaxSeek::IsEbmlId(const EbmlId & aId) const
{
KaxSeekID *_Id = static_cast<KaxSeekID*>(FindFirstElt(KaxSeekID::ClassInfos));
if (_Id == NULL)
return false;
EbmlId aEbmlId(_Id->GetBuffer(), _Id->GetSize());
return (aId == aEbmlId);
}
bool KaxSeek::IsEbmlId(const KaxSeek & aPoint) const
{
KaxSeekID *_IdA = static_cast<KaxSeekID*>(FindFirstElt(KaxSeekID::ClassInfos));
if (_IdA == NULL)
return false;
KaxSeekID *_IdB = static_cast<KaxSeekID*>(aPoint.FindFirstElt(KaxSeekID::ClassInfos));
if (_IdB == NULL)
return false;
EbmlId aEbmlIdA(_IdA->GetBuffer(), _IdA->GetSize());
EbmlId aEbmlIdB(_IdB->GetBuffer(), _IdB->GetSize());
return (aEbmlIdA == aEbmlIdB);
}
END_LIBMATROSKA_NAMESPACE

111
src/KaxSegment.cpp Normal file
View File

@ -0,0 +1,111 @@
/****************************************************************************
** libmatroska : parse Matroska files, see http://www.matroska.org/
**
** <file/class description>
**
** Copyright (C) 2002-2004 Steve Lhomme. All rights reserved.
**
** This file is part of libmatroska.
**
** This library is free software; you can redistribute it and/or
** modify it under the terms of the GNU Lesser General Public
** License as published by the Free Software Foundation; either
** version 2.1 of the License, or (at your option) any later version.
**
** This library is distributed in the hope that it will be useful,
** but WITHOUT ANY WARRANTY; without even the implied warranty of
** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
** Lesser General Public License for more details.
**
** You should have received a copy of the GNU Lesser General Public
** License along with this library; if not, write to the Free Software
** Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
**
** See http://www.matroska.org/license/lgpl/ for LGPL licensing information.**
** Contact license@matroska.org if any conditions of this licensing are
** not clear to you.
**
**********************************************************************/
/*!
\file
\version \$Id: KaxSegment.cpp 1096 2005-03-17 09:14:52Z robux4 $
\author Steve Lhomme <robux4 @ users.sf.net>
*/
#include "matroska/KaxSegment.h"
#include "ebml/EbmlHead.h"
// sub elements
#include "matroska/KaxCluster.h"
#include "matroska/KaxSeekHead.h"
#include "matroska/KaxCues.h"
#include "matroska/KaxTracks.h"
#include "matroska/KaxInfo.h"
#include "matroska/KaxChapters.h"
#include "matroska/KaxAttachments.h"
#include "matroska/KaxTags.h"
#include "matroska/KaxContexts.h"
START_LIBMATROSKA_NAMESPACE
EbmlSemantic KaxMatroska_ContextList[2] =
{
EbmlSemantic(true, true, EbmlHead::ClassInfos),
EbmlSemantic(true, false, KaxSegment::ClassInfos),
};
EbmlSemantic KaxSegment_ContextList[8] =
{
EbmlSemantic(false, false, KaxCluster::ClassInfos),
EbmlSemantic(false, false, KaxSeekHead::ClassInfos),
EbmlSemantic(false, true, KaxCues::ClassInfos),
EbmlSemantic(false, false, KaxTracks::ClassInfos),
EbmlSemantic(true, true, KaxInfo::ClassInfos),
EbmlSemantic(false, true, KaxChapters::ClassInfos),
EbmlSemantic(false, true, KaxAttachments::ClassInfos),
EbmlSemantic(false, true, KaxTags::ClassInfos),
};
const EbmlSemanticContext KaxMatroska_Context = EbmlSemanticContext(countof(KaxMatroska_ContextList), KaxMatroska_ContextList, NULL, *GetKaxGlobal_Context, NULL);
const EbmlSemanticContext KaxSegment_Context = EbmlSemanticContext(countof(KaxSegment_ContextList), KaxSegment_ContextList, NULL, *GetKaxGlobal_Context, &KaxSegment::ClassInfos);
EbmlId KaxSegment_TheId(0x18538067, 4);
const EbmlCallbacks KaxSegment::ClassInfos(KaxSegment::Create, KaxSegment_TheId, "Segment\0rotomopogo", KaxSegment_Context);
KaxSegment::KaxSegment()
:EbmlMaster(KaxSegment_Context)
{
SetSizeLength(5); // mandatory min size support (for easier updating) (2^(7*5)-2 = 32Go)
SetSizeInfinite(); // by default a segment is big and the size is unknown in advance
}
KaxSegment::KaxSegment(const KaxSegment & ElementToClone)
:EbmlMaster(ElementToClone)
{
// update the parent of each children
std::vector<EbmlElement *>::const_iterator Itr = ElementList.begin();
while (Itr != ElementList.end())
{
if (EbmlId(**Itr) == KaxCluster::ClassInfos.GlobalId) {
static_cast<KaxCluster *>(*Itr)->SetParent(*this);
}
}
}
uint64 KaxSegment::GetRelativePosition(uint64 aGlobalPosition) const
{
return aGlobalPosition - GetElementPosition() - HeadSize();
}
uint64 KaxSegment::GetRelativePosition(const EbmlElement & Elt) const
{
return GetRelativePosition(Elt.GetElementPosition());
}
uint64 KaxSegment::GetGlobalPosition(uint64 aRelativePosition) const
{
return aRelativePosition + GetElementPosition() + HeadSize();
}
END_LIBMATROSKA_NAMESPACE

347
src/KaxTag.cpp Normal file
View File

@ -0,0 +1,347 @@
/****************************************************************************
** libmatroska : parse Matroska files, see http://www.matroska.org/
**
** <file/class description>
**
** Copyright (C) 2002-2004 Steve Lhomme. All rights reserved.
**
** This file is part of libmatroska.
**
** This library is free software; you can redistribute it and/or
** modify it under the terms of the GNU Lesser General Public
** License as published by the Free Software Foundation; either
** version 2.1 of the License, or (at your option) any later version.
**
** This library is distributed in the hope that it will be useful,
** but WITHOUT ANY WARRANTY; without even the implied warranty of
** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
** Lesser General Public License for more details.
**
** You should have received a copy of the GNU Lesser General Public
** License along with this library; if not, write to the Free Software
** Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
**
** See http://www.matroska.org/license/lgpl/ for LGPL licensing information.**
** Contact license@matroska.org if any conditions of this licensing are
** not clear to you.
**
**********************************************************************/
/*!
\file
\version \$Id: KaxTag.cpp 1325 2009-03-30 07:56:54Z robux4 $
\author Jory Stone <jcsston @ toughguy.net>
\author Steve Lhomme <robux4 @ users.sf.net>
*/
#include "matroska/KaxTag.h"
#include "matroska/KaxTagMulti.h"
#include "matroska/KaxContexts.h"
using namespace LIBEBML_NAMESPACE;
// sub elements
START_LIBMATROSKA_NAMESPACE
EbmlSemantic KaxTag_ContextList[14] =
{
EbmlSemantic(true, true, KaxTagTargets::ClassInfos),
EbmlSemantic(false, true, KaxTagGeneral::ClassInfos),
EbmlSemantic(false, true, KaxTagGenres::ClassInfos),
EbmlSemantic(false, true, KaxTagAudioSpecific::ClassInfos),
EbmlSemantic(false, true, KaxTagImageSpecific::ClassInfos),
EbmlSemantic(false, true, KaxTagMultiCommercial::ClassInfos),
EbmlSemantic(false, true, KaxTagMultiDate::ClassInfos),
EbmlSemantic(false, true, KaxTagMultiEntity::ClassInfos),
EbmlSemantic(false, true, KaxTagMultiIdentifier::ClassInfos),
EbmlSemantic(false, true, KaxTagMultiLegal::ClassInfos),
EbmlSemantic(false, true, KaxTagMultiTitle::ClassInfos),
EbmlSemantic(false, true, KaxTagMultiAttachment::ClassInfos),
// EbmlSemantic(false, false, KaxTagLength::ClassInfos),
// EbmlSemantic(false, false, KaxTagPlaylistDelay::ClassInfos),
// EbmlSemantic(false, false, KaxTagUnsynchronisedText::ClassInfos),
// EbmlSemantic(false, false, KaxTagUserDefinedURL::ClassInfos),
EbmlSemantic(false, false, KaxTagMultiComment::ClassInfos),
EbmlSemantic(true, false, KaxTagSimple::ClassInfos),
};
EbmlSemantic KaxTagTargets_ContextList[6] =
{
EbmlSemantic(false, true, KaxTagTargetTypeValue::ClassInfos),
EbmlSemantic(false, true, KaxTagTargetType::ClassInfos),
EbmlSemantic(false, false, KaxTagTrackUID::ClassInfos),
EbmlSemantic(false, false, KaxTagEditionUID::ClassInfos),
EbmlSemantic(false, false, KaxTagChapterUID::ClassInfos),
EbmlSemantic(false, false, KaxTagAttachmentUID::ClassInfos),
};
EbmlSemantic KaxTagGeneral_ContextList[17] =
{
EbmlSemantic(false, true, KaxTagArchivalLocation::ClassInfos),
EbmlSemantic(false, true, KaxTagFile::ClassInfos),
EbmlSemantic(false, false, KaxTagKeywords::ClassInfos),
EbmlSemantic(false, true, KaxTagMood::ClassInfos),
EbmlSemantic(false, false, KaxTagRecordLocation::ClassInfos),
EbmlSemantic(false, true, KaxTagSource::ClassInfos),
EbmlSemantic(false, true, KaxTagSourceForm::ClassInfos),
EbmlSemantic(false, true, KaxTagProduct::ClassInfos),
EbmlSemantic(false, true, KaxTagOriginalMediaType::ClassInfos),
EbmlSemantic(false, true, KaxTagPlayCounter::ClassInfos),
EbmlSemantic(false, true, KaxTagPopularimeter::ClassInfos),
EbmlSemantic(false, true, KaxTagSubject::ClassInfos),
EbmlSemantic(false, true, KaxTagBibliography::ClassInfos),
EbmlSemantic(false, true, KaxTagLanguage::ClassInfos),
EbmlSemantic(false, true, KaxTagRating::ClassInfos),
EbmlSemantic(false, true, KaxTagEncoder::ClassInfos),
EbmlSemantic(false, true, KaxTagEncodeSettings::ClassInfos),
};
EbmlSemantic KaxTagGenres_ContextList[3] =
{
EbmlSemantic(false, false, KaxTagAudioGenre::ClassInfos),
EbmlSemantic(false, false, KaxTagVideoGenre::ClassInfos),
EbmlSemantic(false, true, KaxTagSubGenre::ClassInfos),
};
EbmlSemantic KaxTagAudioSpecific_ContextList[10] =
{
EbmlSemantic(false, true, KaxTagAudioPeak::ClassInfos),
EbmlSemantic(false, true, KaxTagAudioEncryption::ClassInfos),
EbmlSemantic(false, true, KaxTagAudioGain::ClassInfos),
EbmlSemantic(false, true, KaxTagBPM::ClassInfos),
EbmlSemantic(false, true, KaxTagDiscTrack::ClassInfos),
EbmlSemantic(false, true, KaxTagSetPart::ClassInfos),
EbmlSemantic(false, true, KaxTagEqualisation::ClassInfos),
EbmlSemantic(false, true, KaxTagInitialKey::ClassInfos),
EbmlSemantic(false, true, KaxTagOfficialAudioFileURL::ClassInfos),
EbmlSemantic(false, true, KaxTagOfficialAudioSourceURL::ClassInfos),
};
EbmlSemantic KaxTagImageSpecific_ContextList[6] =
{
EbmlSemantic(false, true, KaxTagCaptureDPI::ClassInfos),
EbmlSemantic(false, true, KaxTagCaptureLightness::ClassInfos),
EbmlSemantic(false, true, KaxTagCapturePaletteSetting::ClassInfos),
EbmlSemantic(false, true, KaxTagCaptureSharpness::ClassInfos),
EbmlSemantic(false, true, KaxTagCropped::ClassInfos),
EbmlSemantic(false, true, KaxTagOriginalDimensions::ClassInfos),
};
EbmlSemantic KaxTagSimple_ContextList[6] =
{
EbmlSemantic(true, true, KaxTagName::ClassInfos),
EbmlSemantic(true, true, KaxTagLangue::ClassInfos),
EbmlSemantic(true, true, KaxTagDefault::ClassInfos),
EbmlSemantic(false, true, KaxTagString::ClassInfos),
EbmlSemantic(false, true, KaxTagBinary::ClassInfos),
EbmlSemantic(false, false, KaxTagSimple::ClassInfos),
};
const EbmlSemanticContext KaxTag_Context = EbmlSemanticContext(countof(KaxTag_ContextList), KaxTag_ContextList, &KaxTags_Context, *GetKaxTagsGlobal_Context, &KaxTag::ClassInfos);
const EbmlSemanticContext KaxTagTargets_Context = EbmlSemanticContext(countof(KaxTagTargets_ContextList), KaxTagTargets_ContextList, &KaxTag_Context, *GetKaxTagsGlobal_Context, &KaxTagTargets::ClassInfos);
const EbmlSemanticContext KaxTagGeneral_Context = EbmlSemanticContext(countof(KaxTagGeneral_ContextList), KaxTagGeneral_ContextList, &KaxTag_Context, *GetKaxTagsGlobal_Context, &KaxTagGeneral::ClassInfos);
const EbmlSemanticContext KaxTagGenres_Context = EbmlSemanticContext(countof(KaxTagGenres_ContextList), KaxTagGenres_ContextList, &KaxTag_Context, *GetKaxTagsGlobal_Context, &KaxTagGenres::ClassInfos);
const EbmlSemanticContext KaxTagAudioSpecific_Context = EbmlSemanticContext(countof(KaxTagAudioSpecific_ContextList), KaxTagAudioSpecific_ContextList, &KaxTag_Context, *GetKaxTagsGlobal_Context, &KaxTagAudioSpecific::ClassInfos);
const EbmlSemanticContext KaxTagImageSpecific_Context = EbmlSemanticContext(countof(KaxTagImageSpecific_ContextList), KaxTagImageSpecific_ContextList, &KaxTag_Context, *GetKaxTagsGlobal_Context, &KaxTagImageSpecific::ClassInfos);
const EbmlSemanticContext KaxTagBibliography_Context = EbmlSemanticContext(0, NULL, &KaxTag_Context, *GetKaxGlobal_Context, &KaxTagBibliography::ClassInfos);
const EbmlSemanticContext KaxTagEncoder_Context = EbmlSemanticContext(0, NULL, &KaxTag_Context, *GetKaxGlobal_Context, &KaxTagEncoder::ClassInfos);
const EbmlSemanticContext KaxTagEncodeSettings_Context = EbmlSemanticContext(0, NULL, &KaxTag_Context, *GetKaxGlobal_Context, &KaxTagEncodeSettings::ClassInfos);
const EbmlSemanticContext KaxTagLanguage_Context = EbmlSemanticContext(0, NULL, &KaxTag_Context, *GetKaxGlobal_Context, &KaxTagLanguage::ClassInfos);
const EbmlSemanticContext KaxTagLength_Context = EbmlSemanticContext(0, NULL, &KaxTag_Context, *GetKaxGlobal_Context, &KaxTagLength::ClassInfos);
const EbmlSemanticContext KaxTagPlaylistDelay_Context = EbmlSemanticContext(0, NULL, &KaxTag_Context, *GetKaxGlobal_Context, &KaxTagPlaylistDelay::ClassInfos);
const EbmlSemanticContext KaxTagRating_Context = EbmlSemanticContext(0, NULL, &KaxTag_Context, *GetKaxGlobal_Context, &KaxTagRating::ClassInfos);
const EbmlSemanticContext KaxTagSubject_Context = EbmlSemanticContext(0, NULL, &KaxTag_Context, *GetKaxGlobal_Context, &KaxTagSubject::ClassInfos);
const EbmlSemanticContext KaxTagUnsynchronisedText_Context = EbmlSemanticContext(0, NULL, &KaxTag_Context, *GetKaxGlobal_Context, &KaxTagUnsynchronisedText::ClassInfos);
const EbmlSemanticContext KaxTagUserDefinedURL_Context = EbmlSemanticContext(0, NULL, &KaxTag_Context, *GetKaxGlobal_Context, &KaxTagUserDefinedURL::ClassInfos);
const EbmlSemanticContext KaxTagTargetTypeValue_Context = EbmlSemanticContext(0, NULL, &KaxTagTargets_Context, *GetKaxGlobal_Context, &KaxTagTargetTypeValue::ClassInfos);
const EbmlSemanticContext KaxTagTargetType_Context = EbmlSemanticContext(0, NULL, &KaxTagTargets_Context, *GetKaxGlobal_Context, &KaxTagTargetType::ClassInfos);
const EbmlSemanticContext KaxTagTrackUID_Context = EbmlSemanticContext(0, NULL, &KaxTagTargets_Context, *GetKaxGlobal_Context, &KaxTagTrackUID::ClassInfos);
const EbmlSemanticContext KaxTagEditionUID_Context = EbmlSemanticContext(0, NULL, &KaxTagTargets_Context, *GetKaxGlobal_Context, &KaxTagEditionUID::ClassInfos);
const EbmlSemanticContext KaxTagChapterUID_Context = EbmlSemanticContext(0, NULL, &KaxTagTargets_Context, *GetKaxGlobal_Context, &KaxTagChapterUID::ClassInfos);
const EbmlSemanticContext KaxTagAttachmentUID_Context = EbmlSemanticContext(0, NULL, &KaxTagTargets_Context, *GetKaxGlobal_Context, &KaxTagAttachmentUID::ClassInfos);
const EbmlSemanticContext KaxTagArchivalLocation_Context = EbmlSemanticContext(0, NULL, &KaxTagGeneral_Context, *GetKaxGlobal_Context, &KaxTagArchivalLocation::ClassInfos);
const EbmlSemanticContext KaxTagFile_Context = EbmlSemanticContext(0, NULL, &KaxTagGeneral_Context, *GetKaxGlobal_Context, &KaxTagFile::ClassInfos);
const EbmlSemanticContext KaxTagKeywords_Context = EbmlSemanticContext(0, NULL, &KaxTagGeneral_Context, *GetKaxGlobal_Context, &KaxTagKeywords::ClassInfos);
const EbmlSemanticContext KaxTagMood_Context = EbmlSemanticContext(0, NULL, &KaxTagGeneral_Context, *GetKaxGlobal_Context, &KaxTagMood::ClassInfos);
const EbmlSemanticContext KaxTagRecordLocation_Context = EbmlSemanticContext(0, NULL, &KaxTagGeneral_Context, *GetKaxGlobal_Context, &KaxTagRecordLocation::ClassInfos);
const EbmlSemanticContext KaxTagSource_Context = EbmlSemanticContext(0, NULL, &KaxTagGeneral_Context, *GetKaxGlobal_Context, &KaxTagSource::ClassInfos);
const EbmlSemanticContext KaxTagSourceForm_Context = EbmlSemanticContext(0, NULL, &KaxTagGeneral_Context, *GetKaxGlobal_Context, &KaxTagSourceForm::ClassInfos);
const EbmlSemanticContext KaxTagProduct_Context = EbmlSemanticContext(0, NULL, &KaxTagGeneral_Context, *GetKaxGlobal_Context, &KaxTagProduct::ClassInfos);
const EbmlSemanticContext KaxTagOriginalMediaType_Context = EbmlSemanticContext(0, NULL, &KaxTagGeneral_Context, *GetKaxGlobal_Context, &KaxTagOriginalMediaType::ClassInfos);
const EbmlSemanticContext KaxTagPlayCounter_Context = EbmlSemanticContext(0, NULL, &KaxTagGeneral_Context, *GetKaxGlobal_Context, &KaxTagPlayCounter::ClassInfos);
const EbmlSemanticContext KaxTagPopularimeter_Context = EbmlSemanticContext(0, NULL, &KaxTagGeneral_Context, *GetKaxGlobal_Context, &KaxTagPopularimeter::ClassInfos);
const EbmlSemanticContext KaxTagAudioGenre_Context = EbmlSemanticContext(0, NULL, &KaxTagGenres_Context, *GetKaxGlobal_Context, &KaxTagAudioGenre::ClassInfos);
const EbmlSemanticContext KaxTagVideoGenre_Context = EbmlSemanticContext(0, NULL, &KaxTagGenres_Context, *GetKaxGlobal_Context, &KaxTagVideoGenre::ClassInfos);
const EbmlSemanticContext KaxTagSubGenre_Context = EbmlSemanticContext(0, NULL, &KaxTagGenres_Context, *GetKaxGlobal_Context, &KaxTagSubGenre::ClassInfos);
const EbmlSemanticContext KaxTagAudioEncryption_Context = EbmlSemanticContext(0, NULL, &KaxTagAudioSpecific_Context, *GetKaxGlobal_Context, &KaxTagAudioEncryption::ClassInfos);
const EbmlSemanticContext KaxTagAudioGain_Context = EbmlSemanticContext(0, NULL, &KaxTagAudioSpecific_Context, *GetKaxGlobal_Context, &KaxTagAudioGain::ClassInfos);
const EbmlSemanticContext KaxTagAudioPeak_Context = EbmlSemanticContext(0, NULL, &KaxTagAudioSpecific_Context, *GetKaxGlobal_Context, &KaxTagAudioPeak::ClassInfos);
const EbmlSemanticContext KaxTagBPM_Context = EbmlSemanticContext(0, NULL, &KaxTagAudioSpecific_Context, *GetKaxGlobal_Context, &KaxTagBPM::ClassInfos);
const EbmlSemanticContext KaxTagDiscTrack_Context = EbmlSemanticContext(0, NULL, &KaxTagAudioSpecific_Context, *GetKaxGlobal_Context, &KaxTagDiscTrack::ClassInfos);
const EbmlSemanticContext KaxTagSetPart_Context = EbmlSemanticContext(0, NULL, &KaxTagAudioSpecific_Context, *GetKaxGlobal_Context, &KaxTagSetPart::ClassInfos);
const EbmlSemanticContext KaxTagEqualisation_Context = EbmlSemanticContext(0, NULL, &KaxTagAudioSpecific_Context, *GetKaxGlobal_Context, &KaxTagEqualisation::ClassInfos);
const EbmlSemanticContext KaxTagInitialKey_Context = EbmlSemanticContext(0, NULL, &KaxTagAudioSpecific_Context, *GetKaxGlobal_Context, &KaxTagInitialKey::ClassInfos);
const EbmlSemanticContext KaxTagOfficialAudioFileURL_Context = EbmlSemanticContext(0, NULL, &KaxTagAudioSpecific_Context, *GetKaxGlobal_Context, &KaxTagOfficialAudioFileURL::ClassInfos);
const EbmlSemanticContext KaxTagOfficialAudioSourceURL_Context = EbmlSemanticContext(0, NULL, &KaxTagAudioSpecific_Context, *GetKaxGlobal_Context, &KaxTagOfficialAudioSourceURL::ClassInfos);
const EbmlSemanticContext KaxTagCaptureDPI_Context = EbmlSemanticContext(0, NULL, &KaxTagImageSpecific_Context, *GetKaxGlobal_Context, &KaxTagCaptureDPI::ClassInfos);
const EbmlSemanticContext KaxTagCaptureLightness_Context = EbmlSemanticContext(0, NULL, &KaxTagImageSpecific_Context, *GetKaxGlobal_Context, &KaxTagCaptureLightness::ClassInfos);
const EbmlSemanticContext KaxTagCapturePaletteSetting_Context = EbmlSemanticContext(0, NULL, &KaxTagImageSpecific_Context, *GetKaxGlobal_Context, &KaxTagCapturePaletteSetting::ClassInfos);
const EbmlSemanticContext KaxTagCaptureSharpness_Context = EbmlSemanticContext(0, NULL, &KaxTagImageSpecific_Context, *GetKaxGlobal_Context, &KaxTagCaptureSharpness::ClassInfos);
const EbmlSemanticContext KaxTagCropped_Context = EbmlSemanticContext(0, NULL, &KaxTagImageSpecific_Context, *GetKaxGlobal_Context, &KaxTagCropped::ClassInfos);
const EbmlSemanticContext KaxTagOriginalDimensions_Context = EbmlSemanticContext(0, NULL, &KaxTagImageSpecific_Context, *GetKaxGlobal_Context, &KaxTagOriginalDimensions::ClassInfos);
const EbmlSemanticContext KaxTagSimple_Context = EbmlSemanticContext(countof(KaxTagSimple_ContextList), KaxTagSimple_ContextList, &KaxTag_Context, *GetKaxGlobal_Context, &KaxTagSimple::ClassInfos);
const EbmlSemanticContext KaxTagName_Context = EbmlSemanticContext(0, NULL, &KaxTagSimple_Context, *GetKaxGlobal_Context, &KaxTagName::ClassInfos);
const EbmlSemanticContext KaxTagLangue_Context = EbmlSemanticContext(0, NULL, &KaxTagSimple_Context, *GetKaxGlobal_Context, &KaxTagLangue::ClassInfos);
const EbmlSemanticContext KaxTagDefault_Context = EbmlSemanticContext(0, NULL, &KaxTagSimple_Context, *GetKaxGlobal_Context, &KaxTagDefault::ClassInfos);
const EbmlSemanticContext KaxTagString_Context = EbmlSemanticContext(0, NULL, &KaxTagSimple_Context, *GetKaxGlobal_Context, &KaxTagString::ClassInfos);
const EbmlSemanticContext KaxTagBinary_Context = EbmlSemanticContext(0, NULL, &KaxTagSimple_Context, *GetKaxGlobal_Context, &KaxTagBinary::ClassInfos);
EbmlId KaxTag_TheId (0x7373, 2);
EbmlId KaxTagTargets_TheId (0x63C0, 2);
EbmlId KaxTagGeneral_TheId (0x67C9, 2);
EbmlId KaxTagGenres_TheId (0x6583, 2);
EbmlId KaxTagAudioSpecific_TheId (0x41C5, 2);
EbmlId KaxTagImageSpecific_TheId (0x4990, 2);
EbmlId KaxTagBibliography_TheId (0x4488, 2);
EbmlId KaxTagEncoder_TheId (0x4431, 2);
EbmlId KaxTagEncodeSettings_TheId (0x6526, 2);
EbmlId KaxTagLanguage_TheId (0x22B59F, 3);
EbmlId KaxTagLength_TheId (0x5243, 2);
EbmlId KaxTagPlaylistDelay_TheId (0x72CC, 2);
EbmlId KaxTagRating_TheId (0x52BC, 2);
EbmlId KaxTagSubject_TheId (0x49C1, 2);
EbmlId KaxTagUnsynchronisedText_TheId (0x874B, 2);
EbmlId KaxTagUserDefinedURL_TheId (0x434A, 2);
EbmlId KaxTagTargetTypeValue_TheId (0x68CA, 2);
EbmlId KaxTagTargetType_TheId (0x63CA, 2);
EbmlId KaxTagTrackUID_TheId (0x63C5, 2);
EbmlId KaxTagEditionUID_TheId (0x63C9, 2);
EbmlId KaxTagChapterUID_TheId (0x63C4, 2);
EbmlId KaxTagAttachmentUID_TheId (0x63C6, 2);
EbmlId KaxTagAudioGenre_TheId (0x65C2, 2);
EbmlId KaxTagVideoGenre_TheId (0x65A1, 2);
EbmlId KaxTagSubGenre_TheId (0x65AC, 2);
EbmlId KaxTagAudioEncryption_TheId (0x41B4, 2);
EbmlId KaxTagAudioGain_TheId (0x4199, 2);
EbmlId KaxTagAudioPeak_TheId (0x4189, 2);
EbmlId KaxTagBPM_TheId (0x41A1, 2);
EbmlId KaxTagDiscTrack_TheId (0x41B6, 2);
EbmlId KaxTagSetPart_TheId (0x416E, 2);
EbmlId KaxTagEqualisation_TheId (0x41B1, 2);
EbmlId KaxTagInitialKey_TheId (0x413A, 2);
EbmlId KaxTagOfficialAudioFileURL_TheId (0x4133, 2);
EbmlId KaxTagOfficialAudioSourceURL_TheId(0x413E, 2);
EbmlId KaxTagArchivalLocation_TheId (0x45A4, 2);
EbmlId KaxTagFile_TheId (0x454E, 2);
EbmlId KaxTagKeywords_TheId (0x458C, 2);
EbmlId KaxTagMood_TheId (0x45AE, 2);
EbmlId KaxTagRecordLocation_TheId (0x457E, 2);
EbmlId KaxTagSource_TheId (0x458A, 2);
EbmlId KaxTagSourceForm_TheId (0x45B5, 2);
EbmlId KaxTagProduct_TheId (0x45E3, 2);
EbmlId KaxTagOriginalMediaType_TheId (0x45A7, 2);
EbmlId KaxTagPlayCounter_TheId (0x4566, 2);
EbmlId KaxTagPopularimeter_TheId (0x4532, 2);
EbmlId KaxTagCaptureDPI_TheId (0x49C7, 2);
EbmlId KaxTagCaptureLightness_TheId (0x49E1, 2);
EbmlId KaxTagCapturePaletteSetting_TheId (0x4934, 2);
EbmlId KaxTagCaptureSharpness_TheId (0x4922, 2);
EbmlId KaxTagCropped_TheId (0x4987, 2);
EbmlId KaxTagOriginalDimensions_TheId (0x4933, 2);
EbmlId KaxTagSimple_TheId (0x67C8, 2);
EbmlId KaxTagName_TheId (0x45A3, 2);
EbmlId KaxTagLangue_TheId (0x447A, 2);
EbmlId KaxTagDefault_TheId (0x4484, 2);
EbmlId KaxTagString_TheId (0x4487, 2);
EbmlId KaxTagBinary_TheId (0x4485, 2);
const EbmlCallbacks KaxTag::ClassInfos(KaxTag::Create, KaxTag_TheId, "Tag", KaxTag_Context);
const EbmlCallbacks KaxTagTargets::ClassInfos(KaxTagTargets::Create, KaxTagTargets_TheId, "TagTargets", KaxTagTargets_Context);
const EbmlCallbacks KaxTagGeneral::ClassInfos(KaxTagGeneral::Create, KaxTagGeneral_TheId, "TagGeneral", KaxTagGeneral_Context);
const EbmlCallbacks KaxTagGenres::ClassInfos(KaxTagGenres::Create, KaxTagGenres_TheId, "TagGenres", KaxTagGenres_Context);
const EbmlCallbacks KaxTagAudioSpecific::ClassInfos(KaxTagAudioSpecific::Create, KaxTagAudioSpecific_TheId, "TagAudioSpecific", KaxTagAudioSpecific_Context);
const EbmlCallbacks KaxTagImageSpecific::ClassInfos(KaxTagImageSpecific::Create, KaxTagImageSpecific_TheId, "TagImageSpecific", KaxTagImageSpecific_Context);
const EbmlCallbacks KaxTagBibliography::ClassInfos(KaxTagBibliography::Create, KaxTagBibliography_TheId, "Bibliography", KaxTagBibliography_Context);
const EbmlCallbacks KaxTagCaptureDPI::ClassInfos(KaxTagCaptureDPI::Create, KaxTagCaptureDPI_TheId, "CaptureDPI", KaxTagCaptureDPI_Context);
const EbmlCallbacks KaxTagCaptureLightness::ClassInfos(KaxTagCaptureLightness::Create, KaxTagCaptureLightness_TheId, "CaptureLightness", KaxTagCaptureLightness_Context);
const EbmlCallbacks KaxTagCapturePaletteSetting::ClassInfos(KaxTagCapturePaletteSetting::Create, KaxTagCapturePaletteSetting_TheId, "CapturePaletteSetting", KaxTagCapturePaletteSetting_Context);
const EbmlCallbacks KaxTagCaptureSharpness::ClassInfos(KaxTagCaptureSharpness::Create, KaxTagCaptureSharpness_TheId, "CaptureSharpness", KaxTagCaptureSharpness_Context);
const EbmlCallbacks KaxTagCropped::ClassInfos(KaxTagCropped::Create, KaxTagCropped_TheId, "Cropped", KaxTagCropped_Context);
const EbmlCallbacks KaxTagEncoder::ClassInfos(KaxTagEncoder::Create, KaxTagEncoder_TheId, "Encoder", KaxTagEncoder_Context);
const EbmlCallbacks KaxTagEncodeSettings::ClassInfos(KaxTagEncodeSettings::Create, KaxTagEncodeSettings_TheId, "EncodeSettings", KaxTagEncodeSettings_Context);
const EbmlCallbacks KaxTagLanguage::ClassInfos(KaxTagLanguage::Create, KaxTagLanguage_TheId, "Language", KaxTagLanguage_Context);
const EbmlCallbacks KaxTagLength::ClassInfos(KaxTagLength::Create, KaxTagLength_TheId, "Length", KaxTagLength_Context);
const EbmlCallbacks KaxTagOriginalDimensions::ClassInfos(KaxTagOriginalDimensions::Create, KaxTagOriginalDimensions_TheId, "OriginalDimensions", KaxTagOriginalDimensions_Context);
const EbmlCallbacks KaxTagPlaylistDelay::ClassInfos(KaxTagPlaylistDelay::Create, KaxTagPlaylistDelay_TheId, "PlaylistDelay", KaxTagPlaylistDelay_Context);
const EbmlCallbacks KaxTagRating::ClassInfos(KaxTagRating::Create, KaxTagRating_TheId, "Rating", KaxTagRating_Context);
const EbmlCallbacks KaxTagSubject::ClassInfos(KaxTagSubject::Create, KaxTagSubject_TheId, "Subject", KaxTagSubject_Context);
const EbmlCallbacks KaxTagUnsynchronisedText::ClassInfos(KaxTagUnsynchronisedText::Create, KaxTagUnsynchronisedText_TheId, "UnsynchronisedText", KaxTagUnsynchronisedText_Context);
const EbmlCallbacks KaxTagUserDefinedURL::ClassInfos(KaxTagUserDefinedURL::Create, KaxTagUserDefinedURL_TheId, "UserDefinedURL", KaxTagUserDefinedURL_Context);
const EbmlCallbacks KaxTagTargetTypeValue::ClassInfos(KaxTagTargetTypeValue::Create, KaxTagTargetTypeValue_TheId, "TagTargetTypeValue", KaxTagTargetTypeValue_Context);
const EbmlCallbacks KaxTagTargetType::ClassInfos(KaxTagTargetType::Create, KaxTagTargetType_TheId, "TagTargetType", KaxTagTargetType_Context);
const EbmlCallbacks KaxTagTrackUID::ClassInfos(KaxTagTrackUID::Create, KaxTagTrackUID_TheId, "TagTrackUID", KaxTagTrackUID_Context);
const EbmlCallbacks KaxTagEditionUID::ClassInfos(KaxTagEditionUID::Create, KaxTagEditionUID_TheId, "TagEditionUID", KaxTagEditionUID_Context);
const EbmlCallbacks KaxTagChapterUID::ClassInfos(KaxTagChapterUID::Create, KaxTagChapterUID_TheId, "TagChapterUID", KaxTagChapterUID_Context);
const EbmlCallbacks KaxTagAttachmentUID::ClassInfos(KaxTagAttachmentUID::Create, KaxTagAttachmentUID_TheId, "TagAttachmentUID", KaxTagAttachmentUID_Context);
const EbmlCallbacks KaxTagAudioGenre::ClassInfos(KaxTagAudioGenre::Create, KaxTagAudioGenre_TheId, "AudioGenre", KaxTagAudioGenre_Context);
const EbmlCallbacks KaxTagVideoGenre::ClassInfos(KaxTagVideoGenre::Create, KaxTagVideoGenre_TheId, "VideoGenre", KaxTagVideoGenre_Context);
const EbmlCallbacks KaxTagSubGenre::ClassInfos(KaxTagSubGenre::Create, KaxTagSubGenre_TheId, "SubGenre", KaxTagSubGenre_Context);
const EbmlCallbacks KaxTagAudioEncryption::ClassInfos(KaxTagAudioEncryption::Create, KaxTagAudioEncryption_TheId, "AudioEncryption", KaxTagAudioEncryption_Context);
const EbmlCallbacks KaxTagAudioGain::ClassInfos(KaxTagAudioGain::Create, KaxTagAudioGain_TheId, "AudioGain", KaxTagAudioGain_Context);
const EbmlCallbacks KaxTagAudioPeak::ClassInfos(KaxTagAudioPeak::Create, KaxTagAudioPeak_TheId, "AudioPeak", KaxTagAudioPeak_Context);
const EbmlCallbacks KaxTagBPM::ClassInfos(KaxTagBPM::Create, KaxTagBPM_TheId, "BPM", KaxTagBPM_Context);
const EbmlCallbacks KaxTagDiscTrack::ClassInfos(KaxTagDiscTrack::Create, KaxTagDiscTrack_TheId, "DiscTrack", KaxTagDiscTrack_Context);
const EbmlCallbacks KaxTagSetPart::ClassInfos(KaxTagSetPart::Create, KaxTagSetPart_TheId, "SetPart", KaxTagSetPart_Context);
const EbmlCallbacks KaxTagEqualisation::ClassInfos(KaxTagEqualisation::Create, KaxTagEqualisation_TheId, "Equalisation", KaxTagEqualisation_Context);
const EbmlCallbacks KaxTagInitialKey::ClassInfos(KaxTagInitialKey::Create, KaxTagInitialKey_TheId, "InitialKey", KaxTagInitialKey_Context);
const EbmlCallbacks KaxTagOfficialAudioFileURL::ClassInfos(KaxTagOfficialAudioFileURL::Create, KaxTagOfficialAudioFileURL_TheId, "OfficialAudioFileURL", KaxTagOfficialAudioFileURL_Context);
const EbmlCallbacks KaxTagOfficialAudioSourceURL::ClassInfos(KaxTagOfficialAudioSourceURL::Create, KaxTagOfficialAudioSourceURL_TheId, "AudioSourceURL", KaxTagOfficialAudioSourceURL_Context);
const EbmlCallbacks KaxTagArchivalLocation::ClassInfos(KaxTagArchivalLocation::Create, KaxTagArchivalLocation_TheId, "ArchivalLocation", KaxTagArchivalLocation_Context);
const EbmlCallbacks KaxTagFile::ClassInfos(KaxTagFile::Create, KaxTagFile_TheId, "File", KaxTagFile_Context);
const EbmlCallbacks KaxTagKeywords::ClassInfos(KaxTagKeywords::Create, KaxTagKeywords_TheId, "Keywords", KaxTagKeywords_Context);
const EbmlCallbacks KaxTagMood::ClassInfos(KaxTagMood::Create, KaxTagMood_TheId, "Mood", KaxTagMood_Context);
const EbmlCallbacks KaxTagRecordLocation::ClassInfos(KaxTagRecordLocation::Create, KaxTagRecordLocation_TheId, "RecordLocation", KaxTagRecordLocation_Context);
const EbmlCallbacks KaxTagSource::ClassInfos(KaxTagSource::Create, KaxTagSource_TheId, "Source", KaxTagSource_Context);
const EbmlCallbacks KaxTagSourceForm::ClassInfos(KaxTagSourceForm::Create, KaxTagSourceForm_TheId, "SourceForm", KaxTagSourceForm_Context);
const EbmlCallbacks KaxTagProduct::ClassInfos(KaxTagProduct::Create, KaxTagProduct_TheId, "Product", KaxTagProduct_Context);
const EbmlCallbacks KaxTagOriginalMediaType::ClassInfos(KaxTagOriginalMediaType::Create, KaxTagOriginalMediaType_TheId, "OriginalMediaType", KaxTagOriginalMediaType_Context);
const EbmlCallbacks KaxTagPlayCounter::ClassInfos(KaxTagPlayCounter::Create, KaxTagPlayCounter_TheId, "PlayCounter", KaxTagPlayCounter_Context);
const EbmlCallbacks KaxTagPopularimeter::ClassInfos(KaxTagPopularimeter::Create, KaxTagPopularimeter_TheId, "Popularimeter", KaxTagPopularimeter_Context);
const EbmlCallbacks KaxTagSimple::ClassInfos(KaxTagSimple::Create, KaxTagSimple_TheId, "TagSimple", KaxTagSimple_Context);
const EbmlCallbacks KaxTagName::ClassInfos(KaxTagName::Create, KaxTagName_TheId, "TagName", KaxTagName_Context);
const EbmlCallbacks KaxTagLangue::ClassInfos(KaxTagLangue::Create, KaxTagLangue_TheId, "TagLanguage", KaxTagLangue_Context);
const EbmlCallbacks KaxTagDefault::ClassInfos(KaxTagDefault::Create, KaxTagDefault_TheId, "TagDefault", KaxTagDefault_Context);
const EbmlCallbacks KaxTagString::ClassInfos(KaxTagString::Create, KaxTagString_TheId, "TagString", KaxTagString_Context);
const EbmlCallbacks KaxTagBinary::ClassInfos(KaxTagBinary::Create, KaxTagBinary_TheId, "TagBinary", KaxTagBinary_Context);
KaxTag::KaxTag()
:EbmlMaster(KaxTag_Context)
{}
KaxTagTargets::KaxTagTargets()
:EbmlMaster(KaxTagTargets_Context)
{}
KaxTagGeneral::KaxTagGeneral()
:EbmlMaster(KaxTagGeneral_Context)
{}
KaxTagGenres::KaxTagGenres()
:EbmlMaster(KaxTagGenres_Context)
{}
KaxTagAudioSpecific::KaxTagAudioSpecific()
:EbmlMaster(KaxTagAudioSpecific_Context)
{}
KaxTagImageSpecific::KaxTagImageSpecific()
:EbmlMaster(KaxTagImageSpecific_Context)
{}
KaxTagSimple::KaxTagSimple()
:EbmlMaster(KaxTagSimple_Context)
{}
END_LIBMATROSKA_NAMESPACE

404
src/KaxTagMulti.cpp Normal file
View File

@ -0,0 +1,404 @@
/****************************************************************************
** libmatroska : parse Matroska files, see http://www.matroska.org/
**
** <file/class description>
**
** Copyright (C) 2002-2004 Steve Lhomme. All rights reserved.
**
** This file is part of libmatroska.
**
** This library is free software; you can redistribute it and/or
** modify it under the terms of the GNU Lesser General Public
** License as published by the Free Software Foundation; either
** version 2.1 of the License, or (at your option) any later version.
**
** This library is distributed in the hope that it will be useful,
** but WITHOUT ANY WARRANTY; without even the implied warranty of
** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
** Lesser General Public License for more details.
**
** You should have received a copy of the GNU Lesser General Public
** License along with this library; if not, write to the Free Software
** Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
**
** See http://www.matroska.org/license/lgpl/ for LGPL licensing information.**
** Contact license@matroska.org if any conditions of this licensing are
** not clear to you.
**
**********************************************************************/
/*!
\file
\version \$Id: KaxTagMulti.cpp 640 2004-07-09 21:05:36Z mosu $
\author Jory Stone <jcsston @ toughguy.net>
\author Steve Lhomme <robux4 @ users.sf.net>
*/
#include "matroska/KaxTagMulti.h"
#include "matroska/KaxContexts.h"
using namespace LIBEBML_NAMESPACE;
START_LIBMATROSKA_NAMESPACE
EbmlSemantic KaxTagMultiGlobal_ContextList[1] =
{
EbmlSemantic(false, false, KaxTagMultiComment::ClassInfos),
};
EbmlSemantic KaxTagMultiComment_ContextList[3] =
{
EbmlSemantic(false, true, KaxTagMultiCommentName::ClassInfos),
EbmlSemantic(false, true, KaxTagMultiCommentComments::ClassInfos),
EbmlSemantic(false, true, KaxTagMultiCommentLanguage::ClassInfos),
};
EbmlSemantic KaxTagMultiCommercial_ContextList[1] =
{
EbmlSemantic(true, false, KaxTagCommercial::ClassInfos),
};
EbmlSemantic KaxTagCommercial_ContextList[5] =
{
EbmlSemantic(true, true, KaxTagMultiCommercialType::ClassInfos),
EbmlSemantic(false, true, KaxTagMultiCommercialAddress::ClassInfos),
EbmlSemantic(false, false, KaxTagMultiCommercialURL::ClassInfos),
EbmlSemantic(false, false, KaxTagMultiCommercialEmail::ClassInfos),
EbmlSemantic(false, false, KaxTagMultiPrice::ClassInfos),
};
EbmlSemantic KaxTagMultiPrice_ContextList[3] =
{
EbmlSemantic(false, true, KaxTagMultiPriceCurrency::ClassInfos),
EbmlSemantic(false, true, KaxTagMultiPriceAmount::ClassInfos),
EbmlSemantic(false, true, KaxTagMultiPricePriceDate::ClassInfos),
};
EbmlSemantic KaxTagMultiDate_ContextList[1] =
{
EbmlSemantic(true, false, KaxTagDate::ClassInfos),
};
EbmlSemantic KaxTagDate_ContextList[3] =
{
EbmlSemantic(true, true, KaxTagMultiDateType::ClassInfos),
EbmlSemantic(false, true, KaxTagMultiDateDateBegin::ClassInfos),
EbmlSemantic(false, true, KaxTagMultiDateDateEnd::ClassInfos),
};
EbmlSemantic KaxTagMultiEntity_ContextList[1] =
{
EbmlSemantic(true, false, KaxTagEntity::ClassInfos),
};
EbmlSemantic KaxTagEntity_ContextList[5] =
{
EbmlSemantic(true, true, KaxTagMultiEntityType::ClassInfos),
EbmlSemantic(false, true, KaxTagMultiEntityName::ClassInfos),
EbmlSemantic(false, false, KaxTagMultiEntityURL::ClassInfos),
EbmlSemantic(false, false, KaxTagMultiEntityEmail::ClassInfos),
EbmlSemantic(false, true, KaxTagMultiEntityAddress::ClassInfos),
};
EbmlSemantic KaxTagMultiIdentifier_ContextList[1] =
{
EbmlSemantic(true, false, KaxTagIdentifier::ClassInfos),
};
EbmlSemantic KaxTagIdentifier_ContextList[3] =
{
EbmlSemantic(true, true, KaxTagMultiIdentifierType::ClassInfos),
EbmlSemantic(false, true, KaxTagMultiIdentifierBinary::ClassInfos),
EbmlSemantic(false, true, KaxTagMultiIdentifierString::ClassInfos),
};
EbmlSemantic KaxTagMultiLegal_ContextList[1] =
{
EbmlSemantic(true, false, KaxTagLegal::ClassInfos),
};
EbmlSemantic KaxTagLegal_ContextList[4] =
{
EbmlSemantic(true, true, KaxTagMultiLegalType::ClassInfos),
EbmlSemantic(false, true, KaxTagMultiLegalContent::ClassInfos),
EbmlSemantic(false, false, KaxTagMultiLegalURL::ClassInfos),
EbmlSemantic(false, true, KaxTagMultiLegalAddress::ClassInfos),
};
EbmlSemantic KaxTagMultiTitle_ContextList[1] =
{
EbmlSemantic(true, false, KaxTagTitle::ClassInfos),
};
EbmlSemantic KaxTagTitle_ContextList[8] =
{
EbmlSemantic(true, true, KaxTagMultiTitleType::ClassInfos),
EbmlSemantic(false, true, KaxTagMultiTitleName::ClassInfos),
EbmlSemantic(false, true, KaxTagMultiTitleSubTitle::ClassInfos),
EbmlSemantic(false, true, KaxTagMultiTitleEdition::ClassInfos),
EbmlSemantic(false, true, KaxTagMultiTitleAddress::ClassInfos),
EbmlSemantic(false, false, KaxTagMultiTitleURL::ClassInfos),
EbmlSemantic(false, false, KaxTagMultiTitleEmail::ClassInfos),
EbmlSemantic(false, true, KaxTagMultiTitleLanguage::ClassInfos),
};
EbmlSemantic KaxTagMultiAttachment_ContextList[1] =
{
EbmlSemantic(true, false, KaxTagAttachment::ClassInfos),
};
EbmlSemantic KaxTagAttachment_ContextList[1] =
{
EbmlSemantic(false, true, KaxTagAttachmentID::ClassInfos),
};
const EbmlSemanticContext KaxTagMultiGlobal_Context = EbmlSemanticContext(countof(KaxTagMultiGlobal_ContextList), KaxTagMultiGlobal_ContextList, NULL, *GetKaxGlobal_Context, NULL);
const EbmlSemanticContext KaxTagMultiComment_Context = EbmlSemanticContext(countof(KaxTagMultiComment_ContextList), KaxTagMultiComment_ContextList, &KaxTag_Context, *GetKaxGlobal_Context, &KaxTagMultiComment::ClassInfos);
const EbmlSemanticContext KaxTagMultiCommentName_Context = EbmlSemanticContext(0, NULL, &KaxTagMultiComment_Context, *GetKaxGlobal_Context, &KaxTagMultiCommentName::ClassInfos);
const EbmlSemanticContext KaxTagMultiCommentComments_Context = EbmlSemanticContext(0, NULL, &KaxTagMultiComment_Context, *GetKaxGlobal_Context, &KaxTagMultiCommentComments::ClassInfos);
const EbmlSemanticContext KaxTagMultiCommentLanguage_Context = EbmlSemanticContext(0, NULL, &KaxTagMultiComment_Context, *GetKaxGlobal_Context, &KaxTagMultiCommentLanguage::ClassInfos);
const EbmlSemanticContext KaxTagMultiCommercial_Context = EbmlSemanticContext(countof(KaxTagMultiCommercial_ContextList), KaxTagMultiCommercial_ContextList, &KaxTag_Context, *GetKaxTagsGlobal_Context, &KaxTagMultiCommercial::ClassInfos);
const EbmlSemanticContext KaxTagCommercial_Context = EbmlSemanticContext(countof(KaxTagCommercial_ContextList), KaxTagCommercial_ContextList, &KaxTagMultiCommercial_Context, *GetKaxTagsGlobal_Context, &KaxTagCommercial::ClassInfos);
const EbmlSemanticContext KaxTagMultiCommercialType_Context = EbmlSemanticContext(0, NULL, &KaxTagCommercial_Context, *GetKaxGlobal_Context, &KaxTagMultiCommercialType::ClassInfos);
const EbmlSemanticContext KaxTagMultiCommercialAddress_Context = EbmlSemanticContext(0, NULL, &KaxTagCommercial_Context, *GetKaxGlobal_Context, &KaxTagMultiCommercialAddress::ClassInfos);
const EbmlSemanticContext KaxTagMultiCommercialURL_Context = EbmlSemanticContext(0, NULL, &KaxTagCommercial_Context, *GetKaxGlobal_Context, &KaxTagMultiCommercialURL::ClassInfos);
const EbmlSemanticContext KaxTagMultiCommercialEmail_Context = EbmlSemanticContext(0, NULL, &KaxTagCommercial_Context, *GetKaxGlobal_Context, &KaxTagMultiCommercialEmail::ClassInfos);
const EbmlSemanticContext KaxTagMultiPrice_Context = EbmlSemanticContext(countof(KaxTagMultiPrice_ContextList), KaxTagMultiPrice_ContextList, &KaxTagCommercial_Context, *GetKaxTagsGlobal_Context, &KaxTagMultiPrice::ClassInfos);
const EbmlSemanticContext KaxTagMultiPriceCurrency_Context = EbmlSemanticContext(0, NULL, &KaxTagMultiPrice_Context, *GetKaxGlobal_Context, &KaxTagMultiPriceCurrency::ClassInfos);
const EbmlSemanticContext KaxTagMultiPriceAmount_Context = EbmlSemanticContext(0, NULL, &KaxTagMultiPrice_Context, *GetKaxGlobal_Context, &KaxTagMultiPriceAmount::ClassInfos);
const EbmlSemanticContext KaxTagMultiPricePriceDate_Context = EbmlSemanticContext(0, NULL, &KaxTagMultiPrice_Context, *GetKaxGlobal_Context, &KaxTagMultiPricePriceDate::ClassInfos);
const EbmlSemanticContext KaxTagMultiDate_Context = EbmlSemanticContext(countof(KaxTagMultiDate_ContextList), KaxTagMultiDate_ContextList, &KaxTag_Context, *GetKaxTagsGlobal_Context, &KaxTagMultiDate::ClassInfos);
const EbmlSemanticContext KaxTagDate_Context = EbmlSemanticContext(countof(KaxTagDate_ContextList), KaxTagDate_ContextList, &KaxTagMultiDate_Context, *GetKaxTagsGlobal_Context, &KaxTagDate::ClassInfos);
const EbmlSemanticContext KaxTagMultiDateType_Context = EbmlSemanticContext(0, NULL, &KaxTagDate_Context, *GetKaxGlobal_Context, &KaxTagMultiDateType::ClassInfos);
const EbmlSemanticContext KaxTagMultiDateDateBegin_Context = EbmlSemanticContext(0, NULL, &KaxTagDate_Context, *GetKaxGlobal_Context, &KaxTagMultiDateDateBegin::ClassInfos);
const EbmlSemanticContext KaxTagMultiDateDateEnd_Context = EbmlSemanticContext(0, NULL, &KaxTagDate_Context, *GetKaxGlobal_Context, &KaxTagMultiDateDateEnd::ClassInfos);
const EbmlSemanticContext KaxTagMultiEntity_Context = EbmlSemanticContext(countof(KaxTagMultiEntity_ContextList), KaxTagMultiEntity_ContextList, &KaxTag_Context, *GetKaxTagsGlobal_Context, &KaxTagMultiEntity::ClassInfos);
const EbmlSemanticContext KaxTagEntity_Context = EbmlSemanticContext(countof(KaxTagEntity_ContextList), KaxTagEntity_ContextList, &KaxTagMultiEntity_Context, *GetKaxTagsGlobal_Context, &KaxTagEntity::ClassInfos);
const EbmlSemanticContext KaxTagMultiEntityType_Context = EbmlSemanticContext(0, NULL, &KaxTagEntity_Context, *GetKaxGlobal_Context, &KaxTagMultiEntityType::ClassInfos);
const EbmlSemanticContext KaxTagMultiEntityName_Context = EbmlSemanticContext(0, NULL, &KaxTagEntity_Context, *GetKaxGlobal_Context, &KaxTagMultiEntityName::ClassInfos);
const EbmlSemanticContext KaxTagMultiEntityURL_Context = EbmlSemanticContext(0, NULL, &KaxTagEntity_Context, *GetKaxGlobal_Context, &KaxTagMultiEntityURL::ClassInfos);
const EbmlSemanticContext KaxTagMultiEntityEmail_Context = EbmlSemanticContext(0, NULL, &KaxTagEntity_Context, *GetKaxGlobal_Context, &KaxTagMultiEntityEmail::ClassInfos);
const EbmlSemanticContext KaxTagMultiEntityAddress_Context = EbmlSemanticContext(0, NULL, &KaxTagEntity_Context, *GetKaxGlobal_Context, &KaxTagMultiEntityAddress::ClassInfos);
const EbmlSemanticContext KaxTagMultiIdentifier_Context = EbmlSemanticContext(countof(KaxTagMultiIdentifier_ContextList), KaxTagMultiIdentifier_ContextList, &KaxTag_Context, *GetKaxTagsGlobal_Context, &KaxTagMultiIdentifier::ClassInfos);
const EbmlSemanticContext KaxTagIdentifier_Context = EbmlSemanticContext(countof(KaxTagIdentifier_ContextList), KaxTagIdentifier_ContextList, &KaxTagMultiIdentifier_Context, *GetKaxTagsGlobal_Context, &KaxTagIdentifier::ClassInfos);
const EbmlSemanticContext KaxTagMultiIdentifierType_Context = EbmlSemanticContext(0, NULL, &KaxTagIdentifier_Context, *GetKaxGlobal_Context, &KaxTagMultiIdentifierType::ClassInfos);
const EbmlSemanticContext KaxTagMultiIdentifierBinary_Context = EbmlSemanticContext(0, NULL, &KaxTagIdentifier_Context, *GetKaxGlobal_Context, &KaxTagMultiIdentifierBinary::ClassInfos);
const EbmlSemanticContext KaxTagMultiIdentifierString_Context = EbmlSemanticContext(0, NULL, &KaxTagIdentifier_Context, *GetKaxGlobal_Context, &KaxTagMultiIdentifierString::ClassInfos);
const EbmlSemanticContext KaxTagMultiLegal_Context = EbmlSemanticContext(countof(KaxTagMultiLegal_ContextList), KaxTagMultiLegal_ContextList, &KaxTag_Context, *GetKaxTagsGlobal_Context, &KaxTagMultiLegal::ClassInfos);
const EbmlSemanticContext KaxTagLegal_Context = EbmlSemanticContext(countof(KaxTagLegal_ContextList), KaxTagLegal_ContextList, &KaxTagMultiLegal_Context, *GetKaxTagsGlobal_Context, &KaxTagLegal::ClassInfos);
const EbmlSemanticContext KaxTagMultiLegalType_Context = EbmlSemanticContext(0, NULL, &KaxTagLegal_Context, *GetKaxGlobal_Context, &KaxTagMultiLegalType::ClassInfos);
const EbmlSemanticContext KaxTagMultiLegalContent_Context = EbmlSemanticContext(0, NULL, &KaxTagLegal_Context, *GetKaxGlobal_Context, &KaxTagMultiLegalContent::ClassInfos);
const EbmlSemanticContext KaxTagMultiLegalURL_Context = EbmlSemanticContext(0, NULL, &KaxTagLegal_Context, *GetKaxGlobal_Context, &KaxTagMultiLegalURL::ClassInfos);
const EbmlSemanticContext KaxTagMultiLegalAddress_Context = EbmlSemanticContext(0, NULL, &KaxTagLegal_Context, *GetKaxGlobal_Context, &KaxTagMultiLegalAddress::ClassInfos);
const EbmlSemanticContext KaxTagMultiTitle_Context = EbmlSemanticContext(countof(KaxTagMultiTitle_ContextList), KaxTagMultiTitle_ContextList, &KaxTag_Context, *GetKaxTagsGlobal_Context, &KaxTagMultiTitle::ClassInfos);
const EbmlSemanticContext KaxTagTitle_Context = EbmlSemanticContext(countof(KaxTagTitle_ContextList), KaxTagTitle_ContextList, &KaxTagMultiTitle_Context, *GetKaxTagsGlobal_Context, &KaxTagTitle::ClassInfos);
const EbmlSemanticContext KaxTagMultiTitleType_Context = EbmlSemanticContext(0, NULL, &KaxTagTitle_Context, *GetKaxGlobal_Context, &KaxTagMultiTitleType::ClassInfos);
const EbmlSemanticContext KaxTagMultiTitleName_Context = EbmlSemanticContext(0, NULL, &KaxTagTitle_Context, *GetKaxGlobal_Context, &KaxTagMultiTitleName::ClassInfos);
const EbmlSemanticContext KaxTagMultiTitleSubTitle_Context = EbmlSemanticContext(0, NULL, &KaxTagTitle_Context, *GetKaxGlobal_Context, &KaxTagMultiTitleSubTitle::ClassInfos);
const EbmlSemanticContext KaxTagMultiTitleEdition_Context = EbmlSemanticContext(0, NULL, &KaxTagTitle_Context, *GetKaxGlobal_Context, &KaxTagMultiTitleEdition::ClassInfos);
const EbmlSemanticContext KaxTagMultiTitleAddress_Context = EbmlSemanticContext(0, NULL, &KaxTagTitle_Context, *GetKaxGlobal_Context, &KaxTagMultiTitleAddress::ClassInfos);
const EbmlSemanticContext KaxTagMultiTitleURL_Context = EbmlSemanticContext(0, NULL, &KaxTagTitle_Context, *GetKaxGlobal_Context, &KaxTagMultiTitleURL::ClassInfos);
const EbmlSemanticContext KaxTagMultiTitleEmail_Context = EbmlSemanticContext(0, NULL, &KaxTagTitle_Context, *GetKaxGlobal_Context, &KaxTagMultiTitleEmail::ClassInfos);
const EbmlSemanticContext KaxTagMultiTitleLanguage_Context = EbmlSemanticContext(0, NULL, &KaxTagTitle_Context, *GetKaxGlobal_Context, &KaxTagMultiTitleLanguage::ClassInfos);
const EbmlSemanticContext KaxTagMultiAttachment_Context = EbmlSemanticContext(countof(KaxTagMultiAttachment_ContextList), KaxTagMultiAttachment_ContextList, &KaxTag_Context, *GetKaxTagsGlobal_Context, &KaxTagMultiAttachment::ClassInfos);
const EbmlSemanticContext KaxTagAttachment_Context = EbmlSemanticContext(countof(KaxTagAttachment_ContextList), KaxTagAttachment_ContextList, &KaxTagMultiAttachment_Context, *GetKaxTagsGlobal_Context, &KaxTagAttachment::ClassInfos);
const EbmlSemanticContext KaxTagAttachmentID_Context = EbmlSemanticContext(0, NULL, &KaxTagAttachment_Context, *GetKaxGlobal_Context, &KaxTagAttachmentID::ClassInfos);
//The Muti Elements
EbmlId KaxTagMultiComment_TheId (0x5B7B, 2);
EbmlId KaxTagMultiCommentName_TheId (0x5F7D, 2);
EbmlId KaxTagMultiCommentComments_TheId (0x5F7C, 2);
EbmlId KaxTagMultiCommentLanguage_TheId (0x22B59D, 3);
EbmlId KaxTagMultiCommercial_TheId (0x4DC7, 2);
EbmlId KaxTagCommercial_TheId (0x4EC7, 2);
EbmlId KaxTagMultiCommercialType_TheId (0x5BD7, 2);
EbmlId KaxTagMultiCommercialAddress_TheId (0x5BBB, 2);
EbmlId KaxTagMultiCommercialURL_TheId (0x5BDA, 2);
EbmlId KaxTagMultiCommercialEmail_TheId (0x5BC0, 2);
EbmlId KaxTagMultiPrice_TheId (0x5BC3, 2);
EbmlId KaxTagMultiPriceCurrency_TheId (0x5B6C, 2);
EbmlId KaxTagMultiPriceAmount_TheId (0x5B6E, 2);
EbmlId KaxTagMultiPricePriceDate_TheId (0x5B6F, 2);
EbmlId KaxTagMultiDate_TheId (0x4DC8, 2);
EbmlId KaxTagDate_TheId (0x4EC8, 2);
EbmlId KaxTagMultiDateType_TheId (0x5BD8, 2);
EbmlId KaxTagMultiDateDateBegin_TheId (0x4460, 2);
EbmlId KaxTagMultiDateDateEnd_TheId (0x4462, 2);
EbmlId KaxTagMultiEntity_TheId (0x4DC9, 2);
EbmlId KaxTagEntity_TheId (0x4EC9, 2);
EbmlId KaxTagMultiEntityType_TheId (0x5BD9, 2);
EbmlId KaxTagMultiEntityName_TheId (0x5BED, 2);
EbmlId KaxTagMultiEntityAddress_TheId (0x5BDC, 2);
EbmlId KaxTagMultiEntityURL_TheId (0x5BDB, 2);
EbmlId KaxTagMultiEntityEmail_TheId (0x5BC1, 2);
EbmlId KaxTagMultiIdentifier_TheId (0x4DC6, 2);
EbmlId KaxTagIdentifier_TheId (0x4EC6, 2);
EbmlId KaxTagMultiIdentifierType_TheId (0x5BAD, 2);
EbmlId KaxTagMultiIdentifierBinary_TheId (0x6B67, 2);
EbmlId KaxTagMultiIdentifierString_TheId (0x6B68, 2);
EbmlId KaxTagMultiLegal_TheId (0x4DC5, 2);
EbmlId KaxTagLegal_TheId (0x4EC5, 2);
EbmlId KaxTagMultiLegalType_TheId (0x5BBD, 2);
EbmlId KaxTagMultiLegalContent_TheId (0x5BB2, 2);
EbmlId KaxTagMultiLegalURL_TheId (0x5B34, 2);
EbmlId KaxTagMultiLegalAddress_TheId (0x5B9B, 2);
EbmlId KaxTagMultiTitle_TheId (0x4DC4, 2);
EbmlId KaxTagTitle_TheId (0x4EC4, 2);
EbmlId KaxTagMultiTitleType_TheId (0x5B7D, 2);
EbmlId KaxTagMultiTitleName_TheId (0x5BB9, 2);
EbmlId KaxTagMultiTitleSubTitle_TheId (0x5B5B, 2);
EbmlId KaxTagMultiTitleEdition_TheId (0x5BAE, 2);
EbmlId KaxTagMultiTitleAddress_TheId (0x5B33, 2);
EbmlId KaxTagMultiTitleURL_TheId (0x5BA9, 2);
EbmlId KaxTagMultiTitleEmail_TheId (0x5BC9, 2);
EbmlId KaxTagMultiTitleLanguage_TheId (0x22B59E, 3);
EbmlId KaxTagMultiAttachment_TheId (0x4DC3, 2);
EbmlId KaxTagAttachment_TheId (0x4EC3, 2);
EbmlId KaxTagAttachmentID_TheId (0x5BA0, 2);
const EbmlCallbacks KaxTagMultiComment::ClassInfos(KaxTagMultiComment::Create, KaxTagMultiComment_TheId, "MultiComment", KaxTagMultiComment_Context);
const EbmlCallbacks KaxTagMultiCommentName::ClassInfos(KaxTagMultiCommentName::Create, KaxTagMultiCommentName_TheId, "MultiCommentName", KaxTagMultiCommentName_Context);
const EbmlCallbacks KaxTagMultiCommentComments::ClassInfos(KaxTagMultiCommentComments::Create, KaxTagMultiCommentComments_TheId, "MultiCommentComments", KaxTagMultiCommentComments_Context);
const EbmlCallbacks KaxTagMultiCommentLanguage::ClassInfos(KaxTagMultiCommentLanguage::Create, KaxTagMultiCommentLanguage_TheId, "MultiCommentLanguage", KaxTagMultiCommentLanguage_Context);
const EbmlCallbacks KaxTagMultiCommercial::ClassInfos(KaxTagMultiCommercial::Create, KaxTagMultiCommercial_TheId, "MultiCommercial", KaxTagMultiCommercial_Context);
const EbmlCallbacks KaxTagCommercial::ClassInfos(KaxTagCommercial::Create, KaxTagCommercial_TheId, "Commercial", KaxTagCommercial_Context);
const EbmlCallbacks KaxTagMultiCommercialType::ClassInfos(KaxTagMultiCommercialType::Create, KaxTagMultiCommercialType_TheId, "MultiCommercialType", KaxTagMultiCommercialType_Context);
const EbmlCallbacks KaxTagMultiCommercialAddress::ClassInfos(KaxTagMultiCommercialAddress::Create, KaxTagMultiCommercialAddress_TheId, "MultiCommercialAddress", KaxTagMultiCommercialAddress_Context);
const EbmlCallbacks KaxTagMultiCommercialURL::ClassInfos(KaxTagMultiCommercialURL::Create, KaxTagMultiCommercialURL_TheId, "MultiCommercialURL", KaxTagMultiCommercialURL_Context);
const EbmlCallbacks KaxTagMultiCommercialEmail::ClassInfos(KaxTagMultiCommercialEmail::Create, KaxTagMultiCommercialEmail_TheId, "MultiCommercialEmail", KaxTagMultiCommercialEmail_Context);
const EbmlCallbacks KaxTagMultiPrice::ClassInfos(KaxTagMultiPrice::Create, KaxTagMultiPrice_TheId, "MultiPrice", KaxTagMultiPrice_Context);
const EbmlCallbacks KaxTagMultiPriceCurrency::ClassInfos(KaxTagMultiPriceCurrency::Create, KaxTagMultiPriceCurrency_TheId, "MultiPriceCurrency", KaxTagMultiPriceCurrency_Context);
const EbmlCallbacks KaxTagMultiPriceAmount::ClassInfos(KaxTagMultiPriceAmount::Create, KaxTagMultiPriceAmount_TheId, "MultiPriceAmount", KaxTagMultiPriceAmount_Context);
const EbmlCallbacks KaxTagMultiPricePriceDate::ClassInfos(KaxTagMultiPricePriceDate::Create, KaxTagMultiPricePriceDate_TheId, "MultiPricePriceDate", KaxTagMultiPricePriceDate_Context);
const EbmlCallbacks KaxTagMultiDate::ClassInfos(KaxTagMultiDate::Create, KaxTagMultiDate_TheId, "MultiDate", KaxTagMultiDate_Context);
const EbmlCallbacks KaxTagDate::ClassInfos(KaxTagDate::Create, KaxTagDate_TheId, "Date", KaxTagDate_Context);
const EbmlCallbacks KaxTagMultiDateType::ClassInfos(KaxTagMultiDateType::Create, KaxTagMultiDateType_TheId, "MultiDateType", KaxTagMultiDateType_Context);
const EbmlCallbacks KaxTagMultiDateDateBegin::ClassInfos(KaxTagMultiDateDateBegin::Create, KaxTagMultiDateDateBegin_TheId, "MultiDateDateBegin", KaxTagMultiDateDateBegin_Context);
const EbmlCallbacks KaxTagMultiDateDateEnd::ClassInfos(KaxTagMultiDateDateEnd::Create, KaxTagMultiDateDateEnd_TheId, "MultiDateDateEnd", KaxTagMultiDateDateEnd_Context);
const EbmlCallbacks KaxTagMultiEntity::ClassInfos(KaxTagMultiEntity::Create, KaxTagMultiEntity_TheId, "MultiEntity", KaxTagMultiEntity_Context);
const EbmlCallbacks KaxTagEntity::ClassInfos(KaxTagEntity::Create, KaxTagEntity_TheId, "Entity", KaxTagEntity_Context);
const EbmlCallbacks KaxTagMultiEntityType::ClassInfos(KaxTagMultiEntityType::Create, KaxTagMultiEntityType_TheId, "MultiEntityType", KaxTagMultiEntityType_Context);
const EbmlCallbacks KaxTagMultiEntityName::ClassInfos(KaxTagMultiEntityName::Create, KaxTagMultiEntityName_TheId, "MultiEntityName", KaxTagMultiEntityName_Context);
const EbmlCallbacks KaxTagMultiEntityURL::ClassInfos(KaxTagMultiEntityURL::Create, KaxTagMultiEntityURL_TheId, "MultiEntityURL", KaxTagMultiEntityURL_Context);
const EbmlCallbacks KaxTagMultiEntityEmail::ClassInfos(KaxTagMultiEntityEmail::Create, KaxTagMultiEntityEmail_TheId, "MultiEntityEmail", KaxTagMultiEntityEmail_Context);
const EbmlCallbacks KaxTagMultiEntityAddress::ClassInfos(KaxTagMultiEntityAddress::Create, KaxTagMultiEntityAddress_TheId, "MultiEntityAddress", KaxTagMultiEntityAddress_Context);
const EbmlCallbacks KaxTagMultiIdentifier::ClassInfos(KaxTagMultiIdentifier::Create, KaxTagMultiIdentifier_TheId, "MultiIdentifier", KaxTagMultiIdentifier_Context);
const EbmlCallbacks KaxTagIdentifier::ClassInfos(KaxTagIdentifier::Create, KaxTagIdentifier_TheId, "Identifier", KaxTagIdentifier_Context);
const EbmlCallbacks KaxTagMultiIdentifierType::ClassInfos(KaxTagMultiIdentifierType::Create, KaxTagMultiIdentifierType_TheId, "TagMultiIdentifierType", KaxTagMultiIdentifierType_Context);
const EbmlCallbacks KaxTagMultiIdentifierBinary::ClassInfos(KaxTagMultiIdentifierBinary::Create, KaxTagMultiIdentifierBinary_TheId, "MultiIdentifierBinary", KaxTagMultiIdentifierBinary_Context);
const EbmlCallbacks KaxTagMultiIdentifierString::ClassInfos(KaxTagMultiIdentifierString::Create, KaxTagMultiIdentifierString_TheId, "MultiIdentifierString", KaxTagMultiIdentifierString_Context);
const EbmlCallbacks KaxTagMultiLegal::ClassInfos(KaxTagMultiLegal::Create, KaxTagMultiLegal_TheId, "MultiLegal", KaxTagMultiLegal_Context);
const EbmlCallbacks KaxTagLegal::ClassInfos(KaxTagLegal::Create, KaxTagLegal_TheId, "Legal", KaxTagLegal_Context);
const EbmlCallbacks KaxTagMultiLegalType::ClassInfos(KaxTagMultiLegalType::Create, KaxTagMultiLegalType_TheId, "KaxTagMultiLegalType", KaxTagMultiLegalType_Context);
const EbmlCallbacks KaxTagMultiLegalContent::ClassInfos(KaxTagMultiLegalContent::Create, KaxTagMultiLegalContent_TheId, "TagMultiLegalContent", KaxTagMultiLegalContent_Context);
const EbmlCallbacks KaxTagMultiLegalURL::ClassInfos(KaxTagMultiLegalURL::Create, KaxTagMultiLegalURL_TheId, "KaxTagMultiLegalURL", KaxTagMultiLegalURL_Context);
const EbmlCallbacks KaxTagMultiLegalAddress::ClassInfos(KaxTagMultiLegalAddress::Create, KaxTagMultiLegalAddress_TheId, "KaxTagMultiLegalAddress", KaxTagMultiLegalAddress_Context);
const EbmlCallbacks KaxTagMultiTitle::ClassInfos(KaxTagMultiTitle::Create, KaxTagMultiTitle_TheId, "MultiEntity", KaxTagMultiTitle_Context);
const EbmlCallbacks KaxTagTitle::ClassInfos(KaxTagTitle::Create, KaxTagTitle_TheId, "Entity", KaxTagTitle_Context);
const EbmlCallbacks KaxTagMultiTitleType::ClassInfos(KaxTagMultiTitleType::Create, KaxTagMultiTitleType_TheId, "MultiTitleType", KaxTagMultiTitleType_Context);
const EbmlCallbacks KaxTagMultiTitleName::ClassInfos(KaxTagMultiTitleName::Create, KaxTagMultiTitleName_TheId, "MultiTitleName", KaxTagMultiTitleName_Context);
const EbmlCallbacks KaxTagMultiTitleSubTitle::ClassInfos(KaxTagMultiTitleSubTitle::Create, KaxTagMultiTitleSubTitle_TheId, "MultiTitleSubTitle", KaxTagMultiTitleSubTitle_Context);
const EbmlCallbacks KaxTagMultiTitleEdition::ClassInfos(KaxTagMultiTitleEdition::Create, KaxTagMultiTitleEdition_TheId, "MultiTitleEdition", KaxTagMultiTitleEdition_Context);
const EbmlCallbacks KaxTagMultiTitleAddress::ClassInfos(KaxTagMultiTitleAddress::Create, KaxTagMultiTitleAddress_TheId, "MultiTitleAddress", KaxTagMultiTitleAddress_Context);
const EbmlCallbacks KaxTagMultiTitleURL::ClassInfos(KaxTagMultiTitleURL::Create, KaxTagMultiTitleURL_TheId, "MultiTitleURL", KaxTagMultiTitleURL_Context);
const EbmlCallbacks KaxTagMultiTitleEmail::ClassInfos(KaxTagMultiTitleEmail::Create, KaxTagMultiTitleEmail_TheId, "MultiTitleEmail", KaxTagMultiTitleEmail_Context);
const EbmlCallbacks KaxTagMultiTitleLanguage::ClassInfos(KaxTagMultiTitleLanguage::Create, KaxTagMultiTitleLanguage_TheId, "MultiTitleLanguage", KaxTagMultiTitleLanguage_Context);
const EbmlCallbacks KaxTagMultiAttachment::ClassInfos(KaxTagMultiAttachment::Create, KaxTagMultiAttachment_TheId, "TagMultiAttachment", KaxTagMultiAttachment_Context);
const EbmlCallbacks KaxTagAttachment::ClassInfos(KaxTagAttachment::Create, KaxTagAttachment_TheId, "TagAttachment", KaxTagAttachment_Context);
const EbmlCallbacks KaxTagAttachmentID::ClassInfos(KaxTagAttachmentID::Create, KaxTagAttachmentID_TheId, "TagAttachmentID", KaxTagAttachmentID_Context);
KaxTagMultiComment::KaxTagMultiComment()
:EbmlMaster(KaxTagMultiComment_Context)
{}
KaxTagMultiCommercial::KaxTagMultiCommercial()
:EbmlMaster(KaxTagMultiCommercial_Context)
{}
KaxTagCommercial::KaxTagCommercial()
:EbmlMaster(KaxTagCommercial_Context)
{}
KaxTagMultiPrice::KaxTagMultiPrice()
:EbmlMaster(KaxTagMultiPrice_Context)
{}
KaxTagMultiDate::KaxTagMultiDate()
:EbmlMaster(KaxTagMultiDate_Context)
{}
KaxTagDate::KaxTagDate()
:EbmlMaster(KaxTagDate_Context)
{}
KaxTagMultiEntity::KaxTagMultiEntity()
:EbmlMaster(KaxTagMultiEntity_Context)
{}
KaxTagEntity::KaxTagEntity()
:EbmlMaster(KaxTagEntity_Context)
{}
KaxTagMultiLegal::KaxTagMultiLegal()
:EbmlMaster(KaxTagMultiLegal_Context)
{}
KaxTagLegal::KaxTagLegal()
:EbmlMaster(KaxTagLegal_Context)
{}
KaxTagMultiIdentifier::KaxTagMultiIdentifier()
:EbmlMaster(KaxTagMultiIdentifier_Context)
{}
KaxTagIdentifier::KaxTagIdentifier()
:EbmlMaster(KaxTagIdentifier_Context)
{}
KaxTagMultiTitle::KaxTagMultiTitle()
:EbmlMaster(KaxTagMultiTitle_Context)
{}
KaxTagTitle::KaxTagTitle()
:EbmlMaster(KaxTagTitle_Context)
{}
KaxTagMultiAttachment::KaxTagMultiAttachment()
:EbmlMaster(KaxTagMultiAttachment_Context)
{}
KaxTagAttachment::KaxTagAttachment()
:EbmlMaster(KaxTagAttachment_Context)
{}
const EbmlSemanticContext & GetKaxTagsGlobal_Context()
{
return KaxTagMultiGlobal_Context;
}
END_LIBMATROSKA_NAMESPACE

60
src/KaxTags.cpp Normal file
View File

@ -0,0 +1,60 @@
/****************************************************************************
** libmatroska : parse Matroska files, see http://www.matroska.org/
**
** <file/class description>
**
** Copyright (C) 2002-2004 Steve Lhomme. All rights reserved.
**
** This file is part of libmatroska.
**
** This library is free software; you can redistribute it and/or
** modify it under the terms of the GNU Lesser General Public
** License as published by the Free Software Foundation; either
** version 2.1 of the License, or (at your option) any later version.
**
** This library is distributed in the hope that it will be useful,
** but WITHOUT ANY WARRANTY; without even the implied warranty of
** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
** Lesser General Public License for more details.
**
** You should have received a copy of the GNU Lesser General Public
** License along with this library; if not, write to the Free Software
** Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
**
** See http://www.matroska.org/license/lgpl/ for LGPL licensing information.**
** Contact license@matroska.org if any conditions of this licensing are
** not clear to you.
**
**********************************************************************/
/*!
\file
\version \$Id: KaxTags.cpp 711 2004-08-10 12:58:47Z robux4 $
\author Steve Lhomme <robux4 @ users.sf.net>
\author Jory Stone <jcsston @ toughguy.net>
*/
#include "matroska/KaxTags.h"
#include "matroska/KaxTag.h"
#include "matroska/KaxContexts.h"
using namespace LIBEBML_NAMESPACE;
// sub elements
START_LIBMATROSKA_NAMESPACE
EbmlSemantic KaxTags_ContextList[1] =
{
EbmlSemantic(true, false, KaxTag::ClassInfos),
};
const EbmlSemanticContext KaxTags_Context = EbmlSemanticContext(countof(KaxTags_ContextList), KaxTags_ContextList, &KaxSegment_Context, *GetKaxGlobal_Context, &KaxTags::ClassInfos);
EbmlId KaxTags_TheId(0x1254C367, 4);
const EbmlCallbacks KaxTags::ClassInfos(KaxTags::Create, KaxTags_TheId, "Tags", KaxTags_Context);
KaxTags::KaxTags()
:EbmlMaster(KaxTags_Context)
{}
END_LIBMATROSKA_NAMESPACE

Some files were not shown because too many files have changed in this diff Show More