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