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