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