--- /dev/null
+ GNU LIBRARY GENERAL PUBLIC LICENSE
+ Version 2, June 1991
+
+ Copyright (C) 1991 Free Software Foundation, Inc.
+ 675 Mass Ave, Cambridge, MA 02139, 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., 675 Mass Ave, Cambridge, MA 02139, 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
+/* GStreamer
+ * Copyright (C) 2016 Biela.Jo <doriya@nexell.co.kr>
+ *
+ * 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 Street, Suite 500,
+ * Boston, MA 02110-1335, USA.
+ */
+/**
+ * SECTION:element-gstnxvideoenc
+ *
+ * The nxvideoenc element does FIXME stuff.
+ *
+ * <refsect2>
+ * <title>Example launch line</title>
+ * |[
+ * gst-launch -v fakesrc ! nxvideoenc ! FIXME ! fakesink
+ * ]|
+ * FIXME Describe what the pipeline does.
+ * </refsect2>
+ */
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include <gst/gst.h>
+#include <gst/video/video.h>
+#include <gst/video/gstvideoencoder.h>
+
+#include <videodev2_nxp_media.h>
+#include <linux/videodev2.h>
+
+#include <stdlib.h>
+#include <string.h>
+#include <fcntl.h>
+#include <unistd.h>
+#include <sys/ioctl.h>
+
+#include <xf86drm.h>
+#include <xf86drmMode.h>
+#include <drm_fourcc.h>
+#include <nexell/nexell_drm.h>
+#include <mm_types.h>
+
+#include <nx_video_alloc.h>
+
+#include <gstmmvideobuffermeta.h>
+#include "gstnxvideoenc.h"
+
+GST_DEBUG_CATEGORY_STATIC (gst_nxvideoenc_debug_category);
+#define GST_CAT_DEFAULT gst_nxvideoenc_debug_category
+
+/* prototypes */
+
+static void gst_nxvideoenc_set_property (GObject * object,
+ guint property_id, const GValue * value, GParamSpec * pspec);
+static void gst_nxvideoenc_get_property (GObject * object,
+ guint property_id, GValue * value, GParamSpec * pspec);
+static void gst_nxvideoenc_finalize (GObject * object);
+
+static gboolean gst_nxvideoenc_start (GstVideoEncoder * encoder);
+static gboolean gst_nxvideoenc_stop (GstVideoEncoder * encoder);
+static gboolean gst_nxvideoenc_set_format (GstVideoEncoder * encoder,
+ GstVideoCodecState * state);
+static GstFlowReturn gst_nxvideoenc_handle_frame (GstVideoEncoder * encoder,
+ GstVideoCodecFrame * frame);
+static GstFlowReturn gst_nxvideoenc_finish (GstVideoEncoder * encoder);
+
+#define DEFAULT_CODEC V4L2_PIX_FMT_H264
+#define DEFAULT_WIDTH 1920
+#define DEFAULT_HEIGHT 1080
+#define DEFAULT_FPS_NUM 30
+#define DEFAULT_FPS_DEN 1
+#define DEFAULT_KEYFRAME_INTERVAL DEFAULT_FPS_NUM / DEFAULT_FPS_DEN
+#define DEFAULT_BITRATE 3000 * 1024
+#define DEFAULT_MAXIMUM_QP 0
+#define DEFAULT_DISABLE_SKIP 0
+#define DEFAULT_RC_DELAY 0
+#define DEFAULT_RC_VBV_SIZE 0
+#define DEFAULT_GAMMA_FACTOR 0
+#define DEFAULT_INITIAL_QP 0
+#define DEFAULT_INTRA_REFRESH_MBS 0
+#define DEFAULT_SEARCH_RANGE 0
+#define DEFAULT_ENABLE_AU_DELIMITER FALSE
+
+#define DEFAULT_IMAGE_FORMAT V4L2_PIX_FMT_YUV420M
+#define H264_AU_LENGTH_SIZE 4
+
+enum
+{
+ PROP_0,
+ PROP_CODEC, // video/x-h264, video/x-h263, video/mpeg
+ PROP_WIDTH,
+ PROP_HEIGHT,
+ PROP_FPS_N,
+ PROP_FPS_D,
+ PROP_KEYFRAME_INTERVAL,
+ PROP_BITRATE,
+ PROP_MAXIMUM_QP,
+ PROP_DISABLE_SKIP,
+ PROP_RC_DELAY,
+ PROP_RC_VBV_SIZE,
+ PROP_GAMMA_FACTOR,
+ PROP_INITIAL_QP,
+ PROP_INTRA_REFRESH_MBS,
+ PROP_SEARCH_RANGE,
+ PROP_ENABLE_AU_DELIMITER,
+};
+
+/* pad templates */
+
+/* FIXME: add/remove formats you can handle */
+static GstStaticPadTemplate gst_nxvideoenc_sink_template =
+ GST_STATIC_PAD_TEMPLATE ("sink",
+ GST_PAD_SINK,
+ GST_PAD_ALWAYS,
+ GST_STATIC_CAPS ("video/x-raw, " "format =(string) I420; ")
+ );
+
+static GstStaticPadTemplate gst_nxvideoenc_src_template =
+ GST_STATIC_PAD_TEMPLATE ("src",
+ GST_PAD_SRC,
+ GST_PAD_ALWAYS,
+ GST_STATIC_CAPS ("video/x-h264, "
+ "width = (int) [ 96, 1920 ], "
+ "height = (int) [ 16, 1920 ], "
+ "framerate = (fraction) [ 0/1, 65535/1 ], "
+ "stream-format = (string) { byte-stream, avc }, "
+ "alignment = (string) { au, nal }; "
+ "video/x-h263, "
+ "width = (int) [ 96, 1920 ], "
+ "height = (int) [ 16, 1088 ], "
+ "framerate = (fraction) [ 0/1, 65535/1 ]; "
+ "video/mpeg, "
+ "width = (int) [ 96, 1920 ], "
+ "height = (int) [ 16, 1088 ], "
+ "framerate = (fraction) [ 0/1, 65535/1 ], "
+ "mpegversion = (int) 4, " "systemstream = (boolean) FALSE; ")
+ );
+
+/* class initialization */
+
+G_DEFINE_TYPE_WITH_CODE (GstNxvideoenc, gst_nxvideoenc, GST_TYPE_VIDEO_ENCODER,
+ GST_DEBUG_CATEGORY_INIT (gst_nxvideoenc_debug_category, "nxvideoenc", 0,
+ "debug category for nxvideoenc element"));
+
+static void
+gst_nxvideoenc_class_init (GstNxvideoencClass * klass)
+{
+ GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
+ GstVideoEncoderClass *video_encoder_class = GST_VIDEO_ENCODER_CLASS (klass);
+
+ /* Setting up pads and setting metadata should be moved to
+ base_class_init if you intend to subclass this class. */
+
+ gst_element_class_add_pad_template (GST_ELEMENT_CLASS (klass),
+ gst_static_pad_template_get (&gst_nxvideoenc_sink_template));
+
+ gst_element_class_add_pad_template (GST_ELEMENT_CLASS (klass),
+ gst_static_pad_template_get (&gst_nxvideoenc_src_template));
+
+ gst_element_class_set_static_metadata (GST_ELEMENT_CLASS (klass),
+ "S5P6818 H/W Video Encoder",
+ "Codec/Encoder/Video",
+ "Nexell H/W Video Encoder for S5P6818", "Biela.Jo <doriya@nexell.co.kr>");
+
+ gobject_class->set_property = gst_nxvideoenc_set_property;
+ gobject_class->get_property = gst_nxvideoenc_get_property;
+ gobject_class->finalize = gst_nxvideoenc_finalize;
+
+ video_encoder_class->start = GST_DEBUG_FUNCPTR (gst_nxvideoenc_start);
+ video_encoder_class->stop = GST_DEBUG_FUNCPTR (gst_nxvideoenc_stop);
+ video_encoder_class->set_format =
+ GST_DEBUG_FUNCPTR (gst_nxvideoenc_set_format);
+ video_encoder_class->handle_frame =
+ GST_DEBUG_FUNCPTR (gst_nxvideoenc_handle_frame);
+ video_encoder_class->finish = GST_DEBUG_FUNCPTR (gst_nxvideoenc_finish);
+
+ g_object_class_install_property (G_OBJECT_CLASS (klass), PROP_CODEC,
+ g_param_spec_string ("codec", "codec",
+ "codec type",
+ "video/x-h264",
+ (GParamFlags) (G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)
+ )
+ );
+
+ g_object_class_install_property (G_OBJECT_CLASS (klass), PROP_WIDTH,
+ g_param_spec_uint ("width", "width",
+ "width of image",
+ 96, 1920, DEFAULT_WIDTH,
+ (GParamFlags) (G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)
+ )
+ );
+
+ g_object_class_install_property (G_OBJECT_CLASS (klass), PROP_HEIGHT,
+ g_param_spec_uint ("height", "height",
+ "height of image",
+ 16, 1920, DEFAULT_HEIGHT,
+ (GParamFlags) (G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)
+ )
+ );
+
+ g_object_class_install_property (G_OBJECT_CLASS (klass), PROP_FPS_N,
+ g_param_spec_uint ("fps-n", "fps-n",
+ "frame per second's numerator",
+ 0, G_MAXUINT16, DEFAULT_FPS_NUM,
+ (GParamFlags) (G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)
+ )
+ );
+
+ g_object_class_install_property (G_OBJECT_CLASS (klass), PROP_FPS_D,
+ g_param_spec_uint ("fps-d", "fps-d",
+ "frame per second's denominator",
+ 1, G_MAXUINT16, DEFAULT_FPS_DEN,
+ (GParamFlags) (G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)
+ )
+ );
+
+ g_object_class_install_property (G_OBJECT_CLASS (klass),
+ PROP_KEYFRAME_INTERVAL, g_param_spec_uint ("key-interval", "key-interval",
+ "size of key frame interval", 0, G_MAXUINT, DEFAULT_KEYFRAME_INTERVAL,
+ (GParamFlags) (G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)
+ )
+ );
+
+ g_object_class_install_property (G_OBJECT_CLASS (klass), PROP_BITRATE,
+ g_param_spec_uint ("bitrate", "bitrate",
+ "target bitrate in bits per second",
+ 0, G_MAXUINT16 * 1024, DEFAULT_BITRATE,
+ (GParamFlags) (G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)
+ )
+ );
+
+ g_object_class_install_property (G_OBJECT_CLASS (klass), PROP_MAXIMUM_QP,
+ g_param_spec_uint ("max-qp", "max-qp",
+ "maximum quantization parameter",
+ 0, G_MAXUINT, DEFAULT_MAXIMUM_QP,
+ (GParamFlags) (G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)
+ )
+ );
+
+ g_object_class_install_property (G_OBJECT_CLASS (klass), PROP_DISABLE_SKIP,
+ g_param_spec_uint ("skip", "skip",
+ "disable skip frame mode",
+ 0, 1, DEFAULT_DISABLE_SKIP,
+ (GParamFlags) (G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)
+ )
+ );
+
+ g_object_class_install_property (G_OBJECT_CLASS (klass), PROP_RC_DELAY,
+ g_param_spec_uint ("rc-delay", "rc-delay",
+ "rate control delay",
+ 0, G_MAXUINT16, DEFAULT_RC_DELAY,
+ (GParamFlags) (G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)
+ )
+ );
+
+ g_object_class_install_property (G_OBJECT_CLASS (klass), PROP_RC_VBV_SIZE,
+ g_param_spec_uint ("rc-vbv", "rc-vbv",
+ "reference decoder buffer size in bits",
+ 0, G_MAXUINT / 2, DEFAULT_RC_VBV_SIZE,
+ (GParamFlags) (G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)
+ )
+ );
+
+ g_object_class_install_property (G_OBJECT_CLASS (klass), PROP_GAMMA_FACTOR,
+ g_param_spec_uint ("gamma-factor", "gamma-factor",
+ "user gamma factor",
+ 0, G_MAXUINT16 / 2, DEFAULT_GAMMA_FACTOR,
+ (GParamFlags) (G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)
+ )
+ );
+
+ g_object_class_install_property (G_OBJECT_CLASS (klass), PROP_INITIAL_QP,
+ g_param_spec_uint ("init-qp", "init-qp",
+ "initial quantization parameter",
+ 0, 51, DEFAULT_INITIAL_QP,
+ (GParamFlags) (G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)
+ )
+ );
+
+ g_object_class_install_property (G_OBJECT_CLASS (klass),
+ PROP_INTRA_REFRESH_MBS, g_param_spec_uint ("intra", "intra",
+ "Intra MB refresh number (Cyclic Intera Refresh)", 0, 51,
+ DEFAULT_INTRA_REFRESH_MBS,
+ (GParamFlags) (G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)
+ )
+ );
+
+ g_object_class_install_property (G_OBJECT_CLASS (klass), PROP_SEARCH_RANGE,
+ g_param_spec_uint ("search-range", "search-range",
+ "search range of motion estimation (0 : 128 x 64, 1 : 64 x 32, 2 : 32 x 16, 3 : 16 x 16)",
+ 0, 3, DEFAULT_SEARCH_RANGE,
+ (GParamFlags) (G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)
+ )
+ );
+
+ g_object_class_install_property (G_OBJECT_CLASS (klass),
+ PROP_ENABLE_AU_DELIMITER, g_param_spec_boolean ("au-delimiter",
+ "au-delimiter", "insert access unit delimiter befor NAL unit",
+ DEFAULT_ENABLE_AU_DELIMITER,
+ (GParamFlags) (G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)
+ )
+ );
+}
+
+static void
+gst_nxvideoenc_init (GstNxvideoenc * nxvideoenc)
+{
+ gint i;
+
+ nxvideoenc->input_state = NULL;
+ nxvideoenc->init = FALSE;
+ nxvideoenc->accelerable = FALSE;
+ nxvideoenc->buf_index = 0;
+ nxvideoenc->drm_fd = -1;
+ nxvideoenc->seq_buf = NULL;
+ nxvideoenc->seq_size = 0;
+ for (i = 0; i < MAX_INPUT_BUFFER; i++) {
+ nxvideoenc->inbuf[i] = NULL;
+ }
+
+ nxvideoenc->enc = NULL;
+ nxvideoenc->codec = DEFAULT_CODEC;
+ nxvideoenc->width = 0;
+ nxvideoenc->height = 0;
+ nxvideoenc->keyFrmInterval = 0;
+ nxvideoenc->fpsNum = 0;
+ nxvideoenc->fpsDen = 0;
+ nxvideoenc->profile = 0;
+ nxvideoenc->bitrate = DEFAULT_BITRATE;
+ nxvideoenc->maximumQp = DEFAULT_MAXIMUM_QP;
+ nxvideoenc->disableSkip = DEFAULT_DISABLE_SKIP;
+ nxvideoenc->RCDelay = DEFAULT_RC_DELAY;
+ nxvideoenc->rcVbvSize = DEFAULT_RC_VBV_SIZE;
+ nxvideoenc->gammaFactor = DEFAULT_GAMMA_FACTOR;
+ nxvideoenc->initialQp = DEFAULT_INITIAL_QP;
+ nxvideoenc->numIntraRefreshMbs = DEFAULT_INTRA_REFRESH_MBS;
+ nxvideoenc->searchRange = DEFAULT_SEARCH_RANGE;
+ nxvideoenc->enableAUDelimiter = DEFAULT_ENABLE_AU_DELIMITER;
+ nxvideoenc->imgFormat = DEFAULT_IMAGE_FORMAT;
+ nxvideoenc->imgBufferNum = MAX_INPUT_BUFFER;
+ nxvideoenc->rotAngle = 0;
+ nxvideoenc->mirDirection = 0;
+ nxvideoenc->jpgQuality = 0;
+}
+
+static gint
+get_v4l2_codec (const gchar * codec)
+{
+ gint v4l2_codec = -1;
+ if (!g_strcmp0 (codec, "video/x-h264"))
+ v4l2_codec = V4L2_PIX_FMT_H264;
+ else if (!g_strcmp0 (codec, "video/x-h263"))
+ v4l2_codec = V4L2_PIX_FMT_H263;
+ else if (!g_strcmp0 (codec, "video/mpeg"))
+ v4l2_codec = V4L2_PIX_FMT_MPEG4;
+
+ return v4l2_codec;
+}
+
+static const gchar *
+get_codec_name (gint codec)
+{
+ if (codec == V4L2_PIX_FMT_H264)
+ return "video/x-h264";
+ else if (codec == V4L2_PIX_FMT_H263)
+ return "video/x-h263";
+ else if (codec == V4L2_PIX_FMT_MPEG4)
+ return "video/mpeg";
+
+ return NULL;
+}
+
+static void
+gst_nxvideoenc_set_property (GObject * object, guint property_id,
+ const GValue * value, GParamSpec * pspec)
+{
+ GstNxvideoenc *nxvideoenc = GST_NXVIDEOENC (object);
+
+ GST_DEBUG_OBJECT (nxvideoenc, "set_property");
+
+ switch (property_id) {
+ case PROP_CODEC:
+ nxvideoenc->codec = get_v4l2_codec (g_value_get_string (value));
+ break;
+
+ case PROP_WIDTH:
+ nxvideoenc->width = g_value_get_uint (value);
+ break;
+
+ case PROP_HEIGHT:
+ nxvideoenc->height = g_value_get_uint (value);
+ break;
+
+ case PROP_FPS_N:
+ nxvideoenc->fpsNum = g_value_get_uint (value);
+ break;
+
+ case PROP_FPS_D:
+ nxvideoenc->fpsDen = g_value_get_uint (value);
+ break;
+
+ case PROP_KEYFRAME_INTERVAL:
+ nxvideoenc->keyFrmInterval = g_value_get_uint (value);
+ break;
+
+ case PROP_BITRATE:
+ nxvideoenc->bitrate = g_value_get_uint (value);
+ break;
+
+ case PROP_MAXIMUM_QP:
+ nxvideoenc->maximumQp = g_value_get_uint (value);
+ break;
+
+ case PROP_DISABLE_SKIP:
+ nxvideoenc->disableSkip = g_value_get_uint (value);
+ break;
+
+ case PROP_RC_DELAY:
+ nxvideoenc->RCDelay = g_value_get_uint (value);
+ break;
+
+ case PROP_RC_VBV_SIZE:
+ nxvideoenc->rcVbvSize = g_value_get_uint (value);
+ break;
+
+ case PROP_GAMMA_FACTOR:
+ nxvideoenc->gammaFactor = g_value_get_uint (value);
+ break;
+
+ case PROP_INITIAL_QP:
+ nxvideoenc->initialQp = g_value_get_uint (value);
+ break;
+
+ case PROP_INTRA_REFRESH_MBS:
+ nxvideoenc->numIntraRefreshMbs = g_value_get_uint (value);
+ break;
+
+ case PROP_SEARCH_RANGE:
+ nxvideoenc->searchRange = g_value_get_uint (value);
+ break;
+
+ case PROP_ENABLE_AU_DELIMITER:
+ nxvideoenc->enableAUDelimiter = g_value_get_boolean (value);
+ break;
+
+ default:
+ G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
+ break;
+ }
+}
+
+static void
+gst_nxvideoenc_get_property (GObject * object, guint property_id,
+ GValue * value, GParamSpec * pspec)
+{
+ GstNxvideoenc *nxvideoenc = GST_NXVIDEOENC (object);
+
+ GST_DEBUG_OBJECT (nxvideoenc, "get_property");
+
+ switch (property_id) {
+ case PROP_CODEC:
+ g_value_set_string (value, get_codec_name (nxvideoenc->codec));
+ break;
+
+ case PROP_WIDTH:
+ g_value_set_uint (value, nxvideoenc->width);
+ break;
+
+ case PROP_HEIGHT:
+ g_value_set_uint (value, nxvideoenc->height);
+ break;
+
+ case PROP_FPS_N:
+ g_value_set_uint (value, nxvideoenc->fpsNum);
+ break;;
+
+ case PROP_FPS_D:
+ g_value_set_uint (value, nxvideoenc->fpsDen);
+ break;
+
+ case PROP_KEYFRAME_INTERVAL:
+ g_value_set_uint (value, nxvideoenc->keyFrmInterval);
+ break;
+
+ case PROP_BITRATE:
+ g_value_set_uint (value, nxvideoenc->bitrate);
+ break;
+
+ case PROP_MAXIMUM_QP:
+ g_value_set_uint (value, nxvideoenc->maximumQp);
+ break;
+
+ case PROP_DISABLE_SKIP:
+ g_value_set_uint (value, nxvideoenc->disableSkip);
+ break;
+
+ case PROP_RC_DELAY:
+ g_value_set_uint (value, nxvideoenc->RCDelay);
+ break;
+
+ case PROP_RC_VBV_SIZE:
+ g_value_set_uint (value, nxvideoenc->rcVbvSize);
+ break;
+
+ case PROP_GAMMA_FACTOR:
+ g_value_set_uint (value, nxvideoenc->gammaFactor);
+ break;
+
+ case PROP_INITIAL_QP:
+ g_value_set_uint (value, nxvideoenc->initialQp);
+ break;
+
+ case PROP_INTRA_REFRESH_MBS:
+ g_value_set_uint (value, nxvideoenc->numIntraRefreshMbs);
+ break;
+
+ case PROP_SEARCH_RANGE:
+ g_value_set_uint (value, nxvideoenc->searchRange);
+ break;
+
+ case PROP_ENABLE_AU_DELIMITER:
+ g_value_set_boolean (value, nxvideoenc->enableAUDelimiter);
+ break;
+
+ default:
+ G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
+ break;
+ }
+}
+
+static gboolean
+h264_split_nal (guchar * in_buf, gint in_len, guchar ** out_buf, gint * out_len)
+{
+ gint i, pos = 0;
+ gboolean valid = FALSE;
+
+ for (i = 0; i < in_len - 3; i++) {
+ if ((in_buf[i] == 0x00) && (in_buf[i + 1] == 0x00)
+ && (in_buf[i + 2] == 0x01)) {
+ if (valid)
+ break;
+
+ *out_buf = in_buf + i;
+
+ valid = TRUE;
+ pos = i;
+ }
+ }
+
+ if (i == in_len - 3) {
+ *out_len = in_len - pos;
+ } else {
+ if (i != 0 && in_buf[i - 1] == 0) {
+ i--;
+ }
+
+ *out_len = i - pos;
+ }
+
+ return valid;
+}
+
+// in_buf format = nal start code + sps + nal start code + pps
+static gboolean
+h264_find_spspps_stream (guchar * in_buf, gint in_size, guchar ** sps,
+ gint * sps_len, guchar ** pps, gint * pps_len)
+{
+ guchar *buf = in_buf;
+ gint size = in_size;
+
+ // find nal start code for sps
+ if (FALSE == h264_split_nal (buf, size, sps, sps_len)) {
+ return FALSE;
+ }
+ // remove 3byte nal start code
+ *sps = *sps + 3;
+ *sps_len = *sps_len - 3;
+
+ if (FALSE == h264_split_nal (in_buf + *sps_len + 3, in_size - *sps_len - 3,
+ pps, pps_len)) {
+ return FALSE;
+ }
+ // remove 3byte nal start code
+ *pps = *pps + 3;
+ *pps_len = *pps_len - 3;
+
+ return TRUE;
+}
+
+static GstBuffer *
+h264_get_header (GstVideoEncoder * encoder)
+{
+ GstNxvideoenc *nxvideoenc = GST_NXVIDEOENC (encoder);
+
+ NX_V4L2ENC_HANDLE enc = NULL;
+ NX_V4L2ENC_PARA param;
+
+ guchar *buf = NULL, *ptr = NULL;;
+ gint buf_size = 0;
+
+ guchar *seq_buf = NULL;
+ gint seq_size = 0;
+
+ GstBuffer *header_buffer;
+
+ guchar *sps = NULL, *pps = NULL;
+ gint sps_len = 0, pps_len = 0;
+
+ memset (¶m, 0x00, sizeof (NX_V4L2ENC_PARA));
+ param.width = nxvideoenc->width;
+ param.height = nxvideoenc->height;
+ param.keyFrmInterval =
+ nxvideoenc->keyFrmInterval ? (nxvideoenc->
+ keyFrmInterval) : (nxvideoenc->fpsNum / nxvideoenc->fpsDen);
+ param.fpsNum = nxvideoenc->fpsNum;
+ param.fpsDen = nxvideoenc->fpsDen;
+ param.profile =
+ (nxvideoenc->codec ==
+ V4L2_PIX_FMT_H263) ? V4L2_MPEG_VIDEO_H263_PROFILE_P3 : 0;
+ param.bitrate = nxvideoenc->bitrate;
+ param.maximumQp = nxvideoenc->maximumQp;
+ param.disableSkip = nxvideoenc->disableSkip;
+ param.RCDelay = nxvideoenc->RCDelay;
+ param.rcVbvSize = nxvideoenc->rcVbvSize;
+ param.gammaFactor = nxvideoenc->gammaFactor;
+ param.initialQp = nxvideoenc->initialQp;
+ param.numIntraRefreshMbs = nxvideoenc->numIntraRefreshMbs;
+ param.searchRange = nxvideoenc->searchRange;
+ param.enableAUDelimiter =
+ (nxvideoenc->codec ==
+ V4L2_PIX_FMT_H264) ? nxvideoenc->enableAUDelimiter : 0;
+ param.imgFormat = nxvideoenc->imgFormat;
+ param.imgBufferNum = MAX_INPUT_BUFFER;
+ param.imgPlaneNum = 3;
+
+ enc = NX_V4l2EncOpen (nxvideoenc->codec);
+ if (NULL == enc) {
+ GST_ERROR ("Fail, NX_V4l2EncOpen().\n");
+ return NULL;
+ }
+
+ if (0 > NX_V4l2EncInit (enc, ¶m)) {
+ GST_ERROR ("Fail, NX_V4l2EncInit().\n");
+ NX_V4l2EncClose (enc);
+ return NULL;
+ }
+
+ NX_V4l2EncGetSeqInfo (enc, &seq_buf, &seq_size);
+
+ // seq_buf format = nal start code + sps + nal start code + pps
+ if (FALSE == h264_find_spspps_stream (seq_buf, seq_size, &sps, &sps_len, &pps,
+ &pps_len)) {
+ GST_ERROR ("Fail, Not Found SPS/PPS.\n");
+ return NULL;
+ }
+
+ buf_size += sps_len + pps_len + 11;
+ buf = g_malloc (buf_size * sizeof (guchar));
+ ptr = buf;
+
+ // make avcC information
+ *ptr++ = 0x01;
+ *ptr++ = sps[1]; // profile
+ *ptr++ = sps[2]; // compatibility
+ *ptr++ = sps[3]; // level
+ *ptr++ = (0x3F << 2) | (H264_AU_LENGTH_SIZE - 1); // length size - 1 --> 4 length size
+ *ptr++ = 0xE0 | 1; // number of sps : 1
+ *ptr++ = sps_len >> 8; // length of sps : 2 bytes
+ *ptr++ = sps_len & 0xFF;
+
+ memcpy (ptr, sps, sps_len);
+ ptr += sps_len;
+
+ *ptr++ = 1; // number of pps : 1
+ *ptr++ = pps_len >> 8; // length of pps : 2bytes
+ *ptr++ = pps_len & 0xFF;
+
+ memcpy (ptr, pps, pps_len);
+ ptr += pps_len;
+
+ header_buffer = gst_buffer_new_and_alloc (buf_size);
+ gst_buffer_fill (header_buffer, 0, buf, buf_size);
+ g_free (buf);
+
+ NX_V4l2EncClose (enc);
+
+ return header_buffer;
+}
+
+static GstCaps *
+get_encoder_src_caps (GstVideoEncoder * encoder)
+{
+ GstNxvideoenc *nxvideoenc = GST_NXVIDEOENC (encoder);
+
+ GstCaps *caps = NULL;
+ GstCaps *src_caps = NULL;
+
+ gint caps_num;
+
+ caps = gst_static_pad_template_get_caps (&gst_nxvideoenc_src_template);
+ if (NULL == caps) {
+ return NULL;
+ }
+
+ for (caps_num = 0; caps_num < gst_caps_get_size (caps); caps_num++) {
+ GstStructure *src_structure = gst_caps_get_structure (caps, caps_num);
+ if (src_structure) {
+ if (!g_strcmp0 (get_codec_name (nxvideoenc->codec),
+ gst_structure_get_name (src_structure))) {
+ src_caps = gst_caps_copy_nth (caps, caps_num);
+ gst_caps_make_writable (src_caps);
+ break;
+ }
+ }
+ }
+ gst_caps_unref (caps);
+
+ if (NULL == src_caps) {
+ return NULL;
+ }
+
+ caps = gst_pad_peer_query_caps (GST_VIDEO_ENCODER_SRC_PAD (encoder), NULL);
+ if (NULL == caps) {
+ return NULL;
+ }
+
+ if (TRUE == gst_caps_is_any (caps)) {
+ GstStructure *src_structure;
+ src_structure = gst_caps_get_structure (src_caps, 0);
+ if (!g_strcmp0 (get_codec_name (nxvideoenc->codec), "video/x-h264")) {
+ gst_structure_set (src_structure, "stream-format", G_TYPE_STRING,
+ "byte-stream", NULL);
+ g_strlcpy (nxvideoenc->stream_format, "byte-stream", MAX_STRING_SIZE);
+
+ gst_structure_set (src_structure, "alignment", G_TYPE_STRING, "au", NULL);
+ g_strlcpy (nxvideoenc->alignment, "au", MAX_STRING_SIZE);
+ }
+
+ gst_caps_unref (caps);
+
+ return src_caps;
+ } else {
+ for (caps_num = 0; caps_num < gst_caps_get_size (caps); caps_num++) {
+ GstCaps *peer_caps = gst_caps_copy_nth (caps, caps_num);
+ if (!peer_caps && gst_caps_is_empty (peer_caps))
+ continue;
+
+ GstStructure *peer_structure = gst_caps_get_structure (peer_caps, 0);
+ if (peer_structure) {
+ if (!g_strcmp0 (get_codec_name (nxvideoenc->codec),
+ gst_structure_get_name (peer_structure))) {
+ if (!g_strcmp0 (get_codec_name (nxvideoenc->codec), "video/x-h264")) {
+ GstStructure *src_structure;
+ const gchar *stream_format, *alignment;
+
+
+ src_structure = gst_caps_get_structure (src_caps, 0);
+
+ stream_format =
+ gst_structure_get_string (peer_structure, "stream-format");
+ alignment = gst_structure_get_string (peer_structure, "alignment");
+
+ if (NULL != stream_format) {
+ gst_structure_set (src_structure, "stream-format", G_TYPE_STRING,
+ stream_format, NULL);
+ g_strlcpy (nxvideoenc->stream_format, stream_format,
+ MAX_STRING_SIZE);
+ } else {
+ gst_structure_set (src_structure, "stream-format", G_TYPE_STRING,
+ "byte-stream", NULL);
+ g_strlcpy (nxvideoenc->stream_format, "byte-stream",
+ MAX_STRING_SIZE);
+ }
+
+ if (NULL != alignment) {
+ gst_structure_set (src_structure, "alignment", G_TYPE_STRING,
+ alignment, NULL);
+ g_strlcpy (nxvideoenc->alignment, alignment, MAX_STRING_SIZE);
+ } else {
+ gst_structure_set (src_structure, "alignment", G_TYPE_STRING,
+ "au", NULL);
+ g_strlcpy (nxvideoenc->alignment, "au", MAX_STRING_SIZE);
+ }
+
+ if (!g_strcmp0 (nxvideoenc->stream_format, "avc")
+ && !g_strcmp0 (nxvideoenc->alignment, "au")) {
+ GstBuffer *buffer = h264_get_header (encoder);
+ if (NULL != buffer) {
+ gst_structure_set (src_structure, "codec_data", GST_TYPE_BUFFER,
+ buffer, NULL);
+ gst_buffer_unref (buffer);
+ }
+ }
+
+ gst_caps_unref (caps);
+ gst_caps_unref (peer_caps);
+
+ return src_caps;
+ }
+
+ if (!g_strcmp0 (get_codec_name (nxvideoenc->codec), "video/x-h263")) {
+
+ gst_caps_unref (caps);
+ gst_caps_unref (peer_caps);
+
+ return src_caps;
+ }
+
+ if (!g_strcmp0 (get_codec_name (nxvideoenc->codec), "video/mpeg")) {
+
+ gst_caps_unref (caps);
+ gst_caps_unref (peer_caps);
+
+ return src_caps;
+ }
+ }
+ gst_caps_unref (peer_caps);
+ }
+ }
+ }
+
+ if (NULL != caps) {
+ gst_caps_unref (caps);
+ }
+
+ return NULL;
+}
+
+static gboolean
+gst_nxvideoenc_set_format (GstVideoEncoder * encoder,
+ GstVideoCodecState * state)
+{
+ GstNxvideoenc *nxvideoenc = GST_NXVIDEOENC (encoder);
+ GstCaps *src_caps = NULL;
+
+ gint ret = FALSE;
+
+ GST_DEBUG_OBJECT (nxvideoenc, "set_format");
+
+ if (nxvideoenc->input_state) {
+ gst_video_codec_state_unref (nxvideoenc->input_state);
+ }
+
+ nxvideoenc->input_state = gst_video_codec_state_ref (state);
+
+ nxvideoenc->width =
+ !nxvideoenc->width ? GST_VIDEO_INFO_WIDTH (&state->
+ info) : nxvideoenc->width;
+ nxvideoenc->height =
+ !nxvideoenc->height ? GST_VIDEO_INFO_HEIGHT (&state->
+ info) : nxvideoenc->height;
+ nxvideoenc->fpsNum =
+ !nxvideoenc->fpsNum ? GST_VIDEO_INFO_FPS_N (&state->
+ info) : nxvideoenc->fpsNum;
+ nxvideoenc->fpsDen =
+ !nxvideoenc->fpsDen ? GST_VIDEO_INFO_FPS_D (&state->
+ info) : nxvideoenc->fpsDen;
+ nxvideoenc->keyFrmInterval =
+ !nxvideoenc->keyFrmInterval ? nxvideoenc->fpsNum /
+ nxvideoenc->fpsDen : nxvideoenc->keyFrmInterval;
+
+ GST_VIDEO_INFO_WIDTH (&state->info) = nxvideoenc->width;
+ GST_VIDEO_INFO_HEIGHT (&state->info) = nxvideoenc->height;
+ GST_VIDEO_INFO_FPS_N (&state->info) = nxvideoenc->fpsNum;
+ GST_VIDEO_INFO_FPS_D (&state->info) = nxvideoenc->fpsDen;
+
+ if (nxvideoenc->width < 96 || nxvideoenc->height < 16) {
+ GST_ERROR ("Fail, Invalid Width( %d ), height( %d )\n", nxvideoenc->width,
+ nxvideoenc->height);
+ return FALSE;
+ }
+
+ nxvideoenc->drm_fd = open ("/dev/dri/card0", O_RDWR);
+ if (0 > nxvideoenc->drm_fd) {
+ GST_ERROR ("Fail, drmOpen().\n");
+ return FALSE;
+ }
+
+ drmDropMaster (nxvideoenc->drm_fd);
+
+ src_caps = get_encoder_src_caps (encoder);
+ if (src_caps != NULL) {
+ gst_video_encoder_set_output_state (encoder, src_caps, state);
+
+ ret = gst_video_encoder_negotiate (encoder);
+
+ gst_caps_unref (src_caps);
+ } else {
+ return FALSE;
+ }
+
+ if (ret == FALSE) {
+ if (NULL != nxvideoenc->enc) {
+ NX_V4l2EncClose (nxvideoenc->enc);
+ nxvideoenc->enc = NULL;
+ }
+
+ if (NULL != nxvideoenc->input_state) {
+ gst_video_codec_state_unref (nxvideoenc->input_state);
+ nxvideoenc->input_state = NULL;
+ }
+
+ if (0 > nxvideoenc->drm_fd) {
+ drmClose (nxvideoenc->drm_fd);
+ nxvideoenc->drm_fd = -1;
+ }
+ }
+
+ return ret;
+}
+
+static void
+copy_to_videomemory (GstVideoFrame * pInframe, NX_VID_MEMORY_INFO * pImage)
+{
+ gint w = GST_VIDEO_FRAME_WIDTH (pInframe);
+ gint h = GST_VIDEO_FRAME_HEIGHT (pInframe);
+ guchar *pSrc, *pDst;
+ gint i, j;
+
+ pSrc = (guchar *) GST_VIDEO_FRAME_COMP_DATA (pInframe, 0);
+ pDst = (guchar *) pImage->pBuffer[0];
+
+ for (i = 0; i < h; i++) {
+ memcpy (pDst, pSrc, w);
+
+ pSrc += GST_VIDEO_FRAME_COMP_STRIDE (pInframe, 0);
+ pDst += pImage->stride[0];
+ }
+
+ for (j = 1; j < 3; j++) {
+ pSrc = (guchar *) GST_VIDEO_FRAME_COMP_DATA (pInframe, j);
+ pDst = (guchar *) pImage->pBuffer[j];
+
+ for (i = 0; i < h / 2; i++) {
+ memcpy (pDst, pSrc, w / 2);
+ pSrc += GST_VIDEO_FRAME_COMP_STRIDE (pInframe, j);
+ pDst += pImage->stride[j];
+ }
+ }
+}
+
+static int
+drm_ioctl (int fd, unsigned long request, void *arg)
+{
+ int ret;
+
+ do {
+ ret = ioctl (fd, request, arg);
+ } while (ret == -1 && (errno == EINTR || errno == EAGAIN));
+
+ return ret;
+}
+
+static int
+gem_to_dmafd (int fd, int gem_fd)
+{
+ int ret;
+ struct drm_prime_handle arg = { 0, };
+
+ arg.handle = gem_fd;
+ ret = drm_ioctl (fd, DRM_IOCTL_PRIME_HANDLE_TO_FD, &arg);
+ if (0 != ret)
+ return -1;
+
+ return arg.fd;
+}
+
+static int
+gem_close (int fd, int gem_fd)
+{
+ struct drm_gem_close arg = { 0, };
+
+ arg.handle = gem_fd;
+ if (drm_ioctl (fd, DRM_IOCTL_GEM_CLOSE, &arg)) {
+ return -EINVAL;
+ }
+
+ return 0;
+}
+
+static int
+import_gem_from_flink (int fd, unsigned int flink_name)
+{
+ struct drm_gem_open arg = { 0, };
+ /* struct nx_drm_gem_info info = { 0, }; */
+
+ arg.name = flink_name;
+ if (drm_ioctl (fd, DRM_IOCTL_GEM_OPEN, &arg)) {
+ return -EINVAL;
+ }
+
+ return arg.handle;
+}
+
+static void
+gst_nxvideoenc_finalize (GObject * object)
+{
+ GstNxvideoenc *nxvideoenc = GST_NXVIDEOENC (object);
+
+ GST_DEBUG_OBJECT (nxvideoenc, "finalize");
+
+ /* clean up object here */
+
+ G_OBJECT_CLASS (gst_nxvideoenc_parent_class)->finalize (object);
+}
+
+static gboolean
+gst_nxvideoenc_start (GstVideoEncoder * encoder)
+{
+ GstNxvideoenc *nxvideoenc = GST_NXVIDEOENC (encoder);
+
+ GST_DEBUG_OBJECT (nxvideoenc, "start");
+
+ return TRUE;
+}
+
+static gboolean
+gst_nxvideoenc_stop (GstVideoEncoder * encoder)
+{
+ GstNxvideoenc *nxvideoenc = GST_NXVIDEOENC (encoder);
+ gint i, j;
+
+ GST_DEBUG_OBJECT (nxvideoenc, "stop");
+
+ if (FALSE == nxvideoenc->accelerable) {
+ for (i = 0; i < MAX_ALLOC_BUFFER; i++) {
+ if (NULL != nxvideoenc->inbuf[i]) {
+ NX_FreeVideoMemory (nxvideoenc->inbuf[i]);
+ nxvideoenc->inbuf[i] = NULL;
+ }
+ }
+ } else {
+ for (i = 0; i < MAX_INPUT_BUFFER; i++) {
+ if (NULL != nxvideoenc->inbuf[i]) {
+ for (j = 0; j < nxvideoenc->inbuf[i]->planes; j++) {
+ gem_close (nxvideoenc->drm_fd, nxvideoenc->inbuf[i]->gemFd[j]);
+ close (nxvideoenc->inbuf[i]->dmaFd[j]);
+ }
+
+ free (nxvideoenc->inbuf[i]);
+ nxvideoenc->inbuf[i] = NULL;
+ }
+ }
+ }
+
+ if (NULL != nxvideoenc->enc) {
+ GST_DEBUG_OBJECT (nxvideoenc, "NX_V4l2EncClose ++");
+ NX_V4l2EncClose (nxvideoenc->enc);
+ GST_DEBUG_OBJECT (nxvideoenc, "NX_V4l2EncClose --");
+ nxvideoenc->enc = NULL;
+ }
+
+ if (NULL != nxvideoenc->input_state) {
+ gst_video_codec_state_unref (nxvideoenc->input_state);
+ nxvideoenc->input_state = NULL;
+ }
+
+ if (0 <= nxvideoenc->drm_fd) {
+ drmClose (nxvideoenc->drm_fd);
+ nxvideoenc->drm_fd = -1;
+ }
+ GST_DEBUG_OBJECT (nxvideoenc, "stop --");
+
+ return TRUE;
+}
+
+static GstFlowReturn
+gst_nxvideoenc_handle_frame (GstVideoEncoder * encoder,
+ GstVideoCodecFrame * frame)
+{
+ GstNxvideoenc *nxvideoenc = GST_NXVIDEOENC (encoder);
+ GstVideoFrame inframe;
+
+ GstMMVideoBufferMeta *meta = NULL;
+ GstMapInfo in_info;
+ GstMapInfo out_info;
+
+ NX_V4L2ENC_IN encIn;
+ NX_V4L2ENC_OUT encOut;
+
+ GST_DEBUG_OBJECT (nxvideoenc, "handle_frame");
+
+ gst_video_codec_frame_ref (frame);
+
+ meta = gst_buffer_get_mmvideobuffer_meta (frame->input_buffer);
+ if (NULL != meta && meta->memory_index >= 0) {
+ GstMemory *meta_block = NULL;
+ MMVideoBuffer *mm_buf = NULL;
+
+ meta_block =
+ gst_buffer_peek_memory (frame->input_buffer, meta->memory_index);
+ if (!meta_block) {
+ GST_ERROR ("Fail, gst_buffer_peek_memory().\n");
+ }
+
+ memset (&in_info, 0, sizeof (GstMapInfo));
+ gst_memory_map (meta_block, &in_info, GST_MAP_READ);
+
+ mm_buf = (MMVideoBuffer *) in_info.data;
+ if (!mm_buf) {
+ GST_ERROR ("Fail, get MMVideoBuffer.\n");
+ } else {
+ GST_DEBUG_OBJECT (nxvideoenc,
+ "type: 0x%x, width: %d, height: %d, plane_num: %d, handle_num: %d, index: %d",
+ mm_buf->type, mm_buf->width[0], mm_buf->height[0], mm_buf->plane_num,
+ mm_buf->handle_num, mm_buf->buffer_index);
+
+ if (FALSE == nxvideoenc->init) {
+ NX_V4L2ENC_PARA param;
+ memset (¶m, 0x00, sizeof (NX_V4L2ENC_PARA));
+
+ param.width = nxvideoenc->width;
+ param.height = nxvideoenc->height;
+ param.keyFrmInterval =
+ nxvideoenc->
+ keyFrmInterval ? (nxvideoenc->keyFrmInterval) : (nxvideoenc->
+ fpsNum / nxvideoenc->fpsDen);
+ param.fpsNum = nxvideoenc->fpsNum;
+ param.fpsDen = nxvideoenc->fpsDen;
+ param.profile =
+ (nxvideoenc->codec ==
+ V4L2_PIX_FMT_H263) ? V4L2_MPEG_VIDEO_H263_PROFILE_P3 : 0;
+ param.bitrate = nxvideoenc->bitrate;
+ param.maximumQp = nxvideoenc->maximumQp;
+ param.disableSkip = nxvideoenc->disableSkip;
+ param.RCDelay = nxvideoenc->RCDelay;
+ param.rcVbvSize = nxvideoenc->rcVbvSize;
+ param.gammaFactor = nxvideoenc->gammaFactor;
+ param.initialQp = nxvideoenc->initialQp;
+ param.numIntraRefreshMbs = nxvideoenc->numIntraRefreshMbs;
+ param.searchRange = nxvideoenc->searchRange;
+ param.enableAUDelimiter =
+ (nxvideoenc->codec ==
+ V4L2_PIX_FMT_H264) ? nxvideoenc->enableAUDelimiter : 0;
+ param.imgFormat = nxvideoenc->imgFormat;
+ param.imgBufferNum = MAX_INPUT_BUFFER;
+ param.imgPlaneNum = mm_buf->handle_num;
+
+ nxvideoenc->enc = NX_V4l2EncOpen (nxvideoenc->codec);
+ if (NULL == nxvideoenc->enc) {
+ GST_ERROR ("Fail, NX_V4l2EncOpen().\n");
+ return FALSE;
+ }
+
+ if (0 > NX_V4l2EncInit (nxvideoenc->enc, ¶m)) {
+ GST_ERROR ("Fail, NX_V4l2EncInit().\n");
+ NX_V4l2EncClose (nxvideoenc->enc);
+ nxvideoenc->enc = NULL;
+
+ return FALSE;
+ }
+
+ NX_V4l2EncGetSeqInfo (nxvideoenc->enc, &nxvideoenc->seq_buf,
+ &nxvideoenc->seq_size);
+
+ nxvideoenc->init = TRUE;
+ nxvideoenc->accelerable = TRUE;
+ }
+
+ if (NULL == nxvideoenc->inbuf[mm_buf->buffer_index]) {
+ gint i;
+ nxvideoenc->inbuf[mm_buf->buffer_index] =
+ (NX_VID_MEMORY_INFO *) malloc (sizeof (NX_VID_MEMORY_INFO));
+ memset (nxvideoenc->inbuf[mm_buf->buffer_index], 0,
+ sizeof (NX_VID_MEMORY_INFO));
+
+ nxvideoenc->inbuf[mm_buf->buffer_index]->width = mm_buf->width[0];
+ nxvideoenc->inbuf[mm_buf->buffer_index]->height = mm_buf->height[0];
+ nxvideoenc->inbuf[mm_buf->buffer_index]->planes = mm_buf->handle_num;
+ nxvideoenc->inbuf[mm_buf->buffer_index]->format = V4L2_PIX_FMT_YUV420M;
+
+ for (i = 0; i < mm_buf->handle_num; i++) {
+ nxvideoenc->inbuf[mm_buf->buffer_index]->size[i] = mm_buf->size[i];
+ nxvideoenc->inbuf[mm_buf->buffer_index]->pBuffer[i] = mm_buf->data[i];
+ nxvideoenc->inbuf[mm_buf->buffer_index]->gemFd[i] =
+ import_gem_from_flink (nxvideoenc->drm_fd, mm_buf->handle.gem[i]);
+ nxvideoenc->inbuf[mm_buf->buffer_index]->dmaFd[i] =
+ gem_to_dmafd (nxvideoenc->drm_fd,
+ nxvideoenc->inbuf[mm_buf->buffer_index]->gemFd[i]);
+ }
+
+ for (i = 0; i < mm_buf->plane_num; i++) {
+ nxvideoenc->inbuf[mm_buf->buffer_index]->stride[i] =
+ mm_buf->stride_width[i];
+ }
+ }
+
+ memset (&encIn, 0x00, sizeof (encIn));
+ encIn.pImage = nxvideoenc->inbuf[mm_buf->buffer_index];
+ encIn.imgIndex = mm_buf->buffer_index;
+ encIn.timeStamp = 0;
+ encIn.forcedIFrame = 0;
+ encIn.forcedSkipFrame = 0;
+ encIn.quantParam = nxvideoenc->initialQp;
+
+ if (0 > NX_V4l2EncEncodeFrame (nxvideoenc->enc, &encIn, &encOut)) {
+ GST_ERROR ("Fail, NX_V4l2EncEncodeFrame().\n");
+ gst_video_codec_frame_unref (frame);
+ return GST_FLOW_ERROR;
+ }
+
+ if (!g_strcmp0 (nxvideoenc->alignment, "au") && !g_strcmp0 (nxvideoenc->stream_format, "avc")) // H.264 & AU
+ {
+ frame->output_buffer =
+ gst_video_encoder_allocate_output_buffer (encoder, encOut.strmSize);
+ gst_buffer_map (frame->output_buffer, &out_info, GST_MAP_WRITE);
+
+ out_info.size = encOut.strmSize;
+ memcpy (out_info.data, encOut.strmBuf, encOut.strmSize);
+
+ // Nexell H.264 encoder output format : nal start code + 1 slice
+ // Remark au size instead of nal start code
+ GST_WRITE_UINT32_BE (out_info.data,
+ encOut.strmSize - H264_AU_LENGTH_SIZE);
+ } else // mpeg4 / h.263 / h.264 nal type
+ {
+ if ((V4L2_PIX_FMT_H263 != nxvideoenc->codec)
+ && (PIC_TYPE_I == encOut.frameType)) {
+ frame->output_buffer =
+ gst_video_encoder_allocate_output_buffer (encoder,
+ nxvideoenc->seq_size + encOut.strmSize);
+ gst_buffer_map (frame->output_buffer, &out_info, GST_MAP_WRITE);
+
+ out_info.size = nxvideoenc->seq_size + encOut.strmSize;
+ memcpy (out_info.data, nxvideoenc->seq_buf, nxvideoenc->seq_size);
+ memcpy (out_info.data + nxvideoenc->seq_size, encOut.strmBuf,
+ encOut.strmSize);
+ } else {
+ frame->output_buffer =
+ gst_video_encoder_allocate_output_buffer (encoder,
+ encOut.strmSize);
+ gst_buffer_map (frame->output_buffer, &out_info, GST_MAP_WRITE);
+
+ out_info.size = encOut.strmSize;
+ memcpy (out_info.data, encOut.strmBuf, encOut.strmSize);
+ }
+ }
+
+ if (PIC_TYPE_I == encOut.frameType) {
+ GST_VIDEO_CODEC_FRAME_SET_SYNC_POINT (frame);
+ } else {
+ GST_VIDEO_CODEC_FRAME_UNSET_SYNC_POINT (frame);
+ }
+
+ gst_buffer_unmap (frame->output_buffer, &out_info);
+ }
+ gst_memory_unmap (meta_block, &in_info);
+ } else {
+ if (FALSE == nxvideoenc->init) {
+ gint i = 0;
+ NX_V4L2ENC_PARA param;
+ memset (¶m, 0x00, sizeof (NX_V4L2ENC_PARA));
+
+ for (i = 0; i < MAX_ALLOC_BUFFER; i++) {
+ nxvideoenc->inbuf[i] = NX_AllocateVideoMemory (nxvideoenc->width,
+ nxvideoenc->height,
+ (nxvideoenc->imgFormat == V4L2_PIX_FMT_YUV420M) ? 3 : 2,
+ DRM_FORMAT_YUV420, 4096);
+
+ if (NULL == nxvideoenc->inbuf[i]) {
+ GST_ERROR ("Fail, NX_AllocateVideoMemory().\n");
+ return FALSE;
+ }
+
+ if (0 != NX_MapVideoMemory (nxvideoenc->inbuf[i])) {
+ GST_ERROR ("Fail, NX_MapVideoMemory().\n");
+ return FALSE;
+ }
+ }
+
+ param.width = nxvideoenc->width;
+ param.height = nxvideoenc->height;
+ param.keyFrmInterval =
+ nxvideoenc->
+ keyFrmInterval ? (nxvideoenc->keyFrmInterval) : (nxvideoenc->fpsNum /
+ nxvideoenc->fpsDen);
+ param.fpsNum = nxvideoenc->fpsNum;
+ param.fpsDen = nxvideoenc->fpsDen;
+ param.profile =
+ (nxvideoenc->codec ==
+ V4L2_PIX_FMT_H263) ? V4L2_MPEG_VIDEO_H263_PROFILE_P3 : 0;
+ param.bitrate = nxvideoenc->bitrate;
+ param.maximumQp = nxvideoenc->maximumQp;
+ param.disableSkip = nxvideoenc->disableSkip;
+ param.RCDelay = nxvideoenc->RCDelay;
+ param.rcVbvSize = nxvideoenc->rcVbvSize;
+ param.gammaFactor = nxvideoenc->gammaFactor;
+ param.initialQp = nxvideoenc->initialQp;
+ param.numIntraRefreshMbs = nxvideoenc->numIntraRefreshMbs;
+ param.searchRange = nxvideoenc->searchRange;
+ param.enableAUDelimiter =
+ (nxvideoenc->codec ==
+ V4L2_PIX_FMT_H264) ? nxvideoenc->enableAUDelimiter : 0;
+ param.imgFormat = nxvideoenc->imgFormat;
+ param.imgBufferNum = MAX_ALLOC_BUFFER;
+ param.imgPlaneNum = 3;
+
+ nxvideoenc->enc = NX_V4l2EncOpen (nxvideoenc->codec);
+ if (NULL == nxvideoenc->enc) {
+ GST_ERROR ("Fail, NX_V4l2EncOpen().\n");
+ return FALSE;
+ }
+
+ if (0 > NX_V4l2EncInit (nxvideoenc->enc, ¶m)) {
+ GST_ERROR ("Fail, NX_V4l2EncInit().\n");
+ NX_V4l2EncClose (nxvideoenc->enc);
+ nxvideoenc->enc = NULL;
+
+ return FALSE;
+ }
+
+ NX_V4l2EncGetSeqInfo (nxvideoenc->enc, &nxvideoenc->seq_buf,
+ &nxvideoenc->seq_size);
+
+ nxvideoenc->init = TRUE;
+ }
+
+ if (!gst_video_frame_map (&inframe, &nxvideoenc->input_state->info,
+ frame->input_buffer, GST_MAP_READ)) {
+ gst_video_codec_frame_unref (frame);
+ return GST_FLOW_ERROR;
+ }
+ copy_to_videomemory (&inframe, nxvideoenc->inbuf[nxvideoenc->buf_index]);
+
+ memset (&encIn, 0x00, sizeof (encIn));
+ encIn.pImage = nxvideoenc->inbuf[nxvideoenc->buf_index];
+ encIn.imgIndex = nxvideoenc->buf_index;
+ encIn.forcedIFrame = 0;
+ encIn.forcedSkipFrame = 0;
+ encIn.quantParam = nxvideoenc->initialQp;
+
+ nxvideoenc->buf_index = (nxvideoenc->buf_index + 1) % MAX_ALLOC_BUFFER;
+
+ if (0 > NX_V4l2EncEncodeFrame (nxvideoenc->enc, &encIn, &encOut)) {
+ GST_ERROR ("Fail, NX_V4l2EncEncodeFrame().\n");
+ gst_video_codec_frame_unref (frame);
+ return GST_FLOW_ERROR;
+ }
+
+ if (!g_strcmp0 (nxvideoenc->alignment, "au") && !g_strcmp0 (nxvideoenc->stream_format, "avc")) // H.264 & AU
+ {
+ frame->output_buffer =
+ gst_video_encoder_allocate_output_buffer (encoder, encOut.strmSize);
+ gst_buffer_map (frame->output_buffer, &out_info, GST_MAP_WRITE);
+
+ out_info.size = encOut.strmSize;
+ memcpy (out_info.data, encOut.strmBuf, encOut.strmSize);
+
+ // Nexell H.264 encoder output format : nal start code + 1 slice
+ // Remark au size instead of nal start code
+ GST_WRITE_UINT32_BE (out_info.data,
+ encOut.strmSize - H264_AU_LENGTH_SIZE);
+ } else // mpeg4 / h.263 / h.264 nal type
+ {
+ if ((V4L2_PIX_FMT_H263 != nxvideoenc->codec)
+ && (PIC_TYPE_I == encOut.frameType)) {
+ frame->output_buffer =
+ gst_video_encoder_allocate_output_buffer (encoder,
+ nxvideoenc->seq_size + encOut.strmSize);
+ gst_buffer_map (frame->output_buffer, &out_info, GST_MAP_WRITE);
+
+ out_info.size = nxvideoenc->seq_size + encOut.strmSize;
+ memcpy (out_info.data, nxvideoenc->seq_buf, nxvideoenc->seq_size);
+ memcpy (out_info.data + nxvideoenc->seq_size, encOut.strmBuf,
+ encOut.strmSize);
+ } else {
+ frame->output_buffer =
+ gst_video_encoder_allocate_output_buffer (encoder, encOut.strmSize);
+ gst_buffer_map (frame->output_buffer, &out_info, GST_MAP_WRITE);
+
+ out_info.size = encOut.strmSize;
+ memcpy (out_info.data, encOut.strmBuf, encOut.strmSize);
+ }
+ }
+
+ if (PIC_TYPE_I == encOut.frameType) {
+ GST_VIDEO_CODEC_FRAME_SET_SYNC_POINT (frame);
+ } else {
+ GST_VIDEO_CODEC_FRAME_UNSET_SYNC_POINT (frame);
+ }
+
+ gst_buffer_unmap (frame->output_buffer, &out_info);
+ gst_video_frame_unmap (&inframe);
+ }
+
+ gst_video_codec_frame_unref (frame);
+
+ return gst_video_encoder_finish_frame (encoder, frame);
+}
+
+static GstFlowReturn
+gst_nxvideoenc_finish (GstVideoEncoder * encoder)
+{
+ GstNxvideoenc *nxvideoenc = GST_NXVIDEOENC (encoder);
+
+ GST_DEBUG_OBJECT (nxvideoenc, "finish");
+
+ return GST_FLOW_OK;
+}
+
+static gboolean
+plugin_init (GstPlugin * plugin)
+{
+ /* FIXME Remember to set the rank if it's an element that is meant
+ to be autoplugged by decodebin. */
+
+ return gst_element_register (plugin, "nxvideoenc", GST_RANK_NONE,
+ GST_TYPE_NXVIDEOENC);
+}
+
+/* FIXME: these are normally defined by the GStreamer build system.
+ If you are creating an element to be included in gst-plugins-*,
+ remove these, as they're always defined. Otherwise, edit as
+ appropriate for your external plugin package. */
+#ifndef VERSION
+#define VERSION "0.1.1"
+#endif
+#ifndef PACKAGE
+#define PACKAGE "S5P6818 GStreamer PlugIn"
+#endif
+#ifndef PACKAGE_NAME
+#define PACKAGE_NAME "S5P6818 GStreamer PlugIn"
+#endif
+#ifndef GST_PACKAGE_ORIGIN
+#define GST_PACKAGE_ORIGIN "http://www.nexell.co.kr"
+#endif
+
+GST_PLUGIN_DEFINE (GST_VERSION_MAJOR,
+ GST_VERSION_MINOR,
+ nxvideoenc,
+ "Nexell H/W Video Encoder for S5P6818",
+ plugin_init, VERSION, "LGPL", PACKAGE_NAME, GST_PACKAGE_ORIGIN)
projects / platform / adaptation / nexell / gst-plugins-video-enc.git / commitdiff