← Back to branch summary

~ubuntu-branches/ubuntu/karmic/zapping/karmic

« back to all changes in this revision

Viewing changes to libvbi/teletext_decoder.c

  • Committer: Bazaar Package Importer
  • Author(s): Robert Luberda
  • Date: 2008-02-14 12:56:23 UTC
  • mfrom: (2.1.3 lenny)
  • Revision ID: james.westby@ubuntu.com-20080214125623-975n25ve2dat7jen
Tags: 0.10~cvs6-2
05_ftbfs_powerpc_libtv.patch: Try to fix FTBFS on powerpc.

Show diffs side-by-side

added added

removed removed

Lines of Context:
libvbi/teletext_decoder.c
17
17
 *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
18
18
 */
19
19
 
20
 
/* $Id: teletext_decoder.c,v 1.9 2005/06/28 00:54:48 mschimek Exp $ */
 
20
/* $Id: teletext_decoder.c,v 1.12 2006/02/03 18:24:42 mschimek Exp $ */
21
21
 
22
22
#include "../site_def.h"
23
23
 
178
178
 * Static ASCII string, NULL if @a type is invalid.
179
179
 */
180
180
const char *
181
 
vbi3_ttx_page_type_name         (vbi3_ttx_page_type     type)
 
181
vbi3_page_type_name             (vbi3_page_type         type)
182
182
{
183
183
        switch (type) {
184
184
 
779
779
                                 btt_page_type          btt_type)
780
780
{
781
781
        page_stat *ps;
782
 
        vbi3_ttx_page_type page_type;
 
782
        vbi3_page_type page_type;
783
783
        unsigned int subcode;
784
784
        vbi3_bool changed;
785
785
 
840
840
 
841
841
        log ("BTT %04x: %2u %04x %s\n",
842
842
             pgno, btt_type, subcode,
843
 
             vbi3_ttx_page_type_name (page_type));
 
843
             vbi3_page_type_name (page_type));
844
844
 
845
845
        ps = cache_network_page_stat (cn, pgno);
846
846
 
1083
1083
 
1084
1084
                        for (i = 0; i < 40; ++i) {
1085
1085
                                page_stat *ps;
1086
 
                                vbi3_ttx_page_type page_type;
 
1086
                                vbi3_page_type page_type;
1087
1087
                                unsigned int subcode;
1088
1088
                                int n;
1089
1089
 
1100
1100
 
1101
1101
                                log ("MPT %04x: %04x %x %s\n",
1102
1102
                                     pgno, subcode, n,
1103
 
                                     vbi3_ttx_page_type_name (page_type));
 
1103
                                     vbi3_page_type_name (page_type));
1104
1104
 
1105
1105
                                if (n > 9) {
1106
1106
                                        /* Has more than 9 subpages, details
1147
1147
                        for (i = 0; i < 5; ++i) {
1148
1148
                                pagenum pn;
1149
1149
                                page_stat *ps;
1150
 
                                vbi3_ttx_page_type page_type;
 
1150
                                vbi3_page_type page_type;
1151
1151
                                unsigned int subcode;
1152
1152
 
1153
1153
                                if (!top_page_number (&pn, raw)) {
1155
1155
                                        continue;
1156
1156
                                }
1157
1157
 
1158
 
                                pn.subno = vbi3_dec2bcd (pn.subno & 0x7F);
 
1158
                                pn.subno = vbi3_bin2bcd (pn.subno & 0x7F);
1159
1159
 
1160
1160
                                if (TELETEXT_DECODER_LOG) {
1161
1161
                                        log ("MPT-EX %3u: ",
1208
1208
                                 vbi3_pgno              pgno)
1209
1209
{
1210
1210
        page_stat *ps;
1211
 
        vbi3_ttx_page_type page_type;
1212
 
        vbi3_ttx_page_type old_type;
 
1211
        vbi3_page_type page_type;
 
1212
        vbi3_page_type old_type;
1213
1213
        int code;
1214
1214
        unsigned int subcode;
1215
1215
        unsigned int old_subcode;
1254
1254
 
1255
1255
        case 0x02 ... 0x4F: /* VBI3_NORMAL_PAGE with 2 ... 79 subpages */
1256
1256
                page_type = VBI3_NORMAL_PAGE;
1257
 
                subcode = vbi3_dec2bcd (code);
 
1257
                subcode = vbi3_bin2bcd (code);
1258
1258
                break;
1259
1259
 
1260
1260
        case 0x50 ... 0x51: /* normal page */
1336
1336
 
1337
1337
        case 0x82 ... 0xCF: /* VBI3_PROGR_SCHEDULE with 2 ... 79 subpages */
1338
1338
                page_type = VBI3_PROGR_SCHEDULE;
1339
 
                subcode = vbi3_dec2bcd (code & 0x7F);
 
1339
                subcode = vbi3_bin2bcd (code & 0x7F);
1340
1340
                break;
1341
1341
 
1342
1342
        case 0xE2:          /* Page format CA, undefined number of subpages. */
1379
1379
 
1380
1380
        log ("MIP %04x: %02x:%02x:%04x %s\n",
1381
1381
             pgno, page_type, ps->charset_code, subcode,
1382
 
             vbi3_ttx_page_type_name (page_type));
 
1382
             vbi3_page_type_name (page_type));
1383
1383
 
1384
1384
        return changed;
1385
1385
}
1745
1745
eacem_trigger                   (vbi3_teletext_decoder *        td,
1746
1746
                                 cache_page *           cp)
1747
1747
{
 
1748
        td = td;
 
1749
        cp = cp;
 
1750
 
1748
1751
#if 0 /* TODO */
1749
1752
 
1750
1753
        vbi3_page_priv pgp;
2008
2011
                td->header_page.pgno = cp->pgno;
2009
2012
                COPY (td->header, cp->data.lop.raw[0]);
2010
2013
 
2011
 
                /* Reset at next vbi3_teletext_decoder_decode() call. */
 
2014
                /* Reset at next vbi3_teletext_decoder_feed() call. */
2012
2015
                td->virtual_reset (td, NULL, td->timestamp + 0.0);
2013
2016
 
2014
2017
                break;
2092
2095
 
2093
2096
                ps->flags = cp->flags;
2094
2097
 
2095
 
                switch ((vbi3_ttx_page_type) ps->page_type) {
 
2098
                switch ((vbi3_page_type) ps->page_type) {
2096
2099
                case VBI3_NO_PAGE:
2097
2100
                case VBI3_UNKNOWN_PAGE:
2098
2101
                        if (cp->flags & C6_SUBTITLE)
2151
2154
                             cp->x27_designations,
2152
2155
                             cp->x28_designations);
2153
2156
 
2154
 
                        cp1 = _vbi3_cache_put_page (td->cache, td->network, cp);
 
2157
                        cp1 = _vbi3_cache_put_page (td->cache,
 
2158
                                                    td->network, cp);
2155
2159
 
2156
2160
                        if (cp1) {
2157
2161
                                vbi3_event e;
2514
2518
 
2515
2519
                ps = cache_network_page_stat (td->network, cp->pgno);
2516
2520
 
2517
 
                switch ((vbi3_ttx_page_type) ps->page_type) {
 
2521
                switch ((vbi3_page_type) ps->page_type) {
2518
2522
                case VBI3_NO_PAGE:
2519
2523
                        /* Who's wrong here? */
2520
2524
                        ps->page_type = VBI3_UNKNOWN_PAGE;
3486
3490
                                 const uint8_t          buffer[42])
3487
3491
{
3488
3492
        const vbi3_character_set *cs;
3489
 
        cache_network *cn;
3490
3493
        char *title;
3491
 
        vbi3_event e;
3492
3494
 
3493
3495
        cs = vbi3_character_set_from_code (0); /* XXX ok? */
3494
3496
        title = _vbi3_strdup_locale_teletext (buffer + 22, 20, cs);
3496
3498
        if (!title)
3497
3499
                return FALSE;
3498
3500
 
3499
 
#ifndef ZAPPING8
3500
 
        cn = td->network;
3501
 
 
3502
 
        vbi3_free (cn->program_info.title);
3503
 
        cn->program_info.title = title;
3504
 
 
3505
 
        e.type = VBI3_EVENT_PROG_INFO;
3506
 
        e.network = &cn->network;
3507
 
        e.timestamp = td->timestamp;
3508
 
        e.ev.prog_info = &cn->program_info;
3509
 
 
3510
 
        _vbi3_event_handler_list_send (&td->handlers, &e);
 
3501
#ifdef ZAPPING8
 
3502
        td = td;
 
3503
#else
 
3504
        {
 
3505
                cache_network *cn;
 
3506
                vbi3_event e;
 
3507
 
 
3508
                cn = td->network;
 
3509
 
 
3510
                vbi3_free (cn->program_info.title);
 
3511
                cn->program_info.title = title;
 
3512
 
 
3513
                e.type = VBI3_EVENT_PROG_INFO;
 
3514
                e.network = &cn->network;
 
3515
                e.timestamp = td->timestamp;
 
3516
                e.ev.prog_info = &cn->program_info;
 
3517
 
 
3518
                _vbi3_event_handler_list_send (&td->handlers, &e);
 
3519
        }
3511
3520
#endif
3512
3521
 
3513
3522
        return TRUE;
3605
3614
                        if (0 == cn->network.cni_8301) {
3606
3615
                                /* First CNI, assume no channel change. */
3607
3616
 
3608
 
                                vbi3_network_set_cni
3609
 
                                        (&cn->network, VBI3_CNI_TYPE_8301, cni);
 
3617
                                vbi3_network_set_cni (&cn->network,
 
3618
                                                      VBI3_CNI_TYPE_8301, cni);
3610
3619
 
3611
3620
                                cn->confirm_cni_8301 = 0;
3612
3621
 
3783
3792
 * @c FALSE if the packet contained incorrectable errors. 
3784
3793
 */
3785
3794
vbi3_bool
3786
 
vbi3_teletext_decoder_decode    (vbi3_teletext_decoder *        td,
 
3795
vbi3_teletext_decoder_feed      (vbi3_teletext_decoder *        td,
3787
3796
                                 const uint8_t          buffer[42],
3788
3797
                                 double                 timestamp)
3789
3798
{
 
3799
        vbi3_bool success;
3790
3800
        cache_page *cp;
3791
3801
        int pmag;
3792
3802
        int mag0;
3793
3803
        int packet;
3794
3804
 
 
3805
        success = FALSE;
 
3806
 
3795
3807
        td->timestamp = timestamp;
3796
3808
 
3797
3809
        if (td->reset_time > 0
3798
3810
            && timestamp >= td->reset_time) {
3799
3811
                cache_network *cn;
3800
 
                vbi3_event e;
3801
3812
 
3802
3813
                /* Deferred reset. */
3803
3814
 
3811
3822
        }
3812
3823
 
3813
3824
        if ((pmag = vbi3_unham16p (buffer)) < 0)
3814
 
                return FALSE;
 
3825
                goto finish;
3815
3826
 
3816
3827
        mag0 = pmag & 7;
3817
3828
        packet = pmag >> 3;
3835
3846
                     & (VBI3_EVENT_TTX_PAGE |
3836
3847
                        VBI3_EVENT_TRIGGER |
3837
3848
                        VBI3_EVENT_PAGE_TYPE |
3838
 
                        VBI3_EVENT_TOP_CHANGE)))
3839
 
                return TRUE;
 
3849
                        VBI3_EVENT_TOP_CHANGE))) {
 
3850
                success = TRUE;
 
3851
                goto finish;
 
3852
        }
3840
3853
 
3841
3854
        switch (packet) {
3842
3855
        case 0:
3843
3856
                /* Page header. */
3844
 
                return decode_packet_0 (td, cp, buffer, (unsigned int) mag0);
 
3857
                success = decode_packet_0 (td, cp, buffer,
 
3858
                                           (unsigned int) mag0);
 
3859
                break;
3845
3860
 
3846
3861
        case 1 ... 25:
3847
3862
                /* Page body. */
3848
3863
                switch (cp->function) {
3849
3864
                case PAGE_FUNCTION_DISCARD:
3850
 
                        return TRUE;
 
3865
                        success = TRUE;
 
3866
                        break;
3851
3867
 
3852
3868
                case PAGE_FUNCTION_GPOP:
3853
3869
                case PAGE_FUNCTION_POP:
3854
 
                        if (!decode_pop_packet (cp, buffer + 2,
3855
 
                                                (unsigned int) packet))
3856
 
                                return FALSE;
 
3870
                        success = decode_pop_packet (cp, buffer + 2,
 
3871
                                                     (unsigned int) packet);
3857
3872
                        break;
3858
3873
 
3859
3874
                case PAGE_FUNCTION_GDRCS:
3860
3875
                case PAGE_FUNCTION_DRCS:
3861
3876
                        memcpy (cp->data.drcs.lop.raw[packet],
3862
3877
                                buffer + 2, 40);
 
3878
                        success = TRUE;
3863
3879
                        break;
3864
3880
 
3865
3881
                case PAGE_FUNCTION_AIT:
3866
 
                        if (!(decode_ait_packet (cp, buffer + 2,
3867
 
                                                 (unsigned int) packet)))
3868
 
                                return FALSE;
 
3882
                        success = decode_ait_packet (cp, buffer + 2,
 
3883
                                                     (unsigned int) packet);
3869
3884
                        break;
3870
3885
 
3871
3886
                case PAGE_FUNCTION_EPG:
3872
 
                        // TODO
3873
 
                        return TRUE;
 
3887
                        /* TODO */
 
3888
                        success = TRUE;
 
3889
                        break;
3874
3890
 
3875
3891
                case PAGE_FUNCTION_LOP:
3876
3892
                case PAGE_FUNCTION_TRIGGER:
3884
3900
                                err |= vbi3_unpar8 (buffer[2 + i]);
3885
3901
 
3886
3902
                        if (err < 0)
3887
 
                                return FALSE;
 
3903
                                break;
3888
3904
 
3889
3905
                        memcpy (cp->data.unknown.raw[packet], buffer + 2, 40);
3890
3906
 
 
3907
                        success = TRUE;
 
3908
 
3891
3909
                        break;
3892
3910
                }
3893
3911
 
3898
3916
                case PAGE_FUNCTION_MPT_EX:
3899
3917
                default:
3900
3918
                        memcpy (cp->data.unknown.raw[packet], buffer + 2, 40);
 
3919
                        success = TRUE;
3901
3920
                        break;
3902
3921
                }
3903
3922
 
3907
3926
 
3908
3927
        case 26:
3909
3928
                /* Page enhancement packet. */
3910
 
                return decode_packet_26 (td, cp, buffer);
 
3929
                success = decode_packet_26 (td, cp, buffer);
 
3930
                break;
3911
3931
 
3912
3932
        case 27:
3913
3933
                /* Page linking. */
3914
 
                return decode_packet_27 (td, cp, buffer);
 
3934
                success = decode_packet_27 (td, cp, buffer);
 
3935
                break;
3915
3936
 
3916
3937
        case 28:
3917
3938
        case 29:
3918
3939
                /* Level 2.5/3.5 enhancement. */
3919
 
                return decode_packet_28_29 (td, cp, buffer,
3920
 
                                            (unsigned int) packet);
 
3940
                success = decode_packet_28_29 (td, cp, buffer,
 
3941
                                               (unsigned int) packet);
 
3942
                break;
3921
3943
 
3922
3944
        case 30:
3923
3945
        case 31:
3930
3952
 
3931
3953
                switch (channel) {
3932
3954
                case 0:
3933
 
                        return decode_packet_8_30 (td, buffer);
 
3955
                        success = decode_packet_8_30 (td, buffer);
 
3956
                        break;
3934
3957
 
3935
3958
                /* 1 ... 3      = Packet 1/30 ... 3/30 */
3936
3959
                /* 4            = Low bit rate audio */
3943
3966
 
3944
3967
                default:
3945
3968
                        log ("IDL %u\n", channel);
 
3969
                        success = TRUE;
3946
3970
                        break;
3947
3971
                }
3948
3972
 
3953
3977
                assert (0);
3954
3978
        }
3955
3979
 
3956
 
        return TRUE;
 
3980
 finish:
 
3981
        td->error_history = td->error_history * 2 + success;
 
3982
        return success;
3957
3983
}
3958
3984
 
3959
3985
/**
4186
4212
                                 vbi3_pid_channel       channel)
4187
4213
{
4188
4214
#ifdef ZAPPING8
 
4215
        td = td;
 
4216
        pid = pid;
 
4217
        channel = channel;
 
4218
 
4189
4219
        assert (0);
4190
4220
#else
4191
4221
        assert (NULL != td);
4333
4363
cache_network_destroy_teletext  (cache_network *        cn)
4334
4364
{
4335
4365
        /* Nothing. */
 
4366
 
 
4367
        cn = cn;
4336
4368
}
4337
4369
 
4338
4370
/**
4365
4397
        cn->have_top = FALSE;
4366
4398
}
4367
4399
 
4368
 
/* Internal reset function, called by td->virtual_reset(). */
 
4400
/**
 
4401
 * @internal
 
4402
 * @param td Teletext decoder allocated with vbi3_teletext_decoder_new().
 
4403
 * @param cn New network, can be @c NULL if 0.0 != time.
 
4404
 * @param time Deferred reset when time is greater than
 
4405
 *   vbi3_teletext_decoder_feed() timestamp. Pass a negative number to
 
4406
 *   cancel a deferred reset, 0.0 to reset immediately.
 
4407
 *
 
4408
 * Internal reset function, called via td->virtual_reset().
 
4409
 */
4369
4410
static void
4370
 
reset                           (vbi3_teletext_decoder *        td,
 
4411
internal_reset                  (vbi3_teletext_decoder *        td,
4371
4412
                                 cache_network *        cn,
4372
4413
                                 double                 time)
4373
4414
{
4374
 
        vbi3_event e;
4375
 
 
4376
4415
        assert (NULL != td);
4377
4416
 
4378
4417
        if (0)
4379
 
                fprintf (stderr, "reset %f: %f -> %f\n",
 
4418
                fprintf (stderr, "teletext reset %f: %f -> %f\n",
4380
4419
                         td->timestamp, td->reset_time, time);
4381
4420
 
4382
 
        if (time <= 0.0 || time > td->reset_time)
 
4421
        if (time <= 0.0 /* reset now or cancel deferred reset */
 
4422
            || time > td->reset_time)
4383
4423
                td->reset_time = time;
4384
4424
 
4385
 
        if (0.0 != time)
 
4425
        if (0.0 != time) {
 
4426
                /* Don't reset now. */
4386
4427
                return;
 
4428
        }
4387
4429
 
4388
4430
        assert (NULL != cn);
4389
4431
 
4400
4442
 
4401
4443
        _vbi3_teletext_decoder_resync (td);
4402
4444
 
4403
 
        e.type          = VBI3_EVENT_RESET;
4404
 
        e.network       = &td->network->network;
4405
 
        e.timestamp     = td->timestamp;
4406
 
 
4407
 
        _vbi3_event_handler_list_send (&td->handlers, &e);
 
4445
        if (internal_reset == td->virtual_reset) {
 
4446
                vbi3_event e;
 
4447
 
 
4448
                e.type          = VBI3_EVENT_RESET;
 
4449
                e.network       = &td->network->network;
 
4450
                e.timestamp     = td->timestamp;
 
4451
 
 
4452
                _vbi3_event_handler_list_send (&td->handlers, &e);
 
4453
        }
4408
4454
}
4409
4455
 
4410
4456
/**
4437
4483
 * @param event_mask Set of events (@c VBI3_EVENT_) the handler is waiting
4438
4484
 *   for, can be -1 for all and 0 for none.
4439
4485
 * @param callback Function to be called on events by
4440
 
 *   vbi3_teletext_decoder_decode() and other vbi3_teletext functions as noted.
 
4486
 *   vbi3_teletext_decoder_feed() and other vbi3_teletext functions as noted.
4441
4487
 * @param user_data User pointer passed through to the @a callback function.
4442
4488
 * 
4443
4489
 * Adds a new event handler to the Teletext decoder. When the @a callback
4500
4546
                                                  user_data)) {
4501
4547
                if (add_mask & (VBI3_EVENT_TTX_PAGE |
4502
4548
                                VBI3_EVENT_TRIGGER)) {
 
4549
                        /* XXX is this really necessary? */
4503
4550
                        _vbi3_teletext_decoder_resync (td);
4504
4551
                }
4505
4552
 
4552
4599
 * This function sends a @c VBI3_EVENT_RESET.
4553
4600
 *
4554
4601
 * You can pass a vbi3_network structure to identify the new network in
4555
 
 * advance, before the decoder receives an ID if ever.
 
4602
 * advance, before the decoder receives a network ID, if ever.
4556
4603
 */
4557
4604
void
4558
4605
vbi3_teletext_decoder_reset     (vbi3_teletext_decoder *        td,
4566
4613
        td->videostd_set = videostd_set;
4567
4614
 
4568
4615
        cn = _vbi3_cache_add_network (td->cache, nk, videostd_set);
 
4616
 
4569
4617
        td->virtual_reset (td, cn, 0.0 /* now */);
 
4618
 
4570
4619
        cache_network_unref (cn);
4571
4620
}
4572
4621
 
4638
4687
        if (!td->cache)
4639
4688
                return FALSE;
4640
4689
 
4641
 
        td->virtual_reset = reset;
 
4690
        td->virtual_reset = internal_reset;
4642
4691
 
4643
4692
        td->cni_830_timeout = 2.5; /* sec */
4644
4693
        td->cni_vps_timeout = 5 / 25.0; /* sec */
4648
4697
        td->videostd_set = videostd_set;
4649
4698
 
4650
4699
        cn = _vbi3_cache_add_network (td->cache, nk, videostd_set);
4651
 
        reset (td, cn, 0.0 /* now */);
 
4700
        internal_reset (td, cn, 0.0 /* now */);
4652
4701
        cache_network_unref (cn);
4653
4702
 
4654
4703
        return TRUE;
4655
4704
}
4656
4705
 
 
4706
static void
 
4707
internal_delete                 (vbi3_teletext_decoder *        td)
 
4708
{
 
4709
        assert (NULL != td);
 
4710
 
 
4711
        _vbi3_teletext_decoder_destroy (td);
 
4712
 
 
4713
        vbi3_free (td);
 
4714
}
 
4715
 
4657
4716
/**
4658
4717
 * @param td Teletext decoder allocated with vbi3_teletext_decoder_new(),
4659
4718
 *   can be @c NULL.
4667
4726
        if (NULL == td)
4668
4727
                return;
4669
4728
 
4670
 
        _vbi3_teletext_decoder_destroy (td);
 
4729
        assert (NULL != td->virtual_delete);
4671
4730
 
4672
 
        vbi3_free (td);
 
4731
        td->virtual_delete (td);
4673
4732
}
4674
4733
 
4675
4734
/**
4708
4767
                td = NULL;
4709
4768
        }
4710
4769
 
 
4770
        td->virtual_delete = internal_delete;
 
4771
 
4711
4772
        return td;
4712
4773
}