From: HyungKyu Song Date: Fri, 15 Feb 2013 15:15:11 +0000 (+0900) Subject: Tizen 2.0 Release X-Git-Tag: accepted/tizen_2.0/20130215.203719^0 X-Git-Url: http://review.tizen.org/git/?a=commitdiff_plain;h=refs%2Fheads%2Ftizen_2.0;p=platform%2Fcore%2Fmultimedia%2Flibmedia-service.git Tizen 2.0 Release --- diff --git a/AUTHORS b/AUTHORS new file mode 100644 index 0000000..677fb81 --- /dev/null +++ b/AUTHORS @@ -0,0 +1,2 @@ +Haejeong Kim +Hyunjun Ko diff --git a/CMakeLists.txt b/CMakeLists.txt new file mode 100755 index 0000000..af7ccc4 --- /dev/null +++ b/CMakeLists.txt @@ -0,0 +1,111 @@ +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/) diff --git a/LICENSE b/LICENSE new file mode 100644 index 0000000..51cfd5c --- /dev/null +++ b/LICENSE @@ -0,0 +1,733 @@ + 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. + + Finally, software patents pose a constant threat to the existence of +any free program. We wish to make sure that a company cannot +effectively restrict the users of a free program by obtaining a +restrictive license from a patent holder. Therefore, we insist that +any patent license obtained for a version of the library must be +consistent with the full freedom of use specified in this license. + + Most GNU software, including some libraries, is covered by the +ordinary GNU General Public License. This license, the GNU Lesser +General Public License, applies to certain designated libraries, and +is quite different from the ordinary General Public License. We use +this license for certain libraries in order to permit linking those +libraries into non-free programs. + + When a program is linked with a library, whether statically or using +a shared library, the combination of the two is legally speaking a +combined work, a derivative of the original library. The ordinary +General Public License therefore permits such linking only if the +entire combination fits its criteria of freedom. The Lesser General +Public License permits more lax criteria for linking other code with +the library. + + We call this license the "Lesser" General Public License because it +does Less to protect the user's freedom than the ordinary General +Public License. It also provides other free software developers Less +of an advantage over competing non-free programs. These disadvantages +are the reason we use the ordinary General Public License for many +libraries. However, the Lesser license provides advantages in certain +special circumstances. + + For example, on rare occasions, there may be a special need to +encourage the widest possible use of a certain library, so that it becomes +a de-facto standard. To achieve this, non-free programs must be +allowed to use the library. A more frequent case is that a free +library does the same job as widely used non-free libraries. In this +case, there is little to gain by limiting the free library to free +software only, so we use the Lesser General Public License. + + In other cases, permission to use a particular library in non-free +programs enables a greater number of people to use a large body of +free software. For example, permission to use the GNU C Library in +non-free programs enables many more people to use the whole GNU +operating system, as well as its variant, the GNU/Linux operating +system. + + Although the Lesser General Public License is Less protective of the +users' freedom, it does ensure that the user of a program that is +linked with the Library has the freedom and the wherewithal to run +that program using a modified version of the Library. + + The precise terms and conditions for copying, distribution and +modification follow. Pay close attention to the difference between a +"work based on the library" and a "work that uses the library". The +former contains code derived from the library, whereas the latter must +be combined with the library in order to run. + + GNU LESSER GENERAL PUBLIC LICENSE + TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION + + 0. This License Agreement applies to any software library or other +program which contains a notice placed by the copyright holder or +other authorized party saying it may be distributed under the terms of +this Lesser General Public License (also called "this License"). +Each licensee is addressed as "you". + + A "library" means a collection of software functions and/or data +prepared so as to be conveniently linked with application programs +(which use some of those functions and data) to form executables. + + The "Library", below, refers to any such software library or work +which has been distributed under these terms. A "work based on the +Library" means either the Library or any derivative work under +copyright law: that is to say, a work containing the Library or a +portion of it, either verbatim or with modifications and/or translated +straightforwardly into another language. (Hereinafter, translation is +included without limitation in the term "modification".) + + "Source code" for a work means the preferred form of the work for +making modifications to it. For a library, complete source code means +all the source code for all modules it contains, plus any associated +interface definition files, plus the scripts used to control compilation +and installation of the library. + + Activities other than copying, distribution and modification are not +covered by this License; they are outside its scope. The act of +running a program using the Library is not restricted, and output from +such a program is covered only if its contents constitute a work based +on the Library (independent of the use of the Library in a tool for +writing it). Whether that is true depends on what the Library does +and what the program that uses the Library does. + + 1. You may copy and distribute verbatim copies of the Library's +complete source code as you receive it, in any medium, provided that +you conspicuously and appropriately publish on each copy an +appropriate copyright notice and disclaimer of warranty; keep intact +all the notices that refer to this License and to the absence of any +warranty; and distribute a copy of this License along with the +Library. + + You may charge a fee for the physical act of transferring a copy, +and you may at your option offer warranty protection in exchange for a +fee. + + 2. You may modify your copy or copies of the Library or any portion +of it, thus forming a work based on the Library, and copy and +distribute such modifications or work under the terms of Section 1 +above, provided that you also meet all of these conditions: + + a) The modified work must itself be a software library. + + b) You must cause the files modified to carry prominent notices + stating that you changed the files and the date of any change. + + c) You must cause the whole of the work to be licensed at no + charge to all third parties under the terms of this License. + + d) If a facility in the modified Library refers to a function or a + table of data to be supplied by an application program that uses + the facility, other than as an argument passed when the facility + is invoked, then you must make a good faith effort to ensure that, + in the event an application does not supply such function or + table, the facility still operates, and performs whatever part of + its purpose remains meaningful. + + (For example, a function in a library to compute square roots has + a purpose that is entirely well-defined independent of the + application. Therefore, Subsection 2d requires that any + application-supplied function or table used by this function must + be optional: if the application does not supply it, the square + root function must still compute square roots.) + +These requirements apply to the modified work as a whole. If +identifiable sections of that work are not derived from the Library, +and can be reasonably considered independent and separate works in +themselves, then this License, and its terms, do not apply to those +sections when you distribute them as separate works. But when you +distribute the same sections as part of a whole which is a work based +on the Library, the distribution of the whole must be on the terms of +this License, whose permissions for other licensees extend to the +entire whole, and thus to each and every part regardless of who wrote +it. + +Thus, it is not the intent of this section to claim rights or contest +your rights to work written entirely by you; rather, the intent is to +exercise the right to control the distribution of derivative or +collective works based on the Library. + +In addition, mere aggregation of another work not based on the Library +with the Library (or with a work based on the Library) on a volume of +a storage or distribution medium does not bring the other work under +the scope of this License. + + 3. You may opt to apply the terms of the ordinary GNU General Public +License instead of this License to a given copy of the Library. To do +this, you must alter all the notices that refer to this License, so +that they refer to the ordinary GNU General Public License, version 2, +instead of to this License. (If a newer version than version 2 of the +ordinary GNU General Public License has appeared, then you can specify +that version instead if you wish.) Do not make any other change in +these notices. + + Once this change is made in a given copy, it is irreversible for +that copy, so the ordinary GNU General Public License applies to all +subsequent copies and derivative works made from that copy. + + This option is useful when you wish to copy part of the code of +the Library into a program that is not a library. + + 4. You may copy and distribute the Library (or a portion or +derivative of it, under Section 2) in object code or executable form +under the terms of Sections 1 and 2 above provided that you accompany +it with the complete corresponding machine-readable source code, which +must be distributed under the terms of Sections 1 and 2 above on a +medium customarily used for software interchange. + + If distribution of object code is made by offering access to copy +from a designated place, then offering equivalent access to copy the +source code from the same place satisfies the requirement to +distribute the source code, even though third parties are not +compelled to copy the source along with the object code. + + 5. A program that contains no derivative of any portion of the +Library, but is designed to work with the Library by being compiled or +linked with it, is called a "work that uses the Library". Such a +work, in isolation, is not a derivative work of the Library, and +therefore falls outside the scope of this License. + + However, linking a "work that uses the Library" with the Library +creates an executable that is a derivative of the Library (because it +contains portions of the Library), rather than a "work that uses the +library". The executable is therefore covered by this License. +Section 6 states terms for distribution of such executables. + + When a "work that uses the Library" uses material from a header file +that is part of the Library, the object code for the work may be a +derivative work of the Library even though the source code is not. +Whether this is true is especially significant if the work can be +linked without the Library, or if the work is itself a library. The +threshold for this to be true is not precisely defined by law. + + If such an object file uses only numerical parameters, data +structure layouts and accessors, and small macros and small inline +functions (ten lines or less in length), then the use of the object +file is unrestricted, regardless of whether it is legally a derivative +work. (Executables containing this object code plus portions of the +Library will still fall under Section 6.) + + Otherwise, if the work is a derivative of the Library, you may +distribute the object code for the work under the terms of Section 6. +Any executables containing that work also fall under Section 6, +whether or not they are linked directly with the Library itself. + + 6. As an exception to the Sections above, you may also combine or +link a "work that uses the Library" with the Library to produce a +work containing portions of the Library, and distribute that work +under terms of your choice, provided that the terms permit +modification of the work for the customer's own use and reverse +engineering for debugging such modifications. + + You must give prominent notice with each copy of the work that the +Library is used in it and that the Library and its use are covered by +this License. You must supply a copy of this License. If the work +during execution displays copyright notices, you must include the +copyright notice for the Library among them, as well as a reference +directing the user to the copy of this License. Also, you must do one +of these things: + + a) Accompany the work with the complete corresponding + machine-readable source code for the Library including whatever + changes were used in the work (which must be distributed under + Sections 1 and 2 above); and, if the work is an executable linked + with the Library, with the complete machine-readable "work that + uses the Library", as object code and/or source code, so that the + user can modify the Library and then relink to produce a modified + executable containing the modified Library. (It is understood + that the user who changes the contents of definitions files in the + Library will not necessarily be able to recompile the application + to use the modified definitions.) + + b) Use a suitable shared library mechanism for linking with the + Library. A suitable mechanism is one that (1) uses at run time a + copy of the library already present on the user's computer system, + rather than copying library functions into the executable, and (2) + will operate properly with a modified version of the library, if + the user installs one, as long as the modified version is + interface-compatible with the version that the work was made with. + + c) Accompany the work with a written offer, valid for at + least three years, to give the same user the materials + specified in Subsection 6a, above, for a charge no more + than the cost of performing this distribution. + + d) If distribution of the work is made by offering access to copy + from a designated place, offer equivalent access to copy the above + specified materials from the same place. + + e) Verify that the user has already received a copy of these + materials or that you have already sent this user a copy. + + For an executable, the required form of the "work that uses the +Library" must include any data and utility programs needed for +reproducing the executable from it. However, as a special exception, +the materials to be distributed need not include anything that is +normally distributed (in either source or binary form) with the major +components (compiler, kernel, and so on) of the operating system on +which the executable runs, unless that component itself accompanies +the executable. + + It may happen that this requirement contradicts the license +restrictions of other proprietary libraries that do not normally +accompany the operating system. Such a contradiction means you cannot +use both them and the Library together in an executable that you +distribute. + + 7. You may place library facilities that are a work based on the +Library side-by-side in a single library together with other library +facilities not covered by this License, and distribute such a combined +library, provided that the separate distribution of the work based on +the Library and of the other library facilities is otherwise +permitted, and provided that you do these two things: + + a) Accompany the combined library with a copy of the same work + based on the Library, uncombined with any other library + facilities. This must be distributed under the terms of the + Sections above. + + b) Give prominent notice with the combined library of the fact + that part of it is a work based on the Library, and explaining + where to find the accompanying uncombined form of the same work. + + 8. You may not copy, modify, sublicense, link with, or distribute +the Library except as expressly provided under this License. Any +attempt otherwise to copy, modify, sublicense, link with, or +distribute the Library is void, and will automatically terminate your +rights under this License. However, parties who have received copies, +or rights, from you under this License will not have their licenses +terminated so long as such parties remain in full compliance. + + 9. You are not required to accept this License, since you have not +signed it. However, nothing else grants you permission to modify or +distribute the Library or its derivative works. These actions are +prohibited by law if you do not accept this License. Therefore, by +modifying or distributing the Library (or any work based on the +Library), you indicate your acceptance of this License to do so, and +all its terms and conditions for copying, distributing or modifying +the Library or works based on it. + + 10. Each time you redistribute the Library (or any work based on the +Library), the recipient automatically receives a license from the +original licensor to copy, distribute, link with or modify the Library +subject to these terms and conditions. You may not impose any further +restrictions on the recipients' exercise of the rights granted herein. +You are not responsible for enforcing compliance by third parties with +this License. + + 11. If, as a consequence of a court judgment or allegation of patent +infringement or for any other reason (not limited to patent issues), +conditions are imposed on you (whether by court order, agreement or +otherwise) that contradict the conditions of this License, they do not +excuse you from the conditions of this License. If you cannot +distribute so as to satisfy simultaneously your obligations under this +License and any other pertinent obligations, then as a consequence you +may not distribute the Library at all. For example, if a patent +license would not permit royalty-free redistribution of the Library by +all those who receive copies directly or indirectly through you, then +the only way you could satisfy both it and this License would be to +refrain entirely from distribution of the Library. + +If any portion of this section is held invalid or unenforceable under any +particular circumstance, the balance of the section is intended to apply, +and the section as a whole is intended to apply in other circumstances. + +It is not the purpose of this section to induce you to infringe any +patents or other property right claims or to contest validity of any +such claims; this section has the sole purpose of protecting the +integrity of the free software distribution system which is +implemented by public license practices. Many people have made +generous contributions to the wide range of software distributed +through that system in reliance on consistent application of that +system; it is up to the author/donor to decide if he or she is willing +to distribute software through any other system and a licensee cannot +impose that choice. + +This section is intended to make thoroughly clear what is believed to +be a consequence of the rest of this License. + + 12. If the distribution and/or use of the Library is restricted in +certain countries either by patents or by copyrighted interfaces, the +original copyright holder who places the Library under this License may add +an explicit geographical distribution limitation excluding those countries, +so that distribution is permitted only in or among countries not thus +excluded. In such case, this License incorporates the limitation as if +written in the body of this License. + + 13. The Free Software Foundation may publish revised and/or new +versions of the Lesser General Public License from time to time. +Such new versions will be similar in spirit to the present version, +but may differ in detail to address new problems or concerns. + +Each version is given a distinguishing version number. If the Library +specifies a version number of this License which applies to it and +"any later version", you have the option of following the terms and +conditions either of that version or of any later version published by +the Free Software Foundation. If the Library does not specify a +license version number, you may choose any version ever published by +the Free Software Foundation. + + 14. If you wish to incorporate parts of the Library into other free +programs whose distribution conditions are incompatible with these, +write to the author to ask for permission. For software which is +copyrighted by the Free Software Foundation, write to the Free +Software Foundation; we sometimes make exceptions for this. Our +decision will be guided by the two goals of preserving the free status +of all derivatives of our free software and of promoting the sharing +and reuse of software generally. + + NO WARRANTY + + 15. BECAUSE THE LIBRARY IS LICENSED FREE OF CHARGE, THERE IS NO +WARRANTY FOR THE LIBRARY, TO THE EXTENT PERMITTED BY APPLICABLE LAW. +EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR +OTHER PARTIES PROVIDE THE LIBRARY "AS IS" WITHOUT WARRANTY OF ANY +KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE +IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR +PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE +LIBRARY IS WITH YOU. SHOULD THE LIBRARY PROVE DEFECTIVE, YOU ASSUME +THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION. + + 16. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN +WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY +AND/OR REDISTRIBUTE THE LIBRARY AS PERMITTED ABOVE, BE LIABLE TO YOU +FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR +CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE +LIBRARY (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING +RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A +FAILURE OF THE LIBRARY TO OPERATE WITH ANY OTHER SOFTWARE), EVEN IF +SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH +DAMAGES. + + END OF TERMS AND CONDITIONS + + How to Apply These Terms to Your New Libraries + + If you develop a new library, and you want it to be of the greatest +possible use to the public, we recommend making it free software that +everyone can redistribute and change. You can do so by permitting +redistribution under these terms (or, alternatively, under the terms of the +ordinary General Public License). + + To apply these terms, attach the following notices to the library. It is +safest to attach them to the start of each source file to most effectively +convey the exclusion of warranty; and each file should have at least the +"copyright" line and a pointer to where the full notice is found. + + + Copyright (C) + + 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. + + , 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. + diff --git a/LICENSE.APLv2.0 b/LICENSE.APLv2.0 new file mode 100755 index 0000000..261eeb9 --- /dev/null +++ b/LICENSE.APLv2.0 @@ -0,0 +1,201 @@ + 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. diff --git a/LICENSE.BSD-style b/LICENSE.BSD-style new file mode 100644 index 0000000..9894c14 --- /dev/null +++ b/LICENSE.BSD-style @@ -0,0 +1,23 @@ +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. diff --git a/LICENSE.LGPLv2.1 b/LICENSE.LGPLv2.1 new file mode 100644 index 0000000..8add30a --- /dev/null +++ b/LICENSE.LGPLv2.1 @@ -0,0 +1,504 @@ + 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. + + Finally, software patents pose a constant threat to the existence of +any free program. We wish to make sure that a company cannot +effectively restrict the users of a free program by obtaining a +restrictive license from a patent holder. Therefore, we insist that +any patent license obtained for a version of the library must be +consistent with the full freedom of use specified in this license. + + Most GNU software, including some libraries, is covered by the +ordinary GNU General Public License. This license, the GNU Lesser +General Public License, applies to certain designated libraries, and +is quite different from the ordinary General Public License. We use +this license for certain libraries in order to permit linking those +libraries into non-free programs. + + When a program is linked with a library, whether statically or using +a shared library, the combination of the two is legally speaking a +combined work, a derivative of the original library. The ordinary +General Public License therefore permits such linking only if the +entire combination fits its criteria of freedom. The Lesser General +Public License permits more lax criteria for linking other code with +the library. + + We call this license the "Lesser" General Public License because it +does Less to protect the user's freedom than the ordinary General +Public License. It also provides other free software developers Less +of an advantage over competing non-free programs. These disadvantages +are the reason we use the ordinary General Public License for many +libraries. However, the Lesser license provides advantages in certain +special circumstances. + + For example, on rare occasions, there may be a special need to +encourage the widest possible use of a certain library, so that it becomes +a de-facto standard. To achieve this, non-free programs must be +allowed to use the library. A more frequent case is that a free +library does the same job as widely used non-free libraries. In this +case, there is little to gain by limiting the free library to free +software only, so we use the Lesser General Public License. + + In other cases, permission to use a particular library in non-free +programs enables a greater number of people to use a large body of +free software. For example, permission to use the GNU C Library in +non-free programs enables many more people to use the whole GNU +operating system, as well as its variant, the GNU/Linux operating +system. + + Although the Lesser General Public License is Less protective of the +users' freedom, it does ensure that the user of a program that is +linked with the Library has the freedom and the wherewithal to run +that program using a modified version of the Library. + + The precise terms and conditions for copying, distribution and +modification follow. Pay close attention to the difference between a +"work based on the library" and a "work that uses the library". The +former contains code derived from the library, whereas the latter must +be combined with the library in order to run. + + GNU LESSER GENERAL PUBLIC LICENSE + TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION + + 0. This License Agreement applies to any software library or other +program which contains a notice placed by the copyright holder or +other authorized party saying it may be distributed under the terms of +this Lesser General Public License (also called "this License"). +Each licensee is addressed as "you". + + A "library" means a collection of software functions and/or data +prepared so as to be conveniently linked with application programs +(which use some of those functions and data) to form executables. + + The "Library", below, refers to any such software library or work +which has been distributed under these terms. A "work based on the +Library" means either the Library or any derivative work under +copyright law: that is to say, a work containing the Library or a +portion of it, either verbatim or with modifications and/or translated +straightforwardly into another language. (Hereinafter, translation is +included without limitation in the term "modification".) + + "Source code" for a work means the preferred form of the work for +making modifications to it. For a library, complete source code means +all the source code for all modules it contains, plus any associated +interface definition files, plus the scripts used to control compilation +and installation of the library. + + Activities other than copying, distribution and modification are not +covered by this License; they are outside its scope. The act of +running a program using the Library is not restricted, and output from +such a program is covered only if its contents constitute a work based +on the Library (independent of the use of the Library in a tool for +writing it). Whether that is true depends on what the Library does +and what the program that uses the Library does. + + 1. You may copy and distribute verbatim copies of the Library's +complete source code as you receive it, in any medium, provided that +you conspicuously and appropriately publish on each copy an +appropriate copyright notice and disclaimer of warranty; keep intact +all the notices that refer to this License and to the absence of any +warranty; and distribute a copy of this License along with the +Library. + + You may charge a fee for the physical act of transferring a copy, +and you may at your option offer warranty protection in exchange for a +fee. + + 2. You may modify your copy or copies of the Library or any portion +of it, thus forming a work based on the Library, and copy and +distribute such modifications or work under the terms of Section 1 +above, provided that you also meet all of these conditions: + + a) The modified work must itself be a software library. + + b) You must cause the files modified to carry prominent notices + stating that you changed the files and the date of any change. + + c) You must cause the whole of the work to be licensed at no + charge to all third parties under the terms of this License. + + d) If a facility in the modified Library refers to a function or a + table of data to be supplied by an application program that uses + the facility, other than as an argument passed when the facility + is invoked, then you must make a good faith effort to ensure that, + in the event an application does not supply such function or + table, the facility still operates, and performs whatever part of + its purpose remains meaningful. + + (For example, a function in a library to compute square roots has + a purpose that is entirely well-defined independent of the + application. Therefore, Subsection 2d requires that any + application-supplied function or table used by this function must + be optional: if the application does not supply it, the square + root function must still compute square roots.) + +These requirements apply to the modified work as a whole. If +identifiable sections of that work are not derived from the Library, +and can be reasonably considered independent and separate works in +themselves, then this License, and its terms, do not apply to those +sections when you distribute them as separate works. But when you +distribute the same sections as part of a whole which is a work based +on the Library, the distribution of the whole must be on the terms of +this License, whose permissions for other licensees extend to the +entire whole, and thus to each and every part regardless of who wrote +it. + +Thus, it is not the intent of this section to claim rights or contest +your rights to work written entirely by you; rather, the intent is to +exercise the right to control the distribution of derivative or +collective works based on the Library. + +In addition, mere aggregation of another work not based on the Library +with the Library (or with a work based on the Library) on a volume of +a storage or distribution medium does not bring the other work under +the scope of this License. + + 3. You may opt to apply the terms of the ordinary GNU General Public +License instead of this License to a given copy of the Library. To do +this, you must alter all the notices that refer to this License, so +that they refer to the ordinary GNU General Public License, version 2, +instead of to this License. (If a newer version than version 2 of the +ordinary GNU General Public License has appeared, then you can specify +that version instead if you wish.) Do not make any other change in +these notices. + + Once this change is made in a given copy, it is irreversible for +that copy, so the ordinary GNU General Public License applies to all +subsequent copies and derivative works made from that copy. + + This option is useful when you wish to copy part of the code of +the Library into a program that is not a library. + + 4. You may copy and distribute the Library (or a portion or +derivative of it, under Section 2) in object code or executable form +under the terms of Sections 1 and 2 above provided that you accompany +it with the complete corresponding machine-readable source code, which +must be distributed under the terms of Sections 1 and 2 above on a +medium customarily used for software interchange. + + If distribution of object code is made by offering access to copy +from a designated place, then offering equivalent access to copy the +source code from the same place satisfies the requirement to +distribute the source code, even though third parties are not +compelled to copy the source along with the object code. + + 5. A program that contains no derivative of any portion of the +Library, but is designed to work with the Library by being compiled or +linked with it, is called a "work that uses the Library". Such a +work, in isolation, is not a derivative work of the Library, and +therefore falls outside the scope of this License. + + However, linking a "work that uses the Library" with the Library +creates an executable that is a derivative of the Library (because it +contains portions of the Library), rather than a "work that uses the +library". The executable is therefore covered by this License. +Section 6 states terms for distribution of such executables. + + When a "work that uses the Library" uses material from a header file +that is part of the Library, the object code for the work may be a +derivative work of the Library even though the source code is not. +Whether this is true is especially significant if the work can be +linked without the Library, or if the work is itself a library. The +threshold for this to be true is not precisely defined by law. + + If such an object file uses only numerical parameters, data +structure layouts and accessors, and small macros and small inline +functions (ten lines or less in length), then the use of the object +file is unrestricted, regardless of whether it is legally a derivative +work. (Executables containing this object code plus portions of the +Library will still fall under Section 6.) + + Otherwise, if the work is a derivative of the Library, you may +distribute the object code for the work under the terms of Section 6. +Any executables containing that work also fall under Section 6, +whether or not they are linked directly with the Library itself. + + 6. As an exception to the Sections above, you may also combine or +link a "work that uses the Library" with the Library to produce a +work containing portions of the Library, and distribute that work +under terms of your choice, provided that the terms permit +modification of the work for the customer's own use and reverse +engineering for debugging such modifications. + + You must give prominent notice with each copy of the work that the +Library is used in it and that the Library and its use are covered by +this License. You must supply a copy of this License. If the work +during execution displays copyright notices, you must include the +copyright notice for the Library among them, as well as a reference +directing the user to the copy of this License. Also, you must do one +of these things: + + a) Accompany the work with the complete corresponding + machine-readable source code for the Library including whatever + changes were used in the work (which must be distributed under + Sections 1 and 2 above); and, if the work is an executable linked + with the Library, with the complete machine-readable "work that + uses the Library", as object code and/or source code, so that the + user can modify the Library and then relink to produce a modified + executable containing the modified Library. (It is understood + that the user who changes the contents of definitions files in the + Library will not necessarily be able to recompile the application + to use the modified definitions.) + + b) Use a suitable shared library mechanism for linking with the + Library. A suitable mechanism is one that (1) uses at run time a + copy of the library already present on the user's computer system, + rather than copying library functions into the executable, and (2) + will operate properly with a modified version of the library, if + the user installs one, as long as the modified version is + interface-compatible with the version that the work was made with. + + c) Accompany the work with a written offer, valid for at + least three years, to give the same user the materials + specified in Subsection 6a, above, for a charge no more + than the cost of performing this distribution. + + d) If distribution of the work is made by offering access to copy + from a designated place, offer equivalent access to copy the above + specified materials from the same place. + + e) Verify that the user has already received a copy of these + materials or that you have already sent this user a copy. + + For an executable, the required form of the "work that uses the +Library" must include any data and utility programs needed for +reproducing the executable from it. However, as a special exception, +the materials to be distributed need not include anything that is +normally distributed (in either source or binary form) with the major +components (compiler, kernel, and so on) of the operating system on +which the executable runs, unless that component itself accompanies +the executable. + + It may happen that this requirement contradicts the license +restrictions of other proprietary libraries that do not normally +accompany the operating system. Such a contradiction means you cannot +use both them and the Library together in an executable that you +distribute. + + 7. You may place library facilities that are a work based on the +Library side-by-side in a single library together with other library +facilities not covered by this License, and distribute such a combined +library, provided that the separate distribution of the work based on +the Library and of the other library facilities is otherwise +permitted, and provided that you do these two things: + + a) Accompany the combined library with a copy of the same work + based on the Library, uncombined with any other library + facilities. This must be distributed under the terms of the + Sections above. + + b) Give prominent notice with the combined library of the fact + that part of it is a work based on the Library, and explaining + where to find the accompanying uncombined form of the same work. + + 8. You may not copy, modify, sublicense, link with, or distribute +the Library except as expressly provided under this License. Any +attempt otherwise to copy, modify, sublicense, link with, or +distribute the Library is void, and will automatically terminate your +rights under this License. However, parties who have received copies, +or rights, from you under this License will not have their licenses +terminated so long as such parties remain in full compliance. + + 9. You are not required to accept this License, since you have not +signed it. However, nothing else grants you permission to modify or +distribute the Library or its derivative works. These actions are +prohibited by law if you do not accept this License. Therefore, by +modifying or distributing the Library (or any work based on the +Library), you indicate your acceptance of this License to do so, and +all its terms and conditions for copying, distributing or modifying +the Library or works based on it. + + 10. Each time you redistribute the Library (or any work based on the +Library), the recipient automatically receives a license from the +original licensor to copy, distribute, link with or modify the Library +subject to these terms and conditions. You may not impose any further +restrictions on the recipients' exercise of the rights granted herein. +You are not responsible for enforcing compliance by third parties with +this License. + + 11. If, as a consequence of a court judgment or allegation of patent +infringement or for any other reason (not limited to patent issues), +conditions are imposed on you (whether by court order, agreement or +otherwise) that contradict the conditions of this License, they do not +excuse you from the conditions of this License. If you cannot +distribute so as to satisfy simultaneously your obligations under this +License and any other pertinent obligations, then as a consequence you +may not distribute the Library at all. For example, if a patent +license would not permit royalty-free redistribution of the Library by +all those who receive copies directly or indirectly through you, then +the only way you could satisfy both it and this License would be to +refrain entirely from distribution of the Library. + +If any portion of this section is held invalid or unenforceable under any +particular circumstance, the balance of the section is intended to apply, +and the section as a whole is intended to apply in other circumstances. + +It is not the purpose of this section to induce you to infringe any +patents or other property right claims or to contest validity of any +such claims; this section has the sole purpose of protecting the +integrity of the free software distribution system which is +implemented by public license practices. Many people have made +generous contributions to the wide range of software distributed +through that system in reliance on consistent application of that +system; it is up to the author/donor to decide if he or she is willing +to distribute software through any other system and a licensee cannot +impose that choice. + +This section is intended to make thoroughly clear what is believed to +be a consequence of the rest of this License. + + 12. If the distribution and/or use of the Library is restricted in +certain countries either by patents or by copyrighted interfaces, the +original copyright holder who places the Library under this License may add +an explicit geographical distribution limitation excluding those countries, +so that distribution is permitted only in or among countries not thus +excluded. In such case, this License incorporates the limitation as if +written in the body of this License. + + 13. The Free Software Foundation may publish revised and/or new +versions of the Lesser General Public License from time to time. +Such new versions will be similar in spirit to the present version, +but may differ in detail to address new problems or concerns. + +Each version is given a distinguishing version number. If the Library +specifies a version number of this License which applies to it and +"any later version", you have the option of following the terms and +conditions either of that version or of any later version published by +the Free Software Foundation. If the Library does not specify a +license version number, you may choose any version ever published by +the Free Software Foundation. + + 14. If you wish to incorporate parts of the Library into other free +programs whose distribution conditions are incompatible with these, +write to the author to ask for permission. For software which is +copyrighted by the Free Software Foundation, write to the Free +Software Foundation; we sometimes make exceptions for this. Our +decision will be guided by the two goals of preserving the free status +of all derivatives of our free software and of promoting the sharing +and reuse of software generally. + + NO WARRANTY + + 15. BECAUSE THE LIBRARY IS LICENSED FREE OF CHARGE, THERE IS NO +WARRANTY FOR THE LIBRARY, TO THE EXTENT PERMITTED BY APPLICABLE LAW. +EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR +OTHER PARTIES PROVIDE THE LIBRARY "AS IS" WITHOUT WARRANTY OF ANY +KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE +IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR +PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE +LIBRARY IS WITH YOU. SHOULD THE LIBRARY PROVE DEFECTIVE, YOU ASSUME +THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION. + + 16. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN +WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY +AND/OR REDISTRIBUTE THE LIBRARY AS PERMITTED ABOVE, BE LIABLE TO YOU +FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR +CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE +LIBRARY (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING +RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A +FAILURE OF THE LIBRARY TO OPERATE WITH ANY OTHER SOFTWARE), EVEN IF +SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH +DAMAGES. + + END OF TERMS AND CONDITIONS + + How to Apply These Terms to Your New Libraries + + If you develop a new library, and you want it to be of the greatest +possible use to the public, we recommend making it free software that +everyone can redistribute and change. You can do so by permitting +redistribution under these terms (or, alternatively, under the terms of the +ordinary General Public License). + + To apply these terms, attach the following notices to the library. It is +safest to attach them to the start of each source file to most effectively +convey the exclusion of warranty; and each file should have at least the +"copyright" line and a pointer to where the full notice is found. + + + Copyright (C) + + 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. + + , 1 April 1990 + Ty Coon, President of Vice + +That's all there is to it! + + diff --git a/NOTICE b/NOTICE new file mode 100644 index 0000000..8bd60d4 --- /dev/null +++ b/NOTICE @@ -0,0 +1,13 @@ +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/ diff --git a/image/SLP_MediaSvc_PG_image001.png b/image/SLP_MediaSvc_PG_image001.png new file mode 100755 index 0000000..d120338 Binary files /dev/null and b/image/SLP_MediaSvc_PG_image001.png differ diff --git a/image/SLP_MediaSvc_PG_image002.png b/image/SLP_MediaSvc_PG_image002.png new file mode 100755 index 0000000..5edce77 Binary files /dev/null and b/image/SLP_MediaSvc_PG_image002.png differ diff --git a/image/SLP_MusicSVC_PG_image001.png b/image/SLP_MusicSVC_PG_image001.png new file mode 100755 index 0000000..fbb7cc4 Binary files /dev/null and b/image/SLP_MusicSVC_PG_image001.png differ diff --git a/image/SLP_MusicSVC_PG_image002.png b/image/SLP_MusicSVC_PG_image002.png new file mode 100755 index 0000000..7d783be Binary files /dev/null and b/image/SLP_MusicSVC_PG_image002.png differ diff --git a/include/media-svc-error.h b/include/media-svc-error.h new file mode 100755 index 0000000..ed28a53 --- /dev/null +++ b/include/media-svc-error.h @@ -0,0 +1,89 @@ +/* + * libmedia-service + * + * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved. + * + * Contact: Hyunjun Ko , Haejeong Kim + * + * 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_*/ diff --git a/include/media-svc-types.h b/include/media-svc-types.h new file mode 100755 index 0000000..2f202ec --- /dev/null +++ b/include/media-svc-types.h @@ -0,0 +1,53 @@ +/* + * libmedia-service + * + * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved. + * + * Contact: Hyunjun Ko , Haejeong Kim + * + * 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_*/ diff --git a/include/media-svc.h b/include/media-svc.h new file mode 100755 index 0000000..1471d3d --- /dev/null +++ b/include/media-svc.h @@ -0,0 +1,247 @@ +/* + * libmedia-service + * + * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved. + * + * Contact: Hyunjun Ko , Haejeong Kim + * + * 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 + +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 + +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 + +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_*/ diff --git a/libmedia-service.manifest b/libmedia-service.manifest new file mode 100644 index 0000000..ca37499 --- /dev/null +++ b/libmedia-service.manifest @@ -0,0 +1,6 @@ + + + + + + diff --git a/libmedia-service.pc.in b/libmedia-service.pc.in new file mode 100755 index 0000000..978a9c9 --- /dev/null +++ b/libmedia-service.pc.in @@ -0,0 +1,13 @@ +# 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 diff --git a/md5/md5.c b/md5/md5.c new file mode 100644 index 0000000..59b47ba --- /dev/null +++ b/md5/md5.c @@ -0,0 +1,253 @@ +/* + * 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 /* 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<>(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; +} diff --git a/md5/md5.h b/md5/md5.h new file mode 100644 index 0000000..dac53fb --- /dev/null +++ b/md5/md5.h @@ -0,0 +1,39 @@ +/* + * 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 +#include + +#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 diff --git a/md5/media-svc-hash.c b/md5/media-svc-hash.c new file mode 100755 index 0000000..ae8209d --- /dev/null +++ b/md5/media-svc-hash.c @@ -0,0 +1,133 @@ +/* GLIB - Library of useful routines for C programming + * + * gconvert.c: Convert between character sets using iconv + * Copyright Red Hat Inc., 2000 + * Authors: Havoc Pennington , Owen Taylor +#include +#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; +} + diff --git a/md5/media-svc-hash.h b/md5/media-svc-hash.h new file mode 100755 index 0000000..3aedc65 --- /dev/null +++ b/md5/media-svc-hash.h @@ -0,0 +1,24 @@ +/* + * 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_*/ + diff --git a/packaging/libmedia-service.spec b/packaging/libmedia-service.spec new file mode 100755 index 0000000..38ec448 --- /dev/null +++ b/packaging/libmedia-service.spec @@ -0,0 +1,73 @@ +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 diff --git a/plugin/media-content-plugin.c b/plugin/media-content-plugin.c new file mode 100755 index 0000000..97f59f7 --- /dev/null +++ b/plugin/media-content-plugin.c @@ -0,0 +1,787 @@ +/* + * libmedia-service + * + * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved. + * + * Contact: Hyunjun Ko , Haejeong Kim + * + * 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 +#include +#include +#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; +} diff --git a/src/common/media-svc-album.c b/src/common/media-svc-album.c new file mode 100755 index 0000000..6f66160 --- /dev/null +++ b/src/common/media-svc-album.c @@ -0,0 +1,124 @@ +/* + * libmedia-service + * + * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved. + * + * Contact: Hyunjun Ko , Haejeong Kim + * + * 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; +} diff --git a/src/common/media-svc-db-utils.c b/src/common/media-svc-db-utils.c new file mode 100755 index 0000000..5d30705 --- /dev/null +++ b/src/common/media-svc-db-utils.c @@ -0,0 +1,692 @@ +/* + * libmedia-service + * + * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved. + * + * Contact: Hyunjun Ko , Haejeong Kim + * + * 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 +#include +#include +#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; + } +} diff --git a/src/common/media-svc-debug.c b/src/common/media-svc-debug.c new file mode 100755 index 0000000..53617c6 --- /dev/null +++ b/src/common/media-svc-debug.c @@ -0,0 +1,111 @@ +/* + * libmedia-service + * + * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved. + * + * Contact: Hyunjun Ko , Haejeong Kim + * + * 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 +#include +#include +#include +#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 +} diff --git a/src/common/media-svc-media-folder.c b/src/common/media-svc-media-folder.c new file mode 100755 index 0000000..2a1678a --- /dev/null +++ b/src/common/media-svc-media-folder.c @@ -0,0 +1,146 @@ +/* + * libmedia-service + * + * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved. + * + * Contact: Hyunjun Ko , Haejeong Kim + * + * 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 +#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; +} diff --git a/src/common/media-svc-media.c b/src/common/media-svc-media.c new file mode 100755 index 0000000..d0ef0d6 --- /dev/null +++ b/src/common/media-svc-media.c @@ -0,0 +1,667 @@ +/* + * libmedia-service + * + * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved. + * + * Contact: Hyunjun Ko , Haejeong Kim + * + * 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 +#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; + +} diff --git a/src/common/media-svc-util.c b/src/common/media-svc-util.c new file mode 100755 index 0000000..a6160b6 --- /dev/null +++ b/src/common/media-svc-util.c @@ -0,0 +1,1953 @@ +/* + * libmedia-service + * + * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved. + * + * Contact: Hyunjun Ko , Haejeong Kim + * + * 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 +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#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; +} diff --git a/src/common/media-svc.c b/src/common/media-svc.c new file mode 100755 index 0000000..1dcebb9 --- /dev/null +++ b/src/common/media-svc.c @@ -0,0 +1,1084 @@ +/* + * libmedia-service + * + * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved. + * + * Contact: Hyunjun Ko , Haejeong Kim + * + * 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 +#include +#include +#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); +} diff --git a/src/include/common/media-svc-album.h b/src/include/common/media-svc-album.h new file mode 100755 index 0000000..09fe97b --- /dev/null +++ b/src/include/common/media-svc-album.h @@ -0,0 +1,32 @@ +/* + * libmedia-service + * + * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved. + * + * Contact: Hyunjun Ko , Haejeong Kim + * + * 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 + +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_*/ diff --git a/src/include/common/media-svc-db-utils.h b/src/include/common/media-svc-db-utils.h new file mode 100755 index 0000000..8493a64 --- /dev/null +++ b/src/include/common/media-svc-db-utils.h @@ -0,0 +1,50 @@ +/* + * libmedia-service + * + * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved. + * + * Contact: Hyunjun Ko , Haejeong Kim + * + * 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 +#include + +#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_*/ diff --git a/src/include/common/media-svc-debug.h b/src/include/common/media-svc-debug.h new file mode 100755 index 0000000..857f130 --- /dev/null +++ b/src/include/common/media-svc-debug.h @@ -0,0 +1,96 @@ +/* + * libmedia-service + * + * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved. + * + * Contact: Hyunjun Ko , Haejeong Kim + * + * 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 +#include +#include + +#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_*/ diff --git a/src/include/common/media-svc-env.h b/src/include/common/media-svc-env.h new file mode 100755 index 0000000..3de5b73 --- /dev/null +++ b/src/include/common/media-svc-env.h @@ -0,0 +1,204 @@ +/* + * libmedia-service + * + * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved. + * + * Contact: Hyunjun Ko , Haejeong Kim + * + * 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 +#include + +#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_*/ diff --git a/src/include/common/media-svc-media-folder.h b/src/include/common/media-svc-media-folder.h new file mode 100755 index 0000000..3b9897a --- /dev/null +++ b/src/include/common/media-svc-media-folder.h @@ -0,0 +1,35 @@ +/* + * libmedia-service + * + * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved. + * + * Contact: Hyunjun Ko , Haejeong Kim + * + * 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 +#include +#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_*/ diff --git a/src/include/common/media-svc-media.h b/src/include/common/media-svc-media.h new file mode 100755 index 0000000..1d83735 --- /dev/null +++ b/src/include/common/media-svc-media.h @@ -0,0 +1,48 @@ +/* + * libmedia-service + * + * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved. + * + * Contact: Hyunjun Ko , Haejeong Kim + * + * 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 +#include +#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_*/ diff --git a/src/include/common/media-svc-util.h b/src/include/common/media-svc-util.h new file mode 100755 index 0000000..cd1f80f --- /dev/null +++ b/src/include/common/media-svc-util.h @@ -0,0 +1,146 @@ +/* + * libmedia-service + * + * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved. + * + * Contact: Hyunjun Ko , Haejeong Kim + * + * 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 +#include +#include +#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_*/ diff --git a/test/plugin/Makefile b/test/plugin/Makefile new file mode 100644 index 0000000..94e3a27 --- /dev/null +++ b/test/plugin/Makefile @@ -0,0 +1,14 @@ +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) diff --git a/test/plugin/media_svc_plugin_test.c b/test/plugin/media_svc_plugin_test.c new file mode 100755 index 0000000..eb4023f --- /dev/null +++ b/test/plugin/media_svc_plugin_test.c @@ -0,0 +1,234 @@ +/* + * libmedia-service + * + * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved. + * + * Contact: Hyunjun Ko , Haejeong Kim + * + * 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 +#include +#include +#include + +#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); +} + diff --git a/uuid/clear.c b/uuid/clear.c new file mode 100644 index 0000000..2d91fee --- /dev/null +++ b/uuid/clear.c @@ -0,0 +1,43 @@ +/* + * 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); +} + diff --git a/uuid/compare.c b/uuid/compare.c new file mode 100644 index 0000000..f28a726 --- /dev/null +++ b/uuid/compare.c @@ -0,0 +1,55 @@ +/* + * 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 + +#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); +} + diff --git a/uuid/copy.c b/uuid/copy.c new file mode 100644 index 0000000..ead33aa --- /dev/null +++ b/uuid/copy.c @@ -0,0 +1,45 @@ +/* + * 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++; +} diff --git a/uuid/gen_uuid.c b/uuid/gen_uuid.c new file mode 100644 index 0000000..48a7f4a --- /dev/null +++ b/uuid/gen_uuid.c @@ -0,0 +1,672 @@ +/* + * 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 +#define UUID MYUUID +#endif +#include +#ifdef HAVE_UNISTD_H +#include +#endif +#ifdef HAVE_STDLIB_H +#include +#endif +#include +#include +#include +#include +#ifdef HAVE_SYS_TIME_H +#include +#endif +#include +#include +#ifdef HAVE_SYS_FILE_H +#include +#endif +#ifdef HAVE_SYS_IOCTL_H +#include +#endif +#ifdef HAVE_SYS_SOCKET_H +#include +#endif +#ifdef HAVE_SYS_UN_H +#include +#endif +#ifdef HAVE_SYS_SOCKIO_H +#include +#endif +#ifdef HAVE_NET_IF_H +#include +#endif +#ifdef HAVE_NETINET_IN_H +#include +#endif +#ifdef HAVE_NET_IF_DL_H +#include +#endif +#if defined(__linux__) && defined(HAVE_SYS_SYSCALL_H) +#include +#endif +#ifdef HAVE_SYS_RESOURCE_H +#include +#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); +} diff --git a/uuid/isnull.c b/uuid/isnull.c new file mode 100644 index 0000000..931e7e7 --- /dev/null +++ b/uuid/isnull.c @@ -0,0 +1,48 @@ +/* + * 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; +} + diff --git a/uuid/pack.c b/uuid/pack.c new file mode 100644 index 0000000..097516d --- /dev/null +++ b/uuid/pack.c @@ -0,0 +1,69 @@ +/* + * 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 +#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); +} + diff --git a/uuid/parse.c b/uuid/parse.c new file mode 100644 index 0000000..074383e --- /dev/null +++ b/uuid/parse.c @@ -0,0 +1,79 @@ +/* + * 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 +#include +#include +#include + +#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; +} diff --git a/uuid/unpack.c b/uuid/unpack.c new file mode 100644 index 0000000..beaaff3 --- /dev/null +++ b/uuid/unpack.c @@ -0,0 +1,63 @@ +/* + * 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 +#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); +} + diff --git a/uuid/unparse.c b/uuid/unparse.c new file mode 100644 index 0000000..a95bbb0 --- /dev/null +++ b/uuid/unparse.c @@ -0,0 +1,76 @@ +/* + * 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 + +#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); +} diff --git a/uuid/uuid.h b/uuid/uuid.h new file mode 100644 index 0000000..ca846da --- /dev/null +++ b/uuid/uuid.h @@ -0,0 +1,103 @@ +/* + * 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 +#ifndef _WIN32 +#include +#endif +#include + +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 */ diff --git a/uuid/uuidP.h b/uuid/uuidP.h new file mode 100644 index 0000000..86d86c5 --- /dev/null +++ b/uuid/uuidP.h @@ -0,0 +1,66 @@ +/* + * 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 +#else +#include +#endif +#include + +#include +#include +#include +#include + +/* + * 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); diff --git a/uuid/uuid_time.c b/uuid/uuid_time.c new file mode 100644 index 0000000..f25f5c9 --- /dev/null +++ b/uuid/uuid_time.c @@ -0,0 +1,171 @@ +/* + * 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 +#define UUID MYUUID +#endif + +#include +#ifdef HAVE_UNISTD_H +#include +#endif +#include +#include +#ifdef HAVE_SYS_TIME_H +#include +#endif +#include + +#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 diff --git a/uuid/uuid_types.h b/uuid/uuid_types.h new file mode 100644 index 0000000..169a88a --- /dev/null +++ b/uuid/uuid_types.h @@ -0,0 +1,50 @@ +/* + * 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 diff --git a/uuid/uuidd.h b/uuid/uuidd.h new file mode 100644 index 0000000..c71f4b7 --- /dev/null +++ b/uuid/uuidd.h @@ -0,0 +1,54 @@ +/* + * 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 */