--- /dev/null
+Haejeong Kim <backto.kim at samsung dot com>
+Hyunjun Ko <zzoon.ko at samsung dot com>
--- /dev/null
+CMAKE_MINIMUM_REQUIRED(VERSION 2.6)
+PROJECT(media-service C)
+SET(VERSION_MAJOR 1)
+SET(VERSION "${VERSION_MAJOR}.0.0")
+
+SET(MEDIASERVICE-LIB "media-service")
+SET(MEDIASERVICE-HASH-LIB "media-svc-hash")
+SET(MEDIACONTENT-PLUGIN-LIB "media-content-plugin")
+SET(SRCS
+ uuid/clear.c
+ uuid/compare.c
+ uuid/copy.c
+ uuid/gen_uuid.c
+ uuid/isnull.c
+ uuid/pack.c
+ uuid/parse.c
+ uuid/unpack.c
+ uuid/unparse.c
+ uuid/uuid_time.c
+
+ src/common/media-svc.c
+ src/common/media-svc-media.c
+ src/common/media-svc-album.c
+ src/common/media-svc-media-folder.c
+ src/common/media-svc-db-utils.c
+ src/common/media-svc-util.c
+ src/common/media-svc-debug.c
+ )
+
+SET(HASH_SRCS
+ md5/md5.c
+ md5/media-svc-hash.c
+ )
+
+SET(PLUGIN_SRCS
+ plugin/media-svc-plugin.c
+ )
+SET(CONTENTPLUGIN_SRCS
+ plugin/media-content-plugin.c
+ )
+
+SET(VENDOR "samsung")
+SET(PACKAGE ${PROJECT_NAME})
+SET(PKGNAME "com.${VENDOR}.${PACKAGE}")
+SET(PREFIX ${CMAKE_INSTALL_PREFIX})
+SET(BINDIR "${PREFIX}/bin")
+SET(DATADIR "${PREFIX}/share")
+SET(EXEC_PREFIX "\${prefix}")
+SET(LIBDIR "\${prefix}/lib")
+SET(INCLUDEDIR "\${prefix}/include")
+
+IF("${CMAKE_BUILD_TYPE}" STREQUAL "")
+ SET(CMAKE_BUILD_TYPE "Release")
+ENDIF("${CMAKE_BUILD_TYPE}" STREQUAL "")
+MESSAGE("Build type: ${CMAKE_BUILD_TYPE}")
+
+INCLUDE_DIRECTORIES(${CMAKE_SOURCE_DIR}/include ${CMAKE_SOURCE_DIR}/src/include/common ${CMAKE_SOURCE_DIR} ${CMAKE_SOURCE_DIR}/uuid ${CMAKE_SOURCE_DIR}/md5)
+
+INCLUDE(FindPkgConfig)
+pkg_check_modules(pkgs REQUIRED glib-2.0 dlog sqlite3 db-util libexif mm-common mm-fileinfo drm-client media-thumbnail libmedia-utils aul)
+
+
+
+FOREACH(flag ${pkgs_CFLAGS})
+ SET(EXTRA_CFLAGS "${EXTRA_CFLAGS} ${flag}")
+ENDFOREACH(flag)
+
+SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${EXTRA_CFLAGS} -fPIC")
+SET(CMAKE_C_FLAGS_DEBUG "-O0 -g")
+SET(CMAKE_C_FLAGS_RELEASE "-O2 -fPIC")
+
+FIND_PROGRAM(UNAME NAMES uname)
+EXEC_PROGRAM("${UNAME}" ARGS "-m" OUTPUT_VARIABLE "ARCH")
+IF("${ARCH}" STREQUAL "arm")
+ ADD_DEFINITIONS("-DTARGET")
+ MESSAGE("add -DTARGET")
+ENDIF("${ARCH}" STREQUAL "arm")
+
+ADD_DEFINITIONS("-DVENDOR=\"${VENDOR}\"")
+ADD_DEFINITIONS("-DPACKAGE=\"${PACKAGE}\"")
+ADD_DEFINITIONS("-DPACKAGE_NAME=\"${PKGNAME}\"")
+ADD_DEFINITIONS("-DPREFIX=\"${PREFIX}\"")
+ADD_DEFINITIONS("-D_FILE_OFFSET_BITS=64")
+#ADD_DEFINITIONS("-D_PERFORMANCE_CHECK_")
+#ADD_DEFINITIONS("-D_USE_LOG_FILE_")
+
+SET(CMAKE_EXE_LINKER_FLAGS "-Wl,--as-needed -Wl,--hash-style=both")
+CONFIGURE_FILE(libmedia-service.pc.in libmedia-service.pc @ONLY)
+INSTALL(FILES ${CMAKE_CURRENT_BINARY_DIR}/libmedia-service.pc DESTINATION lib/pkgconfig)
+
+LINK_DIRECTORIES(lib)
+
+ADD_LIBRARY(${MEDIASERVICE-HASH-LIB} SHARED ${HASH_SRCS})
+SET_TARGET_PROPERTIES(${MEDIASERVICE-HASH-LIB} PROPERTIES SOVERSION ${VERSION_MAJOR})
+SET_TARGET_PROPERTIES(${MEDIASERVICE-HASH-LIB} PROPERTIES VERSION ${VERSION})
+ADD_LIBRARY(${MEDIASERVICE-LIB} SHARED ${SRCS})
+TARGET_LINK_LIBRARIES(${MEDIASERVICE-LIB} ${pkgs_LDFLAGS} ${MEDIASERVICE-HASH-LIB})
+SET_TARGET_PROPERTIES(${MEDIASERVICE-LIB} PROPERTIES SOVERSION ${VERSION_MAJOR})
+SET_TARGET_PROPERTIES(${MEDIASERVICE-LIB} PROPERTIES VERSION ${VERSION})
+ADD_LIBRARY(${MEDIACONTENT-PLUGIN-LIB} SHARED ${CONTENTPLUGIN_SRCS})
+TARGET_LINK_LIBRARIES(${MEDIACONTENT-PLUGIN-LIB} ${MEDIASERVICE-LIB})
+SET_TARGET_PROPERTIES(${MEDIACONTENT-PLUGIN-LIB} PROPERTIES SOVERSION ${VERSION_MAJOR})
+SET_TARGET_PROPERTIES(${MEDIACONTENT-PLUGIN-LIB} PROPERTIES VERSION ${VERSION})
+
+INSTALL(TARGETS ${MEDIASERVICE-LIB} LIBRARY DESTINATION lib)
+INSTALL(TARGETS ${MEDIASERVICE-HASH-LIB} LIBRARY DESTINATION lib)
+INSTALL(TARGETS ${MEDIACONTENT-PLUGIN-LIB} LIBRARY DESTINATION lib)
+
+INSTALL(FILES ${CMAKE_CURRENT_SOURCE_DIR}/include/media-svc.h DESTINATION include/media-service/)
+INSTALL(FILES ${CMAKE_CURRENT_SOURCE_DIR}/include/media-svc-error.h DESTINATION include/media-service/)
+INSTALL(FILES ${CMAKE_CURRENT_SOURCE_DIR}/include/media-svc-types.h DESTINATION include/media-service/)
--- /dev/null
+ Apache License
+ Version 2.0, January 2004
+ http://www.apache.org/licenses/
+
+ TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+ 1. Definitions.
+
+ "License" shall mean the terms and conditions for use, reproduction,
+ and distribution as defined by Sections 1 through 9 of this document.
+
+ "Licensor" shall mean the copyright owner or entity authorized by
+ the copyright owner that is granting the License.
+
+ "Legal Entity" shall mean the union of the acting entity and all
+ other entities that control, are controlled by, or are under common
+ control with that entity. For the purposes of this definition,
+ "control" means (i) the power, direct or indirect, to cause the
+ direction or management of such entity, whether by contract or
+ otherwise, or (ii) ownership of fifty percent (50%) or more of the
+ outstanding shares, or (iii) beneficial ownership of such entity.
+
+ "You" (or "Your") shall mean an individual or Legal Entity
+ exercising permissions granted by this License.
+
+ "Source" form shall mean the preferred form for making modifications,
+ including but not limited to software source code, documentation
+ source, and configuration files.
+
+ "Object" form shall mean any form resulting from mechanical
+ transformation or translation of a Source form, including but
+ not limited to compiled object code, generated documentation,
+ and conversions to other media types.
+
+ "Work" shall mean the work of authorship, whether in Source or
+ Object form, made available under the License, as indicated by a
+ copyright notice that is included in or attached to the work
+ (an example is provided in the Appendix below).
+
+ "Derivative Works" shall mean any work, whether in Source or Object
+ form, that is based on (or derived from) the Work and for which the
+ editorial revisions, annotations, elaborations, or other modifications
+ represent, as a whole, an original work of authorship. For the purposes
+ of this License, Derivative Works shall not include works that remain
+ separable from, or merely link (or bind by name) to the interfaces of,
+ the Work and Derivative Works thereof.
+
+ "Contribution" shall mean any work of authorship, including
+ the original version of the Work and any modifications or additions
+ to that Work or Derivative Works thereof, that is intentionally
+ submitted to Licensor for inclusion in the Work by the copyright owner
+ or by an individual or Legal Entity authorized to submit on behalf of
+ the copyright owner. For the purposes of this definition, "submitted"
+ means any form of electronic, verbal, or written communication sent
+ to the Licensor or its representatives, including but not limited to
+ communication on electronic mailing lists, source code control systems,
+ and issue tracking systems that are managed by, or on behalf of, the
+ Licensor for the purpose of discussing and improving the Work, but
+ excluding communication that is conspicuously marked or otherwise
+ designated in writing by the copyright owner as "Not a Contribution."
+
+ "Contributor" shall mean Licensor and any individual or Legal Entity
+ on behalf of whom a Contribution has been received by Licensor and
+ subsequently incorporated within the Work.
+
+ 2. Grant of Copyright License. Subject to the terms and conditions of
+ this License, each Contributor hereby grants to You a perpetual,
+ worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+ copyright license to reproduce, prepare Derivative Works of,
+ publicly display, publicly perform, sublicense, and distribute the
+ Work and such Derivative Works in Source or Object form.
+
+ 3. Grant of Patent License. Subject to the terms and conditions of
+ this License, each Contributor hereby grants to You a perpetual,
+ worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+ (except as stated in this section) patent license to make, have made,
+ use, offer to sell, sell, import, and otherwise transfer the Work,
+ where such license applies only to those patent claims licensable
+ by such Contributor that are necessarily infringed by their
+ Contribution(s) alone or by combination of their Contribution(s)
+ with the Work to which such Contribution(s) was submitted. If You
+ institute patent litigation against any entity (including a
+ cross-claim or counterclaim in a lawsuit) alleging that the Work
+ or a Contribution incorporated within the Work constitutes direct
+ or contributory patent infringement, then any patent licenses
+ granted to You under this License for that Work shall terminate
+ as of the date such litigation is filed.
+
+ 4. Redistribution. You may reproduce and distribute copies of the
+ Work or Derivative Works thereof in any medium, with or without
+ modifications, and in Source or Object form, provided that You
+ meet the following conditions:
+
+ (a) You must give any other recipients of the Work or
+ Derivative Works a copy of this License; and
+
+ (b) You must cause any modified files to carry prominent notices
+ stating that You changed the files; and
+
+ (c) You must retain, in the Source form of any Derivative Works
+ that You distribute, all copyright, patent, trademark, and
+ attribution notices from the Source form of the Work,
+ excluding those notices that do not pertain to any part of
+ the Derivative Works; and
+
+ (d) If the Work includes a "NOTICE" text file as part of its
+ distribution, then any Derivative Works that You distribute must
+ include a readable copy of the attribution notices contained
+ within such NOTICE file, excluding those notices that do not
+ pertain to any part of the Derivative Works, in at least one
+ of the following places: within a NOTICE text file distributed
+ as part of the Derivative Works; within the Source form or
+ documentation, if provided along with the Derivative Works; or,
+ within a display generated by the Derivative Works, if and
+ wherever such third-party notices normally appear. The contents
+ of the NOTICE file are for informational purposes only and
+ do not modify the License. You may add Your own attribution
+ notices within Derivative Works that You distribute, alongside
+ or as an addendum to the NOTICE text from the Work, provided
+ that such additional attribution notices cannot be construed
+ as modifying the License.
+
+ You may add Your own copyright statement to Your modifications and
+ may provide additional or different license terms and conditions
+ for use, reproduction, or distribution of Your modifications, or
+ for any such Derivative Works as a whole, provided Your use,
+ reproduction, and distribution of the Work otherwise complies with
+ the conditions stated in this License.
+
+ 5. Submission of Contributions. Unless You explicitly state otherwise,
+ any Contribution intentionally submitted for inclusion in the Work
+ by You to the Licensor shall be under the terms and conditions of
+ this License, without any additional terms or conditions.
+ Notwithstanding the above, nothing herein shall supersede or modify
+ the terms of any separate license agreement you may have executed
+ with Licensor regarding such Contributions.
+
+ 6. Trademarks. This License does not grant permission to use the trade
+ names, trademarks, service marks, or product names of the Licensor,
+ except as required for reasonable and customary use in describing the
+ origin of the Work and reproducing the content of the NOTICE file.
+
+ 7. Disclaimer of Warranty. Unless required by applicable law or
+ agreed to in writing, Licensor provides the Work (and each
+ Contributor provides its Contributions) on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+ implied, including, without limitation, any warranties or conditions
+ of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+ PARTICULAR PURPOSE. You are solely responsible for determining the
+ appropriateness of using or redistributing the Work and assume any
+ risks associated with Your exercise of permissions under this License.
+
+ 8. Limitation of Liability. In no event and under no legal theory,
+ whether in tort (including negligence), contract, or otherwise,
+ unless required by applicable law (such as deliberate and grossly
+ negligent acts) or agreed to in writing, shall any Contributor be
+ liable to You for damages, including any direct, indirect, special,
+ incidental, or consequential damages of any character arising as a
+ result of this License or out of the use or inability to use the
+ Work (including but not limited to damages for loss of goodwill,
+ work stoppage, computer failure or malfunction, or any and all
+ other commercial damages or losses), even if such Contributor
+ has been advised of the possibility of such damages.
+
+ 9. Accepting Warranty or Additional Liability. While redistributing
+ the Work or Derivative Works thereof, You may choose to offer,
+ and charge a fee for, acceptance of support, warranty, indemnity,
+ or other liability obligations and/or rights consistent with this
+ License. However, in accepting such obligations, You may act only
+ on Your own behalf and on Your sole responsibility, not on behalf
+ of any other Contributor, and only if You agree to indemnify,
+ defend, and hold each Contributor harmless for any liability
+ incurred by, or claims asserted against, such Contributor by reason
+ of your accepting any such warranty or additional liability.
+
+ END OF TERMS AND CONDITIONS
+
+ APPENDIX: How to apply the Apache License to your work.
+
+ To apply the Apache License to your work, attach the following
+ boilerplate notice, with the fields enclosed by brackets "[]"
+ replaced with your own identifying information. (Don't include
+ the brackets!) The text should be enclosed in the appropriate
+ comment syntax for the file format. We also recommend that a
+ file or class name and description of purpose be included on the
+ same "printed page" as the copyright notice for easier
+ identification within third-party archives.
+
+ Copyright [yyyy] [name of copyright owner]
+
+ Licensed under the Apache License, Version 2.0 (the "License");
+ you may not use this file except in compliance with the License.
+ You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing, software
+ distributed under the License is distributed on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ See the License for the specific language governing permissions and
+ limitations under the License.
+
+
+
+ GNU LESSER GENERAL PUBLIC LICENSE
+ Version 2.1, February 1999
+
+ Copyright (C) 1991, 1999 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 Lesser GPL. It also counts
+ as the successor of the GNU Library Public License, version 2, hence
+ the version number 2.1.]
+
+ Preamble
+
+ The licenses for most software are designed to take away your
+freedom to share and change it. By contrast, the GNU General Public
+Licenses are intended to guarantee your freedom to share and change
+free software--to make sure the software is free for all its users.
+
+ This license, the Lesser General Public License, applies to some
+specially designated software packages--typically libraries--of the
+Free Software Foundation and other authors who decide to use it. You
+can use it too, but we suggest you first think carefully about whether
+this license or the ordinary General Public License is the better
+strategy to use in any particular case, based on the explanations below.
+
+ When we speak of free software, we are referring to freedom of use,
+not price. Our General Public Licenses are designed to make sure that
+you have the freedom to distribute copies of free software (and charge
+for this service if you wish); that you receive source code or can get
+it if you want it; that you can change the software and use pieces of
+it in new free programs; and that you are informed that you can do
+these things.
+
+ To protect your rights, we need to make restrictions that forbid
+distributors to deny you these rights or to ask you to surrender these
+rights. These restrictions translate to certain responsibilities for
+you if you distribute copies of the library or if you modify it.
+
+ For example, if you distribute copies of the library, whether gratis
+or for a fee, you must give the recipients all the rights that we gave
+you. You must make sure that they, too, receive or can get the source
+code. If you link other code with the library, you must provide
+complete object files to the recipients, so that they can relink them
+with the library after making changes to the library and recompiling
+it. And you must show them these terms so they know their rights.
+
+ We protect your rights with a two-step method: (1) we copyright the
+library, and (2) we offer you this license, which gives you legal
+permission to copy, distribute and/or modify the library.
+
+ To protect each distributor, we want to make it very clear that
+there is no warranty for the free library. Also, if the library is
+modified by someone else and passed on, the recipients should know
+that what they have is not the original version, so that the original
+author's reputation will not be affected by problems that might be
+introduced by others.
+\f
+ Finally, software patents pose a constant threat to the existence of
+any free program. We wish to make sure that a company cannot
+effectively restrict the users of a free program by obtaining a
+restrictive license from a patent holder. Therefore, we insist that
+any patent license obtained for a version of the library must be
+consistent with the full freedom of use specified in this license.
+
+ Most GNU software, including some libraries, is covered by the
+ordinary GNU General Public License. This license, the GNU Lesser
+General Public License, applies to certain designated libraries, and
+is quite different from the ordinary General Public License. We use
+this license for certain libraries in order to permit linking those
+libraries into non-free programs.
+
+ When a program is linked with a library, whether statically or using
+a shared library, the combination of the two is legally speaking a
+combined work, a derivative of the original library. The ordinary
+General Public License therefore permits such linking only if the
+entire combination fits its criteria of freedom. The Lesser General
+Public License permits more lax criteria for linking other code with
+the library.
+
+ We call this license the "Lesser" General Public License because it
+does Less to protect the user's freedom than the ordinary General
+Public License. It also provides other free software developers Less
+of an advantage over competing non-free programs. These disadvantages
+are the reason we use the ordinary General Public License for many
+libraries. However, the Lesser license provides advantages in certain
+special circumstances.
+
+ For example, on rare occasions, there may be a special need to
+encourage the widest possible use of a certain library, so that it becomes
+a de-facto standard. To achieve this, non-free programs must be
+allowed to use the library. A more frequent case is that a free
+library does the same job as widely used non-free libraries. In this
+case, there is little to gain by limiting the free library to free
+software only, so we use the Lesser General Public License.
+
+ In other cases, permission to use a particular library in non-free
+programs enables a greater number of people to use a large body of
+free software. For example, permission to use the GNU C Library in
+non-free programs enables many more people to use the whole GNU
+operating system, as well as its variant, the GNU/Linux operating
+system.
+
+ Although the Lesser General Public License is Less protective of the
+users' freedom, it does ensure that the user of a program that is
+linked with the Library has the freedom and the wherewithal to run
+that program using a modified version of the Library.
+
+ The precise terms and conditions for copying, distribution and
+modification follow. Pay close attention to the difference between a
+"work based on the library" and a "work that uses the library". The
+former contains code derived from the library, whereas the latter must
+be combined with the library in order to run.
+\f
+ GNU LESSER GENERAL PUBLIC LICENSE
+ TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+
+ 0. This License Agreement applies to any software library or other
+program which contains a notice placed by the copyright holder or
+other authorized party saying it may be distributed under the terms of
+this Lesser General Public License (also called "this License").
+Each licensee is addressed as "you".
+
+ A "library" means a collection of software functions and/or data
+prepared so as to be conveniently linked with application programs
+(which use some of those functions and data) to form executables.
+
+ The "Library", below, refers to any such software library or work
+which has been distributed under these terms. A "work based on the
+Library" means either the Library or any derivative work under
+copyright law: that is to say, a work containing the Library or a
+portion of it, either verbatim or with modifications and/or translated
+straightforwardly into another language. (Hereinafter, translation is
+included without limitation in the term "modification".)
+
+ "Source code" for a work means the preferred form of the work for
+making modifications to it. For a library, complete source code means
+all the source code for all modules it contains, plus any associated
+interface definition files, plus the scripts used to control compilation
+and installation of the library.
+
+ Activities other than copying, distribution and modification are not
+covered by this License; they are outside its scope. The act of
+running a program using the Library is not restricted, and output from
+such a program is covered only if its contents constitute a work based
+on the Library (independent of the use of the Library in a tool for
+writing it). Whether that is true depends on what the Library does
+and what the program that uses the Library does.
+
+ 1. You may copy and distribute verbatim copies of the Library's
+complete source code as you receive it, in any medium, provided that
+you conspicuously and appropriately publish on each copy an
+appropriate copyright notice and disclaimer of warranty; keep intact
+all the notices that refer to this License and to the absence of any
+warranty; and distribute a copy of this License along with the
+Library.
+
+ You may charge a fee for the physical act of transferring a copy,
+and you may at your option offer warranty protection in exchange for a
+fee.
+\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 combine or
+link a "work that uses the Library" with the Library to produce a
+work containing portions of the Library, and distribute that work
+under terms of your choice, provided that the terms permit
+modification of the work for the customer's own use and reverse
+engineering for debugging such modifications.
+
+ You must give prominent notice with each copy of the work that the
+Library is used in it and that the Library and its use are covered by
+this License. You must supply a copy of this License. If the work
+during execution displays copyright notices, you must include the
+copyright notice for the Library among them, as well as a reference
+directing the user to the copy of this License. Also, you must do one
+of these things:
+
+ a) Accompany the work with the complete corresponding
+ machine-readable source code for the Library including whatever
+ changes were used in the work (which must be distributed under
+ Sections 1 and 2 above); and, if the work is an executable linked
+ with the Library, with the complete machine-readable "work that
+ uses the Library", as object code and/or source code, so that the
+ user can modify the Library and then relink to produce a modified
+ executable containing the modified Library. (It is understood
+ that the user who changes the contents of definitions files in the
+ Library will not necessarily be able to recompile the application
+ to use the modified definitions.)
+
+ b) Use a suitable shared library mechanism for linking with the
+ Library. A suitable mechanism is one that (1) uses at run time a
+ copy of the library already present on the user's computer system,
+ rather than copying library functions into the executable, and (2)
+ will operate properly with a modified version of the library, if
+ the user installs one, as long as the modified version is
+ interface-compatible with the version that the work was made with.
+
+ c) Accompany the work with a written offer, valid for at
+ least three years, to give the same user the materials
+ specified in Subsection 6a, above, for a charge no more
+ than the cost of performing this distribution.
+
+ d) If distribution of the work is made by offering access to copy
+ from a designated place, offer equivalent access to copy the above
+ specified materials from the same place.
+
+ e) Verify that the user has already received a copy of these
+ materials or that you have already sent this user a copy.
+
+ For an executable, the required form of the "work that uses the
+Library" must include any data and utility programs needed for
+reproducing the executable from it. However, as a special exception,
+the materials to be distributed need not include anything that is
+normally distributed (in either source or binary form) with the major
+components (compiler, kernel, and so on) of the operating system on
+which the executable runs, unless that component itself accompanies
+the executable.
+
+ It may happen that this requirement contradicts the license
+restrictions of other proprietary libraries that do not normally
+accompany the operating system. Such a contradiction means you cannot
+use both them and the Library together in an executable that you
+distribute.
+\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 with
+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 Lesser General Public License from time to time.
+Such new versions will be similar in spirit to the present version,
+but may differ in detail to address new problems or concerns.
+
+Each version is given a distinguishing version number. If the Library
+specifies a version number of this License which applies to it and
+"any later version", you have the option of following the terms and
+conditions either of that version or of any later version published by
+the Free Software Foundation. If the Library does not specify a
+license version number, you may choose any version ever published by
+the Free Software Foundation.
+\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
+ How to Apply These Terms to Your New Libraries
+
+ If you develop a new library, and you want it to be of the greatest
+possible use to the public, we recommend making it free software that
+everyone can redistribute and change. You can do so by permitting
+redistribution under these terms (or, alternatively, under the terms of the
+ordinary General Public License).
+
+ To apply these terms, attach the following notices to the library. It is
+safest to attach them to the start of each source file to most effectively
+convey the exclusion of warranty; and each file should have at least the
+"copyright" line and a pointer to where the full notice is found.
+
+ <one line to give the library's name and a brief idea of what it does.>
+ Copyright (C) <year> <name of author>
+
+ This library is free software; you can redistribute it and/or
+ modify it under the terms of the GNU Lesser General Public
+ License as published by the Free Software Foundation; either
+ version 2.1 of the License, or (at your option) any later version.
+
+ This library is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ Lesser General Public License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with this library; if not, write to the Free Software
+ Foundation, Inc., 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!
+
+
+BSD-style
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+ this list of conditions and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright
+ notice, this list of conditions and the following disclaimer in
+ the documentation and/or other materials provided with the distribution.
+
+ 3. The names of the authors may not be used to endorse or promote products
+ derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED WARRANTIES,
+INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
+FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL JCRAFT,
+INC. OR ANY CONTRIBUTORS TO THIS SOFTWARE BE LIABLE FOR ANY DIRECT, INDIRECT,
+INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,
+OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
--- /dev/null
+ Apache License
+ Version 2.0, January 2004
+ http://www.apache.org/licenses/
+
+ TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+ 1. Definitions.
+
+ "License" shall mean the terms and conditions for use, reproduction,
+ and distribution as defined by Sections 1 through 9 of this document.
+
+ "Licensor" shall mean the copyright owner or entity authorized by
+ the copyright owner that is granting the License.
+
+ "Legal Entity" shall mean the union of the acting entity and all
+ other entities that control, are controlled by, or are under common
+ control with that entity. For the purposes of this definition,
+ "control" means (i) the power, direct or indirect, to cause the
+ direction or management of such entity, whether by contract or
+ otherwise, or (ii) ownership of fifty percent (50%) or more of the
+ outstanding shares, or (iii) beneficial ownership of such entity.
+
+ "You" (or "Your") shall mean an individual or Legal Entity
+ exercising permissions granted by this License.
+
+ "Source" form shall mean the preferred form for making modifications,
+ including but not limited to software source code, documentation
+ source, and configuration files.
+
+ "Object" form shall mean any form resulting from mechanical
+ transformation or translation of a Source form, including but
+ not limited to compiled object code, generated documentation,
+ and conversions to other media types.
+
+ "Work" shall mean the work of authorship, whether in Source or
+ Object form, made available under the License, as indicated by a
+ copyright notice that is included in or attached to the work
+ (an example is provided in the Appendix below).
+
+ "Derivative Works" shall mean any work, whether in Source or Object
+ form, that is based on (or derived from) the Work and for which the
+ editorial revisions, annotations, elaborations, or other modifications
+ represent, as a whole, an original work of authorship. For the purposes
+ of this License, Derivative Works shall not include works that remain
+ separable from, or merely link (or bind by name) to the interfaces of,
+ the Work and Derivative Works thereof.
+
+ "Contribution" shall mean any work of authorship, including
+ the original version of the Work and any modifications or additions
+ to that Work or Derivative Works thereof, that is intentionally
+ submitted to Licensor for inclusion in the Work by the copyright owner
+ or by an individual or Legal Entity authorized to submit on behalf of
+ the copyright owner. For the purposes of this definition, "submitted"
+ means any form of electronic, verbal, or written communication sent
+ to the Licensor or its representatives, including but not limited to
+ communication on electronic mailing lists, source code control systems,
+ and issue tracking systems that are managed by, or on behalf of, the
+ Licensor for the purpose of discussing and improving the Work, but
+ excluding communication that is conspicuously marked or otherwise
+ designated in writing by the copyright owner as "Not a Contribution."
+
+ "Contributor" shall mean Licensor and any individual or Legal Entity
+ on behalf of whom a Contribution has been received by Licensor and
+ subsequently incorporated within the Work.
+
+ 2. Grant of Copyright License. Subject to the terms and conditions of
+ this License, each Contributor hereby grants to You a perpetual,
+ worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+ copyright license to reproduce, prepare Derivative Works of,
+ publicly display, publicly perform, sublicense, and distribute the
+ Work and such Derivative Works in Source or Object form.
+
+ 3. Grant of Patent License. Subject to the terms and conditions of
+ this License, each Contributor hereby grants to You a perpetual,
+ worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+ (except as stated in this section) patent license to make, have made,
+ use, offer to sell, sell, import, and otherwise transfer the Work,
+ where such license applies only to those patent claims licensable
+ by such Contributor that are necessarily infringed by their
+ Contribution(s) alone or by combination of their Contribution(s)
+ with the Work to which such Contribution(s) was submitted. If You
+ institute patent litigation against any entity (including a
+ cross-claim or counterclaim in a lawsuit) alleging that the Work
+ or a Contribution incorporated within the Work constitutes direct
+ or contributory patent infringement, then any patent licenses
+ granted to You under this License for that Work shall terminate
+ as of the date such litigation is filed.
+
+ 4. Redistribution. You may reproduce and distribute copies of the
+ Work or Derivative Works thereof in any medium, with or without
+ modifications, and in Source or Object form, provided that You
+ meet the following conditions:
+
+ (a) You must give any other recipients of the Work or
+ Derivative Works a copy of this License; and
+
+ (b) You must cause any modified files to carry prominent notices
+ stating that You changed the files; and
+
+ (c) You must retain, in the Source form of any Derivative Works
+ that You distribute, all copyright, patent, trademark, and
+ attribution notices from the Source form of the Work,
+ excluding those notices that do not pertain to any part of
+ the Derivative Works; and
+
+ (d) If the Work includes a "NOTICE" text file as part of its
+ distribution, then any Derivative Works that You distribute must
+ include a readable copy of the attribution notices contained
+ within such NOTICE file, excluding those notices that do not
+ pertain to any part of the Derivative Works, in at least one
+ of the following places: within a NOTICE text file distributed
+ as part of the Derivative Works; within the Source form or
+ documentation, if provided along with the Derivative Works; or,
+ within a display generated by the Derivative Works, if and
+ wherever such third-party notices normally appear. The contents
+ of the NOTICE file are for informational purposes only and
+ do not modify the License. You may add Your own attribution
+ notices within Derivative Works that You distribute, alongside
+ or as an addendum to the NOTICE text from the Work, provided
+ that such additional attribution notices cannot be construed
+ as modifying the License.
+
+ You may add Your own copyright statement to Your modifications and
+ may provide additional or different license terms and conditions
+ for use, reproduction, or distribution of Your modifications, or
+ for any such Derivative Works as a whole, provided Your use,
+ reproduction, and distribution of the Work otherwise complies with
+ the conditions stated in this License.
+
+ 5. Submission of Contributions. Unless You explicitly state otherwise,
+ any Contribution intentionally submitted for inclusion in the Work
+ by You to the Licensor shall be under the terms and conditions of
+ this License, without any additional terms or conditions.
+ Notwithstanding the above, nothing herein shall supersede or modify
+ the terms of any separate license agreement you may have executed
+ with Licensor regarding such Contributions.
+
+ 6. Trademarks. This License does not grant permission to use the trade
+ names, trademarks, service marks, or product names of the Licensor,
+ except as required for reasonable and customary use in describing the
+ origin of the Work and reproducing the content of the NOTICE file.
+
+ 7. Disclaimer of Warranty. Unless required by applicable law or
+ agreed to in writing, Licensor provides the Work (and each
+ Contributor provides its Contributions) on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+ implied, including, without limitation, any warranties or conditions
+ of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+ PARTICULAR PURPOSE. You are solely responsible for determining the
+ appropriateness of using or redistributing the Work and assume any
+ risks associated with Your exercise of permissions under this License.
+
+ 8. Limitation of Liability. In no event and under no legal theory,
+ whether in tort (including negligence), contract, or otherwise,
+ unless required by applicable law (such as deliberate and grossly
+ negligent acts) or agreed to in writing, shall any Contributor be
+ liable to You for damages, including any direct, indirect, special,
+ incidental, or consequential damages of any character arising as a
+ result of this License or out of the use or inability to use the
+ Work (including but not limited to damages for loss of goodwill,
+ work stoppage, computer failure or malfunction, or any and all
+ other commercial damages or losses), even if such Contributor
+ has been advised of the possibility of such damages.
+
+ 9. Accepting Warranty or Additional Liability. While redistributing
+ the Work or Derivative Works thereof, You may choose to offer,
+ and charge a fee for, acceptance of support, warranty, indemnity,
+ or other liability obligations and/or rights consistent with this
+ License. However, in accepting such obligations, You may act only
+ on Your own behalf and on Your sole responsibility, not on behalf
+ of any other Contributor, and only if You agree to indemnify,
+ defend, and hold each Contributor harmless for any liability
+ incurred by, or claims asserted against, such Contributor by reason
+ of your accepting any such warranty or additional liability.
+
+ END OF TERMS AND CONDITIONS
+
+ APPENDIX: How to apply the Apache License to your work.
+
+ To apply the Apache License to your work, attach the following
+ boilerplate notice, with the fields enclosed by brackets "[]"
+ replaced with your own identifying information. (Don't include
+ the brackets!) The text should be enclosed in the appropriate
+ comment syntax for the file format. We also recommend that a
+ file or class name and description of purpose be included on the
+ same "printed page" as the copyright notice for easier
+ identification within third-party archives.
+
+ Copyright [yyyy] [name of copyright owner]
+
+ Licensed under the Apache License, Version 2.0 (the "License");
+ you may not use this file except in compliance with the License.
+ You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing, software
+ distributed under the License is distributed on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ See the License for the specific language governing permissions and
+ limitations under the License.
--- /dev/null
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+ this list of conditions and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright
+ notice, this list of conditions and the following disclaimer in
+ the documentation and/or other materials provided with the distribution.
+
+ 3. The names of the authors may not be used to endorse or promote products
+ derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED WARRANTIES,
+INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
+FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL JCRAFT,
+INC. OR ANY CONTRIBUTORS TO THIS SOFTWARE BE LIABLE FOR ANY DIRECT, INDIRECT,
+INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,
+OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
--- /dev/null
+ GNU LESSER GENERAL PUBLIC LICENSE
+ Version 2.1, February 1999
+
+ Copyright (C) 1991, 1999 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 Lesser GPL. It also counts
+ as the successor of the GNU Library Public License, version 2, hence
+ the version number 2.1.]
+
+ Preamble
+
+ The licenses for most software are designed to take away your
+freedom to share and change it. By contrast, the GNU General Public
+Licenses are intended to guarantee your freedom to share and change
+free software--to make sure the software is free for all its users.
+
+ This license, the Lesser General Public License, applies to some
+specially designated software packages--typically libraries--of the
+Free Software Foundation and other authors who decide to use it. You
+can use it too, but we suggest you first think carefully about whether
+this license or the ordinary General Public License is the better
+strategy to use in any particular case, based on the explanations below.
+
+ When we speak of free software, we are referring to freedom of use,
+not price. Our General Public Licenses are designed to make sure that
+you have the freedom to distribute copies of free software (and charge
+for this service if you wish); that you receive source code or can get
+it if you want it; that you can change the software and use pieces of
+it in new free programs; and that you are informed that you can do
+these things.
+
+ To protect your rights, we need to make restrictions that forbid
+distributors to deny you these rights or to ask you to surrender these
+rights. These restrictions translate to certain responsibilities for
+you if you distribute copies of the library or if you modify it.
+
+ For example, if you distribute copies of the library, whether gratis
+or for a fee, you must give the recipients all the rights that we gave
+you. You must make sure that they, too, receive or can get the source
+code. If you link other code with the library, you must provide
+complete object files to the recipients, so that they can relink them
+with the library after making changes to the library and recompiling
+it. And you must show them these terms so they know their rights.
+
+ We protect your rights with a two-step method: (1) we copyright the
+library, and (2) we offer you this license, which gives you legal
+permission to copy, distribute and/or modify the library.
+
+ To protect each distributor, we want to make it very clear that
+there is no warranty for the free library. Also, if the library is
+modified by someone else and passed on, the recipients should know
+that what they have is not the original version, so that the original
+author's reputation will not be affected by problems that might be
+introduced by others.
+\f
+ Finally, software patents pose a constant threat to the existence of
+any free program. We wish to make sure that a company cannot
+effectively restrict the users of a free program by obtaining a
+restrictive license from a patent holder. Therefore, we insist that
+any patent license obtained for a version of the library must be
+consistent with the full freedom of use specified in this license.
+
+ Most GNU software, including some libraries, is covered by the
+ordinary GNU General Public License. This license, the GNU Lesser
+General Public License, applies to certain designated libraries, and
+is quite different from the ordinary General Public License. We use
+this license for certain libraries in order to permit linking those
+libraries into non-free programs.
+
+ When a program is linked with a library, whether statically or using
+a shared library, the combination of the two is legally speaking a
+combined work, a derivative of the original library. The ordinary
+General Public License therefore permits such linking only if the
+entire combination fits its criteria of freedom. The Lesser General
+Public License permits more lax criteria for linking other code with
+the library.
+
+ We call this license the "Lesser" General Public License because it
+does Less to protect the user's freedom than the ordinary General
+Public License. It also provides other free software developers Less
+of an advantage over competing non-free programs. These disadvantages
+are the reason we use the ordinary General Public License for many
+libraries. However, the Lesser license provides advantages in certain
+special circumstances.
+
+ For example, on rare occasions, there may be a special need to
+encourage the widest possible use of a certain library, so that it becomes
+a de-facto standard. To achieve this, non-free programs must be
+allowed to use the library. A more frequent case is that a free
+library does the same job as widely used non-free libraries. In this
+case, there is little to gain by limiting the free library to free
+software only, so we use the Lesser General Public License.
+
+ In other cases, permission to use a particular library in non-free
+programs enables a greater number of people to use a large body of
+free software. For example, permission to use the GNU C Library in
+non-free programs enables many more people to use the whole GNU
+operating system, as well as its variant, the GNU/Linux operating
+system.
+
+ Although the Lesser General Public License is Less protective of the
+users' freedom, it does ensure that the user of a program that is
+linked with the Library has the freedom and the wherewithal to run
+that program using a modified version of the Library.
+
+ The precise terms and conditions for copying, distribution and
+modification follow. Pay close attention to the difference between a
+"work based on the library" and a "work that uses the library". The
+former contains code derived from the library, whereas the latter must
+be combined with the library in order to run.
+\f
+ GNU LESSER GENERAL PUBLIC LICENSE
+ TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+
+ 0. This License Agreement applies to any software library or other
+program which contains a notice placed by the copyright holder or
+other authorized party saying it may be distributed under the terms of
+this Lesser General Public License (also called "this License").
+Each licensee is addressed as "you".
+
+ A "library" means a collection of software functions and/or data
+prepared so as to be conveniently linked with application programs
+(which use some of those functions and data) to form executables.
+
+ The "Library", below, refers to any such software library or work
+which has been distributed under these terms. A "work based on the
+Library" means either the Library or any derivative work under
+copyright law: that is to say, a work containing the Library or a
+portion of it, either verbatim or with modifications and/or translated
+straightforwardly into another language. (Hereinafter, translation is
+included without limitation in the term "modification".)
+
+ "Source code" for a work means the preferred form of the work for
+making modifications to it. For a library, complete source code means
+all the source code for all modules it contains, plus any associated
+interface definition files, plus the scripts used to control compilation
+and installation of the library.
+
+ Activities other than copying, distribution and modification are not
+covered by this License; they are outside its scope. The act of
+running a program using the Library is not restricted, and output from
+such a program is covered only if its contents constitute a work based
+on the Library (independent of the use of the Library in a tool for
+writing it). Whether that is true depends on what the Library does
+and what the program that uses the Library does.
+
+ 1. You may copy and distribute verbatim copies of the Library's
+complete source code as you receive it, in any medium, provided that
+you conspicuously and appropriately publish on each copy an
+appropriate copyright notice and disclaimer of warranty; keep intact
+all the notices that refer to this License and to the absence of any
+warranty; and distribute a copy of this License along with the
+Library.
+
+ You may charge a fee for the physical act of transferring a copy,
+and you may at your option offer warranty protection in exchange for a
+fee.
+\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 combine or
+link a "work that uses the Library" with the Library to produce a
+work containing portions of the Library, and distribute that work
+under terms of your choice, provided that the terms permit
+modification of the work for the customer's own use and reverse
+engineering for debugging such modifications.
+
+ You must give prominent notice with each copy of the work that the
+Library is used in it and that the Library and its use are covered by
+this License. You must supply a copy of this License. If the work
+during execution displays copyright notices, you must include the
+copyright notice for the Library among them, as well as a reference
+directing the user to the copy of this License. Also, you must do one
+of these things:
+
+ a) Accompany the work with the complete corresponding
+ machine-readable source code for the Library including whatever
+ changes were used in the work (which must be distributed under
+ Sections 1 and 2 above); and, if the work is an executable linked
+ with the Library, with the complete machine-readable "work that
+ uses the Library", as object code and/or source code, so that the
+ user can modify the Library and then relink to produce a modified
+ executable containing the modified Library. (It is understood
+ that the user who changes the contents of definitions files in the
+ Library will not necessarily be able to recompile the application
+ to use the modified definitions.)
+
+ b) Use a suitable shared library mechanism for linking with the
+ Library. A suitable mechanism is one that (1) uses at run time a
+ copy of the library already present on the user's computer system,
+ rather than copying library functions into the executable, and (2)
+ will operate properly with a modified version of the library, if
+ the user installs one, as long as the modified version is
+ interface-compatible with the version that the work was made with.
+
+ c) Accompany the work with a written offer, valid for at
+ least three years, to give the same user the materials
+ specified in Subsection 6a, above, for a charge no more
+ than the cost of performing this distribution.
+
+ d) If distribution of the work is made by offering access to copy
+ from a designated place, offer equivalent access to copy the above
+ specified materials from the same place.
+
+ e) Verify that the user has already received a copy of these
+ materials or that you have already sent this user a copy.
+
+ For an executable, the required form of the "work that uses the
+Library" must include any data and utility programs needed for
+reproducing the executable from it. However, as a special exception,
+the materials to be distributed need not include anything that is
+normally distributed (in either source or binary form) with the major
+components (compiler, kernel, and so on) of the operating system on
+which the executable runs, unless that component itself accompanies
+the executable.
+
+ It may happen that this requirement contradicts the license
+restrictions of other proprietary libraries that do not normally
+accompany the operating system. Such a contradiction means you cannot
+use both them and the Library together in an executable that you
+distribute.
+\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 with
+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 Lesser General Public License from time to time.
+Such new versions will be similar in spirit to the present version,
+but may differ in detail to address new problems or concerns.
+
+Each version is given a distinguishing version number. If the Library
+specifies a version number of this License which applies to it and
+"any later version", you have the option of following the terms and
+conditions either of that version or of any later version published by
+the Free Software Foundation. If the Library does not specify a
+license version number, you may choose any version ever published by
+the Free Software Foundation.
+\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
+ How to Apply These Terms to Your New Libraries
+
+ If you develop a new library, and you want it to be of the greatest
+possible use to the public, we recommend making it free software that
+everyone can redistribute and change. You can do so by permitting
+redistribution under these terms (or, alternatively, under the terms of the
+ordinary General Public License).
+
+ To apply these terms, attach the following notices to the library. It is
+safest to attach them to the start of each source file to most effectively
+convey the exclusion of warranty; and each file should have at least the
+"copyright" line and a pointer to where the full notice is found.
+
+ <one line to give the library's name and a brief idea of what it does.>
+ Copyright (C) <year> <name of author>
+
+ This library is free software; you can redistribute it and/or
+ modify it under the terms of the GNU Lesser General Public
+ License as published by the Free Software Foundation; either
+ version 2.1 of the License, or (at your option) any later version.
+
+ This library is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ Lesser General Public License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with this library; if not, write to the Free Software
+ Foundation, Inc., 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
+Copyright (c) Samsung Electronics Co., Ltd. All rights reserved.
+Except as noted, this software is licensed under Apache License, Version 2.
+Please, see the LICENSE file for Apache License terms and conditions.
+
+Some parts of libmedia-service are licensed under the GNU Lesser General Public License version 2.1
+See the LICENSE file for LGPL License terms and conditions.
+Specifically, the LGPL parts of libmedia-service are
+ - md5/media-svc-hash.c
+
+Some parts of libmedia-service are licensed under BSD-style
+See the LICENSE file for BSD-style License terms and conditions.
+Specifically, the BSD-style parts of libmedia-service are
+ - uuid/
--- /dev/null
+/*
+ * libmedia-service
+ *
+ * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
+ *
+ * Contact: Hyunjun Ko <zzoon.ko@samsung.com>, Haejeong Kim <backto.kim@samsung.com>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+
+
+#ifndef _MEDIA_SVC_ERROR_H_
+#define _MEDIA_SVC_ERROR_H_
+
+/**
+ @addtogroup MEDIA_SVC
+ @{
+ * @file media-svc-error.h
+ * @brief This file defines error codes for media service.
+
+ */
+
+/**
+ @defgroup MEDIA_SVC_COMMON Global data structure and error code
+ @{
+
+ @par
+ type definition and error code
+ */
+
+
+#define MEDIA_INFO_ERROR_NONE 0 /**< No Error */
+
+#define MEDIA_INFO_ERROR_INVALID_PARAMETER -1 /**< Invalid parameter */
+#define MEDIA_INFO_ERROR_INVALID_MEDIA -2 /**< Invalid media */
+#define MEDIA_INFO_ERROR_INVALID_FILE_FORMAT -3 /**< Invalid file format */
+#define MEDIA_INFO_ERROR_INVALID_PATH -4 /**< Invalid file path */
+#define MEDIA_INFO_ERROR_OUT_OF_MEMORY -5 /**< Out of memory */
+#define MEDIA_INFO_ERROR_OUT_OF_STORAGE -6 /**< Out of storage */
+#define MEDIA_INFO_ERROR_INSERT_FAIL -7 /**< Insert failed */
+#define MEDIA_INFO_ERROR_DRM_INSERT_FAIL -8 /**< DRM file insert failed */
+
+#define MEDIA_INFO_ERROR_ITEM_NOT_FOUND -11 /**< Item not found */
+#define MEDIA_INFO_ERROR_FILE_NOT_FOUND -12 /**< File not found */
+#define MEDIA_INFO_ERROR_APPEND_ITEM_FAILED -13 /**< Append item failed */
+#define MEDIA_INFO_ERROR_REMOVE_ITEM_FAILED -14 /**< Remove item failed */
+#define MEDIA_INFO_ERROR_GET_ITEM_FAILED -15 /**< Get item failed */
+#define MEDIA_INFO_ERROR_REMOVE_FILE_FAILED -16 /**< Remove file failed */
+#define MEDIA_INFO_ERROR_EXTRACT_FAILED -17 /**< Extract Failed */
+#define MEDIA_INFO_ERROR_MAKE_PLAYLIST_NAME_FAILED -18 /**< fail to make new playlist name */
+
+#define MEDIA_INFO_ERROR_DATABASE_CONNECT -100 /**< DB connect error */
+#define MEDIA_INFO_ERROR_DATABASE_DISCONNECT -101 /**< DB disconnect error */
+#define MEDIA_INFO_ERROR_DATABASE_QUERY -104 /**< DB query error */
+#define MEDIA_INFO_ERROR_DATABASE_TABLE_OPEN -105 /**< DB table open error */
+#define MEDIA_INFO_ERROR_DATABASE_INVALID -106 /**< DB invalid error */
+#define MEDIA_INFO_ERROR_DATABASE_INTERNAL -107 /**< DB internal error */
+#define MEDIA_INFO_ERROR_DATABASE_NO_RECORD -108 /**< Item not found in DB */
+
+#define MEDIA_INFO_ERROR_SOCKET_CONN -201 /**< Socket connect error */
+#define MEDIA_INFO_ERROR_SOCKET_MSG -202 /**< Socket message error */
+#define MEDIA_INFO_ERROR_SOCKET_SEND -203 /**< Socket send error */
+#define MEDIA_INFO_ERROR_SOCKET_RECEIVE -204 /**< Socket receive error */
+#define MEDIA_INFO_ERROR_SOCKET_RECEIVE_TIMEOUT -205 /**< Socket time out */
+
+#define MEDIA_INFO_ERROR_INTERNAL -998 /**< Internal error */
+#define MEDIA_INFO_ERROR_UNKNOWN -999 /**< Unknown error */
+#define MEDIA_INFO_ERROR_NOT_IMPLEMENTED -200 /**< Not implemented */
+/**
+ @}
+*/
+
+/**
+ @}
+*/
+
+#endif /*_MEDIA_SVC_ERROR_H_*/
--- /dev/null
+/*
+ * libmedia-service
+ *
+ * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
+ *
+ * Contact: Hyunjun Ko <zzoon.ko@samsung.com>, Haejeong Kim <backto.kim@samsung.com>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+
+
+#ifndef _MEDIA_SVC_TYPES_H_
+#define _MEDIA_SVC_TYPES_H_
+
+#ifndef DEPRECATED_API
+# define DEPRECATED_API __attribute__ ((deprecated))
+#endif
+
+typedef void MediaSvcHandle; /**< Handle */
+
+/**
+ * Type definition for storage type
+ */
+typedef enum{
+ MEDIA_SVC_STORAGE_INTERNAL, /**< Internal storage*/
+ MEDIA_SVC_STORAGE_EXTERNAL, /**< External storage*/
+ MEDIA_SVC_STORAGE_MAX, /**< Invalid storage*/
+}media_svc_storage_type_e;
+
+/**
+ * Type definition for content type
+ */
+typedef enum{
+ MEDIA_SVC_MEDIA_TYPE_IMAGE = 0, /**< Image Content*/
+ MEDIA_SVC_MEDIA_TYPE_VIDEO = 1, /**< Video Content*/
+ MEDIA_SVC_MEDIA_TYPE_SOUND = 2, /**< Sound Content like Ringtone*/
+ MEDIA_SVC_MEDIA_TYPE_MUSIC = 3, /**< Music Content like mp3*/
+ MEDIA_SVC_MEDIA_TYPE_OTHER = 4, /**< Invalid Content*/
+}media_svc_media_type_e;
+
+#endif /*_MEDIA_SVC_TYPES_H_*/
--- /dev/null
+/*
+ * libmedia-service
+ *
+ * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
+ *
+ * Contact: Hyunjun Ko <zzoon.ko@samsung.com>, Haejeong Kim <backto.kim@samsung.com>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+
+
+#ifndef _MEDIA_SVC_H_
+#define _MEDIA_SVC_H_
+
+#include "media-svc-types.h"
+#include "media-svc-error.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+/**
+ @defgroup MEDIA_SVC Media Information Service
+ @{
+ * @file media-svc.h
+ * @brief This file defines API's for media service.
+ * @version 1.0
+ */
+
+/**
+ @defgroup MEDIA_SVC_API Media Database API
+ @{
+
+ @par
+ manage the service database.
+ */
+
+
+/**
+ * media_svc_connect:
+ * Connect to the media database. This is the function that an user who wants to get a handle to access the media database.
+ *
+ * @param handle [out] Handle to access database.
+ * @return This function returns zero(MEDIA_INFO_ERROR_NONE) on success, or negative value with error code.
+ * Please refer 'media-info-error.h' to know the exact meaning of the error.
+ * @see media_svc_disconnect
+ * @pre None
+ * @post call media_svc_disconnect to disconnect media database.
+ * @remark The database name is "/opt/usr/dbspace/.media.db".
+ * @par example
+ * @code
+
+#include <media-info.h>
+
+void connect_media_db()
+{
+ int ret = MEDIA_INFO_ERROR_NONE;
+ MediaSvcHandle* my_handle = NULL;
+
+ // connect to the media database
+ ret = media_svc_connect(&my_handle);
+
+ if (ret < 0)
+ {
+ printf("Fatal error to connect DB\n");
+ return;
+ }
+
+ return;
+}
+
+ * @endcode
+ */
+int media_svc_connect(MediaSvcHandle **handle);
+
+
+/**
+ * media_svc_disconnect:
+ * Disconnect to the media database. This is the function that an user who wants to disconnect the media database.
+ *
+ * @param handle [in] Handle to access database.
+ * @return This function returns zero(MEDIA_INFO_ERROR_NONE) on success, or negative value with error code.
+ * Please refer 'media-info-error.h' to know the exact meaning of the error.
+ * @see media_svc_connect
+ * @pre call media_svc_connect to connect media database.
+ * @post None
+ * @remark The database name is "/opt/usr/dbspace/.media.db".
+ * @par example
+ * @code
+
+#include <media-info.h>
+
+void disconnect_media_db()
+{
+ int ret = MEDIA_INFO_ERROR_NONE;
+ MediaSvcHandle* my_handle = NULL;
+
+ // connect to the media database
+ ret = media_svc_connect(&my_handle);
+
+ if (ret < 0)
+ {
+ printf("Fatal error to connect DB\n");
+ return;
+ }
+
+ //
+ // Do something using my_handle
+ //
+
+
+ ret = media_svc_disconnect(my_handle);
+ if (ret < 0)
+ {
+ printf("Fatal error to disconnect DB\n");
+ }
+
+ return;
+}
+
+ * @endcode
+ */
+int media_svc_disconnect(MediaSvcHandle *handle);
+
+
+/**
+ * media_svc_create_table:
+ * Create table of media database and set Index and Triggers.
+ *
+ * @param handle [in] Handle to access database.
+ * @return This function returns zero(MEDIA_INFO_ERROR_NONE) on success, or negative value with error code.
+ * Please refer 'media-info-error.h' to know the exact meaning of the error.
+ * @see None
+ * @pre call media_svc_connect to connect media database.
+ * @post call media_svc_disconnect to disconnect media database.
+ * @remark The database name is "/opt/usr/dbspace/.media.db".
+ * @par example
+ * @code
+
+#include <media-info.h>
+
+void create_media_db_table()
+{
+ int ret = MEDIA_INFO_ERROR_NONE;
+ MediaSvcHandle* my_handle = NULL;
+
+ // connect to the media database
+ ret = media_svc_connect(&my_handle);
+
+ if (ret < 0)
+ {
+ printf("Fatal error to connect DB\n");
+ return;
+ }
+
+ ret = media_svc_create_table(my_handle);
+ if (ret < 0)
+ {
+ printf("Fatal error to create DB table\n");
+ }
+
+ ret = media_svc_disconnect(my_handle);
+ if (ret < 0)
+ {
+ printf("Fatal error to disconnect DB\n");
+ }
+
+ return;
+}
+
+ * @endcode
+ */
+
+int media_svc_create_table(MediaSvcHandle *handle);
+
+int media_svc_check_item_exist_by_path(MediaSvcHandle *handle, const char *path);
+
+int media_svc_insert_folder(MediaSvcHandle *handle, media_svc_storage_type_e storage_type, const char *path);
+
+int media_svc_insert_item_begin(MediaSvcHandle *handle, int data_cnt);
+
+int media_svc_insert_item_end(MediaSvcHandle *handle);
+
+int media_svc_insert_item_bulk(MediaSvcHandle *handle, media_svc_storage_type_e storage_type, const char *path, const char *mime_type, media_svc_media_type_e media_type);
+
+int media_svc_insert_item_immediately(MediaSvcHandle *handle, media_svc_storage_type_e storage_type, const char *path, const char *mime_type, media_svc_media_type_e media_type);
+
+int media_svc_move_item_begin(MediaSvcHandle *handle, int data_cnt);
+
+int media_svc_move_item_end(MediaSvcHandle *handle);
+
+int media_svc_move_item(MediaSvcHandle *handle, media_svc_storage_type_e src_storage, const char *src_path, media_svc_storage_type_e dest_storage, const char *dest_path);
+
+int media_svc_set_item_validity_begin(MediaSvcHandle *handle, int data_cnt);
+
+int media_svc_set_item_validity_end(MediaSvcHandle *handle);
+
+int media_svc_set_item_validity(MediaSvcHandle *handle, const char *path, int validity);
+
+int media_svc_delete_item_by_path(MediaSvcHandle *handle, const char *path);
+
+int media_svc_delete_all_items_in_storage(MediaSvcHandle *handle, media_svc_storage_type_e storage_type);
+
+int media_svc_delete_invalid_items_in_storage(MediaSvcHandle *handle, media_svc_storage_type_e storage_type);
+
+int media_svc_delete_invalid_items_in_folder(MediaSvcHandle *handle, const char *folder_path);
+
+int media_svc_set_all_storage_items_validity(MediaSvcHandle *handle, media_svc_storage_type_e storage_type, int validity);
+
+int media_svc_set_folder_items_validity(MediaSvcHandle *handle, const char *folder_path, int validity, int recursive);
+
+int media_svc_refresh_item(MediaSvcHandle *handle, media_svc_storage_type_e storage_type, const char *path, media_svc_media_type_e media_type);
+
+int media_svc_rename_folder(MediaSvcHandle *handle, const char *src_path, const char *dst_path);
+
+int media_svc_request_update_db(const char *db_query);
+
+int media_svc_get_storage_type(const char *path, media_svc_storage_type_e *storage_type);
+
+int media_svc_get_mime_type(const char *path, char *mimetype);
+
+int media_svc_get_media_type(const char *path, const char *mime_type, media_svc_media_type_e *media_type);
+
+/** @} */
+
+/**
+ @}
+ */
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /*_MEDIA_SVC_H_*/
--- /dev/null
+<manifest>
+ <request>
+ <domain name="_" />
+ </request>
+</manifest>
+
--- /dev/null
+# Package Information for pkg-config
+
+prefix=@PREFIX@
+exec_prefix=@EXEC_PREFIX@
+libdir=@LIBDIR@
+includedir=@INCLUDEDIR@
+
+Name: @PROJECT_NAME@
+Description: Samsung Linux platform @PROJECT_NAME@ library
+Version: @VERSION@
+Requires: glib-2.0 dlog sqlite3 db-util mm-common
+Libs: -L${libdir} -lmedia-service -lmedia-svc-hash
+Cflags: -I${includedir}/media-service
--- /dev/null
+/*
+ * This code implements the MD5 message-digest algorithm.
+ * The algorithm is due to Ron Rivest. This code was
+ * written by Colin Plumb in 1993, no copyright is claimed.
+ * This code is in the public domain; do with it what you wish.
+ *
+ * Equivalent code is available from RSA Data Security, Inc.
+ * This code has been tested against that, and is equivalent,
+ * except that you don't need to include two pages of legalese
+ * with every copy.
+ *
+ * To compute the message digest of a chunk of bytes, declare an
+ * MD5Context structure, pass it to MD5Init, call MD5Update as
+ * needed on buffers full of bytes, and then call MD5Final, which
+ * will fill a supplied 16-byte array with the digest.
+ */
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include <string.h> /* for memcpy() */
+#include "md5.h"
+
+#if (__BYTE_ORDER == 1234)
+#define byteReverse(buf, len) /* Nothing */
+#else
+void byteReverse(unsigned char *buf, unsigned longs);
+
+/*
+ * Note: this code is harmless on little-endian machines.
+ */
+void byteReverse(unsigned char *buf, unsigned longs)
+{
+ uint32_t t;
+ do {
+ t = (uint32_t) ((unsigned)buf[3] << 8 | buf[2]) << 16 |
+ ((unsigned)buf[1] << 8 | buf[0]);
+ *(uint32_t *) buf = t;
+ buf += 4;
+ } while (--longs);
+}
+#endif
+
+/*
+ * Start MD5 accumulation. Set bit count to 0 and buffer to mysterious
+ * initialization constants.
+ */
+void MD5Init(MD5_CTX *ctx)
+{
+ ctx->buf[0] = 0x67452301;
+ ctx->buf[1] = 0xefcdab89;
+ ctx->buf[2] = 0x98badcfe;
+ ctx->buf[3] = 0x10325476;
+
+ ctx->bits[0] = 0;
+ ctx->bits[1] = 0;
+}
+
+/*
+ * Update context to reflect the concatenation of another buffer full
+ * of bytes.
+ */
+void MD5Update(MD5_CTX *ctx, unsigned char const *buf, unsigned len)
+{
+ uint32_t t;
+
+ /* Update bitcount */
+
+ t = ctx->bits[0];
+ if ((ctx->bits[0] = t + ((uint32_t) len << 3)) < t) {
+ ctx->bits[1]++; /* Carry from low to high */
+ }
+
+ ctx->bits[1] += len >> 29;
+
+ t = (t >> 3) & 0x3f; /* Bytes already in shsInfo->data */
+
+ /* Handle any leading odd-sized chunks */
+
+ if (t) {
+ unsigned char *p = (unsigned char *)ctx->in + t;
+
+ t = 64 - t;
+ if (len < t) {
+ memcpy(p, buf, len);
+ return;
+ }
+ memcpy(p, buf, t);
+ byteReverse(ctx->in, 16);
+ MD5Transform(ctx->buf, (uint32_t *) ctx->in);
+ buf += t;
+ len -= t;
+ }
+ /* Process data in 64-byte chunks */
+
+ while (len >= 64) {
+ memcpy(ctx->in, buf, 64);
+ byteReverse(ctx->in, 16);
+ MD5Transform(ctx->buf, (uint32_t *) ctx->in);
+ buf += 64;
+ len -= 64;
+ }
+
+ /* Handle any remaining bytes of data. */
+
+ memcpy(ctx->in, buf, len);
+}
+
+/*
+ * Final wrapup - pad to 64-byte boundary with the bit pattern
+ * 1 0* (64-bit count of bits processed, MSB-first)
+ */
+void MD5Final(unsigned char digest[16], MD5_CTX *ctx)
+{
+ unsigned count;
+ unsigned char *p;
+
+ /* Compute number of bytes mod 64 */
+ count = (ctx->bits[0] >> 3) & 0x3F;
+
+ /* Set the first char of padding to 0x80. This is safe since there is
+ always at least one byte free */
+ p = ctx->in + count;
+ *p++ = 0x80;
+
+ /* Bytes of padding needed to make 64 bytes */
+ count = 64 - 1 - count;
+
+ /* Pad out to 56 mod 64 */
+ if (count < 8) {
+ /* Two lots of padding: Pad the first block to 64 bytes */
+ memset(p, 0, count);
+ byteReverse(ctx->in, 16);
+ MD5Transform(ctx->buf, (uint32_t *) ctx->in);
+
+ /* Now fill the next block with 56 bytes */
+ memset(ctx->in, 0, 56);
+ } else {
+ /* Pad block to 56 bytes */
+ memset(p, 0, count - 8);
+ }
+ byteReverse(ctx->in, 14);
+
+ /* Append length in bits and transform */
+ ((uint32_t *) ctx->in)[14] = ctx->bits[0];
+ ((uint32_t *) ctx->in)[15] = ctx->bits[1];
+
+ MD5Transform(ctx->buf, (uint32_t *) ctx->in);
+ byteReverse((unsigned char *)ctx->buf, 4);
+ memcpy(digest, ctx->buf, 16);
+ memset((char *)ctx, 0, sizeof(ctx)); /* In case it's sensitive */
+}
+
+/* The four core functions - F1 is optimized somewhat */
+
+/* #define F1(x, y, z) (x & y | ~x & z) */
+#define F1(x, y, z) ((z) ^ ((x) & ((y) ^ (z))))
+#define F2(x, y, z) (F1((z), (x), (y)))
+#define F3(x, y, z) ((x) ^ (y) ^ (z))
+#define F4(x, y, z) ((y) ^ ((x) | ~(z)))
+
+/* This is the central step in the MD5 algorithm. */
+#define MD5STEP(f, w, x, y, z, data, s) \
+(w += f(x, y, z) + data, w = w<<s | w>>(32-s), w += x)
+
+/*
+ * The core of the MD5 algorithm, this alters an existing MD5 hash to
+ * reflect the addition of 16 longwords of new data. MD5Update blocks
+ * the data and converts bytes into longwords for this routine.
+ */
+void MD5Transform(uint32_t buf[4], uint32_t const in[16])
+{
+ register uint32_t a, b, c, d;
+
+ a = buf[0];
+ b = buf[1];
+ c = buf[2];
+ d = buf[3];
+
+ MD5STEP(F1, a, b, c, d, in[0] + 0xd76aa478, 7);
+ MD5STEP(F1, d, a, b, c, in[1] + 0xe8c7b756, 12);
+ MD5STEP(F1, c, d, a, b, in[2] + 0x242070db, 17);
+ MD5STEP(F1, b, c, d, a, in[3] + 0xc1bdceee, 22);
+ MD5STEP(F1, a, b, c, d, in[4] + 0xf57c0faf, 7);
+ MD5STEP(F1, d, a, b, c, in[5] + 0x4787c62a, 12);
+ MD5STEP(F1, c, d, a, b, in[6] + 0xa8304613, 17);
+ MD5STEP(F1, b, c, d, a, in[7] + 0xfd469501, 22);
+ MD5STEP(F1, a, b, c, d, in[8] + 0x698098d8, 7);
+ MD5STEP(F1, d, a, b, c, in[9] + 0x8b44f7af, 12);
+ MD5STEP(F1, c, d, a, b, in[10] + 0xffff5bb1, 17);
+ MD5STEP(F1, b, c, d, a, in[11] + 0x895cd7be, 22);
+ MD5STEP(F1, a, b, c, d, in[12] + 0x6b901122, 7);
+ MD5STEP(F1, d, a, b, c, in[13] + 0xfd987193, 12);
+ MD5STEP(F1, c, d, a, b, in[14] + 0xa679438e, 17);
+ MD5STEP(F1, b, c, d, a, in[15] + 0x49b40821, 22);
+
+ MD5STEP(F2, a, b, c, d, in[1] + 0xf61e2562, 5);
+ MD5STEP(F2, d, a, b, c, in[6] + 0xc040b340, 9);
+ MD5STEP(F2, c, d, a, b, in[11] + 0x265e5a51, 14);
+ MD5STEP(F2, b, c, d, a, in[0] + 0xe9b6c7aa, 20);
+ MD5STEP(F2, a, b, c, d, in[5] + 0xd62f105d, 5);
+ MD5STEP(F2, d, a, b, c, in[10] + 0x02441453, 9);
+ MD5STEP(F2, c, d, a, b, in[15] + 0xd8a1e681, 14);
+ MD5STEP(F2, b, c, d, a, in[4] + 0xe7d3fbc8, 20);
+ MD5STEP(F2, a, b, c, d, in[9] + 0x21e1cde6, 5);
+ MD5STEP(F2, d, a, b, c, in[14] + 0xc33707d6, 9);
+ MD5STEP(F2, c, d, a, b, in[3] + 0xf4d50d87, 14);
+ MD5STEP(F2, b, c, d, a, in[8] + 0x455a14ed, 20);
+ MD5STEP(F2, a, b, c, d, in[13] + 0xa9e3e905, 5);
+ MD5STEP(F2, d, a, b, c, in[2] + 0xfcefa3f8, 9);
+ MD5STEP(F2, c, d, a, b, in[7] + 0x676f02d9, 14);
+ MD5STEP(F2, b, c, d, a, in[12] + 0x8d2a4c8a, 20);
+
+ MD5STEP(F3, a, b, c, d, in[5] + 0xfffa3942, 4);
+ MD5STEP(F3, d, a, b, c, in[8] + 0x8771f681, 11);
+ MD5STEP(F3, c, d, a, b, in[11] + 0x6d9d6122, 16);
+ MD5STEP(F3, b, c, d, a, in[14] + 0xfde5380c, 23);
+ MD5STEP(F3, a, b, c, d, in[1] + 0xa4beea44, 4);
+ MD5STEP(F3, d, a, b, c, in[4] + 0x4bdecfa9, 11);
+ MD5STEP(F3, c, d, a, b, in[7] + 0xf6bb4b60, 16);
+ MD5STEP(F3, b, c, d, a, in[10] + 0xbebfbc70, 23);
+ MD5STEP(F3, a, b, c, d, in[13] + 0x289b7ec6, 4);
+ MD5STEP(F3, d, a, b, c, in[0] + 0xeaa127fa, 11);
+ MD5STEP(F3, c, d, a, b, in[3] + 0xd4ef3085, 16);
+ MD5STEP(F3, b, c, d, a, in[6] + 0x04881d05, 23);
+ MD5STEP(F3, a, b, c, d, in[9] + 0xd9d4d039, 4);
+ MD5STEP(F3, d, a, b, c, in[12] + 0xe6db99e5, 11);
+ MD5STEP(F3, c, d, a, b, in[15] + 0x1fa27cf8, 16);
+ MD5STEP(F3, b, c, d, a, in[2] + 0xc4ac5665, 23);
+
+ MD5STEP(F4, a, b, c, d, in[0] + 0xf4292244, 6);
+ MD5STEP(F4, d, a, b, c, in[7] + 0x432aff97, 10);
+ MD5STEP(F4, c, d, a, b, in[14] + 0xab9423a7, 15);
+ MD5STEP(F4, b, c, d, a, in[5] + 0xfc93a039, 21);
+ MD5STEP(F4, a, b, c, d, in[12] + 0x655b59c3, 6);
+ MD5STEP(F4, d, a, b, c, in[3] + 0x8f0ccc92, 10);
+ MD5STEP(F4, c, d, a, b, in[10] + 0xffeff47d, 15);
+ MD5STEP(F4, b, c, d, a, in[1] + 0x85845dd1, 21);
+ MD5STEP(F4, a, b, c, d, in[8] + 0x6fa87e4f, 6);
+ MD5STEP(F4, d, a, b, c, in[15] + 0xfe2ce6e0, 10);
+ MD5STEP(F4, c, d, a, b, in[6] + 0xa3014314, 15);
+ MD5STEP(F4, b, c, d, a, in[13] + 0x4e0811a1, 21);
+ MD5STEP(F4, a, b, c, d, in[4] + 0xf7537e82, 6);
+ MD5STEP(F4, d, a, b, c, in[11] + 0xbd3af235, 10);
+ MD5STEP(F4, c, d, a, b, in[2] + 0x2ad7d2bb, 15);
+ MD5STEP(F4, b, c, d, a, in[9] + 0xeb86d391, 21);
+
+ buf[0] += a;
+ buf[1] += b;
+ buf[2] += c;
+ buf[3] += d;
+}
--- /dev/null
+/*
+ * This code implements the MD5 message-digest algorithm.
+ * The algorithm is due to Ron Rivest. This code was
+ * written by Colin Plumb in 1993, no copyright is claimed.
+ * This code is in the public domain; do with it what you wish.
+ *
+ * Equivalent code is available from RSA Data Security, Inc.
+ * This code has been tested against that, and is equivalent,
+ * except that you don't need to include two pages of legalese
+ * with every copy.
+ *
+ * To compute the message digest of a chunk of bytes, declare an
+ * MD5Context structure, pass it to MD5Init, call MD5Update as
+ * needed on buffers full of bytes, and then call MD5Final, which
+ * will fill a supplied 16-byte array with the digest.
+ */
+
+
+#ifndef _MD5_H_
+#define _MD5_H_
+
+#include <stdint.h>
+#include <sys/types.h>
+
+#define MD5_HASHBYTES 16
+
+typedef struct MD5Context {
+ uint32_t buf[4];
+ uint32_t bits[2];
+ unsigned char in[64];
+} MD5_CTX;
+
+extern void MD5Init(MD5_CTX *context);
+extern void MD5Update(MD5_CTX *context,unsigned char const *buf,unsigned len);
+extern void MD5Final(unsigned char digest[MD5_HASHBYTES], MD5_CTX *context);
+
+extern void MD5Transform(uint32_t buf[4], uint32_t const in[16]);
+
+#endif
--- /dev/null
+/* GLIB - Library of useful routines for C programming
+ *
+ * gconvert.c: Convert between character sets using iconv
+ * Copyright Red Hat Inc., 2000
+ * Authors: Havoc Pennington <hp@redhat.com>, Owen Taylor <otaylor@redhat.com
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+/* The array below is taken from gconvert.c, which is licensed by GNU Lesser General Public License
+ * Code to escape string is also taken partially from gconvert.c
+ * File name is changed to media-svc-hash.c
+ */
+
+#include "md5.h"
+#include <string.h>
+#include <alloca.h>
+#include "media-svc-hash.h"
+#include "media-svc-error.h"
+
+
+static const char ACCEPTABLE_URI_CHARS[96] = {
+ /* ! " # $ % & ' ( ) * + , - . / */
+ 0x00, 0x3F, 0x20, 0x20, 0x28, 0x00, 0x2C, 0x3F, 0x3F, 0x3F, 0x3F, 0x2A,
+ 0x28, 0x3F, 0x3F, 0x1C,
+ /* 0 1 2 3 4 5 6 7 8 9 : ; < = > ? */
+ 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x38, 0x20,
+ 0x20, 0x2C, 0x20, 0x20,
+ /* @ A B C D E F G H I J K L M N O */
+ 0x38, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F,
+ 0x3F, 0x3F, 0x3F, 0x3F,
+ /* P Q R S T U V W X Y Z [ \ ] ^ _ */
+ 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x20,
+ 0x20, 0x20, 0x20, 0x3F,
+ /* ` a b c d e f g h i j k l m n o */
+ 0x20, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F,
+ 0x3F, 0x3F, 0x3F, 0x3F,
+ /* p q r s t u v w x y z { | } ~ DEL */
+ 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x20,
+ 0x20, 0x20, 0x3F, 0x20
+};
+
+char *_mb_svc_generate_hash_name(const char *file)
+{
+ int n;
+ MD5_CTX ctx;
+ static char md5out[(2 * MD5_HASHBYTES) + 1];
+ unsigned char hash[MD5_HASHBYTES];
+ static const char hex[] = "0123456789abcdef";
+
+ char *uri;
+ char *t;
+ const unsigned char *c;
+ int length;
+
+ if (!file) {
+ return NULL;
+ }
+
+ length = 3 * strlen(file) + 9;
+
+ memset(md5out, 0, sizeof(md5out));
+
+#define _check_uri_char(c) \
+((c) >= 32 && (c) < 128 && (ACCEPTABLE_URI_CHARS[(c) - 32] & 0x08))
+
+ uri = alloca(length);
+ if (uri == NULL) {
+ return NULL;
+ }
+
+ strncpy(uri, "file://", length);
+ uri[length - 1] = '\0';
+ t = uri + sizeof("file://") - 1;
+
+ for (c = (const unsigned char *)file; *c != '\0'; c++) {
+ if (!_check_uri_char(*c)) {
+ *t++ = '%';
+ *t++ = hex[*c >> 4];
+ *t++ = hex[*c & 15];
+ } else {
+ *t++ = *c;
+ }
+ }
+ *t = '\0';
+#undef _check_uri_char
+
+ MD5Init(&ctx);
+ MD5Update(&ctx, (unsigned char const *)uri, (unsigned)strlen(uri));
+ MD5Final(hash, &ctx);
+
+ for (n = 0; n < MD5_HASHBYTES; n++) {
+ md5out[2 * n] = hex[hash[n] >> 4];
+ md5out[2 * n + 1] = hex[hash[n] & 0x0f];
+ }
+ md5out[2 * n] = '\0';
+
+ return md5out;
+}
+
+int mb_svc_generate_hash_code(const char *origin_path, char *hash_code, int max_length)
+{
+ char *hash = NULL;
+
+ if (max_length < ((2 * MD5_HASHBYTES) + 1)) {
+ return MEDIA_INFO_ERROR_INVALID_PARAMETER;
+ }
+
+ hash = _mb_svc_generate_hash_name(origin_path);
+
+ if (hash == NULL) {
+ return MEDIA_INFO_ERROR_INTERNAL;
+ }
+
+ strncpy(hash_code, hash, max_length);
+ hash_code[strlen(hash_code)] ='\0';
+
+ return MEDIA_INFO_ERROR_NONE;
+}
+
--- /dev/null
+/*
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+#ifndef _MEDIA_SVC_HASH_
+#define _MEDIA_SVC_HASH_
+
+int mb_svc_generate_hash_code(const char *origin_path, char *hash_code, int max_length);
+
+#endif /*MEDIA_SVC_HASH_*/
+
--- /dev/null
+Name: libmedia-service
+Summary: Media information service library for multimedia applications.
+Version: 0.2.19
+Release: 1
+Group: System/Libraries
+License: Apache License, Version 2.0
+Source0: %{name}-%{version}.tar.gz
+
+Requires(post): /sbin/ldconfig
+Requires(postun): /sbin/ldconfig
+
+BuildRequires: cmake
+BuildRequires: pkgconfig(glib-2.0)
+BuildRequires: pkgconfig(dlog)
+BuildRequires: pkgconfig(aul)
+BuildRequires: pkgconfig(libexif)
+BuildRequires: pkgconfig(mm-common)
+BuildRequires: pkgconfig(sqlite3)
+BuildRequires: pkgconfig(db-util)
+BuildRequires: pkgconfig(mm-fileinfo)
+BuildRequires: pkgconfig(media-thumbnail)
+BuildRequires: pkgconfig(drm-client)
+BuildRequires: pkgconfig(libmedia-utils)
+
+%description
+Media information service library for multimedia applications.
+
+%package devel
+Summary: Media information service library for multimedia applications. (development)
+Group: Development/Libraries
+Requires: %{name} = %{version}-%{release}
+
+%description devel
+Media information service library for multimedia applications. (development files)
+
+
+%prep
+%setup -q
+
+
+%build
+cmake . -DCMAKE_INSTALL_PREFIX=%{_prefix}
+make %{?jobs:-j%jobs}
+
+%install
+rm -rf %{buildroot}
+%make_install
+
+#License
+mkdir -p %{buildroot}/%{_datadir}/license
+cp -rf %{_builddir}/%{name}-%{version}/LICENSE %{buildroot}/%{_datadir}/license/%{name}
+
+%post -p /sbin/ldconfig
+%postun -p /sbin/ldconfig
+
+%files
+%manifest libmedia-service.manifest
+%defattr(-,root,root,-)
+%{_libdir}/libmedia-service.so
+%{_libdir}/libmedia-service.so.1
+%{_libdir}/libmedia-service.so.1.0.0
+%{_libdir}/libmedia-svc-hash.so
+%{_libdir}/libmedia-svc-hash.so.1
+%{_libdir}/libmedia-svc-hash.so.1.0.0
+%{_libdir}/libmedia-content-plugin.so
+%{_libdir}/libmedia-content-plugin.so.1
+%{_libdir}/libmedia-content-plugin.so.1.0.0
+#License
+%{_datadir}/license/%{name}
+
+%files devel
+%{_libdir}/pkgconfig/libmedia-service.pc
+%{_includedir}/media-service/*.h
--- /dev/null
+/*
+ * libmedia-service
+ *
+ * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
+ *
+ * Contact: Hyunjun Ko <zzoon.ko@samsung.com>, Haejeong Kim <backto.kim@samsung.com>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+#include <string.h>
+#include <mm_file.h>
+#include <media-thumbnail.h>
+#include "media-svc.h"
+
+#define MEDIA_SVC_PLUGIN_ERROR_NONE 0
+#define MEDIA_SVC_PLUGIN_ERROR -1
+
+#define STRING_VALID(str) \
+ ((str != NULL && strlen(str) > 0) ? TRUE : FALSE)
+#define STORAGE_VALID(storage)\
+ (((storage == MEDIA_SVC_STORAGE_INTERNAL) || (storage == MEDIA_SVC_STORAGE_EXTERNAL)) ? TRUE : FALSE)
+
+
+typedef enum{
+ ERR_HANDLE = 1,
+ ERR_FILE_PATH,
+ ERR_FOLDER_PATH,
+ ERR_MIME_TYPE,
+ ERR_NOT_MEDIAFILE,
+ ERR_STORAGE_TYPE,
+ ERR_CHECK_ITEM,
+ ERR_MAX,
+}media_svc_error_type_e;
+
+#define MS_CATEGORY_UNKNOWN 0x00000000 /**< Default */
+#define MS_CATEGORY_ETC 0x00000001 /**< ETC category */
+#define MS_CATEGORY_IMAGE 0x00000002 /**< Image category */
+#define MS_CATEGORY_VIDEO 0x00000004 /**< Video category */
+#define MS_CATEGORY_MUSIC 0x00000008 /**< Music category */
+#define MS_CATEGORY_SOUND 0x00000010 /**< Sound category */
+
+#define CONTENT_TYPE_NUM 4
+#define MUSIC_MIME_NUM 29
+#define SOUND_MIME_NUM 1
+#define MIME_TYPE_LENGTH 255
+#define MIME_LENGTH 50
+#define _3GP_FILE ".3gp"
+#define _MP4_FILE ".mp4"
+
+
+typedef struct {
+ char content_type[15];
+ int category_by_mime;
+} fex_content_table_t;
+
+static const fex_content_table_t content_category[CONTENT_TYPE_NUM] = {
+ {"audio", MS_CATEGORY_SOUND},
+ {"image", MS_CATEGORY_IMAGE},
+ {"video", MS_CATEGORY_VIDEO},
+ {"application", MS_CATEGORY_ETC},
+};
+
+static const char music_mime_table[MUSIC_MIME_NUM][MIME_LENGTH] = {
+ /*known mime types of normal files*/
+ "mpeg",
+ "ogg",
+ "x-ms-wma",
+ "x-flac",
+ "mp4",
+ /* known mime types of drm files*/
+ "mp3",
+ "x-mp3", /*alias of audio/mpeg*/
+ "x-mpeg", /*alias of audio/mpeg*/
+ "3gpp",
+ "x-ogg", /*alias of audio/ogg*/
+ "vnd.ms-playready.media.pya:*.pya", /*playready*/
+ "wma",
+ "aac",
+ "x-m4a", /*alias of audio/mp4*/
+ /* below mimes are rare*/
+ "x-vorbis+ogg",
+ "x-flac+ogg",
+ "x-matroska",
+ "ac3",
+ "mp2",
+ "x-ape",
+ "x-ms-asx",
+ "vnd.rn-realaudio",
+
+ "x-vorbis", /*alias of audio/x-vorbis+ogg*/
+ "vorbis", /*alias of audio/x-vorbis+ogg*/
+ "x-oggflac",
+ "x-mp2", /*alias of audio/mp2*/
+ "x-pn-realaudio", /*alias of audio/vnd.rn-realaudio*/
+ "vnd.m-realaudio", /*alias of audio/vnd.rn-realaudio*/
+ "x-wav",
+};
+
+static const char sound_mime_table[SOUND_MIME_NUM][MIME_LENGTH] = {
+ "x-smaf",
+};
+
+static int __get_content_type_from_mime(const char * path, const char * mimetype, int * category);
+static int __get_content_type(const char * file_path, const char * mime_type);
+static void __set_error_message(int err_type, char ** err_msg);
+
+static int __get_content_type_from_mime(const char * path, const char * mimetype, int * category)
+{
+ int i = 0;
+ int err = 0;
+
+ *category = MS_CATEGORY_UNKNOWN;
+
+ //MS_DBG("mime type : %s", mimetype);
+
+ /*categorize from mimetype */
+ for (i = 0; i < CONTENT_TYPE_NUM; i++) {
+ if (strstr(mimetype, content_category[i].content_type) != NULL) {
+ *category = (*category | content_category[i].category_by_mime);
+ break;
+ }
+ }
+
+ /*in application type, exitst sound file ex) x-smafs */
+ if (*category & MS_CATEGORY_ETC) {
+ int prefix_len = strlen(content_category[0].content_type);
+
+ for (i = 0; i < SOUND_MIME_NUM; i++) {
+ if (strstr(mimetype + prefix_len, sound_mime_table[i]) != NULL) {
+ *category ^= MS_CATEGORY_ETC;
+ *category |= MS_CATEGORY_SOUND;
+ break;
+ }
+ }
+ }
+
+ /*check music file in soun files. */
+ if (*category & MS_CATEGORY_SOUND) {
+ int prefix_len = strlen(content_category[0].content_type) + 1;
+
+ //MS_DBG("mime_type : %s", mimetype + prefix_len);
+
+ for (i = 0; i < MUSIC_MIME_NUM; i++) {
+ if (strcmp(mimetype + prefix_len, music_mime_table[i]) == 0) {
+ *category ^= MS_CATEGORY_SOUND;
+ *category |= MS_CATEGORY_MUSIC;
+ break;
+ }
+ }
+
+ /*m3u file is playlist but mime type is "audio/x-mpegurl". but It has to be classified into MS_CATEGORY_ETC since playlist is not a sound track*/
+ if(strncasecmp(mimetype, "audio/x-mpegurl", strlen("audio/x-mpegurl")) == 0) {
+ *category ^= MS_CATEGORY_SOUND;
+ *category |= MS_CATEGORY_ETC;
+ }
+ } else if (*category & MS_CATEGORY_VIDEO) {
+ /*some video files don't have video stream. in this case it is categorize as music. */
+ /*"3gp" and "mp4" must check video stream and then categorize in directly. */
+ char file_ext[10] = {0};
+ memset(file_ext, 0, sizeof(file_ext));
+ if((_media_svc_get_file_ext(path, file_ext)) && strlen(file_ext) > 0) {
+ if ((strncasecmp(file_ext, _3GP_FILE, 4) == 0) || (strncasecmp(file_ext, _MP4_FILE, 5) == 0)) {
+ int audio = 0;
+ int video = 0;
+
+ err = mm_file_get_stream_info(path, &audio, &video);
+ if (err == 0) {
+ if (audio > 0 && video == 0) {
+ *category ^= MS_CATEGORY_VIDEO;
+ *category |= MS_CATEGORY_MUSIC;
+ }
+ }
+ }
+ }
+ }
+
+ //MS_DBG("category_from_ext : %d", *category);
+
+ return err;
+}
+
+static int __get_content_type(const char * file_path, const char * mime_type)
+{
+ int ret = MEDIA_SVC_PLUGIN_ERROR_NONE;
+ int category = 0;
+
+ ret = __get_content_type_from_mime(file_path, mime_type, &category);
+
+ if (category & MS_CATEGORY_SOUND) return MEDIA_SVC_MEDIA_TYPE_SOUND;
+ else if (category & MS_CATEGORY_MUSIC) return MEDIA_SVC_MEDIA_TYPE_MUSIC;
+ else if (category & MS_CATEGORY_IMAGE) return MEDIA_SVC_MEDIA_TYPE_IMAGE;
+ else if (category & MS_CATEGORY_VIDEO) return MEDIA_SVC_MEDIA_TYPE_VIDEO;
+ else return MEDIA_SVC_MEDIA_TYPE_OTHER;
+}
+
+static void __set_error_message(int err_type, char ** err_msg)
+{
+ if (err_msg)
+ *err_msg = NULL;
+ else
+ return;
+
+ if(err_type == ERR_HANDLE)
+ *err_msg = strdup("invalid handle");
+ else if(err_type == ERR_FILE_PATH)
+ *err_msg = strdup("invalid file path");
+ else if(err_type == ERR_FOLDER_PATH)
+ *err_msg = strdup("invalid folder path");
+ else if(err_type == ERR_MIME_TYPE)
+ *err_msg = strdup("invalid mime type");
+ else if(err_type == ERR_NOT_MEDIAFILE)
+ *err_msg = strdup("not media content");
+ else if(err_type == ERR_STORAGE_TYPE)
+ *err_msg = strdup("invalid storage type");
+ else if(err_type == ERR_CHECK_ITEM)
+ *err_msg = strdup("item does not exist");
+ else if(err_type == MEDIA_INFO_ERROR_DATABASE_CONNECT)
+ *err_msg = strdup("DB connect error");
+ else if(err_type == MEDIA_INFO_ERROR_DATABASE_DISCONNECT)
+ *err_msg = strdup("DB disconnect error");
+ else if(err_type == MEDIA_INFO_ERROR_INVALID_PARAMETER)
+ *err_msg = strdup("invalid parameter");
+ else if(err_type == MEDIA_INFO_ERROR_DATABASE_INTERNAL)
+ *err_msg = strdup("DB internal error");
+ else if(err_type == MEDIA_INFO_ERROR_DATABASE_NO_RECORD)
+ *err_msg = strdup("not found in DB");
+ else if(err_type == MEDIA_INFO_ERROR_INTERNAL)
+ *err_msg = strdup("media service internal error");
+ else
+ *err_msg = strdup("error unknown");
+
+ return;
+}
+
+int check_item(const char *file_path, const char * mime_type, char ** err_msg)
+{
+ if (!STRING_VALID(file_path)) {
+ __set_error_message(ERR_FILE_PATH, err_msg);
+ return MEDIA_SVC_PLUGIN_ERROR;
+ }
+
+ if (!STRING_VALID(mime_type)) {
+ __set_error_message(ERR_MIME_TYPE, err_msg);
+ return MEDIA_SVC_PLUGIN_ERROR;
+ }
+
+ return MEDIA_SVC_PLUGIN_ERROR_NONE;
+}
+
+int connect(void ** handle, char ** err_msg)
+{
+ int ret = media_svc_connect(handle);
+
+ if(ret < 0) {
+ __set_error_message(ret, err_msg);
+ return MEDIA_SVC_PLUGIN_ERROR;
+ }
+
+ return MEDIA_SVC_PLUGIN_ERROR_NONE;
+}
+
+int disconnect(void * handle, char ** err_msg)
+{
+ int ret = MEDIA_SVC_PLUGIN_ERROR_NONE;
+
+ if(handle == NULL) {
+ __set_error_message(ERR_HANDLE, err_msg);
+ return MEDIA_SVC_PLUGIN_ERROR;
+ }
+
+ ret = media_svc_disconnect(handle);
+ if(ret < 0) {
+ __set_error_message(ret, err_msg);
+ return MEDIA_SVC_PLUGIN_ERROR;
+ }
+
+ return MEDIA_SVC_PLUGIN_ERROR_NONE;
+}
+
+int check_item_exist(void* handle, const char *file_path, int storage_type, char ** err_msg)
+{
+ int ret = MEDIA_SVC_PLUGIN_ERROR_NONE;
+
+ if(handle == NULL) {
+ __set_error_message(ERR_HANDLE, err_msg);
+ return MEDIA_SVC_PLUGIN_ERROR;
+ }
+
+ if (!STRING_VALID(file_path)) {
+ __set_error_message(ERR_FILE_PATH, err_msg);
+ return MEDIA_SVC_PLUGIN_ERROR;
+ }
+
+ if(!STORAGE_VALID(storage_type)) {
+ __set_error_message(ERR_STORAGE_TYPE, err_msg);
+ return MEDIA_SVC_PLUGIN_ERROR;
+ }
+
+ ret = media_svc_check_item_exist_by_path(handle, file_path);
+ if(ret == MEDIA_INFO_ERROR_NONE)
+ return MEDIA_SVC_PLUGIN_ERROR_NONE; //exist
+
+ __set_error_message(ERR_CHECK_ITEM, err_msg);
+
+ return MEDIA_SVC_PLUGIN_ERROR; //not exist
+}
+
+int insert_item_begin(void * handle, int item_cnt, char ** err_msg)
+{
+ int ret = MEDIA_SVC_PLUGIN_ERROR_NONE;
+
+ if(handle == NULL) {
+ __set_error_message(ERR_HANDLE, err_msg);
+ return MEDIA_SVC_PLUGIN_ERROR;
+ }
+
+ ret = media_svc_insert_item_begin(handle, item_cnt);
+ if(ret < 0) {
+ __set_error_message(ret, err_msg);
+ return MEDIA_SVC_PLUGIN_ERROR;
+ }
+
+ return MEDIA_SVC_PLUGIN_ERROR_NONE;
+}
+
+int insert_item_end(void * handle, char ** err_msg)
+{
+ int ret = MEDIA_SVC_PLUGIN_ERROR_NONE;
+
+ if(handle == NULL) {
+ __set_error_message(ERR_HANDLE, err_msg);
+ return MEDIA_SVC_PLUGIN_ERROR;
+ }
+
+ ret = media_svc_insert_item_end(handle);
+ if(ret < 0) {
+ __set_error_message(ret, err_msg);
+ return MEDIA_SVC_PLUGIN_ERROR;
+ }
+
+ return MEDIA_SVC_PLUGIN_ERROR_NONE;
+}
+
+int insert_item(void * handle, const char *file_path, int storage_type, const char * mime_type, char ** err_msg)
+{
+ int ret = MEDIA_SVC_PLUGIN_ERROR_NONE;
+
+ if(handle == NULL) {
+ __set_error_message(ERR_HANDLE, err_msg);
+ return MEDIA_SVC_PLUGIN_ERROR;
+ }
+
+ if (!STRING_VALID(file_path)) {
+ __set_error_message(ERR_FILE_PATH, err_msg);
+ return MEDIA_SVC_PLUGIN_ERROR;
+ }
+
+ if (!STRING_VALID(mime_type)) {
+ __set_error_message(ERR_MIME_TYPE, err_msg);
+ return MEDIA_SVC_PLUGIN_ERROR;
+ }
+
+ if(!STORAGE_VALID(storage_type)) {
+ __set_error_message(ERR_STORAGE_TYPE, err_msg);
+ return MEDIA_SVC_PLUGIN_ERROR;
+ }
+
+ media_svc_media_type_e content_type = __get_content_type(file_path, mime_type);
+
+ ret = media_svc_insert_item_bulk(handle, storage_type, file_path, mime_type, content_type);
+ if(ret < 0) {
+ __set_error_message(ret, err_msg);
+ return MEDIA_SVC_PLUGIN_ERROR;
+ }
+
+ return MEDIA_SVC_PLUGIN_ERROR_NONE;
+}
+
+int insert_item_immediately(void * handle, const char *file_path, int storage_type, const char * mime_type, char ** err_msg)
+{
+ int ret = MEDIA_SVC_PLUGIN_ERROR_NONE;
+
+ if(handle == NULL) {
+ __set_error_message(ERR_HANDLE, err_msg);
+ return MEDIA_SVC_PLUGIN_ERROR;
+ }
+
+ if (!STRING_VALID(file_path)) {
+ __set_error_message(ERR_FILE_PATH, err_msg);
+ return MEDIA_SVC_PLUGIN_ERROR;
+ }
+
+ if (!STRING_VALID(mime_type)) {
+ __set_error_message(ERR_MIME_TYPE, err_msg);
+ return MEDIA_SVC_PLUGIN_ERROR;
+ }
+
+ if(!STORAGE_VALID(storage_type)) {
+ __set_error_message(ERR_STORAGE_TYPE, err_msg);
+ return MEDIA_SVC_PLUGIN_ERROR;
+ }
+
+ media_svc_media_type_e content_type = __get_content_type(file_path, mime_type);
+
+ ret = media_svc_insert_item_immediately(handle, storage_type, file_path, mime_type, content_type);
+
+ if(ret < 0) {
+ __set_error_message(ret, err_msg);
+ return MEDIA_SVC_PLUGIN_ERROR;
+ }
+
+ return MEDIA_SVC_PLUGIN_ERROR_NONE;
+}
+
+int move_item_begin(void * handle, int item_cnt, char ** err_msg)
+{
+ int ret = MEDIA_SVC_PLUGIN_ERROR_NONE;
+
+ if(handle == NULL) {
+ __set_error_message(ERR_HANDLE, err_msg);
+ return MEDIA_SVC_PLUGIN_ERROR;
+ }
+
+ ret = media_svc_move_item_begin(handle, item_cnt);
+ if(ret < 0) {
+ __set_error_message(ret, err_msg);
+ return MEDIA_SVC_PLUGIN_ERROR;
+ }
+
+ return MEDIA_SVC_PLUGIN_ERROR_NONE;
+}
+
+int move_item_end(void * handle, char ** err_msg)
+{
+ int ret = MEDIA_SVC_PLUGIN_ERROR_NONE;
+
+ if(handle == NULL) {
+ __set_error_message(ERR_HANDLE, err_msg);
+ return MEDIA_SVC_PLUGIN_ERROR;
+ }
+
+ ret = media_svc_move_item_end(handle);
+ if(ret < 0) {
+ __set_error_message(ret, err_msg);
+ return MEDIA_SVC_PLUGIN_ERROR;
+ }
+
+ return MEDIA_SVC_PLUGIN_ERROR_NONE;
+}
+
+int move_item(void * handle, const char *src_path, int src_storage_type, const char *dest_path, int dest_storage_type, const char * mime_type, char ** err_msg)
+{
+ int ret = MEDIA_SVC_PLUGIN_ERROR_NONE;
+
+ if(handle == NULL) {
+ __set_error_message(ERR_HANDLE, err_msg);
+ return MEDIA_SVC_PLUGIN_ERROR;
+ }
+
+ if ((!STRING_VALID(src_path)) || (!STRING_VALID(dest_path))) {
+ __set_error_message(ERR_FILE_PATH, err_msg);
+ return MEDIA_SVC_PLUGIN_ERROR;
+ }
+
+ if (!STRING_VALID(mime_type)) {
+ __set_error_message(ERR_MIME_TYPE, err_msg);
+ return MEDIA_SVC_PLUGIN_ERROR;
+ }
+
+ if((!STORAGE_VALID(src_storage_type)) || (!STORAGE_VALID(dest_storage_type))) {
+ __set_error_message(ERR_STORAGE_TYPE, err_msg);
+ return MEDIA_SVC_PLUGIN_ERROR;
+ }
+
+ ret = media_svc_move_item(handle, src_storage_type, src_path, dest_storage_type, dest_path);
+ if(ret < 0) {
+ __set_error_message(ret, err_msg);
+ return MEDIA_SVC_PLUGIN_ERROR;
+ }
+
+ return MEDIA_SVC_PLUGIN_ERROR_NONE;
+}
+
+int set_all_storage_items_validity(void * handle, int storage_type, int validity, char ** err_msg)
+{
+ int ret = MEDIA_SVC_PLUGIN_ERROR_NONE;
+
+ if(handle == NULL) {
+ __set_error_message(ERR_HANDLE, err_msg);
+ return MEDIA_SVC_PLUGIN_ERROR;
+ }
+
+ if(!STORAGE_VALID(storage_type)) {
+ __set_error_message(ERR_STORAGE_TYPE, err_msg);
+ return MEDIA_SVC_PLUGIN_ERROR;
+ }
+
+ ret = media_svc_set_all_storage_items_validity(handle, storage_type, validity);
+ if(ret < 0) {
+ __set_error_message(ret, err_msg);
+ return MEDIA_SVC_PLUGIN_ERROR;
+ }
+
+ return MEDIA_SVC_PLUGIN_ERROR_NONE;
+}
+
+int set_folder_item_validity(void * handle, const char * folder_path, int validity, int recursive, char ** err_msg)
+{
+ int ret = MEDIA_SVC_PLUGIN_ERROR_NONE;
+
+ if(handle == NULL) {
+ __set_error_message(ERR_HANDLE, err_msg);
+ return MEDIA_SVC_PLUGIN_ERROR;
+ }
+
+ if (!STRING_VALID(folder_path)) {
+ __set_error_message(ERR_FOLDER_PATH, err_msg);
+ return MEDIA_SVC_PLUGIN_ERROR;
+ }
+
+ ret = media_svc_set_folder_items_validity(handle, folder_path, validity, recursive);
+ if(ret < 0) {
+ __set_error_message(ret, err_msg);
+ return MEDIA_SVC_PLUGIN_ERROR;
+ }
+
+ return MEDIA_SVC_PLUGIN_ERROR_NONE;
+}
+
+int set_item_validity_begin(void * handle, int item_cnt, char ** err_msg)
+{
+ int ret = MEDIA_SVC_PLUGIN_ERROR_NONE;
+
+ if(handle == NULL) {
+ __set_error_message(ERR_HANDLE, err_msg);
+ return MEDIA_SVC_PLUGIN_ERROR;
+ }
+
+ ret = media_svc_set_item_validity_begin(handle, item_cnt);
+ if(ret < 0) {
+ __set_error_message(ret, err_msg);
+ return MEDIA_SVC_PLUGIN_ERROR;
+ }
+
+ return MEDIA_SVC_PLUGIN_ERROR_NONE;
+}
+
+int set_item_validity_end(void * handle, char ** err_msg)
+{
+ int ret = MEDIA_SVC_PLUGIN_ERROR_NONE;
+
+ if(handle == NULL) {
+ __set_error_message(ERR_HANDLE, err_msg);
+ return MEDIA_SVC_PLUGIN_ERROR;
+ }
+
+ ret = media_svc_set_item_validity_end(handle);
+ if(ret < 0) {
+ __set_error_message(ret, err_msg);
+ return MEDIA_SVC_PLUGIN_ERROR;
+ }
+
+ return MEDIA_SVC_PLUGIN_ERROR_NONE;
+}
+
+int set_item_validity(void * handle, const char *file_path, int storage_type, const char * mime_type, int validity, char ** err_msg)
+{
+ int ret = MEDIA_SVC_PLUGIN_ERROR_NONE;
+
+ if(handle == NULL) {
+ __set_error_message(ERR_HANDLE, err_msg);
+ return MEDIA_SVC_PLUGIN_ERROR;
+ }
+
+ if (!STRING_VALID(file_path)) {
+ __set_error_message(ERR_FILE_PATH, err_msg);
+ return MEDIA_SVC_PLUGIN_ERROR;
+ }
+
+ if (!STRING_VALID(mime_type)) {
+ __set_error_message(ERR_MIME_TYPE, err_msg);
+ return MEDIA_SVC_PLUGIN_ERROR;
+ }
+
+ if(!STORAGE_VALID(storage_type)) {
+ __set_error_message(ERR_STORAGE_TYPE, err_msg);
+ return MEDIA_SVC_PLUGIN_ERROR;
+ }
+
+ ret = media_svc_set_item_validity(handle, file_path, validity);
+
+ if(ret < 0) {
+ __set_error_message(ret, err_msg);
+ return MEDIA_SVC_PLUGIN_ERROR;
+ }
+
+ return MEDIA_SVC_PLUGIN_ERROR_NONE;
+}
+
+int delete_item(void * handle, const char *file_path, int storage_type, char ** err_msg)
+{
+ int ret = MEDIA_SVC_PLUGIN_ERROR_NONE;
+
+ if(handle == NULL) {
+ __set_error_message(ERR_HANDLE, err_msg);
+ return MEDIA_SVC_PLUGIN_ERROR;
+ }
+
+ if (!STRING_VALID(file_path)) {
+ __set_error_message(ERR_FILE_PATH, err_msg);
+ return MEDIA_SVC_PLUGIN_ERROR;
+ }
+
+ if(!STORAGE_VALID(storage_type)) {
+ __set_error_message(ERR_STORAGE_TYPE, err_msg);
+ return MEDIA_SVC_PLUGIN_ERROR;
+ }
+
+ ret = media_svc_check_item_exist_by_path(handle, file_path);
+ if(ret == 0) {
+ ret = media_svc_delete_item_by_path(handle, file_path);
+
+ if(ret < 0) {
+ __set_error_message(ret, err_msg);
+ return MEDIA_SVC_PLUGIN_ERROR;
+ }
+ else
+ return MEDIA_SVC_PLUGIN_ERROR_NONE;
+ }
+
+ __set_error_message(ERR_CHECK_ITEM, err_msg); //not exist in DB so can't delete item.
+ return MEDIA_SVC_PLUGIN_ERROR;
+}
+
+int delete_all_items_in_storage(void * handle, int storage_type, char ** err_msg)
+{
+ int ret = MEDIA_SVC_PLUGIN_ERROR_NONE;
+
+ if(handle == NULL) {
+ __set_error_message(ERR_HANDLE, err_msg);
+ return MEDIA_SVC_PLUGIN_ERROR;
+ }
+
+ if(!STORAGE_VALID(storage_type)) {
+ __set_error_message(ERR_STORAGE_TYPE, err_msg);
+ return MEDIA_SVC_PLUGIN_ERROR;
+ }
+
+ ret = media_svc_delete_all_items_in_storage(handle, storage_type);
+ if(ret < 0) {
+ __set_error_message(ret, err_msg);
+ return MEDIA_SVC_PLUGIN_ERROR;
+ }
+
+ return MEDIA_SVC_PLUGIN_ERROR_NONE;
+}
+
+int delete_all_invalid_items_in_storage(void * handle, int storage_type, char ** err_msg)
+{
+ int ret = MEDIA_SVC_PLUGIN_ERROR_NONE;
+
+ if(handle == NULL) {
+ __set_error_message(ERR_HANDLE, err_msg);
+ return MEDIA_SVC_PLUGIN_ERROR;
+ }
+
+ if(!STORAGE_VALID(storage_type)) {
+ __set_error_message(ERR_STORAGE_TYPE, err_msg);
+ return MEDIA_SVC_PLUGIN_ERROR;
+ }
+
+ ret = media_svc_delete_invalid_items_in_storage(handle, storage_type);
+ if(ret < 0) {
+ __set_error_message(ret, err_msg);
+ return MEDIA_SVC_PLUGIN_ERROR;
+ }
+
+ return MEDIA_SVC_PLUGIN_ERROR_NONE;
+}
+
+int delete_all_invalid_items_in_folder(void * handle, const char *folder_path, char ** err_msg)
+{
+ int ret = MEDIA_SVC_PLUGIN_ERROR_NONE;
+
+ if(handle == NULL) {
+ __set_error_message(ERR_HANDLE, err_msg);
+ return MEDIA_SVC_PLUGIN_ERROR;
+ }
+
+ if (!STRING_VALID(folder_path)) {
+ __set_error_message(ERR_FOLDER_PATH, err_msg);
+ return MEDIA_SVC_PLUGIN_ERROR;
+ }
+
+ ret = media_svc_delete_invalid_items_in_folder(handle, folder_path);
+ if(ret < 0) {
+ __set_error_message(ret, err_msg);
+ return MEDIA_SVC_PLUGIN_ERROR;
+ }
+
+ return MEDIA_SVC_PLUGIN_ERROR_NONE;
+}
+
+int delete_all_items(void * handle, char ** err_msg)
+{
+ int ret = MEDIA_SVC_PLUGIN_ERROR_NONE;
+
+ if(handle == NULL) {
+ __set_error_message(ERR_HANDLE, err_msg);
+ return MEDIA_SVC_PLUGIN_ERROR;
+ }
+
+ ret = delete_all_items_in_storage(handle, MEDIA_SVC_STORAGE_INTERNAL, err_msg);
+ if(ret < 0)
+ return MEDIA_SVC_PLUGIN_ERROR;
+
+ ret = delete_all_items_in_storage(handle, MEDIA_SVC_STORAGE_EXTERNAL, err_msg);
+ if(ret < 0)
+ return MEDIA_SVC_PLUGIN_ERROR;
+
+ return MEDIA_SVC_PLUGIN_ERROR_NONE;
+}
+
+int refresh_item(void * handle, const char *file_path, int storage_type, const char * mime_type, char ** err_msg)
+{
+ int ret = MEDIA_SVC_PLUGIN_ERROR_NONE;
+
+ if(handle == NULL) {
+ __set_error_message(ERR_HANDLE, err_msg);
+ return MEDIA_SVC_PLUGIN_ERROR;
+ }
+
+ if (!STRING_VALID(file_path)) {
+ __set_error_message(ERR_FILE_PATH, err_msg);
+ return MEDIA_SVC_PLUGIN_ERROR;
+ }
+
+ if (!STRING_VALID(mime_type)) {
+ __set_error_message(ERR_MIME_TYPE, err_msg);
+ return MEDIA_SVC_PLUGIN_ERROR;
+ }
+
+ if(!STORAGE_VALID(storage_type)) {
+ __set_error_message(ERR_STORAGE_TYPE, err_msg);
+ return MEDIA_SVC_PLUGIN_ERROR;
+ }
+
+ media_svc_media_type_e content_type = __get_content_type(file_path, mime_type);
+
+ ret = media_svc_refresh_item(handle, storage_type, file_path, content_type);
+
+ if(ret < 0) {
+ __set_error_message(ret, err_msg);
+ return MEDIA_SVC_PLUGIN_ERROR;
+ }
+
+ return MEDIA_SVC_PLUGIN_ERROR_NONE;
+}
+
+int update_begin(void)
+{
+ return MEDIA_SVC_PLUGIN_ERROR_NONE;
+}
+
+int update_end(void)
+{
+ int ret = MEDIA_SVC_PLUGIN_ERROR_NONE;
+
+ ret = thumbnail_request_extract_all_thumbs();
+ if (ret < 0) {
+ return MEDIA_SVC_PLUGIN_ERROR;
+ }
+
+ return MEDIA_SVC_PLUGIN_ERROR_NONE;
+}
--- /dev/null
+/*
+ * libmedia-service
+ *
+ * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
+ *
+ * Contact: Hyunjun Ko <zzoon.ko@samsung.com>, Haejeong Kim <backto.kim@samsung.com>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+#include "media-svc-album.h"
+#include "media-svc-error.h"
+#include "media-svc-debug.h"
+#include "media-svc-env.h"
+#include "media-svc-util.h"
+#include "media-svc-db-utils.h"
+
+int _media_svc_get_album_id(sqlite3 *handle, const char *album, const char *artist, int * album_id)
+{
+ int ret = MEDIA_INFO_ERROR_NONE;
+ sqlite3_stmt *sql_stmt = NULL;
+ char *sql = NULL;
+
+ media_svc_retvm_if(album == NULL, MEDIA_INFO_ERROR_INVALID_PARAMETER, "album is NULL");
+
+ if(artist != NULL) {
+ sql = sqlite3_mprintf("SELECT album_id FROM %s WHERE name = '%q' AND artist = '%q';", MEDIA_SVC_DB_TABLE_ALBUM, album, artist);
+ } else {
+ sql = sqlite3_mprintf("SELECT album_id FROM %s WHERE name = '%q' AND artist IS NULL;", MEDIA_SVC_DB_TABLE_ALBUM, album, artist);
+ }
+
+ ret = _media_svc_sql_prepare_to_step(handle, sql, &sql_stmt);
+
+ if (ret != MEDIA_INFO_ERROR_NONE) {
+ if(ret == MEDIA_INFO_ERROR_DATABASE_NO_RECORD) {
+ media_svc_debug("there is no album.");
+ }
+ else {
+ media_svc_error("error when _media_svc_get_album_id. err = [%d]", ret);
+ }
+ return ret;
+ }
+
+ *album_id = sqlite3_column_int(sql_stmt, 0);
+
+ SQLITE3_FINALIZE(sql_stmt);
+
+ return ret;
+}
+
+int _media_svc_get_album_art_by_album_id(sqlite3 *handle, int album_id, char **album_art)
+{
+ int ret = MEDIA_INFO_ERROR_NONE;
+ sqlite3_stmt *sql_stmt = NULL;
+ char *value = NULL;
+
+ char *sql = sqlite3_mprintf("SELECT album_art FROM %s WHERE album_id=%d", MEDIA_SVC_DB_TABLE_ALBUM, album_id);
+
+ ret = _media_svc_sql_prepare_to_step(handle, sql, &sql_stmt);
+
+ if (ret != MEDIA_INFO_ERROR_NONE) {
+ if(ret == MEDIA_INFO_ERROR_DATABASE_NO_RECORD) {
+ media_svc_debug("there is no album_id.");
+ }
+ else {
+ media_svc_error("error when _media_svc_get_folder_id_by_foldername. err = [%d]", ret);
+ }
+ return ret;
+ }
+
+ value = (char *)sqlite3_column_text(sql_stmt, 0);
+
+ if (STRING_VALID(value)) {
+ ret = __media_svc_malloc_and_strncpy(album_art, value);
+ if (ret < 0) {
+ media_svc_error("__media_svc_malloc_and_strncpy failed: %d", ret);
+ SQLITE3_FINALIZE(sql_stmt);
+ return ret;
+ }
+ } else {
+ *album_art = NULL;
+ }
+
+ SQLITE3_FINALIZE(sql_stmt);
+
+ return MEDIA_INFO_ERROR_NONE;
+}
+
+int _media_svc_append_album(sqlite3 *handle, const char *album, const char *artist, const char *album_art, int * album_id)
+{
+ int err = -1;
+
+ char *sql = sqlite3_mprintf("INSERT INTO %s (name, artist, album_art, album_art) values (%Q, %Q, %Q, %Q); ",
+ MEDIA_SVC_DB_TABLE_ALBUM, album, artist, album_art, album_art);
+ err = _media_svc_sql_query(handle, sql);
+ sqlite3_free(sql);
+ if (err != SQLITE_OK) {
+ media_svc_error("failed to insert albums");
+ return MEDIA_INFO_ERROR_DATABASE_INTERNAL;
+ }
+
+ //*album_id = sqlite3_last_insert_rowid(handle);
+ int inserted_album_id = 0;
+ err = _media_svc_get_album_id(handle, album, artist, &inserted_album_id);
+ if (err < 0) {
+ media_svc_error("Failed _media_svc_get_album_id : %d", err);
+ return err;
+ }
+
+ *album_id = inserted_album_id;
+
+ return MEDIA_INFO_ERROR_NONE;
+}
--- /dev/null
+/*
+ * libmedia-service
+ *
+ * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
+ *
+ * Contact: Hyunjun Ko <zzoon.ko@samsung.com>, Haejeong Kim <backto.kim@samsung.com>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+#include <unistd.h>
+#include <db-util.h>
+#include <media-util.h>
+#include "media-svc-env.h"
+#include "media-svc-debug.h"
+#include "media-svc-error.h"
+#include "media-svc-util.h"
+#include "media-svc-db-utils.h"
+#include "media-util-db.h"
+
+static int __media_svc_busy_handler(void *pData, int count);
+
+static int __media_svc_busy_handler(void *pData, int count)
+{
+ usleep(50000);
+
+ media_svc_debug("media_svc_busy_handler called : %d", count);
+
+ return 100 - count;
+}
+
+int _media_svc_connect_db_with_handle(sqlite3 **db_handle)
+{
+ int ret = MEDIA_INFO_ERROR_NONE;
+
+ media_svc_debug_func();
+
+ /*Connect DB*/
+ ret = db_util_open(MEDIA_SVC_DB_NAME, db_handle, DB_UTIL_REGISTER_HOOK_METHOD);
+
+ if (SQLITE_OK != ret) {
+
+ media_svc_error("error when db open");
+ *db_handle = NULL;
+ return MEDIA_INFO_ERROR_DATABASE_CONNECT;
+ }
+
+ /*Register busy handler*/
+ if (*db_handle) {
+ ret = sqlite3_busy_handler(*db_handle, __media_svc_busy_handler, NULL);
+
+ if (SQLITE_OK != ret) {
+
+ if (*db_handle) {
+ media_svc_error("[error when register busy handler] %s\n", sqlite3_errmsg(*db_handle));
+ }
+
+ db_util_close(*db_handle);
+ *db_handle = NULL;
+
+ return MEDIA_INFO_ERROR_DATABASE_CONNECT;
+ }
+ } else {
+ *db_handle = NULL;
+ return MEDIA_INFO_ERROR_DATABASE_CONNECT;
+ }
+
+ return MEDIA_INFO_ERROR_NONE;
+}
+
+int _media_svc_disconnect_db_with_handle(sqlite3 *db_handle)
+{
+ int ret = MEDIA_INFO_ERROR_NONE;
+
+ media_svc_debug_func();
+
+ ret = db_util_close(db_handle);
+
+ if (SQLITE_OK != ret) {
+ media_svc_error("Error when db close : %s", sqlite3_errmsg(db_handle));
+ db_handle = NULL;
+ return MEDIA_INFO_ERROR_DATABASE_DISCONNECT;
+ }
+
+ return MEDIA_INFO_ERROR_NONE;
+}
+
+int _media_svc_create_media_table(sqlite3 *db_handle)
+{
+ int ret = MEDIA_INFO_ERROR_NONE;
+ char * sql = NULL;
+
+ media_svc_debug_func();
+
+ sql = sqlite3_mprintf("CREATE TABLE IF NOT EXISTS %s (\
+ media_uuid TEXT PRIMARY KEY, \
+ path TEXT NOT NULL UNIQUE, \
+ file_name TEXT NOT NULL, \
+ media_type INTEGER,\
+ mime_type TEXT, \
+ size INTEGER DEFAULT 0, \
+ added_time INTEGER DEFAULT 0,\
+ modified_time INTEGER DEFAULT 0, \
+ folder_uuid TEXT NOT NULL, \
+ thumbnail_path TEXT, \
+ title TEXT, \
+ album_id INTEGER DEFAULT 0, \
+ album TEXT, \
+ artist TEXT, \
+ genre TEXT, \
+ composer TEXT, \
+ year TEXT, \
+ recorded_date TEXT, \
+ copyright TEXT, \
+ track_num TEXT, \
+ description TEXT, \
+ bitrate INTEGER DEFAULT -1, \
+ samplerate INTEGER DEFAULT -1, \
+ channel INTEGER DEFAULT -1, \
+ duration INTEGER DEFAULT -1, \
+ longitude DOUBLE DEFAULT 0, \
+ latitude DOUBLE DEFAULT 0, \
+ altitude DOUBLE DEFAULT 0, \
+ width INTEGER DEFAULT -1, \
+ height INTEGER DEFAULT -1, \
+ datetaken TEXT, \
+ orientation INTEGER DEFAULT -1, \
+ played_count INTEGER DEFAULT 0, \
+ last_played_time INTEGER DEFAULT 0, \
+ last_played_position INTEGER DEFAULT 0, \
+ rating INTEGER DEFAULT 0, \
+ favourite INTEGER DEFAULT 0, \
+ author TEXT, \
+ provider TEXT, \
+ content_name TEXT, \
+ category TEXT, \
+ location_tag TEXT, \
+ age_rating TEXT, \
+ keyword TEXT, \
+ is_drm INTEGER DEFAULT 0, \
+ storage_type INTEGER, \
+ validity INTEGER DEFAULT 1, \
+ unique(path, file_name) \
+ );",
+ MEDIA_SVC_DB_TABLE_MEDIA);
+
+ media_svc_retv_if(sql == NULL, MEDIA_INFO_ERROR_OUT_OF_MEMORY);
+
+ ret = _media_svc_sql_query(db_handle, sql);
+ sqlite3_free(sql);
+ if (ret != SQLITE_OK) {
+ media_svc_error("It failed to create db table (%d)", ret);
+ return MEDIA_INFO_ERROR_DATABASE_TABLE_OPEN;
+ }
+
+ /* Create Index*/
+ sql = sqlite3_mprintf(" CREATE INDEX IF NOT EXISTS media_media_type_idx on %s (media_type); \
+ CREATE INDEX IF NOT EXISTS media_title_idx on %s (title); \
+ CREATE INDEX IF NOT EXISTS media_modified_time_idx on %s (modified_time); \
+ CREATE INDEX IF NOT EXISTS media_provider_idx on %s (provider); \
+ ",
+ MEDIA_SVC_DB_TABLE_MEDIA,
+ MEDIA_SVC_DB_TABLE_MEDIA,
+ MEDIA_SVC_DB_TABLE_MEDIA,
+ MEDIA_SVC_DB_TABLE_MEDIA);
+
+ media_svc_retv_if(sql == NULL, MEDIA_INFO_ERROR_OUT_OF_MEMORY);
+
+ ret = _media_svc_sql_query(db_handle, sql);
+ sqlite3_free(sql);
+ if (ret != SQLITE_OK) {
+ media_svc_error("It failed to create db table (%d)", ret);
+ return MEDIA_INFO_ERROR_DATABASE_TABLE_OPEN;
+ }
+
+ return MEDIA_INFO_ERROR_NONE;
+}
+
+int _media_svc_create_folder_table(sqlite3 *db_handle)
+{
+ int ret = MEDIA_INFO_ERROR_NONE;
+ char * sql = NULL;
+
+ media_svc_debug_func();
+
+ sql = sqlite3_mprintf("CREATE TABLE IF NOT EXISTS %s (\
+ folder_uuid TEXT PRIMARY KEY, \
+ path TEXT NOT NULL UNIQUE, \
+ name TEXT NOT NULL, \
+ modified_time INTEGER DEFAULT 0, \
+ storage_type INTEGER, \
+ unique(path, name) \
+ );",
+ MEDIA_SVC_DB_TABLE_FOLDER);
+
+ media_svc_retv_if(sql == NULL, MEDIA_INFO_ERROR_OUT_OF_MEMORY);
+
+ ret = _media_svc_sql_query(db_handle, sql);
+ sqlite3_free(sql);
+ if (ret != SQLITE_OK) {
+ media_svc_error("It failed to create db table (%d)", ret);
+ return MEDIA_INFO_ERROR_DATABASE_TABLE_OPEN;
+ }
+
+ /* Create Trigger to remove folder which have no content from folder when media remove from media_table*/
+ sql = sqlite3_mprintf("CREATE TRIGGER IF NOT EXISTS folder_cleanup \
+ DELETE ON %s BEGIN DELETE FROM %s \
+ WHERE (SELECT count(*) FROM %s WHERE folder_uuid=old.folder_uuid)=1 AND folder_uuid=old.folder_uuid;END;",
+ MEDIA_SVC_DB_TABLE_MEDIA, MEDIA_SVC_DB_TABLE_FOLDER, MEDIA_SVC_DB_TABLE_MEDIA);
+
+ media_svc_retv_if(sql == NULL, MEDIA_INFO_ERROR_OUT_OF_MEMORY);
+
+ ret = _media_svc_sql_query(db_handle, sql);
+ sqlite3_free(sql);
+ if (ret != SQLITE_OK) {
+ media_svc_error("It failed to create trigger (%d)", ret);
+ return MEDIA_INFO_ERROR_DATABASE_TABLE_OPEN;
+ }
+
+ return MEDIA_INFO_ERROR_NONE;
+}
+
+int _media_svc_create_playlist_table(sqlite3 *db_handle)
+{
+ int ret = MEDIA_INFO_ERROR_NONE;
+ char * sql = NULL;
+
+ media_svc_debug_func();
+
+ /*Create playlist table*/
+ sql = sqlite3_mprintf("CREATE TABLE IF NOT EXISTS %s (\
+ playlist_id INTEGER PRIMARY KEY AUTOINCREMENT, \
+ name TEXT NOT NULL UNIQUE\
+ );",
+ MEDIA_SVC_DB_TABLE_PLAYLIST);
+
+ media_svc_retv_if(sql == NULL, MEDIA_INFO_ERROR_OUT_OF_MEMORY);
+
+ ret = _media_svc_sql_query(db_handle, sql);
+ sqlite3_free(sql);
+ if (ret != SQLITE_OK) {
+ media_svc_error("It failed to create db table (%d)", ret);
+ return MEDIA_INFO_ERROR_DATABASE_TABLE_OPEN;
+ }
+
+ /*Create playlist_map table*/
+ sql = sqlite3_mprintf("CREATE TABLE IF NOT EXISTS %s (\
+ _id INTEGER PRIMARY KEY AUTOINCREMENT, \
+ playlist_id INTEGER NOT NULL,\
+ media_uuid TEXT NOT NULL,\
+ play_order INTEGER NOT NULL\
+ );",
+ MEDIA_SVC_DB_TABLE_PLAYLIST_MAP);
+
+ media_svc_retv_if(sql == NULL, MEDIA_INFO_ERROR_OUT_OF_MEMORY);
+
+ ret = _media_svc_sql_query(db_handle, sql);
+ sqlite3_free(sql);
+ if (ret != SQLITE_OK) {
+ media_svc_error("It failed to create db table (%d)", ret);
+ return MEDIA_INFO_ERROR_DATABASE_TABLE_OPEN;
+ }
+
+ /* Create Trigger to remove media from playlist_map when media remove from media_table*/
+ sql = sqlite3_mprintf("CREATE TRIGGER IF NOT EXISTS playlist_map_cleanup \
+ DELETE ON %s BEGIN DELETE FROM %s WHERE media_uuid=old.media_uuid;END;",
+ MEDIA_SVC_DB_TABLE_MEDIA, MEDIA_SVC_DB_TABLE_PLAYLIST_MAP);
+
+ media_svc_retv_if(sql == NULL, MEDIA_INFO_ERROR_OUT_OF_MEMORY);
+
+ ret = _media_svc_sql_query(db_handle, sql);
+ sqlite3_free(sql);
+ if (ret != SQLITE_OK) {
+ media_svc_error("It failed to create trigger (%d)", ret);
+ return MEDIA_INFO_ERROR_DATABASE_TABLE_OPEN;
+ }
+
+ /* Create Trigger to remove media from playlist_map when playlist removed from playlist table*/
+ sql = sqlite3_mprintf("CREATE TRIGGER IF NOT EXISTS playlist_map_cleanup_1 \
+ DELETE ON %s BEGIN DELETE FROM %s WHERE playlist_id=old.playlist_id;END;",
+ MEDIA_SVC_DB_TABLE_PLAYLIST, MEDIA_SVC_DB_TABLE_PLAYLIST_MAP);
+
+ media_svc_retv_if(sql == NULL, MEDIA_INFO_ERROR_OUT_OF_MEMORY);
+
+ ret = _media_svc_sql_query(db_handle, sql);
+ sqlite3_free(sql);
+ if (ret != SQLITE_OK) {
+ media_svc_error("It failed to create trigger (%d)", ret);
+ return MEDIA_INFO_ERROR_DATABASE_TABLE_OPEN;
+ }
+
+ return MEDIA_INFO_ERROR_NONE;
+}
+
+int _media_svc_create_album_table(sqlite3 *db_handle)
+{
+ int ret = MEDIA_INFO_ERROR_NONE;
+ char * sql = NULL;
+
+ media_svc_debug_func();
+
+ sql = sqlite3_mprintf("CREATE TABLE IF NOT EXISTS %s (\
+ album_id INTEGER PRIMARY KEY AUTOINCREMENT, \
+ name TEXT NOT NULL,\
+ artist TEXT, \
+ album_art TEXT, \
+ unique(name, artist) \
+ );",
+ MEDIA_SVC_DB_TABLE_ALBUM);
+
+ media_svc_retv_if(sql == NULL, MEDIA_INFO_ERROR_OUT_OF_MEMORY);
+
+ ret = _media_svc_sql_query(db_handle, sql);
+ sqlite3_free(sql);
+ if (ret != SQLITE_OK) {
+ media_svc_error("It failed to create db table (%d)", ret);
+ return MEDIA_INFO_ERROR_DATABASE_TABLE_OPEN;
+ }
+
+ /* Create Trigger to remove album when media remove from media_table*/
+ sql = sqlite3_mprintf("CREATE TRIGGER IF NOT EXISTS album_cleanup \
+ DELETE ON %s BEGIN DELETE FROM %s \
+ WHERE (SELECT count(*) FROM %s WHERE album_id=old.album_id)=1 AND album_id=old.album_id;END;",
+ MEDIA_SVC_DB_TABLE_MEDIA, MEDIA_SVC_DB_TABLE_ALBUM, MEDIA_SVC_DB_TABLE_MEDIA);
+
+ media_svc_retv_if(sql == NULL, MEDIA_INFO_ERROR_OUT_OF_MEMORY);
+
+ ret = _media_svc_sql_query(db_handle, sql);
+ sqlite3_free(sql);
+ if (ret != SQLITE_OK) {
+ media_svc_error("It failed to create trigger (%d)", ret);
+ return MEDIA_INFO_ERROR_DATABASE_TABLE_OPEN;
+ }
+
+ return MEDIA_INFO_ERROR_NONE;
+}
+
+int _media_svc_create_tag_table(sqlite3 *db_handle)
+{
+ int ret = MEDIA_INFO_ERROR_NONE;
+ char * sql = NULL;
+
+ media_svc_debug_func();
+
+ /*Create tag table*/
+ sql = sqlite3_mprintf("CREATE TABLE IF NOT EXISTS %s (\
+ tag_id INTEGER PRIMARY KEY AUTOINCREMENT, \
+ name TEXT NOT NULL UNIQUE\
+ );",
+ MEDIA_SVC_DB_TABLE_TAG);
+
+ media_svc_retv_if(sql == NULL, MEDIA_INFO_ERROR_OUT_OF_MEMORY);
+
+ ret = _media_svc_sql_query(db_handle, sql);
+ sqlite3_free(sql);
+ if (ret != SQLITE_OK) {
+ media_svc_error("It failed to create db table (%d)", ret);
+ return MEDIA_INFO_ERROR_DATABASE_TABLE_OPEN;
+ }
+
+ /*Create tag_map table*/
+ sql = sqlite3_mprintf("CREATE TABLE IF NOT EXISTS %s (\
+ _id INTEGER PRIMARY KEY AUTOINCREMENT, \
+ tag_id INTEGER NOT NULL,\
+ media_uuid TEXT NOT NULL,\
+ unique(tag_id, media_uuid) \
+ );",
+ MEDIA_SVC_DB_TABLE_TAG_MAP);
+
+ media_svc_retv_if(sql == NULL, MEDIA_INFO_ERROR_OUT_OF_MEMORY);
+
+ ret = _media_svc_sql_query(db_handle, sql);
+ sqlite3_free(sql);
+ if (ret != SQLITE_OK) {
+ media_svc_error("It failed to create db table (%d)", ret);
+ return MEDIA_INFO_ERROR_DATABASE_TABLE_OPEN;
+ }
+
+ /* Create Trigger to remove media from tag_map when media remove from media_table*/
+ sql = sqlite3_mprintf("CREATE TRIGGER IF NOT EXISTS tag_map_cleanup \
+ DELETE ON %s BEGIN DELETE FROM %s WHERE media_uuid=old.media_uuid;END;",
+ MEDIA_SVC_DB_TABLE_MEDIA, MEDIA_SVC_DB_TABLE_TAG_MAP);
+
+ media_svc_retv_if(sql == NULL, MEDIA_INFO_ERROR_OUT_OF_MEMORY);
+
+ ret = _media_svc_sql_query(db_handle, sql);
+ sqlite3_free(sql);
+ if (ret != SQLITE_OK) {
+ media_svc_error("It failed to create trigger (%d)", ret);
+ return MEDIA_INFO_ERROR_DATABASE_TABLE_OPEN;
+ }
+
+ /* Create Trigger to remove media from tag_map when tag removed from tag table*/
+ sql = sqlite3_mprintf("CREATE TRIGGER IF NOT EXISTS tag_map_cleanup_1 \
+ DELETE ON %s BEGIN DELETE FROM %s WHERE tag_id=old.tag_id;END;",
+ MEDIA_SVC_DB_TABLE_TAG, MEDIA_SVC_DB_TABLE_TAG_MAP);
+
+ media_svc_retv_if(sql == NULL, MEDIA_INFO_ERROR_OUT_OF_MEMORY);
+
+ ret = _media_svc_sql_query(db_handle, sql);
+ sqlite3_free(sql);
+ if (ret != SQLITE_OK) {
+ media_svc_error("It failed to create trigger (%d)", ret);
+ return MEDIA_INFO_ERROR_DATABASE_TABLE_OPEN;
+ }
+ return MEDIA_INFO_ERROR_NONE;
+}
+
+int _media_svc_create_bookmark_table(sqlite3 *db_handle)
+{
+ int ret = MEDIA_INFO_ERROR_NONE;
+ char * sql = NULL;
+
+ media_svc_debug_func();
+
+ sql = sqlite3_mprintf("CREATE TABLE IF NOT EXISTS %s (\
+ bookmark_id INTEGER PRIMARY KEY AUTOINCREMENT, \
+ media_uuid TEXT NOT NULL,\
+ marked_time INTEGER DEFAULT 0, \
+ thumbnail_path TEXT, \
+ unique(media_uuid, marked_time) \
+ );",
+ MEDIA_SVC_DB_TABLE_BOOKMARK);
+
+ media_svc_retv_if(sql == NULL, MEDIA_INFO_ERROR_OUT_OF_MEMORY);
+
+ ret = _media_svc_sql_query(db_handle, sql);
+ sqlite3_free(sql);
+ if (ret != SQLITE_OK) {
+ media_svc_error("It failed to create db table (%d)", ret);
+ return MEDIA_INFO_ERROR_DATABASE_TABLE_OPEN;
+ }
+
+ /* Create Trigger to remove media from tag_map when media remove from media_table*/
+ sql = sqlite3_mprintf("CREATE TRIGGER IF NOT EXISTS bookmark_cleanup \
+ DELETE ON %s BEGIN DELETE FROM %s WHERE media_uuid=old.media_uuid;END;",
+ MEDIA_SVC_DB_TABLE_MEDIA, MEDIA_SVC_DB_TABLE_BOOKMARK);
+
+ media_svc_retv_if(sql == NULL, MEDIA_INFO_ERROR_OUT_OF_MEMORY);
+
+ ret = _media_svc_sql_query(db_handle, sql);
+ sqlite3_free(sql);
+ if (ret != SQLITE_OK) {
+ media_svc_error("It failed to create trigger (%d)", ret);
+ return MEDIA_INFO_ERROR_DATABASE_TABLE_OPEN;
+ }
+
+ return MEDIA_INFO_ERROR_NONE;
+}
+
+int _media_svc_create_custom_table(sqlite3 *db_handle)
+{
+ int ret = MEDIA_INFO_ERROR_NONE;
+ char * sql = NULL;
+
+ media_svc_debug_func();
+
+ sql = sqlite3_mprintf("CREATE TABLE IF NOT EXISTS %s (\
+ _id INTEGER PRIMARY KEY AUTOINCREMENT, \
+ media_uuid TEXT, \
+ media_type INTEGER,\
+ author TEXT, \
+ provider TEXT, \
+ content_name TEXT, \
+ category TEXT, \
+ location_tag TEXT, \
+ age_rating TEXT \
+ );",
+ MEDIA_SVC_DB_TABLE_CUSTOM);
+
+ media_svc_retv_if(sql == NULL, MEDIA_INFO_ERROR_OUT_OF_MEMORY);
+
+ ret = _media_svc_sql_query(db_handle, sql);
+ sqlite3_free(sql);
+ if (ret != SQLITE_OK) {
+ media_svc_error("It failed to create db table (%d)", ret);
+ return MEDIA_INFO_ERROR_DATABASE_TABLE_OPEN;
+ }
+
+ /* Create Trigger to remove media from tag_map when media remove from media_table*/
+ sql = sqlite3_mprintf("CREATE TRIGGER IF NOT EXISTS custom_cleanup \
+ DELETE ON %s BEGIN DELETE FROM %s WHERE media_uuid=old.media_uuid;END;",
+ MEDIA_SVC_DB_TABLE_MEDIA, MEDIA_SVC_DB_TABLE_CUSTOM);
+
+ media_svc_retv_if(sql == NULL, MEDIA_INFO_ERROR_OUT_OF_MEMORY);
+
+ ret = _media_svc_sql_query(db_handle, sql);
+ sqlite3_free(sql);
+ if (ret != SQLITE_OK) {
+ media_svc_error("It failed to create trigger (%d)", ret);
+ return MEDIA_INFO_ERROR_DATABASE_TABLE_OPEN;
+ }
+
+ /* Create Index*/
+ sql = sqlite3_mprintf("CREATE INDEX IF NOT EXISTS custom_provider_idx on %s (provider); \
+ ",
+ MEDIA_SVC_DB_TABLE_CUSTOM);
+
+ media_svc_retv_if(sql == NULL, MEDIA_INFO_ERROR_OUT_OF_MEMORY);
+
+ ret = _media_svc_sql_query(db_handle, sql);
+ sqlite3_free(sql);
+ if (ret != SQLITE_OK) {
+ media_svc_error("It failed to create db table (%d)", ret);
+ return MEDIA_INFO_ERROR_DATABASE_TABLE_OPEN;
+ }
+
+ return MEDIA_INFO_ERROR_NONE;
+}
+
+int _media_svc_request_update_db(const char *sql_str)
+{
+ int ret = MS_MEDIA_ERR_NONE;
+
+ ret = media_db_request_update_db(sql_str);
+
+ return ret;
+}
+
+int _media_svc_sql_query(sqlite3 *db_handle, const char *sql_str)
+{
+ int err = -1;
+
+ media_svc_debug("[SQL query] : %s", sql_str);
+#if 1
+ //DB will be updated by Media Server.
+ err = _media_svc_request_update_db(sql_str);
+
+ return _media_svc_error_convert(err);
+#else
+ char *zErrMsg = NULL;
+ media_svc_retvm_if(sql_str == NULL, MEDIA_INFO_ERROR_INVALID_PARAMETER, "sql_str is NULL");
+
+ err = sqlite3_exec(db_handle, sql_str, NULL, NULL, &zErrMsg);
+
+ if (SQLITE_OK != err) {
+ media_svc_error("failed to execute [%s], err[%d]", zErrMsg, err);
+ } else {
+ media_svc_debug("query success");
+ }
+
+ if (zErrMsg)
+ sqlite3_free (zErrMsg);
+ return err;
+#endif
+}
+
+int _media_svc_sql_prepare_to_step(sqlite3 *handle, const char *sql_str, sqlite3_stmt** stmt)
+{
+ int err = -1;
+
+ media_svc_debug("[SQL query] : %s", sql_str);
+
+ err = sqlite3_prepare_v2(handle, sql_str, -1, stmt, NULL);
+ sqlite3_free((char *)sql_str);
+
+ if (err != SQLITE_OK) {
+ media_svc_error ("prepare error [%s]", sqlite3_errmsg(handle));
+ return MEDIA_INFO_ERROR_DATABASE_INTERNAL;
+ }
+
+ err = sqlite3_step(*stmt);
+ if (err != SQLITE_ROW) {
+ media_svc_error("Item not found. end of row [%s]", sqlite3_errmsg(handle));
+ SQLITE3_FINALIZE(*stmt);
+ return MEDIA_INFO_ERROR_DATABASE_NO_RECORD;
+ }
+
+ return MEDIA_INFO_ERROR_NONE;
+}
+
+int _media_svc_sql_begin_trans(sqlite3 *handle)
+{
+ int err = MEDIA_INFO_ERROR_NONE;
+
+ media_svc_debug("========_media_svc_sql_begin_trans");
+#if 1
+ //err = _media_svc_request_update_db("BEGIN IMMEDIATE;");
+ err = media_db_request_update_db_batch_start("BEGIN IMMEDIATE;");
+
+ return _media_svc_error_convert(err);
+#else
+ char *err_msg = NULL;
+
+ if (SQLITE_OK != sqlite3_exec(handle, "BEGIN IMMEDIATE;", NULL, NULL, &err_msg)) {
+ media_svc_error("Error:failed to begin transaction: error=%s", err_msg);
+ sqlite3_free(err_msg);
+ return MEDIA_INFO_ERROR_DATABASE_INTERNAL;
+ }
+
+ sqlite3_free(err_msg);
+ return err;
+#endif
+}
+
+int _media_svc_sql_end_trans(sqlite3 *handle)
+{
+ int err = MEDIA_INFO_ERROR_NONE;
+
+ media_svc_debug("========_media_svc_sql_end_trans");
+#if 1
+ err = media_db_request_update_db_batch_end("COMMIT;");
+ //err = _media_svc_request_update_db("COMMIT;");
+ return _media_svc_error_convert(err);
+#else
+ char *err_msg = NULL;
+ if (SQLITE_OK != sqlite3_exec(handle, "COMMIT;", NULL, NULL, &err_msg)) {
+ media_svc_error("Error:failed to end transaction: error=%s", err_msg);
+ sqlite3_free(err_msg);
+ return MEDIA_INFO_ERROR_DATABASE_INTERNAL;
+ }
+
+ sqlite3_free(err_msg);
+ return err;
+#endif
+}
+
+int _media_svc_sql_rollback_trans(sqlite3 *handle)
+{
+ int err = MEDIA_INFO_ERROR_NONE;
+
+ media_svc_debug("========_media_svc_sql_rollback_trans");
+#if 1
+ err = _media_svc_request_update_db("ROLLBACK;");
+ return _media_svc_error_convert(err);
+#else
+ char *err_msg = NULL;
+ if (SQLITE_OK != sqlite3_exec(handle, "ROLLBACK;", NULL, NULL, &err_msg)) {
+ media_svc_error("Error:failed to rollback transaction: error=%s", err_msg);
+ sqlite3_free(err_msg);
+ return MEDIA_INFO_ERROR_DATABASE_INTERNAL;
+ }
+
+ sqlite3_free(err_msg);
+ return err;
+#endif
+}
+
+int _media_svc_sql_query_list(sqlite3 *handle, GList **query_list)
+{
+ int i = 0;
+ int length = g_list_length(*query_list);
+ int err = -1;
+ char *sql = NULL;
+
+ media_svc_debug("query list length : [%d]", length);
+
+ for (i = 0; i < length; i++) {
+ sql = (char*)g_list_nth_data(*query_list, i);
+ if(sql != NULL) {
+ //err = _media_svc_sql_query(handle, sql);
+ err = media_db_request_update_db_batch(sql);
+ //if (err != SQLITE_OK) {
+ // media_svc_error("A query failed in batch");
+ if (err < MS_MEDIA_ERR_NONE) {
+ media_svc_error("media_db_request_update_db_batch failed : %d", err);
+ }
+ sqlite3_free(sql);
+ sql = NULL;
+ }
+ }
+
+ _media_svc_sql_query_release(query_list);
+
+ return MEDIA_INFO_ERROR_NONE;
+
+}
+
+void _media_svc_sql_query_add(GList **query_list, char **query)
+{
+ *query_list = g_list_append( *query_list, *query);
+}
+
+void _media_svc_sql_query_release(GList **query_list)
+{
+ if (*query_list) {
+ media_svc_debug("_svc_sql_query_release");
+ g_list_free(*query_list);
+ *query_list = NULL;
+ }
+}
--- /dev/null
+/*
+ * libmedia-service
+ *
+ * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
+ *
+ * Contact: Hyunjun Ko <zzoon.ko@samsung.com>, Haejeong Kim <backto.kim@samsung.com>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+#include <unistd.h>
+#include <asm/unistd.h>
+#include <time.h>
+#include <sys/time.h>
+#include "media-svc-debug.h"
+
+#ifdef _PERFORMANCE_CHECK_
+static long g_time_usec = 0L;
+#endif
+
+#ifdef _USE_LOG_FILE_
+static FILE *g_log_fp = NULL;
+static char _g_file_path[1024] = "\0";
+
+FILE *get_fp()
+{
+ return g_log_fp;
+}
+
+void mediainfo_init_file_debug()
+{
+ if (g_log_fp == NULL) {
+ snprintf(_g_file_path, sizeof(_g_file_path), "/tmp/%s",
+ "media-info");
+ if (access(_g_file_path, R_OK == 0)) {
+ remove(_g_file_path);
+ }
+
+ g_log_fp = fopen(_g_file_path, "a");
+ }
+}
+
+void mediainfo_close_file_debug()
+{
+ if (g_log_fp != NULL) {
+ fclose(g_log_fp);
+ g_log_fp = NULL;
+ }
+}
+
+#endif
+
+long mediainfo_get_debug_time(void)
+{
+#ifdef _PERFORMANCE_CHECK_
+ struct timeval time;
+ gettimeofday(&time, NULL);
+ return time.tv_sec * 1000000 + time.tv_usec;
+#else
+ return 0L;
+#endif
+}
+
+void mediainfo_reset_debug_time(void)
+{
+#ifdef _PERFORMANCE_CHECK_
+ struct timeval time;
+ gettimeofday(&time, NULL);
+ g_time_usec = time.tv_sec * 1000000 + time.tv_usec;
+#endif
+}
+
+void mediainfo_print_debug_time(char *time_string)
+{
+#ifdef _PERFORMANCE_CHECK_
+ struct timeval time;
+ double totaltime = 0.0;
+
+ gettimeofday(&time, NULL);
+ totaltime =
+ (double)(time.tv_sec * 1000000 + time.tv_usec -
+ g_time_usec) / CLOCKS_PER_SEC;
+
+ media_svc_debug("time [%s] : %f \n", time_string, totaltime);
+#endif
+}
+
+void
+mediainfo_print_debug_time_ex(long start, long end, const char *func_name,
+ char *time_string)
+{
+#ifdef _PERFORMANCE_CHECK_
+ double totaltime = 0.0;
+
+ totaltime = (double)(end - start) / CLOCKS_PER_SEC;
+
+ media_svc_debug("time [%s: %s] : %f \n", func_name, time_string,
+ totaltime);
+#endif
+}
--- /dev/null
+/*
+ * libmedia-service
+ *
+ * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
+ *
+ * Contact: Hyunjun Ko <zzoon.ko@samsung.com>, Haejeong Kim <backto.kim@samsung.com>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+#include <glib/gstdio.h>
+#include "media-svc-media-folder.h"
+#include "media-svc-error.h"
+#include "media-svc-debug.h"
+#include "media-svc-env.h"
+#include "media-svc-util.h"
+#include "media-svc-db-utils.h"
+
+extern __thread GList *g_media_svc_move_item_query_list;
+
+int _media_svc_get_folder_id_by_foldername(sqlite3 *handle, const char *folder_name, char *folder_id)
+{
+ int ret = MEDIA_INFO_ERROR_NONE;
+ sqlite3_stmt *sql_stmt = NULL;
+
+ char *sql = sqlite3_mprintf("SELECT folder_uuid FROM %s WHERE path = '%q';", MEDIA_SVC_DB_TABLE_FOLDER, folder_name);
+
+ ret = _media_svc_sql_prepare_to_step(handle, sql, &sql_stmt);
+
+ if (ret != MEDIA_INFO_ERROR_NONE) {
+ if(ret == MEDIA_INFO_ERROR_DATABASE_NO_RECORD) {
+ media_svc_debug("there is no folder.");
+ }
+ else {
+ media_svc_error("error when _media_svc_get_folder_id_by_foldername. err = [%d]", ret);
+ }
+ return ret;
+ }
+
+ _strncpy_safe(folder_id, (const char *)sqlite3_column_text(sql_stmt, 0), MEDIA_SVC_UUID_SIZE+1);
+
+ SQLITE3_FINALIZE(sql_stmt);
+
+ return ret;
+}
+
+int _media_svc_append_folder(sqlite3 *handle, media_svc_storage_type_e storage_type,
+ const char *folder_id, const char *path_name, const char *folder_name, int modified_date)
+{
+ int err = -1;
+
+ char *sql = sqlite3_mprintf("INSERT INTO %s (folder_uuid, path, name, storage_type, modified_time) values (%Q, %Q, %Q, '%d', '%d'); ",
+ MEDIA_SVC_DB_TABLE_FOLDER, folder_id, path_name, folder_name, storage_type, modified_date);
+ err = _media_svc_sql_query(handle, sql);
+ sqlite3_free(sql);
+ if (err != SQLITE_OK) {
+ media_svc_error("failed to insert folder");
+ return MEDIA_INFO_ERROR_DATABASE_INTERNAL;
+ }
+
+ return MEDIA_INFO_ERROR_NONE;
+}
+
+int _media_svc_update_folder_modified_time_by_folder_uuid(sqlite3 *handle, const char *folder_uuid, const char *folder_path, bool stack_query)
+{
+ int err = -1;
+ int modified_time = 0;
+
+ modified_time = _media_svc_get_file_time(folder_path);
+
+ char *sql = sqlite3_mprintf("UPDATE %s SET modified_time=%d WHERE folder_uuid=%Q;", MEDIA_SVC_DB_TABLE_FOLDER, modified_time, folder_uuid);
+
+ if(!stack_query) {
+ err = _media_svc_sql_query(handle, sql);
+ sqlite3_free(sql);
+ if (err != SQLITE_OK) {
+ media_svc_error("failed to update folder");
+ return MEDIA_INFO_ERROR_DATABASE_INTERNAL;
+ }
+ } else {
+ _media_svc_sql_query_add(&g_media_svc_move_item_query_list, &sql);
+ }
+
+ return MEDIA_INFO_ERROR_NONE;
+}
+
+int _media_svc_get_and_append_folder_id_by_path(sqlite3 *handle, const char *path, media_svc_storage_type_e storage_type, char *folder_id)
+{
+ char *path_name = NULL;
+ int ret = MEDIA_INFO_ERROR_NONE;
+
+ path_name = g_path_get_dirname(path);
+
+ ret = _media_svc_get_folder_id_by_foldername(handle, path_name, folder_id);
+
+ if(ret == MEDIA_INFO_ERROR_DATABASE_NO_RECORD) {
+ char *folder_name = NULL;
+ int folder_modified_date = 0;
+ char *folder_uuid = _media_info_generate_uuid();
+ if(folder_uuid == NULL ) {
+ media_svc_error("Invalid UUID");
+ SAFE_FREE(path_name);
+ return MEDIA_INFO_ERROR_INTERNAL;
+ }
+
+ folder_name = g_path_get_basename(path_name);
+ folder_modified_date = _media_svc_get_file_time(path_name);
+
+ ret = _media_svc_append_folder(handle, storage_type, folder_uuid, path_name, folder_name, folder_modified_date);
+ SAFE_FREE(folder_name);
+ _strncpy_safe(folder_id, folder_uuid, MEDIA_SVC_UUID_SIZE+1);
+ }
+
+ SAFE_FREE(path_name);
+
+ return ret;
+}
+
+int _media_svc_update_folder_table(sqlite3 *handle)
+{
+ int err = -1;
+ char *sql = NULL;
+
+ sql = sqlite3_mprintf("DELETE FROM %s WHERE folder_uuid IN (SELECT folder_uuid FROM %s WHERE folder_uuid NOT IN (SELECT folder_uuid FROM %s))",
+ MEDIA_SVC_DB_TABLE_FOLDER, MEDIA_SVC_DB_TABLE_FOLDER, MEDIA_SVC_DB_TABLE_MEDIA);
+
+ err = _media_svc_sql_query(handle, sql);
+ sqlite3_free(sql);
+ if (err != SQLITE_OK) {
+ media_svc_error("failed to delete folder item");
+ return MEDIA_INFO_ERROR_DATABASE_INTERNAL;
+ }
+
+ return MEDIA_INFO_ERROR_NONE;
+}
--- /dev/null
+/*
+ * libmedia-service
+ *
+ * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
+ *
+ * Contact: Hyunjun Ko <zzoon.ko@samsung.com>, Haejeong Kim <backto.kim@samsung.com>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+#include <string.h>
+#include "media-svc-media.h"
+#include "media-svc-media-folder.h"
+#include "media-svc-error.h"
+#include "media-svc-debug.h"
+#include "media-svc-util.h"
+#include "media-svc-db-utils.h"
+
+typedef struct{
+ char thumbnail_path[MEDIA_SVC_PATHNAME_SIZE];
+}media_svc_thumbnailpath_s;
+
+static __thread GList *g_media_svc_item_validity_query_list = NULL;
+static __thread GList *g_media_svc_insert_item_query_list = NULL;
+__thread GList *g_media_svc_move_item_query_list = NULL;
+
+static int __media_svc_count_invalid_records_with_thumbnail(sqlite3 *handle, media_svc_storage_type_e storage_type, int *count);
+static int __media_svc_get_invalid_records_with_thumbnail(sqlite3 *handle, media_svc_storage_type_e storage_type,
+ int count, media_svc_thumbnailpath_s * thumb_path);
+static int __media_svc_count_invalid_folder_records_with_thumbnail(sqlite3 *handle, const char *folder_path, int *count);
+static int __media_svc_get_invalid_folder_records_with_thumbnail(sqlite3 *handle, const char *folder_path,
+ int count, media_svc_thumbnailpath_s * thumb_path);
+
+static int __media_svc_count_invalid_records_with_thumbnail(sqlite3 *handle, media_svc_storage_type_e storage_type, int *count)
+{
+ int ret = MEDIA_INFO_ERROR_NONE;
+ sqlite3_stmt *sql_stmt = NULL;
+ char *sql = sqlite3_mprintf("SELECT count(*) FROM %s WHERE validity=0 AND storage_type=%d AND thumbnail_path IS NOT NULL",
+ MEDIA_SVC_DB_TABLE_MEDIA, storage_type);
+
+ ret = _media_svc_sql_prepare_to_step(handle, sql, &sql_stmt);
+
+ if (ret != MEDIA_INFO_ERROR_NONE) {
+ media_svc_error("error when __media_svc_count_invalid_records_with_thumbnail. err = [%d]", ret);
+ return ret;
+ }
+
+ *count = sqlite3_column_int(sql_stmt, 0);
+
+ SQLITE3_FINALIZE(sql_stmt);
+
+ return MEDIA_INFO_ERROR_NONE;
+
+}
+
+static int __media_svc_get_invalid_records_with_thumbnail(sqlite3 *handle, media_svc_storage_type_e storage_type,
+ int count, media_svc_thumbnailpath_s * thumb_path)
+{
+ int err = -1;
+ int idx = 0;
+ sqlite3_stmt *sql_stmt = NULL;
+
+ char *sql = sqlite3_mprintf("select thumbnail_path from %s WHERE validity=0 AND storage_type=%d AND thumbnail_path IS NOT NULL",
+ MEDIA_SVC_DB_TABLE_MEDIA, storage_type);
+
+ media_svc_debug("[SQL query] : %s", sql);
+
+ err = sqlite3_prepare_v2(handle, sql, -1, &sql_stmt, NULL);
+ sqlite3_free(sql);
+ if (err != SQLITE_OK) {
+ media_svc_error("prepare error [%s]", sqlite3_errmsg(handle));
+ return MEDIA_INFO_ERROR_DATABASE_INTERNAL;
+ }
+
+ while (sqlite3_step(sql_stmt) == SQLITE_ROW) {
+ _strncpy_safe(thumb_path[idx].thumbnail_path, (const char *)sqlite3_column_text(sql_stmt, 0), sizeof(thumb_path[idx]));
+ //media_svc_debug("thumb_path[%d]=[%s]", idx, thumb_path[idx].thumbnail_path);
+ idx++;
+ }
+
+ SQLITE3_FINALIZE(sql_stmt);
+
+ return MEDIA_INFO_ERROR_NONE;
+}
+
+static int __media_svc_count_invalid_folder_records_with_thumbnail(sqlite3 *handle, const char *folder_path, int *count)
+{
+ int ret = MEDIA_INFO_ERROR_NONE;
+ sqlite3_stmt *sql_stmt = NULL;
+ char *sql = sqlite3_mprintf("SELECT count(*) FROM %s WHERE validity=0 AND path LIKE '%q/%%' AND thumbnail_path IS NOT NULL",
+ MEDIA_SVC_DB_TABLE_MEDIA, folder_path);
+
+ ret = _media_svc_sql_prepare_to_step(handle, sql, &sql_stmt);
+
+ if (ret != MEDIA_INFO_ERROR_NONE) {
+ media_svc_error("error when __media_svc_count_invalid_folder_records_with_thumbnail. err = [%d]", ret);
+ return ret;
+ }
+
+ *count = sqlite3_column_int(sql_stmt, 0);
+
+ SQLITE3_FINALIZE(sql_stmt);
+
+ return MEDIA_INFO_ERROR_NONE;
+
+}
+
+static int __media_svc_get_invalid_folder_records_with_thumbnail(sqlite3 *handle, const char *folder_path,
+ int count, media_svc_thumbnailpath_s * thumb_path)
+{
+ int err = -1;
+ int idx = 0;
+ sqlite3_stmt *sql_stmt = NULL;
+
+ char *sql = sqlite3_mprintf("select thumbnail_path from %s WHERE validity=0 AND path LIKE '%q/%%' AND thumbnail_path IS NOT NULL",
+ MEDIA_SVC_DB_TABLE_MEDIA, folder_path);
+
+ media_svc_debug("[SQL query] : %s", sql);
+
+ err = sqlite3_prepare_v2(handle, sql, -1, &sql_stmt, NULL);
+ sqlite3_free(sql);
+ if (err != SQLITE_OK) {
+ media_svc_error("prepare error [%s]", sqlite3_errmsg(handle));
+ return MEDIA_INFO_ERROR_DATABASE_INTERNAL;
+ }
+
+ while (sqlite3_step(sql_stmt) == SQLITE_ROW) {
+ _strncpy_safe(thumb_path[idx].thumbnail_path, (const char *)sqlite3_column_text(sql_stmt, 0), sizeof(thumb_path[idx]));
+ idx++;
+ }
+
+ SQLITE3_FINALIZE(sql_stmt);
+
+ return MEDIA_INFO_ERROR_NONE;
+}
+
+int _media_svc_count_record_with_path(sqlite3 *handle, const char *path, int *count)
+{
+ int ret = MEDIA_INFO_ERROR_NONE;
+ sqlite3_stmt *sql_stmt = NULL;
+
+ char *sql = sqlite3_mprintf("SELECT count(*) FROM %s WHERE path='%q'", MEDIA_SVC_DB_TABLE_MEDIA, path);
+
+ ret = _media_svc_sql_prepare_to_step(handle, sql, &sql_stmt);
+
+ media_svc_retv_if(ret != MEDIA_INFO_ERROR_NONE, ret);
+
+ *count = sqlite3_column_int(sql_stmt, 0);
+
+ SQLITE3_FINALIZE(sql_stmt);
+
+ return MEDIA_INFO_ERROR_NONE;
+}
+
+int _media_svc_insert_item_with_data(sqlite3 *handle, media_svc_content_info_s *content_info, bool stack_query)
+{
+ media_svc_debug("");
+ int err = -1;
+
+ char * db_fields = "media_uuid, path, file_name, media_type, mime_type, size, added_time, modified_time, folder_uuid, \
+ thumbnail_path, title, album_id, album, artist, genre, composer, year, recorded_date, copyright, track_num, description,\
+ bitrate, samplerate, channel, duration, longitude, latitude, altitude, width, height, datetaken, orientation,\
+ rating, is_drm, storage_type";
+
+ /* This sql is due to sqlite3_mprintf's wrong operation when using floating point in the text format */
+ /* This code will be removed when sqlite3_mprintf works clearly */
+ char *test_sql = sqlite3_mprintf("%f, %f, %f", content_info->media_meta.longitude, content_info->media_meta.latitude, content_info->media_meta.altitude);
+ sqlite3_free(test_sql);
+
+ char *sql = sqlite3_mprintf("INSERT INTO %s (%s) VALUES (%Q, %Q, %Q, %d, %Q, %lld, %d, %d, %Q, \
+ %Q, %Q, %d, %Q, %Q, %Q, %Q, %Q, %Q, %Q, %Q, %Q, \
+ %d, %d, %d, %d, %.2f, %.2f, %.2f, %d, %d, %Q, %d, \
+ %d, %d, %d);",
+ MEDIA_SVC_DB_TABLE_MEDIA, db_fields,
+ content_info->media_uuid,
+ content_info->path,
+ content_info->file_name,
+ content_info->media_type,
+ content_info->mime_type,
+ content_info->size,
+ content_info->added_time,
+ content_info->modified_time,
+ content_info->folder_uuid,
+ content_info->thumbnail_path, //
+ content_info->media_meta.title,
+ content_info->album_id,
+ content_info->media_meta.album,
+ content_info->media_meta.artist,
+ content_info->media_meta.genre,
+ content_info->media_meta.composer,
+ content_info->media_meta.year,
+ content_info->media_meta.recorded_date,
+ content_info->media_meta.copyright,
+ content_info->media_meta.track_num,
+ content_info->media_meta.description, //
+ content_info->media_meta.bitrate,
+ content_info->media_meta.samplerate,
+ content_info->media_meta.channel,
+ content_info->media_meta.duration,
+ content_info->media_meta.longitude,
+ content_info->media_meta.latitude,
+ content_info->media_meta.altitude,
+ content_info->media_meta.width,
+ content_info->media_meta.height,
+ content_info->media_meta.datetaken,
+ content_info->media_meta.orientation,
+ content_info->media_meta.rating,
+ content_info->is_drm,
+ content_info->storage_type);
+
+ if(!stack_query) {
+ err = _media_svc_sql_query(handle, sql);
+ sqlite3_free(sql);
+ if (err != SQLITE_OK) {
+ media_svc_error("failed to insert item");
+
+ return MEDIA_INFO_ERROR_DATABASE_INTERNAL;
+ }
+ } else {
+ media_svc_debug("query : %s", sql);
+ _media_svc_sql_query_add(&g_media_svc_insert_item_query_list, &sql);
+ }
+
+ return MEDIA_INFO_ERROR_NONE;
+}
+
+int _media_svc_update_item_with_data(sqlite3 *handle, media_svc_content_info_s *content_info)
+{
+ int err = -1;
+
+ /* This sql is due to sqlite3_mprintf's wrong operation when using floating point in the text format */
+ /* This code will be removed when sqlite3_mprintf works clearly */
+ char *test_sql = sqlite3_mprintf("%f, %f, %f", content_info->media_meta.longitude, content_info->media_meta.latitude, content_info->media_meta.altitude);
+ sqlite3_free(test_sql);
+
+ char *sql = sqlite3_mprintf("UPDATE %s SET \
+ size=%lld, modified_time=%d, thumbnail_path=%Q, title=%Q, album_id=%d, album=%Q, artist=%Q, genre=%Q, \
+ composer=%Q, year=%Q, recorded_date=%Q, copyright=%Q, track_num=%Q, description=%Q, \
+ bitrate=%d, samplerate=%d, channel=%d, duration=%d, longitude=%f, latitude=%f, altitude=%f, width=%d, height=%d, datetaken=%Q, \
+ orientation=%d WHERE path=%Q",
+ MEDIA_SVC_DB_TABLE_MEDIA,
+ content_info->size,
+ content_info->modified_time,
+ content_info->thumbnail_path,
+ content_info->media_meta.title,
+ content_info->album_id,
+ content_info->media_meta.album,
+ content_info->media_meta.artist,
+ content_info->media_meta.genre,
+ content_info->media_meta.composer,
+ content_info->media_meta.year,
+ content_info->media_meta.recorded_date,
+ content_info->media_meta.copyright,
+ content_info->media_meta.track_num,
+ content_info->media_meta.description,
+ content_info->media_meta.bitrate,
+ content_info->media_meta.samplerate,
+ content_info->media_meta.channel,
+ content_info->media_meta.duration,
+ content_info->media_meta.longitude,
+ content_info->media_meta.latitude,
+ content_info->media_meta.altitude,
+ content_info->media_meta.width,
+ content_info->media_meta.height,
+ content_info->media_meta.datetaken,
+ content_info->media_meta.orientation,
+ content_info->path
+ );
+
+ err = _media_svc_sql_query(handle, sql);
+ sqlite3_free(sql);
+ if (err != SQLITE_OK) {
+ media_svc_error("failed to update item");
+
+ return MEDIA_INFO_ERROR_DATABASE_INTERNAL;
+ }
+
+ return MEDIA_INFO_ERROR_NONE;
+}
+int _media_svc_get_thumbnail_path_by_path(sqlite3 *handle, const char *path, char *thumbnail_path)
+{
+ int ret = MEDIA_INFO_ERROR_NONE;
+ sqlite3_stmt *sql_stmt = NULL;
+
+ char *sql = sqlite3_mprintf("SELECT thumbnail_path FROM %s WHERE path='%q'", MEDIA_SVC_DB_TABLE_MEDIA, path);
+
+ ret = _media_svc_sql_prepare_to_step(handle, sql, &sql_stmt);
+
+ if (ret != MEDIA_INFO_ERROR_NONE) {
+ if(ret == MEDIA_INFO_ERROR_DATABASE_NO_RECORD) {
+ media_svc_debug("there is no thumbnail.");
+ }
+ else {
+ media_svc_error("error when _media_svc_get_thumbnail_path_by_path. err = [%d]", ret);
+ }
+ return ret;
+ }
+
+ _strncpy_safe(thumbnail_path, (const char *)sqlite3_column_text(sql_stmt, 0), MEDIA_SVC_PATHNAME_SIZE);
+
+ SQLITE3_FINALIZE(sql_stmt);
+
+ return MEDIA_INFO_ERROR_NONE;
+}
+
+int _media_svc_get_media_type_by_path(sqlite3 *handle, const char *path, int *media_type)
+{
+ int ret = MEDIA_INFO_ERROR_NONE;
+ sqlite3_stmt *sql_stmt = NULL;
+
+ char *sql = sqlite3_mprintf("SELECT media_type FROM %s WHERE path='%q'", MEDIA_SVC_DB_TABLE_MEDIA, path);
+
+ ret = _media_svc_sql_prepare_to_step(handle, sql, &sql_stmt);
+
+ if (ret != MEDIA_INFO_ERROR_NONE) {
+ media_svc_error("error when _media_svc_get_media_type_by_path. err = [%d]", ret);
+ return ret;
+ }
+
+ *media_type = sqlite3_column_int(sql_stmt, 0);
+
+ SQLITE3_FINALIZE(sql_stmt);
+
+ return MEDIA_INFO_ERROR_NONE;
+}
+
+int _media_svc_delete_item_by_path(sqlite3 *handle, const char *path)
+{
+ int err = -1;
+ char *sql = sqlite3_mprintf("DELETE FROM %s WHERE validity=1 AND path='%q'", MEDIA_SVC_DB_TABLE_MEDIA, path);
+
+ err = _media_svc_sql_query(handle, sql);
+ sqlite3_free(sql);
+ if (err != SQLITE_OK) {
+ media_svc_error("It failed to delete item (%d)", err);
+ return MEDIA_INFO_ERROR_DATABASE_INTERNAL;
+ }
+
+ return MEDIA_INFO_ERROR_NONE;
+}
+
+int _media_svc_truncate_table(sqlite3 *handle, media_svc_storage_type_e storage_type)
+{
+ int err = -1;
+ char *sql = sqlite3_mprintf("DELETE FROM %s WHERE storage_type=%d", MEDIA_SVC_DB_TABLE_MEDIA, storage_type);
+
+ err = _media_svc_sql_query(handle, sql);
+ sqlite3_free(sql);
+ if (err != SQLITE_OK) {
+ media_svc_error("It failed to truncate table (%d)", err);
+ return MEDIA_INFO_ERROR_DATABASE_INTERNAL;
+ }
+
+ return MEDIA_INFO_ERROR_NONE;
+
+}
+
+int _media_svc_delete_invalid_items(sqlite3 *handle, media_svc_storage_type_e storage_type)
+{
+ int idx = 0;
+ media_svc_thumbnailpath_s *thumbpath_record = NULL;
+ int err = -1;
+ int invalid_count = 0;
+ int ret = MEDIA_INFO_ERROR_NONE;
+
+ ret = __media_svc_count_invalid_records_with_thumbnail(handle, storage_type, &invalid_count);
+ media_svc_retv_if(ret != MEDIA_INFO_ERROR_NONE, ret);
+
+ media_svc_debug("invalid count: %d\n", invalid_count);
+
+ if (invalid_count > 0) {
+ thumbpath_record = (media_svc_thumbnailpath_s *)calloc( invalid_count, sizeof(media_svc_thumbnailpath_s));
+ if (thumbpath_record == NULL) {
+ media_svc_error("fail to memory allocation");
+ return MEDIA_INFO_ERROR_OUT_OF_MEMORY;
+ }
+
+ ret = __media_svc_get_invalid_records_with_thumbnail(handle, storage_type, invalid_count, thumbpath_record);
+ if (ret != MEDIA_INFO_ERROR_NONE) {
+ media_svc_error("error when get thumbnail record");
+ SAFE_FREE(thumbpath_record);
+ return ret;
+ }
+ } else {
+ media_svc_debug("There is no item with thumbnail");
+ }
+
+ char *sql = sqlite3_mprintf("DELETE FROM %s WHERE validity = 0 AND storage_type=%d", MEDIA_SVC_DB_TABLE_MEDIA, storage_type);
+ err = _media_svc_sql_query(handle, sql);
+ sqlite3_free(sql);
+ if (err != SQLITE_OK) {
+ media_svc_error("To delete invalid items is failed(%d)", err);
+ SAFE_FREE(thumbpath_record);
+ return MEDIA_INFO_ERROR_DATABASE_INTERNAL;
+ }
+
+ /*Delete thumbnails*/
+ for (idx = 0; idx < invalid_count; idx++) {
+ if (strlen(thumbpath_record[idx].thumbnail_path) > 0) {
+ if (_media_svc_remove_file(thumbpath_record[idx].thumbnail_path) == FALSE) {
+ media_svc_error("fail to remove thumbnail file.");
+ //SAFE_FREE(thumbpath_record);
+ //return MEDIA_INFO_ERROR_INTERNAL;
+ }
+ }
+ }
+
+ SAFE_FREE(thumbpath_record);
+
+ return MEDIA_INFO_ERROR_NONE;
+}
+
+int _media_svc_delete_invalid_folder_items(sqlite3 *handle, const char *folder_path)
+{
+ int idx = 0;
+ media_svc_thumbnailpath_s *thumbpath_record = NULL;
+ int err = -1;
+ int invalid_count = 0;
+ int ret = MEDIA_INFO_ERROR_NONE;
+
+ ret = __media_svc_count_invalid_folder_records_with_thumbnail(handle, folder_path, &invalid_count);
+ media_svc_retv_if(ret != MEDIA_INFO_ERROR_NONE, ret);
+
+ media_svc_debug("invalid count: %d\n", invalid_count);
+
+ if (invalid_count > 0) {
+ thumbpath_record = (media_svc_thumbnailpath_s *)calloc( invalid_count, sizeof(media_svc_thumbnailpath_s));
+ if (thumbpath_record == NULL) {
+ media_svc_error("fail to memory allocation");
+ return MEDIA_INFO_ERROR_OUT_OF_MEMORY;
+ }
+
+ ret = __media_svc_get_invalid_folder_records_with_thumbnail(handle, folder_path, invalid_count, thumbpath_record);
+ if (ret != MEDIA_INFO_ERROR_NONE) {
+ media_svc_error("error when get thumbnail record");
+ SAFE_FREE(thumbpath_record);
+ return ret;
+ }
+ } else {
+ media_svc_debug("There is no item with thumbnail");
+ }
+
+ char *sql = sqlite3_mprintf("DELETE FROM %s WHERE validity = 0 AND path LIKE '%q/%%'", MEDIA_SVC_DB_TABLE_MEDIA, folder_path);
+ err = _media_svc_sql_query(handle, sql);
+ sqlite3_free(sql);
+ if (err != SQLITE_OK) {
+ media_svc_error("To delete invalid items is failed(%d)", err);
+ SAFE_FREE(thumbpath_record);
+ return MEDIA_INFO_ERROR_DATABASE_INTERNAL;
+ }
+
+ /*Delete thumbnails*/
+ for (idx = 0; idx < invalid_count; idx++) {
+ if (strlen(thumbpath_record[idx].thumbnail_path) > 0) {
+ if (_media_svc_remove_file(thumbpath_record[idx].thumbnail_path) == FALSE) {
+ media_svc_error("fail to remove thumbnail file [%s].", thumbpath_record[idx].thumbnail_path);
+ //SAFE_FREE(thumbpath_record);
+ //return MEDIA_INFO_ERROR_INTERNAL;
+ }
+ }
+ }
+
+ SAFE_FREE(thumbpath_record);
+
+ return MEDIA_INFO_ERROR_NONE;
+}
+
+
+int _media_svc_update_item_validity(sqlite3 *handle, const char *path, int validity, bool stack_query)
+{
+ int err = -1;
+
+ char *sql = sqlite3_mprintf("UPDATE %s SET validity=%d WHERE path= '%q'", MEDIA_SVC_DB_TABLE_MEDIA, validity, path);
+
+ if(!stack_query) {
+ err = _media_svc_sql_query(handle, sql);
+ sqlite3_free(sql);
+ if (err != SQLITE_OK) {
+ media_svc_error("To update item as valid is failed(%d)", err);
+ return MEDIA_INFO_ERROR_DATABASE_INTERNAL;
+ }
+ } else {
+ _media_svc_sql_query_add(&g_media_svc_item_validity_query_list, &sql);
+ }
+
+ return MEDIA_INFO_ERROR_NONE;
+}
+
+int _media_svc_update_thumbnail_path(sqlite3 *handle, const char *path, const char *thumb_path)
+{
+ int err = -1;
+
+ char *sql = sqlite3_mprintf("UPDATE %s SET thumbnail_path=%Q WHERE path= %Q", MEDIA_SVC_DB_TABLE_MEDIA, thumb_path, path);
+
+ err = _media_svc_sql_query(handle, sql);
+ sqlite3_free(sql);
+ if (err != SQLITE_OK) {
+ media_svc_error("To update thumb path failed(%d)", err);
+ return MEDIA_INFO_ERROR_DATABASE_INTERNAL;
+ }
+
+ return MEDIA_INFO_ERROR_NONE;
+}
+
+int _media_svc_update_storage_item_validity(sqlite3 *handle, media_svc_storage_type_e storage_type, int validity)
+{
+ int err = -1;
+ char *sql = sqlite3_mprintf("UPDATE %s SET validity=%d WHERE storage_type=%d", MEDIA_SVC_DB_TABLE_MEDIA, validity, storage_type);
+ err = _media_svc_sql_query(handle, sql);
+ sqlite3_free(sql);
+ if (err != SQLITE_OK) {
+ media_svc_error("To update item as valid is failed(%d)", err);
+ return MEDIA_INFO_ERROR_DATABASE_INTERNAL;
+ }
+
+ return MEDIA_INFO_ERROR_NONE;
+}
+
+int _media_svc_update_folder_item_validity(sqlite3 *handle, const char *folder_path, int validity)
+{
+ int err = -1;
+ int ret = MEDIA_INFO_ERROR_NONE;
+ char *sql = NULL;
+ char folder_uuid[MEDIA_SVC_UUID_SIZE + 1] = {0, };
+ sqlite3_stmt *sql_stmt = NULL;
+
+ /*Get folder ID*/
+ sql = sqlite3_mprintf("SELECT folder_uuid FROM %s WHERE path='%q'", MEDIA_SVC_DB_TABLE_FOLDER, folder_path);
+ ret = _media_svc_sql_prepare_to_step(handle, sql, &sql_stmt);
+ if (ret != MEDIA_INFO_ERROR_NONE) {
+ media_svc_error("error when get folder_id. err = [%d]", ret);
+ return ret;
+ }
+
+ _strncpy_safe(folder_uuid, (const char *)sqlite3_column_text(sql_stmt, 0), MEDIA_SVC_UUID_SIZE+1);
+ SQLITE3_FINALIZE(sql_stmt);
+
+ /*Update folder item validity*/
+ sql = sqlite3_mprintf("UPDATE %s SET validity=%d WHERE folder_uuid='%q'", MEDIA_SVC_DB_TABLE_MEDIA, validity, folder_uuid);
+ err = _media_svc_sql_query(handle, sql);
+ sqlite3_free(sql);
+ if (err != SQLITE_OK) {
+ media_svc_error("To update folder item as valid is failed(%d)", err);
+ return MEDIA_INFO_ERROR_DATABASE_INTERNAL;
+ }
+
+ return MEDIA_INFO_ERROR_NONE;
+}
+
+int _media_svc_update_recursive_folder_item_validity(sqlite3 *handle, const char *folder_path, int validity)
+{
+ int err = -1;
+
+ /*Update folder item validity*/
+ char *sql = sqlite3_mprintf("UPDATE %s SET validity=%d WHERE path LIKE '%q/%%'", MEDIA_SVC_DB_TABLE_MEDIA, validity, folder_path);
+ err = _media_svc_sql_query(handle, sql);
+ sqlite3_free(sql);
+ if (err != SQLITE_OK) {
+ media_svc_error("To update recursive folder item validity is failed(%d)", err);
+ return MEDIA_INFO_ERROR_DATABASE_INTERNAL;
+ }
+
+ return MEDIA_INFO_ERROR_NONE;
+}
+
+int _media_svc_update_item_by_path(sqlite3 *handle, const char *src_path, media_svc_storage_type_e dest_storage, const char *dest_path,
+ const char *file_name, int modified_time, const char *folder_uuid, const char *thumb_path, bool stack_query)
+{
+ /* update path, filename, modified_time, folder_uuid, thumbnail_path, */
+ /* played_count, last_played_time, last_played_position, favourite, storaget_type*/
+
+ int err = -1;
+ char *sql = NULL;
+
+ if(thumb_path != NULL) {
+ sql = sqlite3_mprintf("UPDATE %s SET \
+ path=%Q, file_name=%Q, modified_time=%d, folder_uuid=%Q, thumbnail_path=%Q, storage_type=%d, \
+ played_count=0, last_played_time=0, last_played_position=0 \
+ WHERE path=%Q",
+ MEDIA_SVC_DB_TABLE_MEDIA, dest_path, file_name, modified_time, folder_uuid, thumb_path, dest_storage, src_path);
+ } else {
+ sql = sqlite3_mprintf("UPDATE %s SET \
+ path=%Q, file_name=%Q, modified_time=%d, folder_uuid=%Q, storage_type=%d, \
+ played_count=0, last_played_time=0, last_played_position=0 \
+ WHERE path=%Q",
+ MEDIA_SVC_DB_TABLE_MEDIA, dest_path, file_name, modified_time, folder_uuid, dest_storage, src_path);
+ }
+
+ if(!stack_query) {
+ err = _media_svc_sql_query(handle, sql);
+ sqlite3_free(sql);
+ if (err != SQLITE_OK) {
+ media_svc_error("It failed to update metadata (%d)", err);
+ return MEDIA_INFO_ERROR_DATABASE_INTERNAL;
+ }
+ } else {
+ _media_svc_sql_query_add(&g_media_svc_move_item_query_list, &sql);
+ }
+
+ return MEDIA_INFO_ERROR_NONE;
+}
+
+int _media_svc_list_query_do(sqlite3 *handle, media_svc_query_type_e query_type)
+{
+ int ret = MEDIA_INFO_ERROR_NONE;
+
+ ret = _media_svc_sql_begin_trans(handle);
+ media_svc_retv_if(ret != MEDIA_INFO_ERROR_NONE, ret);
+
+ if (query_type == MEDIA_SVC_QUERY_SET_ITEM_VALIDITY)
+ ret = _media_svc_sql_query_list(handle, &g_media_svc_item_validity_query_list);
+ else if (query_type == MEDIA_SVC_QUERY_MOVE_ITEM)
+ ret = _media_svc_sql_query_list(handle, &g_media_svc_move_item_query_list);
+ else if (query_type == MEDIA_SVC_QUERY_INSERT_ITEM)
+ ret = _media_svc_sql_query_list(handle, &g_media_svc_insert_item_query_list);
+ else
+ ret = MEDIA_INFO_ERROR_INVALID_PARAMETER;
+
+ if (ret != MEDIA_INFO_ERROR_NONE) {
+ media_svc_error("_media_svc_list_query_do failed. start rollback");
+ _media_svc_sql_rollback_trans(handle);
+ return ret;
+ }
+
+ ret = _media_svc_sql_end_trans(handle);
+ if (ret != MEDIA_INFO_ERROR_NONE) {
+ media_svc_error("mb_svc_sqlite3_commit_trans failed.. Now start to rollback\n");
+ _media_svc_sql_rollback_trans(handle);
+ return ret;
+ }
+
+ return MEDIA_INFO_ERROR_NONE;
+}
+
+int _media_svc_get_media_id_by_path(sqlite3 *handle, const char *path, char *media_uuid, int max_length)
+{
+ int ret = MEDIA_INFO_ERROR_NONE;
+ sqlite3_stmt *sql_stmt = NULL;
+ char *sql = sqlite3_mprintf("SELECT media_uuid FROM %s WHERE validity=1 AND path='%q'",
+ MEDIA_SVC_DB_TABLE_MEDIA, path);
+
+ ret = _media_svc_sql_prepare_to_step(handle, sql, &sql_stmt);
+
+ if (ret != MEDIA_INFO_ERROR_NONE) {
+ media_svc_error("error when __media_svc_count_invalid_records_with_thumbnail. err = [%d]", ret);
+ return ret;
+ }
+
+ strncpy(media_uuid, (const char*)sqlite3_column_text(sql_stmt, 0), max_length);
+ media_uuid[max_length - 1] = '\0';
+
+ SQLITE3_FINALIZE(sql_stmt);
+
+ return MEDIA_INFO_ERROR_NONE;
+
+}
--- /dev/null
+/*
+ * libmedia-service
+ *
+ * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
+ *
+ * Contact: Hyunjun Ko <zzoon.ko@samsung.com>, Haejeong Kim <backto.kim@samsung.com>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+#include <unistd.h>
+#include <stdlib.h>
+#include <time.h>
+#include <string.h>
+#include <sys/vfs.h>
+#include <glib/gstdio.h>
+#include <sys/stat.h>
+#include <string.h>
+#include <dirent.h>
+#include <ctype.h>
+#include <errno.h>
+#include <drm_client.h>
+#include <mm_file.h>
+#include <mm_error.h>
+#include <libexif/exif-data.h>
+#include <media-thumbnail.h>
+#include <media-util.h>
+#include "uuid.h"
+#include "media-svc-util.h"
+#include "media-svc-error.h"
+#include "media-svc-debug.h"
+#include "media-svc-env.h"
+#include "media-svc-hash.h"
+#include "media-svc-album.h"
+
+
+#define MEDIA_SVC_FILE_EXT_LEN_MAX 6 /**< Maximum file ext lenth*/
+
+typedef enum {
+ MEDIA_SVC_EXTRACTED_FIELD_NONE = 0x00000001,
+ MEDIA_SVC_EXTRACTED_FIELD_TITLE = MEDIA_SVC_EXTRACTED_FIELD_NONE << 1,
+ MEDIA_SVC_EXTRACTED_FIELD_DESC = MEDIA_SVC_EXTRACTED_FIELD_NONE << 2,
+ MEDIA_SVC_EXTRACTED_FIELD_COPYRIGHT = MEDIA_SVC_EXTRACTED_FIELD_NONE << 3,
+ MEDIA_SVC_EXTRACTED_FIELD_AUTHOR = MEDIA_SVC_EXTRACTED_FIELD_NONE << 4,
+ MEDIA_SVC_EXTRACTED_FIELD_ARTIST = MEDIA_SVC_EXTRACTED_FIELD_NONE << 5,
+ MEDIA_SVC_EXTRACTED_FIELD_GENRE = MEDIA_SVC_EXTRACTED_FIELD_NONE << 6,
+ MEDIA_SVC_EXTRACTED_FIELD_ALBUM = MEDIA_SVC_EXTRACTED_FIELD_NONE << 7,
+ MEDIA_SVC_EXTRACTED_FIELD_TRACKNUM = MEDIA_SVC_EXTRACTED_FIELD_NONE << 8,
+ MEDIA_SVC_EXTRACTED_FIELD_YEAR = MEDIA_SVC_EXTRACTED_FIELD_NONE << 9,
+ MEDIA_SVC_EXTRACTED_FIELD_CATEGORY = MEDIA_SVC_EXTRACTED_FIELD_NONE << 10,
+} media_svc_extracted_field_e;
+
+#if 0
+static char *__year_2_str(int year);
+
+static char *__year_2_str(int year)
+{
+ static char ret[MEDIA_SVC_METADATA_LEN_MAX];
+
+ if (year == -1 || year == 0) {
+ _strncpy_safe(ret, MEDIA_SVC_TAG_UNKNOWN, MEDIA_SVC_METADATA_LEN_MAX);
+ } else {
+ snprintf(ret, MEDIA_SVC_METADATA_LEN_MAX - 1, "%d", year);
+ }
+ return ret;
+}
+#endif
+
+char *_media_info_generate_uuid(void)
+{
+ uuid_t uuid_value;
+ static char uuid_unparsed[50];
+
+ uuid_generate(uuid_value);
+ uuid_unparse(uuid_value, uuid_unparsed);
+
+ //media_svc_debug("UUID : %s", uuid_unparsed);
+ return uuid_unparsed;
+}
+
+void _strncpy_safe(char *x_dst, const char *x_src, int max_len)
+{
+ if (!x_src || strlen(x_src) == 0) {
+ media_svc_error("x_src is NULL");
+ return;
+ }
+
+ if (max_len < 1) {
+ media_svc_error("length is Wrong");
+ return;
+ }
+
+ strncpy(x_dst, x_src, max_len-1);
+ x_dst[max_len-1] = '\0';
+}
+
+int __media_svc_malloc_and_strncpy(char **dst, const char *src)
+{
+ int len = 0;
+
+ if (!STRING_VALID(src)) {
+ media_svc_error("invalid src");
+ return MEDIA_INFO_ERROR_INVALID_PARAMETER;
+ }
+
+ SAFE_FREE(*dst);
+
+ len = strlen(src) + 1;
+ *dst = malloc(len);
+
+ if (*dst == NULL) {
+ media_svc_error("malloc failed");
+ return MEDIA_INFO_ERROR_INTERNAL;
+ }
+
+ strncpy(*dst, src, len);
+ char *p = *dst;
+ p[len - 1] = '\0';
+
+ return MEDIA_INFO_ERROR_NONE;
+}
+
+static void __media_svc_split_to_double(char *input, double *arr, int *num)
+{
+ char tmp_arr[255] = { 0, };
+ int len = strlen(input);
+ int i = 0, idx = 0, tmp_idx = 0;
+ int is_prev_space = 0;
+
+ for (;;) {
+ if (input[len - 1] == ' ') {
+ len--;
+ } else {
+ break;
+ }
+ }
+
+ for (i = 0; i < len; i++) {
+ if (idx > 2) {
+ break;
+ }
+
+ if (input[i] == ' ') {
+ if (is_prev_space == 1) {
+ continue;
+ }
+ if (idx <= 2) {
+ arr[idx++] = atof(tmp_arr);
+ }
+ tmp_idx = 0;
+ is_prev_space = 1;
+ continue;
+ }
+
+ tmp_arr[tmp_idx] = input[i];
+ tmp_arr[++tmp_idx] = '\0';
+ is_prev_space = 0;
+ }
+
+ if (i == len) {
+ if (idx <= 2) {
+ arr[idx++] = atof(tmp_arr);
+ }
+ *num = idx;
+ return;
+ } else {
+ *num = idx--;
+ return;
+ }
+}
+
+static int __media_svc_get_exif_info(ExifData *ed,
+ char *buf,
+ int *i_value,
+ double *d_value,
+ int ifdtype,
+ long tagtype)
+{
+ ExifEntry *entry;
+ ExifIfd ifd;
+ ExifTag tag;
+
+ if (ed == NULL) {
+ //media_svc_debug("ExifData is NULL");
+ return MEDIA_INFO_ERROR_INVALID_PARAMETER;
+ }
+
+ ifd = ifdtype;
+ tag = tagtype;
+
+ entry = exif_data_get_entry(ed, tag);
+ if (entry) {
+ /* Get the contents of the tag in human-readable form */
+ if (tag == EXIF_TAG_ORIENTATION ||
+ tag == EXIF_TAG_PIXEL_X_DIMENSION ||
+ tag == EXIF_TAG_PIXEL_Y_DIMENSION) {
+
+ if (i_value == NULL) {
+ media_svc_error("i_value is NULL");
+ return MEDIA_INFO_ERROR_INVALID_PARAMETER;
+ }
+
+ ExifByteOrder mByteOrder = exif_data_get_byte_order(ed);
+ short exif_value = exif_get_short(entry->data, mByteOrder);
+ //media_svc_debug("%s : %d", exif_tag_get_name_in_ifd(tag,ifd), exif_value);
+ *i_value = (int)exif_value;
+
+ } else if (tag == EXIF_TAG_GPS_LATITUDE || tag == EXIF_TAG_GPS_LONGITUDE || tag == EXIF_TAG_GPS_ALTITUDE) {
+
+ if (d_value == NULL) {
+ media_svc_error("d_value is NULL");
+ return MEDIA_INFO_ERROR_INVALID_PARAMETER;
+ }
+
+ /* Get the contents of the tag in human-readable form */
+ char gps_buf[MEDIA_SVC_METADATA_LEN_MAX + 1] = { '\0' };
+ exif_entry_get_value(entry, gps_buf, sizeof(gps_buf));
+ gps_buf[strlen(gps_buf)] = '\0';
+
+ //media_svc_debug("%s: %s\n", exif_tag_get_name_in_ifd(tag, ifd), gps_buf);
+
+ double tmp_arr[3] = { 0.0, 0.0, 0.0 };
+ int count = 0;
+
+ __media_svc_split_to_double(gps_buf, tmp_arr, &count);
+ if (count != 3) {
+ media_svc_error("Value is invalid");
+ return MEDIA_INFO_ERROR_INTERNAL;
+ }
+
+ *d_value = tmp_arr[0] + tmp_arr[1] / 60 + tmp_arr[2] / 3600;
+ //media_svc_debug("GPS value is %f", *d_value);
+ } else {
+
+ if (buf == NULL) {
+ media_svc_error("buf is NULL");
+ return MEDIA_INFO_ERROR_INVALID_PARAMETER;
+ }
+
+ exif_entry_get_value(entry, buf, MEDIA_SVC_METADATA_LEN_MAX);
+ buf[strlen(buf)] = '\0';
+
+ if (*buf) {
+ media_svc_debug("%s: %s\n", exif_tag_get_name_in_ifd(tag, ifd), buf);
+ }
+ }
+ }
+
+ return MEDIA_INFO_ERROR_NONE;
+}
+
+unsigned int _media_svc_get_current_time(void)
+{
+ struct timeval t;
+ unsigned int tval = 0;
+ gettimeofday(&t, NULL);
+
+ tval = t.tv_sec*1000000L + t.tv_usec;
+
+ return tval/1000;
+}
+
+int _media_svc_check_escape_char(char ch)
+{
+ int i;
+ char escape_char[3] = {'%', '_' ,'#'};
+
+ for (i = 0; i < 3; i++) {
+ if (ch == escape_char[i]) {
+ return 1;
+ }
+ }
+
+ return 0;
+}
+
+char *_media_svc_escape_str(char *input, int len)
+{
+ int i = 0;
+ int j = 0;
+ char *result = NULL;
+
+ result = (char*)malloc(len * 2 * sizeof(char) + 1);
+ if (result == NULL) {
+ return NULL;
+ }
+
+ for (i = 0; i < len; i++, j++) {
+ if (input[i] == '\0') break;
+
+ if (_media_svc_check_escape_char(input[i])) {
+ result[j] = '#';
+ result[++j] = input[i];
+ } else {
+ result[j] = input[i];
+ }
+ }
+
+ result[j] = '\0';
+
+ return result;
+}
+
+int _media_svc_rename_file( const char *old_name, const char *new_name)
+{
+ if((old_name == NULL) || (new_name == NULL))
+ {
+ media_svc_error("invalid file name");
+ return MEDIA_INFO_ERROR_INVALID_PARAMETER;
+ }
+
+ if (rename(old_name, new_name) < 0) {
+ media_svc_error("Old : [%s] New : [%s] errno : [%s]", old_name, new_name, strerror(errno));
+ return MEDIA_INFO_ERROR_INTERNAL;
+ }
+
+ return MEDIA_INFO_ERROR_NONE;
+}
+
+bool _media_svc_remove_file(const char *path)
+{
+ int result = -1;
+
+ result = remove(path);
+ if (result == 0) {
+ media_svc_debug("success to remove file");
+ return TRUE;
+ } else {
+ media_svc_error("fail to remove file result errno = %s", strerror(errno));
+ return FALSE;
+ }
+}
+
+int _media_svc_remove_all_files_in_dir(const char *dir_path)
+{
+ struct dirent *entry = NULL;
+ struct stat st;
+ char filename[MEDIA_SVC_PATHNAME_SIZE] = {0};
+ DIR *dir = NULL;
+
+ dir = opendir(dir_path);
+ if (dir == NULL) {
+ media_svc_error("%s is not exist", dir_path);
+ return MEDIA_INFO_ERROR_INVALID_PARAMETER;
+ }
+
+ while ((entry = readdir(dir)) != NULL) {
+ if (strcmp(entry->d_name, ".") == 0 || strcmp(entry->d_name, "..") == 0) {
+ continue;
+ }
+ snprintf(filename, sizeof(filename), "%s/%s", dir_path, entry->d_name);
+
+ if (stat(filename, &st) != 0) {
+ continue;
+ }
+ if (S_ISDIR(st.st_mode)) {
+ continue;
+ }
+ if (unlink(filename) != 0) {
+ media_svc_error("failed to remove : %s", filename);
+ closedir(dir);
+ return MEDIA_INFO_ERROR_INTERNAL;
+ }
+ }
+
+ closedir(dir);
+ return MEDIA_INFO_ERROR_NONE;
+}
+
+char *_media_svc_get_title_from_filepath (const char *path)
+{
+ char *filename = NULL;
+ char *title = NULL;
+ char *ext = NULL;
+ int filename_len = -1;
+ int new_title_len = -1;
+
+ if (!path) {
+ media_svc_error("path is NULL");
+ return NULL;
+ }
+
+ filename = g_path_get_basename(path);
+ if (!STRING_VALID(filename)) {
+ media_svc_error("wrong file name");
+ SAFE_FREE(filename);
+ return NULL;
+ }
+
+ filename_len = strlen(filename);
+
+ ext = g_strrstr(filename, ".");
+ if (!ext) {
+ media_svc_error("there is no file extention");
+ return filename;
+ }
+
+ new_title_len = filename_len - strlen(ext);
+ if (new_title_len < 1) {
+ media_svc_error("title length is zero");
+ SAFE_FREE(filename);
+ return NULL;
+ }
+
+ title = g_strndup(filename, new_title_len < MEDIA_SVC_PATHNAME_SIZE ? new_title_len : MEDIA_SVC_PATHNAME_SIZE-1);
+
+ SAFE_FREE(filename);
+
+ media_svc_debug("extract title is [%s]", title);
+
+ return title;
+}
+
+int _media_svc_save_image(void *image, int size, char *image_path)
+{
+ media_svc_debug("start save image, path [%s] image size [%d]", image_path, size);
+
+ if (!image) {
+ media_svc_error("invalid image..");
+ return MEDIA_INFO_ERROR_INVALID_PARAMETER;
+ }
+
+ struct statfs fs;
+ if (-1 == statfs(MEDIA_SVC_THUMB_PATH_PREFIX, &fs)) {
+ media_svc_error("error in statfs");
+ return MEDIA_INFO_ERROR_INTERNAL;
+ }
+
+ long bsize_kbytes = fs.f_bsize >> 10;
+
+ if ((bsize_kbytes * fs.f_bavail) < 1024) {
+ media_svc_error("not enought space...");
+ return MEDIA_INFO_ERROR_INTERNAL;
+ }
+
+ FILE *fp = NULL;
+ int nwrite = -1;
+ if (image != NULL && size > 0) {
+ fp = fopen(image_path, "w");
+
+ if (fp == NULL) {
+ media_svc_error("failed to open file");
+ return MEDIA_INFO_ERROR_INTERNAL;
+ }
+
+ nwrite = fwrite(image, 1, size, fp);
+ if (nwrite != size) {
+ media_svc_error("failed to write thumbnail");
+ fclose(fp);
+ return MEDIA_INFO_ERROR_INTERNAL;
+ }
+ fclose(fp);
+ }
+
+ return MEDIA_INFO_ERROR_NONE;
+}
+
+bool _media_svc_get_thumbnail_path(media_svc_storage_type_e storage_type, char *thumb_path, const char *pathname, const char *img_format)
+{
+ char savename[MEDIA_SVC_PATHNAME_SIZE] = {0};
+ char file_ext[MEDIA_SVC_FILE_EXT_LEN_MAX + 1] = {0};
+ char *thumb_dir = NULL;
+ char hash[255 + 1];
+ char *thumbfile_ext = NULL;
+
+ thumb_dir = (storage_type == MEDIA_SVC_STORAGE_INTERNAL) ? MEDIA_SVC_THUMB_INTERNAL_PATH : MEDIA_SVC_THUMB_EXTERNAL_PATH;
+
+ memset(file_ext, 0, sizeof(file_ext));
+ if (!_media_svc_get_file_ext(pathname, file_ext)) {
+ media_svc_error("get file ext fail");
+ }
+
+ int err = -1;
+ err = mb_svc_generate_hash_code(pathname, hash, sizeof(hash));
+ if (err < 0) {
+ media_svc_error("mb_svc_generate_hash_code failed : %d", err);
+ return FALSE;
+ }
+
+ //media_svc_debug("img format is [%s]", img_format);
+
+ if((strstr(img_format, "jpeg") != NULL) ||(strstr(img_format, "jpg") != NULL) ||(strstr(img_format, "JPG") != NULL)) {
+ thumbfile_ext = "jpg";
+ } else if((strstr(img_format, "png") != NULL) ||(strstr(img_format, "PNG") != NULL)) {
+ thumbfile_ext = "png";
+ } else if((strstr(img_format, "gif") != NULL) ||(strstr(img_format, "GIF") != NULL)) {
+ thumbfile_ext = "gif";
+ } else if((strstr(img_format, "bmp") != NULL) ||(strstr(img_format, "BMP") != NULL)) {
+ thumbfile_ext = "bmp";
+ } else {
+ media_svc_error("Not proper img format");
+ return FALSE;
+ }
+
+ snprintf(savename, sizeof(savename), "%s/.%s-%s.%s", thumb_dir, file_ext, hash, thumbfile_ext);
+ _strncpy_safe(thumb_path, savename, MEDIA_SVC_PATHNAME_SIZE);
+ //media_svc_debug("thumb_path is [%s]", thumb_path);
+
+ return TRUE;
+}
+
+bool _media_svc_get_file_ext(const char *file_path, char *file_ext)
+{
+ int i = 0;
+
+ for (i = strlen(file_path); i >= 0; i--) {
+ if (file_path[i] == '.') {
+ _strncpy_safe(file_ext, &file_path[i+1], MEDIA_SVC_FILE_EXT_LEN_MAX);
+ return true;
+ }
+
+ if (file_path[i] == '/') {
+ return false;
+ }
+ }
+ return false;
+}
+
+int _media_svc_get_file_time(const char *full_path)
+{
+ struct stat statbuf;
+ int fd = 0;
+
+ memset(&statbuf, 0, sizeof(struct stat));
+ fd = stat(full_path, &statbuf);
+ if (fd == -1) {
+ media_svc_error("stat(%s) fails.", full_path);
+ return MEDIA_INFO_ERROR_INTERNAL;
+ }
+
+ return statbuf.st_mtime;
+}
+
+int _media_svc_set_media_info(media_svc_content_info_s *content_info, media_svc_storage_type_e storage_type,
+ const char *path, const char *mime_type, media_svc_media_type_e media_type, bool refresh)
+{
+ int ret = MEDIA_INFO_ERROR_NONE;
+ char * media_uuid = NULL;
+ char * file_name = NULL;
+ struct stat st;
+ drm_bool_type_e drm_type;
+
+ ret = __media_svc_malloc_and_strncpy(&content_info->path, path);
+ media_svc_retv_del_if(ret != MEDIA_INFO_ERROR_NONE, ret, content_info);
+
+ memset(&st, 0, sizeof(struct stat));
+ if (stat(path, &st) == 0) {
+ content_info->modified_time = st.st_mtime;
+ content_info->size = st.st_size;
+ //media_svc_debug("Modified time : [%d] Size : [%lld]", content_info->modified_time, content_info->size);
+ } else {
+ media_svc_error("stat failed : %s", strerror(errno));
+ }
+
+ /* Set default GPS value before extracting meta information */
+ content_info->media_meta.longitude = MEDIA_SVC_DEFAULT_GPS_VALUE;
+ content_info->media_meta.latitude = MEDIA_SVC_DEFAULT_GPS_VALUE;
+ content_info->media_meta.altitude = MEDIA_SVC_DEFAULT_GPS_VALUE;
+
+ /* Set default value before extracting meta information */
+ ret = __media_svc_malloc_and_strncpy(&content_info->media_meta.title, MEDIA_SVC_TAG_UNKNOWN);
+ media_svc_retv_del_if(ret != MEDIA_INFO_ERROR_NONE, ret, content_info);
+
+ ret = __media_svc_malloc_and_strncpy(&content_info->media_meta.description, MEDIA_SVC_TAG_UNKNOWN);
+ media_svc_retv_del_if(ret != MEDIA_INFO_ERROR_NONE, ret, content_info);
+
+ ret = __media_svc_malloc_and_strncpy(&content_info->media_meta.copyright, MEDIA_SVC_TAG_UNKNOWN);
+ media_svc_retv_del_if(ret != MEDIA_INFO_ERROR_NONE, ret, content_info);
+
+ ret = __media_svc_malloc_and_strncpy(&content_info->media_meta.track_num, MEDIA_SVC_TAG_UNKNOWN);
+ media_svc_retv_del_if(ret != MEDIA_INFO_ERROR_NONE, ret, content_info);
+
+ ret = __media_svc_malloc_and_strncpy(&content_info->media_meta.album, MEDIA_SVC_TAG_UNKNOWN);
+ media_svc_retv_del_if(ret != MEDIA_INFO_ERROR_NONE, ret, content_info);
+
+ ret = __media_svc_malloc_and_strncpy(&content_info->media_meta.artist, MEDIA_SVC_TAG_UNKNOWN);
+ media_svc_retv_del_if(ret != MEDIA_INFO_ERROR_NONE, ret, content_info);
+
+ ret = __media_svc_malloc_and_strncpy(&content_info->media_meta.genre, MEDIA_SVC_TAG_UNKNOWN);
+ media_svc_retv_del_if(ret != MEDIA_INFO_ERROR_NONE, ret, content_info);
+
+ ret = __media_svc_malloc_and_strncpy(&content_info->media_meta.composer, MEDIA_SVC_TAG_UNKNOWN);
+ media_svc_retv_del_if(ret != MEDIA_INFO_ERROR_NONE, ret, content_info);
+
+ ret = __media_svc_malloc_and_strncpy(&content_info->media_meta.year, MEDIA_SVC_TAG_UNKNOWN);
+ media_svc_retv_del_if(ret != MEDIA_INFO_ERROR_NONE, ret, content_info);
+
+ /* refresh is TRUE when file modified. so only modified_time and size are changed*/
+ if(refresh) {
+ media_svc_debug("refresh");
+ return MEDIA_INFO_ERROR_NONE;
+ }
+
+ content_info->media_type = media_type;
+ content_info->storage_type = storage_type;
+ time(&content_info->added_time);
+
+ media_uuid = _media_info_generate_uuid();
+ media_svc_retvm_if(media_uuid == NULL, MEDIA_INFO_ERROR_INTERNAL, "Invalid UUID");
+
+ ret = __media_svc_malloc_and_strncpy(&content_info->media_uuid, media_uuid);
+ media_svc_retv_del_if(ret != MEDIA_INFO_ERROR_NONE, ret, content_info);
+
+ ret = __media_svc_malloc_and_strncpy(&content_info->mime_type, mime_type);
+ media_svc_retv_del_if(ret != MEDIA_INFO_ERROR_NONE, ret, content_info);
+
+ file_name = g_path_get_basename(path);
+ ret = __media_svc_malloc_and_strncpy(&content_info->file_name, file_name);
+ SAFE_FREE(file_name);
+ media_svc_retv_del_if(ret != MEDIA_INFO_ERROR_NONE, ret, content_info);
+
+ ret = drm_is_drm_file(content_info->path, &drm_type);
+ if (ret < 0) {
+ media_svc_error("drm_is_drm_file falied : %d", ret);
+ drm_type = DRM_FALSE;
+ }
+
+ content_info->is_drm = drm_type;
+
+ content_info->played_count = 0;
+ content_info->last_played_time= 0;
+ content_info->last_played_position= 0;
+ content_info->favourate= 0;
+ content_info->media_meta.rating = 0;
+
+ return MEDIA_INFO_ERROR_NONE;
+}
+
+int _media_svc_extract_image_metadata(media_svc_content_info_s *content_info, media_svc_media_type_e media_type)
+{
+ if (content_info == NULL || media_type != MEDIA_SVC_MEDIA_TYPE_IMAGE) {
+ media_svc_error("content_info == NULL || media_type != MEDIA_SVC_MEDIA_TYPE_IMAGE");
+ return MEDIA_INFO_ERROR_INVALID_PARAMETER;
+ }
+
+ char buf[MEDIA_SVC_METADATA_LEN_MAX + 1] = { '\0' };
+ char description_buf[MEDIA_SVC_METADATA_DESCRIPTION_MAX + 1] = { '\0' };
+ memset(buf, 0x00, sizeof(buf));
+ memset(description_buf, 0x00, sizeof(description_buf));
+
+ int ret = MEDIA_INFO_ERROR_NONE;
+ double value = 0.0;
+ int orient_value = 0;
+ int exif_width = 0;
+ int exif_height = 0;
+ ExifData *ed = NULL;
+
+ char *path = content_info->path;
+ if (path == NULL) {
+ media_svc_error("path is NULL");
+ return MEDIA_INFO_ERROR_INVALID_PARAMETER;
+ }
+
+ /* Load an ExifData object from an EXIF file */
+ ed = exif_data_new_from_file(path);
+
+ if (!ed) {
+ media_svc_debug("There is no exif data in [ %s ]", path);
+ }
+
+ if (__media_svc_get_exif_info(ed, buf, NULL, NULL, EXIF_IFD_0, EXIF_TAG_GPS_LATITUDE_REF) == MEDIA_INFO_ERROR_NONE) {
+ if (strlen(buf) != 0) {
+ if (__media_svc_get_exif_info(ed, NULL, NULL, &value, EXIF_IFD_GPS, EXIF_TAG_GPS_LATITUDE) == MEDIA_INFO_ERROR_NONE) {
+
+ if (strcmp(buf, "S") == 0) {
+ value = -1 * value;
+ }
+
+ content_info->media_meta.latitude = value;
+ } else {
+ content_info->media_meta.latitude = MEDIA_SVC_DEFAULT_GPS_VALUE;
+ }
+ } else {
+ content_info->media_meta.latitude = MEDIA_SVC_DEFAULT_GPS_VALUE;
+ }
+ } else {
+ content_info->media_meta.latitude = MEDIA_SVC_DEFAULT_GPS_VALUE;
+ }
+
+ memset(buf, 0x00, sizeof(buf));
+
+ if (__media_svc_get_exif_info(ed, buf, NULL, NULL, EXIF_IFD_0, EXIF_TAG_GPS_LONGITUDE_REF) == MEDIA_INFO_ERROR_NONE) {
+ if (strlen(buf) != 0) {
+ if (__media_svc_get_exif_info(ed, NULL, NULL, &value, EXIF_IFD_GPS, EXIF_TAG_GPS_LONGITUDE) == MEDIA_INFO_ERROR_NONE) {
+ if (strcmp(buf, "W") == 0) {
+ value = -1 * value;
+ }
+ content_info->media_meta.longitude = value;
+ } else {
+ content_info->media_meta.longitude = MEDIA_SVC_DEFAULT_GPS_VALUE;
+ }
+ } else {
+ content_info->media_meta.longitude = MEDIA_SVC_DEFAULT_GPS_VALUE;
+ }
+ } else {
+ content_info->media_meta.longitude = MEDIA_SVC_DEFAULT_GPS_VALUE;
+ }
+
+ memset(buf, 0x00, sizeof(buf));
+
+ if (__media_svc_get_exif_info(ed, description_buf, NULL, NULL, EXIF_IFD_0, EXIF_TAG_IMAGE_DESCRIPTION) == MEDIA_INFO_ERROR_NONE) {
+ if (strlen(description_buf) == 0) {
+ //media_svc_debug("Use 'No description'");
+ ret = __media_svc_malloc_and_strncpy(&content_info->media_meta.description, MEDIA_SVC_TAG_UNKNOWN);
+ media_svc_error("strcpy error");
+ } else {
+ ret = __media_svc_malloc_and_strncpy(&content_info->media_meta.description, description_buf);
+ if(ret != MEDIA_INFO_ERROR_NONE)
+ media_svc_error("strcpy error");
+ }
+ } else {
+ ret = __media_svc_malloc_and_strncpy(&content_info->media_meta.description, MEDIA_SVC_TAG_UNKNOWN);
+ if(ret != MEDIA_INFO_ERROR_NONE)
+ media_svc_error("strcpy error");
+ }
+
+ memset(buf, 0x00, sizeof(buf));
+
+ if (__media_svc_get_exif_info(ed, buf, NULL, NULL, EXIF_IFD_0, EXIF_TAG_DATE_TIME) == MEDIA_INFO_ERROR_NONE) {
+ if (strlen(buf) == 0) {
+ //media_svc_debug("time is NULL");
+ } else {
+ //media_svc_debug("time is %s", buf);
+ ret = __media_svc_malloc_and_strncpy(&content_info->media_meta.datetaken, buf);
+ if(ret != MEDIA_INFO_ERROR_NONE)
+ media_svc_error("strcpy error");
+ }
+ }
+
+ /* Get orientation value from exif. */
+ if (__media_svc_get_exif_info(ed, NULL, &orient_value, NULL, EXIF_IFD_0, EXIF_TAG_ORIENTATION) == MEDIA_INFO_ERROR_NONE) {
+ if (orient_value >= NOT_AVAILABLE && orient_value <= ROT_270) {
+ content_info->media_meta.orientation = orient_value;
+ } else {
+ content_info->media_meta.orientation = 0;
+ }
+ } else {
+ content_info->media_meta.orientation = 0;
+ }
+
+ /* Get width value from exif. */
+ if (__media_svc_get_exif_info(ed, NULL, &exif_width, NULL, EXIF_IFD_EXIF, EXIF_TAG_PIXEL_X_DIMENSION) == MEDIA_INFO_ERROR_NONE) {
+ if (exif_width > 0) {
+ content_info->media_meta.width = exif_width;
+ } else {
+ content_info->media_meta.width = 0;
+ }
+ } else {
+ content_info->media_meta.width = 0;
+ }
+
+ /* Get height value from exif. */
+ if (__media_svc_get_exif_info(ed, NULL, &exif_height, NULL, EXIF_IFD_EXIF, EXIF_TAG_PIXEL_Y_DIMENSION) == MEDIA_INFO_ERROR_NONE) {
+ if (exif_height > 0) {
+ content_info->media_meta.height = exif_height;
+ } else {
+ content_info->media_meta.height = 0;
+ }
+ } else {
+ content_info->media_meta.height = 0;
+ }
+
+ if (ed != NULL) exif_data_unref(ed);
+#if 0
+ /* Extracting thumbnail */
+ char thumb_path[MEDIA_SVC_PATHNAME_SIZE + 1] = {0, };
+ int width = 0;
+ int height = 0;
+
+ ret = thumbnail_request_from_db_with_size(content_info->path, thumb_path, sizeof(thumb_path), &width, &height);
+ if (ret < 0) {
+ media_svc_error("thumbnail_request_from_db failed: %d", ret);
+ } else {
+ //media_svc_debug("thumbnail_request_from_db success: %s", thumb_path);
+ }
+
+ content_info->media_meta.width = width;
+ content_info->media_meta.height = height;
+
+ if (STRING_VALID(thumb_path))
+ ret = __media_svc_malloc_and_strncpy(&content_info->thumbnail_path, thumb_path);
+ else
+ content_info->thumbnail_path = NULL;
+
+ if(ret != MEDIA_INFO_ERROR_NONE)
+ media_svc_error("strcpy error");
+#endif
+ return MEDIA_INFO_ERROR_NONE;
+}
+
+int _media_svc_extract_media_metadata(sqlite3 *handle, media_svc_content_info_s *content_info, media_svc_media_type_e media_type)
+{
+ MMHandleType content = 0;
+ MMHandleType tag = 0;
+ char *p = NULL;
+ void *image = NULL;
+ int size = -1;
+ int extracted_field = MEDIA_SVC_EXTRACTED_FIELD_NONE;
+ int mmf_error = MM_ERROR_NONE;
+ bool thumb_extracted_from_drm = FALSE;
+ char *err_attr_name = NULL;
+ char *title = NULL;
+ bool extract_thumbnail = FALSE;
+ bool append_album = FALSE;
+ int album_id = 0;
+ double gps_value = 0.0;
+ int ret = MEDIA_INFO_ERROR_NONE;
+ drm_bool_type_e drm_type;
+ char *path = content_info->path;
+
+ ret = drm_is_drm_file(path, &drm_type);
+ if (ret < 0) {
+ media_svc_error("drm_is_drm_file falied : %d", ret);
+ drm_type = DRM_FALSE;
+ }
+
+ /*To do - code for DRM content*/
+ if (drm_type) {
+ bool invalid_file = FALSE;
+ drm_file_type_e drm_file_type;
+ drm_permission_type_e drm_perm_type = DRM_PERMISSION_TYPE_PLAY;
+ drm_content_info_s contentInfo;
+ drm_license_status_e license_status;
+ memset(&contentInfo, 0x00, sizeof(drm_content_info_s));
+
+ ret = drm_get_file_type(path, &drm_file_type);
+ if (ret < 0) {
+ media_svc_error("drm_get_file_type falied : %d", ret);
+ drm_file_type = DRM_TYPE_UNDEFINED;
+ invalid_file = TRUE;
+ }
+
+ ret = drm_get_content_info(path, &contentInfo);
+ if (ret != DRM_RETURN_SUCCESS) {
+ media_svc_error("drm_get_content_info() fails. : %d", ret);
+ invalid_file = TRUE;
+ }
+
+ ret = drm_get_license_status(path, drm_perm_type, &license_status);
+ if (ret != DRM_RETURN_SUCCESS) {
+ media_svc_error("drm_get_license_status() fails. : %d", ret);
+ invalid_file = TRUE;
+ }
+
+ if ((!invalid_file) && (license_status != DRM_LICENSE_STATUS_VALID)) {
+ invalid_file = TRUE;
+ if (drm_file_type == DRM_TYPE_OMA_V1) {
+
+ if (strlen(contentInfo.title) > 0) {
+ ret = __media_svc_malloc_and_strncpy(&content_info->media_meta.title, contentInfo.title);
+ if(ret != MEDIA_INFO_ERROR_NONE)
+ media_svc_error("strcpy error");
+ extracted_field |= MEDIA_SVC_EXTRACTED_FIELD_TITLE;
+ }
+
+ if (strlen(contentInfo.description) > 0) {
+ ret = __media_svc_malloc_and_strncpy(&content_info->media_meta.description, contentInfo.description);
+ if(ret != MEDIA_INFO_ERROR_NONE)
+ media_svc_error("strcpy error");
+ extracted_field |= MEDIA_SVC_EXTRACTED_FIELD_DESC;
+ }
+ } else if (drm_file_type == DRM_TYPE_OMA_V2) {
+ if (strlen(contentInfo.title) > 0) {
+ ret = __media_svc_malloc_and_strncpy(&content_info->media_meta.title, contentInfo.title);
+ if(ret != MEDIA_INFO_ERROR_NONE)
+ media_svc_error("strcpy error");
+ extracted_field |= MEDIA_SVC_EXTRACTED_FIELD_TITLE;
+ }
+
+ if (strlen(contentInfo.description) > 0) {
+ ret = __media_svc_malloc_and_strncpy(&content_info->media_meta.description, contentInfo.description);
+ if(ret != MEDIA_INFO_ERROR_NONE)
+ media_svc_error("strcpy error");
+ extracted_field |= MEDIA_SVC_EXTRACTED_FIELD_DESC;
+ }
+
+ if (strlen(contentInfo.copyright) > 0) {
+ ret = __media_svc_malloc_and_strncpy(&content_info->media_meta.copyright, contentInfo.copyright);
+ if(ret != MEDIA_INFO_ERROR_NONE)
+ media_svc_error("strcpy error");
+ extracted_field |= MEDIA_SVC_EXTRACTED_FIELD_COPYRIGHT;
+ }
+
+ if (strlen(contentInfo.author) > 0) {
+ ret = __media_svc_malloc_and_strncpy(&content_info->media_meta.composer, contentInfo.author);
+ if(ret != MEDIA_INFO_ERROR_NONE)
+ media_svc_error("strcpy error");
+ ret = __media_svc_malloc_and_strncpy(&content_info->media_meta.artist, contentInfo.author);
+ if(ret != MEDIA_INFO_ERROR_NONE)
+ media_svc_error("strcpy error");
+
+ extracted_field |= MEDIA_SVC_EXTRACTED_FIELD_AUTHOR;
+ extracted_field |= MEDIA_SVC_EXTRACTED_FIELD_ARTIST;
+ }
+ }
+ }
+
+ if (invalid_file) {
+ if (!(extracted_field & MEDIA_SVC_EXTRACTED_FIELD_TITLE)) {
+ title = _media_svc_get_title_from_filepath(path);
+ if (title) {
+ ret = __media_svc_malloc_and_strncpy(&content_info->media_meta.title, title);
+ SAFE_FREE(title);
+ if(ret != MEDIA_INFO_ERROR_NONE)
+ media_svc_error("strcpy error");
+ } else {
+ media_svc_error("Can't extract title from filepath [%s]", content_info->path);
+ }
+ }
+
+ return MEDIA_INFO_ERROR_NONE;
+ }
+ }
+
+#if 0
+ if (drm_svc_is_drm_file(content_info->path)) {
+ bool invalid_file = FALSE;
+
+ DRM_FILE_TYPE type = drm_svc_get_drm_type(content_info->path);
+
+ if (type == DRM_FILE_TYPE_OMA) {
+ drm_dcf_header_t header_info;
+ memset(&header_info, 0, sizeof(drm_dcf_header_t));
+ media_svc_debug("drm type is OMA");
+
+ if (drm_svc_get_dcf_header_info(content_info->path, &header_info) != DRM_RESULT_SUCCESS) {
+ media_svc_debug("cannot get dcf header info. just get the title");
+ title = _media_svc_get_title_from_filepath(content_info->path);
+ if (title) {
+ ret = __media_svc_malloc_and_strncpy(&content_info->media_meta.title, title);
+ SAFE_FREE(title);
+ media_svc_retv_del_if(ret < 0, ret, content_info);
+ //_strncpy_safe(content_info->media_meta.title, title, sizeof(content_info->media_meta.title));
+ } else {
+ media_svc_error("Can't extract title from filepath [%s]", content_info->path);
+ ret = __media_svc_malloc_and_strncpy(&content_info->media_meta.title, MEDIA_SVC_TAG_UNKNOWN);
+ media_svc_retv_del_if(ret < 0, ret, content_info);
+ }
+
+/*
+ _strncpy_safe(content_info->media_meta.album, MEDIA_SVC_TAG_UNKNOWN, sizeof(content_info->media_meta.album));
+ _strncpy_safe(content_info->media_meta.artist, MEDIA_SVC_TAG_UNKNOWN, sizeof(content_info->media_meta.artist));
+ _strncpy_safe(content_info->media_meta.genre, MEDIA_SVC_TAG_UNKNOWN, sizeof(content_info->media_meta.genre));
+ _strncpy_safe(content_info->media_meta.author, MEDIA_SVC_TAG_UNKNOWN, sizeof(content_info->media_meta.author));
+ _strncpy_safe(content_info->media_meta.year, MEDIA_SVC_TAG_UNKNOWN, sizeof(content_info->media_meta.year));
+*/
+
+ ret = __media_svc_malloc_and_strncpy(&content_info->media_meta.album, MEDIA_SVC_TAG_UNKNOWN);
+ media_svc_retv_del_if(ret < 0, ret, content_info);
+ ret = __media_svc_malloc_and_strncpy(&content_info->media_meta.artist, MEDIA_SVC_TAG_UNKNOWN);
+ media_svc_retv_del_if(ret < 0, ret, content_info);
+ ret = __media_svc_malloc_and_strncpy(&content_info->media_meta.genre, MEDIA_SVC_TAG_UNKNOWN);
+ media_svc_retv_del_if(ret < 0, ret, content_info);
+ ret = __media_svc_malloc_and_strncpy(&content_info->media_meta.composer, MEDIA_SVC_TAG_UNKNOWN);
+ media_svc_retv_del_if(ret < 0, ret, content_info);
+ ret = __media_svc_malloc_and_strncpy(&content_info->media_meta.year, MEDIA_SVC_TAG_UNKNOWN);
+ media_svc_retv_del_if(ret < 0, ret, content_info);
+
+ return MEDIA_INFO_ERROR_NONE;
+ }
+
+ if (drm_svc_has_valid_ro(content_info->path, DRM_PERMISSION_PLAY) != DRM_RESULT_SUCCESS) {
+ media_svc_debug("no valid ro. can't extract meta data");
+ invalid_file = TRUE;
+ }
+
+ if (header_info.version == DRM_OMA_DRMV1_RIGHTS) {
+ media_svc_debug("DRM V1");
+ if (invalid_file) {
+
+ if (strlen(header_info.headerUnion.headerV1.contentName) > 0) {
+
+ //_strncpy_safe(content_info->media_meta.title, header_info.headerUnion.headerV1.contentName, sizeof(content_info->media_meta.title));
+ ret = __media_svc_malloc_and_strncpy(&content_info->media_meta.title, header_info.headerUnion.headerV1.contentName);
+ media_svc_retv_del_if(ret < 0, ret, content_info);
+
+ extracted_field |= MEDIA_SVC_EXTRACTED_FIELD_TITLE;
+ media_svc_debug("extract title from DCF");
+ }
+
+ if (strlen(header_info.headerUnion.headerV1.contentDescription) > 0) {
+ //_strncpy_safe(content_info->media_meta.description, header_info.headerUnion.headerV1.contentDescription, sizeof(content_info->media_meta.description));
+ ret = __media_svc_malloc_and_strncpy(&content_info->media_meta.description, header_info.headerUnion.headerV1.contentDescription);
+ media_svc_retv_del_if(ret < 0, ret, content_info);
+
+ extracted_field |= MEDIA_SVC_EXTRACTED_FIELD_DESC;
+ media_svc_debug("extract description from DCF");
+ }
+ }
+ } else if (header_info.version == DRM_OMA_DRMV2_RIGHTS) {
+ drm_user_data_common_t metadata;
+ int type_index = -1;
+
+ media_svc_debug("DRM V2");
+
+ if (drm_svc_get_user_data_box_info(content_info->path, DRM_UDTA_TITLE, &metadata) == DRM_RESULT_SUCCESS) {
+ //_strncpy_safe(content_info->media_meta.title, metadata.subBox.title.str, sizeof(content_info->media_meta.title));
+ ret = __media_svc_malloc_and_strncpy(&content_info->media_meta.title, metadata.subBox.title.str);
+ media_svc_retv_del_if(ret < 0, ret, content_info);
+
+ extracted_field |= MEDIA_SVC_EXTRACTED_FIELD_TITLE;
+ media_svc_debug("extract title from odf");
+ }
+
+ if (drm_svc_get_user_data_box_info(content_info->path, DRM_UDTA_DESCRIPTION, &metadata) == DRM_RESULT_SUCCESS) {
+ //_strncpy_safe(content_info->media_meta.description, metadata.subBox.desc.str, sizeof(content_info->media_meta.description));
+ ret = __media_svc_malloc_and_strncpy(&content_info->media_meta.description, metadata.subBox.desc.str);
+ media_svc_retv_del_if(ret < 0, ret, content_info);
+
+ extracted_field |= MEDIA_SVC_EXTRACTED_FIELD_DESC;
+ }
+
+ if (drm_svc_get_user_data_box_info(content_info->path, DRM_UDTA_COPYRIGHT, &metadata) == DRM_RESULT_SUCCESS) {
+ //_strncpy_safe(content_info->media_meta.copyright, metadata.subBox.copyright.str, sizeof(content_info->media_meta.copyright));
+ ret = __media_svc_malloc_and_strncpy(&content_info->media_meta.copyright, metadata.subBox.copyright.str);
+ media_svc_retv_del_if(ret < 0, ret, content_info);
+
+ extracted_field |= MEDIA_SVC_EXTRACTED_FIELD_COPYRIGHT;
+ }
+
+ if (drm_svc_get_user_data_box_info(content_info->path, DRM_UDTA_AUTHOR, &metadata) == DRM_RESULT_SUCCESS) {
+ //_strncpy_safe(content_info->media_meta.composer, metadata.subBox.author.str, sizeof(content_info->media_meta.composer));
+ ret = __media_svc_malloc_and_strncpy(&content_info->media_meta.composer, metadata.subBox.author.str);
+ media_svc_retv_del_if(ret < 0, ret, content_info);
+
+ extracted_field |= MEDIA_SVC_EXTRACTED_FIELD_AUTHOR;
+ }
+
+ if (drm_svc_get_user_data_box_info(content_info->path, DRM_UDTA_PERFORMER, &metadata) == DRM_RESULT_SUCCESS) {
+ //_strncpy_safe(content_info->media_meta.artist, metadata.subBox.performer.str, sizeof(content_info->media_meta.artist));
+ ret = __media_svc_malloc_and_strncpy(&content_info->media_meta.artist, metadata.subBox.performer.str);
+ media_svc_retv_del_if(ret < 0, ret, content_info);
+
+ extracted_field |= MEDIA_SVC_EXTRACTED_FIELD_ARTIST;
+ }
+
+ if (drm_svc_get_user_data_box_info(content_info->path, DRM_UDTA_GENRE, &metadata) == DRM_RESULT_SUCCESS) {
+ //_strncpy_safe(content_info->media_meta.genre, metadata.subBox.genre.str, sizeof(content_info->media_meta.genre));
+ ret = __media_svc_malloc_and_strncpy(&content_info->media_meta.genre, metadata.subBox.genre.str);
+ media_svc_retv_del_if(ret < 0, ret, content_info);
+
+ media_svc_debug("genre : %s", content_info->media_meta.genre);
+ if ((strcasecmp("Ringtone", metadata.subBox.genre.str) == 0) | (strcasecmp("Alert tone", metadata.subBox.genre.str) == 0)) {
+ content_info->media_type = MEDIA_SVC_MEDIA_TYPE_SOUND;
+ }
+ extracted_field |= MEDIA_SVC_EXTRACTED_FIELD_GENRE;
+ }
+
+ if (drm_svc_get_user_data_box_info(content_info->path, DRM_UDTA_ALBUM, &metadata) == DRM_RESULT_SUCCESS) {
+ //_strncpy_safe(content_info->media_meta.album, metadata.subBox.album.albumTitle, sizeof(content_info->media_meta.album));
+ ret = __media_svc_malloc_and_strncpy(&content_info->media_meta.album, metadata.subBox.album.albumTitle);
+ media_svc_retv_del_if(ret < 0, ret, content_info);
+
+ extracted_field |= MEDIA_SVC_EXTRACTED_FIELD_ALBUM;
+
+ char track_num[MEDIA_SVC_METADATA_LEN_MAX] = {0,};
+ snprintf(track_num, sizeof(track_num), "%d", metadata.subBox.album.trackNum);
+
+ ret = __media_svc_malloc_and_strncpy(&content_info->media_meta.track_num, track_num);
+ media_svc_retv_del_if(ret < 0, ret, content_info);
+
+ //snprintf(content_info->media_meta.track_num, MEDIA_SVC_METADATA_LEN_MAX, "%d", metadata.subBox.album.trackNum);
+ }
+
+ if (drm_svc_get_user_data_box_info(content_info->path, DRM_UDTA_RECODINGYEAR, &metadata) == DRM_RESULT_SUCCESS) {
+ //_strncpy_safe(content_info->media_meta.year, __year_2_str(metadata.subBox.recodingYear.recodingYear), sizeof(content_info->media_meta.year));
+ ret = __media_svc_malloc_and_strncpy(&content_info->media_meta.year, __year_2_str(metadata.subBox.recodingYear.recodingYear));
+ media_svc_retv_del_if(ret < 0, ret, content_info);
+
+ extracted_field |= MEDIA_SVC_EXTRACTED_FIELD_YEAR;
+ }
+
+ if (drm_svc_get_index_of_relative_contents(content_info->path, DRM_CONTENTS_INDEX_ALBUMJACKET, &type_index) == DRM_RESULT_SUCCESS) {
+ char thumb_path[MEDIA_SVC_PATHNAME_SIZE+1] = {0};
+
+ if (drm_svc_make_multipart_drm_full_path(content_info->path, type_index, MEDIA_SVC_PATHNAME_SIZE, thumb_path) == DRM_TRUE) {
+
+ DRM_FILE_HANDLE hFile = DRM_HANDLE_NULL;
+
+ media_svc_debug("drm image path : %s", thumb_path);
+
+ if (drm_svc_open_file(thumb_path, DRM_PERMISSION_ANY, &hFile) == DRM_RESULT_SUCCESS) {
+ int thumb_size = 0;
+
+ if (drm_svc_seek_file(hFile, 0, DRM_SEEK_END) != DRM_RESULT_SUCCESS) {
+ goto DRM_SEEK_ERROR;
+ }
+ thumb_size = drm_svc_tell_file(hFile);
+
+ if (drm_svc_seek_file(hFile, 0, DRM_SEEK_SET) != DRM_RESULT_SUCCESS) {
+ goto DRM_SEEK_ERROR;
+ }
+ /* remove thumbnail extract routine in db creating time.
+ media_svc_debug("drm thumb size : %d", thumb_size);
+ if (thumb_size > 0) {
+ unsigned int readSize = 0;
+
+ thumb_buffer = malloc(thumb_size);
+ if (drm_svc_read_file(hFile, thumb_buffer,thumb_size, &readSize) != DRM_RESULT_SUCCESS) {
+ SAFE_FREE(thumb_buffer);
+ goto DRM_SEEK_ERROR;
+ }
+
+ __save_thumbnail(thumb_buffer, readSize, 1, content_info);
+ SAFE_FREE(thumb_buffer);
+ thumb_extracted_from_drm = TRUE;
+ }
+ */
+ DRM_SEEK_ERROR:
+ drm_svc_free_dcf_header_info(&header_info);
+ drm_svc_close_file(hFile);
+ }
+ }
+ }
+ } else {
+ media_svc_debug("unsupported drm format");
+ drm_svc_free_dcf_header_info(&header_info);
+ title = _media_svc_get_title_from_filepath(content_info->path);
+ if (title) {
+ //_strncpy_safe(content_info->media_meta.title, title, sizeof(content_info->media_meta.title));
+ ret = __media_svc_malloc_and_strncpy(&content_info->media_meta.title, title);
+ SAFE_FREE(title);
+ media_svc_retv_del_if(ret < 0, ret, content_info);
+
+ } else {
+ media_svc_error("Can't extract title from filepath [%s]", content_info->path);
+ ret = __media_svc_malloc_and_strncpy(&content_info->media_meta.title, MEDIA_SVC_TAG_UNKNOWN);
+ media_svc_retv_del_if(ret < 0, ret, content_info);
+ }
+
+ ret = __media_svc_malloc_and_strncpy(&content_info->media_meta.album, MEDIA_SVC_TAG_UNKNOWN);
+ media_svc_retv_del_if(ret < 0, ret, content_info);
+ ret = __media_svc_malloc_and_strncpy(&content_info->media_meta.artist, MEDIA_SVC_TAG_UNKNOWN);
+ media_svc_retv_del_if(ret < 0, ret, content_info);
+ ret = __media_svc_malloc_and_strncpy(&content_info->media_meta.genre, MEDIA_SVC_TAG_UNKNOWN);
+ media_svc_retv_del_if(ret < 0, ret, content_info);
+ ret = __media_svc_malloc_and_strncpy(&content_info->media_meta.composer, MEDIA_SVC_TAG_UNKNOWN);
+ media_svc_retv_del_if(ret < 0, ret, content_info);
+ ret = __media_svc_malloc_and_strncpy(&content_info->media_meta.year, MEDIA_SVC_TAG_UNKNOWN);
+ media_svc_retv_del_if(ret < 0, ret, content_info);
+/*
+ _strncpy_safe(content_info->media_meta.album, MEDIA_SVC_TAG_UNKNOWN, sizeof(content_info->media_meta.album));
+ _strncpy_safe(content_info->media_meta.artist, MEDIA_SVC_TAG_UNKNOWN, sizeof(content_info->media_meta.artist));
+ _strncpy_safe(content_info->media_meta.genre, MEDIA_SVC_TAG_UNKNOWN, sizeof(content_info->media_meta.genre));
+ _strncpy_safe(content_info->media_meta.composer, MEDIA_SVC_TAG_UNKNOWN, sizeof(content_info->media_meta.composer));
+ _strncpy_safe(content_info->media_meta.year, MEDIA_SVC_TAG_UNKNOWN, sizeof(content_info->media_meta.year));
+*/
+ return MEDIA_INFO_ERROR_NONE;
+ }
+
+ if (invalid_file == TRUE) {
+ if (!(extracted_field & MEDIA_SVC_EXTRACTED_FIELD_TITLE)) {
+ title = _media_svc_get_title_from_filepath(content_info->path);
+ if (title) {
+ //_strncpy_safe(content_info->media_meta.title, title, sizeof(content_info->media_meta.title));
+ ret = __media_svc_malloc_and_strncpy(&content_info->media_meta.title, title);
+ SAFE_FREE(title);
+ media_svc_retv_del_if(ret < 0, ret, content_info);
+
+ extracted_field |= MEDIA_SVC_EXTRACTED_FIELD_TITLE;
+ } else {
+ media_svc_error("Can't extract title from filepath");
+ drm_svc_free_dcf_header_info(&header_info);
+ return MEDIA_INFO_ERROR_INTERNAL;
+ }
+
+ ret = __media_svc_malloc_and_strncpy(&content_info->media_meta.album, MEDIA_SVC_TAG_UNKNOWN);
+ media_svc_retv_del_if(ret < 0, ret, content_info);
+ ret = __media_svc_malloc_and_strncpy(&content_info->media_meta.artist, MEDIA_SVC_TAG_UNKNOWN);
+ media_svc_retv_del_if(ret < 0, ret, content_info);
+ ret = __media_svc_malloc_and_strncpy(&content_info->media_meta.genre, MEDIA_SVC_TAG_UNKNOWN);
+ media_svc_retv_del_if(ret < 0, ret, content_info);
+ ret = __media_svc_malloc_and_strncpy(&content_info->media_meta.composer, MEDIA_SVC_TAG_UNKNOWN);
+ media_svc_retv_del_if(ret < 0, ret, content_info);
+ ret = __media_svc_malloc_and_strncpy(&content_info->media_meta.year, MEDIA_SVC_TAG_UNKNOWN);
+ media_svc_retv_del_if(ret < 0, ret, content_info);
+/*
+ _strncpy_safe(content_info->media_meta.album, MEDIA_SVC_TAG_UNKNOWN, sizeof(content_info->media_meta.album));
+ _strncpy_safe(content_info->media_meta.artist, MEDIA_SVC_TAG_UNKNOWN, sizeof(content_info->media_meta.artist));
+ _strncpy_safe(content_info->media_meta.genre, MEDIA_SVC_TAG_UNKNOWN, sizeof(content_info->media_meta.genre));
+ _strncpy_safe(content_info->media_meta.composer, MEDIA_SVC_TAG_UNKNOWN, sizeof(content_info->media_meta.composer));
+ _strncpy_safe(content_info->media_meta.year, MEDIA_SVC_TAG_UNKNOWN, sizeof(content_info->media_meta.year));
+*/
+ }
+
+ drm_svc_free_dcf_header_info(&header_info);
+ return MEDIA_INFO_ERROR_NONE;
+ }
+ } else if (type == DRM_FILE_TYPE_PLAYREADY) {
+ media_svc_debug("drm type is PLAYREADY");
+ if (drm_svc_has_valid_ro(content_info->path, DRM_PERMISSION_PLAY) != DRM_RESULT_SUCCESS) {
+ media_svc_debug("no valid ro. can't extract meta data");
+ title = _media_svc_get_title_from_filepath(content_info->path);
+ if (title) {
+ ret = __media_svc_malloc_and_strncpy(&content_info->media_meta.title, title);
+ SAFE_FREE(title);
+ media_svc_retv_del_if(ret < 0, ret, content_info);
+ //_strncpy_safe(content_info->media_meta.title, title, sizeof(content_info->media_meta.title));
+ } else {
+ media_svc_error("Can't extract title from filepath [%s]", content_info->path);
+ ret = __media_svc_malloc_and_strncpy(&content_info->media_meta.title, MEDIA_SVC_TAG_UNKNOWN);
+ media_svc_retv_del_if(ret < 0, ret, content_info);
+ }
+
+ ret = __media_svc_malloc_and_strncpy(&content_info->media_meta.album, MEDIA_SVC_TAG_UNKNOWN);
+ media_svc_retv_del_if(ret < 0, ret, content_info);
+ ret = __media_svc_malloc_and_strncpy(&content_info->media_meta.artist, MEDIA_SVC_TAG_UNKNOWN);
+ media_svc_retv_del_if(ret < 0, ret, content_info);
+ ret = __media_svc_malloc_and_strncpy(&content_info->media_meta.genre, MEDIA_SVC_TAG_UNKNOWN);
+ media_svc_retv_del_if(ret < 0, ret, content_info);
+ ret = __media_svc_malloc_and_strncpy(&content_info->media_meta.composer, MEDIA_SVC_TAG_UNKNOWN);
+ media_svc_retv_del_if(ret < 0, ret, content_info);
+ ret = __media_svc_malloc_and_strncpy(&content_info->media_meta.year, MEDIA_SVC_TAG_UNKNOWN);
+ media_svc_retv_del_if(ret < 0, ret, content_info);
+/*
+ _strncpy_safe(content_info->media_meta.album, MEDIA_SVC_TAG_UNKNOWN, sizeof(content_info->media_meta.album));
+ _strncpy_safe(content_info->media_meta.artist, MEDIA_SVC_TAG_UNKNOWN, sizeof(content_info->media_meta.artist));
+ _strncpy_safe(content_info->media_meta.genre, MEDIA_SVC_TAG_UNKNOWN, sizeof(content_info->media_meta.genre));
+ _strncpy_safe(content_info->media_meta.composer, MEDIA_SVC_TAG_UNKNOWN, sizeof(content_info->media_meta.composer));
+ _strncpy_safe(content_info->media_meta.year, MEDIA_SVC_TAG_UNKNOWN, sizeof(content_info->media_meta.year));
+*/
+
+ return MEDIA_INFO_ERROR_NONE;
+ }
+ } else {
+ media_svc_error("Not supported DRM type");
+ title = _media_svc_get_title_from_filepath(content_info->path);
+ if (title) {
+ ret = __media_svc_malloc_and_strncpy(&content_info->media_meta.title, title);
+ SAFE_FREE(title);
+ media_svc_retv_del_if(ret < 0, ret, content_info);
+ //_strncpy_safe(content_info->media_meta.title, title, sizeof(content_info->media_meta.title));
+ } else {
+ media_svc_error("Can't extract title from filepath [%s]", content_info->path);
+ ret = __media_svc_malloc_and_strncpy(&content_info->media_meta.title, MEDIA_SVC_TAG_UNKNOWN);
+ media_svc_retv_del_if(ret < 0, ret, content_info);
+ }
+
+ ret = __media_svc_malloc_and_strncpy(&content_info->media_meta.album, MEDIA_SVC_TAG_UNKNOWN);
+ media_svc_retv_del_if(ret < 0, ret, content_info);
+ ret = __media_svc_malloc_and_strncpy(&content_info->media_meta.artist, MEDIA_SVC_TAG_UNKNOWN);
+ media_svc_retv_del_if(ret < 0, ret, content_info);
+ ret = __media_svc_malloc_and_strncpy(&content_info->media_meta.genre, MEDIA_SVC_TAG_UNKNOWN);
+ media_svc_retv_del_if(ret < 0, ret, content_info);
+ ret = __media_svc_malloc_and_strncpy(&content_info->media_meta.composer, MEDIA_SVC_TAG_UNKNOWN);
+ media_svc_retv_del_if(ret < 0, ret, content_info);
+ ret = __media_svc_malloc_and_strncpy(&content_info->media_meta.year, MEDIA_SVC_TAG_UNKNOWN);
+ media_svc_retv_del_if(ret < 0, ret, content_info);
+/*
+ _strncpy_safe(content_info->media_meta.album, MEDIA_SVC_TAG_UNKNOWN, sizeof(content_info->media_meta.album));
+ _strncpy_safe(content_info->media_meta.artist, MEDIA_SVC_TAG_UNKNOWN, sizeof(content_info->media_meta.artist));
+ _strncpy_safe(content_info->media_meta.genre, MEDIA_SVC_TAG_UNKNOWN, sizeof(content_info->media_meta.genre));
+ _strncpy_safe(content_info->media_meta.author, MEDIA_SVC_TAG_UNKNOWN, sizeof(content_info->media_meta.author));
+ _strncpy_safe(content_info->media_meta.year, MEDIA_SVC_TAG_UNKNOWN, sizeof(content_info->media_meta.year));
+*/
+ return MEDIA_INFO_ERROR_NONE;
+ }
+ }
+#endif
+ /*Get Content attribute ===========*/
+ mmf_error = mm_file_create_content_attrs(&content, content_info->path);
+ if (mmf_error == MM_ERROR_NONE) {
+ /*Common attribute*/
+ mmf_error = mm_file_get_attrs(content, &err_attr_name, MM_FILE_CONTENT_DURATION, &content_info->media_meta.duration, NULL);
+ if (mmf_error != MM_ERROR_NONE) {
+ SAFE_FREE(err_attr_name);
+ media_svc_debug("fail to get duration attr - err(%x)", mmf_error);
+ } else {
+ //media_svc_debug("duration : %d", content_info->media_meta.duration);
+ }
+
+ /*Sound/Music attribute*/
+ if((media_type == MEDIA_SVC_MEDIA_TYPE_SOUND) || (media_type == MEDIA_SVC_MEDIA_TYPE_MUSIC)) {
+
+ mmf_error = mm_file_get_attrs(content, &err_attr_name, MM_FILE_CONTENT_AUDIO_BITRATE, &content_info->media_meta.bitrate, NULL);
+ if (mmf_error != MM_ERROR_NONE) {
+ SAFE_FREE(err_attr_name);
+ media_svc_debug("fail to get audio bitrate attr - err(%x)", mmf_error);
+ } else {
+ //media_svc_debug("bit rate : %d", content_info->media_meta.bitrate);
+ }
+
+ mmf_error = mm_file_get_attrs(content, &err_attr_name, MM_FILE_CONTENT_AUDIO_SAMPLERATE, &content_info->media_meta.samplerate, NULL);
+ if (mmf_error != MM_ERROR_NONE) {
+ SAFE_FREE(err_attr_name);
+ media_svc_debug("fail to get sample rate attr - err(%x)", mmf_error);
+ } else {
+ //media_svc_debug("sample rate : %d", content_info->media_meta.samplerate);
+ }
+
+ mmf_error = mm_file_get_attrs(content, &err_attr_name, MM_FILE_CONTENT_AUDIO_CHANNELS, &content_info->media_meta.channel, NULL);
+ if (mmf_error != MM_ERROR_NONE) {
+ SAFE_FREE(err_attr_name);
+ media_svc_debug("fail to get audio channels attr - err(%x)", mmf_error);
+ } else {
+ //media_svc_debug("channel : %d", content_info->media_meta.channel);
+ }
+ }else if(media_type == MEDIA_SVC_MEDIA_TYPE_VIDEO) { /*Video attribute*/
+ int audio_bitrate = 0;
+ int video_bitrate = 0;
+
+ mmf_error = mm_file_get_attrs(content, &err_attr_name, MM_FILE_CONTENT_AUDIO_BITRATE, &audio_bitrate, NULL);
+ if (mmf_error != MM_ERROR_NONE) {
+ SAFE_FREE(err_attr_name);
+ media_svc_debug("fail to get audio bitrate attr - err(%x)", mmf_error);
+ } else {
+ //media_svc_debug("audio bit rate : %d", audio_bitrate);
+ }
+
+ mmf_error = mm_file_get_attrs(content, &err_attr_name, MM_FILE_CONTENT_VIDEO_BITRATE, &video_bitrate, NULL);
+ if (mmf_error != MM_ERROR_NONE) {
+ SAFE_FREE(err_attr_name);
+ media_svc_debug("fail to get audio bitrate attr - err(%x)", mmf_error);
+ } else {
+ //media_svc_debug("video bit rate : %d", video_bitrate);
+ }
+
+ content_info->media_meta.bitrate = audio_bitrate + video_bitrate;
+
+ mmf_error = mm_file_get_attrs(content, &err_attr_name, MM_FILE_CONTENT_VIDEO_WIDTH, &content_info->media_meta.width, NULL);
+ if (mmf_error != MM_ERROR_NONE) {
+ SAFE_FREE(err_attr_name);
+ media_svc_debug("fail to get video width attr - err(%x)", mmf_error);
+ } else {
+ //media_svc_debug("width : %d", content_info->media_meta.width);
+ }
+
+ mmf_error = mm_file_get_attrs(content, &err_attr_name, MM_FILE_CONTENT_VIDEO_HEIGHT, &content_info->media_meta.height, NULL);
+ if (mmf_error != MM_ERROR_NONE) {
+ SAFE_FREE(err_attr_name);
+ media_svc_debug("fail to get video height attr - err(%x)", mmf_error);
+ } else {
+ //media_svc_debug("height : %d", content_info->media_meta.height);
+ }
+
+ } else {
+ media_svc_error("Not support type");
+ return MEDIA_INFO_ERROR_INVALID_PARAMETER;
+ }
+
+ mmf_error = mm_file_destroy_content_attrs(content);
+ if (mmf_error != MM_ERROR_NONE) {
+ media_svc_error("fail to free content attr - err(%x)", mmf_error);
+ }
+ } else {
+ media_svc_error("error in mm_file_create_content_attrs [%d]", mmf_error);
+ }
+
+ /*Get Content Tag attribute ===========*/
+ mmf_error = mm_file_create_tag_attrs(&tag, content_info->path);
+
+ if (mmf_error == MM_ERROR_NONE) {
+ mmf_error = mm_file_get_attrs(tag, &err_attr_name, MM_FILE_TAG_ALBUM, &p, &size, NULL);
+ if ((!(extracted_field & MEDIA_SVC_EXTRACTED_FIELD_ALBUM)) && (mmf_error == MM_ERROR_NONE) && (size > 0)) {
+ ret = __media_svc_malloc_and_strncpy(&content_info->media_meta.album, p);
+ if(ret != MEDIA_INFO_ERROR_NONE)
+ media_svc_error("strcpy error");
+
+ //media_svc_debug("album[%d] : %s", size, content_info->media_meta.album);
+ } else {
+ SAFE_FREE(err_attr_name);
+ //media_svc_debug("album - unknown");
+ }
+
+ mmf_error = mm_file_get_attrs(tag, &err_attr_name, MM_FILE_TAG_ARTIST, &p, &size, NULL);
+ if ((!(extracted_field & MEDIA_SVC_EXTRACTED_FIELD_ARTIST)) && (mmf_error == MM_ERROR_NONE) && (size > 0)) {
+ ret = __media_svc_malloc_and_strncpy(&content_info->media_meta.artist, p);
+ if(ret != MEDIA_INFO_ERROR_NONE)
+ media_svc_error("strcpy error");
+ //media_svc_debug("artist[%d] : %s", size, content_info->media_meta.artist);
+ } else {
+ SAFE_FREE(err_attr_name);
+ //media_svc_debug("artist - unknown");
+ }
+
+ mmf_error = mm_file_get_attrs(tag, &err_attr_name, MM_FILE_TAG_GENRE, &p, &size, NULL);
+ if ((!(extracted_field & MEDIA_SVC_EXTRACTED_FIELD_GENRE)) && (mmf_error == MM_ERROR_NONE) && (size > 0)) {
+ ret = __media_svc_malloc_and_strncpy(&content_info->media_meta.genre, p);
+ if(ret != MEDIA_INFO_ERROR_NONE)
+ media_svc_error("strcpy error");
+
+ //media_svc_debug("genre : %s", content_info->media_meta.genre);
+ if ((strcasecmp("Ringtone", p) == 0) | (strcasecmp("Alert tone", p) == 0)) {
+ content_info->media_type = MEDIA_SVC_MEDIA_TYPE_SOUND;
+ }
+ } else {
+ SAFE_FREE(err_attr_name);
+ //media_svc_debug("genre - unknown");
+ }
+
+ mmf_error = mm_file_get_attrs(tag, &err_attr_name, MM_FILE_TAG_TITLE, &p, &size, NULL);
+ if ((!(extracted_field & MEDIA_SVC_EXTRACTED_FIELD_TITLE)) && (mmf_error == MM_ERROR_NONE) && (size > 0)/* && (!isspace(*p))*/) {
+ if(!isspace(*p)) {
+ ret = __media_svc_malloc_and_strncpy(&content_info->media_meta.title, p);
+ if(ret != MEDIA_INFO_ERROR_NONE)
+ media_svc_error("strcpy error");
+
+ extracted_field |= MEDIA_SVC_EXTRACTED_FIELD_TITLE;
+ //media_svc_debug("extract title from content : %s", content_info->media_meta.title);
+ //media_svc_debug("^^^^^^^^^^^^^^^ path = %s, title = %s, size = %d ^^^^^^^^^^^^^^", content_info->path, content_info->media_meta.title, size);
+ }
+ else {
+ int idx = 0;
+
+ for(idx = 0; idx < size; idx++) {
+ if(isspace(*p)) {
+ media_svc_debug("SPACE [%s]", p);
+ p++;
+ continue;
+ } else {
+ media_svc_debug("Not SPACE [%s]", p);
+ ret = __media_svc_malloc_and_strncpy(&content_info->media_meta.title, p);
+ if(ret != MEDIA_INFO_ERROR_NONE)
+ media_svc_error("strcpy error");
+ break;
+ }
+ }
+
+ if(idx == size)
+ {
+ media_svc_debug("Can't extract title. All string is space");
+ title = _media_svc_get_title_from_filepath(content_info->path);
+ if (title) {
+ ret = __media_svc_malloc_and_strncpy(&content_info->media_meta.title, title);
+ if(ret != MEDIA_INFO_ERROR_NONE)
+ media_svc_error("strcpy error");
+ SAFE_FREE(title);
+ } else {
+ media_svc_error("Can't extract title from filepath [%s]", content_info->path);
+ }
+ }
+ }
+ } else {
+ SAFE_FREE(err_attr_name);
+ title = _media_svc_get_title_from_filepath(content_info->path);
+ if (title) {
+ ret = __media_svc_malloc_and_strncpy(&content_info->media_meta.title, title);
+ if(ret != MEDIA_INFO_ERROR_NONE)
+ media_svc_error("strcpy error");
+ SAFE_FREE(title);
+ } else {
+ media_svc_error("Can't extract title from filepath [%s]", content_info->path);
+ }
+ }
+
+ mmf_error = mm_file_get_attrs(tag, &err_attr_name, MM_FILE_TAG_DESCRIPTION, &p, &size, NULL);
+ if ((!(extracted_field & MEDIA_SVC_EXTRACTED_FIELD_DESC)) && (mmf_error == MM_ERROR_NONE) && (size > 0)) {
+ ret = __media_svc_malloc_and_strncpy(&content_info->media_meta.description, p);
+ if(ret != MEDIA_INFO_ERROR_NONE)
+ media_svc_error("strcpy error");
+ //media_svc_debug("desc : %s", content_info->media_meta.description);
+ } else {
+ SAFE_FREE(err_attr_name);
+ }
+
+ mmf_error = mm_file_get_attrs(tag, &err_attr_name, MM_FILE_TAG_RECDATE, &p, &size, NULL);
+ if ((!(extracted_field & MEDIA_SVC_EXTRACTED_FIELD_DESC)) && (mmf_error == MM_ERROR_NONE) && (size > 0)) {
+ ret = __media_svc_malloc_and_strncpy(&content_info->media_meta.recorded_date, p);
+ if(ret != MEDIA_INFO_ERROR_NONE)
+ media_svc_error("strcpy error");
+ //media_svc_debug("Recorded date : %s", content_info->media_meta.recorded_date);
+ } else {
+ SAFE_FREE(err_attr_name);
+ }
+
+ mmf_error = mm_file_get_attrs(tag, &err_attr_name, MM_FILE_TAG_AUTHOR, &p, &size, NULL);
+ if ((!(extracted_field & MEDIA_SVC_EXTRACTED_FIELD_AUTHOR)) && (mmf_error == MM_ERROR_NONE) && (size > 0)) {
+ ret = __media_svc_malloc_and_strncpy(&content_info->media_meta.composer, p);
+ if(ret != MEDIA_INFO_ERROR_NONE)
+ media_svc_error("strcpy error");
+ extracted_field |= MEDIA_SVC_EXTRACTED_FIELD_AUTHOR;
+ //media_svc_debug("extract composer from content : %s", content_info->media_meta.composer);
+ } else {
+ //media_svc_debug("composer - unknown");
+ SAFE_FREE(err_attr_name);
+ }
+
+ mmf_error = mm_file_get_attrs(tag, &err_attr_name, MM_FILE_TAG_COPYRIGHT, &p, &size, NULL);
+ if ((!(extracted_field & MEDIA_SVC_EXTRACTED_FIELD_COPYRIGHT)) && (mmf_error == MM_ERROR_NONE) && (size > 0)) {
+ ret = __media_svc_malloc_and_strncpy(&content_info->media_meta.copyright, p);
+ if(ret != MEDIA_INFO_ERROR_NONE)
+ media_svc_error("strcpy error");
+ extracted_field |= MEDIA_SVC_EXTRACTED_FIELD_AUTHOR;
+ //media_svc_debug("extract copyright from content : %s", content_info->media_meta.copyright);
+ } else {
+ //media_svc_debug("copyright - unknown");
+ SAFE_FREE(err_attr_name);
+ }
+
+ mmf_error = mm_file_get_attrs(tag, &err_attr_name, MM_FILE_TAG_TRACK_NUM, &p, &size, NULL);
+ if ((mmf_error == MM_ERROR_NONE) && (size > 0)) {
+ ret = __media_svc_malloc_and_strncpy(&content_info->media_meta.track_num, p);
+ if(ret != MEDIA_INFO_ERROR_NONE)
+ media_svc_error("strcpy error");
+ } else {
+ SAFE_FREE(err_attr_name);
+ }
+
+ mmf_error = mm_file_get_attrs(tag, &err_attr_name, MM_FILE_TAG_DATE, &p, &size, NULL);
+ if ((!(extracted_field & MEDIA_SVC_EXTRACTED_FIELD_YEAR)) && (mmf_error == MM_ERROR_NONE) && (size == 4)) {
+ int year = 0;
+ if((p != NULL) && (sscanf( p, "%d", &year))) {
+ ret = __media_svc_malloc_and_strncpy(&content_info->media_meta.year, p);
+ if(ret != MEDIA_INFO_ERROR_NONE)
+ media_svc_error("strcpy error");
+ } else {
+ media_svc_debug("Wrong Year Information [%s]", p);
+ }
+ } else {
+ SAFE_FREE(err_attr_name);
+ }
+
+ mmf_error = mm_file_get_attrs(tag, &err_attr_name, MM_FILE_TAG_RATING, &p, &size, NULL);
+ if ((mmf_error == MM_ERROR_NONE) && (size > 0)) {
+ content_info->media_meta.rating = atoi(p);
+ } else {
+ SAFE_FREE(err_attr_name);
+ content_info->media_meta.rating = 0;
+ }
+
+ /*Initialize album_id to 0. below code will set the album_id*/
+ content_info->album_id = album_id;
+#if 0
+ /* extract thumbnail image */
+ if(strncmp(content_info->media_meta.album, MEDIA_SVC_TAG_UNKNOWN, strlen(MEDIA_SVC_TAG_UNKNOWN))) {
+ if(strncmp(content_info->media_meta.artist, MEDIA_SVC_TAG_UNKNOWN, strlen(MEDIA_SVC_TAG_UNKNOWN))) {
+
+ ret = _media_svc_get_album_id(handle, content_info->media_meta.album, content_info->media_meta.artist, &album_id);
+
+ if (ret != MEDIA_INFO_ERROR_NONE) {
+ if (ret == MEDIA_INFO_ERROR_DATABASE_NO_RECORD) {
+ media_svc_debug("album does not exist. So start to make album art");
+ extract_thumbnail = TRUE;
+ append_album = TRUE;
+ } else {
+ extract_thumbnail = FALSE;
+ append_album = FALSE;
+ }
+ } else {
+ media_svc_debug("album already exists. don't need to make album art");
+ content_info->album_id = album_id;
+ ret = _media_svc_get_album_art_by_album_id(handle, album_id, &content_info->thumbnail_path);
+ media_svc_retv_del_if((ret != MEDIA_INFO_ERROR_NONE) && (ret != MEDIA_INFO_ERROR_DATABASE_NO_RECORD), ret, content_info);
+ extract_thumbnail = FALSE;
+ append_album = FALSE;
+ }
+ } else {
+ ret = _media_svc_get_album_id(handle, content_info->media_meta.album, content_info->media_meta.artist, &album_id);
+
+ if (ret != MEDIA_INFO_ERROR_NONE) {
+ if (ret == MEDIA_INFO_ERROR_DATABASE_NO_RECORD) {
+ media_svc_debug("Unknown artist album does not exist.");
+ extract_thumbnail = TRUE;
+ append_album = TRUE;
+ } else {
+ extract_thumbnail = FALSE;
+ append_album = FALSE;
+ }
+ } else {
+ media_svc_debug("Unknown artist album already exists.");
+
+ content_info->album_id = album_id;
+ extract_thumbnail = TRUE;
+ append_album = FALSE;
+ }
+ }
+ } else {
+ extract_thumbnail = TRUE;
+ append_album = FALSE;
+ }
+#else
+ ret = _media_svc_get_album_id(handle, content_info->media_meta.album, content_info->media_meta.artist, &album_id);
+
+ if (ret != MEDIA_INFO_ERROR_NONE) {
+ if (ret == MEDIA_INFO_ERROR_DATABASE_NO_RECORD) {
+ media_svc_debug("album does not exist. So start to make album art");
+ extract_thumbnail = TRUE;
+ append_album = TRUE;
+ } else {
+ extract_thumbnail = FALSE;
+ append_album = FALSE;
+ }
+ } else {
+ content_info->album_id = album_id;
+ append_album = FALSE;
+
+ if((!strncmp(content_info->media_meta.album, MEDIA_SVC_TAG_UNKNOWN, strlen(MEDIA_SVC_TAG_UNKNOWN))) ||
+ (!strncmp(content_info->media_meta.artist, MEDIA_SVC_TAG_UNKNOWN, strlen(MEDIA_SVC_TAG_UNKNOWN)))) {
+
+ media_svc_debug("Unknown album or artist already exists. Extract thumbnail for Unknown.");
+ extract_thumbnail = TRUE;
+ } else {
+
+ media_svc_debug("album already exists. don't need to make album art");
+ ret = _media_svc_get_album_art_by_album_id(handle, album_id, &content_info->thumbnail_path);
+ media_svc_retv_del_if((ret != MEDIA_INFO_ERROR_NONE) && (ret != MEDIA_INFO_ERROR_DATABASE_NO_RECORD), ret, content_info);
+ extract_thumbnail = FALSE;
+ }
+ }
+#endif
+
+ if ((!thumb_extracted_from_drm) && (extract_thumbnail == TRUE)) {
+ mmf_error = mm_file_get_attrs(tag, &err_attr_name, MM_FILE_TAG_ARTWORK, &image, &size, NULL);
+ if (mmf_error != MM_ERROR_NONE) {
+ media_svc_error("fail to get tag artwork - err(%x)", mmf_error);
+ SAFE_FREE(err_attr_name);
+ } else {
+ //media_svc_debug("artwork size1 [%d]", size);
+ }
+
+ mmf_error = mm_file_get_attrs(tag, &err_attr_name, MM_FILE_TAG_ARTWORK_SIZE, &size, NULL);
+ if (mmf_error != MM_ERROR_NONE) {
+ media_svc_error("fail to get artwork size - err(%x)", mmf_error);
+ SAFE_FREE(err_attr_name);
+ } else {
+ //media_svc_debug("artwork size2 [%d]", size);
+ }
+ if (image != NULL && size > 0) {
+ bool result = FALSE;
+ int ret = MEDIA_INFO_ERROR_NONE;
+ char thumb_path[MEDIA_SVC_PATHNAME_SIZE] = "\0";
+ int artwork_mime_size = -1;
+
+ mmf_error = mm_file_get_attrs(tag, &err_attr_name, MM_FILE_TAG_ARTWORK_MIME, &p, &artwork_mime_size, NULL);
+ if ((mmf_error == MM_ERROR_NONE) && (artwork_mime_size > 0)) {
+ result = _media_svc_get_thumbnail_path(content_info->storage_type, thumb_path, content_info->path, p);
+ if (result == FALSE) {
+ media_svc_error("Fail to Get Thumbnail Path");
+ }
+ } else {
+ SAFE_FREE(err_attr_name);
+ }
+
+ if(strlen(thumb_path) > 0)
+ {
+ ret = _media_svc_save_image(image, size, thumb_path);
+ if (ret != MEDIA_INFO_ERROR_NONE) {
+ media_svc_error("Fail to Save Thumbnail Image");
+ }
+ else {
+ ret = __media_svc_malloc_and_strncpy(&content_info->thumbnail_path, thumb_path);
+ if(ret != MEDIA_INFO_ERROR_NONE)
+ media_svc_error("strcpy error");
+ }
+ }
+ }
+ }
+
+ if(append_album == TRUE) {
+
+ if((strncmp(content_info->media_meta.album, MEDIA_SVC_TAG_UNKNOWN, strlen(MEDIA_SVC_TAG_UNKNOWN))) &&
+ (strncmp(content_info->media_meta.artist, MEDIA_SVC_TAG_UNKNOWN, strlen(MEDIA_SVC_TAG_UNKNOWN))))
+ ret = _media_svc_append_album(handle, content_info->media_meta.album, content_info->media_meta.artist, content_info->thumbnail_path, &album_id);
+ else
+ ret = _media_svc_append_album(handle, content_info->media_meta.album, content_info->media_meta.artist, NULL, &album_id);
+
+ content_info->album_id = album_id;
+ }
+
+ if(media_type == MEDIA_SVC_MEDIA_TYPE_VIDEO) {
+ mmf_error = mm_file_get_attrs(tag, &err_attr_name, MM_FILE_TAG_LONGITUDE, &gps_value, NULL);
+ if (mmf_error == MM_ERROR_NONE) {
+ if (gps_value == 0.0)
+ content_info->media_meta.longitude = MEDIA_SVC_DEFAULT_GPS_VALUE;
+ else
+ content_info->media_meta.longitude = gps_value;
+ } else {
+ SAFE_FREE(err_attr_name);
+ }
+
+ mmf_error = mm_file_get_attrs(tag, &err_attr_name, MM_FILE_TAG_LATIDUE, &gps_value, NULL);
+ if (mmf_error == MM_ERROR_NONE) {
+ if (gps_value == 0.0)
+ content_info->media_meta.latitude = MEDIA_SVC_DEFAULT_GPS_VALUE;
+ else
+ content_info->media_meta.latitude = gps_value;
+ } else {
+ SAFE_FREE(err_attr_name);
+ }
+
+ mmf_error = mm_file_get_attrs(tag, &err_attr_name, MM_FILE_TAG_ALTIDUE, &gps_value, NULL);
+ if (mmf_error == MM_ERROR_NONE) {
+ if (gps_value == 0.0)
+ content_info->media_meta.altitude = MEDIA_SVC_DEFAULT_GPS_VALUE;
+ else
+ content_info->media_meta.altitude = gps_value;
+ } else {
+ SAFE_FREE(err_attr_name);
+ }
+#if 0
+ //if ((!thumb_extracted_from_drm) && (extract_thumbnail == TRUE))
+ {
+ /* Extracting thumbnail */
+ char thumb_path[MEDIA_SVC_PATHNAME_SIZE + 1] = {0, };
+ int width = 0;
+ int height = 0;
+
+ ret = thumbnail_request_from_db_with_size(content_info->path, thumb_path, sizeof(thumb_path), &width, &height);
+ if (ret < 0) {
+ media_svc_error("thumbnail_request_from_db failed: %d", ret);
+ } else {
+ //media_svc_debug("thumbnail_request_from_db success: %s", thumb_path);
+ }
+
+ ret = __media_svc_malloc_and_strncpy(&content_info->thumbnail_path, thumb_path);
+ if(ret != MEDIA_INFO_ERROR_NONE)
+ media_svc_error("strcpy error");
+
+ if (content_info->media_meta.width <= 0) content_info->media_meta.width = width;
+ if (content_info->media_meta.height <= 0) content_info->media_meta.height = height;
+ }
+#endif
+ }
+
+ mmf_error = mm_file_destroy_tag_attrs(tag);
+ if (mmf_error != MM_ERROR_NONE) {
+ media_svc_error("fail to free tag attr - err(%x)", mmf_error);
+ }
+ } else {
+ /* in case of file size 0, MMFW Can't parsting tag info but add it to Music DB. */
+ char *title = NULL;
+ media_svc_error("no tag information");
+
+ title = _media_svc_get_title_from_filepath(content_info->path);
+ if (title) {
+ ret = __media_svc_malloc_and_strncpy(&content_info->media_meta.title, title);
+ if(ret != MEDIA_INFO_ERROR_NONE)
+ media_svc_error("strcpy error");
+ SAFE_FREE(title);
+ } else {
+ media_svc_error("Can't extract title from filepath [%s]", content_info->path);
+ }
+
+ content_info->album_id = album_id;
+ }
+
+ return MEDIA_INFO_ERROR_NONE;
+}
+
+void _media_svc_destroy_content_info(media_svc_content_info_s *content_info)
+{
+ media_svc_retm_if(content_info == NULL, "content info is NULL");
+
+ /* Delete media_svc_content_info_s */
+ SAFE_FREE(content_info->media_uuid);
+ SAFE_FREE(content_info->path);
+ SAFE_FREE(content_info->file_name);
+ SAFE_FREE(content_info->mime_type);
+ SAFE_FREE(content_info->folder_uuid);
+ SAFE_FREE(content_info->thumbnail_path);
+
+ /* Delete media_svc_content_meta_s */
+ SAFE_FREE(content_info->media_meta.title);
+ SAFE_FREE(content_info->media_meta.album);
+ SAFE_FREE(content_info->media_meta.artist);
+ SAFE_FREE(content_info->media_meta.genre);
+ SAFE_FREE(content_info->media_meta.composer);
+ SAFE_FREE(content_info->media_meta.year);
+ SAFE_FREE(content_info->media_meta.recorded_date);
+ SAFE_FREE(content_info->media_meta.copyright);
+ SAFE_FREE(content_info->media_meta.track_num);
+ SAFE_FREE(content_info->media_meta.description);
+ SAFE_FREE(content_info->media_meta.datetaken);
+
+ return;
+}
+
+int _media_svc_get_store_type_by_path(const char *path, media_svc_storage_type_e *storage_type)
+{
+ if(STRING_VALID(path))
+ {
+ if(strncmp(path, MEDIA_SVC_PATH_PHONE, strlen(MEDIA_SVC_PATH_PHONE)) == 0)
+ {
+ *storage_type = MEDIA_SVC_STORAGE_INTERNAL;
+ }
+ else if(strncmp (path, MEDIA_SVC_PATH_MMC, strlen(MEDIA_SVC_PATH_MMC)) == 0)
+ {
+ *storage_type = MEDIA_SVC_STORAGE_EXTERNAL;
+ }
+ }
+ else
+ {
+ media_svc_error("INVALID parameter");
+ return MEDIA_INFO_ERROR_INVALID_PARAMETER;
+ }
+
+ return MEDIA_INFO_ERROR_NONE;
+}
+
+char *_media_svc_replace_path(char *s, const char *olds, const char *news)
+{
+ char *result, *sr;
+ size_t i, count = 0;
+ size_t oldlen = strlen(olds); if (oldlen < 1) return s;
+ size_t newlen = strlen(news);
+
+ if (newlen != oldlen) {
+ for (i = 0; s[i] != '\0';) {
+ if (memcmp(&s[i], olds, oldlen) == 0) count++, i += oldlen;
+ else i++;
+ }
+ } else i = strlen(s);
+
+
+ result = (char *) calloc(1, i + 1 + count * (newlen - oldlen));
+ if (result == NULL) return NULL;
+
+ sr = result;
+ while (*s) {
+ if (memcmp(s, olds, oldlen) == 0) {
+ memcpy(sr, news, newlen);
+ sr += newlen;
+ s += oldlen;
+ } else *sr++ = *s++;
+ }
+
+ *sr = '\0';
+
+ return result;
+}
+
+int _media_svc_error_convert(int error)
+{
+ media_svc_debug("error : [%d]", error);
+
+ if(error == MS_MEDIA_ERR_NONE) /*Error None*/
+ return MEDIA_INFO_ERROR_NONE;
+ else if(error == MS_MEDIA_ERR_DB_CONNECT_FAIL) /*DB Connect Fail*/
+ return MEDIA_INFO_ERROR_DATABASE_CONNECT;
+ else if(error == MS_MEDIA_ERR_DB_DISCONNECT_FAIL) /*DB Disconnect Fail*/
+ return MEDIA_INFO_ERROR_DATABASE_DISCONNECT;
+ else if(error == MS_MEDIA_ERR_SOCKET_CONN) /*Socket Connect Fail*/
+ return MEDIA_INFO_ERROR_SOCKET_CONN;
+ else if(error == MS_MEDIA_ERR_INVALID_PARAMETER || error == MS_MEDIA_ERR_INVALID_PATH)
+ return MEDIA_INFO_ERROR_INVALID_PARAMETER;
+
+ return MEDIA_INFO_ERROR_INTERNAL;
+}
+
+
+bool _media_svc_is_drm_file(const char *path)
+{
+ int ret;
+ drm_bool_type_e is_drm_file = DRM_UNKNOWN;
+
+ ret = drm_is_drm_file(path,&is_drm_file);
+ if(DRM_RETURN_SUCCESS == ret && DRM_TRUE == is_drm_file)
+ return TRUE;
+
+ return FALSE;
+}
+
+int _media_svc_get_mime_in_drm_info(const char *path, char *mime)
+{
+ int ret = MEDIA_INFO_ERROR_NONE;
+ drm_content_info_s contentInfo;
+
+ if (path == NULL || mime == NULL)
+ return MEDIA_INFO_ERROR_INVALID_PARAMETER;
+
+ memset(&contentInfo,0x0,sizeof(drm_content_info_s));
+ ret = drm_get_content_info(path, &contentInfo);
+ if (ret != DRM_RETURN_SUCCESS) {
+ media_svc_error("drm_svc_get_content_info() fails. ");
+ return MEDIA_INFO_ERROR_INVALID_MEDIA;
+ }
+
+ strncpy(mime, contentInfo.mime_type, MEDIA_SVC_METADATA_LEN_MAX);
+ media_svc_debug("DRM contentType : %s", contentInfo.mime_type);
+ //media_svc_debug("DRM mime : %s", mime);
+
+ return MEDIA_INFO_ERROR_NONE;
+}
+
+int _media_svc_get_content_type_from_mime(const char * path, const char * mimetype, int * category)
+{
+ int i = 0;
+ int err = 0;
+
+ *category = MEDIA_SVC_CATEGORY_UNKNOWN;
+
+ //media_svc_debug("mime type : %s", mimetype);
+
+ /*categorize from mimetype */
+ for (i = 0; i < CONTENT_TYPE_NUM; i++) {
+ if (strstr(mimetype, content_category[i].content_type) != NULL) {
+ *category = (*category | content_category[i].category_by_mime);
+ break;
+ }
+ }
+
+ /*in application type, exitst sound file ex) x-smafs */
+ if (*category & MEDIA_SVC_CATEGORY_ETC) {
+ int prefix_len = strlen(content_category[0].content_type);
+
+ for (i = 0; i < SOUND_MIME_NUM; i++) {
+ if (strstr(mimetype + prefix_len, sound_mime_table[i]) != NULL) {
+ *category ^= MEDIA_SVC_CATEGORY_ETC;
+ *category |= MEDIA_SVC_CATEGORY_SOUND;
+ break;
+ }
+ }
+ }
+
+ /*check music file in soun files. */
+ if (*category & MEDIA_SVC_CATEGORY_SOUND) {
+ int prefix_len = strlen(content_category[0].content_type) + 1;
+
+ //MS_DBG("mime_type : %s", mimetype + prefix_len);
+
+ for (i = 0; i < MUSIC_MIME_NUM; i++) {
+ if (strcmp(mimetype + prefix_len, music_mime_table[i]) == 0) {
+ *category ^= MEDIA_SVC_CATEGORY_SOUND;
+ *category |= MEDIA_SVC_CATEGORY_MUSIC;
+ break;
+ }
+ }
+ } else if (*category & MEDIA_SVC_CATEGORY_VIDEO) {
+ /*some video files don't have video stream. in this case it is categorize as music. */
+ char *ext;
+ /*"3gp" and "mp4" must check video stream and then categorize in directly. */
+ ext = strrchr(path, '.');
+ if (ext != NULL) {
+ if ((strncasecmp(ext, _3GP_FILE, 4) == 0) || (strncasecmp(ext, _MP4_FILE, 5) == 0)) {
+ int audio = 0;
+ int video = 0;
+
+ err = mm_file_get_stream_info(path, &audio, &video);
+ if (err == 0) {
+ if (audio > 0 && video == 0) {
+ *category ^= MEDIA_SVC_CATEGORY_VIDEO;
+ *category |= MEDIA_SVC_CATEGORY_MUSIC;
+ }
+ }
+ }
+ }
+ }
+
+ //media_svc_debug("category_from_ext : %d", *category);
+
+ return err;
+}
--- /dev/null
+/*
+ * libmedia-service
+ *
+ * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
+ *
+ * Contact: Hyunjun Ko <zzoon.ko@samsung.com>, Haejeong Kim <backto.kim@samsung.com>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+#include <string.h>
+#include <aul/aul.h>
+#include <media-util.h>
+#include "media-svc.h"
+#include "media-svc-media.h"
+#include "media-svc-debug.h"
+#include "media-svc-util.h"
+#include "media-svc-db-utils.h"
+#include "media-svc-media-folder.h"
+#include "media-svc-album.h"
+
+
+static __thread int g_media_svc_item_validity_data_cnt = 1;
+static __thread int g_media_svc_item_validity_cur_data_cnt = 0;
+
+static __thread int g_media_svc_move_item_data_cnt = 1;
+static __thread int g_media_svc_move_item_cur_data_cnt = 0;
+
+static __thread int g_media_svc_insert_item_data_cnt = 1;
+static __thread int g_media_svc_insert_item_cur_data_cnt = 0;
+
+
+
+
+int media_svc_connect(MediaSvcHandle **handle)
+{
+ int ret = MEDIA_INFO_ERROR_NONE;
+ MediaDBHandle *db_handle = NULL;
+
+ media_svc_debug_func();
+
+#if 1 //Use libmedia_utils API
+ ret = media_db_connect(&db_handle);
+ if(ret != MS_MEDIA_ERR_NONE)
+ return _media_svc_error_convert(ret);
+
+#else
+ sqlite3 * db_handle = NULL;
+
+ ret = _media_svc_connect_db_with_handle(&db_handle);
+ media_svc_retv_if(ret != MEDIA_INFO_ERROR_NONE, ret);
+#endif
+
+ *handle = db_handle;
+ return MEDIA_INFO_ERROR_NONE;
+
+}
+
+int media_svc_disconnect(MediaSvcHandle *handle)
+{
+ MediaDBHandle * db_handle = (MediaDBHandle *)handle;
+
+ media_svc_debug_func();
+
+ media_svc_retvm_if(db_handle == NULL, MEDIA_INFO_ERROR_INVALID_PARAMETER, "Handle is NULL");
+
+#if 1 //Use libmedia_utils API
+ int ret = MEDIA_INFO_ERROR_NONE;
+
+ ret = media_db_disconnect(db_handle);
+ return _media_svc_error_convert(ret);
+#else
+ sqlite3 * db_handle = (sqlite3 *)handle;
+
+ return _media_svc_disconnect_db_with_handle(db_handle);
+#endif
+}
+
+int media_svc_create_table(MediaSvcHandle *handle)
+{
+ int ret = MEDIA_INFO_ERROR_NONE;
+ sqlite3 * db_handle = (sqlite3 *)handle;
+
+ media_svc_debug_func();
+
+ media_svc_retvm_if(db_handle == NULL, MEDIA_INFO_ERROR_INVALID_PARAMETER, "Handle is NULL");
+
+ /*create media table*/
+ ret = _media_svc_create_media_table(handle);
+ media_svc_retv_if(ret != MEDIA_INFO_ERROR_NONE, ret);
+
+ /*create folder table*/
+ ret = _media_svc_create_folder_table(handle);
+ media_svc_retv_if(ret != MEDIA_INFO_ERROR_NONE, ret);
+
+ /*create playlist table*/
+ ret = _media_svc_create_playlist_table(handle);
+ media_svc_retv_if(ret != MEDIA_INFO_ERROR_NONE, ret);
+
+ /* create album table*/
+ ret = _media_svc_create_album_table(handle);
+ media_svc_retv_if(ret != MEDIA_INFO_ERROR_NONE, ret);
+
+ /*create tag table*/
+ ret = _media_svc_create_tag_table(handle);
+ media_svc_retv_if(ret != MEDIA_INFO_ERROR_NONE, ret);
+
+ /*create bookmark table*/
+ ret = _media_svc_create_bookmark_table(handle);
+ media_svc_retv_if(ret != MEDIA_INFO_ERROR_NONE, ret);
+
+#if 0 /*unify media and custom table*/
+ /*create custom table*/
+ ret = _media_svc_create_custom_table(handle);
+ media_svc_retv_if(ret != MEDIA_INFO_ERROR_NONE, ret);
+#endif
+
+ return MEDIA_INFO_ERROR_NONE;
+}
+
+int media_svc_get_storage_type(const char *path, media_svc_storage_type_e *storage_type)
+{
+ int ret = MEDIA_INFO_ERROR_NONE;
+ media_svc_storage_type_e type;
+
+ ret = _media_svc_get_store_type_by_path(path, &type);
+ media_svc_retvm_if(ret < MEDIA_INFO_ERROR_NONE, ret, "_media_svc_get_store_type_by_path failed : %d", ret);
+
+ *storage_type = type;
+
+ return ret;
+}
+
+int media_svc_get_mime_type(const char *path, char *mimetype)
+{
+ int ret = MEDIA_INFO_ERROR_NONE;
+
+ if (path == NULL)
+ return MEDIA_INFO_ERROR_INVALID_PARAMETER;
+
+ /* In case of drm file. */
+ if (_media_svc_is_drm_file(path)) {
+ ret = _media_svc_get_mime_in_drm_info(path, mimetype);
+ if (ret != MEDIA_INFO_ERROR_NONE) {
+ media_svc_error("Fail to get mime");
+ return ret;
+ }
+ } else {
+ /*in case of normal files */
+ if (aul_get_mime_from_file(path, mimetype, 255) < 0) {
+ media_svc_error("aul_get_mime_from_file fail");
+ return MEDIA_INFO_ERROR_INVALID_MEDIA;
+ }
+ }
+
+ return MEDIA_INFO_ERROR_NONE;
+}
+
+int media_svc_get_media_type(const char *path, const char *mime_type, media_svc_media_type_e *media_type)
+{
+ int ret = MEDIA_INFO_ERROR_NONE;
+ int category = 0;
+
+ media_svc_media_type_e type;
+
+ ret = _media_svc_get_content_type_from_mime(path, mime_type, &category);
+ if (ret < 0) {
+ media_svc_error("_media_svc_get_content_type_from_mime failed : %d", ret);
+ }
+
+ if (category & MEDIA_SVC_CATEGORY_SOUND) type = MEDIA_SVC_MEDIA_TYPE_SOUND;
+ else if (category & MEDIA_SVC_CATEGORY_MUSIC) type = MEDIA_SVC_MEDIA_TYPE_MUSIC;
+ else if (category & MEDIA_SVC_CATEGORY_IMAGE) type = MEDIA_SVC_MEDIA_TYPE_IMAGE;
+ else if (category & MEDIA_SVC_CATEGORY_VIDEO) type = MEDIA_SVC_MEDIA_TYPE_VIDEO;
+ else type = MEDIA_SVC_MEDIA_TYPE_OTHER;
+
+ *media_type = type;
+
+ return ret;
+}
+
+int media_svc_check_item_exist_by_path(MediaSvcHandle *handle, const char *path)
+{
+ int ret = MEDIA_INFO_ERROR_NONE;
+ sqlite3 * db_handle = (sqlite3 *)handle;
+ int count = -1;
+
+ media_svc_retvm_if(db_handle == NULL, MEDIA_INFO_ERROR_INVALID_PARAMETER, "Handle is NULL");
+ media_svc_retvm_if(!STRING_VALID(path), MEDIA_INFO_ERROR_INVALID_PARAMETER, "Path is NULL");
+
+ ret = _media_svc_count_record_with_path(db_handle, path, &count);
+ media_svc_retv_if(ret != MEDIA_INFO_ERROR_NONE, ret);
+
+ if(count > 0) {
+ media_svc_debug("item is exist in database");
+ return MEDIA_INFO_ERROR_NONE;
+ } else {
+ media_svc_debug("item is not exist in database");
+ return MEDIA_INFO_ERROR_DATABASE_NO_RECORD;
+ }
+
+ return MEDIA_INFO_ERROR_NONE;
+}
+
+int media_svc_insert_item_begin(MediaSvcHandle *handle, int data_cnt)
+{
+ sqlite3 * db_handle = (sqlite3 *)handle;
+
+ media_svc_debug("Transaction data count : [%d]", data_cnt);
+
+ media_svc_retvm_if(db_handle == NULL, MEDIA_INFO_ERROR_INVALID_PARAMETER, "Handle is NULL");
+ media_svc_retvm_if(data_cnt < 1, MEDIA_INFO_ERROR_INVALID_PARAMETER, "data_cnt shuld be bigger than 1");
+
+ g_media_svc_insert_item_data_cnt = data_cnt;
+ g_media_svc_insert_item_cur_data_cnt = 0;
+
+ return MEDIA_INFO_ERROR_NONE;
+}
+
+int media_svc_insert_item_end(MediaSvcHandle *handle)
+{
+ int ret = MEDIA_INFO_ERROR_NONE;
+ sqlite3 * db_handle = (sqlite3 *)handle;
+
+ media_svc_debug_func();
+
+ media_svc_retvm_if(db_handle == NULL, MEDIA_INFO_ERROR_INVALID_PARAMETER, "Handle is NULL");
+
+ if (g_media_svc_insert_item_cur_data_cnt > 0) {
+
+ ret = _media_svc_list_query_do(db_handle, MEDIA_SVC_QUERY_INSERT_ITEM);
+ }
+
+ g_media_svc_insert_item_data_cnt = 1;
+ g_media_svc_insert_item_cur_data_cnt = 0;
+
+ return ret;
+}
+
+int media_svc_insert_item_bulk(MediaSvcHandle *handle, media_svc_storage_type_e storage_type,
+ const char *path, const char *mime_type, media_svc_media_type_e media_type)
+{
+ int ret = MEDIA_INFO_ERROR_NONE;
+ sqlite3 * db_handle = (sqlite3 *)handle;
+ char folder_uuid[MEDIA_SVC_UUID_SIZE+1] = {0,};
+
+ media_svc_retvm_if(db_handle == NULL, MEDIA_INFO_ERROR_INVALID_PARAMETER, "Handle is NULL");
+ media_svc_retvm_if(!STRING_VALID(path), MEDIA_INFO_ERROR_INVALID_PARAMETER, "path is NULL");
+ media_svc_retvm_if(!STRING_VALID(mime_type), MEDIA_INFO_ERROR_INVALID_PARAMETER, "mime_type is NULL");
+
+ if ((storage_type != MEDIA_SVC_STORAGE_INTERNAL) && (storage_type != MEDIA_SVC_STORAGE_EXTERNAL)) {
+ media_svc_error("storage type is incorrect[%d]", storage_type);
+ return MEDIA_INFO_ERROR_INVALID_PARAMETER;
+ }
+
+ if ((media_type < MEDIA_SVC_MEDIA_TYPE_IMAGE) || (media_type > MEDIA_SVC_MEDIA_TYPE_OTHER)) {
+ media_svc_error("invalid media_type condition[%d]", media_type);
+ return MEDIA_INFO_ERROR_INVALID_PARAMETER;
+ }
+
+ media_svc_debug("storage[%d], path[%s], media_type[%d]", storage_type, path, media_type);
+
+ media_svc_content_info_s content_info;
+ memset(&content_info, 0, sizeof(media_svc_content_info_s));
+
+ /*Set media info*/
+ ret = _media_svc_set_media_info(&content_info, storage_type, path, mime_type, media_type, FALSE);
+ media_svc_retv_if(ret != MEDIA_INFO_ERROR_NONE, ret);
+
+ if(media_type == MEDIA_SVC_MEDIA_TYPE_OTHER) {
+ /*Do nothing.*/
+ } else if(media_type == MEDIA_SVC_MEDIA_TYPE_IMAGE) {
+ ret = _media_svc_extract_image_metadata(&content_info, media_type);
+ media_svc_retv_if(ret != MEDIA_INFO_ERROR_NONE, ret);
+ } else {
+ ret = _media_svc_extract_media_metadata(handle, &content_info, media_type);
+ media_svc_retv_if(ret != MEDIA_INFO_ERROR_NONE, ret);
+ }
+
+ /*Set or Get folder id*/
+ ret = _media_svc_get_and_append_folder_id_by_path(handle, path, storage_type, folder_uuid);
+ media_svc_retv_if(ret != MEDIA_INFO_ERROR_NONE, ret);
+
+ ret = __media_svc_malloc_and_strncpy(&content_info.folder_uuid, folder_uuid);
+ media_svc_retv_del_if(ret != MEDIA_INFO_ERROR_NONE, ret, &content_info);
+
+ if (g_media_svc_insert_item_data_cnt == 1) {
+
+ ret = _media_svc_insert_item_with_data(db_handle, &content_info, FALSE);
+ media_svc_retv_del_if(ret != MEDIA_INFO_ERROR_NONE, ret, &content_info);
+
+ } else if(g_media_svc_insert_item_cur_data_cnt < (g_media_svc_insert_item_data_cnt - 1)) {
+
+ ret = _media_svc_insert_item_with_data(db_handle, &content_info, TRUE);
+ media_svc_retv_del_if(ret != MEDIA_INFO_ERROR_NONE, ret, &content_info);
+
+ g_media_svc_insert_item_cur_data_cnt ++;
+
+ } else if (g_media_svc_insert_item_cur_data_cnt == (g_media_svc_insert_item_data_cnt - 1)) {
+
+ ret = _media_svc_insert_item_with_data(db_handle, &content_info, TRUE);
+ media_svc_retv_del_if(ret != MEDIA_INFO_ERROR_NONE, ret, &content_info);
+
+ ret = _media_svc_list_query_do(db_handle, MEDIA_SVC_QUERY_INSERT_ITEM);
+ media_svc_retv_del_if(ret != MEDIA_INFO_ERROR_NONE, ret, &content_info);
+
+ g_media_svc_insert_item_cur_data_cnt = 0;
+
+ } else {
+ media_svc_error("Error in media_svc_insert_item_bulk");
+ _media_svc_destroy_content_info(&content_info);
+ return MEDIA_INFO_ERROR_INTERNAL;
+ }
+
+ _media_svc_destroy_content_info(&content_info);
+
+ return MEDIA_INFO_ERROR_NONE;
+}
+
+int media_svc_insert_item_immediately(MediaSvcHandle *handle, media_svc_storage_type_e storage_type,
+ const char *path, const char *mime_type, media_svc_media_type_e media_type)
+{
+ int ret = MEDIA_INFO_ERROR_NONE;
+ sqlite3 * db_handle = (sqlite3 *)handle;
+ char folder_uuid[MEDIA_SVC_UUID_SIZE+1] = {0,};
+
+ media_svc_retvm_if(db_handle == NULL, MEDIA_INFO_ERROR_INVALID_PARAMETER, "Handle is NULL");
+ media_svc_retvm_if(!STRING_VALID(path), MEDIA_INFO_ERROR_INVALID_PARAMETER, "path is NULL");
+ media_svc_retvm_if(!STRING_VALID(mime_type), MEDIA_INFO_ERROR_INVALID_PARAMETER, "mime_type is NULL");
+
+ if ((storage_type != MEDIA_SVC_STORAGE_INTERNAL) && (storage_type != MEDIA_SVC_STORAGE_EXTERNAL)) {
+ media_svc_error("storage type is incorrect[%d]", storage_type);
+ return MEDIA_INFO_ERROR_INVALID_PARAMETER;
+ }
+
+ if ((media_type < MEDIA_SVC_MEDIA_TYPE_IMAGE) || (media_type > MEDIA_SVC_MEDIA_TYPE_OTHER)) {
+ media_svc_error("invalid media_type condition[%d]", media_type);
+ return MEDIA_INFO_ERROR_INVALID_PARAMETER;
+ }
+
+ media_svc_debug("storage[%d], path[%s], media_type[%d]", storage_type, path, media_type);
+
+ media_svc_content_info_s content_info;
+ memset(&content_info, 0, sizeof(media_svc_content_info_s));
+
+ /*Set media info*/
+ ret = _media_svc_set_media_info(&content_info, storage_type, path, mime_type, media_type, FALSE);
+ media_svc_retv_if(ret != MEDIA_INFO_ERROR_NONE, ret);
+
+ if(media_type == MEDIA_SVC_MEDIA_TYPE_OTHER) {
+ /*Do nothing.*/
+ } else if(media_type == MEDIA_SVC_MEDIA_TYPE_IMAGE) {
+ ret = _media_svc_extract_image_metadata(&content_info, media_type);
+ media_svc_retv_if(ret != MEDIA_INFO_ERROR_NONE, ret);
+ } else {
+ ret = _media_svc_extract_media_metadata(handle, &content_info, media_type);
+ media_svc_retv_if(ret != MEDIA_INFO_ERROR_NONE, ret);
+ }
+
+ /*Set or Get folder id*/
+ ret = _media_svc_get_and_append_folder_id_by_path(handle, path, storage_type, folder_uuid);
+ media_svc_retv_if(ret != MEDIA_INFO_ERROR_NONE, ret);
+
+ ret = __media_svc_malloc_and_strncpy(&content_info.folder_uuid, folder_uuid);
+ media_svc_retv_del_if(ret != MEDIA_INFO_ERROR_NONE, ret, &content_info);
+#if 1
+ /* Extracting thumbnail */
+ if (media_type == MEDIA_SVC_MEDIA_TYPE_IMAGE || media_type == MEDIA_SVC_MEDIA_TYPE_VIDEO) {
+ char thumb_path[MEDIA_SVC_PATHNAME_SIZE + 1] = {0, };
+ int width = 0;
+ int height = 0;
+
+ ret = thumbnail_request_from_db_with_size(content_info.path, thumb_path, sizeof(thumb_path), &width, &height);
+ if (ret < 0) {
+ media_svc_error("thumbnail_request_from_db failed: %d", ret);
+ } else {
+ media_svc_debug("thumbnail_request_from_db success: %s", thumb_path);
+ }
+
+ if (content_info.media_meta.width <= 0)
+ content_info.media_meta.width = width;
+
+ if (content_info.media_meta.height <= 0)
+ content_info.media_meta.height = height;
+
+ ret = __media_svc_malloc_and_strncpy(&(content_info.thumbnail_path), thumb_path);
+ media_svc_retv_del_if(ret != MEDIA_INFO_ERROR_NONE, ret, &content_info);
+ }
+#endif
+ ret = _media_svc_insert_item_with_data(db_handle, &content_info, FALSE);
+
+ _media_svc_destroy_content_info(&content_info);
+ return ret;
+}
+
+int media_svc_insert_folder(MediaSvcHandle *handle, media_svc_storage_type_e storage_type, const char *path)
+{
+ int ret = MEDIA_INFO_ERROR_NONE;
+ sqlite3 * db_handle = (sqlite3 *)handle;
+
+ media_svc_retvm_if(db_handle == NULL, MEDIA_INFO_ERROR_INVALID_PARAMETER, "Handle is NULL");
+ media_svc_retvm_if(!STRING_VALID(path), MEDIA_INFO_ERROR_INVALID_PARAMETER, "path is NULL");
+
+ if ((storage_type != MEDIA_SVC_STORAGE_INTERNAL) && (storage_type != MEDIA_SVC_STORAGE_EXTERNAL)) {
+ media_svc_error("storage type is incorrect[%d]", storage_type);
+ return MEDIA_INFO_ERROR_INVALID_PARAMETER;
+ }
+
+ media_svc_debug("storage[%d], folder_path[%s]", storage_type, path);
+
+ /*Get folder info*/
+ char *folder_name = NULL;
+ int folder_modified_date = 0;
+ char *folder_uuid = _media_info_generate_uuid();
+ if(folder_uuid == NULL ) {
+ media_svc_error("Invalid UUID");
+ return MEDIA_INFO_ERROR_INTERNAL;
+ }
+
+ folder_name = g_path_get_basename(path);
+ folder_modified_date = _media_svc_get_file_time(path);
+
+ ret = _media_svc_append_folder(handle, storage_type, folder_uuid, path, folder_name, folder_modified_date);
+ SAFE_FREE(folder_name);
+
+ if (ret < MEDIA_INFO_ERROR_NONE) {
+ media_svc_error("_media_svc_append_folder error [%d]", ret);
+ return ret;
+ }
+
+ return MEDIA_INFO_ERROR_NONE;
+}
+
+int media_svc_move_item_begin(MediaSvcHandle *handle, int data_cnt)
+{
+ sqlite3 * db_handle = (sqlite3 *)handle;
+
+ media_svc_debug("Transaction data count : [%d]", data_cnt);
+
+ media_svc_retvm_if(db_handle == NULL, MEDIA_INFO_ERROR_INVALID_PARAMETER, "Handle is NULL");
+ media_svc_retvm_if(data_cnt < 1, MEDIA_INFO_ERROR_INVALID_PARAMETER, "data_cnt shuld be bigger than 1");
+
+ g_media_svc_move_item_data_cnt = data_cnt;
+ g_media_svc_move_item_cur_data_cnt = 0;
+
+ return MEDIA_INFO_ERROR_NONE;
+}
+
+int media_svc_move_item_end(MediaSvcHandle *handle)
+{
+ int ret = MEDIA_INFO_ERROR_NONE;
+ sqlite3 * db_handle = (sqlite3 *)handle;
+
+ media_svc_debug_func();
+
+ media_svc_retvm_if(db_handle == NULL, MEDIA_INFO_ERROR_INVALID_PARAMETER, "Handle is NULL");
+
+ if (g_media_svc_move_item_cur_data_cnt > 0) {
+
+ ret = _media_svc_list_query_do(db_handle, MEDIA_SVC_QUERY_MOVE_ITEM);
+ }
+
+ /*clean up old folder path*/
+ ret = _media_svc_update_folder_table(handle);
+ media_svc_retv_if(ret != MEDIA_INFO_ERROR_NONE, ret);
+
+ g_media_svc_move_item_data_cnt = 1;
+ g_media_svc_move_item_cur_data_cnt = 0;
+
+ return ret;
+}
+
+int media_svc_move_item(MediaSvcHandle *handle, media_svc_storage_type_e src_storage, const char *src_path,
+ media_svc_storage_type_e dest_storage, const char *dest_path)
+{
+ int ret = MEDIA_INFO_ERROR_NONE;
+ sqlite3 * db_handle = (sqlite3 *)handle;
+ char *file_name = NULL;
+ char *folder_path = NULL;
+ int modified_time = 0;
+ char folder_uuid[MEDIA_SVC_UUID_SIZE+1] = {0,};
+ char old_thumb_path[MEDIA_SVC_PATHNAME_SIZE] = {0,};
+ char new_thumb_path[MEDIA_SVC_PATHNAME_SIZE] = {0,};
+ int media_type = -1;
+
+ media_svc_debug_func();
+
+ media_svc_retvm_if(db_handle == NULL, MEDIA_INFO_ERROR_INVALID_PARAMETER, "Handle is NULL");
+ media_svc_retvm_if(!STRING_VALID(src_path), MEDIA_INFO_ERROR_INVALID_PARAMETER, "src_path is NULL");
+ media_svc_retvm_if(!STRING_VALID(dest_path), MEDIA_INFO_ERROR_INVALID_PARAMETER, "dest_path is NULL");
+
+ if ((src_storage != MEDIA_SVC_STORAGE_INTERNAL) && (src_storage != MEDIA_SVC_STORAGE_EXTERNAL)) {
+ media_svc_error("src_storage type is incorrect[%d]", src_storage);
+ return MEDIA_INFO_ERROR_INVALID_PARAMETER;
+ }
+ if ((dest_storage != MEDIA_SVC_STORAGE_INTERNAL) && (dest_storage != MEDIA_SVC_STORAGE_EXTERNAL)) {
+ media_svc_error("dest_storage type is incorrect[%d]", dest_storage);
+ return MEDIA_INFO_ERROR_INVALID_PARAMETER;
+ }
+
+ /*check and update folder*/
+ ret = _media_svc_get_and_append_folder_id_by_path(handle, dest_path, dest_storage, folder_uuid);
+ media_svc_retv_if(ret != MEDIA_INFO_ERROR_NONE, ret);
+
+ /*get filename*/
+ file_name = g_path_get_basename(dest_path);
+
+ /*get modified_time*/
+ modified_time = _media_svc_get_file_time(dest_path);
+
+ /*get thumbnail_path to update. only for Imgae and Video items. Audio share album_art(thumbnail)*/
+ ret = _media_svc_get_media_type_by_path(handle, src_path, &media_type);
+ media_svc_retv_if(ret != MEDIA_INFO_ERROR_NONE, ret);
+
+ if((media_type == MEDIA_SVC_MEDIA_TYPE_IMAGE) ||(media_type == MEDIA_SVC_MEDIA_TYPE_VIDEO)) {
+ /*get old thumbnail_path*/
+ ret = _media_svc_get_thumbnail_path_by_path(handle, src_path, old_thumb_path);
+ media_svc_retv_if((ret != MEDIA_INFO_ERROR_NONE) && (ret != MEDIA_INFO_ERROR_DATABASE_NO_RECORD), ret);
+
+ _media_svc_get_thumbnail_path(dest_storage, new_thumb_path, dest_path, THUMB_EXT);
+ }
+
+ if (g_media_svc_move_item_data_cnt == 1) {
+
+ /*update item*/
+ if((media_type == MEDIA_SVC_MEDIA_TYPE_IMAGE) ||(media_type == MEDIA_SVC_MEDIA_TYPE_VIDEO)) {
+ ret = _media_svc_update_item_by_path(handle, src_path, dest_storage, dest_path, file_name, modified_time, folder_uuid, new_thumb_path, FALSE);
+ } else {
+ ret = _media_svc_update_item_by_path(handle, src_path, dest_storage, dest_path, file_name, modified_time, folder_uuid, NULL, FALSE);
+ }
+ SAFE_FREE(file_name);
+ media_svc_retv_if(ret != MEDIA_INFO_ERROR_NONE, ret);
+
+ /*update folder modified_time*/
+ folder_path = g_path_get_dirname(dest_path);
+ ret = _media_svc_update_folder_modified_time_by_folder_uuid(handle, folder_uuid, folder_path, FALSE);
+ SAFE_FREE(folder_path);
+ media_svc_retv_if(ret != MEDIA_INFO_ERROR_NONE, ret);
+
+ ret = _media_svc_update_folder_table(handle);
+ media_svc_retv_if(ret != MEDIA_INFO_ERROR_NONE, ret);
+
+ } else if (g_media_svc_move_item_cur_data_cnt < (g_media_svc_move_item_data_cnt - 1)) {
+
+ /*update item*/
+ if((media_type == MEDIA_SVC_MEDIA_TYPE_IMAGE) ||(media_type == MEDIA_SVC_MEDIA_TYPE_VIDEO)) {
+ ret = _media_svc_update_item_by_path(handle, src_path, dest_storage, dest_path, file_name, modified_time, folder_uuid, new_thumb_path, TRUE);
+ } else {
+ ret = _media_svc_update_item_by_path(handle, src_path, dest_storage, dest_path, file_name, modified_time, folder_uuid, NULL, TRUE);
+ }
+ SAFE_FREE(file_name);
+ media_svc_retv_if(ret != MEDIA_INFO_ERROR_NONE, ret);
+
+ /*update folder modified_time*/
+ folder_path = g_path_get_dirname(dest_path);
+ ret = _media_svc_update_folder_modified_time_by_folder_uuid(handle, folder_uuid, folder_path, TRUE);
+ SAFE_FREE(folder_path);
+ media_svc_retv_if(ret != MEDIA_INFO_ERROR_NONE, ret);
+
+ g_media_svc_move_item_cur_data_cnt ++;
+
+ } else if (g_media_svc_move_item_cur_data_cnt == (g_media_svc_move_item_data_cnt - 1)) {
+
+ /*update item*/
+ if((media_type == MEDIA_SVC_MEDIA_TYPE_IMAGE) ||(media_type == MEDIA_SVC_MEDIA_TYPE_VIDEO)) {
+ ret = _media_svc_update_item_by_path(handle, src_path, dest_storage, dest_path, file_name, modified_time, folder_uuid, new_thumb_path, TRUE);
+ } else {
+ ret = _media_svc_update_item_by_path(handle, src_path, dest_storage, dest_path, file_name, modified_time, folder_uuid, NULL, TRUE);
+ }
+ SAFE_FREE(file_name);
+ media_svc_retv_if(ret != MEDIA_INFO_ERROR_NONE, ret);
+
+ /*update folder modified_time*/
+ folder_path = g_path_get_dirname(dest_path);
+ ret = _media_svc_update_folder_modified_time_by_folder_uuid(handle, folder_uuid, folder_path, TRUE);
+ SAFE_FREE(folder_path);
+ media_svc_retv_if(ret != MEDIA_INFO_ERROR_NONE, ret);
+
+ /*update db*/
+ ret = _media_svc_list_query_do(db_handle, MEDIA_SVC_QUERY_MOVE_ITEM);
+ media_svc_retv_if(ret != MEDIA_INFO_ERROR_NONE, ret);
+
+ g_media_svc_move_item_cur_data_cnt = 0;
+
+ } else {
+ media_svc_error("Error in media_svc_move_item");
+ return MEDIA_INFO_ERROR_INTERNAL;
+ }
+
+ /*rename thumbnail file*/
+ if((media_type == MEDIA_SVC_MEDIA_TYPE_IMAGE) ||(media_type == MEDIA_SVC_MEDIA_TYPE_VIDEO)) {
+ if(strlen(old_thumb_path) > 0) {
+ ret = _media_svc_rename_file(old_thumb_path,new_thumb_path);
+ media_svc_retv_if(ret != MEDIA_INFO_ERROR_NONE, ret);
+ }
+ }
+
+ return MEDIA_INFO_ERROR_NONE;
+}
+
+int media_svc_set_item_validity_begin(MediaSvcHandle *handle, int data_cnt)
+{
+ sqlite3 * db_handle = (sqlite3 *)handle;
+
+ media_svc_debug("Transaction data count : [%d]", data_cnt);
+
+ media_svc_retvm_if(db_handle == NULL, MEDIA_INFO_ERROR_INVALID_PARAMETER, "Handle is NULL");
+ media_svc_retvm_if(data_cnt < 1, MEDIA_INFO_ERROR_INVALID_PARAMETER, "data_cnt shuld be bigger than 1");
+
+ g_media_svc_item_validity_data_cnt = data_cnt;
+ g_media_svc_item_validity_cur_data_cnt = 0;
+
+ return MEDIA_INFO_ERROR_NONE;
+}
+
+int media_svc_set_item_validity_end(MediaSvcHandle *handle)
+{
+ int ret = MEDIA_INFO_ERROR_NONE;
+ sqlite3 * db_handle = (sqlite3 *)handle;
+
+ media_svc_debug_func();
+
+ media_svc_retvm_if(db_handle == NULL, MEDIA_INFO_ERROR_INVALID_PARAMETER, "Handle is NULL");
+
+ if (g_media_svc_item_validity_cur_data_cnt > 0) {
+
+ ret = _media_svc_list_query_do(db_handle, MEDIA_SVC_QUERY_SET_ITEM_VALIDITY);
+ }
+
+ g_media_svc_item_validity_data_cnt = 1;
+ g_media_svc_item_validity_cur_data_cnt = 0;
+
+ return ret;
+}
+
+int media_svc_set_item_validity(MediaSvcHandle *handle, const char *path, int validity)
+{
+ int ret = MEDIA_INFO_ERROR_NONE;
+ sqlite3 * db_handle = (sqlite3 *)handle;
+
+ media_svc_retvm_if(db_handle == NULL, MEDIA_INFO_ERROR_INVALID_PARAMETER, "Handle is NULL");
+ media_svc_retvm_if(!STRING_VALID(path), MEDIA_INFO_ERROR_INVALID_PARAMETER, "path is NULL");
+
+ media_svc_debug("path=[%s], validity=[%d]", path, validity);
+
+ if (g_media_svc_item_validity_data_cnt == 1) {
+
+ return _media_svc_update_item_validity(db_handle, path, validity, FALSE);
+
+ } else if (g_media_svc_item_validity_cur_data_cnt < (g_media_svc_item_validity_data_cnt - 1)) {
+
+ ret = _media_svc_update_item_validity(db_handle, path, validity, TRUE);
+ media_svc_retv_if(ret != MEDIA_INFO_ERROR_NONE, ret);
+
+ g_media_svc_item_validity_cur_data_cnt ++;
+
+ } else if (g_media_svc_item_validity_cur_data_cnt == (g_media_svc_item_validity_data_cnt - 1)) {
+
+ ret = _media_svc_update_item_validity(db_handle, path, validity, TRUE);
+ media_svc_retv_if(ret != MEDIA_INFO_ERROR_NONE, ret);
+
+ ret = _media_svc_list_query_do(db_handle, MEDIA_SVC_QUERY_SET_ITEM_VALIDITY);
+ media_svc_retv_if(ret != MEDIA_INFO_ERROR_NONE, ret);
+
+ g_media_svc_item_validity_cur_data_cnt = 0;
+
+ } else {
+
+ media_svc_error("Error in media_svc_set_item_validity");
+ return MEDIA_INFO_ERROR_INTERNAL;
+ }
+
+ return MEDIA_INFO_ERROR_NONE;
+}
+
+int media_svc_delete_item_by_path(MediaSvcHandle *handle, const char *path)
+{
+ int ret = MEDIA_INFO_ERROR_NONE;
+ sqlite3 * db_handle = (sqlite3 *)handle;
+ char thumb_path[MEDIA_SVC_PATHNAME_SIZE] = {0,};
+
+ media_svc_debug_func();
+
+ media_svc_retvm_if(db_handle == NULL, MEDIA_INFO_ERROR_INVALID_PARAMETER, "Handle is NULL");
+ media_svc_retvm_if(!STRING_VALID(path), MEDIA_INFO_ERROR_INVALID_PARAMETER, "path is NULL");
+
+ /*Get thumbnail path to delete*/
+ ret = _media_svc_get_thumbnail_path_by_path(db_handle, path, thumb_path);
+ media_svc_retv_if((ret != MEDIA_INFO_ERROR_NONE) && (ret != MEDIA_INFO_ERROR_DATABASE_NO_RECORD), ret);
+
+ /*Delete item*/
+ ret = _media_svc_delete_item_by_path(db_handle, path);
+ media_svc_retv_if(ret != MEDIA_INFO_ERROR_NONE, ret);
+
+ /*Delete thumbnail*/
+ if (strlen(thumb_path) > 0) {
+ if (_media_svc_remove_file(thumb_path) == FALSE) {
+ media_svc_error("fail to remove thumbnail file.");
+ return MEDIA_INFO_ERROR_INTERNAL;
+ }
+ }
+
+ return MEDIA_INFO_ERROR_NONE;
+}
+
+int media_svc_delete_all_items_in_storage(MediaSvcHandle *handle, media_svc_storage_type_e storage_type)
+{
+ int ret = MEDIA_INFO_ERROR_NONE;
+ sqlite3 * db_handle = (sqlite3 *)handle;
+ char * dirpath = NULL;
+
+ media_svc_debug("media_svc_delete_all_items_in_storage [%d]", storage_type);
+
+ media_svc_retvm_if(db_handle == NULL, MEDIA_INFO_ERROR_INVALID_PARAMETER, "Handle is NULL");
+
+ if ((storage_type != MEDIA_SVC_STORAGE_INTERNAL) && (storage_type != MEDIA_SVC_STORAGE_EXTERNAL)) {
+ media_svc_error("storage type is incorrect[%d]", storage_type);
+ return MEDIA_INFO_ERROR_INVALID_PARAMETER;
+ }
+
+ ret = _media_svc_truncate_table(db_handle, storage_type);
+ media_svc_retv_if(ret != MEDIA_INFO_ERROR_NONE, ret);
+
+ dirpath = (storage_type == MEDIA_SVC_STORAGE_INTERNAL) ? MEDIA_SVC_THUMB_INTERNAL_PATH : MEDIA_SVC_THUMB_EXTERNAL_PATH;
+
+ /* remove thumbnails */
+ ret = _media_svc_remove_all_files_in_dir(dirpath);
+ media_svc_retv_if(ret != MEDIA_INFO_ERROR_NONE, ret);
+
+ return MEDIA_INFO_ERROR_NONE;
+}
+
+int media_svc_delete_invalid_items_in_storage(MediaSvcHandle *handle, media_svc_storage_type_e storage_type)
+{
+ sqlite3 * db_handle = (sqlite3 *)handle;
+
+ media_svc_debug_func();
+
+ media_svc_retvm_if(db_handle == NULL, MEDIA_INFO_ERROR_INVALID_PARAMETER, "Handle is NULL");
+
+ if ((storage_type != MEDIA_SVC_STORAGE_INTERNAL) && (storage_type != MEDIA_SVC_STORAGE_EXTERNAL)) {
+ media_svc_error("storage type is incorrect[%d]", storage_type);
+ return MEDIA_INFO_ERROR_INVALID_PARAMETER;
+ }
+
+ /*Delete from DB and remove thumbnail files*/
+ return _media_svc_delete_invalid_items(db_handle, storage_type);
+}
+
+int media_svc_delete_invalid_items_in_folder(MediaSvcHandle *handle, const char *folder_path)
+{
+ sqlite3 * db_handle = (sqlite3 *)handle;
+
+ media_svc_debug_func();
+
+ media_svc_retvm_if(db_handle == NULL, MEDIA_INFO_ERROR_INVALID_PARAMETER, "Handle is NULL");
+
+ /*Delete from DB and remove thumbnail files*/
+ return _media_svc_delete_invalid_folder_items(db_handle, folder_path);
+}
+
+int media_svc_set_all_storage_items_validity(MediaSvcHandle *handle, media_svc_storage_type_e storage_type, int validity)
+{
+ sqlite3 * db_handle = (sqlite3 *)handle;
+
+ media_svc_retvm_if(db_handle == NULL, MEDIA_INFO_ERROR_INVALID_PARAMETER, "Handle is NULL");
+
+ if ((storage_type != MEDIA_SVC_STORAGE_INTERNAL) && (storage_type != MEDIA_SVC_STORAGE_EXTERNAL)) {
+ media_svc_error("storage type is incorrect[%d]", storage_type);
+ return MEDIA_INFO_ERROR_INVALID_PARAMETER;
+ }
+
+ return _media_svc_update_storage_item_validity(db_handle, storage_type, validity);
+}
+
+int media_svc_set_folder_items_validity(MediaSvcHandle *handle, const char *folder_path, int validity, int recursive)
+{
+ sqlite3 * db_handle = (sqlite3 *)handle;
+
+ media_svc_retvm_if(db_handle == NULL, MEDIA_INFO_ERROR_INVALID_PARAMETER, "Handle is NULL");
+ media_svc_retvm_if(!STRING_VALID(folder_path), MEDIA_INFO_ERROR_INVALID_PARAMETER, "folder_path is NULL");
+
+ if(recursive)
+ return _media_svc_update_recursive_folder_item_validity(db_handle, folder_path, validity);
+ else
+ return _media_svc_update_folder_item_validity(db_handle, folder_path, validity);
+}
+
+int media_svc_refresh_item(MediaSvcHandle *handle, media_svc_storage_type_e storage_type,
+ const char *path, media_svc_media_type_e media_type)
+{
+ int ret = MEDIA_INFO_ERROR_NONE;
+ sqlite3 * db_handle = (sqlite3 *)handle;
+
+ media_svc_retvm_if(db_handle == NULL, MEDIA_INFO_ERROR_INVALID_PARAMETER, "Handle is NULL");
+ media_svc_retvm_if(!STRING_VALID(path), MEDIA_INFO_ERROR_INVALID_PARAMETER, "path is NULL");
+
+ if ((storage_type != MEDIA_SVC_STORAGE_INTERNAL) && (storage_type != MEDIA_SVC_STORAGE_EXTERNAL)) {
+ media_svc_error("storage type is incorrect[%d]", storage_type);
+ return MEDIA_INFO_ERROR_INVALID_PARAMETER;
+ }
+
+ if ((media_type < MEDIA_SVC_MEDIA_TYPE_IMAGE) || (media_type > MEDIA_SVC_MEDIA_TYPE_OTHER)) {
+ media_svc_error("invalid media_type condition[%d]", media_type);
+ return MEDIA_INFO_ERROR_INVALID_PARAMETER;
+ }
+
+ media_svc_debug("storage[%d], path[%s], media_type[%d]", storage_type, path, media_type);
+
+ media_svc_content_info_s content_info;
+ memset(&content_info, 0, sizeof(media_svc_content_info_s));
+
+ /*Set media info*/
+ ret = _media_svc_set_media_info(&content_info, storage_type, path, NULL, media_type, TRUE);
+ media_svc_retv_if(ret != MEDIA_INFO_ERROR_NONE, ret);
+
+ /* Initialize thumbnail information to remake thumbnail. */
+ char thumb_path[MEDIA_SVC_PATHNAME_SIZE + 1];
+ ret = _media_svc_get_thumbnail_path_by_path(handle, path, thumb_path);
+ media_svc_retv_if(ret != MEDIA_INFO_ERROR_NONE, ret);
+
+ if (g_file_test(thumb_path, G_FILE_TEST_EXISTS)) {
+ ret = _media_svc_remove_file(thumb_path);
+ media_svc_retv_if(ret != TRUE, ret);
+ }
+
+ ret = _media_svc_update_thumbnail_path(handle, path, NULL);
+ media_svc_retv_if(ret != MEDIA_INFO_ERROR_NONE, ret);
+
+ if(media_type == MEDIA_SVC_MEDIA_TYPE_OTHER) {
+ /*Do nothing.*/
+ } else if(media_type == MEDIA_SVC_MEDIA_TYPE_IMAGE) {
+ ret = _media_svc_extract_image_metadata(&content_info, media_type);
+ media_svc_retv_if(ret != MEDIA_INFO_ERROR_NONE, ret);
+ } else {
+ ret = _media_svc_extract_media_metadata(handle, &content_info, media_type);
+ media_svc_retv_if(ret != MEDIA_INFO_ERROR_NONE, ret);
+ }
+#if 1
+ /* Extracting thumbnail */
+ if (media_type == MEDIA_SVC_MEDIA_TYPE_IMAGE || media_type == MEDIA_SVC_MEDIA_TYPE_VIDEO) {
+ char thumb_path[MEDIA_SVC_PATHNAME_SIZE + 1] = {0, };
+ int width = 0;
+ int height = 0;
+
+ ret = thumbnail_request_from_db_with_size(content_info.path, thumb_path, sizeof(thumb_path), &width, &height);
+ if (ret < 0) {
+ media_svc_error("thumbnail_request_from_db failed: %d", ret);
+ } else {
+ media_svc_debug("thumbnail_request_from_db success: %s", thumb_path);
+ }
+
+ if (content_info.media_meta.width <= 0)
+ content_info.media_meta.width = width;
+
+ if (content_info.media_meta.height <= 0)
+ content_info.media_meta.height = height;
+
+ ret = __media_svc_malloc_and_strncpy(&(content_info.thumbnail_path), thumb_path);
+ media_svc_retv_del_if(ret != MEDIA_INFO_ERROR_NONE, ret, &content_info);
+ }
+#endif
+ ret = _media_svc_update_item_with_data(db_handle, &content_info);
+
+ _media_svc_destroy_content_info(&content_info);
+
+ return ret;
+}
+
+int media_svc_rename_folder(MediaSvcHandle *handle, const char *src_path, const char *dst_path)
+{
+ sqlite3 * db_handle = (sqlite3 *)handle;
+ int ret = MEDIA_INFO_ERROR_NONE;
+
+ media_svc_retvm_if(db_handle == NULL, MEDIA_INFO_ERROR_INVALID_PARAMETER, "Handle is NULL");
+ media_svc_retvm_if(src_path == NULL, MEDIA_INFO_ERROR_INVALID_PARAMETER, "src_path is NULL");
+ media_svc_retvm_if(dst_path == NULL, MEDIA_INFO_ERROR_INVALID_PARAMETER, "dst_path is NULL");
+
+ media_svc_debug("Src path : %s, Dst Path : %s", src_path, dst_path);
+
+ ret = _media_svc_sql_begin_trans(handle);
+ media_svc_retv_if(ret != MEDIA_INFO_ERROR_NONE, ret);
+
+ /* Update all folder record's path, which are matched by old parent path */
+ char *update_folder_path_sql = NULL;
+ char src_path_slash[MEDIA_SVC_PATHNAME_SIZE + 1];
+ char dst_path_slash[MEDIA_SVC_PATHNAME_SIZE + 1];
+
+ snprintf(src_path_slash, sizeof(src_path_slash), "%s/", src_path);
+ snprintf(dst_path_slash, sizeof(dst_path_slash), "%s/", dst_path);
+
+ update_folder_path_sql = sqlite3_mprintf("UPDATE folder SET path = REPLACE( path, '%q', '%q');", src_path_slash, dst_path_slash);
+
+ //ret = _media_svc_sql_query(handle, update_folder_path_sql);
+ ret = media_db_request_update_db_batch(update_folder_path_sql);
+ sqlite3_free(update_folder_path_sql);
+
+ if (ret != SQLITE_OK) {
+ media_svc_error("failed to update folder path");
+ _media_svc_sql_rollback_trans(handle);
+
+ return MEDIA_INFO_ERROR_DATABASE_INTERNAL;
+ }
+
+ /* Update all folder record's modified date, which are changed above */
+ char *update_folder_modified_time_sql = NULL;
+ time_t date;
+ time(&date);
+
+ update_folder_modified_time_sql = sqlite3_mprintf("UPDATE folder SET modified_time = %d where path like '%q';", date, dst_path);
+
+ ret = media_db_request_update_db_batch(update_folder_modified_time_sql);
+ //ret = _media_svc_sql_query(handle, update_folder_modified_time_sql);
+ sqlite3_free(update_folder_modified_time_sql);
+
+ if (ret != SQLITE_OK) {
+ media_svc_error("failed to update folder modified time");
+ _media_svc_sql_rollback_trans(handle);
+
+ return MEDIA_INFO_ERROR_DATABASE_INTERNAL;
+ }
+
+ /* Update all items */
+ char *select_all_sql = NULL;
+ sqlite3_stmt *sql_stmt = NULL;
+ char dst_child_path[MEDIA_SVC_PATHNAME_SIZE + 1];
+
+ snprintf(dst_child_path, sizeof(dst_child_path), "%s/%%", dst_path);
+
+ select_all_sql = sqlite3_mprintf("SELECT media_uuid, path, thumbnail_path, media_type from media where folder_uuid IN ( SELECT folder_uuid FROM folder where path='%q' or path like '%q');", dst_path, dst_child_path);
+
+ media_svc_debug("[SQL query] : %s", select_all_sql);
+
+ ret = sqlite3_prepare_v2(handle, select_all_sql, -1, &sql_stmt, NULL);
+ sqlite3_free((char *)select_all_sql);
+
+ if (ret != SQLITE_OK) {
+ media_svc_error ("prepare error [%s]", sqlite3_errmsg(handle));
+ _media_svc_sql_rollback_trans(handle);
+ return MEDIA_INFO_ERROR_DATABASE_INTERNAL;
+ }
+
+ while (1) {
+ ret = sqlite3_step(sql_stmt);
+ if (ret != SQLITE_ROW) {
+ media_svc_debug("end of iteration");
+ break;
+ }
+
+ char media_uuid[MEDIA_SVC_UUID_SIZE + 1] = {0,};
+ char media_path[MEDIA_SVC_PATHNAME_SIZE + 1] = {0,};
+ char media_thumb_path[MEDIA_SVC_PATHNAME_SIZE + 1] = {0,};
+ char media_new_thumb_path[MEDIA_SVC_PATHNAME_SIZE + 1] = {0,};
+ int media_type;
+ bool no_thumb = FALSE;
+
+ if (STRING_VALID((const char *)sqlite3_column_text(sql_stmt, 0))) {
+ strncpy(media_uuid, (const char *)sqlite3_column_text(sql_stmt, 0), sizeof(media_uuid));
+ } else {
+ media_svc_error("media UUID is NULL");
+ return MEDIA_INFO_ERROR_DATABASE_INVALID;
+ }
+
+ if (STRING_VALID((const char *)sqlite3_column_text(sql_stmt, 1))) {
+ strncpy(media_path, (const char *)sqlite3_column_text(sql_stmt, 1), sizeof(media_path));
+ } else {
+ media_svc_error("media path is NULL");
+ return MEDIA_INFO_ERROR_DATABASE_INVALID;
+ }
+
+ if (STRING_VALID((const char *)sqlite3_column_text(sql_stmt, 2))) {
+ strncpy(media_thumb_path, (const char *)sqlite3_column_text(sql_stmt, 2), sizeof(media_thumb_path));
+ } else {
+ media_svc_debug("media thumb path doesn't exist in DB");
+ no_thumb = TRUE;
+ }
+
+ media_type = sqlite3_column_int(sql_stmt, 3);
+
+ /* Update path, thumbnail path of this item */
+ char *replaced_path = NULL;
+ replaced_path = _media_svc_replace_path(media_path, src_path, dst_path);
+ if (replaced_path == NULL) {
+ media_svc_error("_media_svc_replace_path failed");
+ SQLITE3_FINALIZE(sql_stmt);
+ _media_svc_sql_rollback_trans(handle);
+ return MEDIA_INFO_ERROR_INTERNAL;
+ }
+
+ media_svc_debug("New media path : %s", replaced_path);
+ media_svc_storage_type_e storage_type;
+
+ if (!no_thumb) {
+ ret = _media_svc_get_store_type_by_path(replaced_path, &storage_type);
+ if (ret < 0) {
+ media_svc_error("_media_svc_get_store_type_by_path failed : %d", ret);
+ SAFE_FREE(replaced_path);
+ _media_svc_sql_rollback_trans(handle);
+ return MEDIA_INFO_ERROR_DATABASE_INTERNAL;
+ }
+
+ ret = _media_svc_get_thumbnail_path(storage_type, media_new_thumb_path, replaced_path, THUMB_EXT);
+ if (ret < 0) {
+ media_svc_error("_media_svc_get_thumbnail_path failed : %d", ret);
+ SAFE_FREE(replaced_path);
+ SQLITE3_FINALIZE(sql_stmt);
+ _media_svc_sql_rollback_trans(handle);
+ return MEDIA_INFO_ERROR_INTERNAL;
+ }
+
+ //media_svc_debug("New media thumbnail path : %s", media_new_thumb_path);
+ }
+
+ char *update_item_sql = NULL;
+
+ if (no_thumb) {
+ update_item_sql = sqlite3_mprintf("UPDATE media SET path='%q' WHERE media_uuid='%q'", replaced_path, media_uuid);
+ } else {
+ if (media_type == MEDIA_SVC_MEDIA_TYPE_IMAGE || media_type == MEDIA_SVC_MEDIA_TYPE_VIDEO) {
+ update_item_sql = sqlite3_mprintf("UPDATE media SET path='%q', thumbnail_path='%q' WHERE media_uuid='%q'", replaced_path, media_new_thumb_path, media_uuid);
+ } else {
+ update_item_sql = sqlite3_mprintf("UPDATE media SET path='%q', thumbnail_path='%q' WHERE media_uuid='%q'", replaced_path, media_thumb_path, media_uuid);
+ }
+ }
+
+ ret = media_db_request_update_db_batch(update_item_sql);
+ //ret = _media_svc_sql_query(handle, update_item_sql);
+ sqlite3_free(update_item_sql);
+ SAFE_FREE(replaced_path);
+
+ if (ret != SQLITE_OK) {
+ media_svc_error("failed to update item");
+ SQLITE3_FINALIZE(sql_stmt);
+ _media_svc_sql_rollback_trans(handle);
+
+ return MEDIA_INFO_ERROR_DATABASE_INTERNAL;
+ }
+
+ /* Rename thumbnail file of file system */
+ if ((!no_thumb) && (media_type == MEDIA_SVC_MEDIA_TYPE_IMAGE || media_type == MEDIA_SVC_MEDIA_TYPE_VIDEO)) {
+ ret = _media_svc_rename_file(media_thumb_path, media_new_thumb_path);
+ if (ret < 0) {
+ media_svc_error("_media_svc_rename_file failed : %d", ret);
+ SQLITE3_FINALIZE(sql_stmt);
+ _media_svc_sql_rollback_trans(handle);
+
+ return MEDIA_INFO_ERROR_INTERNAL;
+ }
+ }
+ }
+
+ SQLITE3_FINALIZE(sql_stmt);
+
+ ret = _media_svc_sql_end_trans(handle);
+ if (ret != MEDIA_INFO_ERROR_NONE) {
+ media_svc_error("mb_svc_sqlite3_commit_trans failed.. Now start to rollback\n");
+ _media_svc_sql_rollback_trans(handle);
+ return ret;
+ }
+
+ return MEDIA_INFO_ERROR_NONE;
+}
+
+int media_svc_request_update_db(const char *db_query)
+{
+ int ret = MEDIA_INFO_ERROR_NONE;
+
+ media_svc_retvm_if(!STRING_VALID(db_query), MEDIA_INFO_ERROR_INVALID_PARAMETER, "db_query is NULL");
+
+ ret = _media_svc_request_update_db(db_query);
+
+ return _media_svc_error_convert(ret);
+}
--- /dev/null
+/*
+ * libmedia-service
+ *
+ * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
+ *
+ * Contact: Hyunjun Ko <zzoon.ko@samsung.com>, Haejeong Kim <backto.kim@samsung.com>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+#ifndef _MEDIA_SVC_ALBUM_H_
+#define _MEDIA_SVC_ALBUM_H_
+
+#include <sqlite3.h>
+
+int _media_svc_get_album_id(sqlite3 *handle, const char *album, const char *artist, int * album_id);
+int _media_svc_get_album_art_by_album_id(sqlite3 *handle, int album_id, char **album_art);
+int _media_svc_append_album(sqlite3 *handle, const char *album, const char *artist, const char *album_art, int * album_id);
+
+
+#endif /*_MEDIA_SVC_ALBUM_H_*/
--- /dev/null
+/*
+ * libmedia-service
+ *
+ * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
+ *
+ * Contact: Hyunjun Ko <zzoon.ko@samsung.com>, Haejeong Kim <backto.kim@samsung.com>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+
+#ifndef _MEDIA_SVC_DB_UTILS_H_
+#define _MEDIA_SVC_DB_UTILS_H_
+
+#include <sqlite3.h>
+#include <glib.h>
+
+#define SQLITE3_FINALIZE(x) if(x != NULL) {sqlite3_finalize(x);}
+
+int _media_svc_connect_db_with_handle(sqlite3 **db_handle);
+int _media_svc_disconnect_db_with_handle(sqlite3 *db_handle);
+int _media_svc_create_media_table(sqlite3 *db_handle);
+int _media_svc_create_folder_table(sqlite3 *db_handle);
+int _media_svc_create_playlist_table(sqlite3 *db_handle);
+int _media_svc_create_album_table(sqlite3 *db_handle);
+int _media_svc_create_tag_table(sqlite3 *db_handle);
+int _media_svc_create_bookmark_table(sqlite3 *db_handle);
+int _media_svc_create_custom_table(sqlite3 *db_handle);
+int _media_svc_request_update_db(const char *sql_str);
+int _media_svc_sql_query(sqlite3 *db_handle, const char *sql_str);
+int _media_svc_sql_prepare_to_step(sqlite3 *handle, const char *sql_str, sqlite3_stmt** stmt);
+int _media_svc_sql_begin_trans(sqlite3 *handle);
+int _media_svc_sql_end_trans(sqlite3 *handle);
+int _media_svc_sql_rollback_trans(sqlite3 *handle);
+int _media_svc_sql_query_list(sqlite3 *handle, GList **query_list);
+void _media_svc_sql_query_add(GList **query_list, char **query);
+void _media_svc_sql_query_release(GList **query_list);
+
+#endif /*_MEDIA_SVC_DB_UTILS_H_*/
--- /dev/null
+/*
+ * libmedia-service
+ *
+ * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
+ *
+ * Contact: Hyunjun Ko <zzoon.ko@samsung.com>, Haejeong Kim <backto.kim@samsung.com>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+
+
+#ifndef _MEDIA_SVC_DEBUG_H_
+#define _MEDIA_SVC_DEBUG_H_
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <dlog.h>
+
+#ifdef LOG_TAG
+#undef LOG_TAG
+#endif
+
+#define LOG_TAG "MEDIA_SERVICE"
+
+#define media_svc_debug(fmt, arg...) do { \
+ LOGD(" "fmt"", ##arg); \
+ } while (0)
+
+#define media_svc_error(fmt, arg...) do { \
+ LOGE(" "fmt"", ##arg); \
+ } while (0)
+
+#define media_svc_debug_func() do { \
+ LOGD(""); \
+ } while (0)
+
+#define media_svc_retm_if(expr, fmt, arg...) do { \
+ if(expr) { \
+ LOGE(" "fmt"", ##arg); \
+ return; \
+ } \
+ } while (0)
+#define media_svc_retv_if(expr, val) do { \
+ if(expr) { \
+ LOGE(""); \
+ return (val); \
+ } \
+ } while (0)
+#define media_svc_retvm_if(expr, val, fmt, arg...) do { \
+ if(expr) { \
+ LOGE(" "fmt"", ##arg); \
+ return (val); \
+ } \
+ } while (0)
+
+#define media_svc_retv_del_if(expr, val, p_str) do { \
+ if(expr) { \
+ LOGE(""); \
+ _media_svc_destroy_content_info(p_str); \
+ return (val); \
+ } \
+ } while (0)
+
+#ifdef _USE_LOG_FILE_
+void mediainfo_init_file_debug();
+void mediainfo_close_file_debug();
+FILE* get_fp();
+#define mediainfo_file_dbg(fmt,arg...) fprintf( get_fp(), "[%s: %d] [%s]" fmt "\n", __FILE__, __LINE__, __FUNCTION__, ##arg)
+
+#endif
+
+
+#ifdef _PERFORMANCE_CHECK_
+long
+mediainfo_get_debug_time(void);
+void
+mediainfo_reset_debug_time(void);
+void
+mediainfo_print_debug_time(char* time_string);
+void
+mediainfo_print_debug_time_ex(long start, long end, const char* func_name, char* time_string);
+#endif
+
+#endif /*_MEDIA_SVC_DEBUG_H_*/
--- /dev/null
+/*
+ * libmedia-service
+ *
+ * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
+ *
+ * Contact: Hyunjun Ko <zzoon.ko@samsung.com>, Haejeong Kim <backto.kim@samsung.com>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+
+
+#ifndef _MEDIA_SVC_ENV_H_
+#define _MEDIA_SVC_ENV_H_
+
+#include <time.h>
+#include <media-util.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * DB information
+ */
+
+#define MEDIA_SVC_DB_NAME MEDIA_DB_NAME /**< media db name*/
+
+/**
+ * DB table information
+ */
+
+#define MEDIA_SVC_DB_TABLE_MEDIA "media" /**< media table*/
+#define MEDIA_SVC_DB_TABLE_FOLDER "folder" /**< media_folder table*/
+#define MEDIA_SVC_DB_TABLE_PLAYLIST "playlist" /**< playlist table*/
+#define MEDIA_SVC_DB_TABLE_PLAYLIST_MAP "playlist_map" /**< playlist_map table*/
+#define MEDIA_SVC_DB_TABLE_ALBUM "album" /**< album table*/
+#define MEDIA_SVC_DB_TABLE_TAG "tag" /**< tag table*/
+#define MEDIA_SVC_DB_TABLE_TAG_MAP "tag_map" /**< tag_map table*/
+#define MEDIA_SVC_DB_TABLE_BOOKMARK "bookmark" /**< bookmark table*/
+#define MEDIA_SVC_DB_TABLE_CUSTOM "custom" /**< custom table*/
+
+
+#define MEDIA_SVC_METADATA_LEN_MAX 128 /**< Length of metadata*/
+#define MEDIA_SVC_METADATA_DESCRIPTION_MAX 512 /**< Length of description*/
+#define MEDIA_SVC_PATHNAME_SIZE 4096 /**< Length of Path name. */
+#define MEDIA_SVC_UUID_SIZE 36 /**< Length of UUID*/
+
+#define MEDIA_SVC_TAG_UNKNOWN "Unknown"
+#define MEDIA_SVC_MEDIA_PATH MEDIA_DATA_PATH /**< Media path*/
+#define MEDIA_SVC_THUMB_PATH_PREFIX MEDIA_SVC_MEDIA_PATH"/.thumb" /**< Thumbnail path prefix*/
+#define MEDIA_SVC_THUMB_INTERNAL_PATH MEDIA_SVC_THUMB_PATH_PREFIX"/phone" /**< Phone thumbnail path*/
+#define MEDIA_SVC_THUMB_EXTERNAL_PATH MEDIA_SVC_THUMB_PATH_PREFIX"/mmc" /**< MMC thumbnail path*/
+
+#define MEDIA_SVC_DEFAULT_GPS_VALUE -200 /**< Default GPS Value*/
+#define THUMB_EXT "jpg"
+
+#define MEDIA_SVC_PATH_PHONE MEDIA_ROOT_PATH_INTERNAL
+#define MEDIA_SVC_PATH_MMC MEDIA_ROOT_PATH_SDCARD
+
+enum Exif_Orientation {
+ NOT_AVAILABLE=0,
+ NORMAL =1,
+ HFLIP =2,
+ ROT_180 =3,
+ VFLIP =4,
+ TRANSPOSE =5,
+ ROT_90 =6,
+ TRANSVERSE =7,
+ ROT_270 =8
+};
+
+#if 0
+/**
+ * Media meta data information
+ */
+typedef struct {
+ char title[MEDIA_SVC_METADATA_LEN_MAX]; /**< track title*/
+ char album[MEDIA_SVC_METADATA_LEN_MAX]; /**< album name*/
+ char artist[MEDIA_SVC_METADATA_LEN_MAX]; /**< artist name*/
+ char genre[MEDIA_SVC_METADATA_LEN_MAX]; /**< genre of track*/
+ char author[MEDIA_SVC_METADATA_LEN_MAX]; /**< author name*/
+ char year[MEDIA_SVC_METADATA_LEN_MAX]; /**< author name*/
+ char recorded_date[MEDIA_SVC_METADATA_LEN_MAX]; /**< recorded date*/
+ char copyright[MEDIA_SVC_METADATA_LEN_MAX]; /**< copyright*/
+ char track_num[MEDIA_SVC_METADATA_LEN_MAX]; /**< track number*/
+ char description[MEDIA_SVC_METADATA_DESCRIPTION_MAX]; /**< description*/
+ int bitrate; /**< bitrate*/
+ int samplerate; /**< samplerate*/
+ int channel; /**< channel*/
+ int duration; /**< duration*/
+ float longitude; /**< longitude*/
+ float latitude; /**< latitude*/
+ float altitude; /**< altitude*/
+ int width; /**< width*/
+ int height; /**< height*/
+ char datetaken[MEDIA_SVC_METADATA_LEN_MAX]; /**< datetaken*/
+ char timetaken[MEDIA_SVC_METADATA_LEN_MAX]; /**< timetaken*/
+ int orientation; /**< orientation*/
+ int rating; /**< user defined rating */
+} media_svc_content_meta_s;
+
+
+/**
+ * Media data information
+ */
+typedef struct {
+ char media_uuid[MEDIA_SVC_UUID_SIZE+1]; /**< Unique ID of item */
+ char path[MEDIA_SVC_PATHNAME_SIZE]; /**< Full path and file name of media file */
+ char file_name[MEDIA_SVC_PATHNAME_SIZE]; /**< Full path and file name of media file */
+ int media_type; /**< Type of media file : internal/external */
+ char mime_type[MEDIA_SVC_PATHNAME_SIZE]; /**< Full path and file name of media file */
+ int size;
+ int added_time; /**< added time */
+ int modified_time; /**< modified time */
+ char folder_uuid[MEDIA_SVC_UUID_SIZE+1]; /**< Unique ID of folder */
+ int album_id; /**< Unique ID of album */
+ char thumbnail_path[MEDIA_SVC_PATHNAME_SIZE]; /**< Thumbnail image file path */
+ int played_count; /**< played count */
+ int last_played_time; /**< last played time */
+ int last_played_position;
+ int favourate; /**< favourate. o or 1 */
+ int hiding; /**< hiding. o or 1 */
+ int is_drm; /**< is_drm. o or 1 */
+ int storage_type; /**< Storage of media file : internal/external */
+ media_svc_content_meta_s media_meta; /**< meta data structure for audio files */
+} media_svc_content_info_s;
+#else
+/**
+ * Media meta data information
+ */
+typedef struct {
+ char * title; /**< track title*/
+ char * album; /**< album name*/
+ char * artist; /**< artist name*/
+ char * genre; /**< genre of track*/
+ char * composer; /**< composer name*/
+ char * year; /**< year*/
+ char * recorded_date; /**< recorded date*/
+ char * copyright; /**< copyright*/
+ char * track_num; /**< track number*/
+ char * description; /**< description*/
+ int bitrate; /**< bitrate*/
+ int samplerate; /**< samplerate*/
+ int channel; /**< channel*/
+ int duration; /**< duration*/
+ float longitude; /**< longitude*/
+ float latitude; /**< latitude*/
+ float altitude; /**< altitude*/
+ int width; /**< width*/
+ int height; /**< height*/
+ char * datetaken; /**< datetaken*/
+ int orientation; /**< orientation*/
+ int rating; /**< user defined rating */
+} media_svc_content_meta_s;
+
+
+/**
+ * Media data information
+ */
+typedef struct {
+ char * media_uuid; /**< Unique ID of item */
+ char * path; /**< Full path of media file */
+ char * file_name; /**< File name of media file. Display name */
+ int media_type; /**< Type of media file : internal/external */
+ char * mime_type; /**< Full path and file name of media file */
+ unsigned long long size; /**< size */
+ time_t added_time; /**< added time, time_t */
+ time_t modified_time; /**< modified time, time_t */
+ char * folder_uuid; /**< Unique ID of folder */
+ int album_id; /**< Unique ID of album */
+ char * thumbnail_path; /**< Thumbnail image file path */
+ int played_count; /**< played count */
+ int last_played_time; /**< last played time */
+ int last_played_position; /**< last played position */
+ int favourate; /**< favourate. o or 1 */
+ int is_drm; /**< is_drm. o or 1 */
+ int storage_type; /**< Storage of media file : internal/external */
+ media_svc_content_meta_s media_meta; /**< meta data structure for audio files */
+} media_svc_content_info_s;
+#endif
+
+typedef enum{
+ MEDIA_SVC_QUERY_INSERT_ITEM,
+ MEDIA_SVC_QUERY_SET_ITEM_VALIDITY,
+ MEDIA_SVC_QUERY_MOVE_ITEM,
+} media_svc_query_type_e;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /*_MEDIA_SVC_ENV_H_*/
--- /dev/null
+/*
+ * libmedia-service
+ *
+ * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
+ *
+ * Contact: Hyunjun Ko <zzoon.ko@samsung.com>, Haejeong Kim <backto.kim@samsung.com>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+#ifndef _MEDIA_SVC_MEDIA_FOLDER_H_
+#define _MEDIA_SVC_MEDIA_FOLDER_H_
+
+#include <sqlite3.h>
+#include <stdbool.h>
+#include "media-svc-types.h"
+
+int _media_svc_get_folder_id_by_foldername(sqlite3 *handle, const char *folder_name, char *folder_id);
+int _media_svc_append_folder(sqlite3 *handle, media_svc_storage_type_e storage_type, const char *folder_id, const char *path_name, const char *folder_name, int modified_date);
+int _media_svc_update_folder_modified_time_by_folder_uuid(sqlite3 *handle, const char *folder_uuid, const char *folder_path, bool stack_query);
+int _media_svc_get_and_append_folder_id_by_path(sqlite3 *handle, const char *path, media_svc_storage_type_e storage_type, char *folder_id);
+int _media_svc_update_folder_table(sqlite3 *handle);
+
+#endif /*_MEDIA_SVC_MEDIA_FOLDER_H_*/
--- /dev/null
+/*
+ * libmedia-service
+ *
+ * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
+ *
+ * Contact: Hyunjun Ko <zzoon.ko@samsung.com>, Haejeong Kim <backto.kim@samsung.com>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+#ifndef _MEDIA_SVC_MEDIA_H_
+#define _MEDIA_SVC_MEDIA_H_
+
+#include <sqlite3.h>
+#include <stdbool.h>
+#include "media-svc-types.h"
+#include "media-svc-env.h"
+
+int _media_svc_count_record_with_path(sqlite3 *handle, const char *path, int *count);
+int _media_svc_insert_item_with_data(sqlite3 *handle, media_svc_content_info_s *content_info, bool stack_query);
+int _media_svc_update_item_with_data(sqlite3 *handle, media_svc_content_info_s *content_info);
+int _media_svc_get_thumbnail_path_by_path(sqlite3 *handle, const char *path, char *thumbnail_path);
+int _media_svc_get_media_type_by_path(sqlite3 *handle, const char *path, int *media_type);
+int _media_svc_delete_item_by_path(sqlite3 *handle, const char *path);
+int _media_svc_truncate_table(sqlite3 *handle, media_svc_storage_type_e storage_type);
+int _media_svc_delete_invalid_items(sqlite3 *handle, media_svc_storage_type_e storage_type);
+int _media_svc_delete_invalid_folder_items(sqlite3 *handle, const char *folder_path);
+int _media_svc_update_storage_item_validity(sqlite3 *handle, media_svc_storage_type_e storage_type, int validity);
+int _media_svc_update_folder_item_validity(sqlite3 *handle, const char *folder_path, int validity);
+int _media_svc_update_recursive_folder_item_validity(sqlite3 *handle, const char *folder_path, int validity);
+int _media_svc_update_item_validity(sqlite3 *handle, const char *path, int validity, bool stack_query);
+int _media_svc_update_item_by_path(sqlite3 *handle, const char *src_path, media_svc_storage_type_e dest_storage, const char *dest_path, const char *file_name, int modified_time, const char *folder_uuid, const char *thumb_path, bool stack_query);
+int _media_svc_list_query_do(sqlite3 *handle, media_svc_query_type_e query_type);
+int _media_svc_get_media_id_by_path(sqlite3 *handle, const char *path, char *media_uuid, int max_length);
+int _media_svc_update_thumbnail_path(sqlite3 *handle, const char *path, const char *thumb_path);
+
+#endif /*_MEDIA_SVC_MEDIA_H_*/
--- /dev/null
+/*
+ * libmedia-service
+ *
+ * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
+ *
+ * Contact: Hyunjun Ko <zzoon.ko@samsung.com>, Haejeong Kim <backto.kim@samsung.com>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+
+
+#ifndef _MEDIA_SVC_UTIL_H_
+#define _MEDIA_SVC_UTIL_H_
+
+#include <string.h>
+#include <stdbool.h>
+#include <sqlite3.h>
+#include "media-svc-types.h"
+#include "media-svc-env.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifndef FALSE
+#define FALSE 0
+#endif
+#ifndef TRUE
+#define TRUE 1
+#endif
+
+#define SAFE_FREE(src) { if(src) {free(src); src = NULL;}}
+#define STRING_VALID(str) \
+ ((str != NULL && strlen(str) > 0) ? TRUE : FALSE)
+
+char *_media_info_generate_uuid(void);
+char *_media_svc_escape_str(char *input, int len);
+void _strncpy_safe(char *x_dst, const char *x_src, int max_len);
+unsigned int _media_svc_get_current_time(void);
+int _media_svc_rename_file( const char *old_name, const char *new_name);
+bool _media_svc_remove_file(const char *path);
+int _media_svc_remove_all_files_in_dir(const char *dir_path);
+char *_media_svc_get_title_from_filepath (const char *path);
+int _media_svc_save_image(void *image, int size, char *image_path);
+bool _media_svc_get_thumbnail_path(media_svc_storage_type_e storage_type, char *thumb_path, const char *pathname, const char *img_format);
+bool _media_svc_get_file_ext(const char *file_path, char *file_ext);
+int _media_svc_get_file_time(const char *full_path);
+int _media_svc_set_media_info(media_svc_content_info_s *content_info, media_svc_storage_type_e storage_type, const char *path, const char *mime_type, media_svc_media_type_e media_type, bool refresh);
+int _media_svc_extract_image_metadata(media_svc_content_info_s *content_info, media_svc_media_type_e media_type);
+int _media_svc_extract_media_metadata(sqlite3 *handle, media_svc_content_info_s *content_info, media_svc_media_type_e media_type);
+int __media_svc_malloc_and_strncpy(char **dst, const char *src);
+void _media_svc_destroy_content_info(media_svc_content_info_s *content_info);
+int _media_svc_get_store_type_by_path(const char *path, media_svc_storage_type_e *storage_type);
+char *_media_svc_replace_path(char *s, const char *olds, const char *news);
+
+int _media_svc_error_convert(int error);
+
+/* Define data structures for media type and mime type */
+#define MEDIA_SVC_CATEGORY_UNKNOWN 0x00000000 /**< Default */
+#define MEDIA_SVC_CATEGORY_ETC 0x00000001 /**< ETC category */
+#define MEDIA_SVC_CATEGORY_IMAGE 0x00000002 /**< Image category */
+#define MEDIA_SVC_CATEGORY_VIDEO 0x00000004 /**< Video category */
+#define MEDIA_SVC_CATEGORY_MUSIC 0x00000008 /**< Music category */
+#define MEDIA_SVC_CATEGORY_SOUND 0x00000010 /**< Sound category */
+
+#define CONTENT_TYPE_NUM 4
+#define MUSIC_MIME_NUM 29
+#define SOUND_MIME_NUM 1
+#define MIME_TYPE_LENGTH 255
+#define MIME_LENGTH 50
+#define _3GP_FILE ".3gp"
+#define _MP4_FILE ".mp4"
+
+typedef struct {
+ char content_type[15];
+ int category_by_mime;
+} _media_svc_content_table_s;
+
+static const _media_svc_content_table_s content_category[CONTENT_TYPE_NUM] = {
+ {"audio", MEDIA_SVC_CATEGORY_SOUND},
+ {"image", MEDIA_SVC_CATEGORY_IMAGE},
+ {"video", MEDIA_SVC_CATEGORY_VIDEO},
+ {"application", MEDIA_SVC_CATEGORY_ETC},
+};
+
+static const char music_mime_table[MUSIC_MIME_NUM][MIME_LENGTH] = {
+ /*known mime types of normal files*/
+ "mpeg",
+ "ogg",
+ "x-ms-wma",
+ "x-flac",
+ "mp4",
+ /* known mime types of drm files*/
+ "mp3",
+ "x-mp3", /*alias of audio/mpeg*/
+ "x-mpeg", /*alias of audio/mpeg*/
+ "3gpp",
+ "x-ogg", /*alias of audio/ogg*/
+ "vnd.ms-playready.media.pya:*.pya", /*playready*/
+ "wma",
+ "aac",
+ "x-m4a", /*alias of audio/mp4*/
+ /* below mimes are rare*/
+ "x-vorbis+ogg",
+ "x-flac+ogg",
+ "x-matroska",
+ "ac3",
+ "mp2",
+ "x-ape",
+ "x-ms-asx",
+ "vnd.rn-realaudio",
+
+ "x-vorbis", /*alias of audio/x-vorbis+ogg*/
+ "vorbis", /*alias of audio/x-vorbis+ogg*/
+ "x-oggflac",
+ "x-mp2", /*alias of audio/mp2*/
+ "x-pn-realaudio", /*alias of audio/vnd.rn-realaudio*/
+ "vnd.m-realaudio", /*alias of audio/vnd.rn-realaudio*/
+ "x-wav",
+};
+
+static const char sound_mime_table[SOUND_MIME_NUM][MIME_LENGTH] = {
+ "x-smaf",
+};
+
+bool _media_svc_is_drm_file(const char *path);
+int _media_svc_get_mime_in_drm_info(const char *path, char *mime);
+int _media_svc_get_content_type_from_mime(const char * path, const char * mimetype, int * category);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /*_MEDIA_SVC_UTIL_H_*/
--- /dev/null
+CC =gcc
+LIBS = libmedia-service
+
+OBJS = media_svc_plugin_test.o
+SRCS = media_svc_plugin_test.c
+TARGET = plugin_test
+
+TARGET : $(OBJS)
+ $(CC) -o $(TARGET) $(OBJS) -ldl `pkg-config $(LIBS) --cflags --libs` -g
+$(OBJS) : $(SRCS)
+ $(CC) -c $(SRCS) -I../../include -L../../cmake_build_tmp `pkg-config $(LIBS) --cflags --libs` -g
+clean :
+ rm $(TARGET)
+ rm $(OBJS)
--- /dev/null
+/*
+ * libmedia-service
+ *
+ * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
+ *
+ * Contact: Hyunjun Ko <zzoon.ko@samsung.com>, Haejeong Kim <backto.kim@samsung.com>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <dlfcn.h>
+#include <media-svc.h>
+
+#define PLUGIN_SO_FILE_NAME "/usr/lib/libmedia-content-plugin.so"
+void *funcHandle = NULL;
+
+static void msg_print(int line, char *msg);
+
+int (*svc_check_item) (const char *file_path, const char * mime_type, char ** err_msg);
+int (*svc_connect) (void ** handle, char ** err_msg);
+int (*svc_disconnect) (void * handle, char ** err_msg);
+int (*svc_check_item_exist) (void* handle, const char *file_path, int storage_type, char ** err_msg);
+int (*svc_insert_item_immediately) (void* handle, const char *file_path, int storage_type, const char * mime_type, char ** err_msg);
+int (*svc_set_folder_item_validity) (void * handle, const char * folder_path, int validity, int recursive, char ** err_msg);
+int (*svc_delete_all_invalid_items_in_folder) (void * handle, const char *folder_path, char ** err_msg);
+
+int __load_functions()
+{
+ msg_print(__LINE__, "__load_functions");
+
+ funcHandle = dlopen (PLUGIN_SO_FILE_NAME, RTLD_LAZY);
+ if (!funcHandle) {
+ fprintf (stderr,"error: %s\n", dlerror());
+ }
+
+ svc_check_item = dlsym (funcHandle, "check_item");
+ svc_connect = dlsym (funcHandle, "connect");
+ svc_disconnect = dlsym (funcHandle, "disconnect");
+ svc_check_item_exist = dlsym (funcHandle, "check_item_exist");
+ svc_insert_item_immediately = dlsym (funcHandle, "insert_item_immediately");
+ svc_set_folder_item_validity = dlsym (funcHandle, "set_folder_item_validity");
+ svc_delete_all_invalid_items_in_folder = dlsym (funcHandle, "delete_all_invalid_items_in_folder");
+
+ if ( !svc_check_item ||
+ !svc_connect ||
+ !svc_disconnect ||
+ !svc_insert_item_immediately ||
+ !svc_set_folder_item_validity ||
+ !svc_delete_all_invalid_items_in_folder ||
+ !svc_check_item_exist) {
+ fprintf(stderr,"error: %s\n", dlerror());
+ return -1;
+ }
+
+ return 0;
+}
+
+int __unload_functions(void)
+{
+ msg_print(__LINE__, "__unload_functions");
+
+ if (funcHandle)
+ {
+ dlclose (funcHandle);
+ }
+
+ return 0;
+}
+
+int main()
+{
+ int ret = 0;
+ MediaSvcHandle * db_handle = NULL;
+ char * err_msg = NULL;
+ char path[1024] = {0,};
+ char type[1024] = {0,};
+
+ ret = __load_functions();
+ if(ret < 0) {
+ msg_print(__LINE__, "__load_functions error");
+ return -1;
+ } else {
+ msg_print(__LINE__, "__load_functions success");
+ }
+
+ //check_item ================================================
+ ret = svc_check_item("/opt/usr/media/Music/Over the horizon.mp3", "audio/mpeg", &err_msg);
+ if(ret < 0) {
+ msg_print(__LINE__, "svc_check_item error");
+ if(err_msg != NULL) {
+ printf("err_msg[%s]\n", err_msg);
+ free(err_msg);
+ err_msg = NULL;
+ }
+ __unload_functions();
+ return -1;
+ } else {
+ msg_print(__LINE__, "svc_check_item success");
+ }
+
+ //db open ==================================================
+ ret = svc_connect(&db_handle, &err_msg);
+ if(ret < 0) {
+ msg_print(__LINE__, "svc_connect error");
+ if(err_msg != NULL) {
+ printf("err_msg[%s]\n", err_msg);
+ free(err_msg);
+ err_msg = NULL;
+ }
+ __unload_functions();
+ return -1;
+ } else {
+ msg_print(__LINE__, "svc_connect success");
+ }
+
+#if 1
+ ret = media_svc_create_table(db_handle);
+ if (ret < 0) {
+ msg_print(__LINE__, "table already exists");
+ } else {
+ msg_print(__LINE__, "table create success");
+ }
+#endif
+
+#if 1
+ while (1) {
+
+ printf("Enter path and mimetype ( ex. /opt/usr/media/a.jpg image ) : ");
+ scanf("%s %s", path, type);
+
+ //check_item_exist ============================================
+ ret = svc_check_item_exist(db_handle, path, 0, &err_msg);
+ if(ret < 0) {
+ msg_print(__LINE__, "svc_check_item_exist error");
+ if(err_msg != NULL) {
+ printf("err_msg[%s]\n", err_msg);
+ free(err_msg);
+ err_msg = NULL;
+ }
+ //__unload_functions();
+ //return -1;
+ } else {
+ msg_print(__LINE__, "svc_check_item_exist success");
+ }
+
+ // svc_check_item_exist ============================================
+ ret = svc_insert_item_immediately(db_handle, path, 0, type, &err_msg);
+ if(ret < 0) {
+ msg_print(__LINE__, "svc_insert_item_immediately error");
+ if(err_msg != NULL) {
+ printf("err_msg[%s]\n", err_msg);
+ free(err_msg);
+ err_msg = NULL;
+ }
+ //__unload_functions();
+ //return -1;
+ } else {
+ msg_print(__LINE__, "svc_insert_item_immediately success");
+ }
+ } // End of While
+
+ ret = media_svc_insert_folder(db_handle, 0, path);
+ if(ret < 0) {
+ msg_print(__LINE__, "media_svc_insert_folder error ");
+ } else {
+ msg_print(__LINE__, "media_svc_insert_folder success");
+ }
+#endif
+
+ //folder test ==================================================
+ char *folder_path = "/opt/usr/media/Sounds";
+ ret = svc_set_folder_item_validity(db_handle, folder_path, 0, 1, &err_msg);
+ if(ret < 0) {
+ msg_print(__LINE__, "svc_set_folder_item_validity error");
+ if(err_msg != NULL) {
+ printf("err_msg[%s]\n", err_msg);
+ free(err_msg);
+ err_msg = NULL;
+ }
+ } else {
+ msg_print(__LINE__, "svc_insert_item_immediately success");
+ }
+
+ ret = svc_delete_all_invalid_items_in_folder(db_handle, folder_path, &err_msg);
+ if(ret < 0) {
+ msg_print(__LINE__, "svc_delete_all_invalid_items_in_folder error");
+ if(err_msg != NULL) {
+ printf("err_msg[%s]\n", err_msg);
+ free(err_msg);
+ err_msg = NULL;
+ }
+ } else {
+ msg_print(__LINE__, "svc_insert_item_immediately success");
+ }
+
+ //db close ==================================================
+ ret = svc_disconnect(db_handle, &err_msg);
+ if(ret < 0) {
+ msg_print(__LINE__, "svc_disconnect error");
+ if(err_msg != NULL) {
+ printf("err_msg[%s]\n", err_msg);
+ free(err_msg);
+ err_msg = NULL;
+ }
+ __unload_functions();
+ return -1;
+ } else {
+ msg_print(__LINE__, "svc_disconnect success");
+ }
+
+ __unload_functions();
+
+ return 0;
+}
+
+
+static void msg_print(int line, char *msg)
+{
+ fprintf(stderr, "[%d]%s\n", line, msg);
+}
+
--- /dev/null
+/*
+ * clear.c -- Clear a UUID
+ *
+ * Copyright (C) 1996, 1997 Theodore Ts'o.
+ *
+ * %Begin-Header%
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, and the entire permission notice in its entirety,
+ * including the disclaimer of warranties.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ * 3. The name of the author may not be used to endorse or promote
+ * products derived from this software without specific prior
+ * written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ALL OF
+ * WHICH ARE HEREBY DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT
+ * OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
+ * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+ * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
+ * USE OF THIS SOFTWARE, EVEN IF NOT ADVISED OF THE POSSIBILITY OF SUCH
+ * DAMAGE.
+ * %End-Header%
+ */
+
+#include "string.h"
+
+#include "uuidP.h"
+
+void uuid_clear(uuid_t uu)
+{
+ memset(uu, 0, 16);
+}
+
--- /dev/null
+/*
+ * compare.c --- compare whether or not two UUID's are the same
+ *
+ * Returns 0 if the two UUID's are different, and 1 if they are the same.
+ *
+ * Copyright (C) 1996, 1997 Theodore Ts'o.
+ *
+ * %Begin-Header%
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, and the entire permission notice in its entirety,
+ * including the disclaimer of warranties.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ * 3. The name of the author may not be used to endorse or promote
+ * products derived from this software without specific prior
+ * written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ALL OF
+ * WHICH ARE HEREBY DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT
+ * OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
+ * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+ * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
+ * USE OF THIS SOFTWARE, EVEN IF NOT ADVISED OF THE POSSIBILITY OF SUCH
+ * DAMAGE.
+ * %End-Header%
+ */
+
+#include "uuidP.h"
+#include <string.h>
+
+#define UUCMP(u1,u2) if (u1 != u2) return((u1 < u2) ? -1 : 1);
+
+int uuid_compare(const uuid_t uu1, const uuid_t uu2)
+{
+ struct uuid uuid1, uuid2;
+
+ uuid_unpack(uu1, &uuid1);
+ uuid_unpack(uu2, &uuid2);
+
+ UUCMP(uuid1.time_low, uuid2.time_low);
+ UUCMP(uuid1.time_mid, uuid2.time_mid);
+ UUCMP(uuid1.time_hi_and_version, uuid2.time_hi_and_version);
+ UUCMP(uuid1.clock_seq, uuid2.clock_seq);
+ return memcmp(uuid1.node, uuid2.node, 6);
+}
+
--- /dev/null
+/*
+ * copy.c --- copy UUIDs
+ *
+ * Copyright (C) 1996, 1997 Theodore Ts'o.
+ *
+ * %Begin-Header%
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, and the entire permission notice in its entirety,
+ * including the disclaimer of warranties.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ * 3. The name of the author may not be used to endorse or promote
+ * products derived from this software without specific prior
+ * written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ALL OF
+ * WHICH ARE HEREBY DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT
+ * OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
+ * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+ * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
+ * USE OF THIS SOFTWARE, EVEN IF NOT ADVISED OF THE POSSIBILITY OF SUCH
+ * DAMAGE.
+ * %End-Header%
+ */
+
+#include "uuidP.h"
+
+void uuid_copy(uuid_t dst, const uuid_t src)
+{
+ unsigned char *cp1;
+ const unsigned char *cp2;
+ int i;
+
+ for (i=0, cp1 = dst, cp2 = src; i < 16; i++)
+ *cp1++ = *cp2++;
+}
--- /dev/null
+/*
+ * gen_uuid.c --- generate a DCE-compatible uuid
+ *
+ * Copyright (C) 1996, 1997, 1998, 1999 Theodore Ts'o.
+ *
+ * %Begin-Header%
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, and the entire permission notice in its entirety,
+ * including the disclaimer of warranties.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ * 3. The name of the author may not be used to endorse or promote
+ * products derived from this software without specific prior
+ * written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ALL OF
+ * WHICH ARE HEREBY DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT
+ * OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
+ * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+ * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
+ * USE OF THIS SOFTWARE, EVEN IF NOT ADVISED OF THE POSSIBILITY OF SUCH
+ * DAMAGE.
+ * %End-Header%
+ */
+
+/*
+ * Force inclusion of SVID stuff since we need it if we're compiling in
+ * gcc-wall wall mode
+ */
+#define _SVID_SOURCE
+
+#ifdef _WIN32
+#define _WIN32_WINNT 0x0500
+#include <windows.h>
+#define UUID MYUUID
+#endif
+#include <stdio.h>
+#ifdef HAVE_UNISTD_H
+#include <unistd.h>
+#endif
+#ifdef HAVE_STDLIB_H
+#include <stdlib.h>
+#endif
+#include <string.h>
+#include <fcntl.h>
+#include <errno.h>
+#include <sys/types.h>
+#ifdef HAVE_SYS_TIME_H
+#include <sys/time.h>
+#endif
+#include <sys/wait.h>
+#include <sys/stat.h>
+#ifdef HAVE_SYS_FILE_H
+#include <sys/file.h>
+#endif
+#ifdef HAVE_SYS_IOCTL_H
+#include <sys/ioctl.h>
+#endif
+#ifdef HAVE_SYS_SOCKET_H
+#include <sys/socket.h>
+#endif
+#ifdef HAVE_SYS_UN_H
+#include <sys/un.h>
+#endif
+#ifdef HAVE_SYS_SOCKIO_H
+#include <sys/sockio.h>
+#endif
+#ifdef HAVE_NET_IF_H
+#include <net/if.h>
+#endif
+#ifdef HAVE_NETINET_IN_H
+#include <netinet/in.h>
+#endif
+#ifdef HAVE_NET_IF_DL_H
+#include <net/if_dl.h>
+#endif
+#if defined(__linux__) && defined(HAVE_SYS_SYSCALL_H)
+#include <sys/syscall.h>
+#endif
+#ifdef HAVE_SYS_RESOURCE_H
+#include <sys/resource.h>
+#endif
+
+#include "uuidP.h"
+#include "uuidd.h"
+
+#ifdef HAVE_SRANDOM
+#define srand(x) srandom(x)
+#define rand() random()
+#endif
+
+#ifdef TLS
+#define THREAD_LOCAL static TLS
+#else
+#define THREAD_LOCAL static
+#endif
+
+#if defined(__linux__) && defined(__NR_gettid) && defined(HAVE_JRAND48)
+#define DO_JRAND_MIX
+THREAD_LOCAL unsigned short jrand_seed[3];
+#endif
+
+#ifdef _WIN32
+static void gettimeofday (struct timeval *tv, void *dummy)
+{
+ FILETIME ftime;
+ uint64_t n;
+
+ GetSystemTimeAsFileTime (&ftime);
+ n = (((uint64_t) ftime.dwHighDateTime << 32)
+ + (uint64_t) ftime.dwLowDateTime);
+ if (n) {
+ n /= 10;
+ n -= ((369 * 365 + 89) * (uint64_t) 86400) * 1000000;
+ }
+
+ tv->tv_sec = n / 1000000;
+ tv->tv_usec = n % 1000000;
+}
+
+static int getuid (void)
+{
+ return 1;
+}
+#endif
+
+static int get_random_fd(void)
+{
+ struct timeval tv;
+ static int fd = -2;
+ int i;
+
+ if (fd == -2) {
+ gettimeofday(&tv, 0);
+#ifndef _WIN32
+ fd = open("/dev/urandom", O_RDONLY);
+ if (fd == -1)
+ fd = open("/dev/random", O_RDONLY | O_NONBLOCK);
+ if (fd >= 0) {
+ i = fcntl(fd, F_GETFD);
+ if (i >= 0)
+ fcntl(fd, F_SETFD, i | FD_CLOEXEC);
+ }
+#endif
+ srand((getpid() << 16) ^ getuid() ^ tv.tv_sec ^ tv.tv_usec);
+#ifdef DO_JRAND_MIX
+ jrand_seed[0] = getpid() ^ (tv.tv_sec & 0xFFFF);
+ jrand_seed[1] = getppid() ^ (tv.tv_usec & 0xFFFF);
+ jrand_seed[2] = (tv.tv_sec ^ tv.tv_usec) >> 16;
+#endif
+ }
+ /* Crank the random number generator a few times */
+ gettimeofday(&tv, 0);
+ for (i = (tv.tv_sec ^ tv.tv_usec) & 0x1F; i > 0; i--)
+ rand();
+ return fd;
+}
+
+
+/*
+ * Generate a series of random bytes. Use /dev/urandom if possible,
+ * and if not, use srandom/random.
+ */
+static void get_random_bytes(void *buf, int nbytes)
+{
+ int i, n = nbytes, fd = get_random_fd();
+ int lose_counter = 0;
+ unsigned char *cp = (unsigned char *) buf;
+#ifdef DO_JRAND_MIX
+ unsigned short tmp_seed[3];
+#endif
+
+ if (fd >= 0) {
+ while (n > 0) {
+ i = read(fd, cp, n);
+ if (i <= 0) {
+ if (lose_counter++ > 16)
+ break;
+ continue;
+ }
+ n -= i;
+ cp += i;
+ lose_counter = 0;
+ }
+ }
+
+ /*
+ * We do this all the time, but this is the only source of
+ * randomness if /dev/random/urandom is out to lunch.
+ */
+ for (cp = buf, i = 0; i < nbytes; i++)
+ *cp++ ^= (rand() >> 7) & 0xFF;
+#ifdef DO_JRAND_MIX
+ memcpy(tmp_seed, jrand_seed, sizeof(tmp_seed));
+ jrand_seed[2] = jrand_seed[2] ^ syscall(__NR_gettid);
+ for (cp = buf, i = 0; i < nbytes; i++)
+ *cp++ ^= (jrand48(tmp_seed) >> 7) & 0xFF;
+ memcpy(jrand_seed, tmp_seed,
+ sizeof(jrand_seed)-sizeof(unsigned short));
+#endif
+
+ return;
+}
+
+/*
+ * Get the ethernet hardware address, if we can find it...
+ *
+ * XXX for a windows version, probably should use GetAdaptersInfo:
+ * http://www.codeguru.com/cpp/i-n/network/networkinformation/article.php/c5451
+ * commenting out get_node_id just to get gen_uuid to compile under windows
+ * is not the right way to go!
+ */
+static int get_node_id(unsigned char *node_id)
+{
+#ifdef HAVE_NET_IF_H
+ int sd;
+ struct ifreq ifr, *ifrp;
+ struct ifconf ifc;
+ char buf[1024];
+ int n, i;
+ unsigned char *a;
+#ifdef HAVE_NET_IF_DL_H
+ struct sockaddr_dl *sdlp;
+#endif
+
+/*
+ * BSD 4.4 defines the size of an ifreq to be
+ * max(sizeof(ifreq), sizeof(ifreq.ifr_name)+ifreq.ifr_addr.sa_len
+ * However, under earlier systems, sa_len isn't present, so the size is
+ * just sizeof(struct ifreq)
+ */
+#ifdef HAVE_SA_LEN
+#ifndef max
+#define max(a,b) ((a) > (b) ? (a) : (b))
+#endif
+#define ifreq_size(i) max(sizeof(struct ifreq),\
+ sizeof((i).ifr_name)+(i).ifr_addr.sa_len)
+#else
+#define ifreq_size(i) sizeof(struct ifreq)
+#endif /* HAVE_SA_LEN*/
+
+ sd = socket(AF_INET, SOCK_DGRAM, IPPROTO_IP);
+ if (sd < 0) {
+ return -1;
+ }
+ memset(buf, 0, sizeof(buf));
+ ifc.ifc_len = sizeof(buf);
+ ifc.ifc_buf = buf;
+ if (ioctl (sd, SIOCGIFCONF, (char *)&ifc) < 0) {
+ close(sd);
+ return -1;
+ }
+ n = ifc.ifc_len;
+ for (i = 0; i < n; i+= ifreq_size(*ifrp) ) {
+ ifrp = (struct ifreq *)((char *) ifc.ifc_buf+i);
+ strncpy(ifr.ifr_name, ifrp->ifr_name, IFNAMSIZ);
+#ifdef SIOCGIFHWADDR
+ if (ioctl(sd, SIOCGIFHWADDR, &ifr) < 0)
+ continue;
+ a = (unsigned char *) &ifr.ifr_hwaddr.sa_data;
+#else
+#ifdef SIOCGENADDR
+ if (ioctl(sd, SIOCGENADDR, &ifr) < 0)
+ continue;
+ a = (unsigned char *) ifr.ifr_enaddr;
+#else
+#ifdef HAVE_NET_IF_DL_H
+ sdlp = (struct sockaddr_dl *) &ifrp->ifr_addr;
+ if ((sdlp->sdl_family != AF_LINK) || (sdlp->sdl_alen != 6))
+ continue;
+ a = (unsigned char *) &sdlp->sdl_data[sdlp->sdl_nlen];
+#else
+ /*
+ * XXX we don't have a way of getting the hardware
+ * address
+ */
+ close(sd);
+ return 0;
+#endif /* HAVE_NET_IF_DL_H */
+#endif /* SIOCGENADDR */
+#endif /* SIOCGIFHWADDR */
+ if (!a[0] && !a[1] && !a[2] && !a[3] && !a[4] && !a[5])
+ continue;
+ if (node_id) {
+ memcpy(node_id, a, 6);
+ close(sd);
+ return 1;
+ }
+ }
+ close(sd);
+#endif
+ return 0;
+}
+
+/* Assume that the gettimeofday() has microsecond granularity */
+#define MAX_ADJUSTMENT 10
+
+static int get_clock(uint32_t *clock_high, uint32_t *clock_low,
+ uint16_t *ret_clock_seq, int *num)
+{
+ THREAD_LOCAL int adjustment = 0;
+ THREAD_LOCAL struct timeval last = {0, 0};
+ THREAD_LOCAL int state_fd = -2;
+ THREAD_LOCAL FILE *state_f;
+ THREAD_LOCAL uint16_t clock_seq;
+ struct timeval tv;
+ struct flock fl;
+ uint64_t clock_reg;
+ mode_t save_umask;
+ int len;
+
+ if (state_fd == -2) {
+ save_umask = umask(0);
+ state_fd = open("/var/lib/libuuid/clock.txt",
+ O_RDWR|O_CREAT, 0660);
+ (void) umask(save_umask);
+ state_f = fdopen(state_fd, "r+");
+ if (!state_f) {
+ close(state_fd);
+ state_fd = -1;
+ }
+ }
+ fl.l_type = F_WRLCK;
+ fl.l_whence = SEEK_SET;
+ fl.l_start = 0;
+ fl.l_len = 0;
+ fl.l_pid = 0;
+ if (state_fd >= 0) {
+ rewind(state_f);
+ while (fcntl(state_fd, F_SETLKW, &fl) < 0) {
+ if ((errno == EAGAIN) || (errno == EINTR))
+ continue;
+ fclose(state_f);
+ close(state_fd);
+ state_fd = -1;
+ break;
+ }
+ }
+ if (state_fd >= 0) {
+ unsigned int cl;
+ unsigned long tv1, tv2;
+ int a;
+
+ if (fscanf(state_f, "clock: %04x tv: %lu %lu adj: %d\n",
+ &cl, &tv1, &tv2, &a) == 4) {
+ clock_seq = cl & 0x3FFF;
+ last.tv_sec = tv1;
+ last.tv_usec = tv2;
+ adjustment = a;
+ }
+ }
+
+ if ((last.tv_sec == 0) && (last.tv_usec == 0)) {
+ get_random_bytes(&clock_seq, sizeof(clock_seq));
+ clock_seq &= 0x3FFF;
+ gettimeofday(&last, 0);
+ last.tv_sec--;
+ }
+
+try_again:
+ gettimeofday(&tv, 0);
+ if ((tv.tv_sec < last.tv_sec) ||
+ ((tv.tv_sec == last.tv_sec) &&
+ (tv.tv_usec < last.tv_usec))) {
+ clock_seq = (clock_seq+1) & 0x3FFF;
+ adjustment = 0;
+ last = tv;
+ } else if ((tv.tv_sec == last.tv_sec) &&
+ (tv.tv_usec == last.tv_usec)) {
+ if (adjustment >= MAX_ADJUSTMENT)
+ goto try_again;
+ adjustment++;
+ } else {
+ adjustment = 0;
+ last = tv;
+ }
+
+ clock_reg = tv.tv_usec*10 + adjustment;
+ clock_reg += ((uint64_t) tv.tv_sec)*10000000;
+ clock_reg += (((uint64_t) 0x01B21DD2) << 32) + 0x13814000;
+
+ if (num && (*num > 1)) {
+ adjustment += *num - 1;
+ last.tv_usec += adjustment / 10;
+ adjustment = adjustment % 10;
+ last.tv_sec += last.tv_usec / 1000000;
+ last.tv_usec = last.tv_usec % 1000000;
+ }
+
+ if (state_fd > 0) {
+ rewind(state_f);
+ len = fprintf(state_f,
+ "clock: %04x tv: %016lu %08lu adj: %08d\n",
+ clock_seq, last.tv_sec, last.tv_usec, adjustment);
+ fflush(state_f);
+ if (ftruncate(state_fd, len) < 0) {
+ fprintf(state_f, " \n");
+ fflush(state_f);
+ }
+ rewind(state_f);
+ fl.l_type = F_UNLCK;
+ fcntl(state_fd, F_SETLK, &fl);
+ }
+
+ *clock_high = clock_reg >> 32;
+ *clock_low = clock_reg;
+ *ret_clock_seq = clock_seq;
+ return 0;
+}
+
+#if defined(USE_UUIDD) && defined(HAVE_SYS_UN_H)
+static ssize_t read_all(int fd, char *buf, size_t count)
+{
+ ssize_t ret;
+ ssize_t c = 0;
+ int tries = 0;
+
+ memset(buf, 0, count);
+ while (count > 0) {
+ ret = read(fd, buf, count);
+ if (ret <= 0) {
+ if ((errno == EAGAIN || errno == EINTR || ret == 0) &&
+ (tries++ < 5))
+ continue;
+ return c ? c : -1;
+ }
+ if (ret > 0)
+ tries = 0;
+ count -= ret;
+ buf += ret;
+ c += ret;
+ }
+ return c;
+}
+
+/*
+ * Close all file descriptors
+ */
+#define HAVE_GETDTABLESIZE 1
+static void close_all_fds(void)
+{
+ int i, max;
+
+#if defined(HAVE_SYSCONF) && defined(_SC_OPEN_MAX)
+ max = sysconf(_SC_OPEN_MAX);
+#elif defined(HAVE_GETDTABLESIZE)
+ max = getdtablesize();
+#elif defined(HAVE_GETRLIMIT) && defined(RLIMIT_NOFILE)
+ struct rlimit rl;
+
+ getrlimit(RLIMIT_NOFILE, &rl);
+ max = rl.rlim_cur;
+#else
+ max = OPEN_MAX;
+#endif
+
+ for (i=0; i < max; i++) {
+ close(i);
+ if (i <= 2)
+ open("/dev/null", O_RDWR);
+ }
+}
+#endif
+
+/*
+ * Try using the uuidd daemon to generate the UUID
+ *
+ * Returns 0 on success, non-zero on failure.
+ */
+static int get_uuid_via_daemon(int op, uuid_t out, int *num)
+{
+#if defined(USE_UUIDD) && defined(HAVE_SYS_UN_H)
+ char op_buf[64];
+ int op_len;
+ int s;
+ ssize_t ret;
+ int32_t reply_len = 0, expected = 16;
+ struct sockaddr_un srv_addr;
+ struct stat st;
+ pid_t pid;
+ static const char *uuidd_path = UUIDD_PATH;
+ static int access_ret = -2;
+ static int start_attempts = 0;
+
+ if ((s = socket(AF_UNIX, SOCK_STREAM, 0)) < 0)
+ return -1;
+
+ srv_addr.sun_family = AF_UNIX;
+ strcpy(srv_addr.sun_path, UUIDD_SOCKET_PATH);
+
+ if (connect(s, (const struct sockaddr *) &srv_addr,
+ sizeof(struct sockaddr_un)) < 0) {
+ if (access_ret == -2)
+ access_ret = access(uuidd_path, X_OK);
+ if (access_ret == 0)
+ access_ret = stat(uuidd_path, &st);
+ if (access_ret == 0 && (st.st_mode & (S_ISUID | S_ISGID)) == 0)
+ access_ret = access(UUIDD_DIR, W_OK);
+ if (access_ret == 0 && start_attempts++ < 5) {
+ if ((pid = fork()) == 0) {
+ close_all_fds();
+ execl(uuidd_path, "uuidd", "-qT", "300",
+ (char *) NULL);
+ exit(1);
+ }
+ (void) waitpid(pid, 0, 0);
+ if (connect(s, (const struct sockaddr *) &srv_addr,
+ sizeof(struct sockaddr_un)) < 0)
+ goto fail;
+ } else
+ goto fail;
+ }
+ op_buf[0] = op;
+ op_len = 1;
+ if (op == UUIDD_OP_BULK_TIME_UUID) {
+ memcpy(op_buf+1, num, sizeof(*num));
+ op_len += sizeof(*num);
+ expected += sizeof(*num);
+ }
+
+ ret = write(s, op_buf, op_len);
+ if (ret < 1)
+ goto fail;
+
+ ret = read_all(s, (char *) &reply_len, sizeof(reply_len));
+ if (ret < 0)
+ goto fail;
+
+ if (reply_len != expected)
+ goto fail;
+
+ ret = read_all(s, op_buf, reply_len);
+
+ if (op == UUIDD_OP_BULK_TIME_UUID)
+ memcpy(op_buf+16, num, sizeof(int));
+
+ memcpy(out, op_buf, 16);
+
+ close(s);
+ return ((ret == expected) ? 0 : -1);
+
+fail:
+ close(s);
+#endif
+ return -1;
+}
+
+void uuid__generate_time(uuid_t out, int *num)
+{
+ static unsigned char node_id[6];
+ static int has_init = 0;
+ struct uuid uu;
+ uint32_t clock_mid;
+
+ if (!has_init) {
+ if (get_node_id(node_id) <= 0) {
+ get_random_bytes(node_id, 6);
+ /*
+ * Set multicast bit, to prevent conflicts
+ * with IEEE 802 addresses obtained from
+ * network cards
+ */
+ node_id[0] |= 0x01;
+ }
+ has_init = 1;
+ }
+ get_clock(&clock_mid, &uu.time_low, &uu.clock_seq, num);
+ uu.clock_seq |= 0x8000;
+ uu.time_mid = (uint16_t) clock_mid;
+ uu.time_hi_and_version = ((clock_mid >> 16) & 0x0FFF) | 0x1000;
+ memcpy(uu.node, node_id, 6);
+ uuid_pack(&uu, out);
+}
+
+void uuid_generate_time(uuid_t out)
+{
+#ifdef TLS
+ THREAD_LOCAL int num = 0;
+ THREAD_LOCAL struct uuid uu;
+ THREAD_LOCAL time_t last_time = 0;
+ time_t now;
+
+ if (num > 0) {
+ now = time(0);
+ if (now > last_time+1)
+ num = 0;
+ }
+ if (num <= 0) {
+ num = 1000;
+ if (get_uuid_via_daemon(UUIDD_OP_BULK_TIME_UUID,
+ out, &num) == 0) {
+ last_time = time(0);
+ uuid_unpack(out, &uu);
+ num--;
+ return;
+ }
+ num = 0;
+ }
+ if (num > 0) {
+ uu.time_low++;
+ if (uu.time_low == 0) {
+ uu.time_mid++;
+ if (uu.time_mid == 0)
+ uu.time_hi_and_version++;
+ }
+ num--;
+ uuid_pack(&uu, out);
+ return;
+ }
+#else
+ if (get_uuid_via_daemon(UUIDD_OP_TIME_UUID, out, 0) == 0)
+ return;
+#endif
+
+ uuid__generate_time(out, 0);
+}
+
+
+void uuid__generate_random(uuid_t out, int *num)
+{
+ uuid_t buf;
+ struct uuid uu;
+ int i, n;
+
+ if (!num || !*num)
+ n = 1;
+ else
+ n = *num;
+
+ for (i = 0; i < n; i++) {
+ get_random_bytes(buf, sizeof(buf));
+ uuid_unpack(buf, &uu);
+
+ uu.clock_seq = (uu.clock_seq & 0x3FFF) | 0x8000;
+ uu.time_hi_and_version = (uu.time_hi_and_version & 0x0FFF)
+ | 0x4000;
+ uuid_pack(&uu, out);
+ out += sizeof(uuid_t);
+ }
+}
+
+void uuid_generate_random(uuid_t out)
+{
+ int num = 1;
+ /* No real reason to use the daemon for random uuid's -- yet */
+
+ uuid__generate_random(out, &num);
+}
+
+
+/*
+ * This is the generic front-end to uuid_generate_random and
+ * uuid_generate_time. It uses uuid_generate_random only if
+ * /dev/urandom is available, since otherwise we won't have
+ * high-quality randomness.
+ */
+void uuid_generate(uuid_t out)
+{
+ if (get_random_fd() >= 0)
+ uuid_generate_random(out);
+ else
+ uuid_generate_time(out);
+}
--- /dev/null
+/*
+ * isnull.c --- Check whether or not the UUID is null
+ *
+ * Copyright (C) 1996, 1997 Theodore Ts'o.
+ *
+ * %Begin-Header%
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, and the entire permission notice in its entirety,
+ * including the disclaimer of warranties.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ * 3. The name of the author may not be used to endorse or promote
+ * products derived from this software without specific prior
+ * written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ALL OF
+ * WHICH ARE HEREBY DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT
+ * OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
+ * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+ * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
+ * USE OF THIS SOFTWARE, EVEN IF NOT ADVISED OF THE POSSIBILITY OF SUCH
+ * DAMAGE.
+ * %End-Header%
+ */
+
+#include "uuidP.h"
+
+/* Returns 1 if the uuid is the NULL uuid */
+int uuid_is_null(const uuid_t uu)
+{
+ const unsigned char *cp;
+ int i;
+
+ for (i=0, cp = uu; i < 16; i++)
+ if (*cp++)
+ return 0;
+ return 1;
+}
+
--- /dev/null
+/*
+ * Internal routine for packing UUID's
+ *
+ * Copyright (C) 1996, 1997 Theodore Ts'o.
+ *
+ * %Begin-Header%
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, and the entire permission notice in its entirety,
+ * including the disclaimer of warranties.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ * 3. The name of the author may not be used to endorse or promote
+ * products derived from this software without specific prior
+ * written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ALL OF
+ * WHICH ARE HEREBY DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT
+ * OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
+ * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+ * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
+ * USE OF THIS SOFTWARE, EVEN IF NOT ADVISED OF THE POSSIBILITY OF SUCH
+ * DAMAGE.
+ * %End-Header%
+ */
+
+#include <string.h>
+#include "uuidP.h"
+
+void uuid_pack(const struct uuid *uu, uuid_t ptr)
+{
+ uint32_t tmp;
+ unsigned char *out = ptr;
+
+ tmp = uu->time_low;
+ out[3] = (unsigned char) tmp;
+ tmp >>= 8;
+ out[2] = (unsigned char) tmp;
+ tmp >>= 8;
+ out[1] = (unsigned char) tmp;
+ tmp >>= 8;
+ out[0] = (unsigned char) tmp;
+
+ tmp = uu->time_mid;
+ out[5] = (unsigned char) tmp;
+ tmp >>= 8;
+ out[4] = (unsigned char) tmp;
+
+ tmp = uu->time_hi_and_version;
+ out[7] = (unsigned char) tmp;
+ tmp >>= 8;
+ out[6] = (unsigned char) tmp;
+
+ tmp = uu->clock_seq;
+ out[9] = (unsigned char) tmp;
+ tmp >>= 8;
+ out[8] = (unsigned char) tmp;
+
+ memcpy(out+10, uu->node, 6);
+}
+
--- /dev/null
+/*
+ * parse.c --- UUID parsing
+ *
+ * Copyright (C) 1996, 1997 Theodore Ts'o.
+ *
+ * %Begin-Header%
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, and the entire permission notice in its entirety,
+ * including the disclaimer of warranties.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ * 3. The name of the author may not be used to endorse or promote
+ * products derived from this software without specific prior
+ * written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ALL OF
+ * WHICH ARE HEREBY DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT
+ * OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
+ * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+ * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
+ * USE OF THIS SOFTWARE, EVEN IF NOT ADVISED OF THE POSSIBILITY OF SUCH
+ * DAMAGE.
+ * %End-Header%
+ */
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <ctype.h>
+#include <string.h>
+
+#include "uuidP.h"
+
+int uuid_parse(const char *in, uuid_t uu)
+{
+ struct uuid uuid;
+ int i;
+ const char *cp;
+ char buf[3];
+
+ if (strlen(in) != 36)
+ return -1;
+ for (i=0, cp = in; i <= 36; i++,cp++) {
+ if ((i == 8) || (i == 13) || (i == 18) ||
+ (i == 23)) {
+ if (*cp == '-')
+ continue;
+ else
+ return -1;
+ }
+ if (i== 36)
+ if (*cp == 0)
+ continue;
+ if (!isxdigit(*cp))
+ return -1;
+ }
+ uuid.time_low = strtoul(in, NULL, 16);
+ uuid.time_mid = strtoul(in+9, NULL, 16);
+ uuid.time_hi_and_version = strtoul(in+14, NULL, 16);
+ uuid.clock_seq = strtoul(in+19, NULL, 16);
+ cp = in+24;
+ buf[2] = 0;
+ for (i=0; i < 6; i++) {
+ buf[0] = *cp++;
+ buf[1] = *cp++;
+ uuid.node[i] = strtoul(buf, NULL, 16);
+ }
+
+ uuid_pack(&uuid, uu);
+ return 0;
+}
--- /dev/null
+/*
+ * Internal routine for unpacking UUID
+ *
+ * Copyright (C) 1996, 1997 Theodore Ts'o.
+ *
+ * %Begin-Header%
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, and the entire permission notice in its entirety,
+ * including the disclaimer of warranties.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ * 3. The name of the author may not be used to endorse or promote
+ * products derived from this software without specific prior
+ * written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ALL OF
+ * WHICH ARE HEREBY DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT
+ * OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
+ * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+ * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
+ * USE OF THIS SOFTWARE, EVEN IF NOT ADVISED OF THE POSSIBILITY OF SUCH
+ * DAMAGE.
+ * %End-Header%
+ */
+
+#include <string.h>
+#include "uuidP.h"
+
+void uuid_unpack(const uuid_t in, struct uuid *uu)
+{
+ const uint8_t *ptr = in;
+ uint32_t tmp;
+
+ tmp = *ptr++;
+ tmp = (tmp << 8) | *ptr++;
+ tmp = (tmp << 8) | *ptr++;
+ tmp = (tmp << 8) | *ptr++;
+ uu->time_low = tmp;
+
+ tmp = *ptr++;
+ tmp = (tmp << 8) | *ptr++;
+ uu->time_mid = tmp;
+
+ tmp = *ptr++;
+ tmp = (tmp << 8) | *ptr++;
+ uu->time_hi_and_version = tmp;
+
+ tmp = *ptr++;
+ tmp = (tmp << 8) | *ptr++;
+ uu->clock_seq = tmp;
+
+ memcpy(uu->node, ptr, 6);
+}
+
--- /dev/null
+/*
+ * unparse.c -- convert a UUID to string
+ *
+ * Copyright (C) 1996, 1997 Theodore Ts'o.
+ *
+ * %Begin-Header%
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, and the entire permission notice in its entirety,
+ * including the disclaimer of warranties.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ * 3. The name of the author may not be used to endorse or promote
+ * products derived from this software without specific prior
+ * written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ALL OF
+ * WHICH ARE HEREBY DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT
+ * OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
+ * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+ * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
+ * USE OF THIS SOFTWARE, EVEN IF NOT ADVISED OF THE POSSIBILITY OF SUCH
+ * DAMAGE.
+ * %End-Header%
+ */
+
+#include <stdio.h>
+
+#include "uuidP.h"
+
+static const char *fmt_lower =
+ "%08x-%04x-%04x-%02x%02x-%02x%02x%02x%02x%02x%02x";
+
+static const char *fmt_upper =
+ "%08X-%04X-%04X-%02X%02X-%02X%02X%02X%02X%02X%02X";
+
+#ifdef UUID_UNPARSE_DEFAULT_UPPER
+#define FMT_DEFAULT fmt_upper
+#else
+#define FMT_DEFAULT fmt_lower
+#endif
+
+static void uuid_unparse_x(const uuid_t uu, char *out, const char *fmt)
+{
+ struct uuid uuid;
+
+ uuid_unpack(uu, &uuid);
+ sprintf(out, fmt,
+ uuid.time_low, uuid.time_mid, uuid.time_hi_and_version,
+ uuid.clock_seq >> 8, uuid.clock_seq & 0xFF,
+ uuid.node[0], uuid.node[1], uuid.node[2],
+ uuid.node[3], uuid.node[4], uuid.node[5]);
+}
+
+void uuid_unparse_lower(const uuid_t uu, char *out)
+{
+ uuid_unparse_x(uu, out, fmt_lower);
+}
+
+void uuid_unparse_upper(const uuid_t uu, char *out)
+{
+ uuid_unparse_x(uu, out, fmt_upper);
+}
+
+void uuid_unparse(const uuid_t uu, char *out)
+{
+ uuid_unparse_x(uu, out, FMT_DEFAULT);
+}
--- /dev/null
+/*
+ * Public include file for the UUID library
+ *
+ * Copyright (C) 1996, 1997, 1998 Theodore Ts'o.
+ *
+ * %Begin-Header%
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, and the entire permission notice in its entirety,
+ * including the disclaimer of warranties.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ * 3. The name of the author may not be used to endorse or promote
+ * products derived from this software without specific prior
+ * written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ALL OF
+ * WHICH ARE HEREBY DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT
+ * OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
+ * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+ * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
+ * USE OF THIS SOFTWARE, EVEN IF NOT ADVISED OF THE POSSIBILITY OF SUCH
+ * DAMAGE.
+ * %End-Header%
+ */
+
+#ifndef _UUID_UUID_H
+#define _UUID_UUID_H
+
+#include <sys/types.h>
+#ifndef _WIN32
+#include <sys/time.h>
+#endif
+#include <time.h>
+
+typedef unsigned char uuid_t[16];
+
+/* UUID Variant definitions */
+#define UUID_VARIANT_NCS 0
+#define UUID_VARIANT_DCE 1
+#define UUID_VARIANT_MICROSOFT 2
+#define UUID_VARIANT_OTHER 3
+
+/* UUID Type definitions */
+#define UUID_TYPE_DCE_TIME 1
+#define UUID_TYPE_DCE_RANDOM 4
+
+/* Allow UUID constants to be defined */
+#ifdef __GNUC__
+#define UUID_DEFINE(name,u0,u1,u2,u3,u4,u5,u6,u7,u8,u9,u10,u11,u12,u13,u14,u15) \
+ static const uuid_t name __attribute__ ((unused)) = {u0,u1,u2,u3,u4,u5,u6,u7,u8,u9,u10,u11,u12,u13,u14,u15}
+#else
+#define UUID_DEFINE(name,u0,u1,u2,u3,u4,u5,u6,u7,u8,u9,u10,u11,u12,u13,u14,u15) \
+ static const uuid_t name = {u0,u1,u2,u3,u4,u5,u6,u7,u8,u9,u10,u11,u12,u13,u14,u15}
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* clear.c */
+void uuid_clear(uuid_t uu);
+
+/* compare.c */
+int uuid_compare(const uuid_t uu1, const uuid_t uu2);
+
+/* copy.c */
+void uuid_copy(uuid_t dst, const uuid_t src);
+
+/* gen_uuid.c */
+void uuid_generate(uuid_t out);
+void uuid_generate_random(uuid_t out);
+void uuid_generate_time(uuid_t out);
+
+/* isnull.c */
+int uuid_is_null(const uuid_t uu);
+
+/* parse.c */
+int uuid_parse(const char *in, uuid_t uu);
+
+/* unparse.c */
+void uuid_unparse(const uuid_t uu, char *out);
+void uuid_unparse_lower(const uuid_t uu, char *out);
+void uuid_unparse_upper(const uuid_t uu, char *out);
+
+/* uuid_time.c */
+time_t uuid_time(const uuid_t uu, struct timeval *ret_tv);
+int uuid_type(const uuid_t uu);
+int uuid_variant(const uuid_t uu);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* _UUID_UUID_H */
--- /dev/null
+/*
+ * uuid.h -- private header file for uuids
+ *
+ * Copyright (C) 1996, 1997 Theodore Ts'o.
+ *
+ * %Begin-Header%
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, and the entire permission notice in its entirety,
+ * including the disclaimer of warranties.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ * 3. The name of the author may not be used to endorse or promote
+ * products derived from this software without specific prior
+ * written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ALL OF
+ * WHICH ARE HEREBY DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT
+ * OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
+ * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+ * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
+ * USE OF THIS SOFTWARE, EVEN IF NOT ADVISED OF THE POSSIBILITY OF SUCH
+ * DAMAGE.
+ * %End-Header%
+ */
+
+#ifdef HAVE_INTTYPES_H
+#include <inttypes.h>
+#else
+#include <uuid/uuid_types.h>
+#endif
+#include <sys/types.h>
+
+#include <uuid/uuid.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <unistd.h>
+
+/*
+ * Offset between 15-Oct-1582 and 1-Jan-70
+ */
+#define TIME_OFFSET_HIGH 0x01B21DD2
+#define TIME_OFFSET_LOW 0x13814000
+
+struct uuid {
+ uint32_t time_low;
+ uint16_t time_mid;
+ uint16_t time_hi_and_version;
+ uint16_t clock_seq;
+ uint8_t node[6];
+};
+
+
+/*
+ * prototypes
+ */
+void uuid_pack(const struct uuid *uu, uuid_t ptr);
+void uuid_unpack(const uuid_t in, struct uuid *uu);
--- /dev/null
+/*
+ * uuid_time.c --- Interpret the time field from a uuid. This program
+ * violates the UUID abstraction barrier by reaching into the guts
+ * of a UUID and interpreting it.
+ *
+ * Copyright (C) 1998, 1999 Theodore Ts'o.
+ *
+ * %Begin-Header%
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, and the entire permission notice in its entirety,
+ * including the disclaimer of warranties.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ * 3. The name of the author may not be used to endorse or promote
+ * products derived from this software without specific prior
+ * written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ALL OF
+ * WHICH ARE HEREBY DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT
+ * OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
+ * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+ * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
+ * USE OF THIS SOFTWARE, EVEN IF NOT ADVISED OF THE POSSIBILITY OF SUCH
+ * DAMAGE.
+ * %End-Header%
+ */
+
+#ifdef _WIN32
+#define _WIN32_WINNT 0x0500
+#include <windows.h>
+#define UUID MYUUID
+#endif
+
+#include <stdio.h>
+#ifdef HAVE_UNISTD_H
+#include <unistd.h>
+#endif
+#include <stdlib.h>
+#include <sys/types.h>
+#ifdef HAVE_SYS_TIME_H
+#include <sys/time.h>
+#endif
+#include <time.h>
+
+#include "uuidP.h"
+
+time_t uuid_time(const uuid_t uu, struct timeval *ret_tv)
+{
+ struct timeval tv;
+ struct uuid uuid;
+ uint32_t high;
+ uint64_t clock_reg;
+
+ uuid_unpack(uu, &uuid);
+
+ high = uuid.time_mid | ((uuid.time_hi_and_version & 0xFFF) << 16);
+ clock_reg = uuid.time_low | ((uint64_t) high << 32);
+
+ clock_reg -= (((uint64_t) 0x01B21DD2) << 32) + 0x13814000;
+ tv.tv_sec = clock_reg / 10000000;
+ tv.tv_usec = (clock_reg % 10000000) / 10;
+
+ if (ret_tv)
+ *ret_tv = tv;
+
+ return tv.tv_sec;
+}
+
+int uuid_type(const uuid_t uu)
+{
+ struct uuid uuid;
+
+ uuid_unpack(uu, &uuid);
+ return ((uuid.time_hi_and_version >> 12) & 0xF);
+}
+
+int uuid_variant(const uuid_t uu)
+{
+ struct uuid uuid;
+ int var;
+
+ uuid_unpack(uu, &uuid);
+ var = uuid.clock_seq;
+
+ if ((var & 0x8000) == 0)
+ return UUID_VARIANT_NCS;
+ if ((var & 0x4000) == 0)
+ return UUID_VARIANT_DCE;
+ if ((var & 0x2000) == 0)
+ return UUID_VARIANT_MICROSOFT;
+ return UUID_VARIANT_OTHER;
+}
+
+#ifdef DEBUG
+static const char *variant_string(int variant)
+{
+ switch (variant) {
+ case UUID_VARIANT_NCS:
+ return "NCS";
+ case UUID_VARIANT_DCE:
+ return "DCE";
+ case UUID_VARIANT_MICROSOFT:
+ return "Microsoft";
+ default:
+ return "Other";
+ }
+}
+
+
+int
+main(int argc, char **argv)
+{
+ uuid_t buf;
+ time_t time_reg;
+ struct timeval tv;
+ int type, variant;
+
+ if (argc != 2) {
+ fprintf(stderr, "Usage: %s uuid\n", argv[0]);
+ exit(1);
+ }
+ if (uuid_parse(argv[1], buf)) {
+ fprintf(stderr, "Invalid UUID: %s\n", argv[1]);
+ exit(1);
+ }
+ variant = uuid_variant(buf);
+ type = uuid_type(buf);
+ time_reg = uuid_time(buf, &tv);
+
+ printf("UUID variant is %d (%s)\n", variant, variant_string(variant));
+ if (variant != UUID_VARIANT_DCE) {
+ printf("Warning: This program only knows how to interpret "
+ "DCE UUIDs.\n\tThe rest of the output is likely "
+ "to be incorrect!!\n");
+ }
+ printf("UUID type is %d", type);
+ switch (type) {
+ case 1:
+ printf(" (time based)\n");
+ break;
+ case 2:
+ printf(" (DCE)\n");
+ break;
+ case 3:
+ printf(" (name-based)\n");
+ break;
+ case 4:
+ printf(" (random)\n");
+ break;
+ default:
+ printf("\n");
+ }
+ if (type != 1) {
+ printf("Warning: not a time-based UUID, so UUID time "
+ "decoding will likely not work!\n");
+ }
+ printf("UUID time is: (%ld, %ld): %s\n", tv.tv_sec, tv.tv_usec,
+ ctime(&time_reg));
+
+ return 0;
+}
+#endif
--- /dev/null
+/*
+ * If linux/types.h is already been included, assume it has defined
+ * everything we need. (cross fingers) Other header files may have
+ * also defined the types that we need.
+ */
+#if (!defined(_STDINT_H) && !defined(_UUID_STDINT_H))
+#define _UUID_STDINT_H
+
+typedef unsigned char uint8_t;
+typedef signed char int8_t;
+
+#if (4 == 8)
+typedef int int64_t;
+typedef unsigned int uint64_t;
+#elif (4 == 8)
+typedef long int64_t;
+typedef unsigned long uint64_t;
+#elif (8 == 8)
+#if defined(__GNUC__)
+typedef __signed__ long long int64_t;
+#else
+typedef signed long long int64_t;
+#endif
+typedef unsigned long long uint64_t;
+#endif
+
+#if (4 == 2)
+typedef int int16_t;
+typedef unsigned int uint16_t;
+#elif (2 == 2)
+typedef short int16_t;
+typedef unsigned short uint16_t;
+#else
+ ?==error: undefined 16 bit type
+#endif
+
+#if (4 == 4)
+typedef int int32_t;
+typedef unsigned int uint32_t;
+#elif (4 == 4)
+typedef long int32_t;
+typedef unsigned long uint32_t;
+#elif (2 == 4)
+typedef short int32_t;
+typedef unsigned short uint32_t;
+#else
+ ?== error: undefined 32 bit type
+#endif
+
+#endif
--- /dev/null
+/*
+ * Definitions used by the uuidd daemon
+ *
+ * Copyright (C) 2007 Theodore Ts'o.
+ *
+ * %Begin-Header%
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, and the entire permission notice in its entirety,
+ * including the disclaimer of warranties.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ * 3. The name of the author may not be used to endorse or promote
+ * products derived from this software without specific prior
+ * written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ALL OF
+ * WHICH ARE HEREBY DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT
+ * OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
+ * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+ * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
+ * USE OF THIS SOFTWARE, EVEN IF NOT ADVISED OF THE POSSIBILITY OF SUCH
+ * DAMAGE.
+ * %End-Header%
+ */
+
+#ifndef _UUID_UUIDD_H
+#define _UUID_UUIDD_H
+
+#define UUIDD_DIR "/var/lib/libuuid"
+#define UUIDD_SOCKET_PATH UUIDD_DIR "/request"
+#define UUIDD_PIDFILE_PATH UUIDD_DIR "/uuidd.pid"
+#define UUIDD_PATH "/usr/sbin/uuidd"
+
+#define UUIDD_OP_GETPID 0
+#define UUIDD_OP_GET_MAXOP 1
+#define UUIDD_OP_TIME_UUID 2
+#define UUIDD_OP_RANDOM_UUID 3
+#define UUIDD_OP_BULK_TIME_UUID 4
+#define UUIDD_OP_BULK_RANDOM_UUID 5
+#define UUIDD_MAX_OP UUIDD_OP_BULK_RANDOM_UUID
+
+extern void uuid__generate_time(uuid_t out, int *num);
+extern void uuid__generate_random(uuid_t out, int *num);
+
+#endif /* _UUID_UUID_H */
projects / platform / core / multimedia / libmedia-service.git / commitdiff
