src/media_video.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
  17
  18 #include <media_info_private.h>
  19
  20
  21 int video_meta_destroy(video_meta_h video)
  22 {
  23         int ret = MEDIA_CONTENT_ERROR_NONE;
  24         video_meta_s *_video = (video_meta_s*)video;
  25
  26         if (_video) {
  27                 SAFE_FREE(_video->media_id);
  28                 SAFE_FREE(_video->title);
  29                 SAFE_FREE(_video->album);
  30                 SAFE_FREE(_video->artist);
  31                 SAFE_FREE(_video->album_artist);
  32                 SAFE_FREE(_video->genre);
  33                 SAFE_FREE(_video->composer);
  34                 SAFE_FREE(_video->year);
  35                 SAFE_FREE(_video->recorded_date);
  36                 SAFE_FREE(_video->copyright);
  37                 SAFE_FREE(_video->track_num);
  38                 SAFE_FREE(_video);
  39
  40                 ret = MEDIA_CONTENT_ERROR_NONE;
  41         } else {
  42                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
  43                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
  44         }
  45
  46         return ret;
  47 }
  48
  49 int video_meta_clone(video_meta_h *dst, video_meta_h src)
  50 {
  51         int ret = MEDIA_CONTENT_ERROR_NONE;
  52         video_meta_s *_src = (video_meta_s*)src;
  53
  54         if (_src != NULL) {
  55                 video_meta_s *_dst = (video_meta_s*)calloc(1, sizeof(video_meta_s));
  56                 media_content_retvm_if(_dst == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
  57
  58                 if (STRING_VALID(_src->media_id)) {
  59                         _dst->media_id = strdup(_src->media_id);
  60                         if (_dst->media_id == NULL) {
  61                                 video_meta_destroy((video_meta_h)_dst);
  62                                 media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
  63                                 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
  64                         }
  65                 }
  66
  67                 if (STRING_VALID(_src->title)) {
  68                         _dst->title = strdup(_src->title);
  69                         if (_dst->title == NULL) {
  70                                 video_meta_destroy((video_meta_h)_dst);
  71                                 media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
  72                                 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
  73                         }
  74                 }
  75
  76                 if (STRING_VALID(_src->album)) {
  77                         _dst->album = strdup(_src->album);
  78                         if (_dst->album == NULL) {
  79                                 video_meta_destroy((video_meta_h)_dst);
  80                                 media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
  81                                 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
  82                         }
  83                 }
  84
  85                 if (STRING_VALID(_src->artist)) {
  86                         _dst->artist = strdup(_src->artist);
  87                         if (_dst->artist == NULL) {
  88                                 video_meta_destroy((video_meta_h)_dst);
  89                                 media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
  90                                 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
  91                         }
  92                 }
  93
  94                 if (STRING_VALID(_src->album_artist)) {
  95                         _dst->album_artist = strdup(_src->album_artist);
  96                         if (_dst->album_artist == NULL) {
  97                                 video_meta_destroy((video_meta_h)_dst);
  98                                 media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
  99                                 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
 100                         }
 101                 }
 102
 103                 if (STRING_VALID(_src->genre)) {
 104                         _dst->genre = strdup(_src->genre);
 105                         if (_dst->genre == NULL) {
 106                                 video_meta_destroy((video_meta_h)_dst);
 107                                 media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
 108                                 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
 109                         }
 110                 }
 111
 112                 if (STRING_VALID(_src->composer)) {
 113                         _dst->composer = strdup(_src->composer);
 114                         if (_dst->composer == NULL) {
 115                                 video_meta_destroy((video_meta_h)_dst);
 116                                 media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
 117                                 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
 118                         }
 119                 }
 120
 121                 if (STRING_VALID(_src->year)) {
 122                         _dst->year = strdup(_src->year);
 123                         if (_dst->year == NULL) {
 124                                 video_meta_destroy((video_meta_h)_dst);
 125                                 media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
 126                                 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
 127                         }
 128                 }
 129
 130                 if (STRING_VALID(_src->recorded_date)) {
 131                         _dst->recorded_date = strdup(_src->recorded_date);
 132                         if (_dst->recorded_date == NULL) {
 133                                 video_meta_destroy((video_meta_h)_dst);
 134                                 media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
 135                                 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
 136                         }
 137                 }
 138
 139                 if (STRING_VALID(_src->copyright)) {
 140                         _dst->copyright = strdup(_src->copyright);
 141                         if (_dst->copyright == NULL) {
 142                                 video_meta_destroy((video_meta_h)_dst);
 143                                 media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
 144                                 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
 145                         }
 146                 }
 147
 148                 if (STRING_VALID(_src->track_num)) {
 149                         _dst->track_num = strdup(_src->track_num);
 150                         if (_dst->track_num == NULL) {
 151                                 video_meta_destroy((video_meta_h)_dst);
 152                                 media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
 153                                 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
 154                         }
 155                 }
 156
 157                 _dst->bitrate = _src->bitrate;
 158                 _dst->duration = _src->duration;
 159                 _dst->width = _src->width;
 160                 _dst->height = _src->height;
 161                 _dst->played_count = _src->played_count;
 162                 _dst->played_time = _src->played_time;
 163                 _dst->played_position = _src->played_position;
 164
 165                 *dst = (video_meta_h)_dst;
 166
 167                 ret = MEDIA_CONTENT_ERROR_NONE;
 168         } else {
 169                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 170                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 171         }
 172
 173         return ret;
 174 }
 175
 176 int video_meta_get_media_id(video_meta_h video, char **media_id)
 177 {
 178         int ret = MEDIA_CONTENT_ERROR_NONE;
 179         video_meta_s *_video = (video_meta_s*)video;
 180         if (_video) {
 181                 if (STRING_VALID(_video->media_id)) {
 182                         char *new_string = strdup(_video->media_id);
 183                         media_content_retvm_if(new_string == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
 184
 185                         *media_id = new_string;
 186                 } else {
 187                         *media_id = NULL;
 188                 }
 189                 ret = MEDIA_CONTENT_ERROR_NONE;
 190
 191         } else {
 192                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 193                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 194         }
 195
 196         return ret;
 197 }
 198
 199 int video_meta_get_album(video_meta_h video, char **album)
 200 {
 201         int ret = MEDIA_CONTENT_ERROR_NONE;
 202         video_meta_s *_video = (video_meta_s*)video;
 203         if (_video) {
 204                 if (STRING_VALID(_video->album)) {
 205                         char *new_string = strdup(_video->album);
 206                         media_content_retvm_if(new_string == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
 207
 208                         *album = new_string;
 209                 } else {
 210                         *album = NULL;
 211                 }
 212                 ret = MEDIA_CONTENT_ERROR_NONE;
 213
 214         } else {
 215                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 216                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 217         }
 218
 219         return ret;
 220 }
 221
 222 int video_meta_get_artist(video_meta_h video, char **artist)
 223 {
 224         int ret = MEDIA_CONTENT_ERROR_NONE;
 225         video_meta_s *_video = (video_meta_s*)video;
 226         if (_video) {
 227                 if (STRING_VALID(_video->artist)) {
 228                         char *new_string = strdup(_video->artist);
 229                         media_content_retvm_if(new_string == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
 230
 231                         *artist = new_string;
 232                 } else {
 233                         *artist = NULL;
 234                 }
 235                 ret = MEDIA_CONTENT_ERROR_NONE;
 236
 237         } else {
 238                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 239                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 240         }
 241
 242         return ret;
 243 }
 244
 245 int video_meta_get_album_artist(video_meta_h video, char **album_artist)
 246 {
 247         int ret = MEDIA_CONTENT_ERROR_NONE;
 248         video_meta_s *_video = (video_meta_s*)video;
 249         if (_video) {
 250                 if (STRING_VALID(_video->album_artist)) {
 251                         char *new_string = strdup(_video->album_artist);
 252                         media_content_retvm_if(new_string == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
 253
 254                         *album_artist = new_string;
 255                 } else {
 256                         *album_artist = NULL;
 257                 }
 258                 ret = MEDIA_CONTENT_ERROR_NONE;
 259
 260         } else {
 261                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 262                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 263         }
 264
 265         return ret;
 266 }
 267
 268 int video_meta_get_genre(video_meta_h video, char **genre)
 269 {
 270         int ret = MEDIA_CONTENT_ERROR_NONE;
 271         video_meta_s *_video = (video_meta_s*)video;
 272         if (_video) {
 273                 if (STRING_VALID(_video->genre)) {
 274                         char *new_string = strdup(_video->genre);
 275                         media_content_retvm_if(new_string == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
 276
 277                         *genre = new_string;
 278                 } else {
 279                         *genre = NULL;
 280                 }
 281
 282                 ret = MEDIA_CONTENT_ERROR_NONE;
 283         } else {
 284                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 285                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 286         }
 287
 288         return ret;
 289 }
 290
 291 int video_meta_get_composer(video_meta_h video, char **composer)
 292 {
 293         int ret = MEDIA_CONTENT_ERROR_NONE;
 294         video_meta_s *_video = (video_meta_s*)video;
 295         if (_video) {
 296                 if (STRING_VALID(_video->composer)) {
 297                         char *new_string = strdup(_video->composer);
 298                         media_content_retvm_if(new_string == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
 299
 300                         *composer = new_string;
 301                 } else {
 302                         *composer = NULL;
 303                 }
 304
 305                 ret = MEDIA_CONTENT_ERROR_NONE;
 306         } else {
 307                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 308                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 309         }
 310
 311         return ret;
 312 }
 313
 314 int video_meta_get_year(video_meta_h video, char **year)
 315 {
 316         int ret = MEDIA_CONTENT_ERROR_NONE;
 317         video_meta_s *_video = (video_meta_s*)video;
 318         if (_video) {
 319                 if (STRING_VALID(_video->year)) {
 320                         char *new_string = strdup(_video->year);
 321                         media_content_retvm_if(new_string == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
 322
 323                         *year = new_string;
 324                 } else {
 325                         *year = NULL;
 326                 }
 327
 328                 ret = MEDIA_CONTENT_ERROR_NONE;
 329         } else {
 330                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 331                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 332         }
 333
 334         return ret;
 335 }
 336
 337 int video_meta_get_recorded_date(video_meta_h video, char **recorded_date)
 338 {
 339         int ret = MEDIA_CONTENT_ERROR_NONE;
 340         video_meta_s *_video = (video_meta_s*)video;
 341         if (_video) {
 342                 if (STRING_VALID(_video->recorded_date)) {
 343                         char *new_string = strdup(_video->recorded_date);
 344                         media_content_retvm_if(new_string == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
 345
 346                         *recorded_date = new_string;
 347                 } else {
 348                         *recorded_date = NULL;
 349                 }
 350
 351                 ret = MEDIA_CONTENT_ERROR_NONE;
 352         } else {
 353                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 354                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 355         }
 356
 357         return ret;
 358 }
 359
 360 int video_meta_get_copyright(video_meta_h video, char **copyright)
 361 {
 362         int ret = MEDIA_CONTENT_ERROR_NONE;
 363         video_meta_s *_video = (video_meta_s*)video;
 364         if (_video) {
 365                 if (STRING_VALID(_video->copyright)) {
 366                         char *new_string = strdup(_video->copyright);
 367                         media_content_retvm_if(new_string == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
 368
 369                         *copyright = new_string;
 370                 } else {
 371                         *copyright = NULL;
 372                 }
 373
 374                 ret = MEDIA_CONTENT_ERROR_NONE;
 375         } else {
 376                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 377                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 378         }
 379
 380         return ret;
 381 }
 382
 383 int video_meta_get_track_num(video_meta_h video, char **track_num)
 384 {
 385         int ret = MEDIA_CONTENT_ERROR_NONE;
 386         video_meta_s *_video = (video_meta_s*)video;
 387         if (_video) {
 388                 if (STRING_VALID(_video->track_num)) {
 389                         char *new_string = strdup(_video->track_num);
 390                         media_content_retvm_if(new_string == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
 391
 392                         *track_num = new_string;
 393                 } else {
 394                         *track_num = NULL;
 395                 }
 396
 397                 ret = MEDIA_CONTENT_ERROR_NONE;
 398         } else {
 399                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 400                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 401         }
 402
 403         return ret;
 404 }
 405
 406 int video_meta_get_bit_rate(video_meta_h video, int *bit_rate)
 407 {
 408         int ret = MEDIA_CONTENT_ERROR_NONE;
 409         video_meta_s *_video = (video_meta_s*)video;
 410
 411         if (_video && bit_rate) {
 412                 *bit_rate = _video->bitrate;
 413                 ret = MEDIA_CONTENT_ERROR_NONE;
 414         } else {
 415                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 416                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 417         }
 418
 419         return ret;
 420 }
 421
 422 int video_meta_get_duration(video_meta_h video, int *duration)
 423 {
 424         int ret = MEDIA_CONTENT_ERROR_NONE;
 425         video_meta_s *_video = (video_meta_s*)video;
 426
 427         if (_video && duration) {
 428                 *duration = _video->duration;
 429                 ret = MEDIA_CONTENT_ERROR_NONE;
 430         } else {
 431                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 432                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 433         }
 434
 435         return ret;
 436 }
 437
 438 int video_meta_get_width(video_meta_h video, int *width)
 439 {
 440         int ret = MEDIA_CONTENT_ERROR_NONE;
 441         video_meta_s *_video = (video_meta_s*)video;
 442
 443         if (_video && width) {
 444                 *width = _video->width;
 445                 ret = MEDIA_CONTENT_ERROR_NONE;
 446         } else {
 447                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 448                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 449         }
 450
 451         return ret;
 452 }
 453
 454 int video_meta_get_height(video_meta_h video, int *height)
 455 {
 456         int ret = MEDIA_CONTENT_ERROR_NONE;
 457         video_meta_s *_video = (video_meta_s*)video;
 458         if (_video && height) {
 459                 *height = _video->height;
 460                 ret = MEDIA_CONTENT_ERROR_NONE;
 461         } else {
 462                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 463                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 464         }
 465
 466         return ret;
 467 }
 468
 469 int video_meta_get_played_count(video_meta_h video, int *played_count)
 470 {
 471         int ret = MEDIA_CONTENT_ERROR_NONE;
 472         video_meta_s *_video = (video_meta_s*)video;
 473
 474         if (_video && played_count) {
 475                 *played_count = _video->played_count;
 476                 ret = MEDIA_CONTENT_ERROR_NONE;
 477         } else {
 478                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 479                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 480         }
 481
 482         return ret;
 483 }
 484
 485 int video_meta_get_played_time(video_meta_h video, time_t* played_time)
 486 {
 487         int ret = MEDIA_CONTENT_ERROR_NONE;
 488         video_meta_s *_video = (video_meta_s*)video;
 489
 490         if (_video) {
 491                 *played_time = _video->played_time;
 492                 ret = MEDIA_CONTENT_ERROR_NONE;
 493         } else {
 494                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 495                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 496         }
 497
 498         return ret;
 499 }
 500
 501 int video_meta_get_played_position(video_meta_h video, int *played_position)
 502 {
 503         int ret = MEDIA_CONTENT_ERROR_NONE;
 504         video_meta_s *_video = (video_meta_s*)video;
 505
 506         if (_video) {
 507                 *played_position = _video->played_position;
 508                 ret = MEDIA_CONTENT_ERROR_NONE;
 509         } else {
 510                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 511                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 512         }
 513
 514         return ret;
 515 }
 516
 517 int video_meta_set_played_count(video_meta_h video, int played_count)
 518 {
 519         int ret = MEDIA_CONTENT_ERROR_NONE;
 520         video_meta_s *_video = (video_meta_s*)video;
 521
 522         if ((_video != NULL) && (played_count >= 0)) {
 523                 _video->played_count = played_count;
 524         } else {
 525                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 526                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 527         }
 528
 529         return ret;
 530 }
 531
 532 int video_meta_set_played_time(video_meta_h video, time_t played_time)
 533 {
 534         int ret = MEDIA_CONTENT_ERROR_NONE;
 535         video_meta_s *_video = (video_meta_s*)video;
 536
 537         if ((_video != NULL) && (played_time >= 0)) {
 538                 _video->played_time = played_time;
 539         } else {
 540                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 541                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 542         }
 543
 544         return ret;
 545 }
 546
 547 int video_meta_set_played_position(video_meta_h video, int played_position)
 548 {
 549         int ret = MEDIA_CONTENT_ERROR_NONE;
 550         video_meta_s *_video = (video_meta_s*)video;
 551
 552         if ((_video != NULL) && (played_position >= 0)) {
 553                 _video->played_position = played_position;
 554         } else {
 555                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 556                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 557         }
 558
 559         return ret;
 560 }
 561
 562 int video_meta_update_to_db(video_meta_h video)
 563 {
 564         int ret = MEDIA_CONTENT_ERROR_NONE;
 565         video_meta_s *_video = (video_meta_s*)video;
 566         char *sql = NULL;
 567
 568         if (_video != NULL && STRING_VALID(_video->media_id)) {
 569                 char storage_id[MEDIA_CONTENT_UUID_SIZE+1] = {0, };
 570                 memset(storage_id, 0x00, sizeof(storage_id));
 571
 572                 ret = _media_db_get_storage_id_by_media_id(_video->media_id, storage_id);
 573                 media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 574
 575                 sql = sqlite3_mprintf(UPDATE_AV_META_FROM_MEDIA, storage_id, _video->played_count, _video->played_time, _video->played_position, _video->media_id);
 576                 ret = _content_query_sql(sql);
 577                 SQLITE3_SAFE_FREE(sql);
 578         } else {
 579                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 580                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 581         }
 582
 583         return ret;
 584 }