cinelerra-5.1/libzmpeg3/dvb.C

   1 #include "libzmpeg3.h"
   2 #include "huf.h"
   3
   4 #ifdef ZDVB
   5
   6 //#define DEBUG
   7
   8 #ifdef DEBUG
   9 static const char *desc_name1[] = {
  10 /* 00 */  0,
  11 /* 01 */  0,
  12 /* 02 */  "video_stream_descr",
  13 /* 03 */  "audio_stream_descr",
  14 /* 04 */  "hierarchy_descr",
  15 /* 05 */  "registration_descr",
  16 /* 06 */  "data_stream_align_descr",
  17 /* 07 */  "target_background_grid_descr",
  18 /* 08 */  "video_window_descr",
  19 /* 09 */  "CA_descr",
  20 /* 0a */  "ISO_639_lang_descr",
  21 /* 0b */  "syst_clk_descr",
  22 /* 0c */  "multiplex_buf_utilization_descr",
  23 /* 0d */  "copyright_descr",
  24 /* 0e */  "max_bitrate_descr",
  25 /* 0f */  "private_data_indicator_descr",
  26 /* 10 */  "smoothing_buf_descr",
  27 /* 11 */  "STD_descr",
  28 /* 12 */  "IBP_descr",
  29 /* 13 */ 0,
  30 /* 14 */ "assoc_tag_descr",
  31 };
  32
  33 static const char *desc_name2[] = {
  34 /* 80 */  "stuffing_descr",
  35 /* 81 */  "AC-3 audio descr",
  36 /* 82 */ 0, 0, 0, 0, /* - 85 */
  37 /* 86 */ "caption_serv_descr",
  38 /* 87 */ "content_advisory_descr",
  39 /* 88 */ 0, 0, 0, 0, 0, 0, 0, 0, /* - 8f */
  40 /* 90 */ 0, 0, 0, 0, 0, 0, 0, 0, /* - 97 */
  41 /* 98 */ 0, 0, 0, 0, 0, 0, 0, 0, /* - 9f */
  42 /* a0 */ "extended_ch_name_descr",
  43 /* a1 */ "serv_location_descr",
  44 /* a2 */ "time_shifted_serv_descr",
  45 /* a3 */ "component_name_descr",
  46 /* a4 */ "data_service_descr",
  47 /* a5 */ "PID_count_descr",
  48 /* a6 */ "Download_descr",
  49 /* a7 */ "multiprotocol_encapsulate_descr",
  50 /* a8 */ "DCC_departing_event_descr",
  51 /* a9 */ "DCC_arriving_event_descr",
  52 /* aa */ "Content_Protect_Copy_Mngt_descr",
  53 /* ab */ 0, 0, 0, 0, 0, 0, 0, 0, 0, /* - b3 */
  54 /* b4 */ "Module_Link_descr",
  55 /* b5 */ "CRC32_descr",
  56 /* b6 */ 0, 0, /* - b7 */
  57 /* b8 */ "Group_Link_descr",
  58 };
  59
  60 /* print descr tag info */
  61
  62 static void prt_descr(uint32_t tag, int len)
  63 {
  64   int n;
  65   const char *nm = 0;
  66   printf("descr tag/len=0x%02x/%u (", tag, len);
  67   if( tag < lengthof(desc_name1) )
  68     nm = desc_name1[tag];
  69   else if( (n=tag-0x80) >= 0 && n<=lengthof(desc_name2) )
  70     nm = desc_name2[n];
  71   if( nm == 0 ) nm = "n/a";
  72   printf("%s)\n",nm);
  73 }
  74
  75 static void prt_vct(zvct_t *vct)
  76 {
  77   printf("VCT table -\n");
  78   printf(" ver=0x%04x\n", vct->version);
  79   printf(" items=0x%04x\n", vct->items);
  80   printf(" ts_stream_id=0x%04x\n", vct->transport_stream_id);
  81   for( int i=0; i<vct->items; ++i ) {
  82     zvitem_t *item = vct->vct_tbl[i];
  83     printf(" %2d. name= ", i);
  84     for( int j=0; j<7; ++j ) {
  85       int ch = item->short_name[j];
  86       printf("%c", ch>=0x20 && ch<0x80 ? ch : '.');
  87     }
  88     printf("\n");
  89     printf(" maj =0x%04x", item->major_channel_number);
  90     printf(" min =0x%04x", item->minor_channel_number);
  91     printf(" mod =0x%04x", item->modulation_mode     );
  92     printf(" freq=0x%04x", item->carrier_frequency   );
  93     printf(" TSid=0x%04x", item->channel_TSID        );
  94     printf(" prog=0x%04x\n", item->program_number      );
  95     printf(" etm =0x%04x", item->etm_location        );
  96     printf(" acc =0x%04x", item->access_controlled   );
  97     printf(" hide=0x%04x", item->hidden              );
  98     printf(" serv=0x%04x", item->service_type        );
  99     printf(" s_id=0x%04x", item->source_id           );
 100     printf(" pcr =0x%04x\n", item->pcr_pid             );
 101     for( int k=0; k<item->num_ch_elts; ++k ) {
 102       printf("   %2d.", k);
 103       printf(" stream=0x%04x",item->elts[k].stream_id  );
 104       printf(" pid=0x%04x",item->elts[k].pes_pid    );
 105       int ch0 = item->elts[k].code_639[0];
 106       int ch1 = item->elts[k].code_639[1];
 107       int ch2 = item->elts[k].code_639[2];
 108       printf(" lang_code=%c",ch0>=0x20 && ch0<0x80 ? ch0 : '.');
 109       printf("%c",ch1>=0x20 && ch1<0x80 ? ch1 : '.');
 110       printf("%c",ch2>=0x20 && ch2<0x80 ? ch2 : '.');
 111       printf("\n");
 112     }
 113   }
 114 }
 115
 116 static void prt_mgt(zmgt_t *mgt)
 117 {
 118   printf("MGT table - items=%d\n", mgt->items);
 119   zmitem_t *item = mgt->mitems;
 120   for( int i=0; i<mgt->items; ++i,++item ) {
 121     printf("   %2d.", i);
 122     printf(" typ=0x%04x", item->type);
 123     char msg[16];
 124     uint16_t type = item->type;
 125      if( type >= 0x1500 ) sprintf(msg,"Reserved");
 126 else if( type >= 0x1400 ) sprintf(msg,"DCCT %04x",type-0x1400);
 127 else if( type >= 0x1000 ) sprintf(msg,"Reserved");
 128 else if( type >= 0x0400 ) sprintf(msg,"Private%3d",type-0x0400);
 129 else if( type >= 0x0301 ) sprintf(msg,"RRT %3d",type-0x0300);
 130 else if( type >= 0x0280 ) sprintf(msg,"Reserved");
 131 else if( type >= 0x0200 ) sprintf(msg,"ETT %3d",type-0x0200);
 132 else if( type >= 0x0180 ) sprintf(msg,"Reserved");
 133 else if( type >= 0x0100 ) sprintf(msg,"EIT %3d",type-0x0100);
 134 else if( type >= 0x0006 ) sprintf(msg,"Reserved");
 135 else if( type == 0x0005 ) sprintf(msg,"DCCSCT");
 136 else if( type == 0x0004 ) sprintf(msg,"ChanETT");
 137 else if( type == 0x0003 ) sprintf(msg,"CableVCT0");
 138 else if( type == 0x0002 ) sprintf(msg,"CableVCT1");
 139 else if( type == 0x0001 ) sprintf(msg,"TerraVCT0");
 140 else if( type == 0x0000 ) sprintf(msg,"TerraVCT1");
 141     printf("(%-10s)",msg);
 142     printf(" pid=0x%04x", item->pid);
 143     printf(" ver=0x%04x", item->version);
 144     printf(" size=0x%04x", item->size);
 145     printf("\n");
 146   }
 147 }
 148
 149 static void prt_stt(zdvb_t *dvb, zstt_t *stt)
 150 {
 151   time_t tm = stt->system_time + dvb->stt_offset();
 152   printf("STT table  table_id=0x%04x - %s\n", stt->table_id, ctime(&tm));
 153 }
 154
 155 static void prt_huf(zdvb_t *dvb,uint8_t *bp, int len)
 156 {
 157   char *text = dvb->mstring(bp,len);
 158   if( text ) printf("%s",text);
 159   delete [] text;
 160 }
 161
 162 static void prt_rrt(zrrt_t *rrt)
 163 {
 164   int items = rrt->items;
 165   printf("RRT table - items=%d\n      region=", items);
 166   prt_huf(rrt->dvb,rrt->region_name,rrt->region_nlen);  printf("\n");
 167   zritem_t *rp = rrt->ratings;
 168   for( int i=0; i<items; ++i,++rp ) {
 169     printf("  %d  ",i);
 170     prt_huf(rrt->dvb,rp->dim_name,rp->dim_nlen);  printf("\n");
 171     printf("   grad %d, num=%d\n", rp->graduated_scale, rp->num_values);
 172     zrating_vt *ap = rp->abrevs;
 173     int values = rp->num_values;
 174     for( int j=0; j<values; ++j,++ap ) {
 175       printf("   %3d ", j);  prt_huf(rrt->dvb,ap->rating_name,ap->rating_nlen);
 176       printf(" = ");  prt_huf(rrt->dvb,ap->rating_text,ap->rating_tlen); printf("\n");
 177     }
 178   }
 179 }
 180
 181 static void prt_ett(zdvb_t *dvb,zetext_t *etxt)
 182 {
 183   printf("ETT table - table_id=0x%04x, etm_id=%08x, ",etxt->table_id, etxt->etm_id);
 184   printf("source_id=%04x, ", etxt->etm_id>>16);
 185   printf("event_id=%04x\n    ", (etxt->etm_id & 0xffff) >> 2);
 186   prt_huf(dvb,etxt->msg_text,etxt->msg_tlen); printf("\n");
 187 }
 188
 189 static void prt_eit(zdvb_t *dvb,zeit_t *eit)
 190 {
 191   printf("EIT table - source_id=0x%04x, items=%d\n", eit->source_id, eit->items);
 192   zeinfo_t *ep = eit->infos;
 193   for( int i=0; i<eit->items; ++i,++ep ) {
 194     time_t tm = ep->start_time + dvb->stt_offset();
 195     printf(" %2d.  id=%04x  %02d:%02d %s    | ", i, ep->event_id,
 196       ep->seconds/3600, (ep->seconds/60)%60, ctime(&tm));
 197     prt_huf(eit->dvb,ep->title_text,ep->title_tlen); printf("\n");
 198   }
 199 }
 200
 201 #endif
 202 // comment/uncomment to enable/disable prt
 203 //#define dprintf(s...) printf(s)
 204 #define dprintf(s...) do {} while(0)
 205 #define prt_descr(s,t) do {} while(0)
 206 #define prt_vct(s) do {} while(0)
 207 #define prt_mgt(s) do {} while(0)
 208 #define prt_stt(d,s) do {} while(0)
 209 #define prt_rrt(s) do {} while(0)
 210 #define prt_eit(d,s) do {} while(0)
 211 #define prt_ett(d,s) do {} while(0)
 212
 213 zdvb_t::
 214 dvb_t(zmpeg3_t *zsrc)
 215 : src(zsrc),
 216   base_pid(0x1ffb)
 217 {
 218   char *cp = getenv("DVB_STREAM_PROBE");
 219   empirical = cp ? atoi(cp) : 0;
 220   active = 0;
 221 }
 222
 223 zdvb_t::
 224 ~dvb_t()
 225 {
 226   reset();
 227 }
 228
 229 void zdvb_t::
 230 reset()
 231 {
 232   stt_start_time = 0;
 233   delete mgt;  mgt = 0;
 234   while( eit ) { eit_t *nxt = eit->next;  delete eit;  eit = nxt; }
 235   while( ett ) { ett_t *nxt = ett->next;  delete ett;  ett = nxt; }
 236   delete tvct; tvct = 0;
 237   delete cvct; cvct = 0;
 238   delete rrt;  rrt = 0;
 239   delete stt;  stt = 0;
 240   base_pid.clear();
 241   active = 0;
 242 }
 243
 244 void zdvb_t::
 245 skip_bfr(int n)
 246 {
 247   int len = bfr_len();
 248   if( n > len ) n = len;
 249   xbfr += n;
 250 }
 251
 252 int zdvb_t::
 253 get_text(uint8_t *dat, int bytes)
 254 {
 255   int len = get8bits();
 256   int count = len < bytes ? len : bytes;
 257   for( int i=0; i<count; ++i ) *dat++ = get8bits();
 258   skp_bfr(len-count);
 259   return count;
 260 }
 261
 262 void zdvb_t::
 263 append_text(char *msg, int n)
 264 {
 265   int len = strnlen(msg, n);
 266   int m = text_length + len + 1;
 267   if( m > text_allocated ) {
 268     int allocated = 2*text_allocated + len + 0x100;
 269     char *new_text = new char[allocated];
 270     text_allocated = allocated;
 271     memcpy(new_text, text, text_length);
 272     delete text;  text = new_text;
 273   }
 274   memmove(text+text_length,msg,len);
 275   text[text_length += len] = 0;
 276 }
 277
 278 char *zdvb_t::
 279 mstring(uint8_t *bp, int len)
 280 {
 281   char msg[4096];
 282   text_length = text_allocated = 0;
 283   text = 0;  uint8_t *ep = bp + len;
 284   int num = !len ? 0 : *bp++;
 285   for( int i=0; i<num && bp<ep; ++i ) {
 286     //uint8_t enc[4];
 287     //enc[0] = *bp++; enc[1] = *bp++;
 288     //enc[2] = *bp++; enc[3] = 0;
 289     bp += 3; // enc
 290     int segs = *bp++;
 291     for( int j=0; j<segs; ++j ) {
 292       int type = *bp++;
 293       int mode = *bp++;  (void)mode;
 294       int bytes = *bp++;
 295       uint8_t *dat = bp;
 296       bp += bytes;
 297       switch( type ) {
 298       case 0x01: { // huffman 1
 299         int len = huf::huf1_decode(dat,bytes*8,msg,sizeof(msg));
 300         append_text(msg,len);
 301         break; }
 302       case 0x02: { // huffman 2
 303         int len = huf::huf2_decode(dat,bytes*8,msg,sizeof(msg));
 304         append_text(msg,len);
 305         break; }
 306       default: { // no compression
 307         append_text((char*)&dat[0],bytes);
 308         break; }
 309       }
 310     }
 311   }
 312   return text;
 313 }
 314
 315 void zdvb_t::
 316 skip_descr(int descr_length)
 317 {
 318   if( descr_length > 0 && descr_length <= bfr_len() ) {
 319     int descr_bytes = 0;
 320     while( descr_bytes < descr_length ) {
 321       uint32_t tag = get8bits();
 322      (void)tag; /* avoid cmplr msg when debug off */
 323       int len = get8bits() + 2;
 324       int count = 2;
 325       prt_descr(tag, len);
 326       skp_bfr(len-count);
 327       descr_bytes += len;
 328     }
 329   }
 330 }
 331
 332 void zmitem_t::
 333 init(int len)
 334 {
 335   if( len > bfr_alloc ) {
 336     delete [] bfr;
 337     bfr = new uint8_t[len];
 338     bfr_alloc = len;
 339   }
 340   bfr_size = 0;
 341   tbl_len = len;
 342 }
 343
 344 void zmitem_t::
 345 extract(uint8_t *dat, int len)
 346 {
 347   if( bfr_size+len <= bfr_alloc || (len=bfr_alloc-bfr_size) > 0 ) {
 348     memcpy(bfr+bfr_size, dat, len);
 349     bfr_size += len;
 350   }
 351 }
 352
 353 void zmitem_t::
 354 clear()
 355 {
 356   delete [] bfr;
 357   bfr = 0;
 358   bfr_size = bfr_alloc = 0;
 359 }
 360
 361 void zmgt_t::
 362 extract()
 363 {
 364   clear();
 365   items = dvb->get16bits();
 366   mitems = new mitem_t[items];
 367   mitem_t *item = mitems;
 368   for( int i=0; i<items; ++i,++item ) {
 369     item->type = dvb->get16bits();
 370     item->pid = dvb->get16bits() & 0x1fff;
 371     item->version = dvb->get8bits() & 0x1f;
 372     item->size = dvb->get32bits();
 373     int descr_len = dvb->get16bits() & 0xfff;
 374     dvb->skip_descr(descr_len);
 375   }
 376   int descr_len = dvb->get16bits() & 0xfff;
 377   dvb->skip_descr(descr_len);
 378   prt_mgt(this);
 379 }
 380
 381 void zmgt_t::
 382 clear()
 383 {
 384   delete [] mitems;  mitems = 0;
 385   items = 0;
 386 }
 387
 388 zmitem_t *zmgt_t::
 389 search(uint16_t pid)
 390 {
 391   mitem_t *item = mitems;
 392   int i = items;
 393   while( --i>=0 && item->pid!=pid ) ++item;
 394   return i < 0 ? 0 : item;
 395 }
 396
 397 void zch_elts_t::
 398 extract(dvb_t *dvb)
 399 {
 400   stream_id = dvb->get8bits();
 401   pes_pid = dvb->get16bits() & 0x1fff;
 402   code_639[0] = dvb->get8bits();
 403   code_639[1] = dvb->get8bits();
 404   code_639[2] = dvb->get8bits();
 405 }
 406
 407 void zvitem_t::
 408 extract(dvb_t *dvb)
 409 {
 410   for( int i=0; i<7 ; ++i ) short_name[i] = dvb->get16bits();
 411   uint8_t b0 = dvb->get8bits();
 412   uint8_t b1 = dvb->get8bits();
 413   uint8_t b2 = dvb->get8bits();
 414   major_channel_number = ((b0&0x0f)<<6) | ((b1>>2)&0x3f);
 415   minor_channel_number = ((b1&0x03)<<8) | b2;
 416   modulation_mode = dvb->get8bits();
 417   carrier_frequency = dvb->get32bits();
 418   channel_TSID = dvb->get16bits();
 419   program_number = dvb->get16bits();
 420   b0 = dvb->get8bits();
 421   etm_location = (b0 >> 6) & 0x03;
 422   access_controlled = (b0 >> 5) & 1;
 423   hidden = (b0 >> 4) & 1;
 424   path_select = (b0 >> 3) & 1;
 425   out_of_band = (b0 >> 2) & 1;
 426   service_type = dvb->get8bits() & 0x3f;
 427   source_id = dvb->get16bits();
 428   num_ch_elts = 0;
 429
 430   int descr_length = dvb->get16bits() & 0x3ff;
 431   int descr_bytes = 0;
 432
 433   while( descr_bytes < descr_length ) {
 434     if( dvb->bfr_len() < 2 ) return;
 435     uint32_t tag = dvb->get8bits();
 436     int len = dvb->get8bits() + 2;
 437     prt_descr(tag, len);
 438     int count = 2;
 439     if( tag == 0xa1 ) {
 440       /* "Service Location Descriptor", extract common info */
 441       pcr_pid = dvb->get16bits() & 0x1fff;
 442       int num_elts = dvb->get8bits();
 443       count += 3;
 444       int n = num_elts;
 445       if( n > lengthof(elts) ) {
 446         n = lengthof(elts);
 447         printf("num of pids = %d -- truncated to %d\n", num_elts,n);
 448       }
 449       /* step thru each channel element & extract info into the VCT */
 450       num_ch_elts += n;
 451       for( int j=0; j<n; ++j )
 452         elts[j].extract(dvb);
 453       count += n*6;
 454     }
 455     dvb->skp_bfr(len-count);
 456     descr_bytes += len;
 457   }
 458 }
 459
 460 int zvct_t::
 461 search(zvitem_t &new_item)
 462 {
 463   uint32_t maj = new_item.major_channel_number;
 464   uint32_t min = new_item.minor_channel_number;
 465   for( int i=items; --i>=0; ) {
 466     vitem_t *item = vct_tbl[i];
 467     if( maj == item->major_channel_number &&
 468         min == item->minor_channel_number ) return 1;
 469   }
 470   return 0;
 471 }
 472
 473 void zvct_t::
 474 append(zvitem_t &new_vitem)
 475 {
 476   if( items >= items_allocated ) {
 477     int allocated = 2*items_allocated + 16;
 478     vitem_t **new_vct_tbl = new vitem_t *[allocated];
 479     items_allocated = allocated;
 480     for( int i=0; i<items; ++i ) new_vct_tbl[i] = vct_tbl[i];
 481     delete [] vct_tbl;  vct_tbl = new_vct_tbl;
 482   }
 483   vct_tbl[items++] = new vitem_t(new_vitem);
 484 }
 485
 486 void zvct_t::
 487 extract()
 488 {
 489   transport_stream_id = dvb->stream_id;
 490   version = dvb->version;
 491   int nitems = dvb->get8bits();
 492   /* append new entries */
 493   for( int i=0; i<nitems; ++i ) {
 494     vct_t::vitem_t new_item;
 495     new_item.extract(dvb);
 496     if( !search(new_item) )
 497       append(new_item);
 498   }
 499   int descr_len = dvb->get16bits() & 0x3ff;
 500   dvb->skip_descr(descr_len);
 501   prt_vct(this);
 502 }
 503
 504 void zvct_t::
 505 clear()
 506 {
 507   for( int i=0; i<items; ++i ) delete vct_tbl[i];
 508   delete [] vct_tbl;  vct_tbl = 0;
 509   items = items_allocated = 0;
 510 }
 511
 512 void zrating_vt::
 513 extract(dvb_t *dvb)
 514 {
 515   rating_nlen = dvb->get_text(rating_name, lengthof(rating_name));
 516   rating_tlen = dvb->get_text(rating_text, lengthof(rating_text));
 517 }
 518
 519 void zritem_t::
 520 extract(dvb_t *dvb)
 521 {
 522   clear();
 523   dim_nlen = dvb->get_text(dim_name,lengthof(dim_name));
 524   int len = dvb->get8bits();
 525   graduated_scale = (len>>4) & 1;
 526   num_values = len & 0x0f;
 527   abrevs = new rating_vt[num_values];
 528   for( int i=0; i<num_values; ++i )
 529     abrevs[i].extract(dvb);
 530 }
 531
 532 void zritem_t::
 533 clear()
 534 {
 535   delete [] abrevs;  abrevs = 0;
 536   num_values = 0;
 537 }
 538
 539 void zrrt_t::
 540 extract()
 541 {
 542   clear();
 543   version = dvb->version;
 544   region_nlen = dvb->get_text(region_name,lengthof(region_name));
 545   items = dvb->get8bits();
 546   ratings = new ritem_t[items];
 547   for( int i=0; i<items; ++i )
 548     ratings[i].extract(dvb);
 549   int descr_len = dvb->get16bits() & 0x3ff;
 550   dvb->skip_descr(descr_len);
 551   prt_rrt(this);
 552 }
 553
 554 void zrrt_t::
 555 clear()
 556 {
 557   delete [] ratings;  ratings = 0;
 558   items = 0;
 559 }
 560
 561
 562 void zeinfo_t::
 563 extract(dvb_t *dvb)
 564 {
 565   event_id = dvb->get16bits() & 0x3fff;
 566   start_time = dvb->get32bits();
 567   uint32_t loc = dvb->get24bits();
 568   location = (loc>>20) & 0x3;
 569   seconds = loc & 0x0fffff;
 570   title_tlen = dvb->get8bits();
 571   title_text = new uint8_t[title_tlen];
 572   for( int i=0; i<title_tlen; ++i )
 573     title_text[i] = dvb->get8bits();
 574   int descr_len = dvb->get16bits() & 0xfff;
 575   dvb->skip_descr(descr_len);
 576 }
 577
 578 void zeinfo_t::
 579 clear()
 580 {
 581   delete [] title_text;  title_text = 0;
 582   title_tlen = 0;
 583 }
 584
 585 void zeit_t::
 586 extract()
 587 {
 588   clear();
 589   version = dvb->version;
 590   source_id = dvb->stream_id;
 591   nitems = dvb->get8bits();
 592   infos = new einfo_t[nitems];
 593   items = 0;
 594   for( int i=0; i<nitems; ++i ) {
 595     infos[items].extract(dvb);
 596     if( !search(infos[items].event_id) ) ++items;
 597     else infos[items].clear();
 598   }
 599   prt_eit(dvb,this);
 600 }
 601
 602 void zeit_t::
 603 clear()
 604 {
 605   for( int i=0; i<items; ++i ) infos[i].clear();
 606   delete [] infos;  infos = 0;
 607   items = nitems = 0;
 608 }
 609
 610 int zeit_t::
 611 search(uint16_t evt_id)
 612 {
 613   uint16_t src_id = id >> 16;
 614   for( eit_t *ep=dvb->eit; ep; ep=ep->next ) {
 615     if( (ep->id>>16) != src_id ) continue;
 616     for( int i=0; i<ep->items; ++i )
 617       if( ep->infos[i].event_id == evt_id ) return 1;
 618   }
 619   return 0;
 620 }
 621
 622 void zetext_t::
 623 extract(dvb_t *dvb, uint32_t eid)
 624 {
 625   clear();
 626   version = dvb->version;
 627   table_id = dvb->stream_id;
 628   etm_id = eid;
 629   int tlen = dvb->bfr_len() - sizeof(uint32_t);
 630   msg_text = new uint8_t[tlen];
 631   msg_tlen = tlen;
 632   for( int i=0; i<msg_tlen; ++i )
 633     msg_text[i] = dvb->get8bits();
 634   prt_ett(dvb, this);
 635 }
 636
 637 void zetext_t::
 638 clear()
 639 {
 640   delete [] msg_text;  msg_text = 0;
 641   msg_tlen = 0;
 642 }
 643
 644 void zett_t::
 645 extract()
 646 {
 647   uint32_t eid = dvb->get32bits();
 648   int id = (eid & ~0xffff) | ((eid & 0xffff) >> 2);
 649   etext_t *etp = texts;
 650   while( etp && etp->id != id ) etp=etp->next;
 651   if( !etp ) { etp = new etext_t(id);  etp->next = texts;  texts = etp; }
 652   etp->extract(dvb, eid);
 653 }
 654
 655 void zett_t::
 656 clear()
 657 {
 658   while( texts ) { etext_t *nxt = texts->next;  delete texts;  texts = nxt; }
 659 }
 660
 661
 662 void zstt_t::
 663 extract()
 664 {
 665   clear();
 666   version = dvb->version;
 667   table_id = dvb->stream_id;
 668   system_time = dvb->get32bits();
 669   utc_offset = dvb->get8bits();
 670   daylight_saving = dvb->get16bits();
 671   //doesnt seem to really be there
 672   //int descr_len = len - sizeof(uint32_t);
 673   //dvb->skip_descr(descr_len);
 674   dvb->skp_bfr(sizeof(uint32_t)); /*crc32*/
 675   prt_stt(dvb,this);
 676 }
 677
 678 void zstt_t::
 679 clear()
 680 {
 681 }
 682
 683
 684 zmitem_t *zdvb_t::
 685 atsc_pid(int pid)
 686 {
 687   return pid==0x1ffb ? &base_pid : !mgt ? 0 : mgt->search(pid);
 688 }
 689
 690 int zdvb_t::
 691 atsc_tables(zdemuxer_t *demux, int pid)
 692 {
 693   active = atsc_pid(pid);
 694   if( !active ) return 0;
 695   int dlen = demux->zdata.size;
 696 //zmsgs("*** packet, pid = %04x, len=%04x\n", pid, dlen);
 697   uint8_t *dbfr = demux->zdata.buffer;
 698   uint8_t *dend = dbfr + dlen;
 699   while( dbfr < dend ) {
 700     if( demux->payload_unit_start_indicator ) {
 701       if( active->tbl_id ) {
 702         if( src->log_errs )
 703           zmsgs("atsc_tables, unfinished table %04x, len=%d\n",
 704             active->tbl_id, active->bfr_len());
 705 //      extract();
 706       }
 707       xbfr = dbfr;  eob = dend;
 708       uint32_t tbl_id = get16bits();
 709       switch( tbl_id ) {
 710       case 0xc7: dprintf("MGT: ");     break;
 711       case 0xc8: dprintf("TVCT: ");    break;
 712       case 0xc9: dprintf("CVCT: ");    break;
 713       case 0xca: dprintf("RRT: ");     break;
 714       case 0xcb: dprintf("EIT: ");     break;
 715       case 0xcc: dprintf("ETT: ");     break;
 716       case 0xcd: dprintf("STT: ");     break;
 717       case 0xd3: dprintf("DCCT\n");    return 0;
 718       case 0xd4: dprintf("DCCSCT\n");  return 0;
 719       case 0xffff:                     return 0;
 720       default:   dprintf("tbl_id = 0x%02x\n",tbl_id);
 721         return 1;
 722       }
 723       /* read header */
 724       sect_len = get16bits() & 0x0fff;  /* 1,2 */
 725       if( (sect_len-=6) < 0 ) {
 726         zmsgs("sect_len=%d too small for header\n",sect_len);
 727         return 1;
 728       }
 729       stream_id = get16bits();          /* 3,4 */
 730       uint8_t byt = get8bits();         /* 5 */
 731       version = (byt >> 1) & 0x1f;
 732       cur_next = byt & 0x01;
 733       sect_num = get8bits();            /* 6 */
 734       proto_ver = get16bits() & 0xff;   /* 7,8 */
 735       dprintf("pid/tid=%04x/%02x  len=%04x strm=%04x ver=%d cur=%d sect=%d proto=%d\n",
 736         pid, tbl_id, sect_len, stream_id, version, cur_next, sect_num, proto_ver);
 737       if( proto_ver != 0 ) return 1;
 738       active->init(sect_len);
 739       active->tbl_id = tbl_id;
 740       active->src_id = stream_id;
 741       dbfr = xbfr;
 742     }
 743     else if( !active->tbl_id )
 744       return 1;
 745
 746     /* append data to buffer */
 747     int len = dend - dbfr;
 748     int want = active->bfr_len();
 749     if( want < len ) len = want;
 750     if( len > 0 ) {
 751       active->extract(dbfr, len);
 752       dbfr += len;
 753     }
 754     dprintf("append tbl_id=%04x, len=%04x, size=%04x\n",
 755       active->tbl_id, len, active->bfr_size);
 756
 757     /* if table assembled, extract data */
 758     if( !active->bfr_len() )
 759       extract();
 760   }
 761
 762   return 0;
 763 }
 764
 765 void zdvb_t::extract()
 766 {
 767   xbfr = active->bfr;
 768   eob = xbfr + active->bfr_size;
 769
 770   switch( active->tbl_id ) {
 771   case 0xc7:
 772     if( !mgt ) mgt = new mgt_t(this);
 773       mgt->extract();
 774       break;
 775   case 0xc8:
 776     if( !tvct ) tvct = new vct_t(this);
 777     tvct->extract();
 778     break;
 779   case 0xc9:
 780     if( !cvct ) cvct = new vct_t(this);
 781     cvct->extract();
 782     break;
 783   case 0xca:
 784     if( !rrt ) rrt = new rrt_t(this);
 785     rrt->extract();
 786     break;
 787   case 0xcb: { int id;
 788     if( (id=active->type-0x100) < 0 || id >= 0x80 ) break;
 789     id |= active->src_id << 16;
 790     eit_t *eip = eit;
 791     while( eip && eip->id != id ) eip = eip->next;
 792     if( !eip ) { eip = new eit_t(this, id);  eip->next = eit;  eit = eip; }
 793     eip->extract();
 794     break; }
 795   case 0xcc: { int id;
 796     if( active->type == 0x0004 ) id = -1; // channel ett
 797     else if( (id=active->type-0x200) < 0 || id >= 0x80 ) break;
 798     ett_t *etp = ett;
 799     while( etp && etp->id != id ) etp = etp->next;
 800     if( !etp ) { etp = new ett_t(this, id);  etp->next = ett;  ett = etp; }
 801     etp->extract();
 802     break; }
 803   case 0xcd:
 804     if( !stt ) stt = new stt_t(this);
 805     stt->extract();
 806     if( !stt_start_time )
 807       stt_start_time = stt->system_time;
 808     break;
 809   }
 810
 811   active->tbl_id = 0;
 812 }
 813
 814 int zdvb_t::
 815 signal_time()
 816 {
 817   return stt_start_time ? stt->system_time - stt_start_time : 0;
 818 }
 819
 820 int zdvb_t::
 821 channel_count()
 822 {
 823   vct_t *vct = tvct ? tvct : cvct;
 824   return vct ? vct->items : -1;
 825 }
 826
 827 int zdvb_t::
 828 get_channel(int n, int &major, int &minor)
 829 {
 830   vct_t *vct = tvct ? tvct : cvct;
 831   if( !vct ) return -1;
 832   if( n < 0 || n >= vct->items ) return 1;
 833   vct_t::vitem_t *item = vct->vct_tbl[n];
 834   major = item->major_channel_number;
 835   minor = item->minor_channel_number;
 836   return 0;
 837 }
 838
 839 int zdvb_t::
 840 get_station_id(int n, char *name)
 841 {
 842   vct_t *vct = tvct ? tvct : cvct;
 843   if( !vct ) return -1;
 844   if( n < 0 || n >= vct->items ) return 1;
 845   vct_t::vitem_t *item = vct->vct_tbl[n];
 846   int i = 0;
 847   while( i < 7 ) {
 848     int ch = item->short_name[i];
 849     name[i] = ch >= 0x20 && ch < 0x80 ? ch : '_';
 850     ++i;
 851   }
 852   name[i] = 0;
 853   return 0;
 854 }
 855
 856 int zdvb_t::
 857 total_astreams(int n, int &count)
 858 {
 859   vct_t *vct = tvct ? tvct : cvct;
 860   if( !vct ) return -1;
 861   if( n < 0 || n >= vct->items ) return 1;
 862   vct_t::vitem_t *item = vct->vct_tbl[n];
 863   count = 0;
 864   for( int i=0; i<item->num_ch_elts; ++i ) {
 865     int stream_id = item->elts[i].stream_id;
 866     if( stream_id == 0x81 ||  /* AC3-audio */
 867         stream_id == 0x03 ||  /* MPEG1-audio */
 868         stream_id == 0x04 ) { /* MPEG1-audio */
 869       ++count;
 870     }
 871   }
 872   return 0;
 873 }
 874
 875 int zdvb_t::
 876 astream_number(int n, int ord, int &stream, char *enc)
 877 {
 878   vct_t *vct = tvct ? tvct : cvct;
 879   if( !vct ) return -1;
 880   if( n < 0 || n >= vct->items ) return 1;
 881   vct_t::vitem_t *item = vct->vct_tbl[n];
 882   vct_t::vitem_t::ch_elts_t *elt = 0;
 883   int count = 0;
 884   for( int i=0; i<item->num_ch_elts; ++i ) {
 885     int stream_id = item->elts[i].stream_id;
 886     if( stream_id == 0x81 || stream_id == 0x03 || stream_id == 0x04 ) {
 887       if( count == ord ) {
 888         elt = &item->elts[i];
 889         break;
 890       }
 891       ++count;
 892     }
 893   }
 894   if( !elt ) return 1;
 895   int pid = elt->pes_pid;
 896   int trk = 0;
 897   while( trk < src->total_atracks ) {
 898     if( src->atrack[trk]->pid == pid ) break;
 899     ++trk;
 900   }
 901   if( trk >= src->total_atracks ) return 1;
 902   stream = trk;
 903   if( enc ) {
 904     int ch0 = elt->code_639[0];
 905     int ch1 = elt->code_639[1];
 906     int ch2 = elt->code_639[2];
 907     enc[0] = ch0>=0x20 && ch0<0x80 ? ch0 : '.';
 908     enc[1] = ch1>=0x20 && ch1<0x80 ? ch1 : '.';
 909     enc[2] = ch2>=0x20 && ch2<0x80 ? ch2 : '.';
 910     enc[3] = 0;
 911   }
 912   return 0;
 913 }
 914
 915 int zdvb_t::
 916 total_vstreams(int n,int &count)
 917 {
 918   vct_t *vct = tvct ? tvct : cvct;
 919   if( !vct ) return -1;
 920   if( n < 0 || n >= vct->items ) return 1;
 921   vct_t::vitem_t *item = vct->vct_tbl[n];
 922   count = 0;
 923   for( int i=0; i<item->num_ch_elts; ++i ) {
 924     int stream_id = item->elts[i].stream_id;
 925     if( stream_id == 0x02 || stream_id == 0x80 ) { /* video */
 926       ++count;
 927     }
 928   }
 929   return 0;
 930 }
 931
 932 int zdvb_t::
 933 vstream_number(int n, int ord, int &stream)
 934 {
 935   vct_t *vct = tvct ? tvct : cvct;
 936   if( !vct ) return -1;
 937   if( n < 0 || n >= vct->items ) return 1;
 938   vct_t::vitem_t *item = vct->vct_tbl[n];
 939   int pid = -1;
 940   int count = 0;
 941   for( int i=0; i<item->num_ch_elts; ++i ) {
 942     int stream_id = item->elts[i].stream_id;
 943     if( stream_id == 0x02 || stream_id == 0x80 ) {
 944       if( count == ord ) {
 945         pid = item->elts[i].pes_pid;
 946         break;
 947       }
 948       ++count;
 949     }
 950   }
 951   if( pid < 0 ) return 1;
 952   int trk = 0;
 953   while( trk < src->total_vtracks ) {
 954     if( src->vtrack[trk]->pid == pid ) break;
 955     ++trk;
 956   }
 957   if( trk >= src->total_vtracks ) return 1;
 958   stream = trk;
 959   return 0;
 960 }
 961
 962 int zdvb_t::
 963 read_dvb(zdemuxer_t *demux)
 964 {
 965   vct_t *vct = tvct ? tvct : cvct;
 966   /* scan tables or use empirical data */
 967   if( vct && !empirical ) {
 968     memset(demux->astream_table,0,sizeof(demux->astream_table));
 969     memset(demux->vstream_table,0,sizeof(demux->vstream_table));
 970     /* mark active streams */
 971     for( int n=0; n<vct->items; ++n ) {
 972       vct_t::vitem_t *item = vct->vct_tbl[n];
 973       for( int i=0; i<item->num_ch_elts; ++i ) {
 974         int stream_id = item->elts[i].stream_id;
 975         int pid = item->elts[i].pes_pid;
 976 //zmsgs("** dvb stream %02x pid %04x\n",stream_id,pid);
 977         switch( stream_id ) {
 978         case 0x80: /* video */
 979         case 0x02: /* video */
 980           demux->vstream_table[pid] = 1;
 981           break;
 982         case 0x03: /* MPEG1-audio */
 983         case 0x04: /* MPEG1-audio */
 984           demux->astream_table[pid] = afmt_MPEG;
 985           break;
 986         case 0x81: /* AC3-audio */
 987           demux->astream_table[pid] = afmt_AC3;
 988           break;
 989         }
 990       }
 991     }
 992   }
 993   return 0;
 994 }
 995
 996 int zdvb_t::
 997 get_chan_info(int n, int ord, int i, char *txt, int len)
 998 {
 999   char *cp = txt;
1000   if( len > 0 ) *cp = 0;
1001   vct_t *vct = tvct ? tvct : cvct;
1002   if( !vct ) return -1;
1003   if( n < 0 || n >= vct->items ) return -1;
1004   zvitem_t *item = vct->vct_tbl[n];
1005   zeinfo_t *eip = 0;
1006   int eid = item->source_id << 16;
1007   if( ord >= 0 ) {  // not channel info
1008     int xid = eid | ord;
1009     eit_t *ep = eit;
1010     while( ep && ep->id != xid ) ep = ep->next;
1011     if( !ep || i >= ep->items ) return -1;
1012     eip = &ep->infos[i];
1013     time_t st = eip->start_time + stt_offset();
1014     time_t et = st + eip->seconds;
1015     struct tm stm;  localtime_r(&st, &stm);
1016     struct tm etm;  localtime_r(&et, &etm);
1017     if( len > 0 ) { // output start time
1018       n = snprintf(cp,len,"%02d:%02d:%02d-", stm.tm_hour, stm.tm_min, stm.tm_sec);
1019       cp += n;  len -= n;
1020     }
1021     if( len > 0 ) { // output end time
1022       n = snprintf(cp,len,"%02d:%02d:%02d  ", etm.tm_hour, etm.tm_min, etm.tm_sec);
1023       cp += n;  len -= n;
1024     }
1025     if( len > 0 ) { // output title text
1026       char *text = mstring(eip->title_text,eip->title_tlen);
1027       if( text ) {
1028         char *bp = text;
1029         while( *bp && len>0 ) {  // no new lines, messes up decoding title
1030           *cp++ = *bp != '\n' ? *bp : ';';
1031           --len;  ++bp;
1032         }
1033         if( len > 0 ) { *cp++ = '\n'; --len; }
1034         delete [] text;
1035       }
1036     }
1037     if( len > 0 ) { // output start weekday
1038       n = snprintf(cp,len,"(%3.3s) ",&"sunmontuewedthufrisat"[stm.tm_wday*3]);
1039       cp += n;  len -= n;
1040     }
1041     if( len > 0 ) { // output start date
1042       n = snprintf(cp,len,"%04d/%02d/%02d\n", stm.tm_year+1900, stm.tm_mon+1, stm.tm_mday);
1043       cp += n;  len -= n;
1044     }
1045     eid |= eip->event_id;
1046   }
1047   if( len > 0 && (eip ? eip->location : ord == -1) ) {
1048     ett_t *etp = ett;
1049     while( etp && etp->id != ord ) etp = etp->next;
1050     if( etp ) {    // output extended message text
1051       zetext_t *tp = etp->texts;
1052       while( tp && tp->id != eid ) tp = tp->next;
1053       if( tp ) {
1054         if( ord < 0 ) {  // channel ett exists
1055           n = snprintf(cp,len,"** ");
1056           cp += n;  len -= n;
1057         }
1058         char *text = mstring(tp->msg_text,tp->msg_tlen);
1059         if( text ) {
1060           n = snprintf(cp,len,"%s\n",text);
1061           cp += n;  len -= n;
1062           delete [] text;
1063         }
1064       }
1065     }
1066   }
1067   if( len > 0 ) *cp = 0;
1068   return cp - txt;
1069 }
1070
1071 #endif