2 * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
8 * http://www.apache.org/licenses/LICENSE-2.0
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
18 #include <media_content.h>
19 #include <media_info_private.h>
20 #include <media_util_private.h>
22 static const char * __media_db_get_group_name(media_group_e group)
25 case MEDIA_CONTENT_GROUP_DISPLAY_NAME:
26 return DB_FIELD_MEDIA_DISPLAY_NAME;
27 case MEDIA_CONTENT_GROUP_TYPE:
28 return DB_FIELD_MEDIA_TYPE;
29 case MEDIA_CONTENT_GROUP_MIME_TYPE:
30 return DB_FIELD_MEDIA_MIME_TYPE;
31 case MEDIA_CONTENT_GROUP_SIZE:
32 return DB_FIELD_MEDIA_SIZE;
33 case MEDIA_CONTENT_GROUP_ADDED_TIME:
34 return DB_FIELD_MEDIA_ADDED_TIME;
35 case MEDIA_CONTENT_GROUP_MODIFIED_TIME:
36 return DB_FIELD_MEDIA_MODIFIED_TIME;
37 case MEDIA_CONTENT_GROUP_TITLE:
38 return DB_FIELD_MEDIA_TITLE;
39 case MEDIA_CONTENT_GROUP_ARTIST:
40 return DB_FIELD_MEDIA_ARTIST;
41 case MEDIA_CONTENT_GROUP_ALBUM_ARTIST:
42 return DB_FIELD_MEDIA_ALBUM_ARTIST;
43 case MEDIA_CONTENT_GROUP_GENRE:
44 return DB_FIELD_MEDIA_GENRE;
45 case MEDIA_CONTENT_GROUP_COMPOSER:
46 return DB_FIELD_MEDIA_COMPOSER;
47 case MEDIA_CONTENT_GROUP_YEAR:
48 return DB_FIELD_MEDIA_YEAR;
49 case MEDIA_CONTENT_GROUP_RECORDED_DATE:
50 return DB_FIELD_MEDIA_RECORDED_DATE;
51 case MEDIA_CONTENT_GROUP_COPYRIGHT:
52 return DB_FIELD_MEDIA_COPYRIGHT;
53 case MEDIA_CONTENT_GROUP_TRACK_NUM:
54 return DB_FIELD_MEDIA_TRACK_NUM;
55 case MEDIA_CONTENT_GROUP_DESCRIPTION:
56 return DB_FIELD_MEDIA_DESCRIPTION;
57 case MEDIA_CONTENT_GROUP_LONGITUDE:
58 return DB_FIELD_MEDIA_LONGITUDE;
59 case MEDIA_CONTENT_GROUP_LATITUDE:
60 return DB_FIELD_MEDIA_LATITUDE;
61 case MEDIA_CONTENT_GROUP_ALTITUDE:
62 return DB_FIELD_MEDIA_ALTITUDE;
63 case MEDIA_CONTENT_GROUP_RATING:
64 return DB_FIELD_MEDIA_RATING;
66 case MEDIA_CONTENT_GROUP_MODIFIED_MONTH:
67 return DB_FIELD_MEDIA_MODIFIED_DATE;
68 case MEDIA_CONTENT_GROUP_MODIFIED_DATE:
69 return DB_FIELD_MEDIA_MODIFIED_DATE;
71 #ifdef _USE_SENIOR_MODE
72 case MEDIA_CONTENT_GROUP_CONTACT:
73 return DB_FIELD_MEDIA_CONTACT;
76 case MEDIA_CONTENT_GROUP_ALBUM:
77 return DB_FIELD_MEDIA_ALBUM;
78 case MEDIA_PVR_GROUP_DURATION:
79 return DB_FIELD_PVR_DURATION;
80 case MEDIA_PVR_GROUP_TIME_ZONE:
81 return DB_FIELD_PVR_TIME_ZONE;
82 case MEDIA_PVR_GROUP_PTC:
83 return DB_FIELD_PVR_PTC;
84 case MEDIA_PVR_GROUP_MAJOR:
85 return DB_FIELD_PVR_MAJOR;
86 case MEDIA_PVR_GROUP_MINOR:
87 return DB_FIELD_PVR_MINOR;
88 case MEDIA_PVR_GROUP_CHANNEL_TYPE:
89 return DB_FIELD_PVR_CHANNEL_TYPE;
90 case MEDIA_PVR_GROUP_CHANNEL_NAME:
91 return DB_FIELD_PVR_CHANNEL_NAME;
92 case MEDIA_PVR_GROUP_CHANNEL_NUM:
93 return DB_FIELD_PVR_CHANNEL_NUM;
94 case MEDIA_PVR_GROUP_PROGRAM_TITLE:
95 return DB_FIELD_PVR_PROGRAM_TITLE;
96 case MEDIA_PVR_GROUP_PROGRAM_NUM:
97 return DB_FIELD_PVR_PROGRAM_NUM;
98 case MEDIA_PVR_GROUP_PROGRAM_CRID:
99 return DB_FIELD_PVR_PROGRAM_CRID;
100 case MEDIA_PVR_GROUP_GUIDANCE:
101 return DB_FIELD_PVR_GUIDANCE;
102 case MEDIA_PVR_GROUP_SYNOPSIS:
103 return DB_FIELD_PVR_SYNOPSIS;
104 case MEDIA_PVR_GROUP_GENRE:
105 return DB_FIELD_PVR_GENRE;
106 case MEDIA_PVR_GROUP_LANGUAGE:
107 return DB_FIELD_PVR_LANGUAGE;
108 case MEDIA_PVR_GROUP_EMBARGO_TIME:
109 return DB_FIELD_PVR_EMBARGO_TIME;
110 case MEDIA_PVR_GROUP_EXPIRY_TIME:
111 return DB_FIELD_PVR_EXPIRY_TIME;
112 case MEDIA_PVR_GROUP_START_TIME:
113 return DB_FIELD_PVR_START_TIME;
114 case MEDIA_PVR_GROUP_PROGRAM_START_TIME:
115 return DB_FIELD_PVR_PROGRAM_START_TIME;
116 case MEDIA_PVR_GROUP_PROGRAM_END_TIME:
117 return DB_FIELD_PVR_PROGRAM_END_TIME;
118 case MEDIA_PVR_GROUP_PROGRAM_DATE:
119 return DB_FIELD_PVR_PROGRAM_DATE;
120 case MEDIA_PVR_GROUP_PARENTAL_RATING:
121 return DB_FIELD_PVR_PARENTAL_RATING;
122 case MEDIA_PVR_GROUP_TIMER_RECORD:
123 return DB_FIELD_PVR_TIMER_RECORD;
124 case MEDIA_PVR_GROUP_SERIES_RECORD:
125 return DB_FIELD_PVR_SERIES_RECORD;
126 case MEDIA_PVR_GROUP_HD:
127 return DB_FIELD_PVR_HD;
128 case MEDIA_PVR_GROUP_SUBTITLE:
129 return DB_FIELD_PVR_SUBTITLE;
130 case MEDIA_PVR_GROUP_TTX:
131 return DB_FIELD_PVR_TTX;
132 case MEDIA_PVR_GROUP_AD:
133 return DB_FIELD_PVR_AD;
134 case MEDIA_PVR_GROUP_HARDOF_HEARINGRADIO:
135 return DB_FIELD_PVR_HARDOF_HEARINGRADIO;
136 case MEDIA_PVR_GROUP_DATA_SERVICE:
137 return DB_FIELD_PVR_DATA_SERVICE;
138 case MEDIA_PVR_GROUP_CONTENT_LOCK:
139 return DB_FIELD_PVR_CONTENT_LOCK;
140 case MEDIA_PVR_GROUP_CONTENT_WATCH:
141 return DB_FIELD_PVR_CONTENT_WATCH;
142 case MEDIA_PVR_GROUP_HAS_AUDIO_ONLY:
143 return DB_FIELD_PVR_HAS_AUDIO_ONLY;
144 case MEDIA_PVR_GROUP_IS_LOCAL_RECORDED:
145 return DB_FIELD_PVR_IS_LOCAL_RECORD;
146 case MEDIA_PVR_GROUP_RESOLUTION:
147 return DB_FIELD_PVR_RESOLUTION;
148 case MEDIA_PVR_GROUP_ASPECTRATIO:
149 return DB_FIELD_PVR_ASPECTRATIO;
150 case MEDIA_PVR_GROUP_MODIFIED_MONTH:
151 return DB_FIELD_PVR_MODIFIED_DATE;
152 case MEDIA_PVR_GROUP_MODIFIED_DATE:
153 return DB_FIELD_PVR_MODIFIED_DATE;
154 case MEDIA_PVR_GROUP_SPORTS_TYPE:
155 return DB_FIELD_PVR_SPORTS_TYPE;
156 case MEDIA_PVR_GROUP_GUIDANCE_LENGTH:
157 return DB_FIELD_PVR_GUIDANCE_LENGTH;
158 case MEDIA_PVR_GROUP_TVMODE:
159 return DB_FIELD_PVR_TVMODE;
160 case MEDIA_PVR_GROUP_PLAY_COUNT:
161 return DB_FIELD_PVR_PLAY_COUNT;
162 case MEDIA_PVR_GROUP_PRIVATE_DATA:
163 return DB_FIELD_PVR_PRIVATE_DATA;
164 case MEDIA_UHD_GROUP_CONTENT_TITLE:
165 return DB_FIELD_UHD_CONTENT_TITLE;
166 case MEDIA_UHD_GROUP_RELEASE_DATE:
167 return DB_FIELD_UHD_RELEASE_DATE;
168 case MEDIA_UHD_GROUP_SUB_TYPE:
169 return DB_FIELD_UHD_SUB_TYPE;
170 case MEDIA_UHD_GROUP_FILE_NAME:
171 return DB_FIELD_UHD_FILE_NAME;
172 case MEDIA_UHD_GROUP_PLAYED_COUNT:
173 return DB_FIELD_UHD_PLAYED_COUNT;
182 static int __media_db_make_query(filter_h filter, char **condition_query, char **option_query)
184 int ret = MEDIA_CONTENT_ERROR_NONE;
185 filter_s *_filter = (filter_s *)filter;
187 media_content_retv_if(!_filter, MEDIA_CONTENT_ERROR_NONE);
189 if (STRING_VALID(_filter->condition)) {
190 ret = _media_filter_build_condition(_filter->is_full_condition, _filter->condition, _filter->condition_collate_type, condition_query);
191 media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
194 ret = _media_filter_build_option(filter, option_query);
195 if (ret != MEDIA_CONTENT_ERROR_NONE)
196 g_free(*condition_query);
201 #ifdef _USE_TVPD_MODE
202 int _media_db_get_group_count(filter_h filter, group_list_e group_type, int *group_count)
204 int ret = MEDIA_CONTENT_ERROR_NONE;
205 sqlite3_stmt *stmt = NULL;
206 char select_query[MAX_QUERY_SIZE] = {0, };
207 char *condition_query = NULL;
208 char *option_query = NULL;
209 filter_s *_filter = (filter_s *)filter;
211 memset(select_query, 0x00, sizeof(select_query));
213 switch (group_type) {
214 case MEDIA_GROUP_ALBUM:
215 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
216 snprintf(select_query, sizeof(select_query), SELECT_ALBUM_COUNT, _filter->storage_id);
218 snprintf(select_query, sizeof(select_query), SELECT_ALBUM_COUNT, DB_VIEW_MEDIA);
221 case MEDIA_GROUP_FOLDER:
222 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
223 snprintf(select_query, sizeof(select_query), SELECT_FOLDER_COUNT_BY_STORAGE_ID, _filter->storage_id, _filter->storage_id);
225 snprintf(select_query, sizeof(select_query), SELECT_FOLDER_COUNT, DB_VIEW_MEDIA);
228 case MEDIA_GROUP_PLAYLIST:
229 if (!SAFE_STRLCPY(select_query, SELECT_PLAYLIST_COUNT, sizeof(select_query))) {
230 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
231 return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
234 case MEDIA_GROUP_TAG:
235 if (!SAFE_STRLCPY(select_query, SELECT_TAG_COUNT, sizeof(select_query))) {
236 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
237 return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
240 case MEDIA_GROUP_BOOKMARK:
241 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
242 snprintf(select_query, sizeof(select_query), SELECT_BOOKMARK_COUNT, _filter->storage_id);
244 snprintf(select_query, sizeof(select_query), SELECT_BOOKMARK_COUNT, DB_VIEW_MEDIA);
247 case MEDIA_GROUP_STORAGE:
248 if (!SAFE_STRLCPY(select_query, SELECT_STORAGE_COUNT, sizeof(select_query))) {
249 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
250 return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
253 case MEDIA_GROUP_FACE:
254 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
255 snprintf(select_query, sizeof(select_query), SELECT_FACE_COUNT, _filter->storage_id);
257 snprintf(select_query, sizeof(select_query), SELECT_FACE_COUNT, DB_VIEW_MEDIA);
260 media_content_error("Invalid group type [%d]", group_type);
261 return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
264 ret = __media_db_make_query(filter, &condition_query, &option_query);
265 media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
267 ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
268 SAFE_FREE(condition_query);
269 SAFE_FREE(option_query);
270 media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
272 if (sqlite3_step(stmt) == SQLITE_ROW)
273 *group_count = sqlite3_column_int(stmt, 0);
275 SQLITE3_FINALIZE(stmt);
280 int _media_db_get_media_group_count(media_group_e group, filter_h filter, int *group_count)
282 int ret = MEDIA_CONTENT_ERROR_NONE;
283 sqlite3_stmt *stmt = NULL;
284 char select_query[MAX_QUERY_SIZE] = {0, };
285 char *condition_query = NULL;
286 char *option_query = NULL;
287 char *tmp_option = NULL;
288 filter_s *_filter = (filter_s *)filter;
290 memset(select_query, 0x00, sizeof(select_query));
291 if (group < MEDIA_PVR_GROUP_DURATION) { /*media content*/
292 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
293 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_GROUP_COUNT, __media_db_get_group_name(group), _filter->storage_id);
295 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_GROUP_COUNT, __media_db_get_group_name(group), DB_VIEW_MEDIA);
296 } else if (group < MEDIA_UHD_GROUP_CONTENT_TITLE) { /*pvr content*/
297 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
298 snprintf(select_query, sizeof(select_query), SELECT_PVR_GROUP_COUNT_BY_STORAGE_ID, __media_db_get_group_name(group), _filter->storage_id);
300 snprintf(select_query, sizeof(select_query), SELECT_PVR_GROUP_COUNT, __media_db_get_group_name(group));
301 } else { /*uhd content*/
302 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
303 snprintf(select_query, sizeof(select_query), SELECT_UHD_GROUP_COUNT_BY_STORAGE_ID, __media_db_get_group_name(group), _filter->storage_id);
305 snprintf(select_query, sizeof(select_query), SELECT_UHD_GROUP_COUNT, __media_db_get_group_name(group));
307 ret = __media_db_make_query(filter, &condition_query, &option_query);
308 media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
311 tmp_option = g_strconcat(option_query, ")", NULL);
312 g_free(option_query);
313 option_query = tmp_option;
315 SAFE_STRLCAT(select_query, ")", sizeof(select_query));
318 ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
319 SAFE_FREE(condition_query);
320 SAFE_FREE(option_query);
321 media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
323 if (sqlite3_step(stmt) == SQLITE_ROW)
324 *group_count = sqlite3_column_int(stmt, 0);
326 SQLITE3_FINALIZE(stmt);
331 int _media_db_get_media_group(media_group_e group, filter_h filter, media_group_cb callback, void *user_data)
333 int ret = MEDIA_CONTENT_ERROR_NONE;
334 char select_query[MAX_QUERY_SIZE] = {0, };
335 char *condition_query = NULL;
336 char *option_query = NULL;
338 sqlite3_stmt *stmt = NULL;
339 filter_s *_filter = (filter_s *)filter;
340 memset(select_query, 0x00, sizeof(select_query));
341 if (group < MEDIA_PVR_GROUP_DURATION) { /*media content */
342 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
343 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_GROUP_LIST, __media_db_get_group_name(group), _filter->storage_id);
345 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_GROUP_LIST, __media_db_get_group_name(group), DB_VIEW_MEDIA);
346 } else if (group < MEDIA_UHD_GROUP_CONTENT_TITLE) { /*pvr content */
347 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
348 snprintf(select_query, sizeof(select_query), SELECT_PVR_GROUP_LIST_BY_STORAGE_ID, __media_db_get_group_name(group), _filter->storage_id);
350 snprintf(select_query, sizeof(select_query), SELECT_PVR_GROUP_LIST, __media_db_get_group_name(group));
351 } else { /* uhd content */
352 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
353 snprintf(select_query, sizeof(select_query), SELECT_UHD_GROUP_LIST_BY_STORAGE_ID, __media_db_get_group_name(group), _filter->storage_id);
355 snprintf(select_query, sizeof(select_query), SELECT_UHD_GROUP_LIST, __media_db_get_group_name(group));
357 ret = __media_db_make_query(filter, &condition_query, &option_query);
358 media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
360 ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
361 SAFE_FREE(condition_query);
362 SAFE_FREE(option_query);
363 media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
365 while (sqlite3_step(stmt) == SQLITE_ROW) {
366 name = g_strdup((const char *)sqlite3_column_text(stmt, 0));
368 if (callback(name, user_data) == false) {
376 SQLITE3_FINALIZE(stmt);
381 int _media_db_get_media_group_and_count(media_group_e group, filter_h filter, media_group_and_count_cb callback, void *user_data)
383 int ret = MEDIA_CONTENT_ERROR_NONE;
384 char select_query[DEFAULT_QUERY_SIZE] = {0, };
385 char group_query[DEFAULT_QUERY_SIZE] = {0, };
386 char *condition_query = NULL;
387 char *option_query = NULL;
389 sqlite3_stmt *stmt = NULL;
390 filter_s *_filter = (filter_s *)filter;
392 memset(select_query, 0x00, sizeof(select_query));
393 memset(group_query, 0x00, sizeof(group_query));
395 char* group_name = __media_db_get_group_name(group);
396 if (!STRING_VALID(group_name)) {
397 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
398 media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
401 if (group < MEDIA_PVR_GROUP_DURATION) { /*media content*/
402 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
403 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_GROUP_AND_COUNT, group_name, _filter->storage_id);
405 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_GROUP_AND_COUNT, group_name, DB_VIEW_MEDIA);
406 } else if (group < MEDIA_UHD_GROUP_CONTENT_TITLE) {/*pvr content*/
407 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
408 snprintf(select_query, sizeof(select_query), SELECT_PVR_GROUP_AND_COUNT_BY_STORAGE_ID, group_name, _filter->storage_id);
410 snprintf(select_query, sizeof(select_query), SELECT_PVR_GROUP_AND_COUNT, group_name);
411 } else {/*uhd content*/
412 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
413 snprintf(select_query, sizeof(select_query), SELECT_UHD_GROUP_AND_COUNT_BY_STORAGE_ID, group_name, _filter->storage_id);
415 snprintf(select_query, sizeof(select_query), SELECT_UHD_GROUP_AND_COUNT, group_name);
418 ret = __media_db_make_query(filter, &condition_query, &option_query);
419 media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
421 if (STRING_VALID(option_query))
422 snprintf(group_query, sizeof(group_query), "GROUP BY %s %s", group_name, option_query);
424 snprintf(group_query, sizeof(group_query), "GROUP BY %s", group_name);
426 ret = _content_query_prepare(select_query, condition_query, group_query, &stmt);
427 SAFE_FREE(condition_query);
428 SAFE_FREE(option_query);
429 media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
431 while (sqlite3_step(stmt) == SQLITE_ROW) {
432 if (STRING_VALID((const char *)sqlite3_column_text(stmt, 0)))
433 name = strdup((const char *)sqlite3_column_text(stmt, 0));
435 if (callback(name, sqlite3_column_int(stmt, 1), user_data) == false) {
443 SQLITE3_FINALIZE(stmt);
448 int _media_db_get_group_count(filter_h filter, group_list_e group_type, int *group_count)
450 int ret = MEDIA_CONTENT_ERROR_NONE;
451 sqlite3_stmt *stmt = NULL;
452 char *select_query = NULL;
453 char *condition_query = NULL;
454 char *option_query = NULL;
455 filter_s *_filter = (filter_s *)filter;
457 switch (group_type) {
458 case MEDIA_GROUP_ALBUM:
459 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
460 select_query = g_strdup_printf(SELECT_ALBUM_COUNT_BY_STORAGE_ID, _filter->storage_id);
462 select_query = g_strdup(SELECT_ALBUM_COUNT);
465 case MEDIA_GROUP_FOLDER:
466 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
467 select_query = g_strdup_printf(SELECT_FOLDER_COUNT_BY_STORAGE_ID, _filter->storage_id);
469 select_query = g_strdup(SELECT_FOLDER_COUNT);
472 case MEDIA_GROUP_PLAYLIST:
473 select_query = g_strdup(SELECT_PLAYLIST_COUNT);
475 case MEDIA_GROUP_TAG:
476 select_query = g_strdup(SELECT_TAG_COUNT);
478 case MEDIA_GROUP_BOOKMARK:
479 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
480 select_query = g_strdup_printf(SELECT_BOOKMARK_COUNT_BY_STORAGE_ID, _filter->storage_id);
482 select_query = g_strdup(SELECT_BOOKMARK_COUNT);
485 case MEDIA_GROUP_STORAGE:
486 select_query = g_strdup(SELECT_STORAGE_COUNT);
488 case MEDIA_GROUP_FACE:
489 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
490 select_query = g_strdup_printf(SELECT_FACE_COUNT_BY_STORAGE_ID, _filter->storage_id);
492 select_query = g_strdup(SELECT_FACE_COUNT);
495 media_content_error("Invalid group type [%d]", group_type);
496 return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
499 ret = __media_db_make_query(filter, &condition_query, &option_query);
500 if (ret != MEDIA_CONTENT_ERROR_NONE) {
501 g_free(select_query);
505 ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
506 g_free(select_query);
507 g_free(condition_query);
508 g_free(option_query);
509 media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
511 if (sqlite3_step(stmt) == SQLITE_ROW)
512 *group_count = sqlite3_column_int(stmt, 0);
514 SQLITE3_FINALIZE(stmt);
519 int _media_db_get_media_group_count(media_group_e group, filter_h filter, int *group_count)
521 int ret = MEDIA_CONTENT_ERROR_NONE;
522 sqlite3_stmt *stmt = NULL;
523 char *select_query = NULL;
524 char *condition_query = NULL;
525 char *option_query = NULL;
526 filter_s *_filter = (filter_s *)filter;
528 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
529 select_query = g_strdup_printf(SELECT_MEDIA_GROUP_COUNT_BY_STORAGE_ID, __media_db_get_group_name(group), __media_db_get_group_name(group), _filter->storage_id);
531 select_query = g_strdup_printf(SELECT_MEDIA_GROUP_COUNT, __media_db_get_group_name(group), __media_db_get_group_name(group));
533 ret = __media_db_make_query(filter, &condition_query, &option_query);
534 if (ret != MEDIA_CONTENT_ERROR_NONE) {
535 g_free(select_query);
539 ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
540 g_free(select_query);
541 g_free(condition_query);
542 g_free(option_query);
543 media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
545 if (sqlite3_step(stmt) == SQLITE_ROW)
546 *group_count = sqlite3_column_int(stmt, 0);
548 SQLITE3_FINALIZE(stmt);
553 int _media_db_get_media_group(media_group_e group, filter_h filter, media_group_cb callback, void *user_data)
555 int ret = MEDIA_CONTENT_ERROR_NONE;
556 char *select_query = NULL;
557 char *condition_query = NULL;
558 char *option_query = NULL;
560 sqlite3_stmt *stmt = NULL;
561 filter_s *_filter = (filter_s *)filter;
563 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
564 select_query = g_strdup_printf(SELECT_MEDIA_GROUP_LIST_BY_STORAGE_ID, __media_db_get_group_name(group), _filter->storage_id);
566 select_query = g_strdup_printf(SELECT_MEDIA_GROUP_LIST, __media_db_get_group_name(group));
568 ret = __media_db_make_query(filter, &condition_query, &option_query);
569 if (ret != MEDIA_CONTENT_ERROR_NONE) {
570 g_free(select_query);
574 ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
575 g_free(select_query);
576 g_free(condition_query);
577 g_free(option_query);
578 media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
580 while (sqlite3_step(stmt) == SQLITE_ROW) {
581 name = g_strdup((const char *)sqlite3_column_text(stmt, 0));
583 if (callback(name, user_data) == false) {
591 SQLITE3_FINALIZE(stmt);
597 int _media_db_get_album(filter_h filter, media_album_cb callback, void *user_data)
599 int ret = MEDIA_CONTENT_ERROR_NONE;
600 char select_query[MAX_QUERY_SIZE] = {0, };
601 char *condition_query = NULL;
602 char *option_query = NULL;
603 sqlite3_stmt *stmt = NULL;
604 filter_s *_filter = (filter_s *)filter;
606 memset(select_query, 0x00, sizeof(select_query));
607 #ifdef _USE_TVPD_MODE
608 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
609 snprintf(select_query, sizeof(select_query), SELECT_ALBUM_LIST, _filter->storage_id);
611 snprintf(select_query, sizeof(select_query), SELECT_ALBUM_LIST, DB_VIEW_MEDIA);
613 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
614 snprintf(select_query, sizeof(select_query), SELECT_ALBUM_LIST_BY_STORAGE_ID, _filter->storage_id);
616 snprintf(select_query, sizeof(select_query), SELECT_ALBUM_LIST);
618 ret = __media_db_make_query(filter, &condition_query, &option_query);
619 media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
621 ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
622 SAFE_FREE(condition_query);
623 SAFE_FREE(option_query);
624 media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
626 while (sqlite3_step(stmt) == SQLITE_ROW) {
627 media_album_s *album = (media_album_s*)calloc(1, sizeof(media_album_s));
630 media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
631 SQLITE3_FINALIZE(stmt);
632 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
635 album->album_id = sqlite3_column_int(stmt, 0);
636 album->name = g_strdup((const char *)sqlite3_column_text(stmt, 1));
637 album->artist = g_strdup((const char *)sqlite3_column_text(stmt, 2));
638 album->album_art_path = g_strdup((const char *)sqlite3_column_text(stmt, 3));
640 if (callback((media_album_h)album, user_data) == false) {
641 media_album_destroy((media_album_h)album);
645 media_album_destroy((media_album_h)album);
648 SQLITE3_FINALIZE(stmt);
653 int _media_db_get_folder(filter_h filter, media_folder_cb callback, void *user_data)
655 int ret = MEDIA_CONTENT_ERROR_NONE;
656 char select_query[MAX_QUERY_SIZE] = {0, };
657 char *condition_query = NULL;
658 char *option_query = NULL;
659 sqlite3_stmt *stmt = NULL;
660 filter_s *_filter = (filter_s *)filter;
662 memset(select_query, 0x00, sizeof(select_query));
663 #ifdef _USE_TVPD_MODE
664 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
665 snprintf(select_query, sizeof(select_query), SELECT_FOLDER_LIST_BY_STORAGE_ID, _filter->storage_id, _filter->storage_id);
667 snprintf(select_query, sizeof(select_query), SELECT_FOLDER_LIST, DB_VIEW_MEDIA);
669 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
670 snprintf(select_query, sizeof(select_query), SELECT_FOLDER_LIST_BY_STORAGE_ID, _filter->storage_id);
672 snprintf(select_query, sizeof(select_query), SELECT_FOLDER_LIST);
674 ret = __media_db_make_query(filter, &condition_query, &option_query);
675 media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
677 ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
678 SAFE_FREE(condition_query);
679 SAFE_FREE(option_query);
680 media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
682 while (sqlite3_step(stmt) == SQLITE_ROW) {
683 media_folder_s *_folder = (media_folder_s*)calloc(1, sizeof(media_folder_s));
685 if (_folder == NULL) {
686 media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
687 SQLITE3_FINALIZE(stmt);
688 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
691 _folder->folder_id = g_strdup((const char *)sqlite3_column_text(stmt, 0));
692 _folder->path = g_strdup((const char *)sqlite3_column_text(stmt, 1));
693 _folder->name = g_strdup((const char *)sqlite3_column_text(stmt, 2));
694 _folder->storage_type = sqlite3_column_int(stmt, 3);
695 _folder->storage_uuid = g_strdup((const char *)sqlite3_column_text(stmt, 4));
697 if (callback((media_folder_h)_folder, user_data) == false) {
698 media_folder_destroy((media_folder_h) _folder);
702 media_folder_destroy((media_folder_h) _folder);
705 SQLITE3_FINALIZE(stmt);
710 int _media_db_get_playlist(filter_h filter, media_playlist_cb callback, void *user_data)
712 int ret = MEDIA_CONTENT_ERROR_NONE;
713 char *condition_query = NULL;
714 char *option_query = NULL;
715 sqlite3_stmt *stmt = NULL;
717 ret = __media_db_make_query(filter, &condition_query, &option_query);
718 media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
720 ret = _content_query_prepare(SELECT_PLAYLIST_LIST, condition_query, option_query, &stmt);
721 SAFE_FREE(condition_query);
722 SAFE_FREE(option_query);
723 media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
725 while (sqlite3_step(stmt) == SQLITE_ROW) {
726 media_playlist_s *_playlist = (media_playlist_s*)calloc(1, sizeof(media_playlist_s));
728 if (_playlist == NULL) {
729 media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
730 SQLITE3_FINALIZE(stmt);
731 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
734 _playlist->playlist_id = sqlite3_column_int(stmt, 0);
735 _playlist->name = g_strdup((const char *)sqlite3_column_text(stmt, 1));
736 _playlist->thumbnail_path = g_strdup((const char *)sqlite3_column_text(stmt, 2));
738 if (callback((media_playlist_h)_playlist, user_data) == false) {
739 media_playlist_destroy((media_playlist_h)_playlist);
742 media_playlist_destroy((media_playlist_h)_playlist);
745 SQLITE3_FINALIZE(stmt);
750 int _media_db_get_playlist_item(int playlist_id, filter_h filter, playlist_member_cb callback, void *user_data)
752 int ret = MEDIA_CONTENT_ERROR_NONE;
753 char *select_query = NULL;
754 char *condition_query = NULL;
755 char *option_query = NULL;
756 sqlite3_stmt *stmt = NULL;
758 select_query = g_strdup_printf(SELECT_PLAYLIST_ITEM_ALL_FROM_PLAYLIST_VIEW, playlist_id);
760 ret = __media_db_make_query(filter, &condition_query, &option_query);
761 if (ret != MEDIA_CONTENT_ERROR_NONE) {
762 g_free(select_query);
766 ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
767 g_free(select_query);
768 g_free(condition_query);
769 g_free(option_query);
770 media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
772 while (sqlite3_step(stmt) == SQLITE_ROW) {
773 int playlist_member_id = 0;
774 playlist_member_id = sqlite3_column_int(stmt, MEDIA_INFO_ITEM_MAX); /*MEDIA_INFO_ITEM_MAX is pm_id*/
776 media_info_s *_media = (media_info_s*)calloc(1, sizeof(media_info_s));
778 if (_media == NULL) {
779 media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
780 SQLITE3_FINALIZE(stmt);
781 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
784 _media_info_item_get_detail(stmt, (media_info_h)_media);
786 if (callback(playlist_member_id, (media_info_h)_media, user_data) == false) {
787 media_info_destroy((media_info_h)_media);
790 media_info_destroy((media_info_h)_media);
794 SQLITE3_FINALIZE(stmt);
799 int _media_db_get_tag(const char *media_id, filter_h filter, media_tag_cb callback, void *user_data)
801 int ret = MEDIA_CONTENT_ERROR_NONE;
802 char *select_query = NULL;
803 char *condition_query = NULL;
804 char *option_query = NULL;
805 sqlite3_stmt *stmt = NULL;
807 if (STRING_VALID(media_id))
808 select_query = g_strdup_printf(SELECT_TAG_LIST_BY_MEDIA_ID, media_id);
810 select_query = g_strdup(SELECT_TAG_LIST);
812 ret = __media_db_make_query(filter, &condition_query, &option_query);
813 if (ret != MEDIA_CONTENT_ERROR_NONE) {
814 g_free(select_query);
818 ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
819 g_free(select_query);
820 g_free(condition_query);
821 g_free(option_query);
822 media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
824 while (sqlite3_step(stmt) == SQLITE_ROW) {
825 media_tag_s *_tag = (media_tag_s*)calloc(1, sizeof(media_tag_s));
828 media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
829 SQLITE3_FINALIZE(stmt);
830 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
833 _tag->tag_id = sqlite3_column_int(stmt, 0);
834 _tag->name = g_strdup((const char *)sqlite3_column_text(stmt, 1));
836 if (callback((media_tag_h)_tag, user_data) == false) {
837 media_tag_destroy((media_tag_h)_tag);
840 media_tag_destroy((media_tag_h)_tag);
843 SQLITE3_FINALIZE(stmt);
848 int _media_db_get_bookmark(const char *media_id, filter_h filter, media_bookmark_cb callback, void *user_data)
850 int ret = MEDIA_CONTENT_ERROR_NONE;
851 char select_query[MAX_QUERY_SIZE] = {0, };
852 char *condition_query = NULL;
853 char *option_query = NULL;
854 sqlite3_stmt *stmt = NULL;
855 filter_s *_filter = (filter_s *)filter;
857 memset(select_query, 0x00, sizeof(select_query));
858 #ifdef _USE_TVPD_MODE
859 if (STRING_VALID(media_id)) { //get bookmark by media_id
860 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
861 snprintf(select_query, sizeof(select_query), SELECT_BOOKMARK_LIST_BY_MEDIA_ID, _filter->storage_id, media_id);
863 snprintf(select_query, sizeof(select_query), SELECT_BOOKMARK_LIST_BY_MEDIA_ID, DB_VIEW_MEDIA, media_id);
865 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
866 snprintf(select_query, sizeof(select_query), SELECT_BOOKMARK_LIST, _filter->storage_id);
868 snprintf(select_query, sizeof(select_query), SELECT_BOOKMARK_LIST, DB_VIEW_MEDIA);
871 if (STRING_VALID(media_id)) { //get bookmark by media_id
872 snprintf(select_query, sizeof(select_query), SELECT_BOOKMARK_LIST_BY_MEDIA_ID, media_id);
874 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
875 snprintf(select_query, sizeof(select_query), SELECT_BOOKMARK_LIST_BY_STORAGE_ID, _filter->storage_id);
877 snprintf(select_query, sizeof(select_query), SELECT_BOOKMARK_LIST);
881 ret = __media_db_make_query(filter, &condition_query, &option_query);
882 media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
884 ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
885 SAFE_FREE(condition_query);
886 SAFE_FREE(option_query);
887 media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
889 while (sqlite3_step(stmt) == SQLITE_ROW) {
890 media_bookmark_s *bookmark = (media_bookmark_s*)calloc(1, sizeof(media_bookmark_s));
892 if (bookmark == NULL) {
893 media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
894 SQLITE3_FINALIZE(stmt);
895 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
898 bookmark->bookmark_id = sqlite3_column_int(stmt, 0);
899 bookmark->media_id = g_strdup((const char *)sqlite3_column_text(stmt, 1));
900 bookmark->marked_time = sqlite3_column_int(stmt, 2);
901 bookmark->thumbnail_path = g_strdup((const char *)sqlite3_column_text(stmt, 3));
902 bookmark->name = g_strdup((const char *)sqlite3_column_text(stmt, 4));
904 if (callback((media_bookmark_h)bookmark, user_data) == false) {
905 media_bookmark_destroy((media_bookmark_h)bookmark);
909 media_bookmark_destroy((media_bookmark_h)bookmark);
912 SQLITE3_FINALIZE(stmt);
918 int _media_db_get_face(const char *media_id, filter_h filter, media_face_cb callback, void *user_data)
920 int ret = MEDIA_CONTENT_ERROR_NONE;
921 char select_query[MAX_QUERY_SIZE] = {0, };
922 char *condition_query = NULL;
923 char *option_query = NULL;
924 sqlite3_stmt *stmt = NULL;
925 filter_s *_filter = (filter_s *)filter;
927 memset(select_query, 0x00, sizeof(select_query));
928 #ifdef _USE_TVPD_MODE
929 if (STRING_VALID(media_id)) { //get face by media_id
930 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
931 snprintf(select_query, sizeof(select_query), SELECT_FACE_LIST_BY_MEDIA_ID, _filter->storage_id, media_id);
933 snprintf(select_query, sizeof(select_query), SELECT_FACE_LIST_BY_MEDIA_ID, DB_VIEW_MEDIA, media_id);
935 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
936 snprintf(select_query, sizeof(select_query), SELECT_FACE_LIST, _filter->storage_id);
938 snprintf(select_query, sizeof(select_query), SELECT_FACE_LIST, DB_VIEW_MEDIA);
941 if (STRING_VALID(media_id)) { //get face by media_id
942 snprintf(select_query, sizeof(select_query), SELECT_FACE_LIST_BY_MEDIA_ID, media_id);
944 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
945 snprintf(select_query, sizeof(select_query), SELECT_FACE_LIST_BY_STORAGE_ID, _filter->storage_id);
947 snprintf(select_query, sizeof(select_query), SELECT_FACE_LIST);
950 ret = __media_db_make_query(filter, &condition_query, &option_query);
951 media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
953 ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
954 SAFE_FREE(condition_query);
955 SAFE_FREE(option_query);
956 media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
958 while (sqlite3_step(stmt) == SQLITE_ROW) {
959 media_face_s *face = (media_face_s*)calloc(1, sizeof(media_face_s));
962 media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
963 SQLITE3_FINALIZE(stmt);
964 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
967 face->face_id = sqlite3_column_int(stmt, 0);
968 face->media_id = g_strdup((const char *)sqlite3_column_text(stmt, 1));
969 face->face_rect_x = sqlite3_column_int(stmt, 2);
970 face->face_rect_y = sqlite3_column_int(stmt, 3);
971 face->face_rect_w = sqlite3_column_int(stmt, 4);
972 face->face_rect_h = sqlite3_column_int(stmt, 5);
973 face->orientation = sqlite3_column_int(stmt, 6);
974 face->face_tag = g_strdup((const char *)sqlite3_column_text(stmt, 7));
976 if (callback((media_face_h)face, user_data) == false) {
977 media_face_destroy((media_face_h)face);
981 media_face_destroy((media_face_h)face);
984 SQLITE3_FINALIZE(stmt);
990 int _media_db_get_group_item_count_by_id(int group_id, filter_h filter, group_list_e group_type, int *item_count)
992 int ret = MEDIA_CONTENT_ERROR_NONE;
993 sqlite3_stmt *stmt = NULL;
994 char select_query[MAX_QUERY_SIZE] = {0, };
995 char *condition_query = NULL;
996 char *option_query = NULL;
997 filter_s *_filter = (filter_s *)filter;
999 memset(select_query, 0x00, sizeof(select_query));
1001 if (group_type == MEDIA_GROUP_ALBUM) {
1002 #ifdef _USE_TVPD_MODE
1003 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
1004 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_COUNT_FROM_ALBUM, _filter->storage_id, group_id);
1006 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_COUNT_FROM_ALBUM, DB_VIEW_MEDIA, group_id);
1008 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
1009 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_COUNT_FROM_ALBUM_BY_STORAGE_ID, group_id, _filter->storage_id);
1011 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_COUNT_FROM_ALBUM, group_id);
1013 } else if (group_type == MEDIA_GROUP_PLAYLIST) {
1014 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_COUNT_FROM_PLAYLIST, group_id);
1015 } else if (group_type == MEDIA_GROUP_TAG) {
1016 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_COUNT_FROM_TAG, group_id);
1018 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
1019 return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
1022 ret = __media_db_make_query(filter, &condition_query, &option_query);
1023 media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
1025 ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
1026 SAFE_FREE(condition_query);
1027 SAFE_FREE(option_query);
1028 media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
1030 if (sqlite3_step(stmt) == SQLITE_ROW)
1031 *item_count = sqlite3_column_int(stmt, 0);
1033 SQLITE3_FINALIZE(stmt);
1038 int _media_db_get_group_item_count(const char *group_name, filter_h filter, group_list_e group_type, int *item_count)
1040 int ret = MEDIA_CONTENT_ERROR_NONE;
1041 sqlite3_stmt *stmt = NULL;
1042 char select_query[MAX_QUERY_SIZE] = {0, };
1043 char *condition_query = NULL;
1044 char *option_query = NULL;
1045 char *tmp_option = NULL;
1046 bool need_bracket = false;
1047 filter_s *_filter = (filter_s *)filter;
1049 memset(select_query, 0x00, sizeof(select_query));
1051 if (group_type == MEDIA_GROUP_NONE) {
1052 /* There are 2 ways to get count for media table for performance
1053 If user wants to set offset and count, use SQL SELECT_MEDIA_COUNT_FROM_MEDIA.
1054 If user wants to get count without setting count, SELECT_MEDIA_COUNT_FROM_MEDIA_SIMPLE */
1056 if (_filter->offset < 0 && _filter->count < 0) {
1057 #ifdef _USE_TVPD_MODE
1058 if (STRING_VALID(_filter->storage_id))
1059 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_COUNT_FROM_MEDIA_SIMPLE, _filter->storage_id);
1061 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_COUNT_FROM_MEDIA_SIMPLE, DB_VIEW_MEDIA);
1063 if (STRING_VALID(_filter->storage_id))
1064 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_COUNT_FROM_MEDIA_SIMPLE_BY_STORAGE_ID, _filter->storage_id);
1066 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_COUNT_FROM_MEDIA_SIMPLE);
1069 #ifdef _USE_TVPD_MODE
1070 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_COUNT_FROM_MEDIA, DB_VIEW_MEDIA);
1072 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_COUNT_FROM_MEDIA);
1074 need_bracket = true;
1077 #ifdef _USE_TVPD_MODE
1078 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_COUNT_FROM_MEDIA_SIMPLE, DB_VIEW_MEDIA);
1080 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_COUNT_FROM_MEDIA_SIMPLE);
1083 } else if (group_type == MEDIA_GROUP_FOLDER) {
1084 #ifdef _USE_TVPD_MODE
1085 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
1086 sqlite3_snprintf(sizeof(select_query), select_query, SELECT_MEDIA_COUNT_FROM_FOLDER, _filter->storage_id, group_name);
1088 sqlite3_snprintf(sizeof(select_query), select_query, SELECT_MEDIA_COUNT_FROM_FOLDER, DB_VIEW_MEDIA, group_name);
1090 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
1091 sqlite3_snprintf(sizeof(select_query), select_query, SELECT_MEDIA_COUNT_FROM_FOLDER_BY_STORAGE_ID, group_name, _filter->storage_id);
1093 sqlite3_snprintf(sizeof(select_query), select_query, SELECT_MEDIA_COUNT_FROM_FOLDER, group_name);
1096 } else if (group_type == MEDIA_GROUP_TAG_BY_MEDIA_ID) {
1097 snprintf(select_query, sizeof(select_query), SELECT_TAG_COUNT_BY_MEDIA_ID, group_name);
1098 } else if (group_type == MEDIA_GROUP_BOOKMARK_BY_MEDIA_ID) {
1099 #ifdef _USE_TVPD_MODE
1100 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
1101 sqlite3_snprintf(sizeof(select_query), select_query, SELECT_BOOKMARK_COUNT_BY_MEDIA_ID, _filter->storage_id, group_name);
1103 sqlite3_snprintf(sizeof(select_query), select_query, SELECT_BOOKMARK_COUNT_BY_MEDIA_ID, DB_VIEW_MEDIA, group_name);
1105 sqlite3_snprintf(sizeof(select_query), select_query, SELECT_BOOKMARK_COUNT_BY_MEDIA_ID, group_name);
1108 } else if (group_type == MEDIA_GROUP_STORAGE) {
1109 #ifdef _USE_TVPD_MODE
1110 sqlite3_snprintf(sizeof(select_query), select_query, SELECT_MEDIA_COUNT_FROM_STORAGE, group_name, group_name);
1112 sqlite3_snprintf(sizeof(select_query), select_query, SELECT_MEDIA_COUNT_FROM_STORAGE, group_name);
1115 } else if (group_type == MEDIA_GROUP_FACE_BY_MEDIA_ID) {
1116 #ifdef _USE_TVPD_MODE
1117 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
1118 sqlite3_snprintf(sizeof(select_query), select_query, SELECT_FACE_COUNT_BY_MEDIA_ID, _filter->storage_id, group_name);
1120 sqlite3_snprintf(sizeof(select_query), select_query, SELECT_FACE_COUNT_BY_MEDIA_ID, DB_VIEW_MEDIA, group_name);
1122 sqlite3_snprintf(sizeof(select_query), select_query, SELECT_FACE_COUNT_BY_MEDIA_ID, group_name);
1125 #ifdef _USE_TVPD_MODE
1126 } else if (group_type == MEDIA_GROUP_PVR) {
1127 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
1128 snprintf(select_query, sizeof(select_query), SELECT_PVR_COUNT_BY_STORAGE_ID, _filter->storage_id);
1130 SAFE_STRLCAT(select_query, SELECT_PVR_COUNT, sizeof(select_query));
1131 } else if (group_type == MEDIA_GROUP_UHD) {
1132 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
1133 snprintf(select_query, sizeof(select_query), SELECT_UHD_COUNT_BY_STORAGE_ID, _filter->storage_id);
1135 SAFE_STRLCAT(select_query, SELECT_UHD_COUNT, sizeof(select_query));
1138 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
1139 return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
1142 ret = __media_db_make_query(filter, &condition_query, &option_query);
1143 media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
1146 tmp_option = g_strconcat(option_query, ")", NULL);
1147 g_free(option_query);
1148 option_query = tmp_option;
1151 ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
1152 SAFE_FREE(condition_query);
1153 SAFE_FREE(option_query);
1154 media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
1156 if (sqlite3_step(stmt) == SQLITE_ROW)
1157 *item_count = sqlite3_column_int(stmt, 0);
1159 SQLITE3_FINALIZE(stmt);
1164 int _media_db_get_group_item_by_id(int group_id, filter_h filter, media_info_cb callback, void *user_data, group_list_e group_type)
1166 int ret = MEDIA_CONTENT_ERROR_NONE;
1167 char select_query[MAX_QUERY_SIZE] = {0, };
1168 char *condition_query = NULL;
1169 char *option_query = NULL;
1170 sqlite3_stmt *stmt = NULL;
1171 filter_s *_filter = (filter_s *)filter;
1173 memset(select_query, 0x00, sizeof(select_query));
1175 #ifdef _USE_TVPD_MODE
1176 if (group_type == MEDIA_GROUP_ALBUM) {
1177 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
1178 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_FROM_ALBUM, _filter->storage_id, group_id);
1180 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_FROM_ALBUM, DB_VIEW_MEDIA, group_id);
1181 } else if (group_type == MEDIA_GROUP_PLAYLIST) {
1182 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
1183 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_FROM_PLAYLIST, _filter->storage_id, group_id);
1185 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_FROM_PLAYLIST, DB_VIEW_MEDIA, group_id);
1186 } else if (group_type == MEDIA_GROUP_TAG) {
1187 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
1188 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_FROM_TAG, _filter->storage_id, group_id);
1190 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_FROM_TAG, DB_VIEW_MEDIA, group_id);
1192 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
1193 return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
1196 if (group_type == MEDIA_GROUP_ALBUM) {
1197 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
1198 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_FROM_ALBUM_BY_STORAGE_ID, group_id, _filter->storage_id);
1200 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_FROM_ALBUM, group_id);
1201 } else if (group_type == MEDIA_GROUP_PLAYLIST) {
1202 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
1203 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_FROM_PLAYLIST_BY_STORAGE_ID, group_id, _filter->storage_id);
1205 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_FROM_PLAYLIST, group_id);
1206 } else if (group_type == MEDIA_GROUP_TAG) {
1207 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
1208 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_FROM_TAG_BY_STORAGE_ID, group_id, _filter->storage_id);
1210 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_FROM_TAG, group_id);
1212 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
1213 return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
1216 ret = __media_db_make_query(filter, &condition_query, &option_query);
1217 media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
1219 ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
1220 SAFE_FREE(condition_query);
1221 SAFE_FREE(option_query);
1222 media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
1224 while (sqlite3_step(stmt) == SQLITE_ROW) {
1225 media_info_s *item = (media_info_s*)calloc(1, sizeof(media_info_s));
1227 media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
1228 SQLITE3_FINALIZE(stmt);
1229 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
1232 _media_info_item_get_detail(stmt, (media_info_h)item);
1234 if (callback((media_info_h)item, user_data) == false) {
1235 media_info_destroy((media_info_h)item);
1239 media_info_destroy((media_info_h)item);
1242 SQLITE3_FINALIZE(stmt);
1247 int _media_db_get_group_item(const char *group_name, filter_h filter, media_info_cb callback, void *user_data, group_list_e group_type)
1249 int ret = MEDIA_CONTENT_ERROR_NONE;
1250 char select_query[MAX_QUERY_SIZE] = {0, };
1251 char *condition_query = NULL;
1252 char *option_query = NULL;
1253 sqlite3_stmt *stmt = NULL;
1254 filter_s *_filter = (filter_s *)filter;
1256 memset(select_query, 0x00, sizeof(select_query));
1257 #ifdef _USE_TVPD_MODE
1258 if (group_type == MEDIA_GROUP_NONE) {
1259 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
1260 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_ITEM, _filter->storage_id);
1262 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_ITEM, DB_VIEW_MEDIA);
1263 } else if (group_type == MEDIA_GROUP_FOLDER) {
1264 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
1265 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_FROM_FOLDER, _filter->storage_id, group_name);
1267 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_FROM_FOLDER, DB_VIEW_MEDIA, group_name);
1268 } else if (group_type == MEDIA_GROUP_STORAGE) {
1269 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_FROM_STORAGE, group_name, group_name);
1271 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
1272 return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
1275 if (group_type == MEDIA_GROUP_NONE) {
1276 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
1277 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_ITEM_BY_STORAGE_ID, _filter->storage_id);
1279 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_ITEM);
1280 } else if (group_type == MEDIA_GROUP_FOLDER) {
1281 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_FROM_FOLDER, group_name);
1282 } else if (group_type == MEDIA_GROUP_STORAGE) {
1283 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_FROM_STORAGE, group_name);
1285 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
1286 return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
1289 ret = __media_db_make_query(filter, &condition_query, &option_query);
1290 media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
1292 ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
1293 SAFE_FREE(condition_query);
1294 SAFE_FREE(option_query);
1295 media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
1297 while (sqlite3_step(stmt) == SQLITE_ROW) {
1298 media_info_s *item = (media_info_s*)calloc(1, sizeof(media_info_s));
1300 media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
1301 SQLITE3_FINALIZE(stmt);
1302 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
1305 _media_info_item_get_detail(stmt, (media_info_h)item);
1307 if (callback((media_info_h)item, user_data) == false) {
1308 media_info_destroy((media_info_h)item);
1312 media_info_destroy((media_info_h)item);
1315 SQLITE3_FINALIZE(stmt);
1320 #ifdef _USE_SENIOR_MODE
1321 int _media_db_get_group_item_by_union_select(const char *group_name, filter_h filter1, filter_h filter2, media_info_cb callback, void *user_data)
1323 int ret = MEDIA_CONTENT_ERROR_NONE;
1324 char select_query1[MAX_QUERY_SIZE] = {0, };
1325 char *condition_query1 = NULL;
1326 char *option_query1 = NULL;
1327 char select_query2[MAX_QUERY_SIZE] = {0, };
1328 char *condition_query2 = NULL;
1329 char *option_query2 = NULL;
1330 sqlite3_stmt *stmt = NULL;
1331 filter_s *_filter1 = (filter_s *)filter1;
1332 filter_s *_filter2 = (filter_s *)filter2;
1334 memset(select_query1, 0x00, sizeof(select_query1));
1336 if ((_filter1 != NULL) && STRING_VALID(_filter1->storage_id))
1337 snprintf(select_query1, sizeof(select_query1), SELECT_MEDIA_FROM_FOLDER, _filter1->storage_id, group_name);
1339 snprintf(select_query1, sizeof(select_query1), SELECT_MEDIA_FROM_FOLDER, DB_VIEW_MEDIA, group_name);
1341 ret = __media_db_make_query(filter, &condition_query, &option_query);
1342 if (ret != MEDIA_CONTENT_ERROR_NONE) {
1343 SAFE_FREE(condition_query1);
1344 SAFE_FREE(option_query1);
1345 media_content_error("create select_query1 failed");
1349 memset(select_query2, 0x00, sizeof(select_query2));
1351 if ((_filter2 != NULL) && STRING_VALID(_filter2->storage_id))
1352 snprintf(select_query2, sizeof(select_query2), SELECT_MEDIA_FROM_FOLDER, _filter2->storage_id, group_name);
1354 snprintf(select_query2, sizeof(select_query2), SELECT_MEDIA_FROM_FOLDER, DB_VIEW_MEDIA, group_name);
1356 ret = __media_db_make_query(filter, &condition_query, &option_query);
1357 if (ret != MEDIA_CONTENT_ERROR_NONE) {
1358 SAFE_FREE(condition_query1);
1359 SAFE_FREE(option_query1);
1360 SAFE_FREE(condition_query2);
1361 SAFE_FREE(option_query2);
1362 media_content_error("create select_query2 failed");
1366 ret = _content_query_prepare_by_union_select(&stmt, select_query1, condition_query1, option_query1, select_query2, condition_query2, option_query2);
1367 SAFE_FREE(condition_query1);
1368 SAFE_FREE(option_query1);
1369 SAFE_FREE(condition_query2);
1370 SAFE_FREE(option_query2);
1371 media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
1373 while (sqlite3_step(stmt) == SQLITE_ROW) {
1374 media_info_s *item = (media_info_s*)calloc(1, sizeof(media_info_s));
1376 media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
1377 SQLITE3_FINALIZE(stmt);
1378 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
1381 _media_info_item_get_detail(stmt, (media_info_h)item);
1383 if (callback((media_info_h)item, user_data) == false) {
1384 media_info_destroy((media_info_h)item);
1388 media_info_destroy((media_info_h)item);
1391 SQLITE3_FINALIZE(stmt);
1397 int _media_db_get_media_group_item_count(const char *group_name, filter_h filter, media_group_e group, int *item_count)
1399 int ret = MEDIA_CONTENT_ERROR_NONE;
1400 sqlite3_stmt *stmt = NULL;
1401 char select_query[MAX_QUERY_SIZE] = {0, };
1402 char *tmp_option = NULL;
1403 char *condition_query = NULL;
1404 char *option_query = NULL;
1405 filter_s *_filter = (filter_s *)filter;
1407 memset(select_query, 0x00, sizeof(select_query));
1408 #ifdef _USE_TVPD_MODE
1409 if (group < MEDIA_PVR_GROUP_DURATION) { /*media content */
1410 if (group_name != NULL) {
1411 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
1412 sqlite3_snprintf(sizeof(select_query), select_query, SELECT_MEDIA_COUNT_FROM_GROUP, _filter->storage_id, __media_db_get_group_name(group), group_name);
1414 sqlite3_snprintf(sizeof(select_query), select_query, SELECT_MEDIA_COUNT_FROM_GROUP, DB_VIEW_MEDIA, __media_db_get_group_name(group), group_name);
1418 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
1419 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_COUNT_FROM_GROUP_NULL, _filter->storage_id, __media_db_get_group_name(group));
1421 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_COUNT_FROM_GROUP_NULL, DB_VIEW_MEDIA, __media_db_get_group_name(group));
1423 } else if (group < MEDIA_UHD_GROUP_CONTENT_TITLE) {/*pvr content*/
1424 if (group_name != NULL) {
1425 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
1426 sqlite3_snprintf(sizeof(select_query), select_query, SELECT_PVR_COUNT_FROM_GROUP_BY_STORAGE_ID, _filter->storage_id, __media_db_get_group_name(group), group_name);
1428 sqlite3_snprintf(sizeof(select_query), select_query, SELECT_PVR_COUNT_FROM_GROUP, __media_db_get_group_name(group), group_name);
1432 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
1433 snprintf(select_query, sizeof(select_query), SELECT_PVR_COUNT_FROM_GROUP_NULL_BY_STORAGE_ID, _filter->storage_id, __media_db_get_group_name(group));
1435 snprintf(select_query, sizeof(select_query), SELECT_PVR_COUNT_FROM_GROUP_NULL, __media_db_get_group_name(group));
1437 } else {/*uhd content*/
1438 if (group_name != NULL) {
1439 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
1440 sqlite3_snprintf(sizeof(select_query), select_query, SELECT_UHD_COUNT_FROM_GROUP_BY_STORAGE_ID, _filter->storage_id, __media_db_get_group_name(group), group_name);
1442 sqlite3_snprintf(sizeof(select_query), select_query, SELECT_UHD_COUNT_FROM_GROUP, __media_db_get_group_name(group), group_name);
1446 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
1447 snprintf(select_query, sizeof(select_query), SELECT_UHD_COUNT_FROM_GROUP_NULL_BY_STORAGE_ID, _filter->storage_id, __media_db_get_group_name(group));
1449 snprintf(select_query, sizeof(select_query), SELECT_UHD_COUNT_FROM_GROUP_NULL, __media_db_get_group_name(group));
1453 if (group_name != NULL) {
1454 if ((_filter != NULL) && STRING_VALID(_filter->storage_id)) {
1455 sqlite3_snprintf(sizeof(select_query), select_query, SELECT_MEDIA_COUNT_FROM_GROUP_BY_STORAGE_ID, __media_db_get_group_name(group), group_name, _filter->storage_id);
1458 sqlite3_snprintf(sizeof(select_query), select_query, SELECT_MEDIA_COUNT_FROM_GROUP, __media_db_get_group_name(group), group_name);
1462 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
1463 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_COUNT_FROM_GROUP_NULL_BY_STORAGE_ID, __media_db_get_group_name(group), _filter->storage_id);
1465 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_COUNT_FROM_GROUP_NULL, __media_db_get_group_name(group));
1469 ret = __media_db_make_query(filter, &condition_query, &option_query);
1470 media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
1473 tmp_option = g_strconcat(option_query, ")", NULL);
1474 g_free(option_query);
1475 option_query = tmp_option;
1477 SAFE_STRLCAT(select_query, ")", sizeof(select_query));
1480 ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
1481 SAFE_FREE(condition_query);
1482 SAFE_FREE(option_query);
1483 media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
1485 if (sqlite3_step(stmt) == SQLITE_ROW)
1486 *item_count = sqlite3_column_int(stmt, 0);
1488 SQLITE3_FINALIZE(stmt);
1493 int _media_db_get_media_group_item(const char *group_name, filter_h filter, media_group_e group, media_info_cb callback, void *user_data)
1495 int ret = MEDIA_CONTENT_ERROR_NONE;
1496 char select_query[MAX_QUERY_SIZE] = {0, };
1497 char *condition_query = NULL;
1498 char *option_query = NULL;
1499 sqlite3_stmt *stmt = NULL;
1500 filter_s *_filter = (filter_s *)filter;
1502 memset(select_query, 0x00, sizeof(select_query));
1503 #ifdef _USE_TVPD_MODE
1504 if (group_name != NULL) {
1505 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
1506 sqlite3_snprintf(sizeof(select_query), select_query, SELECT_MEDIA_FROM_GROUP, _filter->storage_id, __media_db_get_group_name(group), group_name);
1508 sqlite3_snprintf(sizeof(select_query), select_query, SELECT_MEDIA_FROM_GROUP, DB_VIEW_MEDIA, __media_db_get_group_name(group), group_name);
1512 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
1513 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_FROM_GROUP_NULL, _filter->storage_id, __media_db_get_group_name(group));
1515 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_FROM_GROUP_NULL, DB_VIEW_MEDIA, __media_db_get_group_name(group));
1518 if (group_name != NULL) {
1519 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
1520 sqlite3_snprintf(sizeof(select_query), select_query, SELECT_MEDIA_FROM_GROUP_BY_STORAGE_ID, __media_db_get_group_name(group), group_name, _filter->storage_id);
1522 sqlite3_snprintf(sizeof(select_query), select_query, SELECT_MEDIA_FROM_GROUP, __media_db_get_group_name(group), group_name);
1526 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
1527 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_FROM_GROUP_NULL_BY_STORAGE_ID, __media_db_get_group_name(group), _filter->storage_id);
1529 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_FROM_GROUP_NULL, __media_db_get_group_name(group));
1532 ret = __media_db_make_query(filter, &condition_query, &option_query);
1533 media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
1535 ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
1536 SAFE_FREE(condition_query);
1537 SAFE_FREE(option_query);
1538 media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
1540 while (sqlite3_step(stmt) == SQLITE_ROW) {
1541 media_info_s *item = (media_info_s*)calloc(1, sizeof(media_info_s));
1543 media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
1544 SQLITE3_FINALIZE(stmt);
1545 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
1548 _media_info_item_get_detail(stmt, (media_info_h)item);
1550 if (callback((media_info_h)item, user_data) == false) {
1551 media_info_destroy((media_info_h)item);
1555 media_info_destroy((media_info_h)item);
1558 SQLITE3_FINALIZE(stmt);
1563 int _media_db_get_storage(filter_h filter, media_storage_cb callback, void *user_data)
1565 int ret = MEDIA_CONTENT_ERROR_NONE;
1566 char *condition_query = NULL;
1567 char *option_query = NULL;
1568 sqlite3_stmt *stmt = NULL;
1570 ret = __media_db_make_query(filter, &condition_query, &option_query);
1571 media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
1573 ret = _content_query_prepare(SELECT_STORAGE_LIST, condition_query, option_query, &stmt);
1574 SAFE_FREE(condition_query);
1575 SAFE_FREE(option_query);
1576 media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
1578 while (sqlite3_step(stmt) == SQLITE_ROW) {
1579 media_storage_s *_storage = (media_storage_s*)calloc(1, sizeof(media_storage_s));
1581 if (_storage == NULL) {
1582 media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
1583 SQLITE3_FINALIZE(stmt);
1584 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
1587 _storage->storage_id = g_strdup((const char *)sqlite3_column_text(stmt, 0));
1588 _storage->storage_path = g_strdup((const char *)sqlite3_column_text(stmt, 1));
1589 _storage->storage_type = sqlite3_column_int(stmt, 2);
1591 if (callback((media_storage_h)_storage, user_data) == false) {
1592 media_storage_destroy((media_storage_h) _storage);
1596 media_storage_destroy((media_storage_h) _storage);
1599 SQLITE3_FINALIZE(stmt);
1604 int _media_db_get_storage_id_by_media_id(const char *media_id, char **storage_id)
1606 int ret = MEDIA_CONTENT_ERROR_NONE;
1607 sqlite3_stmt *stmt = NULL;
1608 char *select_query = NULL;
1610 select_query = sqlite3_mprintf(SELECT_MEDIA_STORAGE_ID_BY_ID, media_id);
1612 ret = _content_get_result(select_query, &stmt);
1613 SQLITE3_SAFE_FREE(select_query);
1614 media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
1616 if (sqlite3_step(stmt) == SQLITE_ROW) {
1617 *storage_id = g_strdup((const char *)sqlite3_column_text(stmt, 0));
1619 media_content_error("Invalid media_id[%s]", media_id);
1620 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
1623 SQLITE3_FINALIZE(stmt);
1628 #ifdef _USE_TVPD_MODE
1629 int _media_db_get_pvr_group_item(const char *group_name, filter_h filter, media_group_e group, media_pvr_cb callback, void *user_data)
1631 int ret = MEDIA_CONTENT_ERROR_NONE;
1632 char select_query[DEFAULT_QUERY_SIZE] = {0, };
1633 char *condition_query = NULL;
1634 char *option_query = NULL;
1635 sqlite3_stmt *stmt = NULL;
1636 filter_s *_filter = (filter_s *)filter;
1638 memset(select_query, 0x00, sizeof(select_query));
1640 if (group_name != NULL) {
1641 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
1642 sqlite3_snprintf(sizeof(select_query), select_query, SELECT_PVR_FROM_GROUP_BY_STORAGE_ID, _filter->storage_id, __media_db_get_group_name(group), group_name);
1644 sqlite3_snprintf(sizeof(select_query), select_query, SELECT_PVR_FROM_GROUP, __media_db_get_group_name(group), group_name);
1648 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
1649 snprintf(select_query, sizeof(select_query), SELECT_PVR_FROM_GROUP_NULL_BY_STORAGE_ID, _filter->storage_id, __media_db_get_group_name(group));
1651 snprintf(select_query, sizeof(select_query), SELECT_PVR_FROM_GROUP_NULL, __media_db_get_group_name(group));
1654 ret = __media_db_make_query(filter, &condition_query, &option_query);
1655 media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
1657 ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
1658 SAFE_FREE(condition_query);
1659 SAFE_FREE(option_query);
1660 media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
1662 while (sqlite3_step(stmt) == SQLITE_ROW) {
1663 media_pvr_s *item = (media_pvr_s*)calloc(1, sizeof(media_pvr_s));
1665 media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
1666 SQLITE3_FINALIZE(stmt);
1667 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
1670 _media_pvr_item_get_detail(stmt, (media_pvr_h)item);
1672 if (callback((media_pvr_h)item, user_data) == false) {
1673 media_info_destroy((media_pvr_h)item);
1677 media_pvr_destroy((media_pvr_h)item);
1680 SQLITE3_FINALIZE(stmt);
1686 MEDIA_PVR_MEDIA_ID = 0,
1687 MEDIA_PVR_STORAGE_ID,
1691 MEDIA_PVR_TIME_ZONE,
1695 MEDIA_PVR_CHANNEL_TYPE,
1696 MEDIA_PVR_CHANNEL_NAME,
1697 MEDIA_PVR_CHANNEL_NUM,
1698 MEDIA_PVR_SERVICE_PROFILE,
1699 MEDIA_PVR_PROGRAM_TITLE,
1700 MEDIA_PVR_PROGRAM_NUM,
1701 MEDIA_PVR_PROGRAM_CRID,
1706 MEDIA_PVR_EMBARGO_TIME,
1707 MEDIA_PVR_EXPIRY_TIME,
1708 MEDIA_PVR_START_TIME,
1709 MEDIA_PVR_PROGRAM_START_TIME,
1710 MEDIA_PVR_PROGRAM_END_TIME,
1711 MEDIA_PVR_PROGRAM_DATE,
1712 MEDIA_PVR_PARENTAL_RATING,
1713 MEDIA_PVR_TIMER_RECORD,
1714 MEDIA_PVR_SERIES_RECORD,
1719 MEDIA_PVR_HARDOF_HEARINGRADIO,
1720 MEDIA_PVR_DATA_SERVICE,
1721 MEDIA_PVR_CONTENT_LOCK,
1722 MEDIA_PVR_CONTENT_WATCH,
1723 MEDIA_PVR_HAS_AUDIO_ONLY,
1724 MEDIA_PVR_IS_LOCAL_RECORDED,
1725 MEDIA_PVR_RESOLUTION,
1726 MEDIA_PVR_ASPECTRATIO,
1727 MEDIA_PVR_MODIFIED_MONTH,
1728 MEDIA_PVR_SPORTS_TYPE,
1729 MEDIA_PVR_GUIDANCE_LENGTH,
1731 MEDIA_PVR_PLAY_COUNT,
1732 MEDIA_PVR_PRIVATE_DATA,
1733 MEDIA_PVR_HIGHLIGHT,
1734 } media_pvr_field_e;
1736 void _media_pvr_item_get_detail(sqlite3_stmt* stmt, media_pvr_h pvr)
1738 media_pvr_s *_pvr = (media_pvr_s*)pvr;
1740 if (STRING_VALID((const char *)sqlite3_column_text(stmt, MEDIA_PVR_MEDIA_ID)))
1741 _pvr->media_id = strdup((const char *)sqlite3_column_text(stmt, MEDIA_PVR_MEDIA_ID));
1743 if (STRING_VALID((const char *)sqlite3_column_text(stmt, MEDIA_PVR_STORAGE_ID)))
1744 _pvr->storage_id = strdup((const char *)sqlite3_column_text(stmt, MEDIA_PVR_STORAGE_ID));
1746 if (STRING_VALID((const char *)sqlite3_column_text(stmt, MEDIA_PVR_PATH)))
1747 _pvr->path = strdup((const char *)sqlite3_column_text(stmt, MEDIA_PVR_PATH));
1749 _pvr->size = (unsigned long long)sqlite3_column_int64(stmt, MEDIA_PVR_SIZE);
1751 _pvr->duration = sqlite3_column_int(stmt, MEDIA_PVR_DURATION);
1753 _pvr->timezone = sqlite3_column_int(stmt, MEDIA_PVR_TIME_ZONE);
1755 _pvr->ptc = sqlite3_column_int(stmt, MEDIA_PVR_PTC);
1757 _pvr->major = sqlite3_column_int(stmt, MEDIA_PVR_MAJOR);
1759 _pvr->minor = sqlite3_column_int(stmt, MEDIA_PVR_MINOR);
1761 _pvr->channel_type = sqlite3_column_int(stmt, MEDIA_PVR_CHANNEL_TYPE);
1763 _pvr->service_profile = (unsigned int)sqlite3_column_int(stmt, MEDIA_PVR_SERVICE_PROFILE);
1765 if (STRING_VALID((const char *)sqlite3_column_text(stmt, MEDIA_PVR_CHANNEL_NAME)))
1766 _pvr->channel_name = strdup((const char *)sqlite3_column_text(stmt, MEDIA_PVR_CHANNEL_NAME));
1768 if (STRING_VALID((const char *)sqlite3_column_text(stmt, MEDIA_PVR_CHANNEL_NUM)))
1769 _pvr->channel_num = strdup((const char *)sqlite3_column_text(stmt, MEDIA_PVR_CHANNEL_NUM));
1771 if (STRING_VALID((const char *)sqlite3_column_text(stmt, MEDIA_PVR_PROGRAM_TITLE)))
1772 _pvr->program_title = strdup((const char *)sqlite3_column_text(stmt, MEDIA_PVR_PROGRAM_TITLE));
1774 _pvr->program_num = sqlite3_column_int(stmt, MEDIA_PVR_PROGRAM_NUM);
1776 if (STRING_VALID((const char *)sqlite3_column_text(stmt, MEDIA_PVR_PROGRAM_CRID)))
1777 _pvr->program_crid = strdup((const char *)sqlite3_column_text(stmt, MEDIA_PVR_PROGRAM_CRID));
1779 if (STRING_VALID((const char *)sqlite3_column_text(stmt, MEDIA_PVR_GUIDANCE)))
1780 _pvr->guidance = strdup((const char *)sqlite3_column_text(stmt, MEDIA_PVR_GUIDANCE));
1782 if (STRING_VALID((const char *)sqlite3_column_text(stmt, MEDIA_PVR_SYNOPSIS)))
1783 _pvr->synopsis = strdup((const char *)sqlite3_column_text(stmt, MEDIA_PVR_SYNOPSIS));
1785 if (STRING_VALID((const char *)sqlite3_column_text(stmt, MEDIA_PVR_GENRE)))
1786 _pvr->genre = strdup((const char *)sqlite3_column_text(stmt, MEDIA_PVR_GENRE));
1788 if (STRING_VALID((const char *)sqlite3_column_text(stmt, MEDIA_PVR_LANGUAGE)))
1789 _pvr->language = strdup((const char *)sqlite3_column_text(stmt, MEDIA_PVR_LANGUAGE));
1791 if (STRING_VALID((const char *)sqlite3_column_text(stmt, MEDIA_PVR_MODIFIED_MONTH)))
1792 _pvr->modified_month = strdup((const char *)sqlite3_column_text(stmt, MEDIA_PVR_MODIFIED_MONTH));
1794 if (STRING_VALID((const char *)sqlite3_column_text(stmt, MEDIA_PVR_PRIVATE_DATA)))
1795 _pvr->private_data = strdup((const char *)sqlite3_column_text(stmt, MEDIA_PVR_PRIVATE_DATA));
1797 _pvr->embargo_time = sqlite3_column_int(stmt, MEDIA_PVR_EMBARGO_TIME);
1799 _pvr->expiry_time = sqlite3_column_int(stmt, MEDIA_PVR_EXPIRY_TIME);
1801 _pvr->start_time = sqlite3_column_int(stmt, MEDIA_PVR_START_TIME);
1803 _pvr->program_start_time = sqlite3_column_int(stmt, MEDIA_PVR_PROGRAM_START_TIME);
1805 _pvr->program_end_time = sqlite3_column_int(stmt, MEDIA_PVR_PROGRAM_END_TIME);
1807 _pvr->program_date = sqlite3_column_int(stmt, MEDIA_PVR_PROGRAM_DATE);
1809 _pvr->parental_rating = sqlite3_column_int(stmt, MEDIA_PVR_PARENTAL_RATING);
1811 _pvr->timer_record = sqlite3_column_int(stmt, MEDIA_PVR_TIMER_RECORD);
1813 _pvr->series_record = sqlite3_column_int(stmt, MEDIA_PVR_SERIES_RECORD);
1815 _pvr->hd = sqlite3_column_int(stmt, MEDIA_PVR_HD);
1817 _pvr->subtitle = sqlite3_column_int(stmt, MEDIA_PVR_SUBTITLE);
1819 _pvr->ttx = sqlite3_column_int(stmt, MEDIA_PVR_TTX);
1821 _pvr->ad = sqlite3_column_int(stmt, MEDIA_PVR_AD);
1823 _pvr->hard_of_hearing_radio = sqlite3_column_int(stmt, MEDIA_PVR_HARDOF_HEARINGRADIO);
1825 _pvr->data_service = sqlite3_column_int(stmt, MEDIA_PVR_DATA_SERVICE);
1827 _pvr->content_lock = sqlite3_column_int(stmt, MEDIA_PVR_CONTENT_LOCK);
1829 _pvr->content_watch = sqlite3_column_int(stmt, MEDIA_PVR_CONTENT_WATCH);
1831 _pvr->has_audio_only = sqlite3_column_int(stmt, MEDIA_PVR_HAS_AUDIO_ONLY);
1833 _pvr->is_local_record = sqlite3_column_int(stmt, MEDIA_PVR_IS_LOCAL_RECORDED);
1835 _pvr->resolution = sqlite3_column_int(stmt, MEDIA_PVR_RESOLUTION);
1837 _pvr->aspectratio = sqlite3_column_int(stmt, MEDIA_PVR_ASPECTRATIO);
1839 _pvr->sports_type = sqlite3_column_int(stmt, MEDIA_PVR_SPORTS_TYPE);
1841 _pvr->guidance_length = sqlite3_column_int(stmt, MEDIA_PVR_GUIDANCE_LENGTH);
1843 _pvr->tvmode = sqlite3_column_int(stmt, MEDIA_PVR_TVMODE);
1845 _pvr->play_count = sqlite3_column_int(stmt, MEDIA_PVR_PLAY_COUNT);
1847 _pvr->highlight = sqlite3_column_int(stmt, MEDIA_PVR_HIGHLIGHT);
1852 int _media_db_get_pvr(filter_h filter, media_pvr_cb callback, void *user_data)
1854 int ret = MEDIA_CONTENT_ERROR_NONE;
1855 char select_query[DEFAULT_QUERY_SIZE] = {0, };
1856 char *condition_query = NULL;
1857 char *option_query = NULL;
1858 sqlite3_stmt *stmt = NULL;
1859 filter_s *_filter = (filter_s *)filter;
1861 memset(select_query, 0x00, sizeof(select_query));
1863 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
1864 snprintf(select_query, sizeof(select_query), SELECT_PVR_LIST_BY_STORAGE_ID, _filter->storage_id);
1866 SAFE_STRLCAT(select_query, SELECT_PVR_LIST, sizeof(select_query));
1868 ret = __media_db_make_query(filter, &condition_query, &option_query);
1869 media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
1871 ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
1872 SAFE_FREE(condition_query);
1873 SAFE_FREE(option_query);
1874 media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
1876 while (sqlite3_step(stmt) == SQLITE_ROW) {
1877 media_pvr_s *_pvr = (media_pvr_s*)calloc(1, sizeof(media_pvr_s));
1880 media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
1881 SQLITE3_FINALIZE(stmt);
1882 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
1885 _media_pvr_item_get_detail(stmt, (media_pvr_h)_pvr);
1887 if (callback((media_pvr_h)_pvr, user_data) == false) {
1888 media_pvr_destroy((media_pvr_h) _pvr);
1892 media_pvr_destroy((media_pvr_h) _pvr);
1895 SQLITE3_FINALIZE(stmt);
1901 MEDIA_UHD_MEDIA_ID = 0,
1902 MEDIA_UHD_STORAGE_ID,
1905 MEDIA_UHD_CONTENT_ID,
1906 MEDIA_UHD_CONTENT_TITLE,
1907 MEDIA_UHD_FILE_NAME,
1908 MEDIA_UHD_FOLDER_ID,
1909 MEDIA_UHD_RELEASE_DATE,
1910 MEDIA_UHD_MODIFIED_TIME,
1911 MEDIA_UHD_PLAYED_POSITION,
1913 MEDIA_UHD_PLAYED_COUNT,
1914 } media_uhd_field_e;
1916 void _media_uhd_item_get_detail(sqlite3_stmt* stmt, media_uhd_h uhd)
1918 media_uhd_s *_uhd = (media_uhd_s*)uhd;
1920 if (STRING_VALID((const char *)sqlite3_column_text(stmt, MEDIA_UHD_MEDIA_ID)))
1921 _uhd->media_id = strdup((const char *)sqlite3_column_text(stmt, MEDIA_UHD_MEDIA_ID));
1923 if (STRING_VALID((const char *)sqlite3_column_text(stmt, MEDIA_UHD_STORAGE_ID)))
1924 _uhd->storage_id = strdup((const char *)sqlite3_column_text(stmt, MEDIA_UHD_STORAGE_ID));
1926 if (STRING_VALID((const char *)sqlite3_column_text(stmt, MEDIA_UHD_PATH)))
1927 _uhd->path = strdup((const char *)sqlite3_column_text(stmt, MEDIA_UHD_PATH));
1929 _uhd->size = (unsigned long long)sqlite3_column_int64(stmt, MEDIA_UHD_SIZE);
1931 if (STRING_VALID((const char *)sqlite3_column_text(stmt, MEDIA_UHD_CONTENT_ID)))
1932 _uhd->content_id = strdup((const char *)sqlite3_column_text(stmt, MEDIA_UHD_CONTENT_ID));
1934 if (STRING_VALID((const char *)sqlite3_column_text(stmt, MEDIA_UHD_CONTENT_TITLE)))
1935 _uhd->content_title = strdup((const char *)sqlite3_column_text(stmt, MEDIA_UHD_CONTENT_TITLE));
1937 if (STRING_VALID((const char *)sqlite3_column_text(stmt, MEDIA_UHD_FILE_NAME)))
1938 _uhd->file_name = strdup((const char *)sqlite3_column_text(stmt, MEDIA_UHD_FILE_NAME));
1940 if (STRING_VALID((const char *)sqlite3_column_text(stmt, MEDIA_UHD_RELEASE_DATE)))
1941 _uhd->release_date = strdup((const char *)sqlite3_column_text(stmt, MEDIA_UHD_RELEASE_DATE));
1943 _uhd->modified_time = sqlite3_column_int(stmt, MEDIA_UHD_MODIFIED_TIME);
1944 _uhd->played_position = sqlite3_column_int(stmt, MEDIA_UHD_PLAYED_POSITION);
1945 _uhd->sub_type = sqlite3_column_int(stmt, MEDIA_UHD_SUB_TYPE);
1946 _uhd->played_count = sqlite3_column_int(stmt, MEDIA_UHD_PLAYED_COUNT);
1951 int _media_db_get_uhd(filter_h filter, media_uhd_cb callback, void *user_data)
1953 int ret = MEDIA_CONTENT_ERROR_NONE;
1954 char select_query[DEFAULT_QUERY_SIZE] = {0, };
1955 char *condition_query = NULL;
1956 char *option_query = NULL;
1957 sqlite3_stmt *stmt = NULL;
1958 filter_s *_filter = (filter_s *)filter;
1960 memset(select_query, 0x00, sizeof(select_query));
1962 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
1963 snprintf(select_query, sizeof(select_query), SELECT_UHD_LIST_BY_STORAGE_ID, _filter->storage_id);
1965 SAFE_STRLCAT(select_query, SELECT_UHD_LIST, sizeof(select_query));
1967 ret = __media_db_make_query(filter, &condition_query, &option_query);
1968 media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
1970 ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
1971 SAFE_FREE(condition_query);
1972 SAFE_FREE(option_query);
1973 media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
1975 while (sqlite3_step(stmt) == SQLITE_ROW) {
1976 media_uhd_s *_uhd = (media_uhd_s*)calloc(1, sizeof(media_uhd_s));
1979 media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
1980 SQLITE3_FINALIZE(stmt);
1981 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
1984 _media_uhd_item_get_detail(stmt, (media_uhd_h)_uhd);
1986 if (callback((media_uhd_h)_uhd, user_data) == false) {
1987 media_uhd_destroy((media_uhd_h) _uhd);
1990 media_uhd_destroy((media_uhd_h) _uhd);
1993 SQLITE3_FINALIZE(stmt);