generic-library/matroska
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Release v1.3.0

Browse Source 
git-svn-id: https://matroska.svn.sourceforge.net/svnroot/matroska/tags/libmatroska/libmatroska-1.3.0@816 a6f86f6d-0131-4f8e-9e7b-e335508773d5
This commit is contained in:
Moritz Bunkus
2011-09-23 13:44:42 +00:00
parent f12d63c798
commit 51f99000c5
109 changed files with 19960 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1984
libmatroska/ChangeLog Normal file
View File

File diff suppressed because it is too large Load Diff

504
libmatroska/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!

204
libmatroska/debian/changelog Normal file
View File

@@ -0,0 +1,204 @@
libmatroska (1.3.0-1) natty; urgency=low
* New version.
-- Moritz Bunkus <moritz@bunkus.org> Fri, 23 Sep 2011 13:54:26 +0200
libmatroska (1.2.0-1) natty; urgency=low
* New version.
-- Moritz Bunkus <moritz@bunkus.org> Wed, 15 Jun 2011 13:58:59 +0200
libmatroska (1.1.0-1) lucid; urgency=low
* New version.
-- Moritz Bunkus <moritz@bunkus.org> Sun, 30 Jan 2011 15:30:00 +0200
libmatroska (1.0.0-1) lucid; urgency=low
* New version.
-- Moritz Bunkus <moritz@bunkus.org> Sat, 05 Jun 2010 10:39:00 +0200
libmatroska (0.9.0-1) karmic; urgency=low
* New version.
-- Moritz Bunkus <moritz@bunkus.org> Sun, 09 May 2010 16:59:20 +0200
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

17
libmatroska/debian/control Normal file
View File

@@ -0,0 +1,17 @@
Source: libmatroska
Priority: optional
Maintainer: Moritz Bunkus <moritz@bunkus.org>
Build-Depends: debhelper (>> 3.0.0), libebml-dev (>= 1.0.0-1)
Standards-Version: 3.5.8
Section: libs
Package: libmatroska-dev
Section: libdevel
Architecture: any
Depends: libebml-dev (>= 1.0.0-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
libmatroska/debian/copyright 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
libmatroska/debian/dirs Normal file
View File

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

0
libmatroska/debian/docs Normal file
View File

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

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

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

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

95
libmatroska/debian/rules 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

56
libmatroska/libmatroska.proj Normal file
View File

@@ -0,0 +1,56 @@
#include "*/*.proj"
LIB matroska
{
PROJECT_VERSION 1.3.0
INCLUDE .
EXPINCLUDE .
IF HAVE_EBML2
USE ebml2_legacy
ELSE
USE ebml
USEINCLUDE corec // so that stdafx implied by ebml2_legacy can build
ENDIF
// 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/KaxCluster.cpp
SOURCE src/KaxContexts.cpp
SOURCE src/KaxCues.cpp
SOURCE src/KaxCuesData.cpp
SOURCE src/KaxInfoData.cpp
SOURCE src/KaxSeekHead.cpp
SOURCE src/KaxSegment.cpp
SOURCE src/KaxSemantic.cpp
SOURCE src/KaxTracks.cpp
SOURCE src/KaxVersion.cpp
HEADER matroska/FileKax.h
HEADER matroska/KaxBlock.h
HEADER matroska/KaxBlockData.h
HEADER matroska/KaxCluster.h
HEADER matroska/KaxConfig.h
HEADER matroska/KaxContexts.h
HEADER matroska/KaxCues.h
HEADER matroska/KaxCuesData.h
HEADER matroska/KaxDefines.h
HEADER matroska/KaxInfoData.h
HEADER matroska/KaxSeekHead.h
HEADER matroska/KaxSegment.h
HEADER matroska/KaxSemantic.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
libmatroska/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
libmatroska/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
libmatroska/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)

178
libmatroska/make/linux/Makefile Normal file
View File

@@ -0,0 +1,178 @@
# 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
CROSS =
CXX = $(CROSS)g++
LD = $(CXX)
AR = $(CROSS)ar
RANLIB = $(CROSS)ranlib
INSTALL = install
INSTALL_OPTS = -m 644
INSTALL_OPTS_LIB = -m 644
INSTALL_DIR_OPTS = -m 755
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.5
# 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) rcvu $@ $(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
libmatroska/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
libmatroska/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 )

61
libmatroska/make/linux/fedora-core.spec Normal file
View File

@@ -0,0 +1,61 @@
# SPEC file for (at least) Fedora Core 1, 2, 3
Name: libmatroska
Version: 1.3.0
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} libdir=$RPM_BUILD_ROOT/%{_libdir} 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

73
libmatroska/make/linux/suse.spec Normal file
View File

@@ -0,0 +1,73 @@
#
# 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 tar zlib zlib-devel binutils gcc gcc-c++ libstdc++-devel perl rpm
Name: libmatroska
URL: http://dl.matroska.org/downloads/libmatroska/
Version: 1.3.0
Release: 1
Summary: library to deal with matroska files.
License: LGPL
Group: Development/Libraries/Other
Source: %{name}-%{version}.tar.bz2
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
%build
export CFLAGS="$RPM_OPT_FLAGS"
cd make/linux
make prefix=$RPM_BUILD_ROOT/usr libdir=$RPM_BUILD_ROOT/%{_libdir} staticlib
%install
cd make/linux
make prefix=$RPM_BUILD_ROOT/usr libdir=$RPM_BUILD_ROOT/%{_libdir} install_staticlib install_headers
%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

3102
libmatroska/make/macosx/macosx.pbproj/project.pbxproj Normal file
View File

File diff suppressed because it is too large Load Diff

8
libmatroska/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
libmatroska/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

112
libmatroska/make/mingw32/Makefile Normal file
View File

@@ -0,0 +1,112 @@
# 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
CROSS =
CXX = $(CROSS)g++
CC = $(CROSS)gcc
WINDRES = $(CROSS)windres
RANLIB = $(CROSS)ranlib
AR = $(CROSS)ar
RES =
SRC = $(wildcard ../../src/*.cpp)
OBJ = $(patsubst %.cpp,%.o,$(SRC))
ifeq (yes,$(SHARED))
LIBS = libmatroska.dll
FLAGS = -DMATROSKA_DLL
DLLFLAGS = -DMATROSKA_DLL_EXPORT
else
LIBS = libmatroska.a
endif
ifeq (yes,$(SHARED))
ifeq (yes,$(EBML_DLL))
FLAGS += -DEBML_DLL
endif
endif
CWD = $(shell pwd)
INCS = -I"$(CWD)/../.." -I$(EBML_DIR)
LDFLAGS = -L. -L$(EBML_DIR)/make/mingw32
COMPILEFLAGS = $(DEBUGFLAGS) $(INCS) $(FLAGS) $(CXXFLAGS)
TESTS = test6 test8 test9
.PHONY: all all-before all-after clean clean-custom
.cpp.o:
$(CXX) $(DLLFLAGS) $(COMPILEFLAGS) -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) rcvu $@ $(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) $(COMPILEFLAGS) -c -o $@ $<
test6: ../../test/mux/test6.o $(LIBS)
$(LD) -o $@ $(LDFLAGS) $< -lmatroska -lebml
../../test/mux/test8.o: ../../test/mux/test8.cpp
$(CXX) $(COMPILEFLAGS) -c -o $@ $<
test8: ../../test/mux/test8.o $(LIBS)
$(LD) -o $@ $(LDFLAGS) $< -lmatroska -lebml
../../test/tags/test9.o: ../../test/tags/test9.cpp
$(CXX) $(COMPILEFLAGS) -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) $(COMPILEFLAGS) -MM -MT $$o $$i >> .depend ; \
done
#
# include dependency files if they exist
#
ifneq ($(wildcard .depend),)
include .depend
endif

390
libmatroska/make/mingw32/libmatroska.dev Normal file
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=

27
libmatroska/make/mingw32/test/Makefile Normal file
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)

54
libmatroska/make/mingw32/test/test6.dev Normal file
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=

54
libmatroska/make/mingw32/test/test8.dev Normal file
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=

284
libmatroska/make/vc6/lib/static/libmatroska.dsp Normal file
View File

@@ -0,0 +1,284 @@
# 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\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\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
libmatroska/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
libmatroska/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
libmatroska/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
libmatroska/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
libmatroska/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
libmatroska/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
libmatroska/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
libmatroska/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
libmatroska/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
libmatroska/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
libmatroska/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
libmatroska/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
libmatroska/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
libmatroska/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
libmatroska/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

271
libmatroska/make/vc7/lib/dll/libmatroskadll.v71.vcproj Normal file
View File

@@ -0,0 +1,271 @@
<?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\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\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>

277
libmatroska/make/vc7/lib/static/libmatroska.v71.vcproj Normal file
View File

@@ -0,0 +1,277 @@
<?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\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\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>

263
libmatroska/make/vc7/lib/static/libmatroska.vcproj Normal file
View File

@@ -0,0 +1,263 @@
<?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\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\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
libmatroska/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
libmatroska/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
libmatroska/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
libmatroska/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
libmatroska/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
libmatroska/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

163
libmatroska/matroska/FileKax.h Normal file
View File

@@ -0,0 +1,163 @@
/****************************************************************************
** libmatroska : parse Matroska files, see http://www.matroska.org/
**
** <file/class description>
**
** Copyright (C) 2002-2010 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
filepos_t 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(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, 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,
bool aKeyFrame = true, 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
#ifdef __cplusplus
extern "C" {
#endif
MATROSKA_DLL_API void matroska_init();
MATROSKA_DLL_API void matroska_done();
#ifdef __cplusplus
}
#endif
#endif // FILE_KAX_HPP

40
libmatroska/matroska/KaxAttached.h Normal file
View File

@@ -0,0 +1,40 @@
/****************************************************************************
** libmatroska : parse Matroska files, see http://www.matroska.org/
**
** <file/class MATROSKA_DLL_API description>
**
** Copyright (C) 2002-2010 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/KaxSemantic.h"
#endif // LIBMATROSKA_ATTACHED_H

40
libmatroska/matroska/KaxAttachments.h Normal file
View File

@@ -0,0 +1,40 @@
/****************************************************************************
** libmatroska : parse Matroska files, see http://www.matroska.org/
**
** <file/class description>
**
** Copyright (C) 2002-2010 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/KaxSemantic.h"
#endif // LIBMATROSKA_ATTACHEMENTS_H

389
libmatroska/matroska/KaxBlock.h Normal file
View File

@@ -0,0 +1,389 @@
/****************************************************************************
** libmatroska : parse Matroska files, see http://www.matroska.org/
**
** <file/class description>
**
** Copyright (C) 2002-2010 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"
#include "matroska/KaxDefines.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
bool bInternalBuffer;
public:
DataBuffer(binary * aBuffer, uint32 aSize, bool (*aFreeBuffer)(const DataBuffer & aBuffer) = NULL, bool _bInternalBuffer = false)
:myBuffer(NULL)
,mySize(aSize)
,bValidValue(true)
,myFreeBuffer(aFreeBuffer)
,bInternalBuffer(_bInternalBuffer)
{
if (bInternalBuffer)
{
myBuffer = new binary[mySize];
if (myBuffer == NULL)
bValidValue = false;
else
memcpy(myBuffer, aBuffer, mySize);
}
else
myBuffer = aBuffer;
}
virtual ~DataBuffer() {}
virtual binary * Buffer() {assert(bValidValue); return myBuffer;}
virtual uint32 & Size() {return mySize;};
virtual const binary * Buffer() const {assert(bValidValue); return myBuffer;}
virtual const uint32 Size() const {return mySize;};
bool FreeBuffer(const DataBuffer & aBuffer) {
bool bResult = true;
if (myBuffer != NULL && bValidValue) {
if (myFreeBuffer != NULL)
bResult = myFreeBuffer(aBuffer);
if (bInternalBuffer)
delete [] myBuffer;
myBuffer = NULL;
mySize = 0;
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);
}
};
*/
DECLARE_MKX_MASTER(KaxBlockGroup)
public:
~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(EBML_DEF_CONS EBML_DEF_SEP bool bSimple EBML_DEF_SEP EBML_EXTRA_PARAM) :EBML_DEF_BINARY_INIT EBML_DEF_SEP bLocalTimecodeUsed(false), mLacing(LACING_AUTO), mInvisible(false)
,ParentCluster(NULL), bIsSimple(bSimple), bIsKeyframe(true), bIsDiscardable(false)
{}
KaxInternalBlock(const KaxInternalBlock & ElementToClone);
~KaxInternalBlock();
virtual 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
*/
filepos_t UpdateSize(bool bSaveDefault = false, bool bForceRender = false);
filepos_t 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;
filepos_t RenderData(IOCallback & output, bool bForceRender, bool bSaveDefault = false);
KaxCluster * ParentCluster;
bool bIsSimple;
bool bIsKeyframe;
bool bIsDiscardable;
};
DECLARE_MKX_CONTEXT(KaxBlock);
class MATROSKA_DLL_API KaxBlock : public KaxInternalBlock {
public:
KaxBlock(EBML_EXTRA_PARAM) :KaxInternalBlock(EBML_DEF_BINARY_CTX(KaxBlock)EBML_DEF_SEP false EBML_DEF_SEP EBML_EXTRA_CALL) {}
EBML_CONCRETE_CLASS(KaxBlock)
};
#if MATROSKA_VERSION >= 2
DECLARE_MKX_CONTEXT(KaxSimpleBlock);
class MATROSKA_DLL_API KaxSimpleBlock : public KaxInternalBlock {
public:
KaxSimpleBlock(EBML_EXTRA_PARAM) :KaxInternalBlock(EBML_DEF_BINARY_CTX(KaxSimpleBlock)EBML_DEF_SEP true EBML_DEF_SEP EBML_EXTRA_CALL) {}
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; }
void SetParent(KaxCluster & aParentCluster);
EBML_CONCRETE_CLASS(KaxSimpleBlock)
};
#endif // MATROSKA_VERSION
/// Placeholder class for either a BlockGroup or a SimpleBlock
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;
};
#if MATROSKA_VERSION >= 2
DECLARE_MKX_BINARY_CONS(KaxBlockVirtual)
public:
~KaxBlockVirtual();
/*!
\note override this function to generate the Data/Size on the fly, unlike the usual binary elements
*/
filepos_t UpdateSize(bool bSaveDefault = false, bool bForceRender = false);
void SetParent(const KaxCluster & aParentCluster) {ParentCluster = &aParentCluster;}
filepos_t RenderData(IOCallback & output, bool bForceRender, bool bSaveDefault);
filepos_t ReadData(IOCallback & input, ScopeMode ReadFully = SCOPE_ALL_DATA);
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
END_LIBMATROSKA_NAMESPACE
#endif // LIBMATROSKA_BLOCK_H

74
libmatroska/matroska/KaxBlockData.h Normal file
View File

@@ -0,0 +1,74 @@
/****************************************************************************
** libmatroska : parse Matroska files, see http://www.matroska.org/
**
** <file/class description>
**
** Copyright (C) 2002-2010 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"
#include "matroska/KaxDefines.h"
#include "matroska/KaxBlock.h"
using namespace LIBEBML_NAMESPACE;
START_LIBMATROSKA_NAMESPACE
/*!
\brief element used for B frame-likes
*/
DECLARE_MKX_SINTEGER_CONS(KaxReferenceBlock)
public:
~KaxReferenceBlock();
/*!
\brief override this method to compute the timecode value
*/
virtual filepos_t 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) {*static_cast<EbmlSInteger*>(this) = refTimecode; bTimecodeSet = true;};
bool bTimecodeSet;
bool bOurBlob;
void FreeBlob();
};
END_LIBMATROSKA_NAMESPACE
#endif // LIBMATROSKA_BLOCK_ADDITIONAL_H

40
libmatroska/matroska/KaxChapters.h Normal file
View File

@@ -0,0 +1,40 @@
/****************************************************************************
** libmatroska : parse Matroska files, see http://www.matroska.org/
**
** <file/class description>
**
** Copyright (C) 2002-2010 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$
\author Steve Lhomme <robux4 @ users.sf.net>
*/
#ifndef LIBMATROSKA_CHAPTERS_H
#define LIBMATROSKA_CHAPTERS_H
#include "matroska/KaxSemantic.h"
#endif // LIBMATROSKA_CHAPTERS_H

159
libmatroska/matroska/KaxCluster.h Normal file
View File

@@ -0,0 +1,159 @@
/****************************************************************************
** libmatroska : parse Matroska files, see http://www.matroska.org/
**
** <file/class description>
**
** Copyright (C) 2002-2010 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/KaxDefines.h"
using namespace LIBEBML_NAMESPACE;
START_LIBMATROSKA_NAMESPACE
class KaxSegment;
DECLARE_MKX_MASTER_CONS(KaxCluster)
public:
/*!
\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
*/
filepos_t 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(EBML_INFO(KaxClusterSilentTracks), 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

40
libmatroska/matroska/KaxClusterData.h Normal file
View File

@@ -0,0 +1,40 @@
/****************************************************************************
** libmatroska : parse Matroska files, see http://www.matroska.org/
**
** <file/class MATROSKA_DLL_API description>
**
** Copyright (C) 2002-2010 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/KaxSemantic.h"
#endif // LIBMATROSKA_CLUSTER_DATA_H

70
libmatroska/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-2010 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

40
libmatroska/matroska/KaxContentEncoding.h Normal file
View File

@@ -0,0 +1,40 @@
/****************************************************************************
** libmatroska : parse Matroska files, see http://www.matroska.org/
**
** <file/class description>
**
** Copyright (C) 2002-2010 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 Steve Lhomme <robux4 @ users.sf.net>
*/
#ifndef LIBMATROSKA_CONTENT_ENCODING_H
#define LIBMATROSKA_CONTENT_ENCODING_H
#include "matroska/KaxSemantic.h"
#endif // LIBMATROSKA_CONTENT_ENCODING_H

103
libmatroska/matroska/KaxContexts.h Normal file
View File

@@ -0,0 +1,103 @@
/****************************************************************************
** libmatroska : parse Matroska files, see http://www.matroska.org/
**
** <file/class description>
**
** Copyright (C) 2002-2010 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$
\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;
#define Context_KaxMatroska KaxMatroska_Context
#define Context_KaxSegment KaxSegment_Context
#define Context_KaxTrackEntry KaxTrackEntry_Context
#define Context_KaxTracks KaxTracks_Context
#define Context_KaxCluster KaxCluster_Context
#define Context_KaxBlockGroup KaxBlockGroup_Context
#define Context_KaxInfo KaxInfo_Context
#define Context_KaxAttached KaxAttached_Context
#define Context_KaxAttachments KaxAttachments_Context
#define Context_KaxChapters KaxChapters_Context
#define Context_KaxCues KaxCues_Context
#define Context_KaxTags KaxTags_Context
#define Context_KaxSeekHead KaxSeekHead_Context
#define Context_KaxTag KaxTag_Context
#define Context_KaxTagCommercial KaxTagCommercial_Context
extern MATROSKA_DLL_API const EbmlSemanticContext & GetKaxGlobal_Context();
//extern MATROSKA_DLL_API const EbmlSemanticContext & GetKaxTagsGlobal_Context();
END_LIBMATROSKA_NAMESPACE
#endif // LIBMATROSKA_CONTEXTS_H

91
libmatroska/matroska/KaxCues.h Normal file
View File

@@ -0,0 +1,91 @@
/****************************************************************************
** libmatroska : parse Matroska files, see http://www.matroska.org/
**
** <file/class description>
**
** Copyright (C) 2002-2010 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;
DECLARE_MKX_MASTER(KaxCues)
public:
~KaxCues();
//bool AddBlockGroup(const KaxBlockGroup & BlockReference); // deprecated
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
*/
filepos_t 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

77
libmatroska/matroska/KaxCuesData.h Normal file
View File

@@ -0,0 +1,77 @@
/****************************************************************************
** libmatroska : parse Matroska files, see http://www.matroska.org/
**
** <file/class description>
**
** Copyright (C) 2002-2010 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"
#include "matroska/KaxDefines.h"
using namespace LIBEBML_NAMESPACE;
START_LIBMATROSKA_NAMESPACE
class KaxBlockGroup;
class KaxBlockBlob;
class KaxCueTrackPositions;
class KaxInternalBlock;
DECLARE_MKX_MASTER(KaxCuePoint)
public:
void PositionSet(const KaxBlockGroup & BlockReference, uint64 GlobalTimecodeScale);
void PositionSet(const KaxBlockBlob & BlobReference, uint64 GlobalTimecodeScale);
virtual bool IsSmallerThan(const EbmlElement *Cmp) const;
const KaxCueTrackPositions * GetSeekPosition() const;
bool Timecode(uint64 & aTimecode, uint64 GlobalTimecodeScale) const;
};
DECLARE_MKX_MASTER(KaxCueTrackPositions)
public:
uint64 ClusterPosition() const;
uint16 TrackNumber() const;
};
#if MATROSKA_VERSION >= 2
DECLARE_MKX_MASTER(KaxCueReference)
public:
void AddReference(const KaxBlockGroup & BlockReferenced, uint64 GlobalTimecodeScale);
void AddReference(const KaxBlockBlob & BlockReferenced, uint64 GlobalTimecodeScale);
};
#endif // MATROSKA_VERSION
END_LIBMATROSKA_NAMESPACE
#endif // LIBMATROSKA_CUES_DATA_H

217
libmatroska/matroska/KaxDefines.h Normal file
View File

@@ -0,0 +1,217 @@
/****************************************************************************
** libmatroska : parse Matroska files, see http://www.matroska.org/
**
** <file/class description>
**
** Copyright (C) 2002-2010 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$
\author Steve Lhomme <robux4 @ users.sf.net>
*/
#ifndef LIBMATROSKA_DEFINES_H
#define LIBMATROSKA_DEFINES_H
#include "ebml/EbmlVersion.h"
#include "ebml/EbmlElement.h"
#if defined(HAVE_EBML2) || defined(HAS_EBML2)
#define DEFINE_MKX_CONTEXT(a) DEFINE_xxx_CONTEXT(a,EBML_SemanticGlobal)
#define DEFINE_MKX_MASTER_CONS(a,b,c,d,e) DEFINE_xxx_MASTER_CONS(a,b,d,e,EBML_SemanticGlobal)
#define DEFINE_MKX_MASTER(a,b,c,d,e) DEFINE_xxx_MASTER(a,b,d,e,EBML_SemanticGlobal)
#define DEFINE_MKX_MASTER_ORPHAN(a,b,c,d) DEFINE_xxx_MASTER_ORPHAN(a,b,d,EBML_SemanticGlobal)
#define DEFINE_MKX_UINTEGER_DEF(a,b,c,d,e,v) DEFINE_xxx_UINTEGER_DEF(a,b,d,e,EBML_SemanticGlobal,v)
#define DEFINE_MKX_SINTEGER_DEF(a,b,c,d,e,v) DEFINE_xxx_SINTEGER_DEF(a,b,d,e,EBML_SemanticGlobal,v)
#define DEFINE_MKX_UINTEGER(a,b,c,d,e) DEFINE_xxx_UINTEGER(a,b,d,e,EBML_SemanticGlobal)
#define DEFINE_MKX_SINTEGER(a,b,c,d,e) DEFINE_xxx_SINTEGER(a,b,d,e,EBML_SemanticGlobal)
#define DEFINE_MKX_SINTEGER_CONS(a,b,c,d,e) DEFINE_xxx_SINTEGER_CONS(a,b,d,e,EBML_SemanticGlobal)
#define DEFINE_MKX_STRING_DEF(a,b,c,d,e,v) DEFINE_xxx_STRING_DEF(a,b,d,e,EBML_SemanticGlobal,v)
#define DEFINE_MKX_STRING(a,b,c,d,e) DEFINE_xxx_STRING(a,b,d,e,EBML_SemanticGlobal)
#define DEFINE_MKX_UNISTRING(a,b,c,d,e) DEFINE_xxx_UNISTRING(a,b,d,e,EBML_SemanticGlobal)
#define DEFINE_MKX_BINARY(a,b,c,d,e) DEFINE_xxx_BINARY(a,b,d,e,EBML_SemanticGlobal)
#define DEFINE_MKX_BINARY_CONS(a,b,c,d,e) DEFINE_xxx_BINARY_CONS(a,b,d,e,EBML_SemanticGlobal)
#define DEFINE_MKX_FLOAT_DEF(a,b,c,d,e,v) DEFINE_xxx_FLOAT_DEF(a,b,d,e,EBML_SemanticGlobal,v)
#define DEFINE_MKX_FLOAT(a,b,c,d,e) DEFINE_xxx_FLOAT(a,b,d,e,EBML_SemanticGlobal)
#define DEFINE_MKX_FLOAT64(a,b,c,d,e) DEFINE_xxx_FLOAT64(a,b,d,e,EBML_SemanticGlobal)
#define DEFINE_MKX_DATE(a,b,c,d,e) DEFINE_xxx_DATE(a,b,d,e,EBML_SemanticGlobal)
#define DECLARE_MKX_CONTEXT(x)
#define DECLARE_MKX_MASTER(x) DECLARE_MKX_CONTEXT(x) \
class MATROSKA_DLL_API x : public EbmlMaster { \
public: x(EBML_EXTRA_PARAM); \
x(const x & ElementToClone) :EbmlMaster(ElementToClone) {} \
EBML_CONCRETE_CLASS(x)
#define DECLARE_MKX_MASTER_CONS(x) DECLARE_MKX_CONTEXT(x) \
class MATROSKA_DLL_API x : public EbmlMaster { \
public: x(EBML_EXTRA_PARAM); \
x(const x & ElementToClone); \
EBML_CONCRETE_CLASS(x)
#define DECLARE_MKX_BINARY(x) DECLARE_MKX_CONTEXT(x) \
class MATROSKA_DLL_API x : public EbmlBinary { \
public: x(EBML_EXTRA_PARAM); \
x(const x & ElementToClone) :EbmlBinary(ElementToClone) {} \
EBML_CONCRETE_CLASS(x)
#define DECLARE_MKX_BINARY_CONS(x) DECLARE_MKX_CONTEXT(x) \
class MATROSKA_DLL_API x : public EbmlBinary { \
public: x(EBML_EXTRA_PARAM); \
x(const x & ElementToClone); \
EBML_CONCRETE_CLASS(x)
#define DECLARE_MKX_UNISTRING(x) DECLARE_MKX_CONTEXT(x) \
class MATROSKA_DLL_API x : public EbmlUnicodeString { \
public: x(EBML_EXTRA_PARAM); \
x(const x & ElementToClone) :EbmlUnicodeString(ElementToClone) {} \
EBML_CONCRETE_CLASS(x)
#define DECLARE_MKX_STRING(x) DECLARE_MKX_CONTEXT(x) \
class MATROSKA_DLL_API x : public EbmlString { \
public: x(EBML_EXTRA_PARAM); \
x(const x & ElementToClone) :EbmlString(ElementToClone) {} \
EBML_CONCRETE_CLASS(x)
#define DECLARE_MKX_UINTEGER(x) DECLARE_MKX_CONTEXT(x) \
class MATROSKA_DLL_API x : public EbmlUInteger { \
public: x(EBML_EXTRA_PARAM); \
x(const x & ElementToClone) :EbmlUInteger(ElementToClone) {} \
EBML_CONCRETE_CLASS(x)
#define DECLARE_MKX_SINTEGER_CONS(x) DECLARE_MKX_CONTEXT(x) \
class MATROSKA_DLL_API x : public EbmlSInteger { \
public: x(EBML_EXTRA_PARAM); \
x(const x & ElementToClone); \
EBML_CONCRETE_CLASS(x)
#define DECLARE_MKX_SINTEGER(x) DECLARE_MKX_CONTEXT(x) \
class MATROSKA_DLL_API x : public EbmlSInteger { \
public: x(EBML_EXTRA_PARAM); \
x(const x & ElementToClone) :EbmlSInteger(ElementToClone) {} \
EBML_CONCRETE_CLASS(x)
#define DECLARE_MKX_DATE(x) DECLARE_MKX_CONTEXT(x) \
class MATROSKA_DLL_API x : public EbmlDate { \
public: x(EBML_EXTRA_PARAM); \
x(const x & ElementToClone) :EbmlDate(ElementToClone) {} \
EBML_CONCRETE_CLASS(x)
#define DECLARE_MKX_FLOAT(x) DECLARE_MKX_CONTEXT(x) \
class MATROSKA_DLL_API x : public EbmlFloat { \
public: x(EBML_EXTRA_PARAM); \
x(const x & ElementToClone) :EbmlFloat(ElementToClone) {} \
EBML_CONCRETE_CLASS(x)
#else
#define DEFINE_MKX_CONTEXT(a) DEFINE_xxx_CONTEXT(a,*GetKaxGlobal_Context)
#define DEFINE_MKX_MASTER_CONS(a,b,c,d,e) DEFINE_xxx_MASTER_CONS(a,b,c,d,e,*GetKaxGlobal_Context)
#define DEFINE_MKX_MASTER(a,b,c,d,e) DEFINE_xxx_MASTER(a,b,c,d,e,*GetKaxGlobal_Context)
#define DEFINE_MKX_MASTER_ORPHAN(a,b,c,d) DEFINE_xxx_MASTER_ORPHAN(a,b,c,d,*GetKaxGlobal_Context)
#define DEFINE_MKX_UINTEGER_DEF(a,b,c,d,e,v) DEFINE_xxx_UINTEGER_DEF(a,b,c,d,e,*GetKaxGlobal_Context,v)
#define DEFINE_MKX_SINTEGER_DEF(a,b,c,d,e,v) DEFINE_xxx_SINTEGER_DEF(a,b,c,d,e,*GetKaxGlobal_Context,v)
#define DEFINE_MKX_UINTEGER(a,b,c,d,e) DEFINE_xxx_CLASS(a,b,c,d,e,*GetKaxGlobal_Context)
#define DEFINE_MKX_SINTEGER(a,b,c,d,e) DEFINE_xxx_CLASS(a,b,c,d,e,*GetKaxGlobal_Context)
#define DEFINE_MKX_STRING_DEF(a,b,c,d,e,v) DEFINE_xxx_STRING_DEF(a,b,c,d,e,*GetKaxGlobal_Context,v)
#define DEFINE_MKX_STRING(a,b,c,d,e) DEFINE_xxx_CLASS(a,b,c,d,e,*GetKaxGlobal_Context)
#define DEFINE_MKX_UNISTRING(a,b,c,d,e) DEFINE_xxx_CLASS(a,b,c,d,e,*GetKaxGlobal_Context)
#define DEFINE_MKX_BINARY(a,b,c,d,e) DEFINE_xxx_CLASS(a,b,c,d,e,*GetKaxGlobal_Context)
#define DEFINE_MKX_FLOAT_DEF(a,b,c,d,e,v) DEFINE_xxx_FLOAT_DEF(a,b,c,d,e,*GetKaxGlobal_Context,v)
#define DEFINE_MKX_FLOAT(a,b,c,d,e) DEFINE_xxx_CLASS(a,b,c,d,e,*GetKaxGlobal_Context)
#define DEFINE_MKX_DATE(a,b,c,d,e) DEFINE_xxx_CLASS(a,b,c,d,e,*GetKaxGlobal_Context)
#define DEFINE_MKX_BINARY_CONS(a,b,c,d,e) DEFINE_xxx_CLASS_CONS(a,b,c,d,e,*GetKaxGlobal_Context)
#define DEFINE_MKX_SINTEGER_CONS(a,b,c,d,e) DEFINE_xxx_CLASS_CONS(a,b,c,d,e,*GetKaxGlobal_Context)
#define DECLARE_MKX_CONTEXT(x)
#define DECLARE_MKX_MASTER(x) DECLARE_MKX_CONTEXT(x) \
class MATROSKA_DLL_API x : public EbmlMaster { \
public: x(); \
x(const x & ElementToClone) :EbmlMaster(ElementToClone) {} \
EBML_CONCRETE_CLASS(x)
#define DECLARE_MKX_MASTER_CONS(x) DECLARE_MKX_CONTEXT(x) \
class MATROSKA_DLL_API x : public EbmlMaster { \
public: x(); \
x(const x & ElementToClone); \
EBML_CONCRETE_CLASS(x)
#define DECLARE_MKX_BINARY(x) DECLARE_MKX_CONTEXT(x) \
class MATROSKA_DLL_API x : public EbmlBinary { \
public: x(); \
x(const x & ElementToClone) :EbmlBinary(ElementToClone) {} \
EBML_CONCRETE_CLASS(x)
#define DECLARE_MKX_BINARY_CONS(x) DECLARE_MKX_CONTEXT(x) \
class MATROSKA_DLL_API x : public EbmlBinary { \
public: x(); \
x(const x & ElementToClone); \
EBML_CONCRETE_CLASS(x)
#define DECLARE_MKX_UNISTRING(x) DECLARE_MKX_CONTEXT(x) \
class MATROSKA_DLL_API x : public EbmlUnicodeString { \
public: x(); \
x(const x & ElementToClone) :EbmlUnicodeString(ElementToClone) {} \
EBML_CONCRETE_CLASS(x)
#define DECLARE_MKX_STRING(x) DECLARE_MKX_CONTEXT(x) \
class MATROSKA_DLL_API x : public EbmlString { \
public: x(); \
x(const x & ElementToClone) :EbmlString(ElementToClone) {} \
EBML_CONCRETE_CLASS(x)
#define DECLARE_MKX_UINTEGER(x) DECLARE_MKX_CONTEXT(x) \
class MATROSKA_DLL_API x : public EbmlUInteger { \
public: x(); \
x(const x & ElementToClone) :EbmlUInteger(ElementToClone) {} \
EBML_CONCRETE_CLASS(x)
#define DECLARE_MKX_SINTEGER_CONS(x) DECLARE_MKX_CONTEXT(x) \
class MATROSKA_DLL_API x : public EbmlSInteger { \
public: x(); \
x(const x & ElementToClone); \
EBML_CONCRETE_CLASS(x)
#define DECLARE_MKX_SINTEGER(x) DECLARE_MKX_CONTEXT(x) \
class MATROSKA_DLL_API x : public EbmlSInteger { \
public: x(); \
x(const x & ElementToClone) :EbmlSInteger(ElementToClone) {} \
EBML_CONCRETE_CLASS(x)
#define DECLARE_MKX_DATE(x) DECLARE_MKX_CONTEXT(x) \
class MATROSKA_DLL_API x : public EbmlDate { \
public: x(); \
x(const x & ElementToClone) :EbmlDate(ElementToClone) {} \
EBML_CONCRETE_CLASS(x)
#define DECLARE_MKX_FLOAT(x) DECLARE_MKX_CONTEXT(x) \
class MATROSKA_DLL_API x : public EbmlFloat { \
public: x(); \
x(const x & ElementToClone) :EbmlFloat(ElementToClone) {} \
EBML_CONCRETE_CLASS(x)
#endif
#endif // LIBMATROSKA_DEFINES_H

40
libmatroska/matroska/KaxInfo.h Normal file
View File

@@ -0,0 +1,40 @@
/****************************************************************************
** libmatroska : parse Matroska files, see http://www.matroska.org/
**
** <file/class MATROSKA_DLL_API description>
**
** Copyright (C) 2002-2010 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/KaxSemantic.h"
#endif // LIBMATROSKA_INFO_H

76
libmatroska/matroska/KaxInfoData.h Normal file
View File

@@ -0,0 +1,76 @@
/****************************************************************************
** libmatroska : parse Matroska files, see http://www.matroska.org/
**
** <file/class description>
**
** Copyright (C) 2002-2010 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$
\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"
#include "matroska/KaxDefines.h"
#include "matroska/KaxSemantic.h"
using namespace LIBEBML_NAMESPACE;
START_LIBMATROSKA_NAMESPACE
DECLARE_MKX_CONTEXT(KaxPrevUID);
class MATROSKA_DLL_API KaxPrevUID : public KaxSegmentUID {
public:
KaxPrevUID(EBML_EXTRA_PARAM);
KaxPrevUID(const KaxPrevUID & ElementToClone) :KaxSegmentUID(ElementToClone){}
virtual bool ValidateSize() const { return IsFiniteSize() && (GetSize() == 16);}
EBML_CONCRETE_CLASS(KaxPrevUID)
};
DECLARE_MKX_CONTEXT(KaxNextUID);
class MATROSKA_DLL_API KaxNextUID : public KaxSegmentUID {
public:
KaxNextUID(EBML_EXTRA_PARAM);
KaxNextUID(const KaxNextUID & ElementToClone) :KaxSegmentUID(ElementToClone){}
virtual bool ValidateSize() const { return IsFiniteSize() && (GetSize() == 16);}
EBML_CONCRETE_CLASS(KaxNextUID)
};
END_LIBMATROSKA_NAMESPACE
#endif // LIBMATROSKA_INFO_DATA_H

71
libmatroska/matroska/KaxSeekHead.h Normal file
View File

@@ -0,0 +1,71 @@
/****************************************************************************
** libmatroska : parse Matroska files, see http://www.matroska.org/
**
** <file/class description>
**
** Copyright (C) 2002-2010 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$
\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"
#include "matroska/KaxDefines.h"
using namespace LIBEBML_NAMESPACE;
START_LIBMATROSKA_NAMESPACE
class KaxSegment;
DECLARE_MKX_MASTER(KaxSeek)
public:
int64 Location() const;
bool IsEbmlId(const EbmlId & aId) const;
bool IsEbmlId(const KaxSeek & aPoint) const;
};
DECLARE_MKX_MASTER(KaxSeekHead)
public:
/*!
\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;
};
END_LIBMATROSKA_NAMESPACE
#endif // LIBMATROSKA_SEEK_HEAD_H

62
libmatroska/matroska/KaxSegment.h Normal file
View File

@@ -0,0 +1,62 @@
/****************************************************************************
** libmatroska : parse Matroska files, see http://www.matroska.org/
**
** <file/class MATROSKA_DLL_API description>
**
** Copyright (C) 2002-2010 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"
#include "matroska/KaxDefines.h"
using namespace LIBEBML_NAMESPACE;
START_LIBMATROSKA_NAMESPACE
DECLARE_MKX_MASTER_CONS(KaxSegment)
public:
/*!
\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

707
libmatroska/matroska/KaxSemantic.h Normal file
View File

@@ -0,0 +1,707 @@
/**********************************************************************
** DO NOT EDIT, GENERATED WITH DATA2LIB
**
** libmatroska : parse Matroska files, see http://www.matroska.org/
**
** Copyright (c) 2002-2010, Matroska (non-profit organisation)
** 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.
**
**********************************************************************/
#ifndef LIBMATROSKA_SEMANTIC_H
#define LIBMATROSKA_SEMANTIC_H
#include "matroska/KaxTypes.h"
#include "ebml/EbmlUInteger.h"
#include "ebml/EbmlSInteger.h"
#include "ebml/EbmlDate.h"
#include "ebml/EbmlFloat.h"
#include "ebml/EbmlString.h"
#include "ebml/EbmlUnicodeString.h"
#include "ebml/EbmlBinary.h"
#include "ebml/EbmlMaster.h"
#include "matroska/KaxDefines.h"
using namespace LIBEBML_NAMESPACE;
START_LIBMATROSKA_NAMESPACE
DECLARE_MKX_BINARY (KaxSeekID)
public:
virtual bool ValidateSize() const {return IsFiniteSize() && GetSize() <= 4;}
};
DECLARE_MKX_UINTEGER(KaxSeekPosition)
};
DECLARE_MKX_MASTER(KaxInfo)
};
DECLARE_MKX_BINARY (KaxSegmentUID)
#if defined(HAVE_EBML2) || defined(HAS_EBML2)
public:
KaxSegmentUID(EBML_DEF_CONS EBML_DEF_SEP EBML_EXTRA_PARAM);
#endif
public:
virtual bool ValidateSize() const {return IsFiniteSize() && GetSize() == 16;}
};
DECLARE_MKX_UNISTRING(KaxSegmentFilename)
};
DECLARE_MKX_UNISTRING(KaxPrevFilename)
};
DECLARE_MKX_UNISTRING(KaxNextFilename)
};
DECLARE_MKX_BINARY (KaxSegmentFamily)
public:
virtual bool ValidateSize() const {return IsFiniteSize() && GetSize() == 16;}
};
DECLARE_MKX_MASTER(KaxChapterTranslate)
};
DECLARE_MKX_UINTEGER(KaxChapterTranslateEditionUID)
};
DECLARE_MKX_UINTEGER(KaxChapterTranslateCodec)
};
DECLARE_MKX_BINARY (KaxChapterTranslateID)
};
DECLARE_MKX_UINTEGER(KaxTimecodeScale)
};
DECLARE_MKX_FLOAT(KaxDuration)
};
DECLARE_MKX_DATE (KaxDateUTC)
};
DECLARE_MKX_UNISTRING(KaxTitle)
};
DECLARE_MKX_UNISTRING(KaxMuxingApp)
};
DECLARE_MKX_UNISTRING(KaxWritingApp)
};
DECLARE_MKX_UINTEGER(KaxClusterTimecode)
};
DECLARE_MKX_MASTER(KaxClusterSilentTracks)
};
DECLARE_MKX_UINTEGER(KaxClusterSilentTrackNumber)
};
DECLARE_MKX_UINTEGER(KaxClusterPosition)
};
DECLARE_MKX_UINTEGER(KaxClusterPrevSize)
};
DECLARE_MKX_MASTER(KaxBlockAdditions)
};
DECLARE_MKX_MASTER(KaxBlockMore)
};
DECLARE_MKX_UINTEGER(KaxBlockAddID)
};
DECLARE_MKX_BINARY (KaxBlockAdditional)
};
DECLARE_MKX_UINTEGER(KaxBlockDuration)
};
DECLARE_MKX_UINTEGER(KaxReferencePriority)
};
#if MATROSKA_VERSION >= 2
DECLARE_MKX_SINTEGER(KaxReferenceVirtual)
public:
filepos_t RenderData(IOCallback & output, bool bForceRender, bool bSaveDefault);
};
DECLARE_MKX_BINARY (KaxCodecState)
};
#endif
DECLARE_MKX_MASTER(KaxSlices)
};
DECLARE_MKX_MASTER(KaxTimeSlice)
};
DECLARE_MKX_UINTEGER(KaxSliceLaceNumber)
};
#if MATROSKA_VERSION >= 2
DECLARE_MKX_UINTEGER(KaxSliceFrameNumber)
public:
filepos_t RenderData(IOCallback & output, bool bForceRender, bool bSaveDefault);
};
DECLARE_MKX_UINTEGER(KaxSliceBlockAddID)
public:
filepos_t RenderData(IOCallback & output, bool bForceRender, bool bSaveDefault);
};
DECLARE_MKX_UINTEGER(KaxSliceDelay)
public:
filepos_t RenderData(IOCallback & output, bool bForceRender, bool bSaveDefault);
};
DECLARE_MKX_UINTEGER(KaxSliceDuration)
public:
filepos_t RenderData(IOCallback & output, bool bForceRender, bool bSaveDefault);
};
DECLARE_MKX_MASTER(KaxReferenceFrame)
};
DECLARE_MKX_UINTEGER(KaxReferenceOffset)
};
DECLARE_MKX_UINTEGER(KaxReferenceTimeCode)
};
DECLARE_MKX_BINARY (KaxEncryptedBlock)
public:
filepos_t RenderData(IOCallback & output, bool bForceRender, bool bSaveDefault);
};
#endif
DECLARE_MKX_MASTER(KaxTracks)
};
DECLARE_MKX_UINTEGER(KaxTrackNumber)
};
DECLARE_MKX_UINTEGER(KaxTrackUID)
};
DECLARE_MKX_UINTEGER(KaxTrackType)
};
#if MATROSKA_VERSION >= 2
DECLARE_MKX_UINTEGER(KaxTrackFlagEnabled)
};
#endif
DECLARE_MKX_UINTEGER(KaxTrackFlagDefault)
};
DECLARE_MKX_UINTEGER(KaxTrackFlagForced)
};
DECLARE_MKX_UINTEGER(KaxTrackFlagLacing)
};
DECLARE_MKX_UINTEGER(KaxTrackMinCache)
};
DECLARE_MKX_UINTEGER(KaxTrackMaxCache)
};
DECLARE_MKX_UINTEGER(KaxTrackDefaultDuration)
};
DECLARE_MKX_FLOAT(KaxTrackTimecodeScale)
};
#if MATROSKA_VERSION >= 2
DECLARE_MKX_SINTEGER(KaxTrackOffset)
public:
filepos_t RenderData(IOCallback & output, bool bForceRender, bool bSaveDefault);
};
#endif
DECLARE_MKX_UINTEGER(KaxMaxBlockAdditionID)
};
DECLARE_MKX_UNISTRING(KaxTrackName)
};
DECLARE_MKX_STRING(KaxTrackLanguage)
};
DECLARE_MKX_STRING(KaxCodecID)
};
DECLARE_MKX_BINARY (KaxCodecPrivate)
};
DECLARE_MKX_UNISTRING(KaxCodecName)
};
DECLARE_MKX_UINTEGER(KaxTrackAttachmentLink)
};
#if MATROSKA_VERSION >= 2
DECLARE_MKX_UNISTRING(KaxCodecSettings)
public:
filepos_t RenderData(IOCallback & output, bool bForceRender, bool bSaveDefault);
};
DECLARE_MKX_STRING(KaxCodecInfoURL)
public:
filepos_t RenderData(IOCallback & output, bool bForceRender, bool bSaveDefault);
};
DECLARE_MKX_STRING(KaxCodecDownloadURL)
public:
filepos_t RenderData(IOCallback & output, bool bForceRender, bool bSaveDefault);
};
DECLARE_MKX_UINTEGER(KaxCodecDecodeAll)
};
#endif
DECLARE_MKX_UINTEGER(KaxTrackOverlay)
};
DECLARE_MKX_MASTER(KaxTrackTranslate)
};
DECLARE_MKX_UINTEGER(KaxTrackTranslateEditionUID)
};
DECLARE_MKX_UINTEGER(KaxTrackTranslateCodec)
};
DECLARE_MKX_BINARY (KaxTrackTranslateTrackID)
};
DECLARE_MKX_MASTER(KaxTrackVideo)
};
#if MATROSKA_VERSION >= 2
DECLARE_MKX_UINTEGER(KaxVideoFlagInterlaced)
};
DECLARE_MKX_UINTEGER(KaxVideoStereoMode)
};
DECLARE_MKX_UINTEGER(KaxOldStereoMode)
public:
filepos_t RenderData(IOCallback & output, bool bForceRender, bool bSaveDefault);
};
#endif
DECLARE_MKX_UINTEGER(KaxVideoPixelWidth)
};
DECLARE_MKX_UINTEGER(KaxVideoPixelHeight)
};
DECLARE_MKX_UINTEGER(KaxVideoPixelCropBottom)
};
DECLARE_MKX_UINTEGER(KaxVideoPixelCropTop)
};
DECLARE_MKX_UINTEGER(KaxVideoPixelCropLeft)
};
DECLARE_MKX_UINTEGER(KaxVideoPixelCropRight)
};
DECLARE_MKX_UINTEGER(KaxVideoDisplayWidth)
};
DECLARE_MKX_UINTEGER(KaxVideoDisplayHeight)
};
DECLARE_MKX_UINTEGER(KaxVideoDisplayUnit)
};
DECLARE_MKX_UINTEGER(KaxVideoAspectRatio)
};
DECLARE_MKX_BINARY (KaxVideoColourSpace)
public:
virtual bool ValidateSize() const {return IsFiniteSize() && GetSize() == 4;}
};
#if MATROSKA_VERSION >= 2
DECLARE_MKX_FLOAT(KaxVideoGamma)
public:
filepos_t RenderData(IOCallback & output, bool bForceRender, bool bSaveDefault);
};
DECLARE_MKX_FLOAT(KaxVideoFrameRate)
public:
filepos_t RenderData(IOCallback & output, bool bForceRender, bool bSaveDefault);
};
#endif
DECLARE_MKX_MASTER(KaxTrackAudio)
};
DECLARE_MKX_FLOAT(KaxAudioSamplingFreq)
};
DECLARE_MKX_FLOAT(KaxAudioOutputSamplingFreq)
};
DECLARE_MKX_UINTEGER(KaxAudioChannels)
};
#if MATROSKA_VERSION >= 2
DECLARE_MKX_BINARY (KaxAudioPosition)
public:
filepos_t RenderData(IOCallback & output, bool bForceRender, bool bSaveDefault);
};
#endif
DECLARE_MKX_UINTEGER(KaxAudioBitDepth)
};
#if MATROSKA_VERSION >= 2
DECLARE_MKX_MASTER(KaxTrackOperation)
};
DECLARE_MKX_MASTER(KaxTrackCombinePlanes)
};
DECLARE_MKX_MASTER(KaxTrackPlane)
};
DECLARE_MKX_UINTEGER(KaxTrackPlaneUID)
};
DECLARE_MKX_UINTEGER(KaxTrackPlaneType)
};
DECLARE_MKX_MASTER(KaxTrackJoinBlocks)
};
DECLARE_MKX_UINTEGER(KaxTrackJoinUID)
};
DECLARE_MKX_UINTEGER(KaxTrickTrackUID)
};
DECLARE_MKX_BINARY (KaxTrickTrackSegmentUID)
public:
virtual bool ValidateSize() const {return IsFiniteSize() && GetSize() == 16;}
};
DECLARE_MKX_UINTEGER(KaxTrickTrackFlag)
};
DECLARE_MKX_UINTEGER(KaxTrickMasterTrackUID)
};
DECLARE_MKX_BINARY (KaxTrickMasterTrackSegmentUID)
public:
virtual bool ValidateSize() const {return IsFiniteSize() && GetSize() == 16;}
};
#endif
DECLARE_MKX_MASTER(KaxContentEncodings)
};
DECLARE_MKX_MASTER(KaxContentEncoding)
};
DECLARE_MKX_UINTEGER(KaxContentEncodingOrder)
};
DECLARE_MKX_UINTEGER(KaxContentEncodingScope)
};
DECLARE_MKX_UINTEGER(KaxContentEncodingType)
};
DECLARE_MKX_MASTER(KaxContentCompression)
};
DECLARE_MKX_UINTEGER(KaxContentCompAlgo)
};
DECLARE_MKX_BINARY (KaxContentCompSettings)
};
DECLARE_MKX_MASTER(KaxContentEncryption)
};
DECLARE_MKX_UINTEGER(KaxContentEncAlgo)
};
DECLARE_MKX_BINARY (KaxContentEncKeyID)
};
DECLARE_MKX_BINARY (KaxContentSignature)
};
DECLARE_MKX_BINARY (KaxContentSigKeyID)
};
DECLARE_MKX_UINTEGER(KaxContentSigAlgo)
};
DECLARE_MKX_UINTEGER(KaxContentSigHashAlgo)
};
DECLARE_MKX_UINTEGER(KaxCueTime)
};
DECLARE_MKX_UINTEGER(KaxCueTrack)
};
DECLARE_MKX_UINTEGER(KaxCueClusterPosition)
};
DECLARE_MKX_UINTEGER(KaxCueBlockNumber)
};
#if MATROSKA_VERSION >= 2
DECLARE_MKX_UINTEGER(KaxCueCodecState)
};
DECLARE_MKX_UINTEGER(KaxCueRefTime)
};
DECLARE_MKX_UINTEGER(KaxCueRefCluster)
public:
filepos_t RenderData(IOCallback & output, bool bForceRender, bool bSaveDefault);
};
DECLARE_MKX_UINTEGER(KaxCueRefNumber)
public:
filepos_t RenderData(IOCallback & output, bool bForceRender, bool bSaveDefault);
};
DECLARE_MKX_UINTEGER(KaxCueRefCodecState)
public:
filepos_t RenderData(IOCallback & output, bool bForceRender, bool bSaveDefault);
};
#endif
DECLARE_MKX_MASTER(KaxAttachments)
};
DECLARE_MKX_MASTER(KaxAttached)
};
DECLARE_MKX_UNISTRING(KaxFileDescription)
};
DECLARE_MKX_UNISTRING(KaxFileName)
};
DECLARE_MKX_STRING(KaxMimeType)
};
DECLARE_MKX_BINARY (KaxFileData)
};
DECLARE_MKX_UINTEGER(KaxFileUID)
};
#if MATROSKA_VERSION >= 2
DECLARE_MKX_BINARY (KaxFileReferral)
public:
filepos_t RenderData(IOCallback & output, bool bForceRender, bool bSaveDefault);
};
DECLARE_MKX_UINTEGER(KaxFileUsedStartTime)
};
DECLARE_MKX_UINTEGER(KaxFileUsedEndTime)
};
#endif
DECLARE_MKX_MASTER(KaxChapters)
};
DECLARE_MKX_MASTER(KaxEditionEntry)
};
DECLARE_MKX_UINTEGER(KaxEditionUID)
};
DECLARE_MKX_UINTEGER(KaxEditionFlagHidden)
};
DECLARE_MKX_UINTEGER(KaxEditionFlagDefault)
};
DECLARE_MKX_UINTEGER(KaxEditionFlagOrdered)
};
DECLARE_MKX_MASTER(KaxChapterAtom)
};
DECLARE_MKX_UINTEGER(KaxChapterUID)
};
DECLARE_MKX_UINTEGER(KaxChapterTimeStart)
};
DECLARE_MKX_UINTEGER(KaxChapterTimeEnd)
};
DECLARE_MKX_UINTEGER(KaxChapterFlagHidden)
};
DECLARE_MKX_UINTEGER(KaxChapterFlagEnabled)
};
DECLARE_MKX_BINARY (KaxChapterSegmentUID)
public:
virtual bool ValidateSize() const {return IsFiniteSize() && GetSize() == 16;}
};
DECLARE_MKX_UINTEGER(KaxChapterSegmentEditionUID)
};
DECLARE_MKX_UINTEGER(KaxChapterPhysicalEquiv)
};
DECLARE_MKX_MASTER(KaxChapterTrack)
};
DECLARE_MKX_UINTEGER(KaxChapterTrackNumber)
};
DECLARE_MKX_MASTER(KaxChapterDisplay)
};
DECLARE_MKX_UNISTRING(KaxChapterString)
};
DECLARE_MKX_STRING(KaxChapterLanguage)
};
DECLARE_MKX_STRING(KaxChapterCountry)
};
DECLARE_MKX_MASTER(KaxChapterProcess)
};
DECLARE_MKX_UINTEGER(KaxChapterProcessCodecID)
};
DECLARE_MKX_BINARY (KaxChapterProcessPrivate)
};
DECLARE_MKX_MASTER(KaxChapterProcessCommand)
};
DECLARE_MKX_UINTEGER(KaxChapterProcessTime)
};
DECLARE_MKX_BINARY (KaxChapterProcessData)
};
DECLARE_MKX_MASTER(KaxTags)
};
DECLARE_MKX_MASTER(KaxTag)
};
DECLARE_MKX_MASTER(KaxTagTargets)
};
DECLARE_MKX_UINTEGER(KaxTagTargetTypeValue)
};
DECLARE_MKX_STRING(KaxTagTargetType)
};
DECLARE_MKX_UINTEGER(KaxTagTrackUID)
};
DECLARE_MKX_UINTEGER(KaxTagEditionUID)
};
DECLARE_MKX_UINTEGER(KaxTagChapterUID)
};
DECLARE_MKX_UINTEGER(KaxTagAttachmentUID)
};
DECLARE_MKX_MASTER(KaxTagSimple)
};
DECLARE_MKX_UNISTRING(KaxTagName)
};
DECLARE_MKX_STRING(KaxTagLangue)
};
DECLARE_MKX_UINTEGER(KaxTagDefault)
};
DECLARE_MKX_UNISTRING(KaxTagString)
};
DECLARE_MKX_BINARY (KaxTagBinary)
};
END_LIBMATROSKA_NAMESPACE
#endif // LIBMATROSKA_SEMANTIC_H

40
libmatroska/matroska/KaxTag.h Normal file
View File

@@ -0,0 +1,40 @@
/****************************************************************************
** libmatroska : parse Matroska files, see http://www.matroska.org/
**
** <file/class MATROSKA_DLL_API description>
**
** Copyright (C) 2002-2010 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$
\author Steve Lhomme <robux4 @ users.sf.net>
*/
#ifndef LIBMATROSKA_TAG_H
#define LIBMATROSKA_TAG_H
#include "matroska/KaxSemantic.h"
#endif // LIBMATROSKA_TAG_H

40
libmatroska/matroska/KaxTags.h Normal file
View File

@@ -0,0 +1,40 @@
/****************************************************************************
** libmatroska : parse Matroska files, see http://www.matroska.org/
**
** <file/class MATROSKA_DLL_API description>
**
** Copyright (C) 2002-2010 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/KaxSemantic.h"
#endif // LIBMATROSKA_TAGS_H

40
libmatroska/matroska/KaxTrackAudio.h Normal file
View File

@@ -0,0 +1,40 @@
/****************************************************************************
** libmatroska : parse Matroska files, see http://www.matroska.org/
**
** <file/class MATROSKA_DLL_API description>
**
** Copyright (C) 2002-2010 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/KaxSemantic.h"
#endif // LIBMATROSKA_TRACK_AUDIO_H

40
libmatroska/matroska/KaxTrackEntryData.h Normal file
View File

@@ -0,0 +1,40 @@
/****************************************************************************
** libmatroska : parse Matroska files, see http://www.matroska.org/
**
** <file/class description>
**
** Copyright (C) 2002-2010 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>
*/
#ifndef LIBMATROSKA_TRACK_ENTRY_DATA_H
#define LIBMATROSKA_TRACK_ENTRY_DATA_H
#include "matroska/KaxSemantic.h"
#endif // LIBMATROSKA_TRACK_ENTRY_DATA_H

40
libmatroska/matroska/KaxTrackVideo.h Normal file
View File

@@ -0,0 +1,40 @@
/****************************************************************************
** libmatroska : parse Matroska files, see http://www.matroska.org/
**
** <file/class MATROSKA_DLL_API description>
**
** Copyright (C) 2002-2010 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$
\author Steve Lhomme <robux4 @ users.sf.net>
*/
#ifndef LIBMATROSKA_TRACK_VIDEO_H
#define LIBMATROSKA_TRACK_VIDEO_H
#include "matroska/KaxSemantic.h"
#endif // LIBMATROSKA_TRACK_VIDEO_H

78
libmatroska/matroska/KaxTracks.h Normal file
View File

@@ -0,0 +1,78 @@
/****************************************************************************
** libmatroska : parse Matroska files, see http://www.matroska.org/
**
** <file/class description>
**
** Copyright (C) 2002-2010 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/KaxDefines.h"
#include "matroska/KaxSemantic.h"
using namespace LIBEBML_NAMESPACE;
START_LIBMATROSKA_NAMESPACE
DECLARE_MKX_MASTER(KaxTrackEntry)
public:
EbmlUInteger & TrackNumber() const { return *(static_cast<EbmlUInteger *>(FindElt(EBML_INFO(KaxTrackNumber)))); }
void EnableLacing(bool bEnable = true);
/*!
\note lacing set by default
*/
inline bool LacingEnabled() const {
KaxTrackFlagLacing * myLacing = static_cast<KaxTrackFlagLacing *>(FindFirstElt(EBML_INFO(KaxTrackFlagLacing)));
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
libmatroska/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-2010 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
libmatroska/matroska/KaxVersion.h Normal file
View File

@@ -0,0 +1,54 @@
/****************************************************************************
** <file/class description>
**
** Copyright (C) 2002-2010 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 0x010300
extern const std::string KaxCodeVersion;
extern const std::string KaxCodeDate;
/*!
\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
libmatroska/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
libmatroska/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_ */

465
libmatroska/src/FileKax.cpp Normal file
View File

@@ -0,0 +1,465 @@
/****************************************************************************
** 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$
\author Steve Lhomme <robux4 @ users.sf.net>
*/
//#include "StdInclude.h"
#include "matroska/FileKax.h"
#include "ebml/EbmlVersion.h"
#include "ebml/EbmlContexts.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
*/
filepos_t 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
filepos_t 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, bool bLaced)
{
if (IsMyTrack(aTrack))
{
aTrack->SetLaced(bLaced);
}
}
bool FileMatroska::AddFrame(Track * aTrack, const uint32 aTimecode, const binary *aFrame, const uint32 aFrameSize,
bool aKeyFrame, 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
void matroska_init()
{
#if defined(HAVE_EBML2) || defined(HAS_EBML2)
ebml_init();
#endif
}
void matroska_done()
{
#if defined(HAVE_EBML2) || defined(HAS_EBML2)
ebml_done();
#endif
}

51
libmatroska/src/KaxAttached.cpp Normal file
View File

@@ -0,0 +1,51 @@
/****************************************************************************
** libmatroska : parse Matroska files, see http://www.matroska.org/
**
** <file/class description>
**
** Copyright (C) 2002-2010 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/KaxContexts.h"
#include "matroska/KaxDefines.h"
#include "matroska/KaxSemantic.h"
// sub elements
using namespace LIBEBML_NAMESPACE;
START_LIBMATROSKA_NAMESPACE
KaxAttached::KaxAttached(EBML_EXTRA_DEF)
:EbmlMaster(EBML_CLASS_SEMCONTEXT(KaxAttached) EBML_DEF_SEP EBML_EXTRA_CALL)
{
SetSizeLength(2); // mandatory min size support (for easier updating) (2^(7*2)-2 = 16Ko)
}
END_LIBMATROSKA_NAMESPACE

50
libmatroska/src/KaxAttachments.cpp Normal file
View File

@@ -0,0 +1,50 @@
/****************************************************************************
** libmatroska : parse Matroska files, see http://www.matroska.org/
**
** <file/class description>
**
** Copyright (C) 2002-2010 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/KaxContexts.h"
#include "matroska/KaxDefines.h"
#include "matroska/KaxSemantic.h"
using namespace LIBEBML_NAMESPACE;
// sub elements
START_LIBMATROSKA_NAMESPACE
KaxAttachments::KaxAttachments(EBML_EXTRA_DEF)
:EbmlMaster(EBML_CLASS_SEMCONTEXT(KaxAttachments) EBML_DEF_SEP EBML_EXTRA_CALL)
{
SetSizeLength(2); // mandatory min size support (for easier updating) (2^(7*2)-2 = 16Ko)
}
END_LIBMATROSKA_NAMESPACE

1043
libmatroska/src/KaxBlock.cpp Normal file
View File

File diff suppressed because it is too large Load Diff

114
libmatroska/src/KaxBlockData.cpp Normal file
View File

@@ -0,0 +1,114 @@
/****************************************************************************
** libmatroska : parse Matroska files, see http://www.matroska.org/
**
** <file/class description>
**
** Copyright (C) 2002-2010 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"
#include "matroska/KaxDefines.h"
#include "matroska/KaxSemantic.h"
using namespace LIBEBML_NAMESPACE;
START_LIBMATROSKA_NAMESPACE
const KaxBlockBlob & KaxReferenceBlock::RefBlock() const
{
assert(RefdBlock != NULL);
return *RefdBlock;
}
KaxReferenceBlock::KaxReferenceBlock(EBML_EXTRA_DEF)
:EBML_DEF_SINTEGER(KaxReferenceBlock)EBML_DEF_SEP
RefdBlock(NULL)
,ParentBlock(NULL)
,bTimecodeSet(false)
,bOurBlob(false)
{
bTimecodeSet = false;
}
KaxReferenceBlock::KaxReferenceBlock(const KaxReferenceBlock & ElementToClone)
:EbmlSInteger(ElementToClone)
,RefdBlock(NULL)
,ParentBlock(NULL)
,bTimecodeSet(ElementToClone.bTimecodeSet)
,bOurBlob(false)
{
}
KaxReferenceBlock::~KaxReferenceBlock()
{
FreeBlob();
}
void KaxReferenceBlock::FreeBlob()
{
if (bOurBlob && RefdBlock!=NULL)
delete RefdBlock;
RefdBlock = NULL;
}
filepos_t KaxReferenceBlock::UpdateSize(bool bSaveDefault, bool bForceRender)
{
if (!bTimecodeSet) {
assert(RefdBlock != NULL);
assert(ParentBlock != NULL);
const KaxInternalBlock &block = *RefdBlock;
*static_cast<EbmlSInteger*>(this) = (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);
FreeBlob();
RefdBlock = aRefdBlock;
bOurBlob = true;
SetValueIsSet();
}
void KaxReferenceBlock::SetReferencedBlock(const KaxBlockGroup & aRefdBlock)
{
FreeBlob();
KaxBlockBlob *block_blob = new KaxBlockBlob(BLOCK_BLOB_NO_SIMPLE);
block_blob->SetBlockGroup(*const_cast<KaxBlockGroup*>(&aRefdBlock));
RefdBlock = block_blob;
bOurBlob = true;
SetValueIsSet();
}
END_LIBMATROSKA_NAMESPACE

320
libmatroska/src/KaxCluster.cpp Normal file
View File

@@ -0,0 +1,320 @@
/****************************************************************************
** libmatroska : parse Matroska files, see http://www.matroska.org/
**
** <file/class description>
**
** Copyright (C) 2002-2010 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/KaxBlock.h"
#include "matroska/KaxContexts.h"
#include "matroska/KaxSegment.h"
#include "matroska/KaxDefines.h"
// sub elements
START_LIBMATROSKA_NAMESPACE
KaxCluster::KaxCluster(EBML_EXTRA_DEF)
:EbmlMaster(EBML_CLASS_SEMCONTEXT(KaxCluster) EBML_DEF_SEP EBML_EXTRA_CALL)
,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
EBML_MASTER_ITERATOR Itr = begin();
while (Itr != end())
{
if (EbmlId(**Itr) == EBML_ID(KaxBlockGroup)) {
static_cast<KaxBlockGroup *>(*Itr)->SetParent(*this);
} else if (EbmlId(**Itr) == EBML_ID(KaxBlock)) {
static_cast<KaxBlock *>(*Itr)->SetParent(*this);
#if MATROSKA_VERSION >= 2
} else if (EbmlId(**Itr) == EBML_ID(KaxBlockVirtual)) {
static_cast<KaxBlockVirtual *>(*Itr)->SetParent(*this);
#endif // MATROSKA_VERSION
}
++Itr;
}
}
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
*/
filepos_t KaxCluster::Render(IOCallback & output, KaxCues & CueToUpdate, bool bSaveDefault)
{
filepos_t Result = 0;
size_t Index;
EBML_MASTER_ITERATOR TrkItr, Itr;
// update the Timecode of the Cluster before writing
KaxClusterTimecode * Timecode = static_cast<KaxClusterTimecode *>(this->FindElt(EBML_INFO(KaxClusterTimecode)));
*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(EBML_INFO(KaxTracks)));
for (TrkItr = MyTracks.begin(); TrkItr != MyTracks.end(); ++TrkItr)
{
if (EbmlId(*(*TrkItr)) == EBML_ID(KaxTrackEntry))
{
KaxTrackEntry & entry = *static_cast<KaxTrackEntry *>(*TrkItr);
uint32 tracknum = entry.TrackNumber();
for (Itr = begin(); Itr != end(); ++Itr)
{
if (EbmlId(*(*Itr)) == EBML_ID(KaxBlockGroup)) {
KaxBlockGroup & group = *static_cast<KaxBlockGroup *>(*Itr);
if (group.TrackNumber() == tracknum)
break; // this track is used
}
}
// the track wasn't found in this cluster
if (Itr == end())
{
KaxClusterSilentTracks * SilentTracks = static_cast<KaxClusterSilentTracks *>(this->FindFirstElt(EBML_INFO(KaxClusterSilentTracks)));
assert(SilentTracks != NULL); // the flag bSilentTracksUsed should be set when creating the Cluster
KaxClusterSilentTrackNumber * trackelt = static_cast<KaxClusterSilentTrackNumber *>(SilentTracks->AddNewElt(EBML_INFO(KaxClusterSilentTrackNumber)));
*static_cast<EbmlUInteger *>(trackelt) = tracknum;
}
}
}
}
Result = EbmlMaster::Render(output, bSaveDefault);
// For all Blocks add their position on the CueEntry
for (Itr = begin(); Itr != end(); ++Itr)
{
if (EbmlId(*(*Itr)) == EBML_ID(KaxBlockGroup)) {
CueToUpdate.PositionSet(*static_cast<const KaxBlockGroup *>(*Itr));
}
}
} else {
// new school, using KaxBlockBlob
for (Index = 0; Index<Blobs.size(); Index++)
{
#if MATROSKA_VERSION >= 2
if (Blobs[Index]->IsSimpleBlock())
PushElement( (KaxSimpleBlock&) *Blobs[Index] );
else
#endif
PushElement( (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(EBML_INFO(KaxTracks)));
for (TrkItr = MyTracks.begin(); TrkItr != MyTracks.end(); ++TrkItr)
{
if (EbmlId(*(*TrkItr)) == EBML_ID(KaxTrackEntry))
{
KaxTrackEntry & entry = *static_cast<KaxTrackEntry *>(*TrkItr);
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 == ListSize())
{
KaxClusterSilentTracks * SilentTracks = static_cast<KaxClusterSilentTracks *>(this->FindFirstElt(EBML_INFO(KaxClusterSilentTracks)));
assert(SilentTracks != NULL); // the flag bSilentTracksUsed should be set when creating the Cluster
KaxClusterSilentTrackNumber * trackelt = static_cast<KaxClusterSilentTrackNumber *>(SilentTracks->AddNewElt(EBML_INFO(KaxClusterSilentTrackNumber)));
*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(EBML_INFO(KaxClusterTimecode)));
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()
{
EBML_MASTER_ITERATOR Itr;
for (Itr = begin(); Itr != end(); ++Itr)
{
if (EbmlId(*(*Itr)) == EBML_ID(KaxBlockGroup)) {
static_cast<KaxBlockGroup*>(*Itr)->ReleaseFrames();
}
}
}
uint64 KaxCluster::GetPosition() const
{
assert(ParentSegment != NULL);
return ParentSegment->GetRelativePosition(*this);
}
END_LIBMATROSKA_NAMESPACE

67
libmatroska/src/KaxContexts.cpp Normal file
View File

@@ -0,0 +1,67 @@
/****************************************************************************
** libmatroska : parse Matroska files, see http://www.matroska.org/
**
** <file/class description>
**
** Copyright (C) 2002-2010 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 "ebml/EbmlHead.h"
#include "matroska/KaxContexts.h"
#include "matroska/KaxBlock.h"
#include "matroska/KaxCluster.h"
#include "matroska/KaxSegment.h"
#include "matroska/KaxTracks.h"
using namespace LIBEBML_NAMESPACE;
START_LIBMATROSKA_NAMESPACE
DEFINE_START_SEMANTIC(KaxMatroska)
DEFINE_SEMANTIC_ITEM(true, true, EbmlHead)
DEFINE_SEMANTIC_ITEM(false, false, KaxSegment)
DEFINE_END_SEMANTIC(KaxMatroska)
DEFINE_MKX_CONTEXT(KaxMatroska)
DEFINE_SEMANTIC_CONTEXT(KaxSegment)
DEFINE_SEMANTIC_CONTEXT(KaxAttached)
DEFINE_SEMANTIC_CONTEXT(KaxAttachments)
DEFINE_SEMANTIC_CONTEXT(KaxBlockGroup)
DEFINE_SEMANTIC_CONTEXT(KaxCluster)
DEFINE_SEMANTIC_CONTEXT(KaxTrackEntry)
// for the moment
const EbmlSemanticContext & GetKaxGlobal_Context()
{
return GetEbmlGlobal_Context();
}
END_LIBMATROSKA_NAMESPACE

162
libmatroska/src/KaxCues.cpp Normal file
View File

@@ -0,0 +1,162 @@
/****************************************************************************
** libmatroska : parse Matroska files, see http://www.matroska.org/
**
** <file/class description>
**
** Copyright (C) 2002-2010 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"
#include "matroska/KaxDefines.h"
#include "matroska/KaxSemantic.h"
// sub elements
START_LIBMATROSKA_NAMESPACE
KaxCues::~KaxCues()
{
assert(myTempReferences.size() == 0); // otherwise that means you have added references and forgot to set the position
}
/* deprecated and wrong
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 (&(KaxBlockGroup&)*ListIdx == &BlockRef)
{
delete 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;
uint64 aNextTime = EBML_PRETTYLONGINT(0xFFFFFFFFFFFF);
EBML_MASTER_CONST_ITERATOR Itr;
for (Itr = begin(); Itr != end(); ++Itr)
{
if (EbmlId(*(*Itr)) == EBML_ID(KaxCuePoint)) {
const KaxCuePoint *tmp = static_cast<const KaxCuePoint *>(*Itr);
// check the tile
const KaxCueTime *aTime = static_cast<const KaxCueTime *>(tmp->FindFirstElt(EBML_INFO(KaxCueTime)));
if (aTime != NULL)
{
uint64 _Time = uint64(*aTime);
if (_Time > aPrevTime && _Time < TimecodeToLocate) {
aPrevTime = _Time;
aPointPrev = tmp;
}
if (_Time < aNextTime && _Time > TimecodeToLocate) {
aNextTime= _Time;
}
}
}
}
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

241
libmatroska/src/KaxCuesData.cpp Normal file
View File

@@ -0,0 +1,241 @@
/****************************************************************************
** libmatroska : parse Matroska files, see http://www.matroska.org/
**
** <file/class description>
**
** Copyright (C) 2002-2010 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"
#include "matroska/KaxDefines.h"
#include "matroska/KaxSemantic.h"
START_LIBMATROSKA_NAMESPACE
/*!
\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(EBML_INFO(KaxCodecState)));
if (CodecState != NULL) {
KaxCueCodecState &CueCodecState = AddNewChild<KaxCueCodecState>(NewPositions);
*static_cast<EbmlUInteger*>(&CueCodecState) = BlockReference.GetParentCluster()->GetParentSegment()->GetRelativePosition(CodecState->GetElementPosition());
}
#endif // MATROSKA_VERSION
SetValueIsSet();
}
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(EBML_INFO(KaxCodecState)));
if (CodecState != NULL) {
KaxCueCodecState &CueCodecState = AddNewChild<KaxCueCodecState>(NewPositions);
*static_cast<EbmlUInteger*>(&CueCodecState) = BlockGroup.GetParentCluster()->GetParentSegment()->GetRelativePosition(CodecState->GetElementPosition());
}
}
#endif // MATROSKA_VERSION
SetValueIsSet();
}
#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::IsSmallerThan(const EbmlElement * EltB) const
{
assert(EbmlId(*this) == EBML_ID(KaxCuePoint));
assert(EbmlId(*EltB) == EBML_ID(KaxCuePoint));
const KaxCuePoint & theEltB = *static_cast<const KaxCuePoint *>(EltB);
// compare timecode
const KaxCueTime * TimeCodeA = static_cast<const KaxCueTime *>(FindElt(EBML_INFO(KaxCueTime)));
if (TimeCodeA == NULL)
return false;
const KaxCueTime * TimeCodeB = static_cast<const KaxCueTime *>(theEltB.FindElt(EBML_INFO(KaxCueTime)));
if (TimeCodeB == NULL)
return false;
if (TimeCodeA->IsSmallerThan(TimeCodeB))
return true;
if (TimeCodeB->IsSmallerThan(TimeCodeA))
return false;
// compare tracks (timecodes are equal)
const KaxCueTrack * TrackA = static_cast<const KaxCueTrack *>(FindElt(EBML_INFO(KaxCueTrack)));
if (TrackA == NULL)
return false;
const KaxCueTrack * TrackB = static_cast<const KaxCueTrack *>(theEltB.FindElt(EBML_INFO(KaxCueTrack)));
if (TrackB == NULL)
return false;
if (TrackA->IsSmallerThan(TrackB))
return true;
if (TrackB->IsSmallerThan(TrackA))
return false;
return false;
}
bool KaxCuePoint::Timecode(uint64 & aTimecode, uint64 GlobalTimecodeScale) const
{
const KaxCueTime *aTime = static_cast<const KaxCueTime *>(FindFirstElt(EBML_INFO(KaxCueTime)));
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(EBML_INFO(KaxCueTrackPositions)));
while (aPoss != NULL)
{
const KaxCueClusterPosition *aPos = static_cast<const KaxCueClusterPosition *>(aPoss->FindFirstElt(EBML_INFO(KaxCueClusterPosition)));
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(EBML_INFO(KaxCueClusterPosition)));
if (aPos == NULL)
return 0;
return uint64(*aPos);
}
uint16 KaxCueTrackPositions::TrackNumber() const
{
const KaxCueTrack *aTrack = static_cast<const KaxCueTrack *>(FindFirstElt(EBML_INFO(KaxCueTrack)));
if (aTrack == NULL)
return 0;
return uint16(*aTrack);
}
END_LIBMATROSKA_NAMESPACE

60
libmatroska/src/KaxInfoData.cpp Normal file
View File

@@ -0,0 +1,60 @@
/****************************************************************************
** libmatroska : parse Matroska files, see http://www.matroska.org/
**
** <file/class description>
**
** Copyright (C) 2002-2010 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$
\author Steve Lhomme <robux4 @ users.sf.net>
\author John Cannon <spyder2555 @ users.sf.net>
*/
#include "matroska/KaxInfoData.h"
#include "matroska/KaxContexts.h"
#include "matroska/KaxDefines.h"
#include "matroska/KaxSemantic.h"
START_LIBMATROSKA_NAMESPACE
KaxPrevUID::KaxPrevUID(EBML_EXTRA_DEF)
:KaxSegmentUID(EBML_DEF_BINARY_CTX(KaxPrevUID) EBML_DEF_SEP EBML_EXTRA_CALL)
{
}
KaxNextUID::KaxNextUID(EBML_EXTRA_DEF)
:KaxSegmentUID(EBML_DEF_BINARY_CTX(KaxNextUID) EBML_DEF_SEP EBML_EXTRA_CALL)
{
}
#if defined(HAVE_EBML2) || defined(HAS_EBML2)
KaxSegmentUID::KaxSegmentUID(EBML_DEF_CONS EBML_DEF_SEP EBML_EXTRA_DEF)
:EbmlBinary(EBML_DEF_PARAM EBML_DEF_SEP EBML_EXTRA_CALL)
{
}
#endif
END_LIBMATROSKA_NAMESPACE

149
libmatroska/src/KaxSeekHead.cpp Normal file
View File

@@ -0,0 +1,149 @@
/****************************************************************************
** libmatroska : parse Matroska files, see http://www.matroska.org/
**
** <file/class description>
**
** Copyright (C) 2002-2010 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"
#include "matroska/KaxDefines.h"
using namespace LIBEBML_NAMESPACE;
// sub elements
START_LIBMATROSKA_NAMESPACE
/*!
\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];
((const EbmlId&)aElt).Fill(ID);
aNewID.CopyBuffer(ID, EBML_ID_LENGTH((const EbmlId&)aElt));
}
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(EBML_INFO(KaxSeek)));
while (aElt != NULL)
{
KaxSeekID * aId = NULL;
EBML_MASTER_ITERATOR Itr;
for (Itr = aElt->begin(); Itr != aElt->end(); ++Itr)
{
if (EbmlId(*(*Itr)) == EBML_ID(KaxSeekID)) {
aId = static_cast<KaxSeekID*>(*Itr);
EbmlId aEbmlId(aId->GetBuffer(), aId->GetSize());
if (aEbmlId == EBML_INFO_ID(Callbacks))
{
return aElt;
}
break;
}
}
aElt = static_cast<KaxSeek *>(FindNextElt(*aElt));
}
return NULL;
}
KaxSeek * KaxSeekHead::FindNextOf(const KaxSeek &aPrev) const
{
EBML_MASTER_CONST_ITERATOR Itr;
KaxSeek *tmp;
// look for the previous in the list
for (Itr = begin(); Itr != end(); ++Itr)
{
if (*Itr == static_cast<const EbmlElement*>(&aPrev))
break;
}
if (Itr != end())
{
++Itr;
for (; Itr != end(); ++Itr)
{
if (EbmlId(*(*Itr)) == EBML_ID(KaxSeek))
{
tmp = (KaxSeek *)(*Itr);
if (tmp->IsEbmlId(aPrev))
return tmp;
}
}
}
return NULL;
}
int64 KaxSeek::Location() const
{
KaxSeekPosition *aPos = static_cast<KaxSeekPosition*>(FindFirstElt(EBML_INFO(KaxSeekPosition)));
if (aPos == NULL)
return 0;
return uint64(*aPos);
}
bool KaxSeek::IsEbmlId(const EbmlId & aId) const
{
KaxSeekID *_Id = static_cast<KaxSeekID*>(FindFirstElt(EBML_INFO(KaxSeekID)));
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(EBML_INFO(KaxSeekID)));
if (_IdA == NULL)
return false;
KaxSeekID *_IdB = static_cast<KaxSeekID*>(aPoint.FindFirstElt(EBML_INFO(KaxSeekID)));
if (_IdB == NULL)
return false;
EbmlId aEbmlIdA(_IdA->GetBuffer(), _IdA->GetSize());
EbmlId aEbmlIdB(_IdB->GetBuffer(), _IdB->GetSize());
return (aEbmlIdA == aEbmlIdB);
}
END_LIBMATROSKA_NAMESPACE

85
libmatroska/src/KaxSegment.cpp Normal file
View File

@@ -0,0 +1,85 @@
/****************************************************************************
** libmatroska : parse Matroska files, see http://www.matroska.org/
**
** <file/class description>
**
** Copyright (C) 2002-2010 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/KaxContexts.h"
#include "matroska/KaxDefines.h"
START_LIBMATROSKA_NAMESPACE
KaxSegment::KaxSegment(EBML_EXTRA_DEF)
:EbmlMaster(EBML_CLASS_SEMCONTEXT(KaxSegment) EBML_DEF_SEP EBML_EXTRA_CALL)
{
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
EBML_MASTER_ITERATOR Itr = begin();
while (Itr != end())
{
if (EbmlId(**Itr) == EBML_ID(KaxCluster)) {
static_cast<KaxCluster *>(*Itr)->SetParent(*this);
}
++Itr;
}
}
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

764
libmatroska/src/KaxSemantic.cpp Normal file
View File

@@ -0,0 +1,764 @@
/**********************************************************************
** DO NOT EDIT, GENERATED WITH DATA2LIB
**
** libmatroska : parse Matroska files, see http://www.matroska.org/
**
** Copyright (c) 2002-2010, Matroska (non-profit organisation)
** 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.
**
**********************************************************************/
#include "matroska/KaxContexts.h"
#include "matroska/KaxSemantic.h"
#include "matroska/KaxSegment.h"
#include "matroska/KaxSeekHead.h"
#include "matroska/KaxCluster.h"
#include "matroska/KaxTracks.h"
#include "matroska/KaxCues.h"
#include "matroska/KaxInfoData.h"
#include "matroska/KaxBlockData.h"
#include "matroska/KaxCuesData.h"
START_LIBMATROSKA_NAMESPACE
DEFINE_START_SEMANTIC(KaxSegment)
DEFINE_SEMANTIC_ITEM(false, false, KaxSeekHead)
DEFINE_SEMANTIC_ITEM(true, false, KaxInfo)
DEFINE_SEMANTIC_ITEM(false, false, KaxCluster)
DEFINE_SEMANTIC_ITEM(false, false, KaxTracks)
DEFINE_SEMANTIC_ITEM(false, true, KaxCues)
DEFINE_SEMANTIC_ITEM(false, true, KaxAttachments)
DEFINE_SEMANTIC_ITEM(false, true, KaxChapters)
DEFINE_SEMANTIC_ITEM(false, false, KaxTags)
DEFINE_END_SEMANTIC(KaxSegment)
DEFINE_MKX_MASTER_ORPHAN(KaxSegment, 0x18538067, 4, "Segment");
DEFINE_START_SEMANTIC(KaxSeekHead)
DEFINE_SEMANTIC_ITEM(true, false, KaxSeek)
DEFINE_END_SEMANTIC(KaxSeekHead)
DEFINE_MKX_MASTER(KaxSeekHead, 0x114D9B74, 4, KaxSegment, "SeekHeader");
DEFINE_START_SEMANTIC(KaxSeek)
DEFINE_SEMANTIC_ITEM(true, true, KaxSeekID)
DEFINE_SEMANTIC_ITEM(true, true, KaxSeekPosition)
DEFINE_END_SEMANTIC(KaxSeek)
DEFINE_MKX_MASTER(KaxSeek, 0x4DBB, 2, KaxSeekHead, "SeekPoint");
DEFINE_MKX_BINARY (KaxSeekID, 0x53AB, 2, KaxSeek, "SeekID");
DEFINE_MKX_UINTEGER(KaxSeekPosition, 0x53AC, 2, KaxSeek, "SeekPosition");
DEFINE_START_SEMANTIC(KaxInfo)
DEFINE_SEMANTIC_ITEM(false, true, KaxSegmentUID)
DEFINE_SEMANTIC_ITEM(false, true, KaxSegmentFilename)
DEFINE_SEMANTIC_ITEM(false, true, KaxPrevUID)
DEFINE_SEMANTIC_ITEM(false, true, KaxPrevFilename)
DEFINE_SEMANTIC_ITEM(false, true, KaxNextUID)
DEFINE_SEMANTIC_ITEM(false, true, KaxNextFilename)
DEFINE_SEMANTIC_ITEM(false, false, KaxSegmentFamily)
DEFINE_SEMANTIC_ITEM(false, false, KaxChapterTranslate)
DEFINE_SEMANTIC_ITEM(true, true, KaxTimecodeScale)
DEFINE_SEMANTIC_ITEM(false, true, KaxDuration)
DEFINE_SEMANTIC_ITEM(false, true, KaxDateUTC)
DEFINE_SEMANTIC_ITEM(false, true, KaxTitle)
DEFINE_SEMANTIC_ITEM(true, true, KaxMuxingApp)
DEFINE_SEMANTIC_ITEM(true, true, KaxWritingApp)
DEFINE_END_SEMANTIC(KaxInfo)
DEFINE_MKX_MASTER(KaxInfo, 0x1549A966, 4, KaxSegment, "Info");
DEFINE_MKX_BINARY (KaxSegmentUID, 0x73A4, 2, KaxInfo, "SegmentUID");
DEFINE_MKX_UNISTRING(KaxSegmentFilename, 0x7384, 2, KaxInfo, "SegmentFilename");
DEFINE_MKX_BINARY_CONS(KaxPrevUID, 0x3CB923, 3, KaxInfo, "PrevUID");
DEFINE_MKX_UNISTRING(KaxPrevFilename, 0x3C83AB, 3, KaxInfo, "PrevFilename");
DEFINE_MKX_BINARY_CONS(KaxNextUID, 0x3EB923, 3, KaxInfo, "NextUID");
DEFINE_MKX_UNISTRING(KaxNextFilename, 0x3E83BB, 3, KaxInfo, "NextFilename");
DEFINE_MKX_BINARY (KaxSegmentFamily, 0x4444, 2, KaxInfo, "SegmentFamily");
DEFINE_START_SEMANTIC(KaxChapterTranslate)
DEFINE_SEMANTIC_ITEM(false, false, KaxChapterTranslateEditionUID)
DEFINE_SEMANTIC_ITEM(true, true, KaxChapterTranslateCodec)
DEFINE_SEMANTIC_ITEM(true, true, KaxChapterTranslateID)
DEFINE_END_SEMANTIC(KaxChapterTranslate)
DEFINE_MKX_MASTER(KaxChapterTranslate, 0x6924, 2, KaxInfo, "ChapterTranslate");
DEFINE_MKX_UINTEGER(KaxChapterTranslateEditionUID, 0x69FC, 2, KaxChapterTranslate, "ChapterTranslateEditionUID");
DEFINE_MKX_UINTEGER(KaxChapterTranslateCodec, 0x69BF, 2, KaxChapterTranslate, "ChapterTranslateCodec");
DEFINE_MKX_BINARY (KaxChapterTranslateID, 0x69A5, 2, KaxChapterTranslate, "ChapterTranslateID");
DEFINE_MKX_UINTEGER_DEF(KaxTimecodeScale, 0x2AD7B1, 3, KaxInfo, "TimecodeScale", 1000000);
DEFINE_MKX_FLOAT(KaxDuration, 0x4489, 2, KaxInfo, "Duration");
DEFINE_MKX_DATE (KaxDateUTC, 0x4461, 2, KaxInfo, "DateUTC");
DEFINE_MKX_UNISTRING(KaxTitle, 0x7BA9, 2, KaxInfo, "Title");
DEFINE_MKX_UNISTRING(KaxMuxingApp, 0x4D80, 2, KaxInfo, "MuxingApp");
DEFINE_MKX_UNISTRING(KaxWritingApp, 0x5741, 2, KaxInfo, "WritingApp");
DEFINE_START_SEMANTIC(KaxCluster)
DEFINE_SEMANTIC_ITEM(true, true, KaxClusterTimecode)
DEFINE_SEMANTIC_ITEM(false, true, KaxClusterSilentTracks)
DEFINE_SEMANTIC_ITEM(false, true, KaxClusterPosition)
DEFINE_SEMANTIC_ITEM(false, true, KaxClusterPrevSize)
#if MATROSKA_VERSION >= 2
DEFINE_SEMANTIC_ITEM(false, false, KaxSimpleBlock)
#endif // MATROSKA_VERSION
DEFINE_SEMANTIC_ITEM(false, false, KaxBlockGroup)
#if MATROSKA_VERSION >= 2
DEFINE_SEMANTIC_ITEM(false, false, KaxEncryptedBlock) // not supported
#endif // MATROSKA_VERSION
DEFINE_END_SEMANTIC(KaxCluster)
DEFINE_MKX_MASTER_CONS(KaxCluster, 0x1F43B675, 4, KaxSegment, "Cluster");
DEFINE_MKX_UINTEGER(KaxClusterTimecode, 0xE7, 1, KaxCluster, "ClusterTimecode");
DEFINE_START_SEMANTIC(KaxClusterSilentTracks)
DEFINE_SEMANTIC_ITEM(false, false, KaxClusterSilentTrackNumber)
DEFINE_END_SEMANTIC(KaxClusterSilentTracks)
DEFINE_MKX_MASTER(KaxClusterSilentTracks, 0x5854, 2, KaxCluster, "ClusterSilentTracks");
DEFINE_MKX_UINTEGER(KaxClusterSilentTrackNumber, 0x58D7, 2, KaxClusterSilentTracks, "ClusterSilentTrackNumber");
DEFINE_MKX_UINTEGER(KaxClusterPosition, 0xA7, 1, KaxCluster, "ClusterPosition");
DEFINE_MKX_UINTEGER(KaxClusterPrevSize, 0xAB, 1, KaxCluster, "ClusterPrevSize");
#if MATROSKA_VERSION >= 2
DEFINE_MKX_BINARY_CONS(KaxSimpleBlock, 0xA3, 1, KaxCluster, "SimpleBlock");
#endif
DEFINE_START_SEMANTIC(KaxBlockGroup)
DEFINE_SEMANTIC_ITEM(true, true, KaxBlock)
#if MATROSKA_VERSION >= 2
DEFINE_SEMANTIC_ITEM(false, true, KaxBlockVirtual) // not supported
#endif // MATROSKA_VERSION
DEFINE_SEMANTIC_ITEM(false, true, KaxBlockAdditions)
DEFINE_SEMANTIC_ITEM(false, true, KaxBlockDuration)
DEFINE_SEMANTIC_ITEM(true, true, KaxReferencePriority)
DEFINE_SEMANTIC_ITEM(false, false, KaxReferenceBlock)
#if MATROSKA_VERSION >= 2
DEFINE_SEMANTIC_ITEM(false, true, KaxReferenceVirtual) // not supported
DEFINE_SEMANTIC_ITEM(false, true, KaxCodecState)
#endif // MATROSKA_VERSION
DEFINE_SEMANTIC_ITEM(false, true, KaxSlices)
#if MATROSKA_VERSION >= 2
DEFINE_SEMANTIC_ITEM(false, true, KaxReferenceFrame) // DivX specific
#endif // MATROSKA_VERSION
DEFINE_END_SEMANTIC(KaxBlockGroup)
DEFINE_MKX_MASTER_CONS(KaxBlockGroup, 0xA0, 1, KaxCluster, "BlockGroup");
DEFINE_MKX_BINARY_CONS(KaxBlock, 0xA1, 1, KaxBlockGroup, "Block");
#if MATROSKA_VERSION >= 2
DEFINE_MKX_BINARY_CONS(KaxBlockVirtual, 0xA2, 1, KaxBlockGroup, "BlockVirtual");
#endif
DEFINE_START_SEMANTIC(KaxBlockAdditions)
DEFINE_SEMANTIC_ITEM(true, false, KaxBlockMore)
DEFINE_END_SEMANTIC(KaxBlockAdditions)
DEFINE_MKX_MASTER(KaxBlockAdditions, 0x75A1, 2, KaxBlockGroup, "BlockAdditions");
DEFINE_START_SEMANTIC(KaxBlockMore)
DEFINE_SEMANTIC_ITEM(true, true, KaxBlockAddID)
DEFINE_SEMANTIC_ITEM(true, true, KaxBlockAdditional)
DEFINE_END_SEMANTIC(KaxBlockMore)
DEFINE_MKX_MASTER(KaxBlockMore, 0xA6, 1, KaxBlockAdditions, "BlockMore");
DEFINE_MKX_UINTEGER_DEF(KaxBlockAddID, 0xEE, 1, KaxBlockMore, "BlockAddID", 1);
DEFINE_MKX_BINARY (KaxBlockAdditional, 0xA5, 1, KaxBlockMore, "BlockAdditional");
DEFINE_MKX_UINTEGER(KaxBlockDuration, 0x9B, 1, KaxBlockGroup, "BlockDuration");
DEFINE_MKX_UINTEGER_DEF(KaxReferencePriority, 0xFA, 1, KaxBlockGroup, "FlagReferenced", 0);
DEFINE_MKX_SINTEGER_CONS(KaxReferenceBlock, 0xFB, 1, KaxBlockGroup, "ReferenceBlock");
#if MATROSKA_VERSION >= 2
DEFINE_MKX_SINTEGER(KaxReferenceVirtual, 0xFD, 1, KaxBlockGroup, "ReferenceVirtual");
DEFINE_MKX_BINARY (KaxCodecState, 0xA4, 1, KaxBlockGroup, "CodecState");
#endif
DEFINE_START_SEMANTIC(KaxSlices)
DEFINE_SEMANTIC_ITEM(false, false, KaxTimeSlice)
DEFINE_END_SEMANTIC(KaxSlices)
DEFINE_MKX_MASTER(KaxSlices, 0x8E, 1, KaxBlockGroup, "Slices");
DEFINE_START_SEMANTIC(KaxTimeSlice)
DEFINE_SEMANTIC_ITEM(false, true, KaxSliceLaceNumber)
#if MATROSKA_VERSION >= 2
DEFINE_SEMANTIC_ITEM(false, true, KaxSliceFrameNumber) // not supported
DEFINE_SEMANTIC_ITEM(false, true, KaxSliceBlockAddID) // not supported
DEFINE_SEMANTIC_ITEM(false, true, KaxSliceDelay) // not supported
DEFINE_SEMANTIC_ITEM(false, true, KaxSliceDuration) // not supported
#endif // MATROSKA_VERSION
DEFINE_END_SEMANTIC(KaxTimeSlice)
DEFINE_MKX_MASTER(KaxTimeSlice, 0xE8, 1, KaxSlices, "TimeSlice");
DEFINE_MKX_UINTEGER_DEF(KaxSliceLaceNumber, 0xCC, 1, KaxTimeSlice, "SliceLaceNumber", 0);
#if MATROSKA_VERSION >= 2
DEFINE_MKX_UINTEGER_DEF(KaxSliceFrameNumber, 0xCD, 1, KaxTimeSlice, "SliceFrameNumber", 0);
DEFINE_MKX_UINTEGER_DEF(KaxSliceBlockAddID, 0xCB, 1, KaxTimeSlice, "SliceBlockAddID", 0);
DEFINE_MKX_UINTEGER_DEF(KaxSliceDelay, 0xCE, 1, KaxTimeSlice, "SliceDelay", 0);
DEFINE_MKX_UINTEGER_DEF(KaxSliceDuration, 0xCF, 1, KaxTimeSlice, "SliceDuration", 0);
DEFINE_START_SEMANTIC(KaxReferenceFrame)
DEFINE_SEMANTIC_ITEM(true, true, KaxReferenceOffset) // DivX specific
DEFINE_SEMANTIC_ITEM(true, true, KaxReferenceTimeCode) // DivX specific
DEFINE_END_SEMANTIC(KaxReferenceFrame)
DEFINE_MKX_MASTER(KaxReferenceFrame, 0xC8, 1, KaxBlockGroup, "ReferenceFrame");
DEFINE_MKX_UINTEGER(KaxReferenceOffset, 0xC9, 1, KaxReferenceFrame, "ReferenceOffset");
DEFINE_MKX_UINTEGER(KaxReferenceTimeCode, 0xCA, 1, KaxReferenceFrame, "ReferenceTimeCode");
DEFINE_MKX_BINARY (KaxEncryptedBlock, 0xAF, 1, KaxCluster, "EncryptedBlock");
#endif
DEFINE_START_SEMANTIC(KaxTracks)
DEFINE_SEMANTIC_ITEM(true, false, KaxTrackEntry)
DEFINE_END_SEMANTIC(KaxTracks)
DEFINE_MKX_MASTER(KaxTracks, 0x1654AE6B, 4, KaxSegment, "Tracks");
DEFINE_START_SEMANTIC(KaxTrackEntry)
DEFINE_SEMANTIC_ITEM(true, true, KaxTrackNumber)
DEFINE_SEMANTIC_ITEM(true, true, KaxTrackUID)
DEFINE_SEMANTIC_ITEM(true, true, KaxTrackType)
#if MATROSKA_VERSION >= 2
DEFINE_SEMANTIC_ITEM(true, true, KaxTrackFlagEnabled)
#endif // MATROSKA_VERSION
DEFINE_SEMANTIC_ITEM(true, true, KaxTrackFlagDefault)
DEFINE_SEMANTIC_ITEM(true, true, KaxTrackFlagForced)
DEFINE_SEMANTIC_ITEM(true, true, KaxTrackFlagLacing)
DEFINE_SEMANTIC_ITEM(true, true, KaxTrackMinCache)
DEFINE_SEMANTIC_ITEM(false, true, KaxTrackMaxCache)
DEFINE_SEMANTIC_ITEM(false, true, KaxTrackDefaultDuration)
DEFINE_SEMANTIC_ITEM(true, true, KaxTrackTimecodeScale)
#if MATROSKA_VERSION >= 2
DEFINE_SEMANTIC_ITEM(false, true, KaxTrackOffset) // not supported
#endif // MATROSKA_VERSION
DEFINE_SEMANTIC_ITEM(true, true, KaxMaxBlockAdditionID)
DEFINE_SEMANTIC_ITEM(false, true, KaxTrackName)
DEFINE_SEMANTIC_ITEM(false, true, KaxTrackLanguage)
DEFINE_SEMANTIC_ITEM(true, true, KaxCodecID)
DEFINE_SEMANTIC_ITEM(false, true, KaxCodecPrivate)
DEFINE_SEMANTIC_ITEM(false, true, KaxCodecName)
DEFINE_SEMANTIC_ITEM(false, true, KaxTrackAttachmentLink)
#if MATROSKA_VERSION >= 2
DEFINE_SEMANTIC_ITEM(false, true, KaxCodecSettings) // not supported
DEFINE_SEMANTIC_ITEM(false, false, KaxCodecInfoURL) // not supported
DEFINE_SEMANTIC_ITEM(false, false, KaxCodecDownloadURL) // not supported
DEFINE_SEMANTIC_ITEM(true, true, KaxCodecDecodeAll)
#endif // MATROSKA_VERSION
DEFINE_SEMANTIC_ITEM(false, false, KaxTrackOverlay)
DEFINE_SEMANTIC_ITEM(false, false, KaxTrackTranslate)
DEFINE_SEMANTIC_ITEM(false, true, KaxTrackVideo)
DEFINE_SEMANTIC_ITEM(false, true, KaxTrackAudio)
#if MATROSKA_VERSION >= 2
DEFINE_SEMANTIC_ITEM(false, true, KaxTrackOperation)
DEFINE_SEMANTIC_ITEM(false, true, KaxTrickTrackUID) // DivX specific
DEFINE_SEMANTIC_ITEM(false, true, KaxTrickTrackSegmentUID) // DivX specific
DEFINE_SEMANTIC_ITEM(false, true, KaxTrickTrackFlag) // DivX specific
DEFINE_SEMANTIC_ITEM(false, true, KaxTrickMasterTrackUID) // DivX specific
DEFINE_SEMANTIC_ITEM(false, true, KaxTrickMasterTrackSegmentUID) // DivX specific
#endif // MATROSKA_VERSION
DEFINE_SEMANTIC_ITEM(false, true, KaxContentEncodings)
DEFINE_END_SEMANTIC(KaxTrackEntry)
DEFINE_MKX_MASTER_CONS(KaxTrackEntry, 0xAE, 1, KaxTracks, "TrackEntry");
DEFINE_MKX_UINTEGER(KaxTrackNumber, 0xD7, 1, KaxTrackEntry, "TrackNumber");
DEFINE_MKX_UINTEGER(KaxTrackUID, 0x73C5, 2, KaxTrackEntry, "TrackUID");
DEFINE_MKX_UINTEGER(KaxTrackType, 0x83, 1, KaxTrackEntry, "TrackType");
#if MATROSKA_VERSION >= 2
DEFINE_MKX_UINTEGER_DEF(KaxTrackFlagEnabled, 0xB9, 1, KaxTrackEntry, "TrackFlagEnabled", 1);
#endif
DEFINE_MKX_UINTEGER_DEF(KaxTrackFlagDefault, 0x88, 1, KaxTrackEntry, "TrackFlagDefault", 1);
DEFINE_MKX_UINTEGER_DEF(KaxTrackFlagForced, 0x55AA, 2, KaxTrackEntry, "TrackFlagForced", 0);
DEFINE_MKX_UINTEGER_DEF(KaxTrackFlagLacing, 0x9C, 1, KaxTrackEntry, "TrackFlagLacing", 1);
DEFINE_MKX_UINTEGER_DEF(KaxTrackMinCache, 0x6DE7, 2, KaxTrackEntry, "TrackMinCache", 0);
DEFINE_MKX_UINTEGER(KaxTrackMaxCache, 0x6DF8, 2, KaxTrackEntry, "TrackMaxCache");
DEFINE_MKX_UINTEGER(KaxTrackDefaultDuration, 0x23E383, 3, KaxTrackEntry, "TrackDefaultDuration");
DEFINE_MKX_FLOAT_DEF(KaxTrackTimecodeScale, 0x23314F, 3, KaxTrackEntry, "TrackTimecodeScale", 1);
#if MATROSKA_VERSION >= 2
DEFINE_MKX_SINTEGER_DEF(KaxTrackOffset, 0x537F, 2, KaxTrackEntry, "TrackOffset", 0);
#endif
DEFINE_MKX_UINTEGER_DEF(KaxMaxBlockAdditionID, 0x55EE, 2, KaxTrackEntry, "MaxBlockAdditionID", 0);
DEFINE_MKX_UNISTRING(KaxTrackName, 0x536E, 2, KaxTrackEntry, "TrackName");
DEFINE_MKX_STRING_DEF(KaxTrackLanguage, 0x22B59C, 3, KaxTrackEntry, "TrackLanguage", "eng");
DEFINE_MKX_STRING(KaxCodecID, 0x86, 1, KaxTrackEntry, "CodecID");
DEFINE_MKX_BINARY (KaxCodecPrivate, 0x63A2, 2, KaxTrackEntry, "CodecPrivate");
DEFINE_MKX_UNISTRING(KaxCodecName, 0x258688, 3, KaxTrackEntry, "CodecName");
DEFINE_MKX_UINTEGER(KaxTrackAttachmentLink, 0x7446, 2, KaxTrackEntry, "TrackAttachmentLink");
#if MATROSKA_VERSION >= 2
DEFINE_MKX_UNISTRING(KaxCodecSettings, 0x3A9697, 3, KaxTrackEntry, "CodecSettings");
DEFINE_MKX_STRING(KaxCodecInfoURL, 0x3B4040, 3, KaxTrackEntry, "CodecInfoURL");
DEFINE_MKX_STRING(KaxCodecDownloadURL, 0x26B240, 3, KaxTrackEntry, "CodecDownloadURL");
DEFINE_MKX_UINTEGER_DEF(KaxCodecDecodeAll, 0xAA, 1, KaxTrackEntry, "CodecDecodeAll", 1);
#endif
DEFINE_MKX_UINTEGER(KaxTrackOverlay, 0x6FAB, 2, KaxTrackEntry, "TrackOverlay");
DEFINE_START_SEMANTIC(KaxTrackTranslate)
DEFINE_SEMANTIC_ITEM(false, false, KaxTrackTranslateEditionUID)
DEFINE_SEMANTIC_ITEM(true, true, KaxTrackTranslateCodec)
DEFINE_SEMANTIC_ITEM(true, true, KaxTrackTranslateTrackID)
DEFINE_END_SEMANTIC(KaxTrackTranslate)
DEFINE_MKX_MASTER(KaxTrackTranslate, 0x6624, 2, KaxTrackEntry, "TrackTranslate");
DEFINE_MKX_UINTEGER(KaxTrackTranslateEditionUID, 0x66FC, 2, KaxTrackTranslate, "TrackTranslateEditionUID");
DEFINE_MKX_UINTEGER(KaxTrackTranslateCodec, 0x66BF, 2, KaxTrackTranslate, "TrackTranslateCodec");
DEFINE_MKX_BINARY (KaxTrackTranslateTrackID, 0x66A5, 2, KaxTrackTranslate, "TrackTranslateTrackID");
DEFINE_START_SEMANTIC(KaxTrackVideo)
#if MATROSKA_VERSION >= 2
DEFINE_SEMANTIC_ITEM(true, true, KaxVideoFlagInterlaced)
DEFINE_SEMANTIC_ITEM(false, true, KaxVideoStereoMode)
DEFINE_SEMANTIC_ITEM(false, true, KaxOldStereoMode) // not supported
#endif // MATROSKA_VERSION
DEFINE_SEMANTIC_ITEM(true, true, KaxVideoPixelWidth)
DEFINE_SEMANTIC_ITEM(true, true, KaxVideoPixelHeight)
DEFINE_SEMANTIC_ITEM(false, true, KaxVideoPixelCropBottom)
DEFINE_SEMANTIC_ITEM(false, true, KaxVideoPixelCropTop)
DEFINE_SEMANTIC_ITEM(false, true, KaxVideoPixelCropLeft)
DEFINE_SEMANTIC_ITEM(false, true, KaxVideoPixelCropRight)
DEFINE_SEMANTIC_ITEM(false, true, KaxVideoDisplayWidth)
DEFINE_SEMANTIC_ITEM(false, true, KaxVideoDisplayHeight)
DEFINE_SEMANTIC_ITEM(false, true, KaxVideoDisplayUnit)
DEFINE_SEMANTIC_ITEM(false, true, KaxVideoAspectRatio)
DEFINE_SEMANTIC_ITEM(false, true, KaxVideoColourSpace)
#if MATROSKA_VERSION >= 2
DEFINE_SEMANTIC_ITEM(false, true, KaxVideoGamma) // not supported
DEFINE_SEMANTIC_ITEM(false, true, KaxVideoFrameRate) // not supported
#endif // MATROSKA_VERSION
DEFINE_END_SEMANTIC(KaxTrackVideo)
DEFINE_MKX_MASTER(KaxTrackVideo, 0xE0, 1, KaxTrackEntry, "TrackVideo");
#if MATROSKA_VERSION >= 2
DEFINE_MKX_UINTEGER_DEF(KaxVideoFlagInterlaced, 0x9A, 1, KaxTrackVideo, "VideoFlagInterlaced", 0);
DEFINE_MKX_UINTEGER_DEF(KaxVideoStereoMode, 0x53B8, 2, KaxTrackVideo, "VideoStereoMode", 0);
DEFINE_MKX_UINTEGER(KaxOldStereoMode, 0x53B9, 2, KaxTrackVideo, "OldStereoMode");
#endif
DEFINE_MKX_UINTEGER(KaxVideoPixelWidth, 0xB0, 1, KaxTrackVideo, "VideoPixelWidth");
DEFINE_MKX_UINTEGER(KaxVideoPixelHeight, 0xBA, 1, KaxTrackVideo, "VideoPixelHeight");
DEFINE_MKX_UINTEGER_DEF(KaxVideoPixelCropBottom, 0x54AA, 2, KaxTrackVideo, "VideoPixelCropBottom", 0);
DEFINE_MKX_UINTEGER_DEF(KaxVideoPixelCropTop, 0x54BB, 2, KaxTrackVideo, "VideoPixelCropTop", 0);
DEFINE_MKX_UINTEGER_DEF(KaxVideoPixelCropLeft, 0x54CC, 2, KaxTrackVideo, "VideoPixelCropLeft", 0);
DEFINE_MKX_UINTEGER_DEF(KaxVideoPixelCropRight, 0x54DD, 2, KaxTrackVideo, "VideoPixelCropRight", 0);
DEFINE_MKX_UINTEGER(KaxVideoDisplayWidth, 0x54B0, 2, KaxTrackVideo, "VideoDisplayWidth");
DEFINE_MKX_UINTEGER(KaxVideoDisplayHeight, 0x54BA, 2, KaxTrackVideo, "VideoDisplayHeight");
DEFINE_MKX_UINTEGER_DEF(KaxVideoDisplayUnit, 0x54B2, 2, KaxTrackVideo, "VideoDisplayUnit", 0);
DEFINE_MKX_UINTEGER_DEF(KaxVideoAspectRatio, 0x54B3, 2, KaxTrackVideo, "VideoAspectRatio", 0);
DEFINE_MKX_BINARY (KaxVideoColourSpace, 0x2EB524, 3, KaxTrackVideo, "VideoColourSpace");
#if MATROSKA_VERSION >= 2
DEFINE_MKX_FLOAT(KaxVideoGamma, 0x2FB523, 3, KaxTrackVideo, "VideoGamma");
DEFINE_MKX_FLOAT(KaxVideoFrameRate, 0x2383E3, 3, KaxTrackVideo, "VideoFrameRate");
#endif
DEFINE_START_SEMANTIC(KaxTrackAudio)
DEFINE_SEMANTIC_ITEM(true, true, KaxAudioSamplingFreq)
DEFINE_SEMANTIC_ITEM(false, true, KaxAudioOutputSamplingFreq)
DEFINE_SEMANTIC_ITEM(true, true, KaxAudioChannels)
#if MATROSKA_VERSION >= 2
DEFINE_SEMANTIC_ITEM(false, true, KaxAudioPosition) // not supported
#endif // MATROSKA_VERSION
DEFINE_SEMANTIC_ITEM(false, true, KaxAudioBitDepth)
DEFINE_END_SEMANTIC(KaxTrackAudio)
DEFINE_MKX_MASTER(KaxTrackAudio, 0xE1, 1, KaxTrackEntry, "TrackAudio");
DEFINE_MKX_FLOAT_DEF(KaxAudioSamplingFreq, 0xB5, 1, KaxTrackAudio, "AudioSamplingFreq", 8000);
DEFINE_MKX_FLOAT(KaxAudioOutputSamplingFreq, 0x78B5, 2, KaxTrackAudio, "AudioOutputSamplingFreq");
DEFINE_MKX_UINTEGER_DEF(KaxAudioChannels, 0x9F, 1, KaxTrackAudio, "AudioChannels", 1);
#if MATROSKA_VERSION >= 2
DEFINE_MKX_BINARY (KaxAudioPosition, 0x7D7B, 2, KaxTrackAudio, "AudioPosition");
#endif
DEFINE_MKX_UINTEGER(KaxAudioBitDepth, 0x6264, 2, KaxTrackAudio, "AudioBitDepth");
#if MATROSKA_VERSION >= 2
DEFINE_START_SEMANTIC(KaxTrackOperation)
DEFINE_SEMANTIC_ITEM(false, true, KaxTrackCombinePlanes)
DEFINE_SEMANTIC_ITEM(false, true, KaxTrackJoinBlocks)
DEFINE_END_SEMANTIC(KaxTrackOperation)
DEFINE_MKX_MASTER(KaxTrackOperation, 0xE2, 1, KaxTrackEntry, "TrackOperation");
DEFINE_START_SEMANTIC(KaxTrackCombinePlanes)
DEFINE_SEMANTIC_ITEM(true, false, KaxTrackPlane)
DEFINE_END_SEMANTIC(KaxTrackCombinePlanes)
DEFINE_MKX_MASTER(KaxTrackCombinePlanes, 0xE3, 1, KaxTrackOperation, "TrackCombinePlanes");
DEFINE_START_SEMANTIC(KaxTrackPlane)
DEFINE_SEMANTIC_ITEM(true, true, KaxTrackPlaneUID)
DEFINE_SEMANTIC_ITEM(true, true, KaxTrackPlaneType)
DEFINE_END_SEMANTIC(KaxTrackPlane)
DEFINE_MKX_MASTER(KaxTrackPlane, 0xE4, 1, KaxTrackCombinePlanes, "TrackPlane");
DEFINE_MKX_UINTEGER(KaxTrackPlaneUID, 0xE5, 1, KaxTrackPlane, "TrackPlaneUID");
DEFINE_MKX_UINTEGER(KaxTrackPlaneType, 0xE6, 1, KaxTrackPlane, "TrackPlaneType");
DEFINE_START_SEMANTIC(KaxTrackJoinBlocks)
DEFINE_SEMANTIC_ITEM(true, false, KaxTrackJoinUID)
DEFINE_END_SEMANTIC(KaxTrackJoinBlocks)
DEFINE_MKX_MASTER(KaxTrackJoinBlocks, 0xE9, 1, KaxTrackOperation, "TrackJoinBlocks");
DEFINE_MKX_UINTEGER(KaxTrackJoinUID, 0xED, 1, KaxTrackJoinBlocks, "TrackJoinUID");
DEFINE_MKX_UINTEGER(KaxTrickTrackUID, 0xC0, 1, KaxTrackEntry, "TrickTrackUID");
DEFINE_MKX_BINARY (KaxTrickTrackSegmentUID, 0xC1, 1, KaxTrackEntry, "TrickTrackSegmentUID");
DEFINE_MKX_UINTEGER_DEF(KaxTrickTrackFlag, 0xC6, 1, KaxTrackEntry, "TrickTrackFlag", 0);
DEFINE_MKX_UINTEGER(KaxTrickMasterTrackUID, 0xC7, 1, KaxTrackEntry, "TrickMasterTrackUID");
DEFINE_MKX_BINARY (KaxTrickMasterTrackSegmentUID, 0xC4, 1, KaxTrackEntry, "TrickMasterTrackSegmentUID");
#endif
DEFINE_START_SEMANTIC(KaxContentEncodings)
DEFINE_SEMANTIC_ITEM(true, false, KaxContentEncoding)
DEFINE_END_SEMANTIC(KaxContentEncodings)
DEFINE_MKX_MASTER(KaxContentEncodings, 0x6D80, 2, KaxTrackEntry, "ContentEncodings");
DEFINE_START_SEMANTIC(KaxContentEncoding)
DEFINE_SEMANTIC_ITEM(true, true, KaxContentEncodingOrder)
DEFINE_SEMANTIC_ITEM(true, true, KaxContentEncodingScope)
DEFINE_SEMANTIC_ITEM(true, true, KaxContentEncodingType)
DEFINE_SEMANTIC_ITEM(false, true, KaxContentCompression)
DEFINE_SEMANTIC_ITEM(false, true, KaxContentEncryption)
DEFINE_END_SEMANTIC(KaxContentEncoding)
DEFINE_MKX_MASTER(KaxContentEncoding, 0x6240, 2, KaxContentEncodings, "ContentEncoding");
DEFINE_MKX_UINTEGER_DEF(KaxContentEncodingOrder, 0x5031, 2, KaxContentEncoding, "ContentEncodingOrder", 0);
DEFINE_MKX_UINTEGER_DEF(KaxContentEncodingScope, 0x5032, 2, KaxContentEncoding, "ContentEncodingScope", 1);
DEFINE_MKX_UINTEGER_DEF(KaxContentEncodingType, 0x5033, 2, KaxContentEncoding, "ContentEncodingType", 0);
DEFINE_START_SEMANTIC(KaxContentCompression)
DEFINE_SEMANTIC_ITEM(true, true, KaxContentCompAlgo)
DEFINE_SEMANTIC_ITEM(false, true, KaxContentCompSettings)
DEFINE_END_SEMANTIC(KaxContentCompression)
DEFINE_MKX_MASTER(KaxContentCompression, 0x5034, 2, KaxContentEncoding, "ContentCompression");
DEFINE_MKX_UINTEGER_DEF(KaxContentCompAlgo, 0x4254, 2, KaxContentCompression, "ContentCompAlgo", 0);
DEFINE_MKX_BINARY (KaxContentCompSettings, 0x4255, 2, KaxContentCompression, "ContentCompSettings");
DEFINE_START_SEMANTIC(KaxContentEncryption)
DEFINE_SEMANTIC_ITEM(false, true, KaxContentEncAlgo)
DEFINE_SEMANTIC_ITEM(false, true, KaxContentEncKeyID)
DEFINE_SEMANTIC_ITEM(false, true, KaxContentSignature)
DEFINE_SEMANTIC_ITEM(false, true, KaxContentSigKeyID)
DEFINE_SEMANTIC_ITEM(false, true, KaxContentSigAlgo)
DEFINE_SEMANTIC_ITEM(false, true, KaxContentSigHashAlgo)
DEFINE_END_SEMANTIC(KaxContentEncryption)
DEFINE_MKX_MASTER(KaxContentEncryption, 0x5035, 2, KaxContentEncoding, "ContentEncryption");
DEFINE_MKX_UINTEGER_DEF(KaxContentEncAlgo, 0x47E1, 2, KaxContentEncryption, "ContentEncAlgo", 0);
DEFINE_MKX_BINARY (KaxContentEncKeyID, 0x47E2, 2, KaxContentEncryption, "ContentEncKeyID");
DEFINE_MKX_BINARY (KaxContentSignature, 0x47E3, 2, KaxContentEncryption, "ContentSignature");
DEFINE_MKX_BINARY (KaxContentSigKeyID, 0x47E4, 2, KaxContentEncryption, "ContentSigKeyID");
DEFINE_MKX_UINTEGER_DEF(KaxContentSigAlgo, 0x47E5, 2, KaxContentEncryption, "ContentSigAlgo", 0);
DEFINE_MKX_UINTEGER_DEF(KaxContentSigHashAlgo, 0x47E6, 2, KaxContentEncryption, "ContentSigHashAlgo", 0);
DEFINE_START_SEMANTIC(KaxCues)
DEFINE_SEMANTIC_ITEM(true, false, KaxCuePoint)
DEFINE_END_SEMANTIC(KaxCues)
DEFINE_MKX_MASTER(KaxCues, 0x1C53BB6B, 4, KaxSegment, "Cues");
DEFINE_START_SEMANTIC(KaxCuePoint)
DEFINE_SEMANTIC_ITEM(true, true, KaxCueTime)
DEFINE_SEMANTIC_ITEM(true, false, KaxCueTrackPositions)
DEFINE_END_SEMANTIC(KaxCuePoint)
DEFINE_MKX_MASTER(KaxCuePoint, 0xBB, 1, KaxCues, "CuePoint");
DEFINE_MKX_UINTEGER(KaxCueTime, 0xB3, 1, KaxCuePoint, "CueTime");
DEFINE_START_SEMANTIC(KaxCueTrackPositions)
DEFINE_SEMANTIC_ITEM(true, true, KaxCueTrack)
DEFINE_SEMANTIC_ITEM(true, true, KaxCueClusterPosition)
DEFINE_SEMANTIC_ITEM(false, true, KaxCueBlockNumber)
#if MATROSKA_VERSION >= 2
DEFINE_SEMANTIC_ITEM(false, true, KaxCueCodecState)
DEFINE_SEMANTIC_ITEM(false, false, KaxCueReference)
#endif // MATROSKA_VERSION
DEFINE_END_SEMANTIC(KaxCueTrackPositions)
DEFINE_MKX_MASTER(KaxCueTrackPositions, 0xB7, 1, KaxCuePoint, "CueTrackPositions");
DEFINE_MKX_UINTEGER(KaxCueTrack, 0xF7, 1, KaxCueTrackPositions, "CueTrack");
DEFINE_MKX_UINTEGER(KaxCueClusterPosition, 0xF1, 1, KaxCueTrackPositions, "CueClusterPosition");
DEFINE_MKX_UINTEGER_DEF(KaxCueBlockNumber, 0x5378, 2, KaxCueTrackPositions, "CueBlockNumber", 1);
#if MATROSKA_VERSION >= 2
DEFINE_MKX_UINTEGER_DEF(KaxCueCodecState, 0xEA, 1, KaxCueTrackPositions, "CueCodecState", 0);
DEFINE_START_SEMANTIC(KaxCueReference)
DEFINE_SEMANTIC_ITEM(true, true, KaxCueRefTime)
DEFINE_SEMANTIC_ITEM(true, true, KaxCueRefCluster) // not supported
DEFINE_SEMANTIC_ITEM(false, true, KaxCueRefNumber) // not supported
DEFINE_SEMANTIC_ITEM(false, true, KaxCueRefCodecState) // not supported
DEFINE_END_SEMANTIC(KaxCueReference)
DEFINE_MKX_MASTER(KaxCueReference, 0xDB, 1, KaxCueTrackPositions, "CueReference");
DEFINE_MKX_UINTEGER(KaxCueRefTime, 0x96, 1, KaxCueReference, "CueRefTime");
DEFINE_MKX_UINTEGER(KaxCueRefCluster, 0x97, 1, KaxCueReference, "CueRefCluster");
DEFINE_MKX_UINTEGER_DEF(KaxCueRefNumber, 0x535F, 2, KaxCueReference, "CueRefNumber", 1);
DEFINE_MKX_UINTEGER_DEF(KaxCueRefCodecState, 0xEB, 1, KaxCueReference, "CueRefCodecState", 0);
#endif
DEFINE_START_SEMANTIC(KaxAttachments)
DEFINE_SEMANTIC_ITEM(true, false, KaxAttached)
DEFINE_END_SEMANTIC(KaxAttachments)
DEFINE_MKX_MASTER_CONS(KaxAttachments, 0x1941A469, 4, KaxSegment, "Attachments");
DEFINE_START_SEMANTIC(KaxAttached)
DEFINE_SEMANTIC_ITEM(false, true, KaxFileDescription)
DEFINE_SEMANTIC_ITEM(true, true, KaxFileName)
DEFINE_SEMANTIC_ITEM(true, true, KaxMimeType)
DEFINE_SEMANTIC_ITEM(true, true, KaxFileData)
DEFINE_SEMANTIC_ITEM(true, true, KaxFileUID)
#if MATROSKA_VERSION >= 2
DEFINE_SEMANTIC_ITEM(false, true, KaxFileReferral) // not supported
DEFINE_SEMANTIC_ITEM(false, true, KaxFileUsedStartTime) // DivX specific
DEFINE_SEMANTIC_ITEM(false, true, KaxFileUsedEndTime) // DivX specific
#endif // MATROSKA_VERSION
DEFINE_END_SEMANTIC(KaxAttached)
DEFINE_MKX_MASTER_CONS(KaxAttached, 0x61A7, 2, KaxAttachments, "AttachedFile");
DEFINE_MKX_UNISTRING(KaxFileDescription, 0x467E, 2, KaxAttached, "FileDescription");
DEFINE_MKX_UNISTRING(KaxFileName, 0x466E, 2, KaxAttached, "FileName");
DEFINE_MKX_STRING(KaxMimeType, 0x4660, 2, KaxAttached, "FileMimeType");
DEFINE_MKX_BINARY (KaxFileData, 0x465C, 2, KaxAttached, "FileData");
DEFINE_MKX_UINTEGER(KaxFileUID, 0x46AE, 2, KaxAttached, "FileUID");
#if MATROSKA_VERSION >= 2
DEFINE_MKX_BINARY (KaxFileReferral, 0x4675, 2, KaxAttached, "FileReferral");
DEFINE_MKX_UINTEGER(KaxFileUsedStartTime, 0x4661, 2, KaxAttached, "FileUsedStartTime");
DEFINE_MKX_UINTEGER(KaxFileUsedEndTime, 0x4662, 2, KaxAttached, "FileUsedEndTime");
#endif
DEFINE_START_SEMANTIC(KaxChapters)
DEFINE_SEMANTIC_ITEM(true, false, KaxEditionEntry)
DEFINE_END_SEMANTIC(KaxChapters)
DEFINE_MKX_MASTER(KaxChapters, 0x1043A770, 4, KaxSegment, "Chapters");
DEFINE_START_SEMANTIC(KaxEditionEntry)
DEFINE_SEMANTIC_ITEM(false, true, KaxEditionUID)
DEFINE_SEMANTIC_ITEM(true, true, KaxEditionFlagHidden)
DEFINE_SEMANTIC_ITEM(true, true, KaxEditionFlagDefault)
DEFINE_SEMANTIC_ITEM(false, true, KaxEditionFlagOrdered)
DEFINE_SEMANTIC_ITEM(true, false, KaxChapterAtom)
DEFINE_END_SEMANTIC(KaxEditionEntry)
DEFINE_MKX_MASTER(KaxEditionEntry, 0x45B9, 2, KaxChapters, "EditionEntry");
DEFINE_MKX_UINTEGER(KaxEditionUID, 0x45BC, 2, KaxEditionEntry, "EditionUID");
DEFINE_MKX_UINTEGER_DEF(KaxEditionFlagHidden, 0x45BD, 2, KaxEditionEntry, "EditionFlagHidden", 0);
DEFINE_MKX_UINTEGER_DEF(KaxEditionFlagDefault, 0x45DB, 2, KaxEditionEntry, "EditionFlagDefault", 0);
DEFINE_MKX_UINTEGER_DEF(KaxEditionFlagOrdered, 0x45DD, 2, KaxEditionEntry, "EditionFlagOrdered", 0);
DEFINE_START_SEMANTIC(KaxChapterAtom)
DEFINE_SEMANTIC_ITEM(false, false, KaxChapterAtom) // recursive
DEFINE_SEMANTIC_ITEM(true, true, KaxChapterUID)
DEFINE_SEMANTIC_ITEM(true, true, KaxChapterTimeStart)
DEFINE_SEMANTIC_ITEM(false, true, KaxChapterTimeEnd)
DEFINE_SEMANTIC_ITEM(true, true, KaxChapterFlagHidden)
DEFINE_SEMANTIC_ITEM(true, true, KaxChapterFlagEnabled)
DEFINE_SEMANTIC_ITEM(false, true, KaxChapterSegmentUID)
DEFINE_SEMANTIC_ITEM(false, true, KaxChapterSegmentEditionUID)
DEFINE_SEMANTIC_ITEM(false, true, KaxChapterPhysicalEquiv)
DEFINE_SEMANTIC_ITEM(false, true, KaxChapterTrack)
DEFINE_SEMANTIC_ITEM(false, false, KaxChapterDisplay)
DEFINE_SEMANTIC_ITEM(false, false, KaxChapterProcess)
DEFINE_END_SEMANTIC(KaxChapterAtom)
DEFINE_MKX_MASTER(KaxChapterAtom, 0xB6, 1, KaxEditionEntry, "ChapterAtom");
DEFINE_MKX_UINTEGER(KaxChapterUID, 0x73C4, 2, KaxChapterAtom, "ChapterUID");
DEFINE_MKX_UINTEGER(KaxChapterTimeStart, 0x91, 1, KaxChapterAtom, "ChapterTimeStart");
DEFINE_MKX_UINTEGER(KaxChapterTimeEnd, 0x92, 1, KaxChapterAtom, "ChapterTimeEnd");
DEFINE_MKX_UINTEGER_DEF(KaxChapterFlagHidden, 0x98, 1, KaxChapterAtom, "ChapterFlagHidden", 0);
DEFINE_MKX_UINTEGER_DEF(KaxChapterFlagEnabled, 0x4598, 2, KaxChapterAtom, "ChapterFlagEnabled", 1);
DEFINE_MKX_BINARY (KaxChapterSegmentUID, 0x6E67, 2, KaxChapterAtom, "ChapterSegmentUID");
DEFINE_MKX_UINTEGER(KaxChapterSegmentEditionUID, 0x6EBC, 2, KaxChapterAtom, "ChapterSegmentEditionUID");
DEFINE_MKX_UINTEGER(KaxChapterPhysicalEquiv, 0x63C3, 2, KaxChapterAtom, "ChapterPhysicalEquiv");
DEFINE_START_SEMANTIC(KaxChapterTrack)
DEFINE_SEMANTIC_ITEM(true, false, KaxChapterTrackNumber)
DEFINE_END_SEMANTIC(KaxChapterTrack)
DEFINE_MKX_MASTER(KaxChapterTrack, 0x8F, 1, KaxChapterAtom, "ChapterTrack");
DEFINE_MKX_UINTEGER(KaxChapterTrackNumber, 0x89, 1, KaxChapterTrack, "ChapterTrackNumber");
DEFINE_START_SEMANTIC(KaxChapterDisplay)
DEFINE_SEMANTIC_ITEM(true, true, KaxChapterString)
DEFINE_SEMANTIC_ITEM(true, false, KaxChapterLanguage)
DEFINE_SEMANTIC_ITEM(false, false, KaxChapterCountry)
DEFINE_END_SEMANTIC(KaxChapterDisplay)
DEFINE_MKX_MASTER(KaxChapterDisplay, 0x80, 1, KaxChapterAtom, "ChapterDisplay");
DEFINE_MKX_UNISTRING(KaxChapterString, 0x85, 1, KaxChapterDisplay, "ChapterString");
DEFINE_MKX_STRING_DEF(KaxChapterLanguage, 0x437C, 2, KaxChapterDisplay, "ChapterLanguage", "eng");
DEFINE_MKX_STRING(KaxChapterCountry, 0x437E, 2, KaxChapterDisplay, "ChapterCountry");
DEFINE_START_SEMANTIC(KaxChapterProcess)
DEFINE_SEMANTIC_ITEM(true, true, KaxChapterProcessCodecID)
DEFINE_SEMANTIC_ITEM(false, true, KaxChapterProcessPrivate)
DEFINE_SEMANTIC_ITEM(false, false, KaxChapterProcessCommand)
DEFINE_END_SEMANTIC(KaxChapterProcess)
DEFINE_MKX_MASTER(KaxChapterProcess, 0x6944, 2, KaxChapterAtom, "ChapterProcess");
DEFINE_MKX_UINTEGER_DEF(KaxChapterProcessCodecID, 0x6955, 2, KaxChapterProcess, "ChapterProcessCodecID", 0);
DEFINE_MKX_BINARY (KaxChapterProcessPrivate, 0x450D, 2, KaxChapterProcess, "ChapterProcessPrivate");
DEFINE_START_SEMANTIC(KaxChapterProcessCommand)
DEFINE_SEMANTIC_ITEM(true, true, KaxChapterProcessTime)
DEFINE_SEMANTIC_ITEM(true, true, KaxChapterProcessData)
DEFINE_END_SEMANTIC(KaxChapterProcessCommand)
DEFINE_MKX_MASTER(KaxChapterProcessCommand, 0x6911, 2, KaxChapterProcess, "ChapterProcessCommand");
DEFINE_MKX_UINTEGER(KaxChapterProcessTime, 0x6922, 2, KaxChapterProcessCommand, "ChapterProcessTime");
DEFINE_MKX_BINARY (KaxChapterProcessData, 0x6933, 2, KaxChapterProcessCommand, "ChapterProcessData");
DEFINE_START_SEMANTIC(KaxTags)
DEFINE_SEMANTIC_ITEM(true, false, KaxTag)
DEFINE_END_SEMANTIC(KaxTags)
DEFINE_MKX_MASTER(KaxTags, 0x1254C367, 4, KaxSegment, "Tags");
DEFINE_START_SEMANTIC(KaxTag)
DEFINE_SEMANTIC_ITEM(true, true, KaxTagTargets)
DEFINE_SEMANTIC_ITEM(true, false, KaxTagSimple)
DEFINE_END_SEMANTIC(KaxTag)
DEFINE_MKX_MASTER(KaxTag, 0x7373, 2, KaxTags, "Tag");
DEFINE_START_SEMANTIC(KaxTagTargets)
DEFINE_SEMANTIC_ITEM(false, true, KaxTagTargetTypeValue)
DEFINE_SEMANTIC_ITEM(false, true, KaxTagTargetType)
DEFINE_SEMANTIC_ITEM(false, false, KaxTagTrackUID)
DEFINE_SEMANTIC_ITEM(false, false, KaxTagEditionUID)
DEFINE_SEMANTIC_ITEM(false, false, KaxTagChapterUID)
DEFINE_SEMANTIC_ITEM(false, false, KaxTagAttachmentUID)
DEFINE_END_SEMANTIC(KaxTagTargets)
DEFINE_MKX_MASTER(KaxTagTargets, 0x63C0, 2, KaxTag, "TagTargets");
DEFINE_MKX_UINTEGER_DEF(KaxTagTargetTypeValue, 0x68CA, 2, KaxTagTargets, "TagTargetTypeValue", 50);
DEFINE_MKX_STRING(KaxTagTargetType, 0x63CA, 2, KaxTagTargets, "TagTargetType");
DEFINE_MKX_UINTEGER_DEF(KaxTagTrackUID, 0x63C5, 2, KaxTagTargets, "TagTrackUID", 0);
DEFINE_MKX_UINTEGER_DEF(KaxTagEditionUID, 0x63C9, 2, KaxTagTargets, "TagEditionUID", 0);
DEFINE_MKX_UINTEGER_DEF(KaxTagChapterUID, 0x63C4, 2, KaxTagTargets, "TagChapterUID", 0);
DEFINE_MKX_UINTEGER_DEF(KaxTagAttachmentUID, 0x63C6, 2, KaxTagTargets, "TagAttachmentUID", 0);
DEFINE_START_SEMANTIC(KaxTagSimple)
DEFINE_SEMANTIC_ITEM(false, false, KaxTagSimple) // recursive
DEFINE_SEMANTIC_ITEM(true, true, KaxTagName)
DEFINE_SEMANTIC_ITEM(true, true, KaxTagLangue)
DEFINE_SEMANTIC_ITEM(true, true, KaxTagDefault)
DEFINE_SEMANTIC_ITEM(false, true, KaxTagString)
DEFINE_SEMANTIC_ITEM(false, true, KaxTagBinary)
DEFINE_END_SEMANTIC(KaxTagSimple)
DEFINE_MKX_MASTER(KaxTagSimple, 0x67C8, 2, KaxTag, "TagSimple");
DEFINE_MKX_UNISTRING(KaxTagName, 0x45A3, 2, KaxTagSimple, "TagName");
DEFINE_MKX_STRING_DEF(KaxTagLangue, 0x447A, 2, KaxTagSimple, "TagLanguage", "und");
DEFINE_MKX_UINTEGER_DEF(KaxTagDefault, 0x4484, 2, KaxTagSimple, "TagDefault", 1);
DEFINE_MKX_UNISTRING(KaxTagString, 0x4487, 2, KaxTagSimple, "TagString");
DEFINE_MKX_BINARY (KaxTagBinary, 0x4485, 2, KaxTagSimple, "TagBinary");
filepos_t KaxBlockVirtual::RenderData(IOCallback & output, bool bForceRender, bool bSaveDefault) {
assert(false); // no you are not allowed to use this element !
return 0;
}
filepos_t KaxReferenceVirtual::RenderData(IOCallback & output, bool bForceRender, bool bSaveDefault) {
assert(false); // no you are not allowed to use this element !
return 0;
}
filepos_t KaxSliceFrameNumber::RenderData(IOCallback & output, bool bForceRender, bool bSaveDefault) {
assert(false); // no you are not allowed to use this element !
return 0;
}
filepos_t KaxSliceBlockAddID::RenderData(IOCallback & output, bool bForceRender, bool bSaveDefault) {
assert(false); // no you are not allowed to use this element !
return 0;
}
filepos_t KaxSliceDelay::RenderData(IOCallback & output, bool bForceRender, bool bSaveDefault) {
assert(false); // no you are not allowed to use this element !
return 0;
}
filepos_t KaxSliceDuration::RenderData(IOCallback & output, bool bForceRender, bool bSaveDefault) {
assert(false); // no you are not allowed to use this element !
return 0;
}
filepos_t KaxEncryptedBlock::RenderData(IOCallback & output, bool bForceRender, bool bSaveDefault) {
assert(false); // no you are not allowed to use this element !
return 0;
}
filepos_t KaxTrackOffset::RenderData(IOCallback & output, bool bForceRender, bool bSaveDefault) {
assert(false); // no you are not allowed to use this element !
return 0;
}
filepos_t KaxCodecSettings::RenderData(IOCallback & output, bool bForceRender, bool bSaveDefault) {
assert(false); // no you are not allowed to use this element !
return 0;
}
filepos_t KaxCodecInfoURL::RenderData(IOCallback & output, bool bForceRender, bool bSaveDefault) {
assert(false); // no you are not allowed to use this element !
return 0;
}
filepos_t KaxCodecDownloadURL::RenderData(IOCallback & output, bool bForceRender, bool bSaveDefault) {
assert(false); // no you are not allowed to use this element !
return 0;
}
filepos_t KaxOldStereoMode::RenderData(IOCallback & output, bool bForceRender, bool bSaveDefault) {
assert(false); // no you are not allowed to use this element !
return 0;
}
filepos_t KaxVideoGamma::RenderData(IOCallback & output, bool bForceRender, bool bSaveDefault) {
assert(false); // no you are not allowed to use this element !
return 0;
}
filepos_t KaxVideoFrameRate::RenderData(IOCallback & output, bool bForceRender, bool bSaveDefault) {
assert(false); // no you are not allowed to use this element !
return 0;
}
filepos_t KaxAudioPosition::RenderData(IOCallback & output, bool bForceRender, bool bSaveDefault) {
assert(false); // no you are not allowed to use this element !
return 0;
}
filepos_t KaxCueRefCluster::RenderData(IOCallback & output, bool bForceRender, bool bSaveDefault) {
assert(false); // no you are not allowed to use this element !
return 0;
}
filepos_t KaxCueRefNumber::RenderData(IOCallback & output, bool bForceRender, bool bSaveDefault) {
assert(false); // no you are not allowed to use this element !
return 0;
}
filepos_t KaxCueRefCodecState::RenderData(IOCallback & output, bool bForceRender, bool bSaveDefault) {
assert(false); // no you are not allowed to use this element !
return 0;
}
filepos_t KaxFileReferral::RenderData(IOCallback & output, bool bForceRender, bool bSaveDefault) {
assert(false); // no you are not allowed to use this element !
return 0;
}
END_LIBMATROSKA_NAMESPACE

54
libmatroska/src/KaxTracks.cpp Normal file
View File

@@ -0,0 +1,54 @@
/****************************************************************************
** libmatroska : parse Matroska files, see http://www.matroska.org/
**
** <file/class description>
**
** Copyright (C) 2002-2010 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.cpp 1202 2005-08-30 14:39:01Z robux4 $
\author Steve Lhomme <robux4 @ users.sf.net>
*/
#include "matroska/KaxTracks.h"
// sub elements
#include "matroska/KaxContexts.h"
#include "matroska/KaxDefines.h"
START_LIBMATROSKA_NAMESPACE
KaxTrackEntry::KaxTrackEntry(EBML_EXTRA_DEF)
:EbmlMaster(EBML_CLASS_SEMCONTEXT(KaxTrackEntry) EBML_DEF_SEP EBML_EXTRA_CALL)
,bGlobalTimecodeScaleIsSet(false)
{}
void KaxTrackEntry::EnableLacing(bool bEnable)
{
KaxTrackFlagLacing & myLacing = GetChild<KaxTrackFlagLacing>(*this);
*(static_cast<EbmlUInteger *>(&myLacing)) = bEnable ? 1 : 0;
}
END_LIBMATROSKA_NAMESPACE

43
libmatroska/src/KaxVersion.cpp Normal file
View File

@@ -0,0 +1,43 @@
/****************************************************************************
** libmatroska : parse Matroska files, see http://www.matroska.org/
**
** <file/class description>
**
** Copyright (C) 2002-2010 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.cpp 640 2004-07-09 21:05:36Z mosu $
\author Steve Lhomme <robux4 @ users.sf.net>
*/
#include "matroska/KaxVersion.h"
START_LIBMATROSKA_NAMESPACE
const std::string KaxCodeVersion = "1.3.0";
const std::string KaxCodeDate = __TIMESTAMP__;
END_LIBMATROSKA_NAMESPACE

10
libmatroska/test/Makefile Normal file
View File

@@ -0,0 +1,10 @@
## libmatroska Makefile
## (c) 2002 Steve Lhomme
## This software is licensed under the LGPL, see LGPL.txt
all: endian
echo "Making endianess tests"
(cd endian; make)
clean:
echo "Cleaning all tests"
(cd endian; make $@)

62
libmatroska/test/ebml/Makefile Normal file
View File

@@ -0,0 +1,62 @@
# 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 -I../../src/
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=test00
# 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))
OBJ=$(objects) test00.o
DEPENDFLAGS = ${CXXFLAGS} ${INCLUDE}
# Build rules
%.o: %$(EXTENSION)
$(CXX) $(CXXFLAGS) $(INCLUDE) -o $@ $<
$(PROGRAM): $(OBJ)
# $(AR) $@ $(objects)
# $(RANLIB) $@
$(LD) $(LDFLAGS) -o $@ $^ $(LIBS)
${LD} -o $@ ${LDFLAGS} ${OBJ} ${LIBS} ${EXTRA_LIBS}
clean:
rm -f $(OBJ)
rm -f $(dependencies)
rm -f $(PROGRAM)
rm -f CORE
# what are the source dependencies
depend: $(sources)
$(DEPEND) $(DEPENDFLAGS) $(sources)
# DO NOT DELETE

13
libmatroska/test/ebml/ebml.proj Normal file
View File

@@ -0,0 +1,13 @@
#include "*/*.proj"
CON ebml-test00
{
USE matroska
SOURCE test00.cpp
}
CON ebml-test0
{
USE matroska
SOURCE test0.cpp
}

304
libmatroska/test/ebml/test0.cpp Normal file
View File

@@ -0,0 +1,304 @@
/****************************************************************************
** 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 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 file may be distributed and/or modified under the terms of the
** GNU General Public License version 2 as published by the Free Software
** Foundation and appearing in the file LICENSE.GPL included in the
** packaging of this file.
**
** 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.
** See http://www.matroska.org/license/gpl/ for GPL licensing information.
**
** Contact license@matroska.org if any conditions of this licensing are
** not clear to you.
**
**********************************************************************/
/*!
\file
\version \$Id$
\author Steve Lhomme <robux4 @ users.sf.net>
Test the EBML write possibilities
\see http://www.cl.cam.ac.uk/~mgk25/unicode.html
\see http://www-106.ibm.com/developerworks/unicode/library/u-encode.html
*/
#include <stdio.h>
#include "ebml/StdIOCallback.h"
#include "ebml/EbmlUInteger.h"
#include "ebml/EbmlSInteger.h"
#include "ebml/EbmlBinary.h"
#include "ebml/EbmlString.h"
#include "ebml/EbmlUnicodeString.h"
#include "ebml/EbmlMaster.h"
#include "ebml/EbmlFloat.h"
#include "ebml/EbmlStream.h"
#include "ebml/StdIOCallback.h"
using namespace LIBEBML_NAMESPACE;
const char RW_FILENAME[] = "test.kax";
enum SemanticType {
EBML_U_INTEGER,
EBML_S_INTEGER,
EBML_BINARY,
EBML_STRING,
EBML_STRING_UNICODE,
EBML_FLOAT,
EBML_MASTER,
};
typedef binary EBMLID[4];
struct Semantic {
EBMLID Id;
int IdLength;
SemanticType Type;
};
struct Semantic SemanticList[] =
{
{{0x42, 0x45}, 2, EBML_U_INTEGER},
{{0x1A, 0x45, 0x33, 0x80}, 4, EBML_S_INTEGER},
{{0x87}, 1, EBML_BINARY},
{{0x22, 0x33, 0x44}, 3, EBML_STRING},
{{0x44, 0x33}, 2, EBML_STRING_UNICODE},
{{0x50, 0x50}, 2, EBML_FLOAT},
{{0x36, 0x47, 0x58}, 3, EBML_MASTER},
};
/*!
\test Some test on the Cluster use
\todo render the Cluster to a file
*/
int main(void)
{
StdIOCallback Ebml_file(RW_FILENAME, ::MODE_CREATE);
///// Writing test
///////////////////////////////
// Unsigned integer
///////////////////////////////
EbmlUInteger testUInt(4); // supposed to hold a 4*8 bits value
testUInt.SetID(SemanticList[0].Id, SemanticList[0].IdLength);
testUInt = 52;
testUInt.SetSizeLength(3); // size should be coded on at least 3 octets
testUInt.Render(Ebml_file);
///////////////////////////////
// Signed integer
///////////////////////////////
EbmlSInteger testSInt(4); // supposed to hold a 4*8 bits value
testSInt.SetID(SemanticList[1].Id, SemanticList[1].IdLength);
testSInt = -20;
testSInt.Render(Ebml_file);
///////////////////////////////
// Binary data
///////////////////////////////
const int BINARY_SIZE=3000;
binary *bin = new binary[BINARY_SIZE];
memset(bin, 0x61, BINARY_SIZE);
EbmlBinary testBin;
testBin.SetID(SemanticList[2].Id, SemanticList[2].IdLength);
testBin.SetBuffer(bin, BINARY_SIZE);
testBin.Render(Ebml_file);
///////////////////////////////
// String data
///////////////////////////////
std::string aString = "Hello World !";
EbmlString testStr(200);
testStr.SetID(SemanticList[3].Id, SemanticList[3].IdLength);
testStr = aString;
testStr.Render(Ebml_file);
///////////////////////////////
// Master element
///////////////////////////////
EbmlMaster testMaster;
testMaster.SetID(SemanticList[6].Id, SemanticList[6].IdLength);
testMaster.PushElement(testStr);
testMaster.PushElement(testUInt);
testMaster.Render(Ebml_file);
///////////////////////////////
// Unicode String data
///////////////////////////////
UTFstring bString = L"St<EFBFBD>ve Lhomm<6D>";
EbmlUnicodeString testUStr(200);
testUStr.SetID(SemanticList[4].Id, SemanticList[4].IdLength);
testUStr = bString;
testUStr.Render(Ebml_file);
///////////////////////////////
// Float data
///////////////////////////////
EbmlFloat testFloat(EbmlFloat::FLOAT_32);
testFloat.SetID(SemanticList[5].Id, SemanticList[5].IdLength);
testFloat.SetPrecision(EbmlFloat::FLOAT_32);
testFloat = 1.01234567890123456;
testFloat.Render(Ebml_file);
testFloat.SetPrecision(EbmlFloat::FLOAT_64);
testFloat = -1.01234567890123456L;
testFloat.Render(Ebml_file);
Ebml_file.close();
///// Reading test
StdIOCallback Ebml_Wfile(RW_FILENAME, ::MODE_READ);
// example 1 skip all the elements found
EbmlStream aStream(Ebml_Wfile);
EbmlElement * ElementLevel0;
// read the data until a possible element is found (valid ID + size combination)
ElementLevel0 = aStream.FindNextID(0xFFFFFFFFL, false);
printf("Read EBML elements & skip data\n");
while (ElementLevel0 != NULL)
{
printf("ID : ");
for (int i=0; i<ElementLevel0->GetIDLength(); i++)
{
printf("[%02X]", ElementLevel0->GetID()[i]);
}
printf("\n");
ElementLevel0->SkipData(Ebml_Wfile);
if (ElementLevel0 != NULL)
delete ElementLevel0;
ElementLevel0 = aStream.FindNextID(0xFFFFFFFFL, false);
}
// example 2 evaluation of all elements found
EbmlStream bStream(Ebml_Wfile);
EbmlElement * EvaledElementLevel0;
// EbmlElement * EvaledElementLevel1;
// reset the stream to the beggining
Ebml_Wfile.setFilePointer(0);
// list of all IDs and their semantic type
// std::list<struct Semantic> SemanticList;
// SemanticList.push_back();
ElementLevel0 = aStream.FindNextID(0xFFFFFFFFL, false);
printf("Read EBML elements & evaluate data\n");
while (ElementLevel0 != NULL)
{
int i;
printf("ID : ");
for (i=0; i<ElementLevel0->GetIDLength(); i++)
{
printf("[%02X]", ElementLevel0->GetID()[i]);
}
// check if the element is known
for (i=0; i<countof(SemanticList); i++) {
if (ElementLevel0->GetIDLength() != SemanticList[i].IdLength)
continue;
if (memcmp(SemanticList[i].Id, ElementLevel0->GetID(), SemanticList[i].IdLength) == 0)
break;
}
/// \todo check if it is known in the context
// handle the data inside the element
if (i < countof(SemanticList)) {
switch (SemanticList[i].Type)
{
case EBML_U_INTEGER:
EvaledElementLevel0 = new EbmlUInteger(*ElementLevel0);
break;
case EBML_S_INTEGER:
EvaledElementLevel0 = new EbmlSInteger(*ElementLevel0);
break;
case EBML_BINARY:
EvaledElementLevel0 = new EbmlBinary(*ElementLevel0);
break;
case EBML_STRING:
EvaledElementLevel0 = new EbmlString(*ElementLevel0);
break;
case EBML_STRING_UNICODE:
EvaledElementLevel0 = new EbmlUnicodeString(*ElementLevel0);
break;
case EBML_FLOAT:
EvaledElementLevel0 = new EbmlFloat(*ElementLevel0);
break;
case EBML_MASTER:
EvaledElementLevel0 = new EbmlMaster(*ElementLevel0);
break;
}
EvaledElementLevel0->ReadData(Ebml_Wfile);
switch (SemanticList[i].Type)
{
case EBML_U_INTEGER:
printf(" : %d", uint32(*(EbmlUInteger*)EvaledElementLevel0));
break;
case EBML_S_INTEGER:
printf(" : %d", int32(*(EbmlSInteger*)EvaledElementLevel0));
break;
case EBML_BINARY:
printf(" : binary data, size = %ld", (*(EbmlBinary*)EvaledElementLevel0).GetSize());
printf(" [%02X]", binary(*(EbmlBinary*)EvaledElementLevel0));
break;
case EBML_STRING:
printf(" : %s", std::string(*(EbmlString*)EvaledElementLevel0).data());
break;
case EBML_STRING_UNICODE:
printf(" : (wide chars) %ls", UTFstring(*(EbmlUnicodeString*)EvaledElementLevel0).data());
break;
case EBML_FLOAT:
printf(" : %f / %.15lf", float(*(EbmlFloat*)EvaledElementLevel0), double(*(EbmlFloat*)EvaledElementLevel0));
break;
case EBML_MASTER:
printf(" : unsupported format 'Master'");
break;
}
delete EvaledElementLevel0;
} else {
ElementLevel0->SkipData(Ebml_Wfile);
}
if (ElementLevel0 != NULL)
delete ElementLevel0;
printf("\n");
ElementLevel0 = aStream.FindNextID(0xFFFFFFFFL, false);
}
Ebml_Wfile.close();
return 0;
}

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