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         {
  28                 SAFE_FREE(_video->media_id);
  29                 SAFE_FREE(_video->title);
  30                 SAFE_FREE(_video->album);
  31                 SAFE_FREE(_video->artist);
  32                 SAFE_FREE(_video->album_artist);
  33                 SAFE_FREE(_video->genre);
  34                 SAFE_FREE(_video->composer);
  35                 SAFE_FREE(_video->year);
  36                 SAFE_FREE(_video->recorded_date);
  37                 SAFE_FREE(_video->copyright);
  38                 SAFE_FREE(_video->track_num);
  39                 SAFE_FREE(_video);
  40
  41                 ret = MEDIA_CONTENT_ERROR_NONE;
  42         }
  43         else
  44         {
  45                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
  46                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
  47         }
  48
  49         return ret;
  50 }
  51
  52 int video_meta_clone(video_meta_h *dst, video_meta_h src)
  53 {
  54         int ret = MEDIA_CONTENT_ERROR_NONE;
  55         video_meta_s *_src = (video_meta_s*)src;
  56
  57         if(_src != NULL)
  58         {
  59                 video_meta_s *_dst = (video_meta_s*)calloc(1, sizeof(video_meta_s));
  60                 media_content_retvm_if(_dst == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
  61
  62                 if(STRING_VALID(_src->media_id))
  63                 {
  64                         _dst->media_id = strdup(_src->media_id);
  65                         if(_dst->media_id == NULL)
  66                         {
  67                                 video_meta_destroy((video_meta_h)_dst);
  68                                 media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
  69                                 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
  70                         }
  71                 }
  72
  73                 if(STRING_VALID(_src->title))
  74                 {
  75                         _dst->title = strdup(_src->title);
  76                         if(_dst->title == NULL)
  77                         {
  78                                 video_meta_destroy((video_meta_h)_dst);
  79                                 media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
  80                                 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
  81                         }
  82                 }
  83
  84                 if(STRING_VALID(_src->album))
  85                 {
  86                         _dst->album = strdup(_src->album);
  87                         if(_dst->album == NULL)
  88                         {
  89                                 video_meta_destroy((video_meta_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->artist))
  96                 {
  97                         _dst->artist = strdup(_src->artist);
  98                         if(_dst->artist == NULL)
  99                         {
 100                                 video_meta_destroy((video_meta_h)_dst);
 101                                 media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
 102                                 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
 103                         }
 104                 }
 105
 106                 if(STRING_VALID(_src->album_artist))
 107                 {
 108                         _dst->album_artist = strdup(_src->album_artist);
 109                         if(_dst->album_artist == NULL)
 110                         {
 111                                 video_meta_destroy((video_meta_h)_dst);
 112                                 media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
 113                                 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
 114                         }
 115                 }
 116
 117                 if(STRING_VALID(_src->genre))
 118                 {
 119                         _dst->genre = strdup(_src->genre);
 120                         if(_dst->genre == NULL)
 121                         {
 122                                 video_meta_destroy((video_meta_h)_dst);
 123                                 media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
 124                                 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
 125                         }
 126                 }
 127
 128                 if(STRING_VALID(_src->composer))
 129                 {
 130                         _dst->composer = strdup(_src->composer);
 131                         if(_dst->composer == NULL)
 132                         {
 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->year))
 140                 {
 141                         _dst->year = strdup(_src->year);
 142                         if(_dst->year == NULL)
 143                         {
 144                                 video_meta_destroy((video_meta_h)_dst);
 145                                 media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
 146                                 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
 147                         }
 148                 }
 149
 150                 if(STRING_VALID(_src->recorded_date))
 151                 {
 152                         _dst->recorded_date = strdup(_src->recorded_date);
 153                         if(_dst->recorded_date == NULL)
 154                         {
 155                                 video_meta_destroy((video_meta_h)_dst);
 156                                 media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
 157                                 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
 158                         }
 159                 }
 160
 161                 if(STRING_VALID(_src->copyright))
 162                 {
 163                         _dst->copyright = strdup(_src->copyright);
 164                         if(_dst->copyright == NULL)
 165                         {
 166                                 video_meta_destroy((video_meta_h)_dst);
 167                                 media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
 168                                 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
 169                         }
 170                 }
 171
 172                 if(STRING_VALID(_src->track_num))
 173                 {
 174                         _dst->track_num = strdup(_src->track_num);
 175                         if(_dst->track_num == NULL)
 176                         {
 177                                 video_meta_destroy((video_meta_h)_dst);
 178                                 media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
 179                                 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
 180                         }
 181                 }
 182
 183                 _dst->bitrate = _src->bitrate;
 184                 _dst->duration = _src->duration;
 185                 _dst->width = _src->width;
 186                 _dst->height = _src->height;
 187                 _dst->played_count = _src->played_count;
 188                 _dst->played_time = _src->played_time;
 189                 _dst->played_position = _src->played_position;
 190
 191                 *dst = (video_meta_h)_dst;
 192
 193                 ret = MEDIA_CONTENT_ERROR_NONE;
 194         }
 195         else
 196         {
 197                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 198                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 199         }
 200
 201         return ret;
 202 }
 203
 204 int video_meta_get_media_id(video_meta_h video, char **media_id)
 205 {
 206         int ret = MEDIA_CONTENT_ERROR_NONE;
 207         video_meta_s *_video = (video_meta_s*)video;
 208         if(_video)
 209         {
 210                 if(STRING_VALID(_video->media_id))
 211                 {
 212                         char *new_string = strdup(_video->media_id);
 213                         media_content_retvm_if(new_string == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
 214
 215                         *media_id = new_string;
 216                 }
 217                 else
 218                 {
 219                         *media_id = NULL;
 220                 }
 221                 ret = MEDIA_CONTENT_ERROR_NONE;
 222
 223         }
 224         else
 225         {
 226                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 227                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 228         }
 229
 230         return ret;
 231 }
 232
 233 int video_meta_get_album(video_meta_h video, char **album)
 234 {
 235         int ret = MEDIA_CONTENT_ERROR_NONE;
 236         video_meta_s *_video = (video_meta_s*)video;
 237         if(_video)
 238         {
 239                 if(STRING_VALID(_video->album))
 240                 {
 241                         char *new_string = strdup(_video->album);
 242                         media_content_retvm_if(new_string == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
 243
 244                         *album = new_string;
 245                 }
 246                 else
 247                 {
 248                         *album = NULL;
 249                 }
 250                 ret = MEDIA_CONTENT_ERROR_NONE;
 251
 252         }
 253         else
 254         {
 255                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 256                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 257         }
 258
 259         return ret;
 260 }
 261
 262 int video_meta_get_artist(video_meta_h video, char **artist)
 263 {
 264         int ret = MEDIA_CONTENT_ERROR_NONE;
 265         video_meta_s *_video = (video_meta_s*)video;
 266         if(_video)
 267         {
 268                 if(STRING_VALID(_video->artist))
 269                 {
 270                         char *new_string = strdup(_video->artist);
 271                         media_content_retvm_if(new_string == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
 272
 273                         *artist = new_string;
 274                 }
 275                 else
 276                 {
 277                         *artist = NULL;
 278                 }
 279                 ret = MEDIA_CONTENT_ERROR_NONE;
 280
 281         }
 282         else
 283         {
 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_album_artist(video_meta_h video, char **album_artist)
 292 {
 293         int ret = MEDIA_CONTENT_ERROR_NONE;
 294         video_meta_s *_video = (video_meta_s*)video;
 295         if(_video)
 296         {
 297                 if(STRING_VALID(_video->album_artist))
 298                 {
 299                         char *new_string = strdup(_video->album_artist);
 300                         media_content_retvm_if(new_string == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
 301
 302                         *album_artist = new_string;
 303                 }
 304                 else
 305                 {
 306                         *album_artist = NULL;
 307                 }
 308                 ret = MEDIA_CONTENT_ERROR_NONE;
 309
 310         }
 311         else
 312         {
 313                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 314                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 315         }
 316
 317         return ret;
 318
 319 }
 320
 321 int video_meta_get_genre(video_meta_h video, char **genre)
 322 {
 323         int ret = MEDIA_CONTENT_ERROR_NONE;
 324         video_meta_s *_video = (video_meta_s*)video;
 325         if(_video)
 326         {
 327                 if(STRING_VALID(_video->genre))
 328                 {
 329                         char *new_string = strdup(_video->genre);
 330                         media_content_retvm_if(new_string == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
 331
 332                         *genre = new_string;
 333                 }
 334                 else
 335                 {
 336                         *genre = NULL;
 337                 }
 338
 339                 ret = MEDIA_CONTENT_ERROR_NONE;
 340         }
 341         else
 342         {
 343                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 344                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 345         }
 346
 347         return ret;
 348 }
 349
 350 int video_meta_get_composer(video_meta_h video, char **composer)
 351 {
 352         int ret = MEDIA_CONTENT_ERROR_NONE;
 353         video_meta_s *_video = (video_meta_s*)video;
 354         if(_video)
 355         {
 356                 if(STRING_VALID(_video->composer))
 357                 {
 358                         char *new_string = strdup(_video->composer);
 359                         media_content_retvm_if(new_string == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
 360
 361                         *composer = new_string;
 362                 }
 363                 else
 364                 {
 365                         *composer = NULL;
 366                 }
 367
 368                 ret = MEDIA_CONTENT_ERROR_NONE;
 369         }
 370         else
 371         {
 372                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 373                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 374         }
 375
 376         return ret;
 377 }
 378
 379 int video_meta_get_year(video_meta_h video, char **year)
 380 {
 381         int ret = MEDIA_CONTENT_ERROR_NONE;
 382         video_meta_s *_video = (video_meta_s*)video;
 383         if(_video)
 384         {
 385                 if(STRING_VALID(_video->year))
 386                 {
 387                         char *new_string = strdup(_video->year);
 388                         media_content_retvm_if(new_string == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
 389
 390                         *year = new_string;
 391                 }
 392                 else
 393                 {
 394                         *year = NULL;
 395                 }
 396
 397                 ret = MEDIA_CONTENT_ERROR_NONE;
 398         }
 399         else
 400         {
 401                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 402                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 403         }
 404
 405         return ret;
 406 }
 407
 408 int video_meta_get_recorded_date(video_meta_h video, char **recorded_date)
 409 {
 410         int ret = MEDIA_CONTENT_ERROR_NONE;
 411         video_meta_s *_video = (video_meta_s*)video;
 412         if(_video)
 413         {
 414                 if(STRING_VALID(_video->recorded_date))
 415                 {
 416                         char *new_string = strdup(_video->recorded_date);
 417                         media_content_retvm_if(new_string == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
 418
 419                         *recorded_date = new_string;
 420                 }
 421                 else
 422                 {
 423                         *recorded_date = NULL;
 424                 }
 425
 426                 ret = MEDIA_CONTENT_ERROR_NONE;
 427         }
 428         else
 429         {
 430                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 431                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 432         }
 433
 434         return ret;
 435 }
 436
 437 int video_meta_get_copyright(video_meta_h video, char **copyright)
 438 {
 439         int ret = MEDIA_CONTENT_ERROR_NONE;
 440         video_meta_s *_video = (video_meta_s*)video;
 441         if(_video)
 442         {
 443                 if(STRING_VALID(_video->copyright))
 444                 {
 445                         char *new_string = strdup(_video->copyright);
 446                         media_content_retvm_if(new_string == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
 447
 448                         *copyright = new_string;
 449                 }
 450                 else
 451                 {
 452                         *copyright = NULL;
 453                 }
 454
 455                 ret = MEDIA_CONTENT_ERROR_NONE;
 456         }
 457         else
 458         {
 459                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 460                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 461         }
 462
 463         return ret;
 464 }
 465
 466 int video_meta_get_track_num(video_meta_h video, char **track_num)
 467 {
 468         int ret = MEDIA_CONTENT_ERROR_NONE;
 469         video_meta_s *_video = (video_meta_s*)video;
 470         if(_video)
 471         {
 472                 if(STRING_VALID(_video->track_num))
 473                 {
 474                         char *new_string = strdup(_video->track_num);
 475                         media_content_retvm_if(new_string == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
 476
 477                         *track_num = new_string;
 478                 }
 479                 else
 480                 {
 481                         *track_num = NULL;
 482                 }
 483
 484                 ret = MEDIA_CONTENT_ERROR_NONE;
 485         }
 486         else
 487         {
 488                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 489                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 490         }
 491
 492         return ret;
 493 }
 494
 495 int video_meta_get_bit_rate(video_meta_h video, int *bit_rate)
 496 {
 497         int ret = MEDIA_CONTENT_ERROR_NONE;
 498         video_meta_s *_video = (video_meta_s*)video;
 499
 500         if(_video && bit_rate)
 501         {
 502                 *bit_rate = _video->bitrate;
 503                 ret = MEDIA_CONTENT_ERROR_NONE;
 504         }
 505         else
 506         {
 507                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 508                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 509         }
 510
 511         return ret;
 512 }
 513
 514 int video_meta_get_duration(video_meta_h video, int *duration)
 515 {
 516         int ret = MEDIA_CONTENT_ERROR_NONE;
 517         video_meta_s *_video = (video_meta_s*)video;
 518
 519         if(_video && duration)
 520         {
 521                 *duration = _video->duration;
 522                 ret = MEDIA_CONTENT_ERROR_NONE;
 523         }
 524         else
 525         {
 526                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 527                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 528         }
 529
 530         return ret;
 531 }
 532
 533 int video_meta_get_width(video_meta_h video, int *width)
 534 {
 535         int ret = MEDIA_CONTENT_ERROR_NONE;
 536         video_meta_s *_video = (video_meta_s*)video;
 537
 538         if(_video && width)
 539         {
 540                 *width = _video->width;
 541                 ret = MEDIA_CONTENT_ERROR_NONE;
 542         }
 543         else
 544         {
 545                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 546                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 547         }
 548
 549         return ret;
 550 }
 551
 552 int video_meta_get_height(video_meta_h video, int *height)
 553 {
 554         int ret = MEDIA_CONTENT_ERROR_NONE;
 555         video_meta_s *_video = (video_meta_s*)video;
 556         if(_video && height)
 557         {
 558                 *height = _video->height;
 559                 ret = MEDIA_CONTENT_ERROR_NONE;
 560         }
 561         else
 562         {
 563                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 564                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 565         }
 566
 567         return ret;
 568 }
 569
 570 int video_meta_get_played_count(video_meta_h video, int *played_count)
 571 {
 572         int ret = MEDIA_CONTENT_ERROR_NONE;
 573         video_meta_s *_video = (video_meta_s*)video;
 574
 575         if(_video && played_count)
 576         {
 577                 *played_count = _video->played_count;
 578                 ret = MEDIA_CONTENT_ERROR_NONE;
 579         }
 580         else
 581         {
 582                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 583                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 584         }
 585
 586         return ret;
 587 }
 588
 589 int video_meta_get_played_time(video_meta_h video, time_t* played_time)
 590 {
 591         int ret = MEDIA_CONTENT_ERROR_NONE;
 592         video_meta_s *_video = (video_meta_s*)video;
 593
 594         if(_video)
 595         {
 596                 *played_time = _video->played_time;
 597                 ret = MEDIA_CONTENT_ERROR_NONE;
 598         }
 599         else
 600         {
 601                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 602                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 603         }
 604
 605         return ret;
 606 }
 607
 608 int video_meta_get_played_position(video_meta_h video, int *played_position)
 609 {
 610         int ret = MEDIA_CONTENT_ERROR_NONE;
 611         video_meta_s *_video = (video_meta_s*)video;
 612
 613         if(_video)
 614         {
 615                 *played_position = _video->played_position;
 616                 ret = MEDIA_CONTENT_ERROR_NONE;
 617         }
 618         else
 619         {
 620                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 621                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 622         }
 623
 624         return ret;
 625 }
 626
 627 int video_meta_set_played_count(video_meta_h video, int played_count)
 628 {
 629         int ret = MEDIA_CONTENT_ERROR_NONE;
 630         video_meta_s *_video = (video_meta_s*)video;
 631
 632         if((_video != NULL) && (played_count >= 0))
 633         {
 634                 _video->played_count = played_count;
 635         }
 636         else
 637         {
 638                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 639                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 640         }
 641
 642         return ret;
 643 }
 644
 645 int video_meta_set_played_time(video_meta_h video, time_t played_time)
 646 {
 647         int ret = MEDIA_CONTENT_ERROR_NONE;
 648         video_meta_s *_video = (video_meta_s*)video;
 649
 650         if((_video != NULL) && (played_time >= 0))
 651         {
 652                 _video->played_time = played_time;
 653         }
 654         else
 655         {
 656                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 657                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 658         }
 659
 660         return ret;
 661 }
 662
 663 int video_meta_set_played_position(video_meta_h video, int played_position)
 664 {
 665         int ret = MEDIA_CONTENT_ERROR_NONE;
 666         video_meta_s *_video = (video_meta_s*)video;
 667
 668         if((_video != NULL) && (played_position >= 0))
 669         {
 670                 _video->played_position = played_position;
 671         }
 672         else
 673         {
 674                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 675                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 676         }
 677
 678         return ret;
 679 }
 680
 681 int video_meta_update_to_db(video_meta_h video)
 682 {
 683         int ret = MEDIA_CONTENT_ERROR_NONE;
 684         video_meta_s *_video = (video_meta_s*)video;
 685         char *sql = NULL;
 686
 687         if(_video != NULL && STRING_VALID(_video->media_id))
 688         {
 689                 char storage_id[MEDIA_CONTENT_UUID_SIZE+1] = {0, };
 690                 memset(storage_id, 0x00, sizeof(storage_id));
 691
 692                 ret = _media_db_get_storage_id_by_media_id(_video->media_id, storage_id);
 693                 media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 694
 695                 sql = sqlite3_mprintf(UPDATE_AV_META_FROM_MEDIA, storage_id, _video->played_count, _video->played_time, _video->played_position, _video->media_id);
 696                 ret = _content_query_sql(sql);
 697                 SQLITE3_SAFE_FREE(sql);
 698         }
 699         else
 700         {
 701                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 702                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 703         }
 704
 705         return ret;
 706 }