~ubuntu-branches/ubuntu/natty/gnome-dvb-daemon/natty

#define DVB_EPG_SCANNER_PIPELINE_TEMPLATE "dvbsrc name=dvbsrc adapter=%u frontend=%u pids=0:16:17:18 stats-reporting-interval=0 ! mpegtsparse ! fakesink silent=true"

262

void dvb_epg_scanner_set_DeviceGroup (DVBEPGScanner* self, DVBDeviceGroup* value);

263

261

GType dvb_settings_get_type (void);

264

262

DVBSettings* dvb_factory_get_settings (void);

265

263

gint dvb_settings_get_integer (DVBSettings* self, const char* group_name, const char* key, GError** error);

267

265

#define DVB_SETTINGS_SCAN_INTERVAL "scan_interval"

268

266

DVBEPGScanner* dvb_epg_scanner_new (DVBDeviceGroup* device);

269

267

DVBEPGScanner* dvb_epg_scanner_construct (GType object_type, DVBDeviceGroup* device);

270

DVBDeviceGroup* dvb_epg_scanner_get_DeviceGroup (DVBEPGScanner* self);

271

268

guint dvb_device_group_get_Id (DVBDeviceGroup* self);

272

269

static void dvb_epg_scanner_remove_timeouts (DVBEPGScanner* self);

273

270

static void dvb_epg_scanner_reset (DVBEPGScanner* self);

276

273

static void* _dvb_epg_scanner_worker_gthread_func (gpointer self);

277

274

GType dvb_channel_list_get_type (void);

278

275

DVBChannelList* dvb_device_group_get_Channels (DVBDeviceGroup* self);

279

guint dvb_channel_get_Frequency (DVBChannel* self);

280

276

GType dvb_device_get_type (void);

281

277

DVBDevice* dvb_device_group_get_next_free_device (DVBDeviceGroup* self);

282

278

guint dvb_device_get_Adapter (DVBDevice* self);

329

325

void dvb_schedule_add (DVBSchedule* self, DVBEvent* event);

330

326

static GObject * dvb_epg_scanner_constructor (GType type, guint n_construct_properties, GObjectConstructParam * construct_properties);

331

327

static void dvb_epg_scanner_finalize (GObject* obj);

332

static void dvb_epg_scanner_get_property (GObject * object, guint property_id, GValue * value, GParamSpec * pspec);

333

static void dvb_epg_scanner_set_property (GObject * object, guint property_id, const GValue * value, GParamSpec * pspec);

334

328

static int _vala_strcmp0 (const char * str1, const char * str2);

335

329

336

330

346

340

g_return_val_if_fail (device != NULL, NULL);

347

341

_inner_error_ = NULL;

348

342

self = g_object_newv (object_type, 0, NULL);

349

dvb_epg_scanner_set_DeviceGroup (self, device);

343

self->priv->DeviceGroup = device;

350

344

if (dvb_epg_scanner_CHECK_EIT_INTERVAL == (-1)) {

351

345

DVBSettings* settings;

352

346

settings = _g_object_ref0 (dvb_factory_get_settings ());

355

349

_tmp0_ = dvb_settings_get_integer (settings, DVB_SETTINGS_EPG_SECTION, DVB_SETTINGS_SCAN_INTERVAL, &_inner_error_);

356

350

if (_inner_error_ != NULL) {

357

351

if (_inner_error_->domain == G_KEY_FILE_ERROR) {

358

goto __catch16_g_key_file_error;

352

goto __catch18_g_key_file_error;

359

353

}

360

goto __finally16;

354

goto __finally18;

361

355

}

362

356

dvb_epg_scanner_CHECK_EIT_INTERVAL = _tmp0_ * 60;

363

357

}

364

goto __finally16;

365

__catch16_g_key_file_error:

358

goto __finally18;

359

__catch18_g_key_file_error:

366

360

{

367

361

GError * e;

368

362

e = _inner_error_;

373

367

_g_error_free0 (e);

374

368

}

375

369

}

376

__finally16:

370

__finally18:

377

371

if (_inner_error_ != NULL) {

378

372

_g_object_unref0 (settings);

379

373

g_critical ("file %s: line %d: uncaught error: %s", __FILE__, __LINE__, _inner_error_->message);

393

387

394

388

void dvb_epg_scanner_stop (DVBEPGScanner* self) {

395

389

g_return_if_fail (self != NULL);

396

g_debug ("EPGScanner.vala:76: Stopping EPG scan for group %u (%d)", dvb_device_group_get_Id (self->priv->_DeviceGroup), self->priv->stop_counter);

390

g_debug ("EPGScanner.vala:76: Stopping EPG scan for group %u (%d)", dvb_device_group_get_Id (self->priv->DeviceGroup), self->priv->stop_counter);

397

391

if (self->priv->stop_counter == 0) {

398

392

dvb_epg_scanner_remove_timeouts (self);

399

393

dvb_epg_scanner_reset (self);

487

481

gboolean result;

488

482

GError * _inner_error_;

489

483

GMainLoop* _tmp0_;

490

GeeHashSet* unique_frequencies;

491

484

DVBDevice* device;

492

485

GSource* _tmp6_;

493

486

g_return_val_if_fail (self != NULL, FALSE);

494

487

_inner_error_ = NULL;

495

g_debug ("EPGScanner.vala:134: Starting EPG scan for group %u (%d)", dvb_device_group_get_Id (self->priv->_DeviceGroup), self->priv->stop_counter);

488

g_debug ("EPGScanner.vala:134: Starting EPG scan for group %u (%d)", dvb_device_group_get_Id (self->priv->DeviceGroup), self->priv->stop_counter);

496

489

self->priv->loop = (_tmp0_ = g_main_loop_new (self->priv->context, FALSE), _g_main_loop_unref0 (self->priv->loop), _tmp0_);

497

490

{

498

491

GThread* _tmp1_;

499

492

_tmp1_ = g_thread_create (_dvb_epg_scanner_worker_gthread_func, self, TRUE, &_inner_error_);

500

493

if (_inner_error_ != NULL) {

501

goto __catch17_g_error;

502

goto __finally17;

494

goto __catch19_g_error;

495

goto __finally19;

503

496

}

504

497

self->priv->worker_thread = _tmp1_;

505

498

}

506

goto __finally17;

507

__catch17_g_error:

499

goto __finally19;

500

__catch19_g_error:

508

501

{

509

502

GError * e;

510

503

e = _inner_error_;

516

509

return result;

517

510

}

518

511

}

519

__finally17:

512

__finally19:

520

513

if (_inner_error_ != NULL) {

521

514

g_critical ("file %s: line %d: uncaught error: %s", __FILE__, __LINE__, _inner_error_->message);

522

515

g_clear_error (&_inner_error_);

528

521

return result;

529

522

}

530

523

self->priv->stop_counter = 0;

531

unique_frequencies = gee_hash_set_new (G_TYPE_UINT, NULL, NULL, NULL, NULL);

532

524

{

533

525

GeeIterator* _c_it;

534

_c_it = gee_iterable_iterator ((GeeIterable*) dvb_device_group_get_Channels (self->priv->_DeviceGroup));

526

_c_it = gee_iterable_iterator ((GeeIterable*) dvb_device_group_get_Channels (self->priv->DeviceGroup));

535

527

while (TRUE) {

536

528

DVBChannel* c;

537

guint freq;

538

529

if (!gee_iterator_next (_c_it)) {

539

530

break;

540

531

}

541

532

c = (DVBChannel*) gee_iterator_get (_c_it);

542

freq = dvb_channel_get_Frequency (c);

543

if (!gee_abstract_collection_contains ((GeeAbstractCollection*) unique_frequencies, GUINT_TO_POINTER (freq))) {

544

gee_abstract_collection_contains ((GeeAbstractCollection*) unique_frequencies, GUINT_TO_POINTER (freq));

545

g_queue_push_tail (self->priv->channels, _g_object_ref0 (c));

546

}

533

g_queue_push_tail (self->priv->channels, _g_object_ref0 (c));

547

534

_g_object_unref0 (c);

548

535

}

549

536

_g_object_unref0 (_c_it);

550

537

}

551

device = dvb_device_group_get_next_free_device (self->priv->_DeviceGroup);

538

device = dvb_device_group_get_next_free_device (self->priv->DeviceGroup);

552

539

if (device == NULL) {

553

540

result = FALSE;

554

_g_object_unref0 (unique_frequencies);

555

541

_g_object_unref0 (device);

556

542

return result;

557

543

}

565

551

GstElement* _tmp5_;

566

552

_tmp4_ = (_tmp3_ = gst_parse_launch (_tmp2_ = g_strdup_printf (DVB_EPG_SCANNER_PIPELINE_TEMPLATE, dvb_device_get_Adapter (device), dvb_device_get_Frontend (device)), &_inner_error_), _g_free0 (_tmp2_), _tmp3_);

567

553

if (_inner_error_ != NULL) {

568

goto __catch18_g_error;

569

goto __finally18;

554

goto __catch20_g_error;

555

goto __finally20;

570

556

}

571

557

self->priv->pipeline = (_tmp5_ = _tmp4_, _gst_object_unref0 (self->priv->pipeline), _tmp5_);

572

558

}

573

goto __finally18;

574

__catch18_g_error:

559

goto __finally20;

560

__catch20_g_error:

575

561

{

576

562

GError * e;

577

563

e = _inner_error_;

578

564

_inner_error_ = NULL;

579

565

{

580

g_error ("EPGScanner.vala:166: Could not create pipeline: %s", e->message);

566

g_error ("EPGScanner.vala:160: Could not create pipeline: %s", e->message);

581

567

result = FALSE;

582

568

_g_error_free0 (e);

583

_g_object_unref0 (unique_frequencies);

584

569

_g_object_unref0 (device);

585

570

return result;

586

571

}

587

572

}

588

__finally18:

573

__finally20:

589

574

if (_inner_error_ != NULL) {

590

_g_object_unref0 (unique_frequencies);

591

575

_g_object_unref0 (device);

592

576

g_critical ("file %s: line %d: uncaught error: %s", __FILE__, __LINE__, _inner_error_->message);

593

577

g_clear_error (&_inner_error_);

602

586

g_source_set_callback (self->priv->scan_source, _dvb_epg_scanner_scan_new_frequency_gsource_func, g_object_ref (self), g_object_unref);

603

587

g_source_attach (self->priv->scan_source, self->priv->context);

604

588

result = FALSE;

605

_g_object_unref0 (unique_frequencies);

606

589

_g_object_unref0 (device);

607

590

return result;

608

591

}

619

602

g_return_val_if_fail (self != NULL, FALSE);

620

603

if (g_queue_is_empty (self->priv->channels)) {

621

604

GSource* _tmp0_;

622

g_debug ("EPGScanner.vala:187: Finished EPG scan for group %u", dvb_device_group_get_Id (self->priv->_DeviceGroup));

605

g_debug ("EPGScanner.vala:181: Finished EPG scan for group %u", dvb_device_group_get_Id (self->priv->DeviceGroup));

623

606

dvb_epg_scanner_reset (self);

624

607

self->priv->queue_source = (_tmp0_ = g_timeout_source_new_seconds ((guint) dvb_epg_scanner_CHECK_EIT_INTERVAL), _g_source_unref0 (self->priv->queue_source), _tmp0_);

625

608

g_source_set_callback (self->priv->queue_source, _dvb_epg_scanner_start_gsource_func, g_object_ref (self), g_object_unref);

654

637

case GST_MESSAGE_ELEMENT:

655

638

{

656

639

if (_vala_strcmp0 (gst_structure_get_name (message->structure), "dvb-read-failure") == 0) {

657

g_critical ("EPGScanner.vala:217: Could not read from DVB device");

640

g_critical ("EPGScanner.vala:211: Could not read from DVB device");

658

641

dvb_epg_scanner_stop (self);

659

642

} else {

660

643

if (_vala_strcmp0 (gst_structure_get_name (message->structure), "eit") == 0) {

675

658

debug = NULL;

676

659

(gst_message_parse_error (message, &_tmp0_, &_tmp2_), gerror = (_tmp1_ = _tmp0_, _g_error_free0 (gerror), _tmp1_));

677

660

debug = (_tmp3_ = _tmp2_, _g_free0 (debug), _tmp3_);

678

g_critical ("EPGScanner.vala:228: %s %s", gerror->message, debug);

661

g_critical ("EPGScanner.vala:222: %s %s", gerror->message, debug);

679

662

dvb_epg_scanner_stop (self);

680

663

result = FALSE;

681

664

_g_error_free0 (gerror);

752

735

val = *gst_value_list_get_value (&events, i);

753

736

event = gst_value_get_structure (&val);

754

737

sid = dvb_epg_scanner_get_uint_val (structure, "service-id");

755

channel = dvb_channel_list_get_channel (dvb_device_group_get_Channels (self->priv->_DeviceGroup), sid);

738

channel = dvb_channel_list_get_channel (dvb_device_group_get_Channels (self->priv->DeviceGroup), sid);

756

739

if (channel == NULL) {

757

g_warning ("EPGScanner.vala:255: Could not find channel %u for this device", sid);

740

g_warning ("EPGScanner.vala:249: Could not find channel %u for this device", sid);

758

741

_g_object_unref0 (channel);

759

742

return;

760

743

}

878

861

}

879

862

880

863

881

DVBDeviceGroup* dvb_epg_scanner_get_DeviceGroup (DVBEPGScanner* self) {

882

DVBDeviceGroup* result;

883

g_return_val_if_fail (self != NULL, NULL);

884

result = self->priv->_DeviceGroup;

885

return result;

886

}

887

888

889

void dvb_epg_scanner_set_DeviceGroup (DVBEPGScanner* self, DVBDeviceGroup* value) {

890

g_return_if_fail (self != NULL);

891

self->priv->_DeviceGroup = value;

892

g_object_notify ((GObject *) self, "DeviceGroup");

893

}

894

895

896

864

static GObject * dvb_epg_scanner_constructor (GType type, guint n_construct_properties, GObjectConstructParam * construct_properties) {

897

865

GObject * obj;

898

866

GObjectClass * parent_class;

914

882

static void dvb_epg_scanner_class_init (DVBEPGScannerClass * klass) {

915

883

dvb_epg_scanner_parent_class = g_type_class_peek_parent (klass);

916

884

g_type_class_add_private (klass, sizeof (DVBEPGScannerPrivate));

917

G_OBJECT_CLASS (klass)->get_property = dvb_epg_scanner_get_property;

918

G_OBJECT_CLASS (klass)->set_property = dvb_epg_scanner_set_property;

919

885

G_OBJECT_CLASS (klass)->constructor = dvb_epg_scanner_constructor;

920

886

G_OBJECT_CLASS (klass)->finalize = dvb_epg_scanner_finalize;

921

g_object_class_install_property (G_OBJECT_CLASS (klass), DVB_EPG_SCANNER_DEVICE_GROUP, g_param_spec_object ("DeviceGroup", "DeviceGroup", "DeviceGroup", DVB_TYPE_DEVICE_GROUP, G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB | G_PARAM_READABLE | G_PARAM_WRITABLE));

922

887

dvb_epg_scanner_CHECK_EIT_INTERVAL = -1;

923

888

}

924

889

953

918

}

954

919

955

920

956

static void dvb_epg_scanner_get_property (GObject * object, guint property_id, GValue * value, GParamSpec * pspec) {

957

DVBEPGScanner * self;

958

self = DVB_EPG_SCANNER (object);

959

switch (property_id) {

960

case DVB_EPG_SCANNER_DEVICE_GROUP:

961

g_value_set_object (value, dvb_epg_scanner_get_DeviceGroup (self));

962

break;

963

default:

964

G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);

965

break;

966

}

967

}

968

969

970

static void dvb_epg_scanner_set_property (GObject * object, guint property_id, const GValue * value, GParamSpec * pspec) {

971

DVBEPGScanner * self;

972

self = DVB_EPG_SCANNER (object);

973

switch (property_id) {

974

case DVB_EPG_SCANNER_DEVICE_GROUP:

975

dvb_epg_scanner_set_DeviceGroup (self, g_value_get_object (value));

976

break;

977

default:

978

G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);

979

break;

980

}

981

}

982

983

984

921

static int _vala_strcmp0 (const char * str1, const char * str2) {

985

922

if (str1 == NULL) {

986

923

return -(str1 != str2);

Older »