helper.c

dvbsnoop is a DVB/MPEG stream analyzer program. The program can be used to sniff, monitor, debug, d

/*
  -- get bits out of buffer  (max 48 bit)
  -- extended bitrange, so it's slower
  -- return: value
 */

long long getBits48 (u_char *buf, int byte_offset, int startbit, int bitlen)
{
 u_char *b;
 unsigned long long v;
 unsigned long long mask;
 unsigned long long tmp;

 if (bitlen > 48) {
	out_nl (1," Error: getBits48() request out of bound!!!! (report!!) \n");
	return 0xFEFEFEFEFEFEFEFELL;
 }
 

 b = &buf[byte_offset + (startbit / 8)];
 startbit %= 8;


 // -- safe is 48 bitlen
 tmp = (unsigned long long)(
	 ((unsigned long long)*(b  )<<48) + ((unsigned long long)*(b+1)<<40) +
	 ((unsigned long long)*(b+2)<<32) + ((unsigned long long)*(b+3)<<24) +
	 (*(b+4)<<16) + (*(b+5)<< 8) + *(b+6) );

 startbit = 56 - startbit - bitlen;
 tmp      = tmp >> startbit;
 mask     = (1ULL << bitlen) - 1;	// 1ULL !!!
 v        = tmp & mask;

 return v;
}



/*
  -- get bits out of buffer   (max 64 bit)
  -- extended bitrange, so it's slower 
  -- return: value
 */

unsigned long long getBits64 (u_char *buf, int byte_offset, int startbit, int bitlen)
{
  unsigned long long x1,x2,x3;

  if (bitlen <= 32) {
     x3 = getBits (buf,byte_offset,startbit,bitlen); 
  } else {
     x1 = getBits (buf,byte_offset,startbit,32); 
     x2 = getBits (buf,byte_offset,startbit+32,bitlen-32); 
     x3 = (x1<<(bitlen-32)) + x2;
  }
  return x3;
}






/*
  -----------------------------------------------------------------------------------
 */




/*
  -- get ISO 639  (3char) language code into string[4]
  -- terminate string with \0
  -- return ptr to buf;
 */

u_char *getISO639_3 (u_char *str, u_char *buf)
{
  int i;

  strncpy (str, buf, 3);
  *(str+3) = '\0';

  // secure print of string
  for (i=0; i<3; i++) {
     if (!isprint(*(str+i))) {
	     *(str+i) = '.';
     }
  }
  
  return str;
}




/*
  -- print_text_468A 
  -- ETSI EN 300 468  Annex A
  -- evaluate string and look on DVB control codes
  -- print the string
*/

static void print_text2_468A (int v, u_char *b, u_int len);

void print_text_468A (int v, const char *s,  u_char *b, u_int len)
{

 out (v, s);

 if (len <= 0) {
    out_nl (v,"\"\"");
 } else {
    out (v,"\"");
    print_text2_468A (v, b,len);
    out (v,"\"");
    out_nl (v,"  -- Charset: %s", dvbstrTextCharset_TYPE (*b));
 }

}


static void print_text2_468A (int v, u_char *b, u_int len)
{
  int    in_emphasis = 0;
  int    i;
  u_char c;
  u_char em_ON  = 0x86;
  u_char em_OFF = 0x87;

 
  for (i=0; i<len; i++) {
    c = b[i];

    if (i == 0 && c < 0x20) continue;   // opt. charset descript.

    if (c == em_ON) {
       in_emphasis = 1;
       out (v,"<EM>");
       continue;
    }
    if (c == em_OFF) {
       in_emphasis = 0;
       out (v,"</EM>");
       continue;
    }

       if (c == 0x8A)     out (v, "<BR>");
       else if (c < 0x20) out (v, ".");
       else               out (v, "%c", c);

  } // for
  

}


/*
  -- print_text_UTF8
  -- print the string using UTF8
  -- (use std_ascii)
*/

void print_text_UTF8 (int v, const char *s,  u_char *b, u_int len)
{
   print_std_ascii (v, s, b, len);
}



/*
  -- print standard ascii text
*/

void print_std_ascii (int v, const char *s, u_char *b, u_int len)
{
  int    i;
  u_char c;
 
  out (v,"%s\"",s);
  for (i=0; i<len; i++) {
    c = b[i];
    if (!isprint (c)) c = '.';
    out (v, "%c", c);
  } 
  out_nl (v,"\"");

}






/*
 -- print time  40 bit (MJD, UTC)
 -- print time  MJD
 -- print time  UTC
 --   16 Bit  MJD,  24 Bit UTC
*/ 

static void _print_time_mjd (int v, u_long mjd)
{
 if (mjd > 0) {
   long   y,m,d ,k;

   // algo: ETSI EN 300 468 - ANNEX C

   y =  (long) ((mjd  - 15078.2) / 365.25);
   m =  (long) ((mjd - 14956.1 - (long)(y * 365.25) ) / 30.6001);
   d =  (long) (mjd - 14956 - (long)(y * 365.25) - (long)(m * 30.6001));
   k =  (m == 14 || m == 15) ? 1 : 0;
   y = y + k + 1900;
   m = m - 1 - k*12;

   out (v, "%02d-%02d-%02d",y,m,d);
 }
}

static void _print_time_utc (int v, u_long utc)
{
 out (v, "%02lx:%02lx:%02lx (UTC)",
	 (utc>>16) &0xFF, (utc>>8) &0xFF, (utc) &0xFF);
}


void print_time_mjd (int v, u_long mjd)
{
  out (v, "0x%04lx [= ",mjd);
  _print_time_mjd (v, mjd);
  out (v,"]");
}

void print_time_utc (int v, u_long utc)
{
  out (v, "0x%06lx [= ",utc);
  _print_time_utc (v, utc);
  out (v,"]");

}

void print_time40 (int v, u_long mjd, u_long utc)
{
  out (v, "0x%lx%06lx [= ",mjd, utc);
  _print_time_mjd (v, mjd);
  out (v," ");
  _print_time_utc (v, utc);
  out (v,"]");
}



/*
 -- print 90kHz timebase
 -- 33 bit  z.B. xTS
*/ 

void print_timebase90kHz (int v, long long time90kHz)

{
   long long ull = time90kHz;

   	int     h,m,s,u;
	u_long  p = ull/90;

	// -- following lines taken from "dvbtextsubs  Dave Chapman"
	h=(p/(1000*60*60));
	m=(p/(1000*60))-(h*60);
	s=(p/1000)-(h*3600)-(m*60);
	u=p-(h*1000*60*60)-(m*1000*60)-(s*1000);

    	out (v,"%llu (0x%08llx)", ull,ull);
	out (v,"  [= 90 kHz-Timestamp: %d:%02d:%02d.%03d]", h,m,s,u);
}


/*
  -- print data bytes (str + hexdump)
  -- print  "Private Data" and Hex-Dump

*/
void print_databytes (int v, const char *str, u_char *b, u_int len)
{
  if (len > 0) {
     out_nl (v,str);
	indent (+1);
	printhex_buf (v+1,b,len);
	indent (-1);
  }
}

void print_private_data (int v, u_char *b, u_int len)
{
  print_databytes (v,"Private Data:",b,len);
}

void print_databytes_line  (int v, const char *str, u_char *b, u_int len)
{
  if (len > 0) {
     out (v,"%s ",str);
     printhexline_buf (v+1,b,len);
  }
}









/*
   -- str2i
   -- string to integer
   --   x, 0x ist Hex
   --   ansonsten Dezimal
   return:  long int

*/

long  str2i  (char *s)
{
 long v;
 
 if (!s) s = "";

 v = strtol (s, NULL, 0);
 return v;

}





/*
   -- str2barray
   -- string to integer (byte array)
   --   x, 0x ist Hex, ansonsten Dezimal oder octal
   --- Input:  1 byte:    0xF0
   ---         multibyte: 0xFE.12.43.4F.6F (etc) (hex)
                          123.255.24 (dec)
   -- return:  <0 = error, 0 = no filter, >0 = count filter bytes
*/

int  str2barray  (char *s, u_char *barray, int max_len)
{
 int  i = 0;
 long v;
 int  base = 10;
 char *endptr = NULL;


 if (!s) s = "";

 // -- get base
 if (*s == '0') {
	base = 8;  // octal
 	if (*s && *(s+1) == 'x') base = 16; // hex
 }

 while (1)  {
	 if ( i >= max_len) break;

	 v = strtol (s, &endptr, base);
	 if ( v < 0 || v > 0xFF) return -1;
	 if (s == endptr) return -1; // illegal char...
	 barray[i++] = v;
	 if (! *endptr) break;   // end of string
	 s = endptr + 1;
 }

 return i;
}







/*
 -- latitude coordinates   (Cell Descriptors)
 -- longitude coordinates   (Cell Descriptors)
 -- ETSI EN 300 468
*/ 

static char *_str_cell_latitude_longitude (long ll, int angle);

char *str_cell_latitude (long latitude)
{
 // cell_latitude: This 16-bit field, coded as a two's complement number,
 // shall specify the latitude of the corner of a spherical rectangle that
 // approximately describes the coverage area of the cell indicated. It shall
 // be calculated by multiplying the value of the latitude field by
 // (90