SET(MEDIATHUMB-LIB "media-thumbnail")
SET(MEDIAHASH-LIB "media-hash")
-SET(SRCS
+SET(SRCS
src/media-thumbnail.c
src/media-thumb-internal.c
src/util/media-thumb-debug.c
INSTALL(FILES ${CMAKE_CURRENT_SOURCE_DIR}/include/media-thumbnail.h DESTINATION include/${MEDIATHUMB-LIB})
INSTALL(FILES ${CMAKE_CURRENT_SOURCE_DIR}/include/media-thumbnail-private.h DESTINATION include/${MEDIATHUMB-LIB})
-INSTALL(FILES ${CMAKE_CURRENT_SOURCE_DIR}/include/media-thumb-error.h DESTINATION include/${MEDIATHUMB-LIB})
INSTALL(FILES ${CMAKE_CURRENT_SOURCE_DIR}/include/media-thumb-types.h DESTINATION include/${MEDIATHUMB-LIB})
#INSTALL(FILES ${CMAKE_CURRENT_SOURCE_DIR}/thumbsvr DESTINATION /etc/init.d)
+++ /dev/null
-/*
- * libmedia-thumbnail
- *
- * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
- *
- * Contact: Hyunjun Ko <zzoon.ko@samsung.com>
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- */
-
-
-
-#ifndef _MEDIA_THUMB_ERROR_H_
-#define _MEDIA_THUMB_ERROR_H_
-
-/**
- @addtogroup THUMB_GENERATE
- @{
- * @file media-thumb-error.h
- * @brief This file defines error codes for thumbnail generation.
-
- */
-
-/**
- @defgroup THUMB_GENERAE_ERROR error code
- @{
-
- @par
- error code
- */
-
-
-#define MEDIA_THUMB_ERROR_NONE 0 /* No Error */
-#define MEDIA_THUMB_ERROR_INVALID_PARAMETER -1 /* invalid parameter(s) */
-#define MEDIA_THUMB_ERROR_TOO_BIG -2 /* Original is too big to make thumb */
-#define MEDIA_THUMB_ERROR_MM_UTIL -3 /* Error in mm-util lib */
-#define MEDIA_THUMB_ERROR_UNSUPPORTED -4 /* Unsupported type */
-#define MEDIA_THUMB_ERROR_NETWORK -5 /* Error in socket */
-#define MEDIA_THUMB_ERROR_DB -6 /* Timeout */
-#define MEDIA_THUMB_ERROR_TIMEOUT -7 /* Timeout */
-#define MEDIA_THUMB_ERROR_HASHCODE -8 /* Failed to generate hash code */
-#define MEDIA_THUMB_ERROR_DUPLICATED_REQUEST -9 /* Duplicated request of same path */
-
-/**
- @}
-*/
-
-/**
- @}
-*/
-
-#endif /*_MEDIA_THUMB_ERROR_H_*/
* limitations under the License.
*
*/
-
-
+#include "media-util.h"
#ifndef _MEDIA_THUMB_TYPES_H_
#define _MEDIA_THUMB_TYPES_H_
#ifndef _MEDIA_THUMBNAIL_PRIVATE_H_
#define _MEDIA_THUMBNAIL_PRIVATE_H_
-#include "media-thumb-error.h"
-
#ifdef __cplusplus
extern "C" {
#endif
#include <sys/types.h>
#include "media-thumb-types.h"
-#include "media-thumb-error.h"
#ifdef __cplusplus
extern "C" {
#include "media-thumbnail-private.h"
#include <string.h>
#include <alloca.h>
+#include <media-util-err.h>
static const char ACCEPTABLE_URI_CHARS[96] = {
char *hash = NULL;
if (max_length < ((2 * MD5_HASHBYTES) + 1)) {
- return MEDIA_THUMB_ERROR_INVALID_PARAMETER;
+ return MS_MEDIA_ERR_INVALID_PARAMETER;
}
hash = _media_thumb_generate_hash_name(origin_path);
if (hash == NULL) {
- return MEDIA_THUMB_ERROR_HASHCODE;
+ return MS_MEDIA_ERR_INTERNAL;
}
strncpy(hash_code, hash, max_length);
hash_code[strlen(hash_code)] ='\0';
- return MEDIA_THUMB_ERROR_NONE;
+ return MS_MEDIA_ERR_NONE;
}
Source1002: %{name}-devel.manifest
Source1003: media-thumbnail-server.manifest
+Requires: media-server
BuildRequires: cmake
BuildRequires: pkgconfig(aul)
BuildRequires: pkgconfig(dlog)
BuildRequires: pkgconfig(vconf)
BuildRequires: pkgconfig(libtzplatform-config)
BuildRequires: pkgconfig(gdk-pixbuf-2.0)
-Requires: media-server
%description
Media thumbnail service library for multimedia applications.
int _thumb_daemon_process_job(thumbMsg *req_msg, thumbMsg *res_msg, uid_t uid)
{
- int err = -1;
+ int err = MS_MEDIA_ERR_NONE;
err = _media_thumb_process(req_msg, res_msg, uid);
- if (err < 0) {
+ if (err != MS_MEDIA_ERR_NONE) {
if (req_msg->msg_type == THUMB_REQUEST_SAVE_FILE) {
thumb_err("_media_thumb_process is failed: %d", err);
res_msg->status = THUMB_FAIL;
int _thumb_daemon_all_extract(uid_t uid)
{
- int err = -1;
+ int err = MS_MEDIA_ERR_NONE;
int count = 0;
char query_string[MAX_PATH_SIZE + 1] = { 0, };
char path[MAX_PATH_SIZE + 1] = { 0, };
sqlite3_stmt *sqlite_stmt = NULL;
err = _media_thumb_db_connect(uid);
- if (err < 0) {
+ if (err != MS_MEDIA_ERR_NONE) {
thumb_err("_media_thumb_db_connect failed: %d", err);
- return MEDIA_THUMB_ERROR_DB;
+ return err;
}
sqlite_db_handle = _media_thumb_db_get_handle();
if (sqlite_db_handle == NULL) {
thumb_err("sqlite handle is NULL");
- return MEDIA_THUMB_ERROR_DB;
+ return MS_MEDIA_ERR_INTERNAL;
}
if (_thumb_daemon_mmc_status() == VCONFKEY_SYSMAN_MMC_MOUNTED) {
} else {
snprintf(query_string, sizeof(query_string), SELECT_PATH_FROM_UNEXTRACTED_THUMB_INTERNAL_MEDIA);
}
-
+
thumb_warn("Query: %s", query_string);
err = sqlite3_prepare_v2(sqlite_db_handle, query_string, strlen(query_string), &sqlite_stmt, NULL);
if (SQLITE_OK != err) {
- thumb_err("prepare error [%s]\n", sqlite3_errmsg(sqlite_db_handle));
+ thumb_err("prepare error [%s]", sqlite3_errmsg(sqlite_db_handle));
_media_thumb_db_disconnect();
- return MEDIA_THUMB_ERROR_DB;
+ return MS_MEDIA_ERR_INTERNAL;
}
while(1) {
err = sqlite3_step(sqlite_stmt);
if (err != SQLITE_ROW) {
- thumb_dbg("end of row [%s]\n", sqlite3_errmsg(sqlite_db_handle));
+ thumb_dbg("end of row [%s]", sqlite3_errmsg(sqlite_db_handle));
break;
}
sqlite3_finalize(sqlite_stmt);
_media_thumb_db_disconnect();
- return MEDIA_THUMB_ERROR_NONE;
+ return MS_MEDIA_ERR_NONE;
}
int _thumb_daemon_process_queue_jobs(gpointer data)
{
- int err = -1;
+ int err = MS_MEDIA_ERR_NONE;
char *path = NULL;
uid_t uid = NULL;
if (g_cur_idx < g_idx) {
- thumb_dbg("There are %d jobs in the queue", g_idx - g_cur_idx);
+ thumb_warn("There are %d jobs in the queue", g_idx - g_cur_idx);
thumb_dbg("Current idx : [%d]", g_cur_idx);
uid = arr_uid[g_cur_idx];
path = arr_path[g_cur_idx++];
if (res_msg.status == THUMB_SUCCESS) {
err = _media_thumb_db_connect(uid);
- if (err < 0) {
+ if (err != MS_MEDIA_ERR_NONE) {
thumb_err("_media_thumb_mb_svc_connect failed: %d", err);
return TRUE;
}
#include "media-thumb-ipc.h"
#include "media-thumb-util.h"
#include "thumb-server-internal.h"
-
#include <pthread.h>
#include <heynoti.h>
#include <vconf.h>
/* Create and bind new UDP socket */
if (!_thumb_server_prepare_socket(&sockfd)) {
- thumb_err("Failed to create socket\n");
+ thumb_err("Failed to create socket");
return -1;
}
g_thumb_server_mainloop = g_main_loop_new(context, FALSE);
-
+
/* Create new channel to watch udp socket */
channel = g_io_channel_unix_new(sockfd);
source = g_io_create_watch(channel, G_IO_IN);
g_source_set_callback(sig_handler_src, (GSourceFunc)_media_thumb_signal_handler, NULL, NULL);
g_source_attach(sig_handler_src, context);
*/
-
thumb_dbg("************************************");
thumb_dbg("*** Thumbnail server is running ***");
thumb_dbg("************************************");
g_main_loop_run(g_thumb_server_mainloop);
-
- thumb_dbg("Thumbnail server is shutting down...");
+ thumb_dbg("Thumbnail server is shutting down...");
g_io_channel_shutdown(channel, FALSE, NULL);
g_io_channel_unref(channel);
_thumb_daemon_finish_jobs();
int inputPos = 0;
int inputPos_temp = 0;
- AGifFrameInfo *pFrameData;
+ AGifFrameInfo *pFrameData;
if (0 == (pFrameData = IfegMemAlloc(sizeof(AGifFrameInfo)))) {
return 0;
}
backcolor_parsing = (unsigned short)((pEncodedData[inputPos+backcolor_index*3] >> 3)<<11) | ((pEncodedData[inputPos+backcolor_index*3+1] >> 2)<<5) | (pEncodedData[inputPos+backcolor_index*3+2] >> 3);
}
- /* graphic extension block */
+ /* graphic extension block */
if (pEncodedData[14+header_temp] == 0xF9 || pEncodedData[14+19+header_temp] == 0xF9) {
if (transparent == 1 && backcolor_index == transIndex) {
if (pFrameData->nLoopCount == -1) {
break;
} else if (pFrameData->bLoop || (pFrameData->nRepeatCount <= pFrameData->nLoopCount) || (pFrameData->nLoopCount == 0)) {
- /* Background Color */
+ /* Background Color */
pImage16 = (unsigned short *)pFrameData->pPrevImg;
for (i = 0; i < expected_width * expected_height; i++) {
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
-
+#include <errno.h>
//#include <drm-service.h>
#include <drm_client.h>
#include <sys/time.h>
#endif
+#include <media-util-err.h>
#include "media-thumb-debug.h"
#include "img-codec-common.h"
#include "img-codec-parser.h"
unsigned char tmp;
if (DrmReadFile(hFile, EncodedDataBuffer, 32, &fileread) ==
- FALSE) {
+ FALSE) {
thumb_err("DrmReadFile was failed");
return IMG_CODEC_NONE;
}
tmp = *(EncodedDataBuffer + 20);
/* If image is interlaced then multiple should be 2 */
if (tmp) {
- thumb_dbg("Interlaced PNG Image.\n");
+ thumb_dbg("Interlaced PNG Image.");
}
thumb_dbg("IMG_CODEC_PNG\n");
return IMG_CODEC_PNG;
}
if (pWidth) {
*pWidth =
- EncodedDataBuffer[18] | (EncodedDataBuffer[19] << 8)
- | (EncodedDataBuffer[20] << 16) |
- (EncodedDataBuffer[21] << 24);
+ EncodedDataBuffer[18] | (EncodedDataBuffer[19] << 8)
+ | (EncodedDataBuffer[20] << 16) |
+ (EncodedDataBuffer[21] << 24);
}
if (pHeight) {
*pHeight =
- EncodedDataBuffer[22] | (EncodedDataBuffer[23] << 8)
- | (EncodedDataBuffer[24] << 16) |
- (EncodedDataBuffer[25] << 24);
+ EncodedDataBuffer[22] | (EncodedDataBuffer[23] << 8)
+ | (EncodedDataBuffer[24] << 16) |
+ (EncodedDataBuffer[25] << 24);
}
thumb_dbg("IMG_CODEC_BMP");
return IMG_CODEC_BMP;
}
/*********************** GIF *************************/
- else if (AcMemcmp(EncodedDataBuffer, gIfegGIFHeader, GIF_HEADER_LENGTH)
- == 0) {
+ else if (AcMemcmp(EncodedDataBuffer, gIfegGIFHeader, GIF_HEADER_LENGTH) == 0) {
unsigned int tablelength = 0;
unsigned int imagecount = 0;
int finished = 0;
return IMG_CODEC_UNKNOWN_TYPE;
}
- if (DrmReadFile(hFile, &EncodedDataBuffer[8], 5, &fileread) ==
- FALSE) {
+ if (DrmReadFile(hFile, &EncodedDataBuffer[8], 5, &fileread) == FALSE) {
thumb_err("DrmReadFile was failed");
return IMG_CODEC_NONE;
}
if (EncodedDataBuffer[0] != 'G' || EncodedDataBuffer[1] != 'I'
- || EncodedDataBuffer[2] != 'F' || EncodedDataBuffer[3] < '0'
- || EncodedDataBuffer[3] > '9' || EncodedDataBuffer[4] < '0'
- || EncodedDataBuffer[4] > '9' || EncodedDataBuffer[5] < 'A'
- || EncodedDataBuffer[5] > 'z') {
+ || EncodedDataBuffer[2] != 'F' || EncodedDataBuffer[3] < '0'
+ || EncodedDataBuffer[3] > '9' || EncodedDataBuffer[4] < '0'
+ || EncodedDataBuffer[4] > '9' || EncodedDataBuffer[5] < 'A'
+ || EncodedDataBuffer[5] > 'z') {
thumb_warn("IMG_CODEC_UNKNOWN_TYPE in GIF");
return IMG_CODEC_UNKNOWN_TYPE;
}
EncodedDataBuffer[8] | (EncodedDataBuffer[9] << 8);
}
- thumb_dbg("Logical width : %d, Height : %d", *pWidth,
- *pHeight);
+ thumb_dbg("Logical width : %d, Height : %d", *pWidth, *pHeight);
if ((EncodedDataBuffer[10] & 0x80) != 0) { /* Global color table */
temp = (EncodedDataBuffer[10] & 0x7) + 1;
tablelength = (1 << temp) * 3;
- if ((tablelength * sizeof(char)) >
- sizeof(EncodedDataBuffer)) {
- thumb_warn
- ("_ImgGetInfoStreaming :table length is more than buffer length");
+ if ((tablelength * sizeof(char)) > sizeof(EncodedDataBuffer)) {
+ thumb_warn("_ImgGetInfoStreaming :table length is more than buffer length");
return IMG_CODEC_UNKNOWN_TYPE;
}
return IMG_CODEC_UNKNOWN_TYPE;
}
/* coverity[ -tainted_data_argument : EncodedDataBuffer ] */
- if (DrmReadFile
- (hFile, EncodedDataBuffer, tablelength,
- &fileread) == FALSE) {
+ if (DrmReadFile(hFile, EncodedDataBuffer, tablelength, &fileread) == FALSE) {
thumb_err("DrmReadFile was failed");
return IMG_CODEC_NONE;
return IMG_CODEC_UNKNOWN_TYPE;
}
- switch (EncodedDataBuffer
- [ifegstreamctrl.buffpos++]) {
+ switch (EncodedDataBuffer[ifegstreamctrl.buffpos++]) {
case 0xf9: /* Graphic control extension block */
- if (_CheckBuffer(&ifegstreamctrl, 6) ==
- 0) {
- thumb_warn
- ("_CheckBuffer was failed");
+ if (_CheckBuffer(&ifegstreamctrl, 6) == 0) {
+ thumb_warn("_CheckBuffer was failed");
return IMG_CODEC_UNKNOWN_TYPE;
}
case 0x01: /* Plain Text block */
case 0xfe: /* Comment Extension block */
case 0xff: /* Appliation Extension block */
- if (_CheckBuffer(&ifegstreamctrl, 1) ==
- 0) {
- thumb_warn
- ("_CheckBuffer was failed");
+ if (_CheckBuffer(&ifegstreamctrl, 1) == 0) {
+ thumb_warn("_CheckBuffer was failed");
return IMG_CODEC_UNKNOWN_TYPE;
}
- if (ifegstreamctrl.buffpos >
- sizeof(EncodedDataBuffer)) {
- thumb_warn
- ("buffer position exceeds buffer max length ");
+ if (ifegstreamctrl.buffpos > sizeof(EncodedDataBuffer)) {
+ thumb_warn("buffer position exceeds buffer max length ");
return IMG_CODEC_UNKNOWN_TYPE;
}
while ((ifegstreamctrl.buffpos < sizeof(EncodedDataBuffer)) && ((length = EncodedDataBuffer[ifegstreamctrl.buffpos++]) > 0)) { /* get the data length */
- if (_CheckBuffer
- (&ifegstreamctrl,
- length) == 0) {
- thumb_warn
- ("_CheckBuffer was failed");
- return
- IMG_CODEC_UNKNOWN_TYPE;
+ if (_CheckBuffer(&ifegstreamctrl, length) == 0) {
+ thumb_warn("_CheckBuffer was failed");
+ return IMG_CODEC_UNKNOWN_TYPE;
}
/* Check integer overflow */
return IMG_CODEC_UNKNOWN_TYPE;
}
- ifegstreamctrl.buffpos +=
- (length);
+ ifegstreamctrl.buffpos += (length);
/* File End Check */
}
break;
return IMG_CODEC_UNKNOWN_TYPE;
}
- temp =
- EncodedDataBuffer[ifegstreamctrl.buffpos++];
+ temp = EncodedDataBuffer[ifegstreamctrl.buffpos++];
if (temp < 2 || 9 < temp) {
return IMG_CODEC_UNKNOWN_TYPE;
}
do {
- if (_CheckBuffer(&ifegstreamctrl, 1) ==
- 0) {
- thumb_warn
- ("_CheckBuffer was failed");
+ if (_CheckBuffer(&ifegstreamctrl, 1) == 0) {
+ thumb_warn("_CheckBuffer was failed");
return IMG_CODEC_UNKNOWN_TYPE;
}
- length =
- EncodedDataBuffer[ifegstreamctrl.
- buffpos++];
+ length =EncodedDataBuffer[ifegstreamctrl.buffpos++];
if ((length + ifegstreamctrl.buffpos) > ifegstreamctrl.buffend) {
length =
- length +
- ifegstreamctrl.buffpos -
- ifegstreamctrl.buffend;
- if (DrmSeekFile
- (ifegstreamctrl.fd,
- SEEK_CUR,
- length) == FALSE) {
+ length +
+ ifegstreamctrl.buffpos -
+ ifegstreamctrl.buffend;
+ if (DrmSeekFile(ifegstreamctrl.fd, SEEK_CUR, length) == FALSE) {
if (imagecount) {
if (pNumberOfFrames)
*pNumberOfFrames
= 2;
- thumb_dbg
- ("IMG_CODEC_AGIF");
- return
- IMG_CODEC_AGIF;
+ thumb_dbg("IMG_CODEC_AGIF");
+ return IMG_CODEC_AGIF;
}
- return
- IMG_CODEC_UNKNOWN_TYPE;
+ return IMG_CODEC_UNKNOWN_TYPE;
}
- ifegstreamctrl.filepos +=
- length;
+ ifegstreamctrl.filepos += length;
ifegstreamctrl.buffpos = 0;
ifegstreamctrl.buffend = 0;
} else {
- ifegstreamctrl.buffpos +=
- length;
+ ifegstreamctrl.buffpos +=length;
}
/* File End Check */
#include "img-codec-parser.h"
#include "img-codec-agif.h"
-
#ifdef __cplusplus
extern "C" {
#endif /* __cplusplus */
*/
-#include "media-thumb-error.h"
#include "media-thumb-debug.h"
#include "media-thumb-types.h"
#include "media-thumb-internal.h"
*
*/
-
+#include <stdbool.h>
+#include <media-util-err.h>
#include "media-thumbnail.h"
-#include "media-thumb-error.h"
#include "media-thumb-types.h"
#include "media-thumb-debug.h"
#include <gdk-pixbuf/gdk-pixbuf.h>
#include <sqlite3.h>
#include <media-util.h>
-#include "media-thumb-error.h"
#include "media-thumb-types.h"
#include "media-thumb-debug.h"
#include <unistd.h>
#include <asm/unistd.h>
+#include <errno.h>
#ifdef LOG_TAG
#undef LOG_TAG
*
*/
-#include "media-thumb-error.h"
#include "media-thumb-types.h"
#include "media-thumb-debug.h"
#include "media-util.h"
#include "media-thumb-ipc.h"
#include "media-thumb-util.h"
#include "media-thumb-db.h"
+#include "media-thumb-debug.h"
#include <glib.h>
#include <fcntl.h>
#include <string.h>
if ((sock_fd = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP)) < 0) {
thumb_err("socket failed: %s", strerror(errno));
- return MEDIA_THUMB_ERROR_NETWORK;
+ return MS_MEDIA_ERR_SOCKET_CONN;
}
if (sock_type == CLIENT_SOCKET) {
if (setsockopt(sock_fd, SOL_SOCKET, SO_RCVTIMEO, &tv_timeout, sizeof(tv_timeout)) == -1) {
thumb_err("setsockopt failed: %s", strerror(errno));
close(sock_fd);
- return MEDIA_THUMB_ERROR_NETWORK;
+ return MS_MEDIA_ERR_SOCKET_CONN;
}
} else if (sock_type == SERVER_SOCKET) {
if (setsockopt(sock_fd, SOL_SOCKET, SO_REUSEADDR, &n_reuse, sizeof(n_reuse)) == -1) {
thumb_err("setsockopt failed: %s", strerror(errno));
close(sock_fd);
- return MEDIA_THUMB_ERROR_NETWORK;
+ return MS_MEDIA_ERR_SOCKET_CONN;
}
}
*sock = sock_fd;
- return MEDIA_THUMB_ERROR_NONE;
+ return MS_MEDIA_ERR_NONE;
}
if ((sock_fd = socket(PF_INET, SOCK_DGRAM, IPPROTO_UDP)) < 0) {
thumb_err("socket failed: %s", strerror(errno));
- return MEDIA_THUMB_ERROR_NETWORK;
+ return MS_MEDIA_ERR_SOCKET_CONN;
}
#ifdef _USE_MEDIA_UTIL_
if (setsockopt(sock_fd, SOL_SOCKET, SO_RCVTIMEO, &tv_timeout, sizeof(tv_timeout)) == -1) {
thumb_err("setsockopt failed: %s", strerror(errno));
close(sock_fd);
- return MEDIA_THUMB_ERROR_NETWORK;
+ return MS_MEDIA_ERR_SOCKET_CONN;
}
*sock = sock_fd;
- return MEDIA_THUMB_ERROR_NONE;
+ return MS_MEDIA_ERR_NONE;
}
int _media_thumb_get_error()
{
if (errno == EWOULDBLOCK) {
thumb_err("Timeout. Can't try any more");
- return MEDIA_THUMB_ERROR_TIMEOUT;
+ return MS_MEDIA_ERR_SOCKET_RECEIVE_TIMEOUT;
} else {
thumb_err("recvfrom failed : %s", strerror(errno));
- return MEDIA_THUMB_ERROR_NETWORK;
+ return MS_MEDIA_ERR_SOCKET_RECEIVE;
}
}
}
}
- return MEDIA_THUMB_ERROR_NONE;
+ return MS_MEDIA_ERR_NONE;
}
int __media_thumb_check_req_queue(const char *path)
{
int req_len = 0, i;
- if (g_request_queue == NULL) return MEDIA_THUMB_ERROR_NONE;
+ if (g_request_queue == NULL) return MS_MEDIA_ERR_NONE;
req_len = g_queue_get_length(g_request_queue);
// thumb_dbg("Queue length : %d", req_len);
if (strncmp(path, req->path, strlen(path)) == 0) {
//thumb_dbg("Same Request - %s", path);
- return -1;
+ return MS_MEDIA_ERR_INVALID_PARAMETER;
break;
}
}
}
- return MEDIA_THUMB_ERROR_NONE;
+ return MS_MEDIA_ERR_NONE;
}
int
//thumb_dbg("destination path : %s", msg->dst_path);
SAFE_FREE(buf);
- return MEDIA_THUMB_ERROR_NONE;
+ return MS_MEDIA_ERR_NONE;
}
#ifdef _USE_UDS_SOCKET_
if (msg->origin_path_size <= 0 || msg->origin_path_size > MAX_PATH_SIZE) {
SAFE_FREE(buf);
thumb_err("msg->origin_path_size is invalid %d", msg->origin_path_size );
- return MEDIA_THUMB_ERROR_NETWORK;
+ return MS_MEDIA_ERR_INVALID_PARAMETER;
}
strncpy(msg->org_path, (char*)buf + header_size, msg->origin_path_size);
if (msg->dest_path_size <= 0 || msg->dest_path_size > MAX_PATH_SIZE) {
SAFE_FREE(buf);
thumb_err("msg->origin_path_size is invalid %d", msg->dest_path_size );
- return MEDIA_THUMB_ERROR_NETWORK;
+ return MS_MEDIA_ERR_INVALID_PARAMETER;
}
strncpy(msg->dst_path, (char*)buf + header_size + msg->origin_path_size, msg->dest_path_size);
SAFE_FREE(buf);
*from_size = from_addr_size;
- return MEDIA_THUMB_ERROR_NONE;
+ return MS_MEDIA_ERR_NONE;
}
int
_media_thumb_set_buffer(thumbMsg *req_msg, unsigned char **buf, int *buf_size)
{
if (req_msg == NULL || buf == NULL) {
- return -1;
+ return MS_MEDIA_ERR_INVALID_PARAMETER;
}
int org_path_len = 0;
*buf_size = size;
- return 0;
+ return MS_MEDIA_ERR_NONE;
}
int
#endif
int recv_str_len = 0;
- int err;
+ int err = MS_MEDIA_ERR_NONE;
int pid;
if (ms_ipc_create_client_socket(MS_PROTOCOL_TCP, MS_TIMEOUT_SEC_10, &sock) < 0) {
#endif
thumb_err("ms_ipc_create_client_socket failed");
- return MEDIA_THUMB_ERROR_NETWORK;
+ return MS_MEDIA_ERR_SOCKET_CONN;
}
#else
/* Creaete a TCP socket */
if (_media_thumb_create_socket(CLIENT_SOCKET, &sock) < 0) {
thumb_err("_media_thumb_create_socket failed");
- return MEDIA_THUMB_ERROR_NETWORK;
+ return MS_MEDIA_ERR_SOCKET_CONN;
}
#endif
/* Connecting to the thumbnail server */
if (connect(sock, (struct sockaddr*)&serv_addr, sizeof(serv_addr)) < 0) {
thumb_err("connect error : %s", strerror(errno));
- return MEDIA_THUMB_ERROR_NETWORK;
+ return MS_MEDIA_ERR_SOCKET_CONN;
}
thumbMsg req_msg;
if (req_msg.origin_path_size > MAX_PATH_SIZE || req_msg.dest_path_size > MAX_PATH_SIZE) {
thumb_err("path's length exceeds %d", MAX_PATH_SIZE);
close(sock);
- return MEDIA_THUMB_ERROR_INVALID_PARAMETER;
+ return MS_MEDIA_ERR_INVALID_PARAMETER;
}
unsigned char *buf = NULL;
thumb_err("sendto failed: %d\n", errno);
SAFE_FREE(buf);
close(sock);
- return MEDIA_THUMB_ERROR_NETWORK;
+ return MS_MEDIA_ERR_SOCKET_SEND;
}
thumb_dbg("Sending msg to thumbnail daemon is successful");
if (recv_str_len > max_length) {
thumb_err("user buffer is too small. Output's length is %d", recv_str_len);
- return MEDIA_THUMB_ERROR_INVALID_PARAMETER;
+ return MS_MEDIA_ERR_INVALID_PARAMETER;
}
if (recv_msg.status == THUMB_FAIL) {
thumb_err("Failed to make thumbnail");
- return -1;
+ return MS_MEDIA_ERR_INVALID_PARAMETER;
}
if (msg_type != THUMB_REQUEST_SAVE_FILE) {
thumb_info->origin_width = recv_msg.origin_width;
thumb_info->origin_height = recv_msg.origin_height;
- return 0;
+ return MS_MEDIA_ERR_NONE;
}
static int _mkdir(const char *dir, mode_t mode) {
if (req_msg == NULL || res_msg == NULL) {
thumb_err("Invalid msg!");
- return MEDIA_THUMB_ERROR_INVALID_PARAMETER;
+ return MS_MEDIA_ERR_INVALID_PARAMETER;
}
int msg_type = req_msg->msg_type;
max_length = sizeof(res_msg->dst_path);
err = _media_thumb_db_connect(uid);
- if (err < 0) {
+ if (err != MS_MEDIA_ERR_NONE) {
thumb_err("_media_thumb_mb_svc_connect failed: %d", err);
- return MEDIA_THUMB_ERROR_DB;
+ return MS_MEDIA_ERR_DB_CONNECT_FAIL;
}
if (msg_type == THUMB_REQUEST_DB_INSERT) {
err = _media_thumb_get_thumb_from_db_with_size(origin_path, thumb_path, max_length, &need_update_db, &origin_w, &origin_h);
- if (err == 0) {
+ if (err == MS_MEDIA_ERR_NONE) {
res_msg->origin_width = origin_w;
res_msg->origin_height = origin_h;
_media_thumb_db_disconnect();
- return MEDIA_THUMB_ERROR_NONE;
+ return MS_MEDIA_ERR_NONE;
} else {
if (strlen(thumb_path) == 0) {
err = _media_thumb_get_hash_name(origin_path, thumb_path, max_length,uid);
- if (err < 0) {
+ if (err != MS_MEDIA_ERR_NONE) {
thumb_err("_media_thumb_get_hash_name failed - %d\n", err);
strncpy(thumb_path, _media_thumb_get_default_path(uid), max_length);
_media_thumb_db_disconnect();
}
err = _thumbnail_get_data(origin_path, thumb_type, thumb_format, &gdkdata, &thumb_size, &thumb_w, &thumb_h, &origin_w, &origin_h, &alpha, uid);
- if (err < 0) {
+ if (err != MS_MEDIA_ERR_NONE) {
thumb_err("_thumbnail_get_data failed - %d\n", err);
if ( gdkdata != NULL ){
g_object_unref(gdkdata);
/* DB update if needed */
if (need_update_db == 1) {
err = _media_thumb_update_db(origin_path, thumb_path, res_msg->origin_width, res_msg->origin_height, uid);
- if (err < 0) {
+ if (err != MS_MEDIA_ERR_NONE) {
thumb_err("_media_thumb_update_db failed : %d", err);
}
}
_media_thumb_db_disconnect();
- return 0;
+ return MS_MEDIA_ERR_NONE;
}
gboolean _media_thumb_write_socket(GIOChannel *src, GIOCondition condition, gpointer data)
int header_size = 0;
int recv_str_len = 0;
int sock = 0;
- int err = MEDIA_THUMB_ERROR_NONE;
+ int err = MS_MEDIA_ERR_NONE;
memset((void *)&recv_msg, 0, sizeof(thumbMsg));
sock = g_io_channel_unix_get_fd(src);
if (recv_msg.status == THUMB_FAIL) {
thumb_err("Failed to make thumbnail");
- err = MEDIA_THUMB_ERROR_UNSUPPORTED;
+ err = MS_MEDIA_ERR_INTERNAL;
goto callback;
}
int pid;
if ((msg_type == THUMB_REQUEST_DB_INSERT) && (__media_thumb_check_req_queue(origin_path) < 0)) {
- return MEDIA_THUMB_ERROR_DUPLICATED_REQUEST;
+ return MS_MEDIA_ERR_THUMB_DUPLICATED_REQUEST;
}
#ifdef _USE_MEDIA_UTIL_
if (ms_ipc_create_client_socket(MS_PROTOCOL_TCP, MS_TIMEOUT_SEC_10, &sock) < 0) {
#endif
thumb_err("ms_ipc_create_client_socket failed");
- return MEDIA_THUMB_ERROR_NETWORK;
+ return MS_MEDIA_ERR_SOCKET_CONN;
}
#else
/* Creaete a TCP socket */
if (_media_thumb_create_socket(CLIENT_SOCKET, &sock) < 0) {
thumb_err("_media_thumb_create_socket failed");
- return MEDIA_THUMB_ERROR_NETWORK;
+ return MS_MEDIA_ERR_SOCKET_CONN;
}
#endif
if (connect(sock, (struct sockaddr*)&serv_addr, sizeof(serv_addr)) < 0) {
thumb_err("connect error : %s", strerror(errno));
g_io_channel_shutdown(channel, TRUE, NULL);
- return MEDIA_THUMB_ERROR_NETWORK;
+ return MS_MEDIA_ERR_SOCKET_CONN;
}
if (msg_type != THUMB_REQUEST_CANCEL_MEDIA) {
if (req_msg.origin_path_size > MAX_PATH_SIZE || req_msg.dest_path_size > MAX_PATH_SIZE) {
thumb_err("path's length exceeds %d", MAX_PATH_SIZE);
g_io_channel_shutdown(channel, TRUE, NULL);
- return MEDIA_THUMB_ERROR_INVALID_PARAMETER;
+ return MS_MEDIA_ERR_INVALID_PARAMETER;
}
unsigned char *buf = NULL;
SAFE_FREE(buf);
g_source_destroy(g_main_context_find_source_by_id(g_main_context_get_thread_default(), source_id));
g_io_channel_shutdown(channel, TRUE, NULL);
- return MEDIA_THUMB_ERROR_NETWORK;
+ return MS_MEDIA_ERR_SOCKET_SEND;
}
SAFE_FREE(buf);
thumb_req = calloc(1, sizeof(thumbReq));
if (thumb_req == NULL) {
thumb_err("Failed to create request element");
- return 0;
+ return MS_MEDIA_ERR_NONE;
}
thumb_req->channel = channel;
}
#endif
- return 0;
+ return MS_MEDIA_ERR_NONE;
}
-
thumb_dbg("proper thumb w: %d h: %d", *thumb_w, *thumb_h);
- return 0;
+ return MS_MEDIA_ERR_NONE;
}
int _media_thumb_get_exif_info(ExifData *ed, char *buf, int max_size, int *value,
ExifTag tag;
if (ed == NULL) {
- return -1;
+ return MS_MEDIA_ERR_INVALID_PARAMETER;
}
ifd = ifdtype;
if (value == NULL) {
thumb_dbg("value is NULL");
- return -1;
+ return MS_MEDIA_ERR_INVALID_PARAMETER;
}
ExifByteOrder mByteOrder = exif_data_get_byte_order(ed);
/* Get the contents of the tag in human-readable form */
if (buf == NULL) {
thumb_dbg("buf is NULL");
- return -1;
+ return MS_MEDIA_ERR_INVALID_PARAMETER;
}
exif_entry_get_value(entry, buf, max_size);
buf[strlen(buf)] = '\0';
}
}
- return 0;
+ return MS_MEDIA_ERR_NONE;
}
-int
-_media_thumb_get_thumb_from_exif(ExifData *ed,
+int _media_thumb_get_thumb_from_exif(ExifData *ed,
const char *file_full_path,
int orientation,
int required_width,
thumb_dbg("There's jpeg thumb in this image");
} else {
thumb_dbg("There's NO jpeg thumb in this image");
- return -1;
+ return MS_MEDIA_ERR_INVALID_PARAMETER;
}
} else {
thumb_dbg("entry is NULL");
- return -1;
+ return MS_MEDIA_ERR_INVALID_PARAMETER;
}
/* Get width and height of thumbnail */
tag = EXIF_TAG_IMAGE_WIDTH;
-
entry = exif_content_get_entry(ed->ifd[ifd], tag);
if (entry) {
}
tag = EXIF_TAG_IMAGE_LENGTH;
-
entry = exif_content_get_entry(ed->ifd[ifd], tag);
-
if (entry) {
/* Get the contents of the tag in human-readable form */
ExifShort value = exif_get_short(entry->data, byte_order);
int thumb_width = dst_width;
int thumb_height = dst_height;
unsigned int buf_size = 0;
-
- if (mm_util_get_image_size(src_format, thumb_width,
- thumb_height, &buf_size) < 0) {
+
+ if (mm_util_get_image_size(src_format, thumb_width, thumb_height, &buf_size) < 0) {
thumb_err("Failed to get buffer size");
- return MEDIA_THUMB_ERROR_MM_UTIL;
+ return MS_MEDIA_ERR_INTERNAL;
}
thumb_dbg("mm_util_get_image_size : %d", buf_size);
SAFE_FREE(dst);
- return MEDIA_THUMB_ERROR_MM_UTIL;
+ return MS_MEDIA_ERR_INTERNAL;
}
thumb_info->size = buf_size;
SAFE_FREE(dst);
- return 0;
+ return MS_MEDIA_ERR_NONE;
}
int _media_thumb_get_wh_with_gdk(const char *origin_path, int *width, int *height)
if (error) {
thumb_err ("Error loading image file %s",origin_path);
g_error_free (error);
- return -1;
+ return MS_MEDIA_ERR_INTERNAL;
}
/* Get w/h of original image */
*width = gdk_pixbuf_get_width(pixbuf);
*height = gdk_pixbuf_get_height(pixbuf);
- return 0;
+ return MS_MEDIA_ERR_NONE;
}
int _media_thumb_decode_with_gdk(const char *origin_path,
if (error) {
thumb_err ("Error loading image file %s",origin_path);
g_error_free (error);
- return -1;
+ return MS_MEDIA_ERR_INTERNAL;
}
/* Get w/h of original image */
rotated_orig_h = height;
}
- int err = -1;
+ int err = MS_MEDIA_ERR_NONE;
media_thumb_type thumb_type;
if (thumb_width == _media_thumb_get_width(MEDIA_THUMB_LARGE)) {
err = _media_thumb_get_proper_thumb_size(thumb_type,
rotated_orig_w, rotated_orig_h,
&thumb_width, &thumb_height);
- if (err < 0) {
+ if (err != MS_MEDIA_ERR_NONE) {
thumb_err("_media_thumb_get_proper_thumb_size failed: %d", err);
g_object_unref(pixbuf);
return err;
g_object_unref(pixbuf);
- return MEDIA_THUMB_ERROR_MM_UTIL;
+ return MS_MEDIA_ERR_INTERNAL;
}
thumb_info->size = buf_size;
thumb_info->gdkdata = gdk_pixbuf_copy(pixbuf);
g_object_unref(pixbuf);
- return 0;
+ return MS_MEDIA_ERR_NONE;
}
mm_util_img_format _media_thumb_get_format(media_thumb_format src_format)
{
switch(src_format) {
- case MEDIA_THUMB_BGRA:
+ case MEDIA_THUMB_BGRA:
return MM_UTIL_IMG_FMT_BGRA8888;
- case MEDIA_THUMB_RGB888:
+ case MEDIA_THUMB_RGB888:
return MM_UTIL_IMG_FMT_RGB888;
default:
- return -1;
+ return MS_MEDIA_ERR_INVALID_PARAMETER;
}
}
int _media_thumb_convert_data(media_thumb_info *thumb_info,
- int thumb_width,
+ int thumb_width,
int thumb_height,
mm_util_img_format src_format,
mm_util_img_format dst_format)
{
- int err = -1;
+ int err = MS_MEDIA_ERR_NONE;
unsigned int buf_size = 0;
unsigned char *src_data = thumb_info->data;
unsigned char *dst_data = NULL;
thumb_dbg("src format:%d, dst format:%d", src_format, dst_format);
- if (mm_util_get_image_size(dst_format, thumb_width,
- thumb_height, &buf_size) < 0) {
+ if (mm_util_get_image_size(dst_format, thumb_width, thumb_height, &buf_size) < 0) {
thumb_err("Failed to get buffer size");
- return MEDIA_THUMB_ERROR_MM_UTIL;
+ return MS_MEDIA_ERR_INTERNAL;
}
thumb_dbg("mm_util_get_image_size : %d", buf_size);
src_format,
dst_data,
dst_format);
-
+
if (err < 0) {
thumb_err("Failed to change from rgb888 to argb8888 %d", err);
SAFE_FREE(dst_data);
- return MEDIA_THUMB_ERROR_MM_UTIL;
+ return MS_MEDIA_ERR_INTERNAL;
}
}
thumb_dbg("_media_thumb_convert_data success");
- return 0;
+ return err;
}
int _media_thumb_convert_format(media_thumb_info *thumb_info,
media_thumb_format src_format,
media_thumb_format dst_format)
{
- int err = -1;
+ int err = MS_MEDIA_ERR_NONE;
if (src_format == dst_format) {
//thumb_dbg("src_format == dst_format");
- return 0;
+ return err;
}
mm_util_img_format src_mm_format;
if (src_mm_format == -1 || dst_mm_format == -1) {
thumb_err("Format is invalid");
- return MEDIA_THUMB_ERROR_UNSUPPORTED;
+ return MS_MEDIA_ERR_INVALID_PARAMETER;
}
- err = _media_thumb_convert_data(thumb_info,
- thumb_info->width,
+ err = _media_thumb_convert_data(thumb_info,
+ thumb_info->width,
thumb_info->height,
- src_mm_format,
+ src_mm_format,
dst_mm_format);
- if (err < 0) {
+ if (err != MS_MEDIA_ERR_NONE) {
thumb_err("media_thumb_convert_format failed : %d", err);
return err;
}
- return 0;
+ return err;
}
int _media_thumb_agif(const char *origin_path,
media_thumb_format format,
media_thumb_info *thumb_info)
{
- int err = -1;
+ int err = MS_MEDIA_ERR_NONE;
unsigned int *thumb = NULL;
media_thumb_type thumb_type;
if (!thumb) {
thumb_err("Frame data is NULL!!");
- return MEDIA_THUMB_ERROR_UNSUPPORTED;
+ return MS_MEDIA_ERR_INTERNAL;
}
if (thumb_width == _media_thumb_get_width(MEDIA_THUMB_LARGE)) {
err = _media_thumb_get_proper_thumb_size(thumb_type,
thumb_info->origin_width, thumb_info->origin_height,
&thumb_width, &thumb_height);
- if (err < 0) {
+ if (err != MS_MEDIA_ERR_NONE) {
thumb_err("_media_thumb_get_proper_thumb_size failed: %d", err);
SAFE_FREE(thumb);
return err;
}
- err = _media_thumb_resize_data((unsigned char *)thumb,
+ err = _media_thumb_resize_data((unsigned char *)thumb,
image_info->width,
image_info->height,
MM_UTIL_IMG_FMT_RGB888,
thumb_width,
thumb_height);
- if (err < 0) {
+ if (err != MS_MEDIA_ERR_NONE) {
thumb_err("_media_thumb_resize_data failed: %d", err);
SAFE_FREE(thumb);
return err;
SAFE_FREE(thumb);
err = _media_thumb_convert_format(thumb_info, MEDIA_THUMB_RGB888, format);
- if (err < 0) {
+ if (err != MS_MEDIA_ERR_NONE) {
thumb_err("_media_thumb_convert_format falied: %d", err);
SAFE_FREE(thumb_info->data);
return err;
}
- return 0;
+ return err;
}
int _media_thumb_png(const char *origin_path,
media_thumb_format format,
media_thumb_info *thumb_info)
{
- int err = -1;
+ int err = MS_MEDIA_ERR_NONE;
err = _media_thumb_decode_with_gdk(origin_path, thumb_width, thumb_height, thumb_info, 0, NORMAL);
-
- if (err < 0) {
+
+ if (err != MS_MEDIA_ERR_NONE) {
thumb_err("decode_with_gdk failed : %d", err);
return err;
}
err = _media_thumb_convert_format(thumb_info, MEDIA_THUMB_RGB888, format);
- if (err < 0) {
+ if (err != MS_MEDIA_ERR_NONE) {
thumb_err("_media_thumb_convert_format falied: %d", err);
SAFE_FREE(thumb_info->data);
return err;
}
- return 0;
+ return err;
}
int _media_thumb_bmp(const char *origin_path,
media_thumb_format format,
media_thumb_info *thumb_info)
{
- int err = -1;
+ int err = MS_MEDIA_ERR_NONE;
err = _media_thumb_decode_with_gdk(origin_path, thumb_width, thumb_height, thumb_info, 0, NORMAL);
- if (err < 0) {
+ if (err != MS_MEDIA_ERR_NONE) {
thumb_err("decode_with_gdk failed : %d", err);
return err;
}
err = _media_thumb_convert_format(thumb_info, MEDIA_THUMB_RGB888, format);
- if (err < 0) {
+ if (err != MS_MEDIA_ERR_NONE) {
thumb_err("_media_thumb_convert_format falied: %d", err);
SAFE_FREE(thumb_info->data);
return err;
}
- return 0;
+ return err;
}
int _media_thumb_wbmp(const char *origin_path,
media_thumb_format format,
media_thumb_info *thumb_info)
{
- int err = -1;
+ int err = MS_MEDIA_ERR_NONE;
err = _media_thumb_decode_with_gdk(origin_path, thumb_width, thumb_height, thumb_info, 0, NORMAL);
- if (err < 0) {
+ if (err != MS_MEDIA_ERR_NONE) {
thumb_err("decode_with_gdk failed : %d", err);
return err;
}
err = _media_thumb_convert_format(thumb_info, MEDIA_THUMB_RGB888, format);
- if (err < 0) {
+ if (err != MS_MEDIA_ERR_NONE) {
thumb_err("_media_thumb_convert_format falied: %d", err);
SAFE_FREE(thumb_info->data);
return err;
}
- return 0;
+ return err;
}
-int _media_thumb_gif(const char *origin_path,
+int _media_thumb_gif(const char *origin_path,
int thumb_width,
int thumb_height,
media_thumb_format format,
media_thumb_info *thumb_info)
{
- int err = -1;
+ int err = MS_MEDIA_ERR_NONE;
err = _media_thumb_decode_with_gdk(origin_path, thumb_width, thumb_height, thumb_info, 0, NORMAL);
- if (err < 0) {
+ if (err != MS_MEDIA_ERR_NONE) {
thumb_err("decode_with_gdk failed : %d", err);
return err;
}
err = _media_thumb_convert_format(thumb_info, MEDIA_THUMB_RGB888, format);
- if (err < 0) {
+ if (err != MS_MEDIA_ERR_NONE) {
thumb_err("_media_thumb_convert_format falied: %d", err);
SAFE_FREE(thumb_info->data);
return err;
}
- return 0;
+ return err;
}
int _media_thumb_jpeg(const char *origin_path,
media_thumb_info *thumb_info,
uid_t uid)
{
- int err = -1;
+ int err = MS_MEDIA_ERR_NONE;
ExifData *ed = NULL;
int thumb_done = 0;
int orientation = NORMAL;
/* First, Get orientation from exif */
err = _media_thumb_get_exif_info(ed, NULL, 0, &orientation, EXIF_IFD_0, EXIF_TAG_ORIENTATION);
- if (err < 0) {
+ if (err != MS_MEDIA_ERR_NONE) {
thumb_warn("_media_thumb_get_exif_info failed");
}
/* Second, Get thumb from exif */
err = _media_thumb_get_thumb_from_exif(ed, origin_path, orientation, thumb_width, thumb_height, thumb_info, uid);
- if (err < 0) {
+ if (err != MS_MEDIA_ERR_NONE) {
thumb_dbg("_media_thumb_get_thumb_from_exif failed");
} else {
thumb_done = 1;
MM_UTIL_IMG_FMT_RGB888,
dst_format);
- if (err < 0) {
+ if (err != MS_MEDIA_ERR_NONE) {
thumb_err("_media_thumb_convert_data failed : %d", err);
exif_data_unref(ed);
return err;
err = _media_thumb_decode_with_gdk(origin_path, thumb_width, thumb_height, thumb_info, 0, orientation);
- if (err < 0) {
+ if (err != MS_MEDIA_ERR_NONE) {
thumb_err("decode_with_gdk failed : %d", err);
return err;
}
err = _media_thumb_convert_format(thumb_info, MEDIA_THUMB_RGB888, format);
- if (err < 0) {
+ if (err != MS_MEDIA_ERR_NONE) {
thumb_err("_media_thumb_convert_format falied: %d", err);
SAFE_FREE(thumb_info->data);
return err;
}
}
- return 0;
+ return err;
}
int
media_thumb_format format,
media_thumb_info *thumb_info, uid_t uid)
{
- int err = -1;
+ int err = MS_MEDIA_ERR_NONE;
int image_type = 0;
int origin_w = 0;
int origin_h = 0;
if ((image_type != IMG_CODEC_JPEG) &&
(origin_w * origin_h > THUMB_MAX_ALLOWED_MEM_FOR_THUMB)) {
thumb_warn("This original image is too big");
- return MEDIA_THUMB_ERROR_UNSUPPORTED;
+ return MS_MEDIA_ERR_THUMB_TOO_BIG;
}
if (image_type == IMG_CODEC_AGIF) {
} else {
char file_ext[10];
err = _media_thumb_get_file_ext(origin_path, file_ext, sizeof(file_ext));
- if (err < 0) {
+ if (err != MS_MEDIA_ERR_NONE) {
thumb_warn("_media_thumb_get_file_ext failed");
} else {
if (strcasecmp(file_ext, "wbmp") == 0) {
int wbmp_height = 0;
err = _media_thumb_get_wh_with_gdk(origin_path, &wbmp_width, &wbmp_height);
- if (err < 0) {
+ if (err != MS_MEDIA_ERR_NONE) {
thumb_err("_media_thumb_get_wh_with_gdk in WBMP : %d", err);
return err;
}
if (wbmp_width * wbmp_height > THUMB_MAX_ALLOWED_MEM_FOR_THUMB) {
thumb_warn("This original image is too big");
- return MEDIA_THUMB_ERROR_UNSUPPORTED;
+ return MS_MEDIA_ERR_THUMB_TOO_BIG;
}
thumb_info->origin_width = wbmp_width;
}
thumb_warn("Unsupported image type");
- return MEDIA_THUMB_ERROR_UNSUPPORTED;
+ return MS_MEDIA_ERR_INVALID_PARAMETER;
}
return err;
}
-int
-_media_thumb_video(const char *origin_path,
+int _media_thumb_video(const char *origin_path,
int thumb_width,
int thumb_height,
media_thumb_format format,
media_thumb_info *thumb_info,
uid_t uid)
{
- int err = -1;
-
+ int err = MS_MEDIA_ERR_NONE;
+
MMHandleType content = (MMHandleType) NULL;
void *frame = NULL;
int video_track_num = 0;
drm_bool_type_e drm_type;
ret = (drm_is_drm_file(origin_path, &drm_type) == 1);
- if (ret < 0) {
+ if (ret != MS_MEDIA_ERR_NONE) {
thumb_err("drm_is_drm_file falied : %d", ret);
drm_type = DRM_FALSE;
}
is_drm = drm_type;
err = mm_file_create_content_attrs(&content, origin_path);
- if (err < 0) {
+ if (err != MM_ERROR_NONE) {
thumb_err("mm_file_create_content_attrs fails : %d", err);
- return MEDIA_THUMB_ERROR_MM_UTIL;
+ return MS_MEDIA_ERR_INTERNAL;
}
- err =
- mm_file_get_attrs(content, &err_msg,
- MM_FILE_CONTENT_VIDEO_TRACK_COUNT,
- &video_track_num, NULL);
-
- if (err != 0) {
+ err = mm_file_get_attrs(content, &err_msg, MM_FILE_CONTENT_VIDEO_TRACK_COUNT, &video_track_num, NULL);
+ if (err != MM_ERROR_NONE) {
thumb_err("mm_file_get_attrs fails : %s", err_msg);
SAFE_FREE(err_msg);
mm_file_destroy_content_attrs(content);
- return MEDIA_THUMB_ERROR_MM_UTIL;
+ return MS_MEDIA_ERR_INTERNAL;
}
/* MMF api handle both normal and DRM video */
MM_FILE_CONTENT_VIDEO_THUMBNAIL, &frame, /* raw image is RGB888 format */
&size, NULL);
- if (err != 0) {
+ if (err != MM_ERROR_NONE) {
thumb_err("mm_file_get_attrs fails : %s", err_msg);
SAFE_FREE(err_msg);
mm_file_destroy_content_attrs(content);
- return MEDIA_THUMB_ERROR_MM_UTIL;
+ return MS_MEDIA_ERR_INTERNAL;
}
thumb_dbg("video width: %d", width);
if (frame == NULL || width == 0 || height == 0) {
thumb_err("Failed to get frame data");
mm_file_destroy_content_attrs(content);
- return MEDIA_THUMB_ERROR_MM_UTIL;
+ return MS_MEDIA_ERR_INTERNAL;
}
media_thumb_type thumb_type;
thumb_width,
thumb_height);
- if (err < 0) {
+ if (err != MS_MEDIA_ERR_NONE) {
thumb_err("_media_thumb_resize_data failed - %d", err);
SAFE_FREE(thumb_info->data);
mm_file_destroy_content_attrs(content);
}
err = mm_util_get_image_size(MM_UTIL_IMG_FMT_RGB888, r_w, r_h, &r_size);
- if (err < 0) {
- thumb_dbg("mm_util_get_image_size failed : %d", err);
+ if (err != MM_ERROR_NONE) {
+ thumb_err("mm_util_get_image_size failed : %d", err);
SAFE_FREE(thumb_info->data);
return err;
}
rotated = (unsigned char *)malloc(r_size);
err = mm_util_rotate_image(thumb_info->data, thumb_info->width, thumb_info->height,
MM_UTIL_IMG_FMT_RGB888,
- rotated, &r_w, &r_h,
+ rotated, &r_w, &r_h,
rot_type);
- if (err < 0) {
+ if (err != MM_ERROR_NONE) {
thumb_err("mm_util_rotate_image failed : %d", err);
SAFE_FREE(thumb_info->data);
SAFE_FREE(rotated);
}
SAFE_FREE(thumb_info->data);
-
thumb_info->data = rotated;
thumb_info->size = r_size;
thumb_info->width = r_w;
}
err = _media_thumb_convert_format(thumb_info, MEDIA_THUMB_RGB888, format);
- if (err < 0) {
+ if (err != MS_MEDIA_ERR_NONE) {
thumb_err("_media_thumb_convert_format falied: %d", err);
SAFE_FREE(thumb_info->data);
return err;
frame = NULL;
mm_file_destroy_content_attrs(content);
- return MEDIA_THUMB_ERROR_UNSUPPORTED;
+ return MS_MEDIA_ERR_INTERNAL;
}
- return 0;
+ return err;
}
int thumbnail_request_from_db(const char *origin_path, char *thumb_path, int max_length, uid_t uid)
{
- int err = -1;
+ int err = MS_MEDIA_ERR_NONE;
//int need_update_db = 0;
media_thumb_info thumb_info;
if (origin_path == NULL || thumb_path == NULL) {
thumb_err("Invalid parameter");
- return MEDIA_THUMB_ERROR_INVALID_PARAMETER;
+ return MS_MEDIA_ERR_INVALID_PARAMETER;
}
if (!g_file_test
(origin_path, G_FILE_TEST_EXISTS | G_FILE_TEST_IS_REGULAR)) {
thumb_err("Original path(%s) doesn't exist.", origin_path);
- return MEDIA_THUMB_ERROR_INVALID_PARAMETER;
+ return MS_MEDIA_ERR_INVALID_PARAMETER;
}
if (max_length <= 0) {
thumb_err("Length is invalid");
- return MEDIA_THUMB_ERROR_INVALID_PARAMETER;
+ return MS_MEDIA_ERR_INVALID_PARAMETER;
}
int store_type = -1;
if ((store_type != THUMB_PHONE) && (store_type != THUMB_MMC)) {
thumb_err("origin path(%s) is invalid", origin_path);
- return MEDIA_THUMB_ERROR_INVALID_PARAMETER;
+ return MS_MEDIA_ERR_INVALID_PARAMETER;
}
thumb_err("Path : %s", origin_path);
-/*
- err = _media_thumb_db_connect();
- if (err < 0) {
- thumb_err("_media_thumb_mb_svc_connect failed: %d", err);
- return MEDIA_THUMB_ERROR_DB;
- }
- err = _media_thumb_get_thumb_from_db(origin_path, thumb_path, max_length, &need_update_db);
- if (err == 0) {
- _media_thumb_db_disconnect();
- return MEDIA_THUMB_ERROR_NONE;
- }
-*/
/* Request for thumb file to the daemon "Thumbnail generator" */
err = _media_thumb_request(THUMB_REQUEST_DB_INSERT, MEDIA_THUMB_LARGE, origin_path, thumb_path, max_length, &thumb_info, uid);
- if (err < 0) {
+ if (err != MS_MEDIA_ERR_NONE) {
thumb_err("_media_thumb_request failed : %d", err);
- //_media_thumb_db_disconnect();
return err;
}
-/*
- // Need to update DB once generating thumb is done
- if (need_update_db) {
- err = _media_thumb_update_db(origin_path, thumb_path, thumb_info.origin_width, thumb_info.origin_height);
- if (err < 0) {
- thumb_err("_media_thumb_update_db failed : %d", err);
- }
- }
- _media_thumb_db_disconnect();
-*/
- return MEDIA_THUMB_ERROR_NONE;
+ return MS_MEDIA_ERR_NONE;
}
int thumbnail_request_save_to_file(const char *origin_path, media_thumb_type thumb_type, const char *thumb_path, uid_t uid)
{
- int err = -1;
+ int err = MS_MEDIA_ERR_NONE;
if (origin_path == NULL || thumb_path == NULL) {
thumb_err("Invalid parameter");
- return MEDIA_THUMB_ERROR_INVALID_PARAMETER;
+ return MS_MEDIA_ERR_INVALID_PARAMETER;
}
media_thumb_info thumb_info;
/* Request for thumb file to the daemon "Thumbnail generator" */
err = _media_thumb_request(THUMB_REQUEST_SAVE_FILE, thumb_type, origin_path, tmp_thumb_path, sizeof(tmp_thumb_path), &thumb_info, uid);
- if (err < 0) {
+ if (err != MS_MEDIA_ERR_NONE) {
thumb_err("_media_thumb_request failed : %d", err);
return err;
}
- return MEDIA_THUMB_ERROR_NONE;
+ return MS_MEDIA_ERR_NONE;
}
int thumbnail_request_from_db_with_size(const char *origin_path, char *thumb_path, int max_length, int *origin_width, int *origin_height, uid_t uid)
{
- int err = -1;
+ int err = MS_MEDIA_ERR_NONE;
//int need_update_db = 0;
media_thumb_info thumb_info;
if (origin_path == NULL || thumb_path == NULL) {
thumb_err("Invalid parameter");
- return MEDIA_THUMB_ERROR_INVALID_PARAMETER;
+ return MS_MEDIA_ERR_INVALID_PARAMETER;
}
if (origin_width == NULL || origin_height == NULL) {
thumb_err("Invalid parameter ( width or height )");
- return MEDIA_THUMB_ERROR_INVALID_PARAMETER;
+ return MS_MEDIA_ERR_INVALID_PARAMETER;
}
if (!g_file_test
(origin_path, G_FILE_TEST_EXISTS | G_FILE_TEST_IS_REGULAR)) {
thumb_err("Original path(%s) doesn't exist.", origin_path);
- return MEDIA_THUMB_ERROR_INVALID_PARAMETER;
+ return MS_MEDIA_ERR_INVALID_PARAMETER;
}
if (max_length <= 0) {
thumb_err("Length is invalid");
- return MEDIA_THUMB_ERROR_INVALID_PARAMETER;
+ return MS_MEDIA_ERR_INVALID_PARAMETER;
}
int store_type = -1;
if ((store_type != THUMB_PHONE) && (store_type != THUMB_MMC)) {
thumb_err("origin path(%s) is invalid", origin_path);
- return MEDIA_THUMB_ERROR_INVALID_PARAMETER;
+ return MS_MEDIA_ERR_INVALID_PARAMETER;
}
thumb_err("Path : %s", origin_path);
-/*
- err = _media_thumb_db_connect();
- if (err < 0) {
- thumb_err("_media_thumb_mb_svc_connect failed: %d", err);
- return MEDIA_THUMB_ERROR_DB;
- }
- err = _media_thumb_get_thumb_from_db_with_size(origin_path, thumb_path, max_length, &need_update_db, &width, &height);
- if (err == 0) {
- _media_thumb_db_disconnect();
- return MEDIA_THUMB_ERROR_NONE;
- }
-*/
/* Request for thumb file to the daemon "Thumbnail generator" */
err = _media_thumb_request(THUMB_REQUEST_DB_INSERT, MEDIA_THUMB_LARGE, origin_path, thumb_path, max_length, &thumb_info, uid);
- if (err < 0) {
+ if (err != MS_MEDIA_ERR_NONE) {
thumb_err("_media_thumb_request failed : %d", err);
//_media_thumb_db_disconnect();
return err;
*origin_width = thumb_info.origin_width;
*origin_height = thumb_info.origin_height;
- //_media_thumb_db_disconnect();
- return MEDIA_THUMB_ERROR_NONE;
+ return MS_MEDIA_ERR_NONE;
}
int thumbnail_request_extract_all_thumbs(uid_t uid)
{
- int err = -1;
+ int err = MS_MEDIA_ERR_NONE;
media_thumb_info thumb_info;
media_thumb_type thumb_type = MEDIA_THUMB_LARGE;
/* Request for thumb file to the daemon "Thumbnail generator" */
err = _media_thumb_request(THUMB_REQUEST_ALL_MEDIA, thumb_type, tmp_origin_path, tmp_thumb_path, sizeof(tmp_thumb_path), &thumb_info, uid);
- if (err < 0) {
+ if (err != MS_MEDIA_ERR_NONE) {
thumb_err("_media_thumb_request failed : %d", err);
return err;
}
- return MEDIA_THUMB_ERROR_NONE;
+ return MS_MEDIA_ERR_NONE;
}
int thumbnail_request_from_db_async(const char *origin_path, ThumbFunc func, void *user_data, uid_t uid)
{
- int err = -1;
+ int err = MS_MEDIA_ERR_NONE;
if (origin_path == NULL) {
thumb_err("Invalid parameter");
- return MEDIA_THUMB_ERROR_INVALID_PARAMETER;
+ return MS_MEDIA_ERR_INVALID_PARAMETER;
}
if (!g_file_test
(origin_path, G_FILE_TEST_EXISTS | G_FILE_TEST_IS_REGULAR)) {
thumb_err("Original path(%s) doesn't exist.", origin_path);
- return MEDIA_THUMB_ERROR_INVALID_PARAMETER;
+ return MS_MEDIA_ERR_INVALID_PARAMETER;
}
int store_type = -1;
if ((store_type != THUMB_PHONE) && (store_type != THUMB_MMC)) {
thumb_err("origin path(%s) is invalid", origin_path);
- return MEDIA_THUMB_ERROR_INVALID_PARAMETER;
+ return MS_MEDIA_ERR_INVALID_PARAMETER;
}
thumb_err("Path : %s", origin_path);
/* Request for thumb file to the daemon "Thumbnail generator" */
err = _media_thumb_request_async(THUMB_REQUEST_DB_INSERT, MEDIA_THUMB_LARGE, origin_path, userData, uid);
- if (err < 0) {
+ if (err != MS_MEDIA_ERR_NONE) {
thumb_err("_media_thumb_request failed : %d", err);
SAFE_FREE(userData);
return err;
}
- return MEDIA_THUMB_ERROR_NONE;
+ return MS_MEDIA_ERR_NONE;
}
int _media_thumbnail_cancel_cb(int error_code, char* path, void* data)
thumb_dbg("Error code : %d", error_code);
if (path) thumb_dbg("Cancel : %s", path);
- return MEDIA_THUMB_ERROR_NONE;
+ return MS_MEDIA_ERR_NONE;
}
int thumbnail_request_cancel_media(const char *origin_path, uid_t uid)
{
- int err = -1;
+ int err = MS_MEDIA_ERR_NONE;
media_thumb_type thumb_type = MEDIA_THUMB_LARGE;
if (origin_path == NULL) {
thumb_err("Invalid parameter");
- return MEDIA_THUMB_ERROR_INVALID_PARAMETER;
+ return MS_MEDIA_ERR_INVALID_PARAMETER;
}
err = _media_thumb_request_async(THUMB_REQUEST_CANCEL_MEDIA, thumb_type, origin_path, NULL, uid);
- if (err < 0) {
+ if (err != MS_MEDIA_ERR_NONE) {
thumb_err("_media_thumb_request failed : %d", err);
return err;
}
- return MEDIA_THUMB_ERROR_NONE;
+ return MS_MEDIA_ERR_NONE;
}
int thumbnail_request_cancel_all(uid_t uid)
{
- int err = -1;
+ int err = MS_MEDIA_ERR_NONE;
media_thumb_info thumb_info;
media_thumb_type thumb_type = MEDIA_THUMB_LARGE;
/* Request for thumb file to the daemon "Thumbnail generator" */
err = _media_thumb_request(THUMB_REQUEST_CANCEL_ALL, thumb_type, tmp_origin_path, tmp_thumb_path, sizeof(tmp_thumb_path), &thumb_info, uid);
- if (err < 0) {
+ if (err != MS_MEDIA_ERR_NONE) {
thumb_err("_media_thumb_request failed : %d", err);
return err;
}
- return MEDIA_THUMB_ERROR_NONE;
+ return err;
}
#include "media-thumb-db.h"
#include "media-thumb-util.h"
+#include "media-thumb-debug.h"
#include <glib.h>
#include <string.h>
int
_media_thumb_sqlite_connect(sqlite3 **handle)
{
- int err = -1;
+ int err = MS_MEDIA_ERR_NONE;
err = db_util_open(MEDIA_DATABASE_NAME, handle,
DB_UTIL_REGISTER_HOOK_METHOD);
if (SQLITE_OK != err) {
*handle = NULL;
- return -1;
+ return MS_MEDIA_ERR_INVALID_PARAMETER;
}
/*Register busy handler*/
}
*handle = NULL;
- return -1;
+ return MS_MEDIA_ERR_INVALID_PARAMETER;
}
} else {
*handle = NULL;
- return -1;
+ return MS_MEDIA_ERR_INVALID_PARAMETER;
}
- return MEDIA_THUMB_ERROR_NONE;
+ return MS_MEDIA_ERR_NONE;
}
int
_media_thumb_sqlite_disconnect(sqlite3 *handle)
{
- int err = -1;
+ int err = MS_MEDIA_ERR_NONE;
if (handle != NULL) {
err = db_util_close(handle);
if (SQLITE_OK != err) {
handle = NULL;
- return -1;
+ return MS_MEDIA_ERR_INVALID_PARAMETER;
}
}
- return MEDIA_THUMB_ERROR_NONE;
+ return MS_MEDIA_ERR_NONE;
}
int
if (handle == NULL) {
thumb_err("DB handle is NULL");
- return -1;
+ return MS_MEDIA_ERR_INVALID_PARAMETER;
}
int err = -1;
sqlite3_free(path_string);
if (SQLITE_OK != err) {
- thumb_err("prepare error [%s]\n", sqlite3_errmsg(handle));
- return -1;
+ thumb_err("prepare error [%s]", sqlite3_errmsg(handle));
+ return MS_MEDIA_ERR_DB_INTERNAL;
}
err = sqlite3_step(stmt);
if (err != SQLITE_ROW) {
- thumb_err("end of row [%s]\n", sqlite3_errmsg(handle));
+ thumb_err("end of row [%s]", sqlite3_errmsg(handle));
sqlite3_finalize(stmt);
- return -1;
+ return MS_MEDIA_ERR_DB_NO_RECORD;
}
*type = sqlite3_column_int(stmt, 0);
sqlite3_finalize(stmt);
- return MEDIA_THUMB_ERROR_NONE;
+ return MS_MEDIA_ERR_NONE;
}
*height = sqlite3_column_int(stmt, 1);
sqlite3_finalize(stmt);
- return MEDIA_THUMB_ERROR_NONE;
+ return MS_MEDIA_ERR_NONE;
}
-int
-_media_thumb_get_thumb_path_from_db(sqlite3 *handle,
+int _media_thumb_get_thumb_path_from_db(sqlite3 *handle,
const char *origin_path,
char *thumb_path,
int max_length)
sqlite3_free(path_string);
if (SQLITE_OK != err) {
- thumb_err("prepare error [%s]\n", sqlite3_errmsg(handle));
+ thumb_err("prepare error [%s]", sqlite3_errmsg(handle));
return -1;
}
err = sqlite3_step(stmt);
if (err != SQLITE_ROW) {
- thumb_err("end of row [%s]\n", sqlite3_errmsg(handle));
+ thumb_err("end of row [%s]", sqlite3_errmsg(handle));
sqlite3_finalize(stmt);
return -1;
}
sqlite3_finalize(stmt);
- return MEDIA_THUMB_ERROR_NONE;
+ return MS_MEDIA_ERR_NONE;
}
-int
-_media_thumb_update_thumb_path_to_db(sqlite3 *handle,
+int _media_thumb_update_thumb_path_to_db(sqlite3 *handle,
const char *origin_path,
char *thumb_path,
uid_t uid)
{
thumb_dbg("");
- int err = -1;
+ int err = MS_MEDIA_ERR_NONE;
char *path_string = NULL;
char *thumbpath_string = NULL;
char *query_string = NULL;
if (handle == NULL) {
thumb_err("DB handle is NULL");
- return -1;
+ return MS_MEDIA_ERR_INVALID_PARAMETER;
}
path_string = sqlite3_mprintf("%s", origin_path);
err_msg = NULL;
}
- return -1;
+ return MS_MEDIA_ERR_DB_UPDATE_FAIL;
}
if (err_msg)
#endif
thumb_dbg("Query success");
- return MEDIA_THUMB_ERROR_NONE;
+ return MS_MEDIA_ERR_NONE;
}
int
int height,
uid_t uid)
{
- thumb_dbg("");
- int err = -1;
+ int err = MS_MEDIA_ERR_NONE;
char *path_string = NULL;
char *query_string = NULL;
if (handle == NULL) {
thumb_err("DB handle is NULL");
- return -1;
+ return MS_MEDIA_ERR_INVALID_PARAMETER;
}
path_string = sqlite3_mprintf("%s", origin_path);
err_msg = NULL;
}
- return -1;
+ return MS_MEDIA_ERR_DB_UPDATE_FAIL;
}
if (err_msg)
sqlite3_free(err_msg);
#else
err = media_db_request_update_db(query_string, uid);
- if (err < 0) {
+ if (err != MS_MEDIA_ERR_NONE) {
thumb_err("media_db_request_update_db failed : %d", err);
return err;
}
#endif
thumb_dbg("Query success");
- return MEDIA_THUMB_ERROR_NONE;
+ return err;
}
-int
-_media_thumb_update_thumb_path_wh_to_db(sqlite3 *handle,
+int _media_thumb_update_thumb_path_wh_to_db(sqlite3 *handle,
const char *origin_path,
char *thumb_path,
int width,
int height,
uid_t uid)
{
- thumb_dbg("");
- int err = -1;
+ int err = MS_MEDIA_ERR_NONE;
char *path_string = NULL;
char *query_string = NULL;
query_string = sqlite3_mprintf(UPDATE_THUMB_WH_BY_PATH, thumb_path, width, height, path_string);
err = media_db_request_update_db(query_string, uid);
- if (err < 0) {
+ if (err != MS_MEDIA_ERR_NONE) {
thumb_err("media_db_request_update_db failed : %d", err);
return err;
}
thumb_dbg("Query success");
- return MEDIA_THUMB_ERROR_NONE;
+ return err;
}
-int
-_media_thumb_db_connect(uid_t uid)
+int _media_thumb_db_connect(uid_t uid)
{
- int err = -1;
+ int err = MS_MEDIA_ERR_NONE;
/*
err = media_svc_connect(&mb_svc_handle);
- if (err < 0) {
+ if (err != MS_MEDIA_ERR_NONE) {
thumb_err("media_svc_connect failed: %d", err);
mb_svc_handle = NULL;
return err;
*/
#ifndef _USE_MEDIA_UTIL_
err = _media_thumb_sqlite_connect(&db_handle);
- if (err < 0) {
+ if (err != MS_MEDIA_ERR_NONE) {
thumb_err("_media_thumb_sqlite_connect failed: %d", err);
db_handle = NULL;
return err;
}
#else
err = media_db_connect(&db_handle,uid);
- if (err < 0) {
+ if (err != MS_MEDIA_ERR_NONE) {
thumb_err("media_db_connect failed: %d", err);
db_handle = NULL;
- return MEDIA_THUMB_ERROR_DB;
+ return MS_MEDIA_ERR_DB_CONNECT_FAIL;
}
#endif
- return MEDIA_THUMB_ERROR_NONE;
+ return MS_MEDIA_ERR_NONE;
}
int
_media_thumb_db_disconnect()
{
- int err = -1;
+ int err = MS_MEDIA_ERR_NONE;
/*
err = media_svc_disconnect(mb_svc_handle);
- if (err < 0) {
+ if (err != MS_MEDIA_ERR_NONE) {
thumb_err("media_svc_disconnect failed: %d", err);
}
*/
#ifndef _USE_MEDIA_UTIL_
err = _media_thumb_sqlite_disconnect(db_handle);
- if (err < 0) {
+ if (err != MS_MEDIA_ERR_NONE) {
thumb_err("_media_thumb_sqlite_disconnect failed: %d", err);
db_handle = NULL;
return err;
}
#else
err = media_db_disconnect(db_handle);
- if (err < 0) {
+ if (err != MS_MEDIA_ERR_NONE) {
thumb_err("media_db_disconnect failed: %d", err);
db_handle = NULL;
- return MEDIA_THUMB_ERROR_DB;
+ return MS_MEDIA_ERR_DB_CONNECT_FAIL;
}
#endif
return err;
}
-int
-_media_thumb_get_thumb_from_db(const char *origin_path,
+int _media_thumb_get_thumb_from_db(const char *origin_path,
char *thumb_path,
int max_length,
int *need_update_db)
{
- thumb_dbg("");
int err = -1;
//err = minfo_get_thumb_path(mb_svc_handle, origin_path, thumb_path, max_length);
thumb_dbg("This thumb path already exist");
}
- return MEDIA_THUMB_ERROR_NONE;
+ return MS_MEDIA_ERR_NONE;
}
-int
-_media_thumb_get_thumb_from_db_with_size(const char *origin_path,
+int _media_thumb_get_thumb_from_db_with_size(const char *origin_path,
char *thumb_path,
int max_length,
int *need_update_db,
int *width,
int *height)
{
- thumb_dbg("");
int err = -1;
//err = minfo_get_thumb_path(mb_svc_handle, origin_path, thumb_path, max_length);
}
}
- return MEDIA_THUMB_ERROR_NONE;
+ return MS_MEDIA_ERR_NONE;
}
-int
-_media_thumb_update_db(const char *origin_path,
+int _media_thumb_update_db(const char *origin_path,
char *thumb_path,
int width,
int height,
uid_t uid)
{
- thumb_dbg("");
- int err = -1;
+ int err = MS_MEDIA_ERR_NONE;
#if 0
Mitem *item = NULL;
err = minfo_get_item(mb_svc_handle, origin_path, &item);
- if (err < 0) {
+ if (err != MS_MEDIA_ERR_NONE) {
thumb_err("minfo_get_item (%s) failed: %d", origin_path, err);
- return MEDIA_THUMB_ERROR_DB;
+ return err;
}
err = minfo_update_media_thumb(mb_svc_handle, item->uuid, thumb_path);
- if (err < 0) {
+ if (err != MS_MEDIA_ERR_NONE) {
thumb_err("minfo_update_media_thumb (ID:%s, %s) failed: %d",
item->uuid, thumb_path, err);
minfo_destroy_mtype_item(item);
- return MEDIA_THUMB_ERROR_DB;
+ return err;
}
if (item->type == MINFO_ITEM_IMAGE) {
MINFO_IMAGE_META_WIDTH, width,
MINFO_IMAGE_META_HEIGHT, height, -1);
- if (err < 0) {
+ if (err != MS_MEDIA_ERR_NONE) {
thumb_err("minfo_update_image_meta_info_int failed: %d", err);
minfo_destroy_mtype_item(item);
- return MEDIA_THUMB_ERROR_DB;
+ return err;
}
}
err = _media_thumb_get_type_from_db(db_handle, origin_path, &media_type);
if (err < 0) {
thumb_err("_media_thumb_get_type_from_db (%s) failed: %d", origin_path, err);
- return MEDIA_THUMB_ERROR_DB;
+ return err;
}
#if 0
err = _media_thumb_update_thumb_path_to_db(db_handle, origin_path, thumb_path);
if (err < 0) {
thumb_err("_media_thumb_update_thumb_path_to_db (%s) failed: %d", origin_path, err);
- return MEDIA_THUMB_ERROR_DB;
+ return err;
}
if (media_type == THUMB_IMAGE_TYPE && width > 0 && height > 0) {
err = _media_thumb_update_wh_to_db(db_handle, origin_path, width, height);
if (err < 0) {
thumb_err("_media_thumb_update_wh_to_db (%s) failed: %d", origin_path, err);
- return MEDIA_THUMB_ERROR_DB;
+ return err;
}
}
#else
err = _media_thumb_update_thumb_path_wh_to_db(db_handle, origin_path, thumb_path, width, height,uid);
if (err < 0) {
thumb_err("_media_thumb_update_wh_to_db (%s) failed: %d", origin_path, err);
- return MEDIA_THUMB_ERROR_DB;
+ return err;
}
} else {
err = _media_thumb_update_thumb_path_to_db(db_handle, origin_path, thumb_path, uid);
if (err < 0) {
thumb_err("_media_thumb_update_thumb_path_to_db (%s) failed: %d", origin_path, err);
- return MEDIA_THUMB_ERROR_DB;
+ return err;
}
}
#endif
thumb_dbg("_media_thumb_update_db success");
- return MEDIA_THUMB_ERROR_NONE;
+ return MS_MEDIA_ERR_NONE;
}
char mimetype[255];
if (file_full_path == NULL)
- return MEDIA_THUMB_ERROR_INVALID_PARAMETER;
+ return MS_MEDIA_ERR_INVALID_PARAMETER;
ret = drm_is_drm_file(file_full_path, &drm_type);
if (ret < 0) {
if (origin_path == NULL || size == NULL
|| width == NULL || height == NULL) {
thumb_err("Invalid parameter");
- return MEDIA_THUMB_ERROR_INVALID_PARAMETER;
+ return MS_MEDIA_ERR_INVALID_PARAMETER;
}
if (format < MEDIA_THUMB_BGRA || format > MEDIA_THUMB_RGB888) {
thumb_err("parameter format is invalid");
- return MEDIA_THUMB_ERROR_INVALID_PARAMETER;
+ return MS_MEDIA_ERR_INVALID_PARAMETER;
}
if (!g_file_test
(origin_path, G_FILE_TEST_EXISTS | G_FILE_TEST_IS_REGULAR)) {
thumb_err("Original path (%s) does not exist", origin_path);
- return MEDIA_THUMB_ERROR_INVALID_PARAMETER;
+ return MS_MEDIA_ERR_INVALID_PARAMETER;
}
thumb_width = _media_thumb_get_width(thumb_type);
if (thumb_width < 0) {
thumb_err("media_thumb_type is invalid");
- return MEDIA_THUMB_ERROR_INVALID_PARAMETER;
+ return MS_MEDIA_ERR_INVALID_PARAMETER;
}
thumb_height = _media_thumb_get_height(thumb_type);
if (thumb_height < 0) {
thumb_err("media_thumb_type is invalid");
- return MEDIA_THUMB_ERROR_INVALID_PARAMETER;
+ return MS_MEDIA_ERR_INVALID_PARAMETER;
}
thumb_dbg("Origin path : %s", origin_path);
thumb_dbg("Thumb data is generated successfully (Size:%d, W:%d, H:%d) 0x%x",
*size, *width, *height, *data);
- return MEDIA_THUMB_ERROR_NONE;
-}
+ return MS_MEDIA_ERR_NONE;
+}
\ No newline at end of file
projects / platform / core / multimedia / libmedia-thumbnail.git / commitdiff