src/media_uhd.c

   1  /*
   2  * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
   3  *
   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
   7  *
   8  * http://www.apache.org/licenses/LICENSE-2.0
   9  *
  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.
  15  */
  16 #ifdef _USE_TV_PROFILE
  17 #include <media_content.h>
  18 #include <media_content_internal.h>
  19 #include <media_info_private.h>
  20 #include <media_util_private.h>
  21 #include <media_uhd.h>
  22
  23 int media_uhd_get_media_count_from_db(filter_h filter, int *media_count)
  24 {
  25         int ret = MEDIA_CONTENT_ERROR_NONE;
  26
  27         if (media_count) {
  28                 ret = _media_db_get_group_item_count(NULL, filter, MEDIA_GROUP_UHD, media_count);
  29         } else {
  30                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
  31                 return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
  32         }
  33
  34         return ret;
  35 }
  36
  37 int media_uhd_foreach_media_from_db(filter_h filter, media_uhd_cb callback, void *user_data)
  38 {
  39         int ret = MEDIA_CONTENT_ERROR_NONE;
  40
  41         if (callback != NULL) {
  42                 ret = _media_db_get_uhd(filter, callback, user_data);
  43         } else {
  44                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
  45                 return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
  46         }
  47
  48         return ret;
  49 }
  50
  51 int media_uhd_destroy(media_uhd_h uhd)
  52 {
  53         int ret = MEDIA_CONTENT_ERROR_NONE;
  54         media_uhd_s *_uhd = (media_uhd_s*)uhd;
  55         if (_uhd) {
  56                 SAFE_FREE(_uhd->media_id);
  57                 SAFE_FREE(_uhd->storage_id);
  58                 SAFE_FREE(_uhd->path);
  59                 SAFE_FREE(_uhd->content_id);
  60                 SAFE_FREE(_uhd->content_title);
  61                 SAFE_FREE(_uhd->file_name);
  62                 SAFE_FREE(_uhd->release_date);
  63                 SAFE_FREE(_uhd);
  64
  65                 ret = MEDIA_CONTENT_ERROR_NONE;
  66         } else {
  67                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
  68                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
  69         }
  70
  71         return ret;
  72 }
  73
  74 int media_uhd_clone(media_uhd_h *dst, media_uhd_h src)
  75 {
  76         int ret = MEDIA_CONTENT_ERROR_NONE;
  77         media_uhd_s *_src = (media_uhd_s*)src;
  78
  79         if (_src != NULL) {
  80                 media_uhd_s *_dst = (media_uhd_s*)calloc(1, sizeof(media_uhd_s));
  81                 if (_dst == NULL) {
  82                         media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
  83                         return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
  84                 }
  85
  86                 if (STRING_VALID(_src->media_id)) {
  87                         _dst->media_id = strdup(_src->media_id);
  88                         if (_dst->media_id == NULL) {
  89                                 media_uhd_destroy((media_uhd_h)_dst);
  90                                 media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
  91                                 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
  92                         }
  93                 }
  94
  95                 if (STRING_VALID(_src->storage_id)) {
  96                         _dst->storage_id = strdup(_src->storage_id);
  97                         if (_dst->storage_id == NULL) {
  98                                 media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
  99                                 media_uhd_destroy((media_uhd_h)_dst);
 100                                 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
 101                         }
 102                 }
 103
 104                 if (STRING_VALID(_src->path)) {
 105                         _dst->path = strdup(_src->path);
 106                         if (_dst->path == NULL) {
 107                                 media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
 108                                 media_uhd_destroy((media_uhd_h)_dst);
 109                                 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
 110                         }
 111                 }
 112
 113                 if (STRING_VALID(_src->content_id)) {
 114                         _dst->content_id = strdup(_src->content_id);
 115                         if (_dst->content_id == NULL) {
 116                                 media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
 117                                 media_uhd_destroy((media_uhd_h)_dst);
 118                                 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
 119                         }
 120                 }
 121
 122                 if (STRING_VALID(_src->content_title)) {
 123                         _dst->content_title = strdup(_src->content_title);
 124                         if (_dst->content_title == NULL) {
 125                                 media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
 126                                 media_uhd_destroy((media_uhd_h)_dst);
 127                                 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
 128                         }
 129                 }
 130
 131                 if (STRING_VALID(_src->release_date)) {
 132                         _dst->release_date = strdup(_src->release_date);
 133                         if (_dst->release_date == NULL) {
 134                                 media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
 135                                 media_uhd_destroy((media_uhd_h)_dst);
 136                                 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
 137                         }
 138                 }
 139
 140                 if (STRING_VALID(_src->file_name)) {
 141                         _dst->file_name = strdup(_src->file_name);
 142                         if (_dst->file_name == NULL) {
 143                                 media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
 144                                 media_uhd_destroy((media_uhd_h)_dst);
 145                                 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
 146                         }
 147                 }
 148
 149                 _dst->size = _src->size;
 150                 _dst->modified_time = _src->modified_time;
 151                 _dst->played_position = _src->played_position;
 152                 _dst->sub_type = _src->sub_type;
 153                 _dst->played_count = _src->played_count;
 154                 *dst = (media_uhd_h)_dst;
 155
 156                 ret = MEDIA_CONTENT_ERROR_NONE;
 157         } else {
 158                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 159                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 160         }
 161
 162         return ret;
 163 }
 164
 165 int media_uhd_get_uhd_from_db(const char *media_id, media_uhd_h *uhd)
 166 {
 167         int ret = MEDIA_CONTENT_ERROR_NONE;
 168         char *select_query = NULL;
 169         sqlite3_stmt *stmt = NULL;
 170
 171         if (!STRING_VALID(media_id) || (uhd == NULL)) {
 172                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 173                 return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 174         }
 175
 176         select_query = sqlite3_mprintf(SELECT_UHD_FROM_UHD, media_id);
 177
 178         ret = _content_query_prepare(&stmt, select_query, NULL, NULL);
 179         sqlite3_free(select_query);
 180         media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 181
 182         media_uhd_s *_uhd = NULL;
 183
 184         while (sqlite3_step(stmt) == SQLITE_ROW) {
 185                 if (_uhd)
 186                         media_uhd_destroy((media_uhd_h)_uhd);
 187
 188                 _uhd = (media_uhd_s*)calloc(1, sizeof(media_uhd_s));
 189
 190                 if (_uhd == NULL) {
 191                         media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
 192                         SQLITE3_FINALIZE(stmt);
 193                         return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
 194                 }
 195
 196                 _media_uhd_item_get_detail(stmt, (media_uhd_h)_uhd);
 197
 198                 *uhd = (media_uhd_h)_uhd;
 199         }
 200
 201         SQLITE3_FINALIZE(stmt);
 202
 203         return ret;
 204 }
 205
 206 int media_uhd_get_media_id(media_uhd_h uhd, char **media_id)
 207 {
 208         int ret = MEDIA_CONTENT_ERROR_NONE;
 209         media_uhd_s *_uhd = (media_uhd_s*)uhd;
 210
 211         if (_uhd && media_id) {
 212                 if (STRING_VALID(_uhd->media_id)) {
 213                         *media_id = strdup(_uhd->media_id);
 214                         if (*media_id == NULL) {
 215                                 media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
 216                                 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
 217                         }
 218                 } else {
 219                         *media_id = NULL;
 220                 }
 221
 222                 ret = MEDIA_CONTENT_ERROR_NONE;
 223         } else {
 224                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 225                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 226         }
 227
 228         return ret;
 229 }
 230
 231 int media_uhd_get_storage_id(media_uhd_h uhd, char **storage_id)
 232 {
 233         int ret = MEDIA_CONTENT_ERROR_NONE;
 234         media_uhd_s *_uhd = (media_uhd_s*)uhd;
 235
 236         if (_uhd && storage_id) {
 237                 if (STRING_VALID(_uhd->storage_id)) {
 238                         *storage_id = strdup(_uhd->storage_id);
 239                         if (*storage_id == NULL) {
 240                                 media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
 241                                 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
 242                         }
 243                 } else {
 244                         *storage_id = NULL;
 245                 }
 246
 247                 ret = MEDIA_CONTENT_ERROR_NONE;
 248         } else {
 249                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 250                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 251         }
 252
 253         return ret;
 254 }
 255
 256 int media_uhd_get_path(media_uhd_h uhd, char **path)
 257 {
 258         int ret = MEDIA_CONTENT_ERROR_NONE;
 259         media_uhd_s *_uhd = (media_uhd_s*)uhd;
 260
 261         if (_uhd && path) {
 262                 if (STRING_VALID(_uhd->path)) {
 263                         *path = strdup(_uhd->path);
 264                         if (*path == NULL) {
 265                                 media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
 266                                 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
 267                         }
 268                 } else {
 269                         *path = NULL;
 270                 }
 271
 272                 ret = MEDIA_CONTENT_ERROR_NONE;
 273         } else {
 274                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 275                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 276         }
 277
 278         return ret;
 279 }
 280
 281 int media_uhd_get_size(media_uhd_h uhd, unsigned long long *size)
 282 {
 283         int ret = MEDIA_CONTENT_ERROR_NONE;
 284         media_uhd_s *_uhd = (media_uhd_s*)uhd;
 285
 286         if (_uhd && size) {
 287                 *size = _uhd->size;
 288                 ret = MEDIA_CONTENT_ERROR_NONE;
 289         } else {
 290                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 291                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 292         }
 293
 294         return ret;
 295 }
 296
 297 int media_uhd_get_content_id(media_uhd_h uhd, char **content_id)
 298 {
 299         int ret = MEDIA_CONTENT_ERROR_NONE;
 300         media_uhd_s *_uhd = (media_uhd_s*)uhd;
 301
 302         if (_uhd && content_id) {
 303                 if (STRING_VALID(_uhd->content_id)) {
 304                         *content_id = strdup(_uhd->content_id);
 305                         if (*content_id == NULL) {
 306                                 media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
 307                                 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
 308                         }
 309                 } else {
 310                         *content_id = NULL;
 311                 }
 312
 313                 ret = MEDIA_CONTENT_ERROR_NONE;
 314         } else {
 315                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 316                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 317         }
 318
 319         return ret;
 320 }
 321
 322 int media_uhd_get_content_title(media_uhd_h uhd, char **content_title)
 323 {
 324         int ret = MEDIA_CONTENT_ERROR_NONE;
 325         media_uhd_s *_uhd = (media_uhd_s*)uhd;
 326
 327         if (_uhd && content_title) {
 328                 if (STRING_VALID(_uhd->content_title)) {
 329                         *content_title = strdup(_uhd->content_title);
 330                         if (*content_title == NULL) {
 331                                 media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
 332                                 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
 333                         }
 334                 } else {
 335                         *content_title = NULL;
 336                 }
 337
 338                 ret = MEDIA_CONTENT_ERROR_NONE;
 339         } else {
 340                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 341                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 342         }
 343
 344         return ret;
 345 }
 346
 347 int media_uhd_get_file_name(media_uhd_h uhd, char **file_name)
 348 {
 349         int ret = MEDIA_CONTENT_ERROR_NONE;
 350         media_uhd_s *_uhd = (media_uhd_s*)uhd;
 351
 352         if (_uhd && file_name) {
 353                 if (STRING_VALID(_uhd->file_name)) {
 354                         *file_name = strdup(_uhd->file_name);
 355                         if (*file_name == NULL) {
 356                                 media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
 357                                 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
 358                         }
 359                 } else {
 360                         *file_name = NULL;
 361                 }
 362
 363                 ret = MEDIA_CONTENT_ERROR_NONE;
 364         } else {
 365                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 366                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 367         }
 368
 369         return ret;
 370 }
 371
 372 int media_uhd_get_release_date(media_uhd_h uhd, char **release_date)
 373 {
 374         int ret = MEDIA_CONTENT_ERROR_NONE;
 375         media_uhd_s *_uhd = (media_uhd_s*)uhd;
 376
 377         if (_uhd && release_date) {
 378                 if (STRING_VALID(_uhd->release_date)) {
 379                         *release_date = strdup(_uhd->release_date);
 380                         if (*release_date == NULL) {
 381                                 media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
 382                                 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
 383                         }
 384                 } else {
 385                         *release_date = NULL;
 386                 }
 387
 388                 ret = MEDIA_CONTENT_ERROR_NONE;
 389         } else {
 390                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 391                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 392         }
 393
 394         return ret;
 395 }
 396
 397 int media_uhd_get_modified_time(media_uhd_h uhd, time_t *modified_time)
 398 {
 399         int ret = MEDIA_CONTENT_ERROR_NONE;
 400         media_uhd_s *_uhd = (media_uhd_s*)uhd;
 401
 402         if (_uhd && modified_time) {
 403                 *modified_time = _uhd->modified_time;
 404                 ret = MEDIA_CONTENT_ERROR_NONE;
 405         } else {
 406                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 407                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 408         }
 409
 410         return ret;
 411 }
 412
 413 int media_uhd_get_played_position(media_uhd_h uhd, int *played_position)
 414 {
 415         int ret = MEDIA_CONTENT_ERROR_NONE;
 416         media_uhd_s *_uhd = (media_uhd_s*)uhd;
 417
 418         if (_uhd) {
 419                 *played_position = _uhd->played_position;
 420                 ret = MEDIA_CONTENT_ERROR_NONE;
 421         } else {
 422                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 423                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 424         }
 425
 426         return ret;
 427 }
 428
 429 int media_uhd_get_sub_type(media_uhd_h uhd, int *sub_type)
 430 {
 431         int ret = MEDIA_CONTENT_ERROR_NONE;
 432         media_uhd_s *_uhd = (media_uhd_s*)uhd;
 433
 434         if (_uhd) {
 435                 *sub_type = _uhd->sub_type;
 436                 ret = MEDIA_CONTENT_ERROR_NONE;
 437         } else {
 438                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 439                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 440         }
 441
 442         return ret;
 443 }
 444
 445 int media_uhd_get_played_count(media_uhd_h uhd, int *played_count)
 446 {
 447         int ret = MEDIA_CONTENT_ERROR_NONE;
 448         media_uhd_s *_uhd = (media_uhd_s*)uhd;
 449
 450         if (_uhd) {
 451                 *played_count = _uhd->played_count;
 452                 ret = MEDIA_CONTENT_ERROR_NONE;
 453         } else {
 454                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 455                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 456         }
 457
 458         return ret;
 459 }
 460
 461 int media_uhd_set_played_position(media_uhd_h uhd, int played_position)
 462 {
 463         int ret = MEDIA_CONTENT_ERROR_NONE;
 464         media_uhd_s *_uhd = (media_uhd_s*)uhd;
 465
 466         if ((_uhd != NULL) && (played_position >= 0)) {
 467                 _uhd->played_position = played_position;
 468         } else {
 469                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 470                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 471         }
 472
 473         return ret;
 474 }
 475
 476 int media_uhd_set_content_title(media_uhd_h uhd, const char *content_title)
 477 {
 478         int ret = MEDIA_CONTENT_ERROR_NONE;
 479         media_uhd_s *_uhd = (media_uhd_s*)uhd;
 480
 481         if (_uhd != NULL && STRING_VALID(content_title)) {
 482                 SAFE_FREE(_uhd->content_title);
 483                 _uhd->content_title = strdup(content_title);
 484                 if (_uhd->content_title == NULL) {
 485                         media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
 486                         return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
 487                 }
 488         } else {
 489                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 490                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 491         }
 492
 493         return ret;
 494 }
 495
 496 int media_uhd_set_release_date(media_uhd_h uhd, const char *release_date)
 497 {
 498         int ret = MEDIA_CONTENT_ERROR_NONE;
 499         media_uhd_s *_uhd = (media_uhd_s*)uhd;
 500
 501         if (_uhd != NULL && STRING_VALID(release_date)) {
 502                 SAFE_FREE(_uhd->release_date);
 503                 _uhd->release_date = strdup(release_date);
 504                 if (_uhd->release_date == NULL) {
 505                         media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
 506                         return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
 507                 }
 508         } else {
 509                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 510                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 511         }
 512
 513         return ret;
 514 }
 515
 516 int media_uhd_set_sub_type(media_uhd_h uhd, int sub_type)
 517 {
 518         int ret = MEDIA_CONTENT_ERROR_NONE;
 519         media_uhd_s *_uhd = (media_uhd_s*)uhd;
 520
 521         if ((_uhd != NULL) && (sub_type >= 0)) {
 522                 _uhd->sub_type = sub_type;
 523         } else {
 524                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 525                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 526         }
 527
 528         return ret;
 529 }
 530
 531 int media_uhd_set_played_count(media_uhd_h uhd, int played_count)
 532 {
 533         int ret = MEDIA_CONTENT_ERROR_NONE;
 534         media_uhd_s *_uhd = (media_uhd_s*)uhd;
 535
 536         if (_uhd != NULL) {
 537                 _uhd->played_count = played_count;
 538         } else {
 539                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 540                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 541         }
 542
 543         return ret;
 544 }
 545
 546 int media_uhd_update_to_db(media_uhd_h uhd)
 547 {
 548         int ret = MEDIA_CONTENT_ERROR_NONE;
 549         media_uhd_s *_uhd = (media_uhd_s*)uhd;
 550         char *update_query = NULL;
 551
 552         if (_uhd != NULL && STRING_VALID(_uhd->media_id) && STRING_VALID(_uhd->path)) {
 553                 update_query = sqlite3_mprintf(UPDATE_UHD_META_FROM_UHD, _uhd->content_title, _uhd->release_date, _uhd->played_position, _uhd->sub_type, _uhd->played_count, _uhd->media_id);
 554
 555                 ret = _content_query_sql(update_query);
 556                 sqlite3_free(update_query);
 557         } else {
 558                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 559                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 560         }
 561
 562         return ret;
 563 }
 564 #endif