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 int video_meta_get_genre(video_meta_h video, char **genre)
 321 {
 322         int ret = MEDIA_CONTENT_ERROR_NONE;
 323         video_meta_s *_video = (video_meta_s*)video;
 324         if (_video)
 325         {
 326                 if(STRING_VALID(_video->genre))
 327                 {
 328                         char *new_string = strdup(_video->genre);
 329                         media_content_retvm_if(new_string == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
 330
 331                         *genre = new_string;
 332                 }
 333                 else
 334                 {
 335                         *genre = NULL;
 336                 }
 337
 338                 ret = MEDIA_CONTENT_ERROR_NONE;
 339         }
 340         else
 341         {
 342                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 343                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 344         }
 345
 346         return ret;
 347 }
 348
 349 int video_meta_get_composer(video_meta_h video, char **composer)
 350 {
 351         int ret = MEDIA_CONTENT_ERROR_NONE;
 352         video_meta_s *_video = (video_meta_s*)video;
 353         if (_video)
 354         {
 355                 if(STRING_VALID(_video->composer))
 356                 {
 357                         char *new_string = strdup(_video->composer);
 358                         media_content_retvm_if(new_string == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
 359
 360                         *composer = new_string;
 361                 }
 362                 else
 363                 {
 364                         *composer = NULL;
 365                 }
 366
 367                 ret = MEDIA_CONTENT_ERROR_NONE;
 368         }
 369         else
 370         {
 371                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 372                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 373         }
 374
 375         return ret;
 376 }
 377
 378 int video_meta_get_year(video_meta_h video, char **year)
 379 {
 380         int ret = MEDIA_CONTENT_ERROR_NONE;
 381         video_meta_s *_video = (video_meta_s*)video;
 382         if (_video)
 383         {
 384                 if(STRING_VALID(_video->year))
 385                 {
 386                         char *new_string = strdup(_video->year);
 387                         media_content_retvm_if(new_string == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
 388
 389                         *year = new_string;
 390                 }
 391                 else
 392                 {
 393                         *year = NULL;
 394                 }
 395
 396                 ret = MEDIA_CONTENT_ERROR_NONE;
 397         }
 398         else
 399         {
 400                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 401                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 402         }
 403
 404         return ret;
 405 }
 406
 407 int video_meta_get_recorded_date(video_meta_h video, char **recorded_date)
 408 {
 409         int ret = MEDIA_CONTENT_ERROR_NONE;
 410         video_meta_s *_video = (video_meta_s*)video;
 411         if (_video)
 412         {
 413                 if(STRING_VALID(_video->recorded_date))
 414                 {
 415                         char *new_string = strdup(_video->recorded_date);
 416                         media_content_retvm_if(new_string == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
 417
 418                         *recorded_date = new_string;
 419                 }
 420                 else
 421                 {
 422                         *recorded_date = NULL;
 423                 }
 424
 425                 ret = MEDIA_CONTENT_ERROR_NONE;
 426         }
 427         else
 428         {
 429                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 430                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 431         }
 432
 433         return ret;
 434 }
 435
 436 int video_meta_get_copyright(video_meta_h video, char **copyright)
 437 {
 438         int ret = MEDIA_CONTENT_ERROR_NONE;
 439         video_meta_s *_video = (video_meta_s*)video;
 440         if (_video)
 441         {
 442                 if(STRING_VALID(_video->copyright))
 443                 {
 444                         char *new_string = strdup(_video->copyright);
 445                         media_content_retvm_if(new_string == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
 446
 447                         *copyright = new_string;
 448                 }
 449                 else
 450                 {
 451                         *copyright = NULL;
 452                 }
 453
 454                 ret = MEDIA_CONTENT_ERROR_NONE;
 455         }
 456         else
 457         {
 458                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 459                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 460         }
 461
 462         return ret;
 463 }
 464
 465 int video_meta_get_track_num(video_meta_h video, char **track_num)
 466 {
 467         int ret = MEDIA_CONTENT_ERROR_NONE;
 468         video_meta_s *_video = (video_meta_s*)video;
 469         if (_video)
 470         {
 471                 if(STRING_VALID(_video->track_num))
 472                 {
 473                         char *new_string = strdup(_video->track_num);
 474                         media_content_retvm_if(new_string == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
 475
 476                         *track_num = new_string;
 477                 }
 478                 else
 479                 {
 480                         *track_num = NULL;
 481                 }
 482
 483                 ret = MEDIA_CONTENT_ERROR_NONE;
 484         }
 485         else
 486         {
 487                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 488                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 489         }
 490
 491         return ret;
 492 }
 493
 494 int video_meta_get_bit_rate(video_meta_h video, int *bit_rate)
 495 {
 496         int ret = MEDIA_CONTENT_ERROR_NONE;
 497         video_meta_s *_video = (video_meta_s*)video;
 498
 499         if (_video && bit_rate)
 500         {
 501                 *bit_rate = _video->bitrate;
 502                 ret = MEDIA_CONTENT_ERROR_NONE;
 503         }
 504         else
 505         {
 506                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 507                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 508         }
 509
 510         return ret;
 511 }
 512
 513 int video_meta_get_duration(video_meta_h video, int *duration)
 514 {
 515         int ret = MEDIA_CONTENT_ERROR_NONE;
 516         video_meta_s *_video = (video_meta_s*)video;
 517
 518         if (_video && duration)
 519         {
 520                 *duration = _video->duration;
 521                 ret = MEDIA_CONTENT_ERROR_NONE;
 522         }
 523         else
 524         {
 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_get_width(video_meta_h video, int *width)
 533 {
 534         int ret = MEDIA_CONTENT_ERROR_NONE;
 535         video_meta_s *_video = (video_meta_s*)video;
 536
 537         if (_video && width)
 538         {
 539                 *width = _video->width;
 540                 ret = MEDIA_CONTENT_ERROR_NONE;
 541         }
 542         else
 543         {
 544                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 545                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 546         }
 547
 548         return ret;
 549 }
 550
 551 int video_meta_get_height(video_meta_h video, int *height)
 552 {
 553         int ret = MEDIA_CONTENT_ERROR_NONE;
 554         video_meta_s *_video = (video_meta_s*)video;
 555         if (_video && height)
 556         {
 557                 *height = _video->height;
 558                 ret = MEDIA_CONTENT_ERROR_NONE;
 559         }
 560         else
 561         {
 562                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 563                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 564         }
 565
 566         return ret;
 567 }
 568
 569 int video_meta_get_played_count(video_meta_h video, int *played_count)
 570 {
 571         int ret = MEDIA_CONTENT_ERROR_NONE;
 572         video_meta_s *_video = (video_meta_s*)video;
 573
 574         if (_video && played_count)
 575         {
 576                 *played_count = _video->played_count;
 577                 ret = MEDIA_CONTENT_ERROR_NONE;
 578         }
 579         else
 580         {
 581                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 582                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 583         }
 584
 585         return ret;
 586 }
 587
 588 int video_meta_get_played_time(video_meta_h video, time_t* played_time)
 589 {
 590         int ret = MEDIA_CONTENT_ERROR_NONE;
 591         video_meta_s *_video = (video_meta_s*)video;
 592
 593         if (_video)
 594         {
 595                 *played_time = _video->played_time;
 596                 ret = MEDIA_CONTENT_ERROR_NONE;
 597         }
 598         else
 599         {
 600                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 601                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 602         }
 603
 604         return ret;
 605 }
 606
 607 int video_meta_get_played_position(video_meta_h video, int *played_position)
 608 {
 609         int ret = MEDIA_CONTENT_ERROR_NONE;
 610         video_meta_s *_video = (video_meta_s*)video;
 611
 612         if (_video)
 613         {
 614                 *played_position = _video->played_position;
 615                 ret = MEDIA_CONTENT_ERROR_NONE;
 616         }
 617         else
 618         {
 619                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 620                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 621         }
 622
 623         return ret;
 624 }
 625
 626 int video_meta_set_played_count(video_meta_h video, int played_count)
 627 {
 628         int ret = MEDIA_CONTENT_ERROR_NONE;
 629         video_meta_s *_video = (video_meta_s*)video;
 630
 631         if ((_video != NULL) && (played_count >= 0))
 632         {
 633                 _video->played_count = played_count;
 634         }
 635         else
 636         {
 637                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 638                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 639         }
 640
 641         return ret;
 642 }
 643
 644 int video_meta_set_played_time(video_meta_h video, time_t played_time)
 645 {
 646         int ret = MEDIA_CONTENT_ERROR_NONE;
 647         video_meta_s *_video = (video_meta_s*)video;
 648
 649         if ((_video != NULL) && (played_time >= 0))
 650         {
 651                 _video->played_time = played_time;
 652         }
 653         else
 654         {
 655                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 656                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 657         }
 658
 659         return ret;
 660 }
 661
 662 int video_meta_set_played_position(video_meta_h video, int played_position)
 663 {
 664         int ret = MEDIA_CONTENT_ERROR_NONE;
 665         video_meta_s *_video = (video_meta_s*)video;
 666
 667         if ((_video != NULL) && (played_position >= 0))
 668         {
 669                 _video->played_position = played_position;
 670         }
 671         else
 672         {
 673                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 674                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 675         }
 676
 677         return ret;
 678 }
 679
 680 int video_meta_update_to_db(video_meta_h video)
 681 {
 682         int ret = MEDIA_CONTENT_ERROR_NONE;
 683         video_meta_s *_video = (video_meta_s*)video;
 684         char *sql = NULL;
 685
 686         if (_video != NULL && STRING_VALID(_video->media_id))
 687         {
 688                 char storage_id[MEDIA_CONTENT_UUID_SIZE+1] = {0, };
 689                 memset(storage_id, 0x00, sizeof(storage_id));
 690
 691                 ret = _media_db_get_storage_id_by_media_id(_video->media_id, storage_id);
 692                 media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 693
 694                 sql = sqlite3_mprintf(UPDATE_AV_META_FROM_MEDIA, storage_id, _video->played_count, _video->played_time, _video->played_position, _video->media_id);
 695                 ret = _content_query_sql(sql);
 696                 SQLITE3_SAFE_FREE(sql);
 697         }
 698         else
 699         {
 700                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 701                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 702         }
 703
 704         return ret;
 705 }