+++ /dev/null
-aclocal.m4
-autom4te.cache
-config.guess
-config.h*
-config.log
-config.status
-config.sub
-configure
-install-sh
-libtool
-ltmain.sh
-missing
-mkinstalldirs
-stamp-h
-stamp-h.in
-stamp-h1
-
-/m4
-
-*.la
-*.lo
-*.o
-*.swp
-*~
-.deps
-.libs
-Makefile
-Makefile.in
-
-build-aux
-src/codecanalyzer
+++ /dev/null
-Sreerenj Balachandran <sreerenj.balachandran@intel.com>
- <sreerenjb@gnome.org>
+++ /dev/null
- GNU LIBRARY GENERAL PUBLIC LICENSE
- Version 2, June 1991
-
- Copyright (C) 1991 Free Software Foundation, Inc.
- 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, 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 library GPL. It is
- numbered 2 because it goes with version 2 of the ordinary GPL.]
-
- 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 Library General Public License, applies to some
-specially designated Free Software Foundation software, and to any
-other libraries whose authors decide to use it. You can use it for
-your libraries, too.
-
- When we speak of free software, we are referring to freedom, 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 or use pieces of it
-in new free programs; and that you know you can do these things.
-
- To protect your rights, we need to make restrictions that forbid
-anyone to deny you these rights or to ask you to surrender the 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 a program 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.
-
- Our method of protecting your rights has two steps: (1) copyright
-the library, and (2) offer you this license which gives you legal
-permission to copy, distribute and/or modify the library.
-
- Also, for each distributor's protection, we want to make certain
-that everyone understands that there is no warranty for this free
-library. If the library is modified by someone else and passed on, we
-want its recipients to know that what they have is not the original
-version, so that any problems introduced by others will not reflect on
-the original authors' reputations.
-\f
- Finally, any free program is threatened constantly by software
-patents. We wish to avoid the danger that companies distributing free
-software will individually obtain patent licenses, thus in effect
-transforming the program into proprietary software. To prevent this,
-we have made it clear that any patent must be licensed for everyone's
-free use or not licensed at all.
-
- Most GNU software, including some libraries, is covered by the ordinary
-GNU General Public License, which was designed for utility programs. This
-license, the GNU Library General Public License, applies to certain
-designated libraries. This license is quite different from the ordinary
-one; be sure to read it in full, and don't assume that anything in it is
-the same as in the ordinary license.
-
- The reason we have a separate public license for some libraries is that
-they blur the distinction we usually make between modifying or adding to a
-program and simply using it. Linking a program with a library, without
-changing the library, is in some sense simply using the library, and is
-analogous to running a utility program or application program. However, in
-a textual and legal sense, the linked executable is a combined work, a
-derivative of the original library, and the ordinary General Public License
-treats it as such.
-
- Because of this blurred distinction, using the ordinary General
-Public License for libraries did not effectively promote software
-sharing, because most developers did not use the libraries. We
-concluded that weaker conditions might promote sharing better.
-
- However, unrestricted linking of non-free programs would deprive the
-users of those programs of all benefit from the free status of the
-libraries themselves. This Library General Public License is intended to
-permit developers of non-free programs to use free libraries, while
-preserving your freedom as a user of such programs to change the free
-libraries that are incorporated in them. (We have not seen how to achieve
-this as regards changes in header files, but we have achieved it as regards
-changes in the actual functions of the Library.) The hope is that this
-will lead to faster development of free libraries.
-
- 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, while the latter only
-works together with the library.
-
- Note that it is possible for a library to be covered by the ordinary
-General Public License rather than by this special one.
-\f
- GNU LIBRARY GENERAL PUBLIC LICENSE
- TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
-
- 0. This License Agreement applies to any software library which
-contains a notice placed by the copyright holder or other authorized
-party saying it may be distributed under the terms of this Library
-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.
-\f
- 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.
-\f
- 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.
-\f
- 6. As an exception to the Sections above, you may also compile 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) 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.
-
- c) 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.
-
- d) 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 source code 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.
-\f
- 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 to
-this License.
-\f
- 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 Library 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.
-\f
- 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
-\f
- Appendix: 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 Library General Public
- License as published by the Free Software Foundation; either
- version 2 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
- Library General Public License for more details.
-
- You should have received a copy of the GNU Library General Public
- License along with this library; if not, write to the Free
- Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, 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!
+++ /dev/null
-ACLOCAL_AMFLAGS = -I m4 ${ACLOCAL_FLAGS}
-
-AUTOMAKE_OPTIONS = foreign
-
-SUBDIRS = src data
-
-# Extra clean files so that maintainer-clean removes *everything*
-MAINTAINERCLEANFILES = \
- aclocal.m4 compile config.guess config.sub \
- configure depcomp install-sh ltmain.sh \
- Makefile.in missing config.h.in
+++ /dev/null
-codecanalyzer
-=============
-
-An analyzer for doing in-depth analysis on compressed media.
-It is built on top of gstreamer, gtk+ and libxml2.
-The goal of the codecanalyzer is to support the follwoing
-features:
-
--- unpack the elementary stream from a container
--- do packetization for the non-packetized stream
--- Parse all the syntax elements from the elementary video stream
--- A simple UI to navigate through all the headers of each frame separately
--- Users would be able to analyze the media files residing in the local machine
-and the remote streams via http or rtp.
-
-Supported codecs:
--- mpeg2
+++ /dev/null
-#!/bin/sh
-
-PROJECT="codecanalyzer"
-
-test -n "$srcdir" || srcdir=`dirname "$0"`
-test -n "$srcdir" || srcdir=.
-
-if ! test -f "$srcdir/configure.ac"; then
- echo "Failed to find the top-level $PROJECT directory"
- exit 1
-fi
-
-olddir="`pwd`"
-cd "$srcdir"
-
-mkdir -p m4
-
-AUTORECONF=`which autoreconf`
-if test -z "$AUTORECONF"; then
- echo "*** No autoreconf found ***"
- exit 1
-else
- autoreconf -v --install || exit $?
-fi
-
-cd "$olddir"
-
-if test -z "$NOCONFIGURE"; then
- $srcdir/configure "$@" && echo "Now type 'make' to compile $PROJECT."
-fi
+++ /dev/null
-AC_PREREQ([2.66])
-AC_INIT([codecanalyzer], [0.1.0],
- [sreerenj.balachandran@intel.com])
-
-AC_CONFIG_HEADERS([config.h])
-AC_CONFIG_SRCDIR([Makefile.am])
-AC_CONFIG_MACRO_DIR([m4])
-AC_CONFIG_AUX_DIR([build-aux])
-
-AC_CANONICAL_TARGET
-
-AM_INIT_AUTOMAKE([1.11 no-dist-gzip dist-xz tar-ustar])
-
-m4_ifdef([AM_SILENT_RULES],[AM_SILENT_RULES([yes])])
-
-dnl Check for tools
-AC_PROG_CC
-AM_PROG_CC_C_O
-
-dnl Initialize libtool
-LT_PREREQ([2.2])
-LT_INIT
-
-# codecanalyzer packag versions
-m4_define([codecanalyzer_major_version], [0])
-m4_define([codecanalyzer_minor_version], [1])
-m4_define([codecanalyzer_build_version], [0])
-
-dnl Check for glib
-PKG_CHECK_MODULES([GLIB], [glib-2.0 >= 2.32.0])
-PKG_CHECK_MODULES([GMODULE_EXPORT], [gmodule-2.0 >= 2.32.0])
-PKG_CHECK_MODULES([GTK], [gtk+-3.0 >= 3.4.2])
-PKG_CHECK_MODULES([GST], [gstreamer-1.0 >= 1.3.1])
-PKG_CHECK_MODULES([GST_BASE], [gstreamer-base-1.0 >= 1.3.1])
-PKG_CHECK_MODULES([GST_PLUGINS_BASE], [gstreamer-plugins-base-1.0 >= 1.3.1])
-PKG_CHECK_MODULES([GST_VIDEO], [gstreamer-video-1.0 >= 1.3.1])
-PKG_CHECK_MODULES([GST_PBUTILS], [gstreamer-pbutils-1.0 >= 1.3.1])
-PKG_CHECK_MODULES([GST_CODEC_PARSERS], [gstreamer-plugins-bad-1.0 >= 1.3.1])
-PKG_CHECK_MODULES([LIBXML2], [libxml-2.0 >= 2.7.8])
-
-GST_ALL_LDFLAGS="-no-undefined"
-AC_SUBST(GST_ALL_LDFLAGS)
-
-AC_SUBST(GLIB_CFLAGS)
-AC_SUBST(GLIB_LIBS)
-AC_SUBST(GMODULE_EXPORT_CFLAGS)
-AC_SUBST(GMODULE_EXPORT_LIBS)
-AC_SUBST(GTK_CFLAGS)
-AC_SUBST(GTK_LIBS)
-AC_SUBST(GST_CFLAGS)
-AC_SUBST(GST_LIBS)
-AC_SUBST(GST_BASE_CFLAGS)
-AC_SUBST(GST_BASE_LIBS)
-AC_SUBST(GST_PLUGINS_CFLAGS)
-AC_SUBST(GST_PLUGINS_LIBS)
-AC_SUBST(GST_VIDEO_CFLAGS)
-AC_SUBST(GST_VIDEO_LIBS)
-AC_SUBST(GST_PBUTILS_CFLAGS)
-AC_SUBST(GST_PBUTILS_LIBS)
-AC_SUBST(GST_CODEC_PARSERS_LIBS)
-AC_SUBST(GST_CODEC_PARSERS_CFLAGS)
-AC_SUBST(LIBXML2_CFLAGS)
-AC_SUBST(LIBXML2_LIBS)
-
-AC_CONFIG_FILES([Makefile
- src/Makefile
- src/plugins/Makefile
- src/plugins/gst/Makefile
- src/plugins/gst/analyzersink/Makefile
- data/Makefile
- data/ui/Makefile
- data/pixmaps/Makefile
- ])
-AC_OUTPUT
-
-echo
-echo $PACKAGE $VERSION
-echo " configure complete, now type make and make install "
-echo " ===================================================== "
+++ /dev/null
-SUBDIRS = pixmaps ui
-
-# Extra clean files so that maintainer-clean removes *everything*
-MAINTAINERCLEANFILES = Makefile.in
+++ /dev/null
-pixmapdir = $(datadir)/codecanalyzer/pixmaps
-
-pixmap_DATA = \
- frame-thumbnail.png \
- codecanalyzer-logo.png
-
-EXTRA_DIST = \
- $(pixmap_DATA)
+++ /dev/null
- GNU LIBRARY GENERAL PUBLIC LICENSE
- Version 2, June 1991
-
- Copyright (C) 1991 Free Software Foundation, Inc.
- 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, 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 library GPL. It is
- numbered 2 because it goes with version 2 of the ordinary GPL.]
-
- 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 Library General Public License, applies to some
-specially designated Free Software Foundation software, and to any
-other libraries whose authors decide to use it. You can use it for
-your libraries, too.
-
- When we speak of free software, we are referring to freedom, 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 or use pieces of it
-in new free programs; and that you know you can do these things.
-
- To protect your rights, we need to make restrictions that forbid
-anyone to deny you these rights or to ask you to surrender the 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 a program 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.
-
- Our method of protecting your rights has two steps: (1) copyright
-the library, and (2) offer you this license which gives you legal
-permission to copy, distribute and/or modify the library.
-
- Also, for each distributor's protection, we want to make certain
-that everyone understands that there is no warranty for this free
-library. If the library is modified by someone else and passed on, we
-want its recipients to know that what they have is not the original
-version, so that any problems introduced by others will not reflect on
-the original authors' reputations.
-
- Finally, any free program is threatened constantly by software
-patents. We wish to avoid the danger that companies distributing free
-software will individually obtain patent licenses, thus in effect
-transforming the program into proprietary software. To prevent this,
-we have made it clear that any patent must be licensed for everyone's
-free use or not licensed at all.
-
- Most GNU software, including some libraries, is covered by the ordinary
-GNU General Public License, which was designed for utility programs. This
-license, the GNU Library General Public License, applies to certain
-designated libraries. This license is quite different from the ordinary
-one; be sure to read it in full, and don't assume that anything in it is
-the same as in the ordinary license.
-
- The reason we have a separate public license for some libraries is that
-they blur the distinction we usually make between modifying or adding to a
-program and simply using it. Linking a program with a library, without
-changing the library, is in some sense simply using the library, and is
-analogous to running a utility program or application program. However, in
-a textual and legal sense, the linked executable is a combined work, a
-derivative of the original library, and the ordinary General Public License
-treats it as such.
-
- Because of this blurred distinction, using the ordinary General
-Public License for libraries did not effectively promote software
-sharing, because most developers did not use the libraries. We
-concluded that weaker conditions might promote sharing better.
-
- However, unrestricted linking of non-free programs would deprive the
-users of those programs of all benefit from the free status of the
-libraries themselves. This Library General Public License is intended to
-permit developers of non-free programs to use free libraries, while
-preserving your freedom as a user of such programs to change the free
-libraries that are incorporated in them. (We have not seen how to achieve
-this as regards changes in header files, but we have achieved it as regards
-changes in the actual functions of the Library.) The hope is that this
-will lead to faster development of free libraries.
-
- 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, while the latter only
-works together with the library.
-
- Note that it is possible for a library to be covered by the ordinary
-General Public License rather than by this special one.
-
- GNU LIBRARY GENERAL PUBLIC LICENSE
- TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
-
- 0. This License Agreement applies to any software library which
-contains a notice placed by the copyright holder or other authorized
-party saying it may be distributed under the terms of this Library
-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 compile 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) 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.
-
- c) 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.
-
- d) 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 source code 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 to
-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 Library 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
-
- Appendix: 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 Library General Public
- License as published by the Free Software Foundation; either
- version 2 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
- Library General Public License for more details.
-
- You should have received a copy of the GNU Library General Public
- License along with this library; if not, write to the Free
- Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, 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!
+++ /dev/null
-uidir = $(datadir)/codecanalyzer/ui
-
-ui_DATA = \
- mainwindow.xml menu.xml LICENSE.txt
-
-EXTRA_DIST = $(ui_DATA)
+++ /dev/null
-<?xml version="1.0" encoding="UTF-8"?>
-<interface>
- <!-- interface-requires gtk+ 3.0 -->
- <object class="GtkWindow" id="Codecanalyzer-main-window">
- <property name="title">CodecAnalyzer</property>
- <property name="can_focus">False</property>
- <property name="default_width">800</property>
- <property name="default_height">600</property>
- <property name="window-position">GTK_WIN_POS_CENTER</property>
- <signal name="destroy" handler="callback_main_window_destroy"/>
- <child>
- <object class="GtkBox" id="MainVBox">
- <property name="visible">False</property>
- <property name="can_focus">False</property>
- <property name="orientation">vertical</property>
- <property name="spacing">5</property>
- <property name="homogeneous">False</property>
- <child>
- <object class="GtkBox" id="menubar_vbox">
- <property name="visible">False</property>
- <property name="can_focus">False</property>
- <property name="orientation">vertical</property>
- </object>
- <packing>
- <property name="expand">False</property>
- <property name="fill">False</property>
- </packing>
- </child>
- <child>
- <object class="GtkBox" id="child_vbox1">
- <property name="visible">True</property>
- <property name="can_focus">False</property>
- <property name="orientation">vertical</property>
- <property name="spacing">5</property>
-
- <child>
- <object class="GtkBox" id="child_vbox1_1">
- <property name="visible">True</property>
- <property name="can_focus">False</property>
- <property name="orientation">vertical</property>
-
- <child>
- <object class="GtkBox" id="child_hbox_in_vbox1_1">
- <property name="visible">True</property>
- <property name="spacing">5</property>
- <child>
- <object class="GtkLabel" id="hspace1">
- <property name="visible">True</property>
- <property name="can_focus">False</property>
- </object>
- <packing>
- <property name="expand">True</property>
- <property name="fill">False</property>
- </packing>
- </child>
- <child>
- <object class="GtkLabel" id="ChooseFileLabel">
- <property name="visible">True</property>
- <property name="can_focus">False</property>
- <property name="xalign">0</property>
- <property name="label"><b>Open the Stream file:</b></property>
- <property name="use_markup">True</property>
- </object>
- <packing>
- <property name="expand">False</property>
- <property name="fill">False</property>
- </packing>
- </child>
- <child>
- <object class="GtkFileChooserButton" id="StreamChooser">
- <property name="title">Select a Stream</property>
- <property name="visible">True</property>
- <property name="can_focus">False</property>
- <signal name="file-set" handler="callback_stream_chooser_new_stream" swapped="no"/>
- </object>
- <packing>
- <property name="expand">False</property>
- <property name="fill">False</property>
- </packing>
- </child>
- <child>
- <object class="GtkLabel" id="hspace2">
- <property name="visible">True</property>
- <property name="can_focus">False</property>
- </object>
- <packing>
- <property name="expand">True</property>
- <property name="fill">False</property>
- </packing>
- </child>
- <child>
- <object class="GtkLabel" id="ChooseNumFrames">
- <property name="visible">True</property>
- <property name="can_focus">False</property>
- <property name="xalign">0</property>
- <property name="label"><b>Number of frames to Analyze:</b></property>
- <property name="use_markup">True</property>
- </object>
- <packing>
- <property name="expand">False</property>
- <property name="fill">False</property>
- </packing>
- </child>
- <child>
- <object class="GtkEntry" id="NumFrameEntryButton">
- <property name="visibility">True</property>
- <property name="visible">True</property>
- <property name="can_focus">True</property>
- </object>
- <packing>
- <property name="expand">False</property>
- <property name="fill">False</property>
- </packing>
- </child>
- <child>
- <object class="GtkLabel" id="hspace3">
- <property name="visible">True</property>
- <property name="can_focus">False</property>
- </object>
- <packing>
- <property name="expand">True</property>
- <property name="fill">False</property>
- </packing>
- </child>
- </object>
- </child>
- </object>
- <packing>
- <property name="expand">False</property>
- <property name="fill">False</property>
- </packing>
- </child>
- <child>
- <object class="GtkBox" id="child_vbox1_2">
- <property name="visible">True</property>
- <property name="can_focus">False</property>
- <property name="orientation">vertical</property>
-
- <child>
- <object class="GtkBox" id="child_hbox_in_vbox1_2">
- <property name="visible">True</property>
- <property name="spacing">5</property>
- <child>
- <object class="GtkLabel" id="hspace4">
- <property name="visible">True</property>
- <property name="can_focus">False</property>
- </object>
- <packing>
- <property name="expand">True</property>
- <property name="fill">False</property>
- </packing>
- </child>
- <child>
- <object class="GtkButton" id="AnalyzeButton">
- <property name="label" translatable="yes">Analyze</property>
- <property name="visible">True</property>
- <property name="can_focus">True</property>
- <property name="receives_default">True</property>
- <property name="use_underline">True</property>
- <property name="sensitive">False</property>
- <signal name="clicked" handler="callback_analyzer_button_analyze" swapped="no"/>
- </object>
- <packing>
- <property name="expand">False</property>
- <property name="fill">False</property>
- </packing>
- </child>
- <child>
- <object class="GtkButton" id="CancelButton">
- <property name="label">Cancel</property>
- <property name="visible">True</property>
- <property name="can_focus">True</property>
- <property name="receives_default">True</property>
- <property name="use_underline">True</property>
- <property name="sensitive">False</property>
- <signal name="clicked" handler="callback_cancel_button_cancel" swapped="no"/>
- </object>
- <packing>
- <property name="expand">False</property>
- <property name="fill">False</property>
- </packing>
- </child>
- <child>
- <object class="GtkLabel" id="hspace5">
- <property name="visible">True</property>
- <property name="can_focus">False</property>
- </object>
- <packing>
- <property name="expand">True</property>
- <property name="fill">False</property>
- </packing>
- </child>
-
- </object>
- </child>
-
- </object>
- <packing>
- <property name="expand">False</property>
- <property name="fill">False</property>
- </packing>
- </child>
-
- </object>
- <packing>
- <property name="expand">False</property>
- </packing>
- </child>
-
- <child>
- <object class="GtkBox" id="child_vbox2">
- <property name="visible">True</property>
- <property name="can_focus">False</property>
- <property name="orientation">vertical</property>
- <child>
- <object class="GtkScrolledWindow" id="thumbnails_scrolled_window">
- <property name="visible">True</property>
- <property name="can_focus">True</property>
- <property name="hscrollbar_policy">automatic</property>
- <property name="vscrollbar_policy">never</property>
- <property name="shadow-type">GTK_SHADOW_IN</property>
- <property name="height_request">20</property>
- <child>
- <object class="GtkViewport" id="thumbnails_view_port">
- <property name="visible">True</property>
- <property name="can_focus">True</property>
- <child>
- <object class="GtkBox" id="hbox1_in_vbox2">
- <property name="visible">True</property>
- <property name="can_focus">False</property>
- </object>
- </child>
- </object>
- </child>
-
- </object>
- </child>
- </object>
- <packing>
- <property name="expand">False</property>
- </packing>
- </child>
-
- <child>
- <object class="GtkBox" id="child_vbox3">
- <property name="visible">True</property>
- <property name="can_focus">True</property>
- <property name="orientation">vertical</property>
- <property name="border_width">5</property>
- <property name="sensitive">False</property>
-
- <child>
- <object class="GtkBox" id="child_hbox_in_vbox3">
- <property name="visible">True</property>
- <property name="can_focus">True</property>
- <property name="spacing">15</property>
-
- <child>
- <object class="GtkFrame" id="general_info_frame">
- <property name="visible">True</property>
- <property name="can_focus">False</property>
-
- <child>
- <object class="GtkBox" id="general_info_vbox">
- <property name="visible">True</property>
- <property name="can_focus">False</property>
- <property name="orientation">vertical</property>
- <property name="spacing">5</property>
-
- <child>
- <object class="GtkLabel" id="general_info_header">
- <property name="visible">True</property>
- <property name="can_focus">False</property>
- <property name="label">General Stream Info</property>
- </object>
- <packing>
- <property name="expand">False</property>
- <property name="fill">False</property>
- </packing>
- </child>
-
- <child>
- <object class="GtkTreeView" id="general_info_treeview">
- <property name="visible">True</property>
- <property name="can_focus">False</property>
- </object>
- <packing>
- <property name="expand">True</property>
- <property name="fill">True</property>
- </packing>
- </child>
-
- </object>
- </child>
-
- </object>
- <packing>
- <property name="expand">False</property>
- <property name="fill">False</property>
- </packing>
- </child> <!-- gerneral_info_frame -->
-
- <child>
- <object class="GtkFrame" id="parsed_info_frame">
- <property name="visible">True</property>
- <property name="can_focus">False</property>
- <property name="label_xalign">0.5</property>
- <property name="label_yalign">1.0</property>
-
- <child>
- <object class="GtkBox" id="parsed_info_hbox">
- <property name="visible">True</property>
- <property name="can_focus">True</property>
-
- <child>
- <object class="GtkBox" id="parsed_info_button_box">
- <property name="visible">True</property>
- <property name="can_focus">True</property>
- <property name="orientation">vertical</property>
- </object>
- <packing>
- <property name="expand">False</property>
- <property name="fill">False</property>
- </packing>
- </child>
-
- <child>
- <object class="GtkBox" id="parsed_info_vbox">
- <property name="visible">True</property>
- <property name="can_focus">True</property>
- <property name="orientation">vertical</property>
- </object>
- </child>
- </object>
- </child>
-
- </object>
- <packing>
- <property name="expand">True</property>
- <property name="fill">True</property>
- </packing>
- </child> <!--parsed_info_frame -->
-
- </object>
- </child> <!-- hbox in vbox3 -->
-
- </object>
- <packing>
- <property name="expand">True</property>
- <property name="fill">True</property>
- </packing>
- </child> <!-- child_vbox3 -->
-
- </object>
- </child>
-
- </object> <!-- MainWindow -->
-</interface>
+++ /dev/null
-<ui>
- <menubar name="MainMenu">
- <menu name="MediaMenu" action="MediaMenuAction">
- <menuitem name="Quit" action="QuitAction" />
- <placeholder name="MediaMenuAdditions" />
- </menu>
- <menu name="HelpMenu" action="HelpMenuAction">
- <menuitem name="Help" action="HelpAction"/>
- <menuitem name="About" action="AboutAction"/>
- </menu>
- </menubar>
-</ui>
+++ /dev/null
-SUBDIRS = plugins
-
-bin_PROGRAMS = codecanalyzer
-
-codecanalyzer_SOURCES = \
- gst_analyzer.c \
- xml_parse.c \
- codecanalyzer.c \
- $(NULL)
-
-noinst_HEADERS = gst_analyzer.h xml_parse.h
-
-codecanalyzer_CFLAGS = \
- $(GLIB_CFLAGS) \
- $(GMODULE_EXPORT_CFLAGS) \
- $(GTK_CFLAGS) \
- $(GST_CFLAGS) \
- $(GST_PBUTILS_CFLAGS) \
- $(LIBXML2_CFLAGS) \
- -I$(top_builddir)/src/plugins/gst/analyzersink \
- -I$(top_srcdir)/src/plugins/gst/analyzersink \
- -DDATADIR=\"$(datadir)\" \
- $(NULL)
-
-codecanalyzer_LDADD = \
- $(GLIB_LIBS) \
- $(GMODULE_EXPORT_LIBS) \
- $(GTK_LIBS) \
- $(GST_LIBS) \
- $(GST_PBUTILS_LIBS) \
- $(top_builddir)/src/plugins/gst/analyzersink/libcodecanalyzer-gst-analyzersink.la \
- $(LIBXML2_LIBS) \
- $(NULL)
-
-codecanalyzer_LDFLAGS = \
- $(GST_ALL_LDFLAGS) \
- $(NULL)
-
-
-# Extra clean files so that maintainer-clean removes *everything*
-MAINTAINERCLEANFILES = Makefile.in
+++ /dev/null
-/*
- * Copyright (c) 2013, Intel Corporation.
- * Author: Sreerenj Balachandran <sreerenj.balachandran@intel.com>
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Library General Public
- * License as published by the Free Software Foundation; either
- * version 2 of the License, or (at your option) any later version.
- *
- * This program is distributed in the hope 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 program; if not, write to the Free Software Foundation, Inc.,
- * 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.
- *
- */
-/**
- * CodecAnalyzer is an analyzer for doing in-depth analysis
- * on compressed media which is built on top of gstreamer, gtk+ and
- * libxml2. It is capable of parsing all the syntax elements
- * from an elementary video stream.
- */
-#include <stdio.h>
-#include <stdlib.h>
-#include <libxml/tree.h>
-#include <libxml/parser.h>
-#include <gtk/gtk.h>
-
-#include <glib.h>
-#include <glib/gprintf.h>
-
-#include "gst_analyzer.h"
-#include "xml_parse.h"
-#ifdef HAVE_CONFIG_H
-#include "config.h"
-#endif
-typedef struct
-{
-
- GtkBuilder *builder;
-
- GtkWidget *main_window;
- GtkWidget *main_vbox;
- GtkWidget *child_vbox1;
- GtkWidget *child_vbox2;
- GtkWidget *child_vbox3;
- GtkWidget *menubar_vbox;
- GtkWidget *stream_chooser;
- GtkWidget *numframes_chooser;
- GtkWidget *analyze_button;
- GtkWidget *cancel_button;
- GtkWidget *thumbnails_scroll_window;
- GtkWidget *thumbnails_view_port;
- GtkWidget *child_hbox_in_vbox1_2;
- GtkWidget *hbox1_in_vbox2;
- GtkWidget *general_info_frame;
- GtkWidget *general_info_vbox;
- GtkWidget *general_info_treeview;
- GtkWidget *parsed_info_frame;
- GtkWidget *parsed_info_hbox;
- GtkWidget *parsed_info_vbox;
- GtkWidget *parsed_info_button_box;
- GtkWidget *tree_view;
- GtkWidget *header_button;
- GtkWidget *slice_button;
- GtkWidget *hexval_button;
-
- GtkUIManager *menu_manager;
- GtkWidget *menubar;
-
- GHashTable *notebook_hash;
- GtkWidget *prev_page;
-
- guint analyze_idle_id;
-
- gchar *file_name;
- gchar *uri;
- gchar *analyzer_home;
- gchar *codec_name;
- gchar *current_xml;
- gchar *current_hex;
-
- gint num_frames;
- gint num_frames_analyzed;
-
-} AnalyzerUI;
-
-static AnalyzerUI *ui;
-GstAnalyzer *gst_analyzer;
-
-static char *treeview_headers[] = { "Field", "Value", "NumofBits" };
-
-enum
-{
- COLUMN_NAME,
- COLUMN_VALUE,
- COLUMN_NBITS,
- NUM_COLS
-};
-
-enum
-{
- GENERAL_INFO_LIST_NAME,
- GENERAL_INFO_LIST_VALUE,
- NUM_GENERAL_INFO_LIST
-};
-
-typedef enum
-{
- COMPONENTS_UNKNOWN,
- COMPONENTS_HEADERS_GENERAL,
- COMPONENTS_HEADERS_SLICE,
- COMPONENTS_HEXVAL
-} CodecComponents;
-
-
-GtkBuilder *
-make_builder (char *file_name)
-{
- GtkBuilder *builder;
-
- builder = gtk_builder_new ();
- g_assert (gtk_builder_add_from_file (builder, file_name, NULL) > 0);
-
- return builder;
-}
-
-GtkWidget *
-get_widget_from_builder (GtkBuilder * builder, char *widget_name)
-{
- GtkWidget *widget;
-
- widget = GTK_WIDGET (gtk_builder_get_object (builder, widget_name));
-
- return widget;
-}
-
-static void
-display_error_dialog (const char *msg)
-{
- GtkWidget *dialog;
- dialog = gtk_message_dialog_new (GTK_WINDOW (ui->main_window),
- GTK_DIALOG_DESTROY_WITH_PARENT,
- GTK_MESSAGE_ERROR, GTK_BUTTONS_CANCEL, "%s", msg);
- gtk_window_set_title (GTK_WINDOW (dialog), "Error");
- gtk_dialog_run (GTK_DIALOG (dialog));
- gtk_widget_destroy (dialog);
-}
-
-static void
-fill_tree_store (gpointer data, gpointer user_data)
-{
- AnalyzerNode *node;
- GtkTreeStore *treestore;
- GtkTreeIter toplevel, child;
- gchar *buf;
-
- node = (AnalyzerNode *) data;
- treestore = (GtkTreeStore *) user_data;
-
- gtk_tree_store_append (treestore, &toplevel, NULL);
- gtk_tree_store_set (treestore, &toplevel, COLUMN_NAME, node->field_name, -1);
- if (!node->is_matrix)
- gtk_tree_store_set (treestore, &toplevel, COLUMN_VALUE, node->value, -1);
- else {
- buf =
- g_strdup_printf ("[%s][%s] :click description", node->rows,
- node->columns);
- gtk_tree_store_set (treestore, &toplevel, COLUMN_VALUE, buf, -1);
- g_free (buf);
- }
- gtk_tree_store_set (treestore, &toplevel, COLUMN_NBITS, node->nbits, -1);
-
- gtk_tree_store_append (treestore, &child, &toplevel);
- if (node->is_matrix)
- gtk_tree_store_set (treestore, &child, COLUMN_NAME, node->value, -1);
- else
- gtk_tree_store_set (treestore, &child,
- COLUMN_NAME, "Description.. (TODO)", -1);
-}
-
-static GtkWidget *
-create_tree_view (void)
-{
- GtkTreeViewColumn *col;
- GtkCellRenderer *renderer;
- GtkWidget *view;
- guint i;
-
- view = gtk_tree_view_new ();
-
- for (i = 0; i < G_N_ELEMENTS (treeview_headers); i++) {
-
- col = gtk_tree_view_column_new ();
-
- gtk_tree_view_column_set_expand (GTK_TREE_VIEW_COLUMN (col), TRUE);
- gtk_tree_view_column_set_resizable (GTK_TREE_VIEW_COLUMN (col), TRUE);
- gtk_tree_view_column_set_title (col, treeview_headers[i]);
- gtk_tree_view_append_column (GTK_TREE_VIEW (view), col);
-
- renderer = gtk_cell_renderer_text_new ();
- gtk_tree_view_column_pack_start (col, renderer, FALSE);
- gtk_tree_view_column_add_attribute (col, renderer, "text", i);
- }
-
- return view;
-}
-
-static void
-populate_notebook (gpointer data, gpointer user_data)
-{
- gchar *header_name;
- GtkWidget *header = NULL;
- GtkWidget *h_data;
- GtkWidget *scrolled_window;
- GtkWidget *notebook;
-
- notebook = (GtkWidget *) user_data;
- header_name = (gchar *) data;
-
- if (g_strcmp0 (header_name, "comment")) {
-
- header = gtk_label_new (header_name);
- gtk_label_set_text (GTK_LABEL (header), header_name);
-
- h_data = create_tree_view ();
-
- scrolled_window = gtk_scrolled_window_new (NULL, NULL);
- gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_window),
- GTK_POLICY_AUTOMATIC, GTK_POLICY_ALWAYS);
- gtk_container_add (GTK_CONTAINER (scrolled_window), h_data);
-
- gtk_notebook_append_page_menu (GTK_NOTEBOOK (notebook),
- scrolled_window, header, NULL);
-
- gtk_notebook_set_tab_reorderable (GTK_NOTEBOOK (notebook),
- scrolled_window, TRUE);
-
- g_hash_table_insert (ui->notebook_hash, header_name, scrolled_window);
- }
-}
-
-static void
-analyzer_display_parsed_info_button_box (GtkWidget * vbox)
-{
- ui->header_button = gtk_button_new_with_label ("Headers");
- ui->slice_button = gtk_button_new_with_label ("Slices");
- ui->hexval_button = gtk_button_new_with_label ("Hex-values");
-
- gtk_box_pack_start (GTK_BOX (vbox), ui->header_button, TRUE, TRUE, 2);
- gtk_box_pack_start (GTK_BOX (vbox), ui->slice_button, TRUE, TRUE, 2);
- gtk_box_pack_start (GTK_BOX (vbox), ui->hexval_button, TRUE, TRUE, 2);
-
- gtk_widget_show_all (ui->main_window);
-}
-
-static gboolean
-callback_button_box_click (GtkWidget * widget, GdkEvent * event,
- gpointer user_data)
-{
- GList *list, *header_list;
- GList *hlist = NULL, *slist = NULL;
- GtkWidget *notebook = NULL;
- GtkWidget *textview = NULL;
- GFile *hexfile;
- GtkWidget *sc_window, *tree_view;
- gboolean is_header, is_slice, is_hexval;
-
- CodecComponents component = (CodecComponents) user_data;
-
- char *xml_name = ui->current_xml;
- char *hex_name = ui->current_hex;
-
- switch (component) {
- case COMPONENTS_HEADERS_GENERAL:
- is_header = TRUE;
- is_slice = FALSE;
- is_hexval = FALSE;
- break;
- case COMPONENTS_HEADERS_SLICE:
- is_slice = TRUE;
- is_header = FALSE;
- is_hexval = FALSE;
- break;
- case COMPONENTS_HEXVAL:
- is_hexval = TRUE;
- is_header = FALSE;
- is_slice = FALSE;
- break;
- default:
- break;
- }
-
- if (ui->prev_page)
- gtk_widget_destroy (GTK_WIDGET (ui->prev_page));
- if (ui->notebook_hash)
- g_hash_table_destroy (ui->notebook_hash);
- ui->notebook_hash = g_hash_table_new (g_str_hash, g_str_equal);
-
- if (!is_hexval) {
- header_list = analyzer_get_list_header_strings (xml_name);
-
- while (header_list) {
- if (g_strcmp0 (header_list->data, "comment")) {
- if (is_header && !g_str_has_prefix (header_list->data, "slice"))
- hlist = g_list_append (hlist, header_list->data);
- else if (is_slice && g_str_has_prefix (header_list->data, "slice"))
- hlist = g_list_append (hlist, header_list->data);
- }
- header_list = header_list->next;
- }
-
- notebook = gtk_notebook_new ();
- g_object_set (G_OBJECT (notebook), "expand", TRUE, NULL);
- gtk_notebook_set_scrollable (GTK_NOTEBOOK (notebook), TRUE);
- gtk_notebook_popup_enable (GTK_NOTEBOOK (notebook));
- gtk_notebook_set_show_border (GTK_NOTEBOOK (notebook), TRUE);
-
- g_list_foreach (hlist, (GFunc) populate_notebook, (gpointer) notebook);
-
- while (hlist) {
- sc_window = g_hash_table_lookup (ui->notebook_hash, hlist->data);
- if (sc_window && GTK_IS_BIN (sc_window))
- tree_view = gtk_bin_get_child (GTK_BIN (sc_window));
-
- if (tree_view) {
- list = analyzer_get_list_analyzer_node_from_xml (xml_name, hlist->data);
- if (list) {
- GtkTreeStore *treestore;
- GtkTreeModel *model;
-
- treestore = gtk_tree_store_new (NUM_COLS,
- G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING);
-
- g_list_foreach (list, (GFunc) fill_tree_store, treestore);
- analyzer_node_list_free (list);
- list = NULL;
-
- model = GTK_TREE_MODEL (treestore);
- gtk_tree_view_set_model (GTK_TREE_VIEW (tree_view), model);
- g_object_unref (model);
- }
- }
- hlist = hlist->next;
- }
- ui->prev_page = notebook;
- gtk_container_add (GTK_CONTAINER (ui->parsed_info_vbox), notebook);
- } else {
- /*Display the hex dump of the frame */
- GtkWidget *scrolled_window;
- GtkTextBuffer *buffer;
- gchar *contents;
- gsize length;
-
- textview = gtk_text_view_new ();
- gtk_text_view_set_left_margin (GTK_TEXT_VIEW (textview), 20);
- g_object_set (G_OBJECT (textview), "expand", TRUE, "editable", FALSE, NULL);
-
- scrolled_window = gtk_scrolled_window_new (NULL, NULL);
- gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_window),
- GTK_POLICY_AUTOMATIC, GTK_POLICY_ALWAYS);
- gtk_container_add (GTK_CONTAINER (scrolled_window), textview);
-
- hexfile = g_file_new_for_path (hex_name);
- if (hexfile) {
- if (g_file_load_contents (hexfile, NULL, &contents, &length, NULL, NULL)) {
- buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (textview));
- gtk_text_buffer_set_text (buffer, contents, length);
- g_free (contents);
- g_object_unref (G_OBJECT (hexfile));
- }
- }
- ui->prev_page = scrolled_window;
- gtk_container_add (GTK_CONTAINER (ui->parsed_info_vbox), scrolled_window);
- }
-
- gtk_widget_show_all (ui->main_window);
-
- return TRUE;
-}
-
-static void
-callback_frame_thumbnail_press (GtkWidget * event_box,
- GdkEventButton * event, gpointer user_data)
-{
- GtkWidget *label;
- gchar *file_name;
- gchar *name;
- gchar *frame_name_markup;
- gint frame_num;
-
- frame_num = (gint) user_data;
-
- name = g_strdup_printf ("%s-%d.xml", ui->codec_name, frame_num);
- file_name = g_build_filename (ui->analyzer_home, "xml", name, NULL);
- if (ui->current_xml)
- g_free (ui->current_xml);
- g_free (name);
- ui->current_xml = file_name;
-
- name = g_strdup_printf ("%s-%d.hex", ui->codec_name, frame_num);
- file_name = g_build_filename (ui->analyzer_home, "hex", name, NULL);
- if (ui->current_hex)
- g_free (ui->current_hex);
- g_free (name);
- ui->current_hex = file_name;
-
- g_signal_connect (G_OBJECT (ui->header_button), "button-press-event",
- G_CALLBACK (callback_button_box_click),
- (gpointer) COMPONENTS_HEADERS_GENERAL);
- g_signal_connect (G_OBJECT (ui->slice_button), "button-press-event",
- G_CALLBACK (callback_button_box_click),
- (gpointer) COMPONENTS_HEADERS_SLICE);
- g_signal_connect (G_OBJECT (ui->hexval_button), "button-press-event",
- G_CALLBACK (callback_button_box_click), (gpointer) COMPONENTS_HEXVAL);
-
- /* load general headers by default */
- callback_button_box_click (NULL, NULL, (gpointer) COMPONENTS_HEADERS_GENERAL);
-
- /*update the label of parsed_info_frame with frame_number */
- gtk_frame_set_label (GTK_FRAME (ui->parsed_info_frame), "");
- label = gtk_frame_get_label_widget (GTK_FRAME (ui->parsed_info_frame));
- frame_name_markup =
- g_markup_printf_escaped
- ("<span style=\"italic\" size=\"xx-large\">Frame %d</span>",
- frame_num + 1);
- gtk_label_set_markup (GTK_LABEL (label), frame_name_markup);
- g_free (frame_name_markup);
-
- gtk_widget_show_all (ui->main_window);
-}
-
-static GtkWidget *
-create_image (int frame_num)
-{
- GtkWidget *image;
- GtkWidget *event_box;
- char *path;
-
- path =
- g_build_filename (DATADIR, "codecanalyzer", "pixmaps",
- "frame-thumbnail.png", NULL);
- image = gtk_image_new_from_file (path);
- g_free (path);
-
- event_box = gtk_event_box_new ();
-
- gtk_event_box_set_above_child (GTK_EVENT_BOX (event_box), TRUE);
- gtk_event_box_set_visible_window (GTK_EVENT_BOX (event_box), FALSE);
-
- gtk_container_add (GTK_CONTAINER (event_box), image);
-
- g_signal_connect (G_OBJECT (event_box), "button_press_event",
- G_CALLBACK (callback_frame_thumbnail_press), (gpointer) frame_num);
- return event_box;
-}
-
-static void
-analyzer_create_thumbnails (void)
-{
- GtkWidget *image;
- guint i;
-
- for (i = 0; i < ui->num_frames_analyzed; i++) {
- image = create_image (i);
- g_object_set (G_OBJECT (image), "visible", TRUE, "can-focus", TRUE, NULL);
- gtk_box_pack_start (GTK_BOX (ui->hbox1_in_vbox2), image, TRUE, TRUE, 2);
- gtk_widget_show_all (image);
-
- /* Update the details of frame_0 by default */
- if (i == 0) {
- analyzer_display_parsed_info_button_box (ui->parsed_info_button_box);
- callback_frame_thumbnail_press (GTK_WIDGET (image), NULL, (gpointer) i);
- callback_button_box_click (NULL, NULL,
- (gpointer) COMPONENTS_HEADERS_GENERAL);
- }
- }
-}
-
-static void
-analyzer_ui_destroy (void)
-{
- gtk_widget_destroy (ui->main_window);
-
- if (ui->file_name)
- g_free (ui->file_name);
-
- if (ui->uri)
- g_free (ui->uri);
-
- if (ui->codec_name)
- g_free (ui->codec_name);
-
- if (ui->analyzer_home)
- g_free (ui->analyzer_home);
-
- if (ui->current_xml)
- g_free (ui->current_xml);
-
- if (ui->current_hex)
- g_free (ui->current_hex);
-
- if (ui->notebook_hash)
- g_hash_table_destroy (ui->notebook_hash);
-
- g_slice_free (AnalyzerUI, ui);
-}
-
-void
-callback_main_window_destroy (GtkWidget * widget, gpointer user_data)
-{
- if (gst_analyzer)
- gst_analyzer_destroy (gst_analyzer);
-
- analyzer_ui_destroy ();
-
- gtk_main_quit ();
-}
-
-
-static void
-fill_general_info_list_row (gchar * name, char *content)
-{
- GtkListStore *store;
- GtkTreeIter iter;
- GtkTreeView *list = GTK_TREE_VIEW (ui->general_info_treeview);
-
- store = GTK_LIST_STORE (gtk_tree_view_get_model (list));
-
- gtk_list_store_append (store, &iter);
- gtk_list_store_set (store, &iter, GENERAL_INFO_LIST_NAME, name,
- GENERAL_INFO_LIST_VALUE, content, -1);
-}
-
-static void
-list_store_init (GtkWidget * treeview)
-{
- GtkCellRenderer *renderer;
- GtkTreeViewColumn *col;
- GtkListStore *store;
- guint i;
-
- gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (treeview), FALSE);
-
- for (i = 0; i < NUM_GENERAL_INFO_LIST; i++) {
-
- col = gtk_tree_view_column_new ();
- gtk_tree_view_column_set_expand (GTK_TREE_VIEW_COLUMN (col), TRUE);
- gtk_tree_view_column_set_resizable (GTK_TREE_VIEW_COLUMN (col), TRUE);
- gtk_tree_view_append_column (GTK_TREE_VIEW (treeview), col);
-
- renderer = gtk_cell_renderer_text_new ();
- gtk_tree_view_column_pack_start (col, renderer, FALSE);
- gtk_tree_view_column_add_attribute (col, renderer, "text", i);
- }
-
- store =
- gtk_list_store_new (NUM_GENERAL_INFO_LIST, G_TYPE_STRING, G_TYPE_STRING);
-
- gtk_tree_view_set_model (GTK_TREE_VIEW (treeview), GTK_TREE_MODEL (store));
-
- g_object_unref (store);
-}
-
-static void
-analyzer_display_general_stream_info (GstAnalyzerVideoInfo * analyzer_vinfo)
-{
- char *str;
-
- if (!analyzer_vinfo || !ui->general_info_treeview)
- return;
-
- list_store_init (ui->general_info_treeview);
-
- if (analyzer_vinfo->codec_name)
- fill_general_info_list_row ("codec", analyzer_vinfo->codec_name);
-
- if (analyzer_vinfo->width) {
- str = g_strdup_printf ("%d", analyzer_vinfo->width);
- fill_general_info_list_row ("width", str);
- g_free (str);
- }
- if (analyzer_vinfo->height) {
- str = g_strdup_printf ("%d", analyzer_vinfo->height);
- fill_general_info_list_row ("height", str);
- g_free (str);
- }
- if (analyzer_vinfo->depth) {
- str = g_strdup_printf ("%d", analyzer_vinfo->depth);
- fill_general_info_list_row ("depth", str);
- g_free (str);
- }
- if (analyzer_vinfo->avg_bitrate) {
- str = g_strdup_printf ("%d", analyzer_vinfo->avg_bitrate);
- fill_general_info_list_row ("avg_bitrate", str);
- g_free (str);
- }
- if (analyzer_vinfo->max_bitrate) {
- str = g_strdup_printf ("%d", analyzer_vinfo->max_bitrate);
- fill_general_info_list_row ("max_bitrate", str);
- g_free (str);
- }
- if (analyzer_vinfo->fps_n) {
- str = g_strdup_printf ("%d", analyzer_vinfo->fps_n);
- fill_general_info_list_row ("fps_n", str);
- g_free (str);
- }
- if (analyzer_vinfo->fps_d) {
- str = g_strdup_printf ("%d", analyzer_vinfo->fps_d);
- fill_general_info_list_row ("fps_d", str);
- g_free (str);
- }
- if (analyzer_vinfo->par_n) {
- str = g_strdup_printf ("%d", analyzer_vinfo->par_n);
- fill_general_info_list_row ("par_n", str);
- g_free (str);
- }
- if (analyzer_vinfo->par_d) {
- str = g_strdup_printf ("%d", analyzer_vinfo->par_d);
- fill_general_info_list_row ("par_d", str);
- g_free (str);
- }
-
- gtk_widget_show_all (ui->general_info_treeview);
-}
-
-static void
-reset_analyzer_ui (void)
-{
-
- if (ui->hbox1_in_vbox2) {
- gtk_widget_destroy (GTK_WIDGET (ui->hbox1_in_vbox2));
- ui->hbox1_in_vbox2 = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
- g_object_set (G_OBJECT (ui->hbox1_in_vbox2), "visible", TRUE,
- "can-focus", FALSE, NULL);
- gtk_container_add (GTK_CONTAINER (ui->thumbnails_view_port),
- ui->hbox1_in_vbox2);
- }
-
- if (ui->general_info_treeview) {
- gtk_widget_destroy (GTK_WIDGET (ui->general_info_treeview));
- ui->general_info_treeview = gtk_tree_view_new ();
- gtk_box_pack_end (GTK_BOX (ui->general_info_vbox),
- ui->general_info_treeview, TRUE, TRUE, 0);
- }
-
- if (ui->parsed_info_button_box) {
- gtk_widget_destroy (GTK_WIDGET (ui->parsed_info_button_box));
- ui->parsed_info_button_box = gtk_box_new (GTK_ORIENTATION_VERTICAL, 2);
- g_object_set (G_OBJECT (ui->parsed_info_button_box), "visible", TRUE,
- "can-focus", TRUE, NULL);
- gtk_box_pack_start (GTK_BOX (ui->parsed_info_hbox),
- ui->parsed_info_button_box, FALSE, FALSE, 0);
- }
- if (ui->parsed_info_vbox) {
- gtk_widget_destroy (GTK_WIDGET (ui->parsed_info_vbox));
- ui->parsed_info_vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 2);
- g_object_set (G_OBJECT (ui->parsed_info_vbox), "visible", TRUE,
- "can-focus", TRUE, NULL);
- gtk_box_pack_start (GTK_BOX (ui->parsed_info_hbox), ui->parsed_info_vbox,
- TRUE, TRUE, 0);
- }
-
- if (ui->parsed_info_frame)
- gtk_frame_set_label (GTK_FRAME (ui->parsed_info_frame), "");
-
- if (ui->notebook_hash)
- g_hash_table_destroy (ui->notebook_hash);
- ui->notebook_hash = g_hash_table_new (g_str_hash, g_str_equal);
-
- ui->prev_page = NULL;
-
- gtk_widget_show_all (ui->main_window);
-}
-
-guint
-analyze_idle_callback (gpointer data)
-{
- guint i;
-
- if (!gst_analyzer)
- return TRUE;
-
- ui->num_frames_analyzed = gst_analyzer->NumOfAnalyzedFrames;
-
- if (!gst_analyzer->complete_analyze)
- return TRUE;
-
- /* Once the analysis is complete, we doesn't need to hold the gst_analyzer */
- if (gst_analyzer) {
- gst_analyzer_destroy (gst_analyzer);
- gst_analyzer = NULL;
- }
-
- analyzer_create_thumbnails ();
-
- gtk_widget_set_sensitive (ui->cancel_button, FALSE);
- gtk_widget_set_sensitive (ui->analyze_button, TRUE);
-
- ui->analyze_idle_id = 0;
-
- return FALSE;
-}
-
-void
-callback_analyzer_button_analyze (GtkWidget * widget, gpointer user_data)
-{
- const char *str;
- GstAnalyzerVideoInfo *analyzer_vinfo;
- guint i, j, k;
-
- gtk_widget_set_sensitive (ui->analyze_button, FALSE);
- gtk_widget_set_sensitive (ui->cancel_button, TRUE);
- gtk_widget_set_sensitive (ui->child_vbox3, TRUE);
-
- g_signal_emit_by_name (ui->numframes_chooser, "activate", NULL, NULL);
- str = gtk_entry_get_text ((GtkEntry *) ui->numframes_chooser);
-
- /* initialize the back-end */
- if (!gst_analyzer) {
- GstAnalyzerStatus status;
- gst_analyzer = g_slice_new0 (GstAnalyzer);
- status = gst_analyzer_init (gst_analyzer, ui->uri);
- if (status != GST_ANALYZER_STATUS_SUCCESS) {
- const gchar *msg;
-
- reset_analyzer_ui ();
-
- msg = gst_analyzer_status_get_name (status);
- display_error_dialog (msg);
-
- gtk_widget_set_sensitive (ui->analyze_button, TRUE);
- gtk_widget_set_sensitive (ui->cancel_button, FALSE);
- gtk_widget_set_sensitive (ui->child_vbox3, FALSE);
- if (gst_analyzer)
- gst_analyzer_destroy (gst_analyzer);
- gst_analyzer = NULL;
- goto done;
- }
- }
-
- /* reset the necessary UI components for each Analysis */
- reset_analyzer_ui ();
-
- ui->num_frames = atoi (str);
-
- if (gst_analyzer->codec_name)
- ui->codec_name = g_strdup (gst_analyzer->codec_name);
-
- if (ui->file_name)
- gst_analyzer_set_file_name (gst_analyzer, ui->file_name);
- if (ui->num_frames)
- gst_analyzer_set_num_frames (gst_analyzer, ui->num_frames);
- if (ui->analyzer_home)
- gst_analyzer_set_destination_dir_path (gst_analyzer, ui->analyzer_home);
-
- gst_analyzer_start (gst_analyzer);
-
- analyzer_display_general_stream_info (gst_analyzer->video_info);
- ui->analyze_idle_id = g_idle_add ((GSourceFunc) analyze_idle_callback, NULL);
-done:{
- }
-}
-
-void
-callback_cancel_button_cancel (GtkWidget * widget, gpointer user_data)
-{
- g_debug ("Cancel the analysis.. \n");
-
- gtk_widget_set_sensitive (ui->cancel_button, FALSE);
-
- if (ui->analyze_idle_id)
- g_source_remove (ui->analyze_idle_id);
-
- if (gst_analyzer) {
- gst_analyzer_destroy (gst_analyzer);
- gst_analyzer = NULL;
- }
-
- /* display the frame contents which are already analyzed */
- analyzer_create_thumbnails ();
- gtk_widget_set_sensitive (ui->analyze_button, TRUE);
-}
-
-void
-callback_stream_chooser_new_stream (GtkFileChooserButton * widget,
- gpointer user_data)
-{
- if (ui->file_name)
- g_free (ui->file_name);
- ui->file_name = gtk_file_chooser_get_filename ((GtkFileChooser *) widget);
-
- if (ui->uri)
- g_free (ui->uri);
- ui->uri = gtk_file_chooser_get_uri ((GtkFileChooser *) widget);
- gtk_widget_set_sensitive (ui->analyze_button, TRUE);
-}
-
-static void
-menu_quit_callback (void)
-{
- gtk_widget_destroy (ui->main_window);
-}
-
-static void
-menu_about_callback (void)
-{
- GFile *license_file;
- GdkPixbuf *logo;
- gchar *contents = NULL;
- gsize length = 0;
- char *file_name;
- char *authors[] =
- { "Sreerenj Balachandran", "< sreerenj.balachandran@intel.com >",
- NULL
- };
-
- file_name = g_build_filename (DATADIR, "codecanalyzer", "pixmaps",
- "codecanalyzer-logo.png", NULL);
- if (file_name) {
- logo = gdk_pixbuf_new_from_file (file_name, NULL);
- g_free (file_name);
- }
-
- file_name =
- g_build_filename (DATADIR, "codecanalyzer", "ui", "LICENSE.txt", NULL);
- if (file_name) {
- license_file = g_file_new_for_path (file_name);
- if (license_file) {
- g_file_load_contents (license_file, NULL, &contents, &length, NULL, NULL);
- g_object_unref (G_OBJECT (license_file));
- }
- g_free (file_name);
- }
-
- gtk_show_about_dialog (GTK_WINDOW (ui->main_window),
- "program-name", "Codecanalyzer",
- "version", PACKAGE_VERSION,
- "copyright", "Copyright © Intel Corporation",
- "authors", authors,
- "comments", "An analyzer for doing in-depth analysis on compressed media",
- "license", contents, "logo", logo, NULL);
- if (logo)
- g_object_unref (G_OBJECT (logo));
- if (contents)
- g_free (contents);
-}
-
-static void
-menu_help_callback (void)
-{
- GtkWidget *dialog;
- dialog = gtk_message_dialog_new (GTK_WINDOW (ui->main_window),
- GTK_DIALOG_DESTROY_WITH_PARENT,
- GTK_MESSAGE_INFO, GTK_BUTTONS_OK,
- "See http://cgit.freedesktop.org/gstreamer/gst-devtools/plain/codecanalyzer/README.md");
- gtk_window_set_title (GTK_WINDOW (dialog), "Help");
- gtk_dialog_run (GTK_DIALOG (dialog));
- gtk_widget_destroy (dialog);
-}
-
-static GtkActionEntry entries_actiongroup[] = {
- {"MediaMenuAction", NULL, "Media"},
- {"HelpMenuAction", NULL, "Help"},
-
- {"QuitAction", GTK_STOCK_QUIT,
- "Quit", "<control>Q",
- "Quit",
- G_CALLBACK (menu_quit_callback)},
-
- {"HelpAction", GTK_STOCK_HELP,
- "Help", NULL,
- "Help",
- G_CALLBACK (menu_help_callback)},
-
- {"AboutAction", GTK_STOCK_ABOUT,
- "About", NULL,
- "About",
- G_CALLBACK (menu_about_callback)}
-};
-
-static gboolean
-analyzer_ui_init (void)
-{
- GtkActionGroup *action_group;
- char *path;
-
- ui = g_slice_new0 (AnalyzerUI);
-
- path =
- g_build_filename (DATADIR, "codecanalyzer", "ui", "mainwindow.xml", NULL);
- ui->builder = make_builder (path);
- g_free (path);
-
- ui->main_window =
- get_widget_from_builder (ui->builder, "Codecanalyzer-main-window");
- ui->main_vbox = get_widget_from_builder (ui->builder, "MainVBox");
- ui->child_vbox1 = get_widget_from_builder (ui->builder, "child_vbox1");
- ui->child_vbox2 = get_widget_from_builder (ui->builder, "child_vbox2");
- ui->child_vbox3 = get_widget_from_builder (ui->builder, "child_vbox3");
- ui->menubar_vbox = get_widget_from_builder (ui->builder, "menubar_vbox");
- ui->stream_chooser = get_widget_from_builder (ui->builder, "StreamChooser");
- ui->numframes_chooser =
- get_widget_from_builder (ui->builder, "NumFrameEntryButton");
- ui->analyze_button = get_widget_from_builder (ui->builder, "AnalyzeButton");
- ui->cancel_button = get_widget_from_builder (ui->builder, "CancelButton");
- ui->hbox1_in_vbox2 = get_widget_from_builder (ui->builder, "hbox1_in_vbox2");
- ui->child_hbox_in_vbox1_2 = get_widget_from_builder (ui->builder,
- "child_hbox_in_vbox1_2");
- ui->thumbnails_scroll_window =
- get_widget_from_builder (ui->builder, "thumbnails_scrolled_window");
- ui->thumbnails_view_port =
- get_widget_from_builder (ui->builder, "thumbnails_view_port");
- ui->general_info_frame =
- get_widget_from_builder (ui->builder, "general_info_frame");
- ui->general_info_vbox =
- get_widget_from_builder (ui->builder, "general_info_vbox");
- ui->general_info_treeview =
- get_widget_from_builder (ui->builder, "general_info_treeview");
- ui->parsed_info_hbox =
- get_widget_from_builder (ui->builder, "parsed_info_hbox");
- ui->parsed_info_vbox =
- get_widget_from_builder (ui->builder, "parsed_info_vbox");
- ui->parsed_info_frame =
- get_widget_from_builder (ui->builder, "parsed_info_frame");
- ui->parsed_info_button_box =
- get_widget_from_builder (ui->builder, "parsed_info_button_box");
-
- /* Create menu */
- action_group = gtk_action_group_new ("ActionGroup");
- gtk_action_group_add_actions (action_group, entries_actiongroup,
- G_N_ELEMENTS (entries_actiongroup), NULL);
- ui->menu_manager = gtk_ui_manager_new ();
- gtk_ui_manager_insert_action_group (ui->menu_manager, action_group, 0);
- path = g_build_filename (DATADIR, "codecanalyzer", "ui", "menu.xml", NULL);
- gtk_ui_manager_add_ui_from_file (ui->menu_manager, path, NULL);
- g_free (path);
- ui->menubar = gtk_ui_manager_get_widget (ui->menu_manager, "/MainMenu");
- gtk_box_pack_start (GTK_BOX (ui->menubar_vbox), ui->menubar, FALSE, FALSE, 0);
- gtk_window_add_accel_group (GTK_WINDOW (ui->main_window),
- gtk_ui_manager_get_accel_group (ui->menu_manager));
-
- ui->notebook_hash = g_hash_table_new (g_str_hash, g_str_equal);
- ui->prev_page = NULL;
- ui->num_frames = 0;
-
- gtk_window_maximize (GTK_WINDOW (ui->main_window));
-
- path =
- g_build_filename (DATADIR, "codecanalyzer", "pixmaps",
- "codecanalyzer-logo.png", NULL);
- if (!gtk_window_set_icon_from_file (GTK_WINDOW (ui->main_window), path, NULL))
- g_warning ("Failed to load the icon image.. ");
- g_free (path);
-
- return TRUE;
-}
-
-static gboolean
-analyzer_create_dirs (void)
-{
- const gchar *user_cache_dir;
- gchar *xml_files_path = NULL;
- gchar *hex_files_path = NULL;
- gboolean ret = TRUE;
-
- user_cache_dir = g_get_user_cache_dir ();
- if (!user_cache_dir)
- return FALSE;
-
- ui->analyzer_home = g_build_filename (user_cache_dir, "codecanalyzer", NULL);
-
- xml_files_path = g_build_filename (ui->analyzer_home, "xml", NULL);
- if (g_mkdir_with_parents (xml_files_path, 0777) < 0) {
- ret = FALSE;
- goto done;
- }
-
- hex_files_path = g_build_filename (ui->analyzer_home, "hex", NULL);
- if (g_mkdir_with_parents (hex_files_path, 0777) < 0) {
- ret = FALSE;
- goto done;
- }
-
- g_debug ("Analyzer_Home %s", ui->analyzer_home);
-
-done:
- if (xml_files_path)
- g_free (xml_files_path);
- if (hex_files_path)
- g_free (hex_files_path);
-
- return ret;
-}
-
-int
-main (int argc, char *argv[])
-{
-
- gboolean ret;
- gboolean debug_mode = FALSE;
- GOptionContext *ctx;
- GError *err = NULL;
- GOptionEntry options[] = {
- {"debug-mode", 'd', 0, G_OPTION_ARG_NONE, &debug_mode, "debug mode", NULL},
- {NULL}
- };
-
- gtk_init (&argc, &argv);
-
- ctx = g_option_context_new (" -codecanalyzer options");
- g_option_context_add_main_entries (ctx, options, NULL);
- if (!g_option_context_parse (ctx, &argc, &argv, &err)) {
- if (err)
- g_printerr ("Failed to initialize: %s\n", err->message);
- else
- g_printerr ("Failed to initialize, Unknown error\n");
- g_clear_error (&err);
- g_option_context_free (ctx);
- exit (1);
- }
- g_option_context_free (ctx);
-
- if (debug_mode) {
- g_log_set_handler (G_LOG_DOMAIN, G_LOG_LEVEL_MASK | G_LOG_FLAG_FATAL,
- g_log_default_handler, NULL);
- g_setenv ("G_MESSAGES_DEBUG", "all", TRUE);
- g_debug ("Codecanalyzer is in DEBUG_MODE..");
- }
-
- xmlKeepBlanksDefault (0);
-
- ret = analyzer_ui_init ();
- if (!ret) {
- g_printerr ("Failed to activate the gtk+-3.x backend\n");
- goto done;
- }
-
- ret = analyzer_create_dirs ();
- if (!ret) {
- g_printerr ("Failed to create the necessary dir names\n");
- goto done;
- }
-
- gtk_builder_connect_signals (ui->builder, NULL);
-
- gtk_widget_show_all (ui->main_window);
-
- gtk_main ();
-
-done:
- g_printf ("Closing Codecanalyzer....\n");
- return 0;
-}
+++ /dev/null
-/*
- * Copyright (c) 2013, Intel Corporation.
- * Author: Sreerenj Balachandran <sreerenj.balachandran@intel.com>
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Library General Public
- * License as published by the Free Software Foundation; either
- * version 2 of the License, or (at your option) any later version.
- *
- * This program is distributed in the hope 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 program; if not, write to the Free Software Foundation, Inc.,
- * 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.
- *
- */
-/* SECTION: gst-analyzer
- * gst-analyzer is the back-end code of codecanalyzer
- * which is for activating the whole gstreamer pipeline.
- * The usual pipeline contains three gstreamer elements,
- * a src(filesrc), parser(any video parser element supporing
- * by the codecanalyzer and upstream gstreamer) and an
- * analyzersink which is residing in plugins/gst/analzyersink.
- */
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-
-#include <glib/gprintf.h>
-
-#include "gst_analyzer.h"
-#include <analyzer_utils.h>
-
-typedef struct
-{
- const gint ret;
- const gchar *name;
-} GstAnalyzerStatusInfo;
-
-static GstAnalyzerStatusInfo analyzer_status_info[] = {
- {GST_ANALYZER_STATUS_SUCCESS, "Success"},
- {GST_ANALYZER_STATUS_CODEC_PARSER_MISSING, "Codec Parser is missing"},
- {GST_ANALYZER_STATUS_CODEC_NOT_SUPPORTED, "Codec not supported"},
- {GST_ANALYZER_STATUS_STREAM_FORMAT_UNKNOWN, "Unknown stream format"},
- {GST_ANALYZER_STATUS_ERROR_UNKNOWN, "Failed to start the gstreamer engine"}
-};
-
-const gchar *
-gst_analyzer_status_get_name (GstAnalyzerStatus status)
-{
- gint i;
-
- for (i = 0; i < G_N_ELEMENTS (analyzer_status_info); i++) {
- if (status == analyzer_status_info[i].ret)
- return analyzer_status_info[i].name;
- }
- return "unknown";
-}
-
-typedef struct
-{
- const gchar *discoverer_codec_name;
- const gchar *codec_short_name;
- GstAnalyzerCodecType codec_type;
- gchar *parser_name;
-} CodecInfo;
-
-static const CodecInfo codecs_info[] = {
-
- {"MPEG-2 Video", "mpeg2", GST_ANALYZER_CODEC_MPEG2_VIDEO, "mpegvideoparse"},
- {"H.264", "h264", GST_ANALYZER_CODEC_H264, "h264parse"},
- {"H.265", "h265", GST_ANALYZER_CODEC_H265, "h265parse"},
- {"UNKNOWN", "unknown", GST_ANALYZER_CODEC_UNKNOWN, NULL}
-};
-
-static const CodecInfo *
-find_codec_info (gchar * name)
-{
- guint i;
- for (i = 0; i < G_N_ELEMENTS (codecs_info); ++i) {
- if (g_str_has_prefix (name, codecs_info[i].discoverer_codec_name))
- return &codecs_info[i];
- }
- return NULL;
-}
-
-void
-gst_analyzer_video_info_destroy (GstAnalyzerVideoInfo * analyzer_vinfo)
-{
- g_return_if_fail (analyzer_vinfo != NULL);
-
- if (analyzer_vinfo->codec_name)
- g_free (analyzer_vinfo->codec_name);
-
- g_slice_free (GstAnalyzerVideoInfo, analyzer_vinfo);
-}
-
-gboolean
-gst_analyzer_video_info_from_uri (GstAnalyzerVideoInfo * analyzer_vinfo,
- gchar * uri)
-{
- g_return_val_if_fail (analyzer_vinfo != NULL, FALSE);
- g_return_val_if_fail (uri != NULL, FALSE);
-
- GstDiscoverer *discoverer = NULL;
- GstDiscovererInfo *d_info = NULL;
- GstDiscovererVideoInfo *dv_info = NULL;
- GList *list = NULL;
- GstCaps *caps = NULL;
-
- discoverer = gst_discoverer_new (3 * GST_SECOND, NULL);
- g_return_val_if_fail (discoverer != NULL, FALSE);
-
- d_info = gst_discoverer_discover_uri (discoverer, uri, NULL);
- g_return_val_if_fail (d_info != NULL, FALSE);
-
- list = gst_discoverer_info_get_video_streams (d_info);
- g_return_val_if_fail (list != NULL && list->data != NULL, FALSE);
-
- caps = gst_discoverer_stream_info_get_caps ((GstDiscovererStreamInfo *)
- list->data);
- dv_info = (GstDiscovererVideoInfo *) list->data;
-
- if (caps)
- analyzer_vinfo->codec_name = gst_pb_utils_get_codec_description (caps);
-
- analyzer_vinfo->width = gst_discoverer_video_info_get_width (dv_info);
- analyzer_vinfo->height = gst_discoverer_video_info_get_height (dv_info);
- analyzer_vinfo->depth = gst_discoverer_video_info_get_depth (dv_info);
- analyzer_vinfo->avg_bitrate = gst_discoverer_video_info_get_bitrate (dv_info);
- analyzer_vinfo->max_bitrate =
- gst_discoverer_video_info_get_max_bitrate (dv_info);
- analyzer_vinfo->fps_n = gst_discoverer_video_info_get_framerate_num (dv_info);
- analyzer_vinfo->fps_d =
- gst_discoverer_video_info_get_framerate_denom (dv_info);
- analyzer_vinfo->par_n = gst_discoverer_video_info_get_par_num (dv_info);
- analyzer_vinfo->par_d = gst_discoverer_video_info_get_par_denom (dv_info);
-
- gst_caps_unref (caps);
- gst_discoverer_stream_info_list_free (list);
- g_object_unref (discoverer);
-
- g_debug
- ("codec=%s w=%d h=%d d=%d avg_bitrate=%d max_bitrate=%d fps_n=%d fps_d=%d par_n=%d par_d=%d \n",
- analyzer_vinfo->codec_name, analyzer_vinfo->width, analyzer_vinfo->height,
- analyzer_vinfo->depth, analyzer_vinfo->avg_bitrate,
- analyzer_vinfo->max_bitrate, analyzer_vinfo->fps_n, analyzer_vinfo->fps_d,
- analyzer_vinfo->par_n, analyzer_vinfo->par_d);
-
- return TRUE;
-}
-
-GstAnalyzerVideoInfo *
-gst_analyzer_video_info_new ()
-{
- GstAnalyzerVideoInfo *vinfo;
-
- vinfo = g_slice_new0 (GstAnalyzerVideoInfo);
-
- return vinfo;
-}
-
-static void
-new_frame_callback (GstElement * element, GstBuffer * buffer, gint frame_num,
- gpointer data)
-{
- GstAnalyzer *analyzer = (GstAnalyzer *) data;
-
- analyzer->NumOfAnalyzedFrames = frame_num + 1;
-
- if (analyzer->NumOfAnalyzedFrames == analyzer->NumOfFramesToAnalyze)
- analyzer->complete_analyze = TRUE;
-}
-
-static gboolean
-bus_callback (GstBus * bus, GstMessage * message, gpointer data)
-{
- GstAnalyzer *analyzer = (GstAnalyzer *) data;
-
- if (GST_MESSAGE_TYPE (message) == GST_MESSAGE_EOS) {
- g_printf ("<===Received EOS: All frames are analyzed====> \n");
- analyzer->complete_analyze = TRUE;
- return FALSE;
- } else if (GST_MESSAGE_TYPE (message) == GST_MESSAGE_ERROR) {
- GError *error = NULL;
- gst_message_parse_error (message, &error, NULL);
- g_printerr ("gstreamer error : %s\n", error->message);
- g_error_free (error);
- return FALSE;
- }
- return TRUE;
-}
-
-void
-gst_analyzer_destroy (GstAnalyzer * analyzer)
-{
- if (analyzer) {
- if (analyzer->video_info)
- gst_analyzer_video_info_destroy (analyzer->video_info);
-
- if (analyzer->codec_name)
- g_free (analyzer->codec_name);
-
- gst_analyzer_stop (analyzer);
- g_slice_free (GstAnalyzer, analyzer);
- }
-}
-
-void
-gst_analyzer_set_file_name (GstAnalyzer * analyzer, char *uri)
-{
- g_object_set (G_OBJECT (analyzer->src), "location", uri, NULL);
-}
-
-void
-gst_analyzer_set_destination_dir_path (GstAnalyzer * analyzer, char *path)
-{
- g_object_set (G_OBJECT (analyzer->sink), "location", path, NULL);
- g_debug ("Destination for xml_files and hex_files %s ", path);
-}
-
-void
-gst_analyzer_set_num_frames (GstAnalyzer * analyzer, gint frame_count)
-{
- g_object_set (G_OBJECT (analyzer->sink), "num-frames", frame_count, NULL);
- analyzer->NumOfFramesToAnalyze = frame_count;
-}
-
-gboolean
-gst_analyzer_stop (GstAnalyzer * analyzer)
-{
- if (analyzer->pipeline)
- gst_element_set_state (analyzer->pipeline, GST_STATE_NULL);
-
- if (analyzer->bus_watch_id)
- g_source_remove (analyzer->bus_watch_id);
-
- return TRUE;
-}
-
-gboolean
-gst_analyzer_start (GstAnalyzer * analyzer)
-{
- gst_element_set_state (analyzer->pipeline, GST_STATE_PLAYING);
- return TRUE;
-}
-
-GstAnalyzerStatus
-gst_analyzer_init (GstAnalyzer * analyzer, char *uri)
-{
- GstAnalyzerStatus status = GST_ANALYZER_STATUS_ERROR_UNKNOWN;
- const CodecInfo *codec_info;
- GstBus *bus;
- gboolean ret;
-
- analyzer->NumOfAnalyzedFrames = 0;
- analyzer->complete_analyze = FALSE;
- analyzer->NumOfFramesToAnalyze = -1;
-
- if (!gst_is_initialized ())
- gst_init (NULL, NULL);
-
- if (!analyzer_sink_register_static ()) {
- g_printerr ("Failed to register static plugins....\n");
- status = GST_ANALYZER_STATUS_CODEC_PARSER_MISSING;
- goto error;
- }
-
- /* GstDiscoverer to extract general stream info */
- analyzer->video_info = gst_analyzer_video_info_new ();
- ret = gst_analyzer_video_info_from_uri (analyzer->video_info, uri);
-
- if (ret && analyzer->video_info->codec_name)
- codec_info = find_codec_info (analyzer->video_info->codec_name);
-
- if (!ret || codec_info == NULL
- || codec_info->codec_type == GST_ANALYZER_CODEC_UNKNOWN) {
- status = GST_ANALYZER_STATUS_STREAM_FORMAT_UNKNOWN;
- goto error;
- }
-
- if (ret && codec_info) {
- switch (codec_info->codec_type) {
- case GST_ANALYZER_CODEC_MPEG2_VIDEO:
- status = GST_ANALYZER_STATUS_SUCCESS;
- break;
- default:
- status = GST_ANALYZER_STATUS_CODEC_NOT_SUPPORTED;
- goto error;
- break;
- }
- }
- analyzer->codec_name = g_strdup (codec_info->codec_short_name);
-
- analyzer->src = gst_element_factory_make ("filesrc", "file-src");
- analyzer->parser =
- gst_element_factory_make (codec_info->parser_name,
- "codec-analyzer-video-parse");
- analyzer->sink = gst_element_factory_make ("analyzersink", "sink");
- analyzer->pipeline = gst_pipeline_new ("pipeline");
-
- if (!analyzer->src || !analyzer->parser || !analyzer->sink) {
- g_printerr ("Failed to create the necessary gstreamer elements..\n");
- status = GST_ANALYZER_STATUS_ERROR_UNKNOWN;
- goto error;
- }
-
- g_signal_connect (analyzer->sink, "new-frame", (GCallback) new_frame_callback,
- analyzer);
- if (!g_strcmp0 (analyzer->codec_name, "mpeg2"))
- g_object_set (G_OBJECT (analyzer->parser), "drop", FALSE, NULL);
-
- gst_bin_add_many (GST_BIN (analyzer->pipeline), analyzer->src,
- analyzer->parser, analyzer->sink, NULL);
- gst_element_link_many (analyzer->src, analyzer->parser, analyzer->sink, NULL);
-
- bus = gst_pipeline_get_bus (GST_PIPELINE (analyzer->pipeline));
- analyzer->bus_watch_id = gst_bus_add_watch (bus, bus_callback, analyzer);
- gst_object_unref (GST_OBJECT (bus));
-
- return status;
-
-error:
- return status;
-}
+++ /dev/null
-/*
- * Copyright (c) 2013, Intel Corporation.
- * Author: Sreerenj Balachandran <sreerenj.balachandran@intel.com>
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Library General Public
- * License as published by the Free Software Foundation; either
- * version 2 of the License, or (at your option) any later version.
- *
- * This program is distributed in the hope 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 program; if not, write to the Free Software Foundation, Inc.,
- * 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.
- *
- */
-#ifndef __GST_ANALYZER__
-#define __GST_ANALYZER__
-
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include <gst/gst.h>
-#include <gst/pbutils/pbutils.h>
-
-typedef struct _GstAnalyzer GstAnalyzer;
-typedef struct _GstAnalyzerVideoInfo GstAnalyzerVideoInfo;
-
-typedef enum {
- GST_ANALYZER_STATUS_SUCCESS = 0,
- GST_ANALYZER_STATUS_CODEC_PARSER_MISSING = 1,
- GST_ANALYZER_STATUS_CODEC_NOT_SUPPORTED = 2,
- GST_ANALYZER_STATUS_STREAM_FORMAT_UNKNOWN = 3,
- GST_ANALYZER_STATUS_ERROR_UNKNOWN = 4
-} GstAnalyzerStatus;
-
-const gchar* gst_analyzer_status_get_name (GstAnalyzerStatus status);
-
-typedef enum {
- GST_ANALYZER_CODEC_UNKNOWN = 0,
- GST_ANALYZER_CODEC_MPEG2_VIDEO = 1,
- GST_ANALYZER_CODEC_H264 = 2,
- GST_ANALYZER_CODEC_VC1 = 3,
- GST_ANALYZER_CODEC_MPEG4_PART_TWO = 4,
- GST_ANALYZER_CODEC_H265 = 5,
- GST_ANALYZER_CODEC_VP8 = 6,
- GST_ANALYZER_CODEC_VP9 = 7
-} GstAnalyzerCodecType;
-
-struct _GstAnalyzerVideoInfo
-{
- gchar *codec_name;
- guint width;
- guint height;
- guint depth;
- guint avg_bitrate;
- guint max_bitrate;
- guint fps_n;
- guint fps_d;
- guint par_n;
- guint par_d;
-};
-
-struct _GstAnalyzer
-{
- GstAnalyzerVideoInfo *video_info;
-
- gchar *codec_name;
-
- GstElement *pipeline;
- GstElement *src;
- GstElement *parser;
- GstElement *sink;
-
- guint bus_watch_id;
-
- gboolean complete_analyze;
- gint NumOfFramesToAnalyze;
- gint NumOfAnalyzedFrames;
-};
-
-GstAnalyzerStatus gst_analyzer_init (GstAnalyzer *analyzer, char *uri);
-
-void gst_analyzer_set_file_name (GstAnalyzer *analyzer,
- char *file_name);
-
-void gst_analyzer_set_destination_dir_path (GstAnalyzer * analyzer,
- char *uri);
-
-void gst_analyzer_set_num_frames (GstAnalyzer *analyzer,
- gint num_frames);
-
-gboolean gst_analyzer_start (GstAnalyzer *analyzer);
-
-gboolean gst_analyzer_stop (GstAnalyzer *analyzer);
-
-void gst_analyzer_destroy (GstAnalyzer *analyzer);
-
-GstAnalyzerVideoInfo *gst_analyzer_video_info_new ();
-
-gboolean gst_analyzer_video_info_from_uri (GstAnalyzerVideoInfo *vinfo, gchar *uri);
-
-void gst_analyzer_video_info_destroy (GstAnalyzerVideoInfo *video_info);
-
-#endif /* __GST_ANALYZER__ */
+++ /dev/null
-SUBDIRS = gst
-
-# Extra clean files so that maintainer-clean removes *everything*
-MAINTAINERCLEANFILES = Makefile.in
+++ /dev/null
-SUBDIRS = analyzersink
-
-# Extra clean files so that maintainer-clean removes *everything*
-MAINTAINERCLEANFILES = Makefile.in
+++ /dev/null
-noinst_LTLIBRARIES = \
- libcodecanalyzer-gst-analyzersink.la \
- $(NULL)
-
-noinst_HEADERS = gstanalyzersink.h mpeg_xml.h xml_utils.h analyzer_utils.h
-
-libcodecanalyzer_gst_analyzersink_cflags = \
- -DGST_USE_UNSTABLE_API \
- $(GST_BASE_CFLAGS) \
- $(GST_VIDEO_CFLAGS) \
- $(GST_CFLAGS) \
- $(GST_CODEC_PARSERS_CFLAGS) \
- $(LIBXML2_CFLAGS) \
- $(NULL)
-
-libcodecanalyzer_gst_analyzersink_libs = \
- $(GST_BASE_LIBS) \
- $(GST_LIBS) \
- $(GST_VIDEO_LIBS) \
- $(GST_CODEC_PARSERS_LIBS) \
- $(LIBXML2_LIBS) \
- $(NULL)
-
-libcodecanalyzer_gst_analyzersink_la_SOURCES = \
- gstanalyzersink.c \
- mpeg_xml.c \
- plugin.c \
- analyzer_utils.c \
- $(NULL)
-
-libcodecanalyzer_gst_analyzersink_la_CFLAGS = \
- $(libcodecanalyzer_gst_analyzersink_cflags) \
- $(NULL)
-
-libcodecanalyzer_gst_analyzersink_la_LIBADD = \
- $(libcodecanalyzer_gst_analyzersink_libs) -lgstcodecparsers-1.0 \
- $(NULL)
-
-libcodecanalyzer_gst_analyzersink_la_LDFLAGS = \
- $(GST_ALL_LDFLAGS) \
- $(NULL)
-
-# Extra clean files so that maintainer-clean removes *everything*
-MAINTAINERCLEANFILES = Makefile.in
+++ /dev/null
-/*
- * Copyright (c) 2013, Intel Corporation.
- * Author: Sreerenj Balachandran <sreerenj.balachandran@intel.com>
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Library General Public
- * License as published by the Free Software Foundation; either
- * version 2 of the License, or (at your option) any later version.
- *
- * This program is distributed in the hope 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 program; if not, write to the Free Software Foundation, Inc.,
- * 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.
- *
- */
-#include "analyzer_utils.h"
-#include "gstanalyzersink.h"
-
-#ifdef HAVE_CONFIG_H
-#include "config.h"
-#endif
-
-static gboolean
-plugin_init (GstPlugin * plugin)
-{
- gboolean ret = FALSE;
-
- ret |= gst_element_register (plugin, "analyzersink",
- GST_RANK_PRIMARY + 1, GST_TYPE_ANALYZER_SINK);
-
- return ret;
-}
-
-gboolean
-analyzer_sink_register_static ()
-{
- return gst_plugin_register_static (GST_VERSION_MAJOR,
- GST_VERSION_MINOR,
- "analzsersink",
- "sink element to dump parsed information to the xml",
- plugin_init, VERSION, "LGPL", "codecanalyzer", PACKAGE_NAME, PACKAGE_URL);
-}
+++ /dev/null
-/*
- * Copyright (c) 2013, Intel Corporation.
- * Author: Sreerenj Balachandran <sreerenj.balachandran@intel.com>
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Library General Public
- * License as published by the Free Software Foundation; either
- * version 2 of the License, or (at your option) any later version.
- *
- * This program is distributed in the hope 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 program; if not, write to the Free Software Foundation, Inc.,
- * 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.
- *
- */
-#ifndef __ANALYZER_UTILS__
-#define __ANALYZER_UTILS__
-
-#include <gst/gst.h>
-
-gboolean
-analyzer_sink_register_static ();
-
-#endif
+++ /dev/null
-/*
- * Copyright (c) <2013-2014>, Intel Corporation.
- * Author: Sreerenj Balachandran <sreerenj.balachandran@intel.com>
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Library General Public
- * License as published by the Free Software Foundation; either
- * version 2 of the License, or (at your option) any later version.
- *
- * This program is distributed in the hope 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 program; if not, write to the Free Software Foundation, Inc.,
- * 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.
- *
- */
-/*SECTION: analyzersink
- * A sink element to generate xml and hex files for each
- * video frame providing by the upstream parser element
- */
-#ifdef HAVE_CONFIG_H
-# include "config.h"
-#endif
-
-#include "gstanalyzersink.h"
-
-#include <string.h>
-
-static GstStaticPadTemplate sinktemplate = GST_STATIC_PAD_TEMPLATE ("sink",
- GST_PAD_SINK,
- GST_PAD_ALWAYS,
- GST_STATIC_CAPS ("video/mpeg, mpegversion=2" ";"
- "video/x-h264" ";" "video/x-h265"));
-
-/* AnalyzerSink signals and args */
-enum
-{
- SIGNAL_NEW_FRAME,
- LAST_SIGNAL
-};
-
-#define DEFAULT_SYNC FALSE
-#define DEFAULT_DUMP TRUE
-#define DEFAULT_NUM_BUFFERS -1
-
-enum
-{
- PROP_0,
- PROP_LOCATION,
- PROP_SILENT,
- PROP_DUMP,
- PROP_NUM_BUFFERS
-};
-
-#define gst_analyzer_sink_parent_class parent_class
-G_DEFINE_TYPE (GstAnalyzerSink, gst_analyzer_sink, GST_TYPE_BASE_SINK);
-
-static gboolean gst_analyzer_sink_set_caps (GstBaseSink * sink, GstCaps * caps);
-static void gst_analyzer_sink_set_property (GObject * object, guint prop_id,
- const GValue * value, GParamSpec * pspec);
-static void gst_analyzer_sink_get_property (GObject * object, guint prop_id,
- GValue * value, GParamSpec * pspec);
-static void gst_analyzer_sink_finalize (GObject * obj);
-
-static GstStateChangeReturn gst_analyzer_sink_change_state (GstElement *
- element, GstStateChange transition);
-
-static GstFlowReturn gst_analyzer_sink_render (GstBaseSink * bsink,
- GstBuffer * buffer);
-static gboolean gst_analyzer_sink_event (GstBaseSink * bsink, GstEvent * event);
-static gboolean gst_analyzer_sink_query (GstBaseSink * bsink, GstQuery * query);
-
-static guint gst_analyzer_sink_signals[LAST_SIGNAL] = { 0 };
-
-static void
-gst_analyzer_sink_class_init (GstAnalyzerSinkClass * klass)
-{
- GObjectClass *gobject_class;
- GstElementClass *gstelement_class;
- GstBaseSinkClass *gstbase_sink_class;
-
- gobject_class = G_OBJECT_CLASS (klass);
- gstelement_class = GST_ELEMENT_CLASS (klass);
- gstbase_sink_class = GST_BASE_SINK_CLASS (klass);
-
- gstbase_sink_class->set_caps = gst_analyzer_sink_set_caps;
- gobject_class->set_property = gst_analyzer_sink_set_property;
- gobject_class->get_property = gst_analyzer_sink_get_property;
- gobject_class->finalize = gst_analyzer_sink_finalize;
-
- g_object_class_install_property (gobject_class, PROP_LOCATION,
- g_param_spec_string ("location", "xml/hex files location",
- "Location of the xml/hex folder/files to write", NULL,
- G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
- g_object_class_install_property (gobject_class, PROP_DUMP,
- g_param_spec_boolean ("dump", "Dump",
- "Dump frame contents as hex to the specified location", DEFAULT_DUMP,
- G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
- g_object_class_install_property (gobject_class, PROP_NUM_BUFFERS,
- g_param_spec_int ("num-frames", "num-frames",
- "Number of frames to accept before going EOS", -1, G_MAXINT,
- DEFAULT_NUM_BUFFERS, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
-
- /**
- * GstAnalyzerSink::new-frame:
- * @analyzersink: the analyzersink instance
- * @buffer: the buffer that just has been received and analysed
- * @frame_num: the frame count
- *
- * This signal gets emitted before unreffing the buffer.
- */
- gst_analyzer_sink_signals[SIGNAL_NEW_FRAME] =
- g_signal_new ("new-frame", G_TYPE_FROM_CLASS (klass), G_SIGNAL_RUN_LAST,
- G_STRUCT_OFFSET (GstAnalyzerSinkClass, new_frame), NULL, NULL,
- g_cclosure_marshal_generic, G_TYPE_NONE, 2,
- GST_TYPE_BUFFER | G_SIGNAL_TYPE_STATIC_SCOPE, G_TYPE_INT);
-
- gst_element_class_set_static_metadata (gstelement_class,
- "Codec Analyzer Sink",
- "Sink",
- "Sink to dump the parsed information",
- "Sreerenj Balachandran<sreerenj.balachandran@intel.com>");
- gst_element_class_add_static_pad_template (gstelement_class, &sinktemplate);
-
- gstelement_class->change_state =
- GST_DEBUG_FUNCPTR (gst_analyzer_sink_change_state);
-
- gstbase_sink_class->event = GST_DEBUG_FUNCPTR (gst_analyzer_sink_event);
- gstbase_sink_class->render = GST_DEBUG_FUNCPTR (gst_analyzer_sink_render);
- gstbase_sink_class->query = GST_DEBUG_FUNCPTR (gst_analyzer_sink_query);
-}
-
-static void
-gst_analyzer_sink_init (GstAnalyzerSink * analyzersink)
-{
- analyzersink->dump = DEFAULT_DUMP;
- analyzersink->num_buffers = DEFAULT_NUM_BUFFERS;
- analyzersink->codec_type = GST_ANALYZER_CODEC_UNKNOWN;
- analyzersink->frame_num = 0;
- analyzersink->location = NULL;
- /* XXX: Add a generic structure to handle different codecs */
- analyzersink->mpeg2_hdrs = g_slice_new0 (Mpeg2Headers);
- gst_base_sink_set_sync (GST_BASE_SINK (analyzersink), DEFAULT_SYNC);
-}
-
-static void
-gst_analyzer_sink_finalize (GObject * obj)
-{
- GstAnalyzerSink *sink = GST_ANALYZER_SINK (obj);
-
- if (sink->location)
- g_free (sink->location);
-
- if (sink->mpeg2_hdrs) {
- if (sink->mpeg2_hdrs->sequencehdr)
- g_slice_free (GstMpegVideoSequenceHdr, sink->mpeg2_hdrs->sequencehdr);
- if (sink->mpeg2_hdrs->sequenceext)
- g_slice_free (GstMpegVideoSequenceExt, sink->mpeg2_hdrs->sequenceext);
- if (sink->mpeg2_hdrs->sequencedispext)
- g_slice_free (GstMpegVideoSequenceDisplayExt,
- sink->mpeg2_hdrs->sequencedispext);
- if (sink->mpeg2_hdrs->quantext)
- g_slice_free (GstMpegVideoQuantMatrixExt, sink->mpeg2_hdrs->quantext);
- g_slice_free (Mpeg2Headers, sink->mpeg2_hdrs);
- }
-
- G_OBJECT_CLASS (parent_class)->finalize (obj);
-}
-
-static gboolean
-gst_analyzer_sink_set_caps (GstBaseSink * bsink, GstCaps * caps)
-{
- GstStructure *structure;
- GstAnalyzerSink *sink = GST_ANALYZER_SINK (bsink);
-
- if (!caps)
- return FALSE;
-
- structure = gst_caps_get_structure (caps, 0);
- const gchar *name = gst_structure_get_name (structure);
-
- if (!g_strcmp0 (name, "video/mpeg"))
- sink->codec_type = GST_ANALYZER_CODEC_MPEG2_VIDEO;
- else
- return FALSE;
-
- return TRUE;
-}
-
-static void
-gst_analyzer_sink_set_property (GObject * object, guint prop_id,
- const GValue * value, GParamSpec * pspec)
-{
- GstAnalyzerSink *sink;
- const gchar *location;
-
- sink = GST_ANALYZER_SINK (object);
-
- switch (prop_id) {
- case PROP_LOCATION:
- location = g_value_get_string (value);
- if (sink->location)
- g_free (sink->location);
- sink->location = g_strdup (location);
- break;
- case PROP_DUMP:
- sink->dump = g_value_get_boolean (value);
- break;
- case PROP_NUM_BUFFERS:
- sink->num_buffers = g_value_get_int (value);
- break;
- default:
- G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
- break;
- }
-}
-
-static void
-gst_analyzer_sink_get_property (GObject * object, guint prop_id, GValue * value,
- GParamSpec * pspec)
-{
- GstAnalyzerSink *sink;
-
- sink = GST_ANALYZER_SINK (object);
-
- switch (prop_id) {
- case PROP_LOCATION:
- g_value_set_string (value, sink->location);
- break;
- case PROP_DUMP:
- g_value_set_boolean (value, sink->dump);
- break;
- case PROP_NUM_BUFFERS:
- g_value_set_int (value, sink->num_buffers);
- break;
- default:
- G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
- break;
- }
-}
-
-static gboolean
-gst_analyzer_sink_event (GstBaseSink * bsink, GstEvent * event)
-{
- GstAnalyzerSink *sink = GST_ANALYZER_SINK (bsink);
-
- return GST_BASE_SINK_CLASS (parent_class)->event (bsink, event);
-}
-
-static gboolean
-gst_analyzer_sink_dump_mem (GstAnalyzerSink * sink, const guchar * mem,
- guint size)
-{
- GString *string;
- FILE *fd;
- gchar *name;
- gchar *file_name;
- guint i = 0, j = 0;
-
- GST_DEBUG ("dump frame content with size = %d", size);
-
- /* XXX: Add a generic structure to handle different codec name string
- * For now analyzersink can only handle mpeg2meta:*/
-
- /* create a new hex file for each frame */
- name = g_strdup_printf ("mpeg2-%d.hex", sink->frame_num);
- file_name = g_build_filename (sink->location, "hex", name, NULL);
- GST_LOG ("Created a New hex file %s to dump the content", file_name);
- free (name);
-
- fd = fopen (file_name, "w");
- if (fd == NULL)
- return FALSE;
-
- string = g_string_sized_new (50);
-
- while (i < size) {
- g_string_append_printf (string, "%02x ", mem[i]);
-
- j++;
- i++;
-
- if (j == 32 || i == size) {
- fprintf (fd, "%s \n", string->str);
- g_string_set_size (string, 0);
- j = 0;
- }
- }
- g_string_free (string, TRUE);
- if (file_name)
- g_free (file_name);
-
- fclose (fd);
- return TRUE;
-}
-
-static GstFlowReturn
-gst_analyzer_sink_render (GstBaseSink * bsink, GstBuffer * buf)
-{
- GstAnalyzerSink *sink = GST_ANALYZER_SINK_CAST (bsink);
- GstMpegVideoMeta *mpeg_meta;
- gboolean ret;
-
- if (sink->num_buffers_left == 0)
- goto eos;
-
- if (sink->num_buffers_left != -1)
- sink->num_buffers_left--;
-
- if (sink->dump) {
- GstMapInfo info;
-
- gst_buffer_map (buf, &info, GST_MAP_READ);
- ret = gst_analyzer_sink_dump_mem (sink, info.data, info.size);
- gst_buffer_unmap (buf, &info);
- }
-
- switch (sink->codec_type) {
- case GST_ANALYZER_CODEC_MPEG2_VIDEO:
- {
- mpeg_meta = gst_buffer_get_mpeg_video_meta (buf);
- if (!mpeg_meta)
- goto no_mpeg_meta;
-
- GST_DEBUG_OBJECT (sink,
- "creatin mpeg2video_frame_xml for mpeg2frame with num=%d \n",
- sink->frame_num);
- if (!analyzer_create_mpeg2video_frame_xml (mpeg_meta, sink->location,
- sink->frame_num, sink->mpeg2_hdrs))
- goto error_create_xml;
- }
- break;
-
- case GST_ANALYZER_CODEC_H264:
- case GST_ANALYZER_CODEC_VC1:
- case GST_ANALYZER_CODEC_MPEG4_PART_TWO:
- case GST_ANALYZER_CODEC_H265:
- {
- GST_WARNING ("No codec support in analyzer sink");
- goto unknown_codec;
- }
- break;
-
- case GST_ANALYZER_CODEC_UNKNOWN:
- default:
- goto unknown_codec;
- }
-
- g_signal_emit (sink, gst_analyzer_sink_signals[SIGNAL_NEW_FRAME], 0, buf,
- sink->frame_num);
- sink->frame_num++;
-
- if (sink->num_buffers_left == 0)
- goto eos;
-
- return GST_FLOW_OK;
-
- /* ERRORS */
-no_mpeg_meta:
- {
- GST_DEBUG_OBJECT (sink, "no mpeg meta");
- return GST_FLOW_EOS;
- }
-unknown_codec:
- {
- GST_DEBUG_OBJECT (sink, "unknown codec");
- return GST_FLOW_EOS;
- }
-error_create_xml:
- {
- GST_DEBUG_OBJECT (sink, "failed to create xml for meta");
- return GST_FLOW_EOS;
- }
-eos:
- {
- GST_DEBUG_OBJECT (sink, "we are EOS");
- return GST_FLOW_EOS;
- }
-}
-
-static gboolean
-gst_analyzer_sink_query (GstBaseSink * bsink, GstQuery * query)
-{
- gboolean ret;
-
- switch (GST_QUERY_TYPE (query)) {
- case GST_QUERY_SEEKING:{
- GstFormat fmt;
-
- /* we don't supporting seeking */
- gst_query_parse_seeking (query, &fmt, NULL, NULL, NULL);
- gst_query_set_seeking (query, fmt, FALSE, 0, -1);
- ret = TRUE;
- break;
- }
- default:
- ret = GST_BASE_SINK_CLASS (parent_class)->query (bsink, query);
- break;
- }
-
- return ret;
-}
-
-static GstStateChangeReturn
-gst_analyzer_sink_change_state (GstElement * element, GstStateChange transition)
-{
- GstStateChangeReturn ret = GST_STATE_CHANGE_SUCCESS;
- GstAnalyzerSink *analyzersink = GST_ANALYZER_SINK (element);
-
- switch (transition) {
- case GST_STATE_CHANGE_NULL_TO_READY:
- break;
- case GST_STATE_CHANGE_READY_TO_PAUSED:
- analyzersink->num_buffers_left = analyzersink->num_buffers;
- break;
- case GST_STATE_CHANGE_PAUSED_TO_PLAYING:
- break;
- default:
- break;
- }
-
- ret = GST_ELEMENT_CLASS (parent_class)->change_state (element, transition);
-
- switch (transition) {
- case GST_STATE_CHANGE_PLAYING_TO_PAUSED:
- break;
- case GST_STATE_CHANGE_PAUSED_TO_READY:
- break;
- case GST_STATE_CHANGE_READY_TO_NULL:
- break;
- default:
- break;
- }
-
- return ret;
-
- /* ERROR */
-error:
- GST_ELEMENT_ERROR (element, CORE, STATE_CHANGE, (NULL),
- ("Erroring out on state change as requested"));
- return GST_STATE_CHANGE_FAILURE;
-}
+++ /dev/null
-/*
- * Copyright (c) 2013, Intel Corporation.
- * Author: Sreerenj Balachandran <sreerenj.balachandran@intel.com>
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Library General Public
- * License as published by the Free Software Foundation; either
- * version 2 of the License, or (at your option) any later version.
- *
- * This program is distributed in the hope 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 program; if not, write to the Free Software Foundation, Inc.,
- * 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.
- *
- */
-
-#ifndef __GST_ANALYZER_SINK_H__
-#define __GST_ANALYZER_SINK_H__
-
-#include <gst/gst.h>
-#include <gst/base/gstbasesink.h>
-#include <gst/codecparsers/gstmpegvideoparser.h>
-#include <gst/codecparsers/gstmpegvideometa.h>
-#include "mpeg_xml.h"
-
-G_BEGIN_DECLS
-
-#define GST_TYPE_ANALYZER_SINK \
- (gst_analyzer_sink_get_type())
-#define GST_ANALYZER_SINK(obj) \
- (G_TYPE_CHECK_INSTANCE_CAST((obj),GST_TYPE_ANALYZER_SINK,GstAnalyzerSink))
-#define GST_ANALYZER_SINK_CLASS(klass) \
- (G_TYPE_CHECK_CLASS_CAST((klass),GST_TYPE_ANALYZER_SINK,GstAnalyzerSinkClass))
-#define GST_IS_ANALYZER_SINK(obj) \
- (G_TYPE_CHECK_INSTANCE_TYPE((obj),GST_TYPE_ANALYZER_SINK))
-#define GST_IS_ANALYZER_SINK_CLASS(klass) \
- (G_TYPE_CHECK_CLASS_TYPE((klass),GST_TYPE_ANALYZER_SINK))
-#define GST_ANALYZER_SINK_CAST(obj) ((GstAnalyzerSink *)obj)
-
-typedef enum {
- GST_ANALYZER_CODEC_UNKNOWN = 0,
- GST_ANALYZER_CODEC_MPEG2_VIDEO = 1,
- GST_ANALYZER_CODEC_H264 = 2,
- GST_ANALYZER_CODEC_VC1 = 3,
- GST_ANALYZER_CODEC_MPEG4_PART_TWO = 4,
- GST_ANALYZER_CODEC_H265 = 5,
- GST_ANALYZER_CODEC_VP8 = 6,
- GST_ANALYZER_CODEC_VP9 = 7
-} GstAnalyzerCodecType;
-
-typedef struct _GstAnalyzerSink GstAnalyzerSink;
-typedef struct _GstAnalyzerSinkClass GstAnalyzerSinkClass;
-
-/**
- * GstAnalyzerSink:
- *
- * The opaque #GstAnalyzerSink data structure.
- */
-struct _GstAnalyzerSink {
- GstBaseSink element;
-
- gboolean dump;
- gint num_buffers;
- gint num_buffers_left;
- gint frame_num;
- gchar* location;
-
- GstAnalyzerCodecType codec_type;
-
- /* codec specific headers */
- Mpeg2Headers *mpeg2_hdrs;
-};
-
-struct _GstAnalyzerSinkClass {
- GstBaseSinkClass parent_class;
-
- /* signals */
- void (*new_frame) (GstElement *element, GstBuffer *buf, gint frame_num);
-};
-
-G_GNUC_INTERNAL GType gst_analyzer_sink_get_type (void);
-
-G_END_DECLS
-
-#endif /* __GST_ANALYZER_SINK_H__ */
+++ /dev/null
-/*
- * Copyright (c) 2013, Intel Corporation.
- * Author: Sreerenj Balachandran <sreerenj.balachandran@intel.com>
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Library General Public
- * License as published by the Free Software Foundation; either
- * version 2 of the License, or (at your option) any later version.
- *
- * This program is distributed in the hope 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 program; if not, write to the Free Software Foundation, Inc.,
- * 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.
- *
- */
-
-#include "mpeg_xml.h"
-#include "xml_utils.h"
-
-#include <glib.h>
-
-static gboolean
-create_seq_hdr_xml (xmlTextWriterPtr writer, GstMpegVideoSequenceHdr * seq_hdr)
-{
- ANALYZER_XML_ELEMENT_START (writer, "SequenceHdr");
-
- ANALYZER_XML_ELEMENT_CREATE_STRING (writer, "sequence_hdr_id", "0xb3",
- "nbits", 8);
-
- ANALYZER_XML_ELEMENT_CREATE_INT (writer, "horizontal_size_value",
- seq_hdr->width, "nbits", 12);
- ANALYZER_XML_ELEMENT_CREATE_INT (writer, "vertical_size_value",
- seq_hdr->height, "nbits", 12);
- ANALYZER_XML_ELEMENT_CREATE_INT (writer, "aspect_ratio_information",
- seq_hdr->aspect_ratio_info, "nbits", 4);
- ANALYZER_XML_ELEMENT_CREATE_INT (writer, "frame_rate_code",
- seq_hdr->frame_rate_code, "nbits", 4);
- ANALYZER_XML_ELEMENT_CREATE_INT (writer, "bit_rate_value",
- seq_hdr->bitrate_value, "nbits", 18);
- ANALYZER_XML_ELEMENT_CREATE_INT (writer, "vbv_buffer_size_value",
- seq_hdr->vbv_buffer_size_value, "nbits", 10);
- ANALYZER_XML_ELEMENT_CREATE_INT (writer, "constrained_parameters_flag",
- seq_hdr->constrained_parameters_flag, "nbits", 1);
-#if 0
- ANALYZER_XML_ELEMENT_CREATE_INT (writer, "load_intra_quantiser_matrix",
- seq_hdr->load_intra_quantiser_matrix, "nbits", 1);
-#endif
- ANALYZER_XML_ELEMENT_CREATE_MATRIX (writer, "intra_quantiser_matrix",
- seq_hdr->intra_quantizer_matrix, 8, 8);
-#if 0
- ANALYZER_XML_ELEMENT_CREATE_INT (writer, "load_non_intra_quantiser_matrix",
- seq_hdr->load_non_intra_quantiser_matrix, "nbits", 1);
-#endif
- ANALYZER_XML_ELEMENT_CREATE_MATRIX (writer, "non_intra_quantizer_matrix",
- seq_hdr->non_intra_quantizer_matrix, 8, 8);
- ANALYZER_XML_ELEMENT_CREATE_INT (writer, "bit_rate_calculated",
- seq_hdr->bitrate, "nbits", 0);
- ANALYZER_XML_ELEMENT_CREATE_INT (writer, "par_w_calculated",
- seq_hdr->par_w, "nbits", 0);
- ANALYZER_XML_ELEMENT_CREATE_INT (writer, "par_h_calculated",
- seq_hdr->par_h, "nbits", 0);
- ANALYZER_XML_ELEMENT_CREATE_INT (writer, "fps_n_calculated",
- seq_hdr->fps_n, "nbits", 0);
- ANALYZER_XML_ELEMENT_CREATE_INT (writer, "fps_d_calculated",
- seq_hdr->fps_d, "nbits", 0);
-
-
- ANALYZER_XML_ELEMENT_END (writer);
-
- return TRUE;
-
-error:
- {
- GST_ERROR ("Failed to write the xml for Mpeg2Video SequenceHeader \n");
- return FALSE;
- }
-}
-
-static gboolean
-create_seq_ext_xml (xmlTextWriterPtr writer, GstMpegVideoSequenceExt * seq_ext)
-{
- ANALYZER_XML_ELEMENT_START (writer, "SequenceExt");
-
- ANALYZER_XML_ELEMENT_CREATE_STRING (writer, "extension_identifier", "0xb5",
- "nbits", 8);
- ANALYZER_XML_ELEMENT_CREATE_STRING (writer, "sequence_extension_id", "0x01",
- "nbits", 4);
- ANALYZER_XML_ELEMENT_CREATE_INT (writer, "profile", seq_ext->profile, "nbits",
- 3);
- ANALYZER_XML_ELEMENT_CREATE_INT (writer, "level", seq_ext->level, "nbits", 4);
- ANALYZER_XML_ELEMENT_CREATE_INT (writer, "progressive_sequence",
- seq_ext->progressive, "nbits", 1);
- ANALYZER_XML_ELEMENT_CREATE_INT (writer, "chroma_fromat",
- seq_ext->chroma_format, "nbits", 2);
- ANALYZER_XML_ELEMENT_CREATE_INT (writer, "horizontal_size_ext",
- seq_ext->horiz_size_ext, "nbits", 2);
- ANALYZER_XML_ELEMENT_CREATE_INT (writer, "vertical_size_ext",
- seq_ext->vert_size_ext, "nbits", 2);
- ANALYZER_XML_ELEMENT_CREATE_INT (writer, "bit_rate_ext", seq_ext->bitrate_ext,
- "nbits", 12);
- ANALYZER_XML_ELEMENT_CREATE_INT (writer, "vbv_buffer_size_ex",
- seq_ext->vbv_buffer_size_extension, "nbits", 8);
- ANALYZER_XML_ELEMENT_CREATE_INT (writer, "low_delay", seq_ext->low_delay,
- "nbits", 1);
- ANALYZER_XML_ELEMENT_CREATE_INT (writer, "fps_ext_n", seq_ext->fps_n_ext,
- "nbits", 2);
- ANALYZER_XML_ELEMENT_CREATE_INT (writer, "fps_ext_d", seq_ext->fps_d_ext,
- "nbits", 5);
-
- ANALYZER_XML_ELEMENT_END (writer);
-
- return TRUE;
-
-error:
- {
- GST_ERROR ("Failed to write the xml for Mpeg2Video SequenceExt \n");
- return FALSE;
- }
-}
-
-static gboolean
-create_seq_disp_ext_xml (xmlTextWriterPtr writer,
- GstMpegVideoSequenceDisplayExt * seq_disp_ext)
-{
- ANALYZER_XML_ELEMENT_START (writer, "SequenceDispExt");
-
- ANALYZER_XML_ELEMENT_CREATE_STRING (writer, "extension_identifier", "0xb5",
- "nbits", 8);
- ANALYZER_XML_ELEMENT_CREATE_STRING (writer, "sequence_display_extension_id",
- "0x02", "nbits", 4);
- ANALYZER_XML_ELEMENT_CREATE_INT (writer, "video_format",
- seq_disp_ext->video_format, "nbits", 3);
- ANALYZER_XML_ELEMENT_CREATE_INT (writer, "colour_description_flag",
- seq_disp_ext->colour_description_flag, "nbits", 1);
- ANALYZER_XML_ELEMENT_CREATE_INT (writer, "colour_primaries",
- seq_disp_ext->colour_primaries, "nbits", 8);
- ANALYZER_XML_ELEMENT_CREATE_INT (writer, "transfer_characteristics",
- seq_disp_ext->transfer_characteristics, "nbits", 8);
- ANALYZER_XML_ELEMENT_CREATE_INT (writer, "matrix_coefficients",
- seq_disp_ext->matrix_coefficients, "nbits", 8);
- ANALYZER_XML_ELEMENT_CREATE_INT (writer, "display_horizontal_size",
- seq_disp_ext->display_horizontal_size, "nbits", 14);
- ANALYZER_XML_ELEMENT_CREATE_INT (writer, "display_vertical_size",
- seq_disp_ext->display_vertical_size, "nbits", 14);
-
- ANALYZER_XML_ELEMENT_END (writer);
-
- return TRUE;
-
-error:
- {
- GST_ERROR ("Failed to write the xml for Mpeg2Video SequenceDisplayExt \n");
- return FALSE;
- }
-}
-
-static gboolean
-create_gop_hdr_xml (xmlTextWriterPtr writer, GstMpegVideoGop * gop_hdr)
-{
- ANALYZER_XML_ELEMENT_START (writer, "GopHdr");
-
- ANALYZER_XML_ELEMENT_CREATE_STRING (writer, "gop_hdr_id", "0xb8", "nbits", 8);
- ANALYZER_XML_ELEMENT_CREATE_INT (writer, "drop_frame_flag",
- gop_hdr->drop_frame_flag, "nbits", 1);
- ANALYZER_XML_ELEMENT_CREATE_INT (writer, "time_code_hours", gop_hdr->hour,
- "nbits", 5);
- ANALYZER_XML_ELEMENT_CREATE_INT (writer, "time_code_minutes", gop_hdr->minute,
- "nbits", 6);
- ANALYZER_XML_ELEMENT_CREATE_INT (writer, "time_code_seconds", gop_hdr->second,
- "nbits", 6);
- ANALYZER_XML_ELEMENT_CREATE_INT (writer, "time_code_pictures", gop_hdr->frame,
- "nbits", 6);
- ANALYZER_XML_ELEMENT_CREATE_INT (writer, "closed_gop", gop_hdr->closed_gop,
- "nbits", 1);
- ANALYZER_XML_ELEMENT_CREATE_INT (writer, "broken_link", gop_hdr->broken_link,
- "nbits", 1);
- ANALYZER_XML_ELEMENT_END (writer);
-
- return TRUE;
-error:
- {
- GST_ERROR ("Failed to write the xml for Mpeg2Video GopHdr \n");
- return FALSE;
- }
-}
-
-static gboolean
-create_pic_hdr_xml (xmlTextWriterPtr writer, GstMpegVideoPictureHdr * pic_hdr)
-{
- ANALYZER_XML_ELEMENT_START (writer, "PicHdr");
-
- ANALYZER_XML_ELEMENT_CREATE_STRING (writer, "picture_hdr_id", "0x00",
- "nbits", 8);
- ANALYZER_XML_ELEMENT_CREATE_INT (writer, "temporal_reference", pic_hdr->tsn,
- "nbits", 10);
- ANALYZER_XML_ELEMENT_CREATE_INT (writer, "picture_coding_type",
- pic_hdr->pic_type, "nbits", 3);
-#if 0
- ANALYZER_XML_ELEMENT_CREATE_INT (writer, "vbv_delay", pic_hdr->vbv_delay,
- "nbits", 16);
-#endif
- ANALYZER_XML_ELEMENT_CREATE_INT (writer, "full_pel_forward_vector",
- pic_hdr->full_pel_forward_vector, "nbits", 1);
- ANALYZER_XML_ELEMENT_CREATE_INT (writer, "forward_f_code",
- pic_hdr->f_code[0][0], "nbits", 3);
- ANALYZER_XML_ELEMENT_CREATE_INT (writer, "full_pel_backword_vector",
- pic_hdr->full_pel_backward_vector, "nbits", 1);
- ANALYZER_XML_ELEMENT_CREATE_INT (writer, "backword_f_code",
- pic_hdr->f_code[1][0], "nbits", 3);
-
- ANALYZER_XML_ELEMENT_END (writer);
-
- return TRUE;
-error:
- {
- GST_ERROR ("Failed to write the xml for Mpeg2Video PicHdr \n");
- return FALSE;
- }
-}
-
-static gboolean
-create_pic_ext_xml (xmlTextWriterPtr writer, GstMpegVideoPictureExt * pic_ext)
-{
- ANALYZER_XML_ELEMENT_START (writer, "PicExt");
-
- ANALYZER_XML_ELEMENT_CREATE_STRING (writer, "extension_identifier", "0xb5",
- "nbits", 8);
- ANALYZER_XML_ELEMENT_CREATE_STRING (writer, "picture_extension_id", "0x08",
- "nbits", 4);
- ANALYZER_XML_ELEMENT_CREATE_INT (writer, "f_code_forward_horizontal",
- pic_ext->f_code[0][0], "nbits", 4);
- ANALYZER_XML_ELEMENT_CREATE_INT (writer, "f_code_forward_vertical",
- pic_ext->f_code[0][1], "nbits", 4);
- ANALYZER_XML_ELEMENT_CREATE_INT (writer, "f_code_backward_horizontal",
- pic_ext->f_code[1][0], "nbits", 4);
- ANALYZER_XML_ELEMENT_CREATE_INT (writer, "f_cod_backward_vertical",
- pic_ext->f_code[1][1], "nbits", 4);
- ANALYZER_XML_ELEMENT_CREATE_INT (writer, "intra_dc_precision",
- pic_ext->intra_dc_precision, "nbits", 2);
- ANALYZER_XML_ELEMENT_CREATE_INT (writer, "picture_structure",
- pic_ext->picture_structure, "nbits", 2);
- ANALYZER_XML_ELEMENT_CREATE_INT (writer, "top_field_first",
- pic_ext->top_field_first, "nbits", 1);
- ANALYZER_XML_ELEMENT_CREATE_INT (writer, "frame_pred_frame_dct",
- pic_ext->frame_pred_frame_dct, "nbits", 1);
- ANALYZER_XML_ELEMENT_CREATE_INT (writer, "concealment_motion_vectors",
- pic_ext->concealment_motion_vectors, "nbits", 1);
- ANALYZER_XML_ELEMENT_CREATE_INT (writer, "q_scale_type",
- pic_ext->q_scale_type, "nbits", 1);
- ANALYZER_XML_ELEMENT_CREATE_INT (writer, "intra_vlc_format",
- pic_ext->intra_vlc_format, "nbits", 1);
- ANALYZER_XML_ELEMENT_CREATE_INT (writer, "alternate_scan",
- pic_ext->alternate_scan, "nbits", 1);
- ANALYZER_XML_ELEMENT_CREATE_INT (writer, "repeat_first_field",
- pic_ext->repeat_first_field, "nbits", 1);
- ANALYZER_XML_ELEMENT_CREATE_INT (writer, "chroma_420_type",
- pic_ext->chroma_420_type, "nbits", 1);
- ANALYZER_XML_ELEMENT_CREATE_INT (writer, "progressive_frame",
- pic_ext->progressive_frame, "nbits", 1);
- ANALYZER_XML_ELEMENT_CREATE_INT (writer, "composite_display_flag",
- pic_ext->composite_display, "nbits", 1);
- if (pic_ext->composite_display) {
- ANALYZER_XML_ELEMENT_CREATE_INT (writer, "v_axis", pic_ext->v_axis, "nbits",
- 1);
- ANALYZER_XML_ELEMENT_CREATE_INT (writer, "field_sequence",
- pic_ext->field_sequence, "nbits", 3);
- ANALYZER_XML_ELEMENT_CREATE_INT (writer, "sub_carrier",
- pic_ext->sub_carrier, "nbits", 1);
- ANALYZER_XML_ELEMENT_CREATE_INT (writer, "burst_amplitude",
- pic_ext->burst_amplitude, "nbits", 7);
- ANALYZER_XML_ELEMENT_CREATE_INT (writer, "sub_carrier_phase",
- pic_ext->sub_carrier_phase, "nbits", 8);
- }
- ANALYZER_XML_ELEMENT_END (writer);
-
- return TRUE;
-error:
- {
- GST_ERROR ("Failed to write the xml for Mpeg2Video PicHdr \n");
- return FALSE;
- }
-}
-
-static gboolean
-create_quant_ext_xml (xmlTextWriterPtr writer,
- GstMpegVideoQuantMatrixExt * quant_ext)
-{
- ANALYZER_XML_ELEMENT_START (writer, "QuantMatrixExt");
-
- ANALYZER_XML_ELEMENT_CREATE_STRING (writer, "extension_identifier", "0xb5",
- "nbits", 8);
- ANALYZER_XML_ELEMENT_CREATE_STRING (writer, "quant_matrix_extension_id",
- "0x03", "nbits", 4);
-
- ANALYZER_XML_ELEMENT_CREATE_INT (writer, "load_intra_quantiser_matrix",
- quant_ext->load_intra_quantiser_matrix, "nbits", 1);
- ANALYZER_XML_ELEMENT_CREATE_MATRIX (writer, "intra_quantizer_matrix",
- quant_ext->intra_quantiser_matrix, 8, 8);
- ANALYZER_XML_ELEMENT_CREATE_INT (writer, "load_non_intra_quantiser_matrix",
- quant_ext->load_non_intra_quantiser_matrix, "nbits", 1);
- ANALYZER_XML_ELEMENT_CREATE_MATRIX (writer, "non_intra_quantizer_matrix",
- quant_ext->non_intra_quantiser_matrix, 8, 8);
- ANALYZER_XML_ELEMENT_CREATE_INT (writer, "load_chroma_intra_quantiser_matrix",
- quant_ext->load_chroma_intra_quantiser_matrix, "nbits", 1);
- ANALYZER_XML_ELEMENT_CREATE_MATRIX (writer, "chroma_intra_quantizer_matrix",
- quant_ext->chroma_intra_quantiser_matrix, 8, 8);
- ANALYZER_XML_ELEMENT_CREATE_INT (writer,
- "load_chroma_non_intra_quantiser_matrix",
- quant_ext->load_chroma_non_intra_quantiser_matrix, "nbits", 1);
- ANALYZER_XML_ELEMENT_CREATE_MATRIX (writer,
- "chroma_non_intra_quantizer_matrix",
- quant_ext->chroma_non_intra_quantiser_matrix, 8, 8);
-
- ANALYZER_XML_ELEMENT_END (writer);
-
- return TRUE;
-error:
- {
- GST_ERROR ("Failed to write the xml for Mpeg2Video QuantizationMatrices! ");
- return FALSE;
- }
- return TRUE;
-}
-
-#if 0
-static gboolean
-create_slice_hdr_xml (xmlTextWriterPtr writer,
- GstMpegVideoMetaSliceInfo * slice_info, gint slice_num)
-{
- char header_name[256];
-
- sprintf (header_name, "slice_%d", slice_num);
-
- ANALYZER_XML_ELEMENT_START (writer, header_name);
-
- ANALYZER_XML_ELEMENT_CREATE_INT (writer, "slice_hdr_identifier",
- slice_info->slice_hdr.slice_id, "nbits", 8);
- if (slice_info->slice_hdr.vertical_position_ext) {
- ANALYZER_XML_ELEMENT_CREATE_INT (writer, "vertical_position_ext",
- slice_info->slice_hdr.vertical_position_ext, "nbits", 3);
- }
- ANALYZER_XML_ELEMENT_CREATE_INT (writer, "priority_breakpoint",
- slice_info->slice_hdr.priority_breakpoint, "nbits", 7);
- ANALYZER_XML_ELEMENT_CREATE_INT (writer, "quantiser_scale_code",
- slice_info->slice_hdr.quantiser_scale_code, "nbits", 5);
- ANALYZER_XML_ELEMENT_CREATE_INT (writer, "slice_ext_flag",
- slice_info->slice_hdr.slice_ext_flag, "nbits", 1);
-
- if (!slice_info->slice_hdr.slice_ext_flag) {
- ANALYZER_XML_ELEMENT_CREATE_INT (writer, "intra_slice",
- slice_info->slice_hdr.intra_slice, "nbits", 1);
- } else {
- ANALYZER_XML_ELEMENT_CREATE_INT (writer, "intra_slice",
- slice_info->slice_hdr.intra_slice, "nbits", 1);
- ANALYZER_XML_ELEMENT_CREATE_INT (writer, "slice_picture_id_enable",
- slice_info->slice_hdr.slice_picture_id_enable, "nbits", 1);
- ANALYZER_XML_ELEMENT_CREATE_INT (writer, "slice_picture_id",
- slice_info->slice_hdr.slice_picture_id, "nbits", 6);
- }
- ANALYZER_XML_ELEMENT_CREATE_INT (writer, "header_size_calculated",
- slice_info->slice_hdr.header_size, "nbits", 0);
- ANALYZER_XML_ELEMENT_CREATE_INT (writer, "mb_row_calculated",
- slice_info->slice_hdr.mb_row, "nbits", 0);
- ANALYZER_XML_ELEMENT_CREATE_INT (writer, "mb_column_calculated",
- slice_info->slice_hdr.mb_column, "nbits", 0);
-
- ANALYZER_XML_ELEMENT_CREATE_INT (writer, "slice_offset_calculated",
- slice_info->slice_offset, "nbits", 0);
- ANALYZER_XML_ELEMENT_CREATE_INT (writer, "slice_size_calculated",
- slice_info->slice_size, "nbits", 0);
-
- ANALYZER_XML_ELEMENT_END (writer);
-
- return TRUE;
-error:
- {
- GST_ERROR ("Failed to write the xml for Mpeg2Video SliceHdr_%d \n",
- slice_num);
- return FALSE;
- }
- return TRUE;
-}
-#endif
-gboolean
-analyzer_create_mpeg2video_frame_xml (GstMpegVideoMeta * mpeg_meta,
- gchar * location, gint frame_num, Mpeg2Headers * mpeg2_hdrs)
-{
- xmlTextWriterPtr writer;
- xmlDocPtr doc;
- xmlBufferPtr buf;
- xmlChar *tmp;
- gchar *file_name;
- gchar *name;
- int fd, i;
- GstMpegVideoSequenceHdr *sequencehdr = NULL;
- GstMpegVideoSequenceExt *sequenceext = NULL;
- GstMpegVideoSequenceDisplayExt *sequencedispext = NULL;
- GstMpegVideoQuantMatrixExt *quantext = NULL;
-
- if (!mpeg_meta)
- return FALSE;
-
- xmlKeepBlanksDefault (0);
-
- writer = xmlNewTextWriterDoc (&doc, 0);
- if (!writer) {
- GST_ERROR ("Error: creating xml text writer \n");
- return FALSE;
- }
-
- if (xmlTextWriterStartDocument (writer, NULL, "UTF-8", NULL) < 0) {
- GST_ERROR ("Error: xmlTextWriterStartDocument");
- return FALSE;
- }
-
- if (xmlTextWriterStartElement (writer, (xmlChar *) "mpeg2") < 0) {
- GST_ERROR ("Error: Failed to start the new element (root element) mpeg2");
- return FALSE;
- }
-
- if (xmlTextWriterWriteComment (writer,
- (xmlChar *) "Data parssed from the mpeg2 stream") < 0) {
- g_printerr ("Error: Failed to write the comment\n");
- return FALSE;
- }
-
- /* Each time we save the gerneral headers, which will get appended for
- each frame xml files */
-
- /* SequenceHdr */
- if (mpeg_meta->sequencehdr) {
- sequencehdr = mpeg_meta->sequencehdr;
-
- if (mpeg2_hdrs->sequencehdr)
- g_slice_free (GstMpegVideoSequenceHdr, mpeg2_hdrs->sequencehdr);
- mpeg2_hdrs->sequencehdr =
- g_slice_dup (GstMpegVideoSequenceHdr, mpeg_meta->sequencehdr);
-
- } else if (mpeg2_hdrs->sequencehdr)
- sequencehdr = mpeg2_hdrs->sequencehdr;
-
- /* SequenceExtHdr */
- if (mpeg_meta->sequenceext) {
- sequenceext = mpeg_meta->sequenceext;
-
- if (mpeg2_hdrs->sequenceext)
- g_slice_free (GstMpegVideoSequenceExt, mpeg2_hdrs->sequenceext);
- mpeg2_hdrs->sequenceext =
- g_slice_dup (GstMpegVideoSequenceExt, mpeg_meta->sequenceext);
-
- } else if (mpeg2_hdrs->sequenceext)
- sequenceext = mpeg2_hdrs->sequenceext;
-
- /* SequenceDisplayExt */
- if (mpeg_meta->sequencedispext) {
- sequencedispext = mpeg_meta->sequencedispext;
-
- if (mpeg2_hdrs->sequencedispext)
- g_slice_free (GstMpegVideoSequenceDisplayExt,
- mpeg2_hdrs->sequencedispext);
- mpeg2_hdrs->sequencedispext =
- g_slice_dup (GstMpegVideoSequenceDisplayExt,
- mpeg_meta->sequencedispext);
-
- } else if (mpeg2_hdrs->sequencedispext)
- sequencedispext = mpeg2_hdrs->sequencedispext;
-
- /* QuantMatrixExt */
- if (mpeg_meta->quantext) {
- quantext = mpeg_meta->quantext;
-
- if (mpeg2_hdrs->quantext)
- g_slice_free (GstMpegVideoQuantMatrixExt, mpeg2_hdrs->quantext);
- mpeg2_hdrs->quantext =
- g_slice_dup (GstMpegVideoQuantMatrixExt, mpeg_meta->quantext);
-
- } else if (mpeg2_hdrs->quantext)
- quantext = mpeg2_hdrs->quantext;
-
- /*Create xmls for each headers */
-
- if (sequencehdr)
- if (!create_seq_hdr_xml (writer, sequencehdr))
- return FALSE;
-
- if (sequenceext) {
- if (!create_seq_ext_xml (writer, sequenceext))
- return FALSE;
- }
-
- if (mpeg_meta->sequencedispext) {
- if (!create_seq_disp_ext_xml (writer, sequencedispext))
- return FALSE;
- }
-
- if (quantext) {
- if (!create_quant_ext_xml (writer, quantext))
- return FALSE;
- }
-#if 0
- if (mpeg_meta->gophdr) {
- if (!create_gop_hdr_xml (writer, mpeg_meta->gophdr))
- return FALSE;
- }
-#endif
- if (mpeg_meta->pichdr) {
- if (!create_pic_hdr_xml (writer, mpeg_meta->pichdr))
- return FALSE;
- }
-
- if (mpeg_meta->picext) {
- if (!create_pic_ext_xml (writer, mpeg_meta->picext))
- return FALSE;
- }
-#if 0
- if (mpeg_meta->slice_info_array) {
- for (i = 0; i < mpeg_meta->slice_info_array->len; i++) {
- GstMpegVideoMetaSliceInfo *slice_info = NULL;
- slice_info =
- &g_array_index (mpeg_meta->slice_info_array,
- GstMpegVideoMetaSliceInfo, i);
- if (!slice_info) {
- g_error ("Failed to get slice details from meta.. \n");
- return FALSE;
- }
- if (!create_slice_hdr_xml (writer, slice_info, i))
- return FALSE;
- }
- }
-#endif
- if (xmlTextWriterEndElement (writer) < 0) {
- g_printerr ("Error: Failed to end mpeg2 root element\n");
- return FALSE;
- }
-
- if (xmlTextWriterEndDocument (writer) < 0) {
- g_printerr ("Error: Ending document\n");
- return FALSE;
- }
-
- xmlFreeTextWriter (writer);
-
- /* create a new xml file for each frame */
- name = g_strdup_printf ("mpeg2-%d.xml", frame_num);
- file_name = g_build_filename (location, "xml", name, NULL);
- GST_LOG ("Created a New xml file %s to dump the parsed info", file_name);
-
- xmlSaveFormatFile (file_name, doc, 1);
-
- if (name)
- g_free (name);
- if (file_name)
- g_free (file_name);
-
- return TRUE;
-}
-
-gboolean
-analyzer_create_mpeg2video_frame_hex (GstMpegVideoMeta * mpeg_meta,
- gint frame_num, guint * data)
-{
- return TRUE;
-}
+++ /dev/null
-/*
- * Copyright (c) 2013, Intel Corporation.
- * Author: Sreerenj Balachandran <sreerenj.balachandran@intel.com>
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Library General Public
- * License as published by the Free Software Foundation; either
- * version 2 of the License, or (at your option) any later version.
- *
- * This program is distributed in the hope 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 program; if not, write to the Free Software Foundation, Inc.,
- * 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.
- *
- */
-#ifndef __GST_OPEN_CODEC_ANALYSER_MPEG_XML__
-#define __GST_OPEN_CODEC_ANALYSER_MPEG_XML__
-
-#include <gst/codecparsers/gstmpegvideometa.h>
-#include <gst/codecparsers/gstmpegvideoparser.h>
-#include <libxml/tree.h>
-#include <libxml/encoding.h>
-#include <libxml/xmlwriter.h>
-
-typedef struct {
- GstMpegVideoSequenceHdr *sequencehdr;
- GstMpegVideoSequenceExt *sequenceext;
- GstMpegVideoSequenceDisplayExt *sequencedispext;
- GstMpegVideoQuantMatrixExt *quantext;
-}Mpeg2Headers;
-
-gboolean
-analyzer_create_mpeg2video_frame_xml (GstMpegVideoMeta *mpeg_meta,
- gchar *location,
- gint frame_num,
- Mpeg2Headers *mpeg2_hdrs);
-
-gboolean
-analyzer_create_mpeg2video_frame_hex (GstMpegVideoMeta *mpeg_meta,
- gint frame_num, guint *data);
-#endif
+++ /dev/null
-/*
- * Copyright (c) 2013, Intel Corporation.
- * Author: Sreerenj Balachandran <sreerenj.balachandran@intel.com>
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Library General Public
- * License as published by the Free Software Foundation; either
- * version 2 of the License, or (at your option) any later version.
- *
- * This program is distributed in the hope 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 program; if not, write to the Free Software Foundation, Inc.,
- * 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.
- *
- */
-#ifdef HAVE_CONFIG_H
-#include "config.h"
-#endif
-
-#include "gstanalyzersink.h"
-
-static gboolean
-plugin_init (GstPlugin * plugin)
-{
- gboolean ret = FALSE;
-
- ret |= gst_element_register (plugin, "analyzersink",
- GST_RANK_PRIMARY + 1, GST_TYPE_ANALYZER_SINK);
-
- return ret;
-}
-
-GST_PLUGIN_DEFINE (GST_VERSION_MAJOR,
- GST_VERSION_MINOR,
- analyzersink,
- "sink element to dump parsed information to the xml",
- plugin_init, VERSION, "LGPL", PACKAGE_NAME, PACKAGE_URL);
+++ /dev/null
-/*
- * Copyright (c) 2013, Intel Corporation.
- * Author: Sreerenj Balachandran <sreerenj.balachandran@intel.com>
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Library General Public
- * License as published by the Free Software Foundation; either
- * version 2 of the License, or (at your option) any later version.
- *
- * This program is distributed in the hope 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 program; if not, write to the Free Software Foundation, Inc.,
- * 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.
- *
- */
-
-#include "xml_utils.h"
+++ /dev/null
-/*
- * Copyright (c) 2013, Intel Corporation.
- * Author: Sreerenj Balachandran <sreerenj.balachandran@intel.com>
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Library General Public
- * License as published by the Free Software Foundation; either
- * version 2 of the License, or (at your option) any later version.
- *
- * This program is distributed in the hope 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 program; if not, write to the Free Software Foundation, Inc.,
- * 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.
- *
- */
-#ifndef __XML_UTILS_H__
-#define __XML_UTILS_H__
-
-#include <gst/gst.h>
-#include <libxml/tree.h>
-#include <libxml/encoding.h>
-#include <libxml/xmlwriter.h>
-
-#define ANALYZER_XML_ELEMENT_START(writer,element) { \
- if (xmlTextWriterStartElement (writer, (xmlChar *)element) < 0) { \
- GST_ERROR ("Failed to start the element %s",element); \
- goto error; \
- } \
-}
-
-/* to create a new #element with #content */
-#define ANALYZER_XML_ELEMENT_NEW(writer,element, content) { \
- if (xmlTextWriterWriteElement (writer, (xmlChar *)element, content) < 0) { \
- GST_ERROR ("Failed to write %s to the element %s",content, element); \
- goto error; \
- } \
-}
-
-#define ANALYZER_XML_ELEMENT_CONTENT_INTEGER_WRITE(writer,content) { \
- if (xmlTextWriterWriteFormatRaw (writer, "%d ", content) < 0) { \
- GST_ERROR ("Failed to write %d to the element",content); \
- goto error; \
- } \
-}
-
-#define ANALYZER_XML_ELEMENT_CONTENT_STRING_WRITE(writer,content) { \
- if (xmlTextWriterWriteFormatRaw (writer, "%s", content) < 0) { \
- GST_ERROR ("Failed to write %s to the element",content); \
- goto error; \
- } \
-}
-
-#define ANALYZER_XML_ELEMENT_ATTRIBUTE_INTEGER_WRITE(writer, attribute, value) { \
- if (xmlTextWriterWriteFormatAttribute (writer, (xmlChar *)attribute, "%d", value) < 0) { \
- GST_ERROR ("Failed to add attribute %s with value %d",attribute, value); \
- goto error; \
- } \
-}
-
-#define ANALYZER_XML_ELEMENT_WRITE_STRING (writer,element,content) { \
- if (xmlTextWriterWriteFormatElement (writer, (xmlChar *)element, "%s", content) < 0) { \
- GST_ERROR ("Failed to write %s to the element %s",content, element); \
- goto error; \
- } \
-}
-
-#define ANALYZER_XML_ELEMENT_END(writer) { \
- if (xmlTextWriterEndElement (writer) < 0) { \
- GST_ERROR ("Failed to end the element"); \
- goto error; \
- } \
-}
-
-#define ANALYZER_XML_ELEMENT_CREATE_INT(writer,element,content,attribute,value) { \
- ANALYZER_XML_ELEMENT_START (writer, element); \
- if (0 != value) \
- ANALYZER_XML_ELEMENT_ATTRIBUTE_INTEGER_WRITE (writer, attribute, value); \
- ANALYZER_XML_ELEMENT_CONTENT_INTEGER_WRITE (writer, content); \
- ANALYZER_XML_ELEMENT_END (writer); \
-}
-
-#define ANALYZER_XML_ELEMENT_CREATE_STRING(writer,element,content,attribute,value) { \
- ANALYZER_XML_ELEMENT_START (writer, element); \
- if (value != 0) \
- ANALYZER_XML_ELEMENT_ATTRIBUTE_INTEGER_WRITE (writer, attribute, value); \
- ANALYZER_XML_ELEMENT_CONTENT_STRING_WRITE (writer, content); \
- ANALYZER_XML_ELEMENT_END (writer); \
-}
-
-#define ANALYZER_XML_ELEMENT_CREATE_MATRIX(writer,element,content,rows,columns) { \
- int i, j; \
- int num_elements = rows * columns; \
- ANALYZER_XML_ELEMENT_START (writer, element); \
- ANALYZER_XML_ELEMENT_ATTRIBUTE_INTEGER_WRITE (writer, "is-matrix", 1); \
- ANALYZER_XML_ELEMENT_ATTRIBUTE_INTEGER_WRITE (writer, "rows", rows); \
- ANALYZER_XML_ELEMENT_ATTRIBUTE_INTEGER_WRITE (writer, "columns", columns); \
- for (i = 0; i < num_elements; i++) \
- ANALYZER_XML_ELEMENT_CONTENT_INTEGER_WRITE (writer, content[i]); \
- ANALYZER_XML_ELEMENT_END (writer); \
-}
-
-#endif /* __XML_UTILS_H__ */
+++ /dev/null
-/*
- * Copyright (c) 2013, Intel Corporation.
- * Author: Sreerenj Balachandran <sreerenj.balachandran@intel.com>
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Library General Public
- * License as published by the Free Software Foundation; either
- * version 2 of the License, or (at your option) any later version.
- *
- * This program is distributed in the hope 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 program; if not, write to the Free Software Foundation, Inc.,
- * 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.
- *
- */
-#include "xml_parse.h"
-
-#include <glib.h>
-
-void
-analyzer_node_list_free (GList * list)
-{
- g_list_free_full (list, (GDestroyNotify) analyzer_node_free);
-}
-
-void
-analyzer_node_free (gpointer data)
-{
- AnalyzerNode *node = (AnalyzerNode *) data;
-
- if (node) {
- if (node->field_name)
- g_free (node->field_name);
- if (node->value)
- g_free (node->value);
- if (node->nbits)
- g_free (node->nbits);
- if (node->is_matrix)
- g_free (node->is_matrix);
- }
-}
-
-AnalyzerNode *
-analyzer_node_new ()
-{
- AnalyzerNode *node;
-
- node = g_slice_new0 (AnalyzerNode);
-
- return node;
-}
-
-GList *
-analyzer_get_list_header_strings (char *file_name)
-{
- xmlDocPtr doc;
- xmlNodePtr cur, tmp;
- GList *list = NULL;
- AnalyzerNode *node;
-
- doc = xmlParseFile (file_name);
- if (!doc) {
- g_printerr ("Failed to do xmlParseFile for the file.. %s\n", file_name);
- goto error;
- }
-
- cur = xmlDocGetRootElement (doc);
- if (cur == NULL) {
- g_printerr ("empty document\n");
- xmlFreeDoc (doc);
- goto error;
- }
-
- if (xmlStrcmp (cur->name, (const xmlChar *) "mpeg2") &&
- xmlStrcmp (cur->name, (const xmlChar *) "h264") &&
- xmlStrcmp (cur->name, (const xmlChar *) "h265")) {
- g_printerr ("document of the wrong type !!\n");
- xmlFreeDoc (doc);
- goto error;
- }
-
- tmp = cur->xmlChildrenNode;
- while (tmp) {
- list = g_list_prepend (list, g_strdup (tmp->name));
- tmp = tmp->next;
- }
- if (list)
- list = g_list_reverse (list);
-
- return list;
-
-error:
- return NULL;
-}
-
-GList *
-analyzer_get_list_analyzer_node_from_xml (char *file_name, char *node_name)
-{
- xmlDocPtr doc;
- xmlNodePtr cur, tmp;
- GList *list = NULL;
- AnalyzerNode *node;
-
- doc = xmlParseFile (file_name);
- if (!doc) {
- g_printerr ("Failed to do xmlParseFile for the file.. %s\n", file_name);
- goto error;
- }
-
- cur = xmlDocGetRootElement (doc);
- if (cur == NULL) {
- xmlFreeDoc (doc);
- g_printerr ("empty document\n");
- goto error;
- }
-
- if (xmlStrcmp (cur->name, (const xmlChar *) "mpeg2") &&
- xmlStrcmp (cur->name, (const xmlChar *) "h264") &&
- xmlStrcmp (cur->name, (const xmlChar *) "h265")) {
- xmlFreeDoc (doc);
- g_printerr ("document of the wrong type !!\n");
- goto error;
- }
-
- tmp = cur->xmlChildrenNode;
- while (tmp) {
- if (!xmlStrcmp (tmp->name, (const xmlChar *) node_name)) {
- g_debug ("Parsing the Child: %s \n", tmp->name);
-
- cur = tmp->xmlChildrenNode;
- while (cur != NULL) {
- xmlChar *key;
- xmlChar *nbits = NULL;
- xmlChar *is_matrix = NULL;
- xmlChar *rows;
- xmlChar *columns;
-
- key = xmlNodeListGetString (doc, cur->xmlChildrenNode, 1);
- nbits = xmlGetProp (cur, "nbits");
- is_matrix = xmlGetProp (cur, "is-matrix");
- if (is_matrix) {
- rows = xmlGetProp (cur, "rows");
- columns = xmlGetProp (cur, "columns");
- }
- node = g_slice_new0 (AnalyzerNode);
- node->field_name = g_strdup (cur->name);
- if (key) {
- node->value = g_strdup ((gchar *) key);
- xmlFree (key);
- }
- if (nbits) {
- node->nbits = g_strdup ((gchar *) nbits);
- xmlFree (nbits);
- }
- if (is_matrix) {
- node->is_matrix = g_strdup ((gchar *) is_matrix);
- xmlFree (is_matrix);
-
- node->rows = g_strdup ((gchar *) rows);
- xmlFree (rows);
-
- node->columns = g_strdup ((gchar *) columns);
- xmlFree (columns);
- }
-
- list = g_list_prepend (list, node);
-
- cur = cur->next;
- }
- break;
- }
- tmp = tmp->next;
- }
-
- xmlFreeDoc (doc);
-
- if (list)
- list = g_list_reverse (list);
-
- return list;
-
-error:
- return NULL;
-}
+++ /dev/null
-/*
- * Copyright (c) 2013, Intel Corporation.
- * Author: Sreerenj Balachandran <sreerenj.balachandran@intel.com>
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Library General Public
- * License as published by the Free Software Foundation; either
- * version 2 of the License, or (at your option) any later version.
- *
- * This program is distributed in the hope 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 program; if not, write to the Free Software Foundation, Inc.,
- * 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.
- *
- */
-#ifndef __XML_PARSE__
-#define __XML_PARSE__
-
-#include <stdio.h>
-#include <stdlib.h>
-#include <libxml/tree.h>
-#include <libxml/parser.h>
-#include <gst/gst.h>
-
-typedef enum {
- ANALYZER_ALL,
- ANALYZER_HEADERS,
- ANALYZER_QUANTMATRIX,
- ANALYZER_SLICE,
- ANALYZER_HEXVAL
-} AnalyzerHeaderGroup;
-
-typedef struct {
- xmlChar *field_name;
- xmlChar *value;
- xmlChar *nbits;
-
- xmlChar *is_matrix;
- xmlChar *rows;
- xmlChar *columns;
-}AnalyzerNode;
-
-AnalyzerNode *analyzer_node_new ();
-
-GList *
-analyzer_get_list_analyzer_node_from_xml (char *file_name, char *node_name);
-
-GList *
-analyzer_get_list_header_strings (char *file_name);
-
-void analyzer_node_free (gpointer data);
-
-void analyzer_node_list_free (GList *list);
-
-#endif
projects / platform / upstream / gstreamer.git / commitdiff
