src/media_pvr.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 #ifdef _USE_TVPD_MODE
  18 #include <media_info_private.h>
  19 #include <media_util_private.h>
  20 #include <media_pvr.h>
  21
  22
  23 int media_pvr_get_media_count_from_db(filter_h filter, int *media_count)
  24 {
  25         int ret = MEDIA_CONTENT_ERROR_NONE;
  26
  27         if (media_count) {
  28                 ret = _media_db_get_group_item_count(NULL, filter, MEDIA_GROUP_PVR, media_count);
  29         } else {
  30                 content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
  31                 return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
  32         }
  33
  34         return ret;
  35 }
  36
  37 int media_pvr_foreach_media_from_db(filter_h filter, media_pvr_cb callback, void *user_data)
  38 {
  39         int ret = MEDIA_CONTENT_ERROR_NONE;
  40
  41         if (callback != NULL) {
  42                 ret = _media_db_get_pvr(filter, callback, user_data);
  43         } else {
  44                 content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
  45                 return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
  46         }
  47
  48         return ret;
  49 }
  50
  51 int media_pvr_destroy(media_pvr_h pvr)
  52 {
  53         int ret = MEDIA_CONTENT_ERROR_NONE;
  54         media_pvr_s *_pvr = (media_pvr_s*)pvr;
  55         if (_pvr) {
  56                 SAFE_FREE(_pvr->media_id);
  57                 SAFE_FREE(_pvr->storage_id);
  58                 SAFE_FREE(_pvr->channel_name);
  59                 SAFE_FREE(_pvr->channel_num);
  60                 SAFE_FREE(_pvr->program_title);
  61                 SAFE_FREE(_pvr->program_crid);
  62                 SAFE_FREE(_pvr->guidance);
  63                 SAFE_FREE(_pvr->synopsis);
  64                 SAFE_FREE(_pvr->genre);
  65                 SAFE_FREE(_pvr->language);
  66                 SAFE_FREE(_pvr->path);
  67                 SAFE_FREE(_pvr->modified_month);
  68                 SAFE_FREE(_pvr->private_data);
  69                 SAFE_FREE(_pvr);
  70
  71                 ret = MEDIA_CONTENT_ERROR_NONE;
  72         } else {
  73                 content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
  74                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
  75         }
  76
  77         return ret;
  78 }
  79
  80 int media_pvr_clone(media_pvr_h *dst, media_pvr_h src)
  81 {
  82         int ret = MEDIA_CONTENT_ERROR_NONE;
  83         media_pvr_s *_src = (media_pvr_s*)src;
  84
  85         if (_src != NULL) {
  86                 media_pvr_s *_dst = (media_pvr_s*)calloc(1, sizeof(media_pvr_s));
  87                 if (_dst == NULL) {
  88                         content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
  89                         return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
  90                 }
  91
  92                 if (STRING_VALID(_src->media_id)) {
  93                         _dst->media_id = strdup(_src->media_id);
  94                         if (_dst->media_id == NULL) {
  95                                 media_pvr_destroy((media_pvr_h)_dst);
  96                                 content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
  97                                 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
  98                         }
  99                 }
 100
 101                 if (STRING_VALID(_src->channel_name)) {
 102                         _dst->channel_name = strdup(_src->channel_name);
 103                         if (_dst->channel_name == NULL) {
 104                                 content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
 105                                 media_pvr_destroy((media_pvr_h)_dst);
 106                                 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
 107                         }
 108                 }
 109
 110                 if (STRING_VALID(_src->channel_num)) {
 111                         _dst->channel_num = strdup(_src->channel_num);
 112                         if (_dst->channel_num == NULL) {
 113                                 content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
 114                                 media_pvr_destroy((media_pvr_h)_dst);
 115                                 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
 116                         }
 117                 }
 118
 119                 if (STRING_VALID(_src->program_title)) {
 120                         _dst->program_title = strdup(_src->program_title);
 121                         if (_dst->program_title == NULL) {
 122                                 content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
 123                                 media_pvr_destroy((media_pvr_h)_dst);
 124                                 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
 125                         }
 126                 }
 127
 128                 if (STRING_VALID(_src->program_crid)) {
 129                         _dst->program_crid = strdup(_src->program_crid);
 130                         if (_dst->program_crid == NULL) {
 131                                 content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
 132                                 media_pvr_destroy((media_pvr_h)_dst);
 133                                 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
 134                         }
 135                 }
 136
 137                 if (STRING_VALID(_src->guidance)) {
 138                         _dst->guidance = strdup(_src->guidance);
 139                         if (_dst->guidance == NULL) {
 140                                 content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
 141                                 media_pvr_destroy((media_pvr_h)_dst);
 142                                 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
 143                         }
 144                 }
 145
 146                 if (STRING_VALID(_src->synopsis)) {
 147                         _dst->synopsis = strdup(_src->synopsis);
 148                         if (_dst->synopsis == NULL) {
 149                                 content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
 150                                 media_pvr_destroy((media_pvr_h)_dst);
 151                                 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
 152                         }
 153                 }
 154
 155                 if (STRING_VALID(_src->genre)) {
 156                         _dst->genre = strdup(_src->genre);
 157                         if (_dst->genre == NULL) {
 158                                 content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
 159                                 media_pvr_destroy((media_pvr_h)_dst);
 160                                 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
 161                         }
 162                 }
 163
 164                 if (STRING_VALID(_src->language)) {
 165                         _dst->language = strdup(_src->language);
 166                         if (_dst->language == NULL) {
 167                                 content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
 168                                 media_pvr_destroy((media_pvr_h)_dst);
 169                                 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
 170                         }
 171                 }
 172
 173                 if (STRING_VALID(_src->path)) {
 174                         _dst->path = strdup(_src->path);
 175                         if (_dst->path == NULL) {
 176                                 content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
 177                                 media_pvr_destroy((media_pvr_h)_dst);
 178                                 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
 179                         }
 180                 }
 181
 182                 if (STRING_VALID(_src->storage_id)) {
 183                         _dst->storage_id = strdup(_src->storage_id);
 184                         if (_dst->storage_id == NULL) {
 185                                 content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
 186                                 media_pvr_destroy((media_pvr_h)_dst);
 187                                 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
 188                         }
 189                 }
 190
 191                 if (STRING_VALID(_src->modified_month)) {
 192                         _dst->modified_month = strdup(_src->modified_month);
 193                         if (_dst->modified_month == NULL) {
 194                                 content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
 195                                 media_pvr_destroy((media_pvr_h)_dst);
 196                                 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
 197                         }
 198                 }
 199
 200                 if (STRING_VALID(_src->private_data)) {
 201                         _dst->private_data = strdup(_src->private_data);
 202                         if (_dst->private_data == NULL) {
 203                                 content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
 204                                 media_pvr_destroy((media_pvr_h)_dst);
 205                                 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
 206                         }
 207                 }
 208                 _dst->duration = _src->duration;
 209                 _dst->timezone = _src->timezone;
 210                 _dst->ptc = _src->ptc;
 211                 _dst->major = _src->major;
 212                 _dst->minor = _src->minor;
 213                 _dst->channel_type = _src->channel_type;
 214                 _dst->program_num = _src->program_num;
 215                 _dst->service_profile = _src->service_profile;
 216                 _dst->timer_record = _src->timer_record;
 217                 _dst->series_record = _src->series_record;
 218                 _dst->hd = _src->hd;
 219                 _dst->subtitle = _src->subtitle;
 220                 _dst->ttx = _src->ttx;
 221                 _dst->ad = _src->ad;
 222                 _dst->hard_of_hearing_radio = _src->hard_of_hearing_radio;
 223                 _dst->data_service = _src->data_service;
 224                 _dst->content_lock = _src->content_lock;
 225                 _dst->embargo_time = _src->embargo_time;
 226                 _dst->expiry_time = _src->expiry_time;
 227                 _dst->size = _src->size;
 228                 _dst->parental_rating = _src->parental_rating;
 229                 _dst->start_time = _src->start_time;
 230                 _dst->program_start_time = _src->program_start_time;
 231                 _dst->program_end_time = _src->program_end_time;
 232                 _dst->program_date = _src->program_date;
 233                 _dst->content_watch = _src->content_watch;
 234                 _dst->has_audio_only = _src->has_audio_only;
 235                 _dst->is_local_record = _src->is_local_record;
 236                 _dst->resolution = _src->resolution;
 237                 _dst->aspectratio = _src->aspectratio;
 238                 _dst->sports_type = _src->sports_type;
 239                 _dst->guidance_length = _src->guidance_length;
 240                 _dst->tvmode = _src->tvmode;
 241                 _dst->play_count = _src->play_count;
 242
 243                 *dst = (media_pvr_h)_dst;
 244
 245                 ret = MEDIA_CONTENT_ERROR_NONE;
 246         } else {
 247                 content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 248                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 249         }
 250
 251         return ret;
 252 }
 253
 254 int media_pvr_get_pvr_from_db(const char *media_id, media_pvr_h *pvr)
 255 {
 256         int ret = MEDIA_CONTENT_ERROR_NONE;
 257         char *select_query = NULL;
 258         sqlite3_stmt *stmt = NULL;
 259
 260         if (!STRING_VALID(media_id) || (pvr == NULL)) {
 261                 content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 262                 return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 263         }
 264
 265         select_query = sqlite3_mprintf(SELECT_PVR_FROM_PVR, media_id);
 266
 267         ret = _content_get_result(select_query, &stmt);
 268         sqlite3_free(select_query);
 269         content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 270
 271         media_pvr_s *_pvr = NULL;
 272
 273         if (sqlite3_step(stmt) == SQLITE_ROW) {
 274                 _pvr = (media_pvr_s*)calloc(1, sizeof(media_pvr_s));
 275
 276                 if (_pvr == NULL) {
 277                         content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
 278                         SQLITE3_FINALIZE(stmt);
 279                         return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
 280                 }
 281
 282                 _media_pvr_item_get_detail(stmt, (media_pvr_h)_pvr);
 283
 284                 *pvr = (media_info_h)_pvr;
 285         } else {
 286                 content_error("Nonexistent media_id[%s]", media_id);
 287                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 288         }
 289
 290         SQLITE3_FINALIZE(stmt);
 291
 292         return ret;
 293 }
 294
 295 int media_pvr_get_media_id(media_pvr_h pvr, char **media_id)
 296 {
 297         int ret = MEDIA_CONTENT_ERROR_NONE;
 298         media_pvr_s *_pvr = (media_pvr_s*)pvr;
 299
 300         if (_pvr && media_id) {
 301                 if (STRING_VALID(_pvr->media_id)) {
 302                         *media_id = strdup(_pvr->media_id);
 303                         if (*media_id == NULL) {
 304                                 content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
 305                                 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
 306                         }
 307                 } else {
 308                         *media_id = NULL;
 309                 }
 310
 311                 ret = MEDIA_CONTENT_ERROR_NONE;
 312         } else {
 313                 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 media_pvr_get_channel_name(media_pvr_h pvr, char **channel_name)
 321 {
 322         int ret = MEDIA_CONTENT_ERROR_NONE;
 323         media_pvr_s *_pvr = (media_pvr_s*)pvr;
 324
 325         if (_pvr && channel_name) {
 326                 if (STRING_VALID(_pvr->channel_name)) {
 327                         *channel_name = strdup(_pvr->channel_name);
 328                         if (*channel_name == NULL) {
 329                                 content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
 330                                 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
 331                         }
 332                 } else {
 333                         *channel_name = NULL;
 334                 }
 335
 336                 ret = MEDIA_CONTENT_ERROR_NONE;
 337         } else {
 338                 content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 339                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 340         }
 341
 342         return ret;
 343 }
 344
 345 int media_pvr_get_channel_num(media_pvr_h pvr, char **channel_num)
 346 {
 347         int ret = MEDIA_CONTENT_ERROR_NONE;
 348         media_pvr_s *_pvr = (media_pvr_s*)pvr;
 349
 350         if (_pvr && channel_num) {
 351                 if (STRING_VALID(_pvr->channel_num)) {
 352                         *channel_num = strdup(_pvr->channel_num);
 353                         if (*channel_num == NULL) {
 354                                 content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
 355                                 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
 356                         }
 357                 } else {
 358                         *channel_num = NULL;
 359                 }
 360
 361                 ret = MEDIA_CONTENT_ERROR_NONE;
 362         } else {
 363                 content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 364                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 365         }
 366
 367         return ret;
 368 }
 369
 370 int media_pvr_get_program_title(media_pvr_h pvr, char **program_title)
 371 {
 372         int ret = MEDIA_CONTENT_ERROR_NONE;
 373         media_pvr_s *_pvr = (media_pvr_s*)pvr;
 374
 375         if (_pvr && program_title) {
 376                 if (STRING_VALID(_pvr->program_title)) {
 377                         *program_title = strdup(_pvr->program_title);
 378                         if (*program_title == NULL) {
 379                                 content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
 380                                 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
 381                         }
 382                 } else {
 383                         *program_title = NULL;
 384                 }
 385
 386                 ret = MEDIA_CONTENT_ERROR_NONE;
 387         } else {
 388                 content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 389                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 390         }
 391
 392         return ret;
 393 }
 394
 395 int media_pvr_get_program_crid(media_pvr_h pvr, char **program_crid)
 396 {
 397         int ret = MEDIA_CONTENT_ERROR_NONE;
 398         media_pvr_s *_pvr = (media_pvr_s*)pvr;
 399
 400         if (_pvr && program_crid) {
 401                 if (STRING_VALID(_pvr->program_crid)) {
 402                         *program_crid = strdup(_pvr->program_crid);
 403                         if (*program_crid == NULL) {
 404                                 content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
 405                                 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
 406                         }
 407                 } else {
 408                         *program_crid = NULL;
 409                 }
 410
 411                 ret = MEDIA_CONTENT_ERROR_NONE;
 412         } else {
 413                 content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 414                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 415         }
 416
 417         return ret;
 418 }
 419
 420 int media_pvr_get_guidance(media_pvr_h pvr, char **guidance)
 421 {
 422         int ret = MEDIA_CONTENT_ERROR_NONE;
 423         media_pvr_s *_pvr = (media_pvr_s*)pvr;
 424
 425         if (_pvr && guidance) {
 426                 if (STRING_VALID(_pvr->guidance)) {
 427                         *guidance = strdup(_pvr->guidance);
 428                         if (*guidance == NULL) {
 429                                 content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
 430                                 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
 431                         }
 432                 } else {
 433                         *guidance = NULL;
 434                 }
 435
 436                 ret = MEDIA_CONTENT_ERROR_NONE;
 437         } else {
 438                 content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 439                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 440         }
 441
 442         return ret;
 443 }
 444
 445 int media_pvr_get_synopsis(media_pvr_h pvr, char **synopsis)
 446 {
 447         int ret = MEDIA_CONTENT_ERROR_NONE;
 448         media_pvr_s *_pvr = (media_pvr_s*)pvr;
 449
 450         if (_pvr && synopsis) {
 451                 if (STRING_VALID(_pvr->synopsis)) {
 452                         *synopsis = strdup(_pvr->synopsis);
 453                         if (*synopsis == NULL) {
 454                                 content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
 455                                 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
 456                         }
 457                 } else {
 458                         *synopsis = NULL;
 459                 }
 460
 461                 ret = MEDIA_CONTENT_ERROR_NONE;
 462         } else {
 463                 content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 464                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 465         }
 466
 467         return ret;
 468 }
 469
 470 int media_pvr_get_genre(media_pvr_h pvr, char **genre)
 471 {
 472         int ret = MEDIA_CONTENT_ERROR_NONE;
 473         media_pvr_s *_pvr = (media_pvr_s*)pvr;
 474
 475         if (_pvr && genre) {
 476                 if (STRING_VALID(_pvr->genre)) {
 477                         *genre = strdup(_pvr->genre);
 478                         if (*genre == NULL) {
 479                                 content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
 480                                 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
 481                         }
 482                 } else {
 483                         *genre = NULL;
 484                 }
 485
 486                 ret = MEDIA_CONTENT_ERROR_NONE;
 487         } else {
 488                 content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 489                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 490         }
 491
 492         return ret;
 493 }
 494
 495 int media_pvr_get_language(media_pvr_h pvr, char **language)
 496 {
 497         int ret = MEDIA_CONTENT_ERROR_NONE;
 498         media_pvr_s *_pvr = (media_pvr_s*)pvr;
 499
 500         if (_pvr && language) {
 501                 if (STRING_VALID(_pvr->language)) {
 502                         *language = strdup(_pvr->language);
 503                         if (*language == NULL) {
 504                                 content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
 505                                 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
 506                         }
 507                 } else {
 508                         *language = NULL;
 509                 }
 510
 511                 ret = MEDIA_CONTENT_ERROR_NONE;
 512         } else {
 513                 content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 514                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 515         }
 516
 517         return ret;
 518 }
 519
 520 int media_pvr_get_path(media_pvr_h pvr, char **path)
 521 {
 522         int ret = MEDIA_CONTENT_ERROR_NONE;
 523         media_pvr_s *_pvr = (media_pvr_s*)pvr;
 524
 525         if (_pvr && path) {
 526                 if (STRING_VALID(_pvr->path)) {
 527                         *path = strdup(_pvr->path);
 528                         if (*path == NULL) {
 529                                 content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
 530                                 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
 531                         }
 532                 } else {
 533                         *path = NULL;
 534                 }
 535
 536                 ret = MEDIA_CONTENT_ERROR_NONE;
 537         } else {
 538                 content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 539                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 540         }
 541
 542         return ret;
 543 }
 544
 545 int media_pvr_get_storage_id(media_pvr_h pvr, char **storage_id)
 546 {
 547         int ret = MEDIA_CONTENT_ERROR_NONE;
 548         media_pvr_s *_pvr = (media_pvr_s*)pvr;
 549
 550         if (_pvr && storage_id) {
 551                 if (STRING_VALID(_pvr->storage_id)) {
 552                         *storage_id = strdup(_pvr->storage_id);
 553                         if (*storage_id == NULL) {
 554                                 content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
 555                                 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
 556                         }
 557                 } else {
 558                         *storage_id = NULL;
 559                 }
 560
 561                 ret = MEDIA_CONTENT_ERROR_NONE;
 562         } else {
 563                 content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 564                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 565         }
 566
 567         return ret;
 568 }
 569
 570 int media_pvr_get_size(media_pvr_h pvr, unsigned long long *size)
 571 {
 572         int ret = MEDIA_CONTENT_ERROR_NONE;
 573         media_pvr_s *_pvr = (media_pvr_s*)pvr;
 574
 575         if (_pvr && size) {
 576                 *size = _pvr->size;
 577                 ret = MEDIA_CONTENT_ERROR_NONE;
 578         } else {
 579                 content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 580                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 581         }
 582
 583         return ret;
 584 }
 585
 586 int media_pvr_get_timezone(media_pvr_h pvr, int *timezone)
 587 {
 588         int ret = MEDIA_CONTENT_ERROR_NONE;
 589         media_pvr_s *_pvr = (media_pvr_s*)pvr;
 590
 591         if (_pvr && timezone) {
 592                 *timezone = _pvr->timezone;
 593                 ret = MEDIA_CONTENT_ERROR_NONE;
 594         } else {
 595                 content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 596                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 597         }
 598
 599         return ret;
 600 }
 601
 602 int media_pvr_get_ptc(media_pvr_h pvr, int *ptc)
 603 {
 604         int ret = MEDIA_CONTENT_ERROR_NONE;
 605         media_pvr_s *_pvr = (media_pvr_s*)pvr;
 606
 607         if (_pvr && ptc) {
 608                 *ptc = _pvr->ptc;
 609                 ret = MEDIA_CONTENT_ERROR_NONE;
 610         } else {
 611                 content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 612                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 613         }
 614
 615         return ret;
 616 }
 617
 618 int media_pvr_get_major(media_pvr_h pvr, int *major)
 619 {
 620         int ret = MEDIA_CONTENT_ERROR_NONE;
 621         media_pvr_s *_pvr = (media_pvr_s*)pvr;
 622
 623         if (_pvr && major) {
 624                 *major = _pvr->major;
 625                 ret = MEDIA_CONTENT_ERROR_NONE;
 626         } else {
 627                 content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 628                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 629         }
 630
 631         return ret;
 632 }
 633
 634 int media_pvr_get_minor(media_pvr_h pvr, int *minor)
 635 {
 636         int ret = MEDIA_CONTENT_ERROR_NONE;
 637         media_pvr_s *_pvr = (media_pvr_s*)pvr;
 638
 639         if (_pvr && minor) {
 640                 *minor = _pvr->minor;
 641                 ret = MEDIA_CONTENT_ERROR_NONE;
 642         } else {
 643                 content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 644                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 645         }
 646
 647         return ret;
 648 }
 649
 650 int media_pvr_get_channel_type(media_pvr_h pvr, int *channel_type)
 651 {
 652         int ret = MEDIA_CONTENT_ERROR_NONE;
 653         media_pvr_s *_pvr = (media_pvr_s*)pvr;
 654
 655         if (_pvr && channel_type) {
 656                 *channel_type = _pvr->channel_type;
 657                 ret = MEDIA_CONTENT_ERROR_NONE;
 658         } else {
 659                 content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 660                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 661         }
 662
 663         return ret;
 664 }
 665
 666 int media_pvr_get_program_num(media_pvr_h pvr, int *program_num)
 667 {
 668         int ret = MEDIA_CONTENT_ERROR_NONE;
 669         media_pvr_s *_pvr = (media_pvr_s*)pvr;
 670
 671         if (_pvr && program_num) {
 672                 *program_num = _pvr->program_num;
 673                 ret = MEDIA_CONTENT_ERROR_NONE;
 674         } else {
 675                 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 media_pvr_get_service_profile(media_pvr_h pvr, unsigned int *service_profile)
 683 {
 684         int ret = MEDIA_CONTENT_ERROR_NONE;
 685         media_pvr_s *_pvr = (media_pvr_s*)pvr;
 686
 687         if (_pvr && service_profile) {
 688                 *service_profile = _pvr->service_profile;
 689                 ret = MEDIA_CONTENT_ERROR_NONE;
 690         } else {
 691                 content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 692                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 693         }
 694
 695         return ret;
 696 }
 697
 698 int media_pvr_get_duration(media_pvr_h pvr, int *duration)
 699 {
 700         int ret = MEDIA_CONTENT_ERROR_NONE;
 701         media_pvr_s *_pvr = (media_pvr_s*)pvr;
 702
 703         if (_pvr && duration) {
 704                 *duration = _pvr->duration;
 705                 ret = MEDIA_CONTENT_ERROR_NONE;
 706         } else {
 707                 content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 708                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 709         }
 710
 711         return ret;
 712 }
 713
 714 int media_pvr_get_embargo_time(media_pvr_h pvr, int *embargo_time)
 715 {
 716         int ret = MEDIA_CONTENT_ERROR_NONE;
 717         media_pvr_s *_pvr = (media_pvr_s*)pvr;
 718
 719         if (_pvr && embargo_time) {
 720                 *embargo_time = _pvr->embargo_time;
 721                 ret = MEDIA_CONTENT_ERROR_NONE;
 722         } else {
 723                 content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 724                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 725         }
 726
 727         return ret;
 728 }
 729
 730 int media_pvr_get_expiry_time(media_pvr_h pvr, int *expiry_time)
 731 {
 732         int ret = MEDIA_CONTENT_ERROR_NONE;
 733         media_pvr_s *_pvr = (media_pvr_s*)pvr;
 734
 735         if (_pvr && expiry_time) {
 736                 *expiry_time = _pvr->expiry_time;
 737                 ret = MEDIA_CONTENT_ERROR_NONE;
 738         } else {
 739                 content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 740                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 741         }
 742
 743         return ret;
 744 }
 745
 746 int media_pvr_get_parental_rating(media_pvr_h pvr, int *parental_rating)
 747 {
 748         int ret = MEDIA_CONTENT_ERROR_NONE;
 749         media_pvr_s *_pvr = (media_pvr_s*)pvr;
 750
 751         if (_pvr && parental_rating) {
 752                 *parental_rating = _pvr->parental_rating;
 753                 ret = MEDIA_CONTENT_ERROR_NONE;
 754         } else {
 755                 content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 756                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 757         }
 758
 759         return ret;
 760 }
 761
 762 int media_pvr_get_start_time(media_pvr_h pvr, int *start_time)
 763 {
 764         int ret = MEDIA_CONTENT_ERROR_NONE;
 765         media_pvr_s *_pvr = (media_pvr_s*)pvr;
 766
 767         if (_pvr && start_time) {
 768                 *start_time = _pvr->start_time;
 769                 ret = MEDIA_CONTENT_ERROR_NONE;
 770         } else {
 771                 content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 772                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 773         }
 774
 775         return ret;
 776 }
 777
 778 int media_pvr_get_program_start_time(media_pvr_h pvr, int *program_start_time)
 779 {
 780         int ret = MEDIA_CONTENT_ERROR_NONE;
 781         media_pvr_s *_pvr = (media_pvr_s*)pvr;
 782
 783         if (_pvr && program_start_time) {
 784                 *program_start_time = _pvr->program_start_time;
 785                 ret = MEDIA_CONTENT_ERROR_NONE;
 786         } else {
 787                 content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 788                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 789         }
 790
 791         return ret;
 792 }
 793
 794 int media_pvr_get_program_end_time(media_pvr_h pvr, int *end_time)
 795 {
 796         int ret = MEDIA_CONTENT_ERROR_NONE;
 797         media_pvr_s *_pvr = (media_pvr_s*)pvr;
 798
 799         if (_pvr && end_time) {
 800                 *end_time = _pvr->program_end_time;
 801                 ret = MEDIA_CONTENT_ERROR_NONE;
 802         } else {
 803                 content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 804                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 805         }
 806
 807         return ret;
 808 }
 809
 810 int media_pvr_get_program_date(media_pvr_h pvr, int *program_date)
 811 {
 812         int ret = MEDIA_CONTENT_ERROR_NONE;
 813         media_pvr_s *_pvr = (media_pvr_s*)pvr;
 814
 815         if (_pvr && program_date) {
 816                 *program_date = _pvr->program_date;
 817                 ret = MEDIA_CONTENT_ERROR_NONE;
 818         } else {
 819                 content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 820                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 821         }
 822
 823         return ret;
 824 }
 825
 826 int media_pvr_get_timer_record(media_pvr_h pvr, bool* timer_record)
 827 {
 828         int ret = MEDIA_CONTENT_ERROR_NONE;
 829         media_pvr_s *_pvr = (media_pvr_s*)pvr;
 830
 831         if (_pvr && timer_record) {
 832                 *timer_record = _pvr->timer_record;
 833                 ret = MEDIA_CONTENT_ERROR_NONE;
 834         } else {
 835                 content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 836                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 837         }
 838
 839         return ret;
 840 }
 841
 842 int media_pvr_get_series_record(media_pvr_h pvr, bool* series_record)
 843 {
 844         int ret = MEDIA_CONTENT_ERROR_NONE;
 845         media_pvr_s *_pvr = (media_pvr_s*)pvr;
 846
 847         if (_pvr && series_record) {
 848                 *series_record = _pvr->series_record;
 849                 ret = MEDIA_CONTENT_ERROR_NONE;
 850         } else {
 851                 content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 852                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 853         }
 854
 855         return ret;
 856 }
 857
 858 int media_pvr_get_hd(media_pvr_h pvr, int* hd)
 859 {
 860         int ret = MEDIA_CONTENT_ERROR_NONE;
 861         media_pvr_s *_pvr = (media_pvr_s*)pvr;
 862
 863         if (_pvr && hd) {
 864                 *hd = _pvr->hd;
 865                 ret = MEDIA_CONTENT_ERROR_NONE;
 866         } else {
 867                 content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 868                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 869         }
 870
 871         return ret;
 872 }
 873
 874 int media_pvr_get_subtitle(media_pvr_h pvr, bool* subtitle)
 875 {
 876         int ret = MEDIA_CONTENT_ERROR_NONE;
 877         media_pvr_s *_pvr = (media_pvr_s*)pvr;
 878
 879         if (_pvr && subtitle) {
 880                 *subtitle = _pvr->subtitle;
 881                 ret = MEDIA_CONTENT_ERROR_NONE;
 882         } else {
 883                 content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 884                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 885         }
 886
 887         return ret;
 888 }
 889
 890 int media_pvr_get_ttx(media_pvr_h pvr, bool* ttx)
 891 {
 892         int ret = MEDIA_CONTENT_ERROR_NONE;
 893         media_pvr_s *_pvr = (media_pvr_s*)pvr;
 894
 895         if (_pvr && ttx) {
 896                 *ttx = _pvr->ttx;
 897                 ret = MEDIA_CONTENT_ERROR_NONE;
 898         } else {
 899                 content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 900                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 901         }
 902
 903         return ret;
 904 }
 905
 906 int media_pvr_get_ad(media_pvr_h pvr, bool* ad)
 907 {
 908         int ret = MEDIA_CONTENT_ERROR_NONE;
 909         media_pvr_s *_pvr = (media_pvr_s*)pvr;
 910
 911         if (_pvr && ad) {
 912                 *ad = _pvr->ad;
 913                 ret = MEDIA_CONTENT_ERROR_NONE;
 914         } else {
 915                 content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 916                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 917         }
 918
 919         return ret;
 920 }
 921
 922 int media_pvr_get_hard_of_hearing_radio(media_pvr_h pvr, bool* hard_of_hearing_radio)
 923 {
 924         int ret = MEDIA_CONTENT_ERROR_NONE;
 925         media_pvr_s *_pvr = (media_pvr_s*)pvr;
 926
 927         if (_pvr && hard_of_hearing_radio) {
 928                 *hard_of_hearing_radio = _pvr->hard_of_hearing_radio;
 929                 ret = MEDIA_CONTENT_ERROR_NONE;
 930         } else {
 931                 content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 932                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 933         }
 934
 935         return ret;
 936 }
 937
 938 int media_pvr_get_data_service(media_pvr_h pvr, bool* data_service)
 939 {
 940         int ret = MEDIA_CONTENT_ERROR_NONE;
 941         media_pvr_s *_pvr = (media_pvr_s*)pvr;
 942
 943         if (_pvr && data_service) {
 944                 *data_service = _pvr->data_service;
 945                 ret = MEDIA_CONTENT_ERROR_NONE;
 946         } else {
 947                 content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 948                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 949         }
 950
 951         return ret;
 952 }
 953
 954 int media_pvr_get_content_lock(media_pvr_h pvr, bool* content_lock)
 955 {
 956         int ret = MEDIA_CONTENT_ERROR_NONE;
 957         media_pvr_s *_pvr = (media_pvr_s*)pvr;
 958
 959         if (_pvr && content_lock) {
 960                 *content_lock = _pvr->content_lock;
 961                 ret = MEDIA_CONTENT_ERROR_NONE;
 962         } else {
 963                 content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 964                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 965         }
 966
 967         return ret;
 968 }
 969
 970 int media_pvr_get_content_watch(media_pvr_h pvr, bool* content_watch)
 971 {
 972         int ret = MEDIA_CONTENT_ERROR_NONE;
 973         media_pvr_s *_pvr = (media_pvr_s*)pvr;
 974
 975         if (_pvr && content_watch) {
 976                 *content_watch = _pvr->content_watch;
 977                 ret = MEDIA_CONTENT_ERROR_NONE;
 978         } else {
 979                 content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 980                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 981         }
 982
 983         return ret;
 984 }
 985
 986 int media_pvr_get_has_audio_only(media_pvr_h pvr, bool* has_audio_only)
 987 {
 988         int ret = MEDIA_CONTENT_ERROR_NONE;
 989         media_pvr_s *_pvr = (media_pvr_s*)pvr;
 990
 991         if (_pvr && has_audio_only) {
 992                 *has_audio_only = _pvr->has_audio_only;
 993                 ret = MEDIA_CONTENT_ERROR_NONE;
 994         } else {
 995                 content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 996                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 997         }
 998
 999         return ret;
1000 }
1001
1002 int media_pvr_get_is_local_record(media_pvr_h pvr, bool* is_local_record)
1003 {
1004         int ret = MEDIA_CONTENT_ERROR_NONE;
1005         media_pvr_s *_pvr = (media_pvr_s*)pvr;
1006
1007         if (_pvr && is_local_record) {
1008                 *is_local_record = _pvr->is_local_record;
1009                 ret = MEDIA_CONTENT_ERROR_NONE;
1010         } else {
1011                 content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
1012                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
1013         }
1014
1015         return ret;
1016 }
1017
1018 int media_pvr_get_resolution(media_pvr_h pvr, media_pvr_resolution_e* resolution)
1019 {
1020         int ret = MEDIA_CONTENT_ERROR_NONE;
1021         media_pvr_s *_pvr = (media_pvr_s*)pvr;
1022
1023         if (_pvr && resolution) {
1024                 *resolution = _pvr->resolution;
1025                 ret = MEDIA_CONTENT_ERROR_NONE;
1026         } else {
1027                 content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
1028                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
1029         }
1030
1031         return ret;
1032 }
1033
1034 int media_pvr_get_aspectratio(media_pvr_h pvr, media_pvr_aspectratio_e* aspectratio)
1035 {
1036         int ret = MEDIA_CONTENT_ERROR_NONE;
1037         media_pvr_s *_pvr = (media_pvr_s*)pvr;
1038
1039         if (_pvr && aspectratio) {
1040                 *aspectratio = _pvr->aspectratio;
1041                 ret = MEDIA_CONTENT_ERROR_NONE;
1042         } else {
1043                 content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
1044                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
1045         }
1046
1047         return ret;
1048 }
1049
1050 int media_pvr_get_modified_month(media_pvr_h pvr, char **modified_month)
1051 {
1052         int ret = MEDIA_CONTENT_ERROR_NONE;
1053         media_pvr_s *_pvr = (media_pvr_s*)pvr;
1054
1055         if (_pvr && modified_month) {
1056                 if (STRING_VALID(_pvr->modified_month)) {
1057                         *modified_month = strdup(_pvr->modified_month);
1058                         if (*modified_month == NULL) {
1059                                 content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
1060                                 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
1061                         }
1062                 } else {
1063                         *modified_month = NULL;
1064                 }
1065
1066                 ret = MEDIA_CONTENT_ERROR_NONE;
1067         } else {
1068                 content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
1069                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
1070         }
1071
1072         return ret;
1073 }
1074
1075 int media_pvr_get_sports_type(media_pvr_h pvr, int* sports_type)
1076 {
1077         int ret = MEDIA_CONTENT_ERROR_NONE;
1078         media_pvr_s *_pvr = (media_pvr_s*)pvr;
1079
1080         if (_pvr && sports_type) {
1081                 *sports_type = _pvr->sports_type;
1082                 ret = MEDIA_CONTENT_ERROR_NONE;
1083         } else {
1084                 content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
1085                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
1086         }
1087
1088         return ret;
1089 }
1090
1091 int media_pvr_get_guidance_length(media_pvr_h pvr, int* guidance_length)
1092 {
1093         int ret = MEDIA_CONTENT_ERROR_NONE;
1094         media_pvr_s *_pvr = (media_pvr_s*)pvr;
1095
1096         if (_pvr && guidance_length) {
1097                 *guidance_length = _pvr->guidance_length;
1098                 ret = MEDIA_CONTENT_ERROR_NONE;
1099         } else {
1100                 content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
1101                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
1102         }
1103
1104         return ret;
1105 }
1106
1107 int media_pvr_get_tvmode(media_pvr_h pvr, int* tvmode)
1108 {
1109         int ret = MEDIA_CONTENT_ERROR_NONE;
1110         media_pvr_s *_pvr = (media_pvr_s*)pvr;
1111
1112         if (_pvr && tvmode) {
1113                 *tvmode = _pvr->tvmode;
1114                 ret = MEDIA_CONTENT_ERROR_NONE;
1115         } else {
1116                 content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
1117                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
1118         }
1119
1120         return ret;
1121 }
1122
1123 int media_pvr_get_play_count(media_pvr_h pvr, int* play_count)
1124 {
1125         int ret = MEDIA_CONTENT_ERROR_NONE;
1126         media_pvr_s *_pvr = (media_pvr_s*)pvr;
1127
1128         if (_pvr && play_count) {
1129                 *play_count = _pvr->play_count;
1130                 ret = MEDIA_CONTENT_ERROR_NONE;
1131         } else {
1132                 content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
1133                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
1134         }
1135
1136         return ret;
1137 }
1138
1139 int media_pvr_get_private_data(media_pvr_h pvr, char **private_data)
1140 {
1141         int ret = MEDIA_CONTENT_ERROR_NONE;
1142         media_pvr_s *_pvr = (media_pvr_s*)pvr;
1143
1144         if (_pvr && private_data) {
1145                 if (STRING_VALID(_pvr->private_data)) {
1146                         *private_data = strdup(_pvr->private_data);
1147                         if (*private_data == NULL) {
1148                                 content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
1149                                 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
1150                         }
1151                 } else {
1152                         *private_data = NULL;
1153                 }
1154
1155                 ret = MEDIA_CONTENT_ERROR_NONE;
1156         } else {
1157                 content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
1158                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
1159         }
1160
1161         return ret;
1162 }
1163
1164 int media_pvr_get_highlight(media_pvr_h pvr, bool *highlight)
1165 {
1166         int ret = MEDIA_CONTENT_ERROR_NONE;
1167         media_pvr_s *_pvr = (media_pvr_s*)pvr;
1168
1169         if (_pvr && highlight) {
1170                 *highlight = _pvr->highlight;
1171                 ret = MEDIA_CONTENT_ERROR_NONE;
1172         } else {
1173                 content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
1174                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
1175         }
1176
1177         return ret;
1178 }
1179
1180 int media_pvr_set_play_count(media_pvr_h pvr, int play_count)
1181 {
1182         int ret = MEDIA_CONTENT_ERROR_NONE;
1183         media_pvr_s *_pvr = (media_pvr_s*)pvr;
1184
1185         if (_pvr != NULL) {
1186                 _pvr->play_count = play_count;
1187         } else {
1188                 content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
1189                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
1190         }
1191
1192         return ret;
1193 }
1194
1195 int media_pvr_set_program_title(media_pvr_h pvr, const char *program_title)
1196 {
1197         int ret = MEDIA_CONTENT_ERROR_NONE;
1198         media_pvr_s *_pvr = (media_pvr_s*)pvr;
1199
1200         if (_pvr != NULL && STRING_VALID(program_title)) {
1201                 SAFE_FREE(_pvr->program_title);
1202                 _pvr->program_title = strdup(program_title);
1203                 if (_pvr->program_title == NULL) {
1204                         content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
1205                         return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
1206                 }
1207         } else {
1208                 content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
1209                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
1210         }
1211
1212         return ret;
1213 }
1214
1215 int media_pvr_set_content_lock(media_pvr_h pvr, bool content_lock)
1216 {
1217         int ret = MEDIA_CONTENT_ERROR_NONE;
1218         media_pvr_s *_pvr = (media_pvr_s*)pvr;
1219
1220         if (_pvr != NULL) {
1221                 _pvr->content_lock = content_lock;
1222         } else {
1223                 content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
1224                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
1225         }
1226
1227         return ret;
1228 }
1229
1230 int media_pvr_set_content_watch(media_pvr_h pvr, bool content_watch)
1231 {
1232         int ret = MEDIA_CONTENT_ERROR_NONE;
1233         media_pvr_s *_pvr = (media_pvr_s*)pvr;
1234
1235         if (_pvr != NULL) {
1236                 _pvr->content_watch = content_watch;
1237         } else {
1238                 content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
1239                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
1240         }
1241
1242         return ret;
1243 }
1244
1245 int media_pvr_set_highlight(media_pvr_h pvr, bool highlight)
1246 {
1247         int ret = MEDIA_CONTENT_ERROR_NONE;
1248         media_pvr_s *_pvr = (media_pvr_s*)pvr;
1249
1250         if (_pvr != NULL) {
1251                 _pvr->highlight = highlight;
1252         } else {
1253                 content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
1254                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
1255         }
1256
1257         return ret;
1258 }
1259
1260 int media_pvr_update_to_db(media_pvr_h pvr)
1261 {
1262         int ret = MEDIA_CONTENT_ERROR_NONE;
1263         media_pvr_s *_pvr = (media_pvr_s*)pvr;
1264         char *update_query = NULL;
1265
1266         if (_pvr != NULL && STRING_VALID(_pvr->media_id) && STRING_VALID(_pvr->path)) {
1267                 update_query = sqlite3_mprintf(UPDATE_PVR_META_FROM_PVR, _pvr->program_title, _pvr->content_lock, _pvr->content_watch, _pvr->play_count, _pvr->highlight, _pvr->media_id);
1268
1269                 ret = _content_query_sql(update_query);
1270                 sqlite3_free(update_query);
1271
1272                 if (ret == MEDIA_CONTENT_ERROR_NONE)
1273                         media_svc_update_pvr_info(_content_get_db_handle(), _pvr->path, _pvr->program_title, _pvr->content_lock);
1274         } else {
1275                 content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
1276                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
1277         }
1278
1279         return ret;
1280 }
1281
1282 int media_pvr_group_foreach_media_from_db(const char *group_name, media_group_e group, filter_h filter, media_pvr_cb callback, void *user_data)
1283 {
1284         int ret = MEDIA_CONTENT_ERROR_NONE;
1285
1286         if ((callback == NULL) || (group < MEDIA_PVR_GROUP_DURATION) || (group >= MEDIA_GROUP_MAX)) {
1287                 content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
1288                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
1289         } else {
1290                 ret = _media_db_get_pvr_group_item(group_name, filter, group, callback, user_data);
1291         }
1292
1293         return ret;
1294 }
1295
1296 int media_pvr_set_is_local_record(const char *pvr_path, bool is_local_record)
1297 {
1298         int ret = MEDIA_CONTENT_ERROR_NONE;
1299         char *update_query = NULL;
1300         char storage_id[MEDIA_CONTENT_UUID_SIZE+1] = {0,};
1301
1302         if (pvr_path == NULL) {
1303                 content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
1304                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
1305         } else {
1306
1307                 /*get the storage uuid*/
1308                 ret = media_svc_get_storage_id(_content_get_db_handle(), pvr_path, storage_id, tzplatform_getuid(TZ_USER_NAME));
1309                 if (ret == MS_MEDIA_ERR_NONE) {
1310                         content_error("storage uuid [%s]", storage_id);
1311                         update_query = sqlite3_mprintf(UPDATE_PVR_LOCAL_RECORD_PVR, is_local_record, pvr_path, storage_id);
1312
1313                         ret = _content_query_sql(update_query);
1314                         sqlite3_free(update_query);
1315                 } else {
1316                         content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
1317                         content_error("pvr path[%s] error[%d]", pvr_path, ret);
1318                         ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
1319                 }
1320         }
1321
1322         return ret;
1323 }
1324 #endif