sys/dvb/camutils.c

   1 /*
   2  * camutils.c -
   3  * Copyright (C) 2007 Alessandro Decina
   4  *
   5  * Authors:
   6  *   Alessandro Decina <alessandro@nnva.org>
   7  *
   8  * This library is free software; you can redistribute it and/or
   9  * modify it under the terms of the GNU Library General Public
  10  * License as published by the Free Software Foundation; either
  11  * version 2 of the License, or (at your option) any later version.
  12  *
  13  * This library is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16  * Library General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU Library General Public
  19  * License along with this library; if not, write to the
  20  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  21  * Boston, MA 02111-1307, USA.
  22  */
  23
  24 #include <gst/gst.h>
  25 #include <string.h>
  26
  27 #include "cam.h"
  28 #include "camutils.h"
  29
  30 #define GST_CAT_DEFAULT cam_debug_cat
  31
  32 /* From the spec:
  33  * length_field() {
  34  *               size_indicator
  35  *               if (size_indicator == 0)
  36  *                        length_value
  37  *               else if (size_indicator == 1) {
  38  *                        length_field_size
  39  *                        for (i=0; i<length_field_size; i++) {
  40  *                                length_value_byte
  41  *                        }
  42  *               }
  43  * }
  44 */
  45
  46 guint8
  47 cam_calc_length_field_size (guint length)
  48 {
  49   guint field_len;
  50
  51   if (length < G_MAXUINT8)
  52     field_len = 1;
  53   else if (length <= G_MAXUINT16)
  54     field_len = 3;
  55   else if (length <= (1 << 24) - 1)
  56     field_len = 4;
  57   else
  58     field_len = 5;
  59
  60   return field_len;
  61 }
  62
  63 /* write a length_field */
  64 guint8
  65 cam_write_length_field (guint8 * buff, guint length)
  66 {
  67   guint8 field_len = cam_calc_length_field_size (length);
  68
  69   if (buff) {
  70     switch (field_len) {
  71       case 1:
  72         buff[0] = length;
  73         break;
  74       case 2:
  75         g_return_val_if_reached (0);
  76         break;
  77       case 3:
  78         buff[0] = TPDU_HEADER_SIZE_INDICATOR | (field_len - 1);
  79         buff[1] = length >> 8;
  80         buff[2] = length & 0xFF;
  81         break;
  82       case 4:
  83         buff[0] = TPDU_HEADER_SIZE_INDICATOR | (field_len - 1);
  84         buff[1] = length >> 16;
  85         buff[2] = (length >> 8) & 0xFF;
  86         buff[3] = length & 0xFF;
  87         break;
  88       case 5:
  89         buff[0] = TPDU_HEADER_SIZE_INDICATOR | (field_len - 1);
  90         buff[1] = length >> 24;
  91         buff[2] = (length >> 16) & 0xFF;
  92         buff[3] = (length >> 8) & 0xFF;
  93         buff[4] = length & 0xFF;
  94         break;
  95       default:
  96         g_return_val_if_reached (0);
  97     }
  98   }
  99
 100   return field_len;
 101 }
 102
 103 /* read a length_field */
 104 guint8
 105 cam_read_length_field (guint8 * buff, guint * length)
 106 {
 107   guint i;
 108   guint field_len;
 109   guint8 len;
 110
 111   if (buff[0] <= G_MAXINT8) {
 112     field_len = 1;
 113     len = buff[0];
 114   } else {
 115     field_len = buff[0] & ~TPDU_HEADER_SIZE_INDICATOR;
 116     if (field_len > 4) {
 117       GST_ERROR ("length_field length exceeds 4 bytes: %d", field_len);
 118       field_len = 0;
 119       len = 0;
 120     } else {
 121       len = 0;
 122       for (i = 0; i < field_len; ++i)
 123         len = (len << 8) | *++buff;
 124
 125       /* count the size indicator byte */
 126       field_len += 1;
 127     }
 128   }
 129
 130   if (length)
 131     *length = len;
 132
 133   return field_len;
 134 }
 135
 136 /*
 137  * ca_pmt () {
 138  *    ca_pmt_tag                                              24        uimsbf
 139  *    length_field()
 140  *    ca_pmt_list_management                                   8        uimsbf
 141  *    program_number                                          16        uimsbf
 142  *    reserved                                                 2        bslbf
 143  *    version_number                                           5        uimsbf
 144  *    current_next_indicator                                   1        bslbf
 145  *    reserved                                                 4        bslbf
 146  *    program_info_length                                     12        uimsbf
 147  *    if (program_info_length != 0) {
 148  *      ca_pmt_cmd_id at program level                         8        uimsbf
 149  *      for (i=0; i<n; i++) {
 150  *        CA_descriptor() programme level
 151  *      }
 152  *   }
 153  *   for (i=0; i<n; i++) {
 154  *     stream_type                                             8       uimsbf
 155  *     reserved                                                3       bslbf
 156  *     elementary_PID  elementary stream PID                  13        uimsbf
 157  *     reserved                                                4       bslbf
 158  *     ES_info_length                                         12        uimsbf
 159  *     if (ES_info_length != 0) {
 160  *       ca_pmt_cmd_id at ES level                             8       uimsbf
 161  *       for (i=0; i<n; i++) {
 162  *         CA_descriptor() elementary stream level
 163  *       }
 164  *     }
 165  *   }
 166  * }
 167  */
 168
 169 static guint
 170 get_ca_descriptors_length (GValueArray * descriptors)
 171 {
 172   guint i;
 173   guint len = 0;
 174   GValue *value;
 175   GString *desc;
 176
 177   if (descriptors != NULL) {
 178     for (i = 0; i < descriptors->n_values; ++i) {
 179       value = g_value_array_get_nth (descriptors, i);
 180       desc = (GString *) g_value_get_boxed (value);
 181
 182       if (desc->str[0] == 0x09)
 183         len += desc->len;
 184     }
 185   }
 186
 187   return len;
 188 }
 189
 190 static guint8 *
 191 write_ca_descriptors (guint8 * body, GValueArray * descriptors)
 192 {
 193   guint i;
 194   GValue *value;
 195   GString *desc;
 196
 197   if (descriptors != NULL) {
 198     for (i = 0; i < descriptors->n_values; ++i) {
 199       value = g_value_array_get_nth (descriptors, i);
 200       desc = (GString *) g_value_get_boxed (value);
 201
 202       if (desc->str[0] == 0x09) {
 203         memcpy (body, desc->str, desc->len);
 204         body += desc->len;
 205       }
 206     }
 207   }
 208
 209   return body;
 210 }
 211
 212 guint8 *
 213 cam_build_ca_pmt (GstStructure * pmt, guint8 list_management, guint8 cmd_id,
 214     guint * size)
 215 {
 216   guint body_size = 0;
 217   guint8 *buffer;
 218   guint8 *body;
 219   GList *lengths = NULL;
 220   guint len = 0;
 221   const GValue *streams;
 222   guint program_number;
 223   guint version_number;
 224   guint i;
 225   const GValue *value;
 226   GstStructure *stream;
 227   GValueArray *program_descriptors = NULL;
 228   GValueArray *stream_descriptors = NULL;
 229
 230   gst_structure_get_uint (pmt, "program-number", &program_number);
 231   gst_structure_get_uint (pmt, "version-number", &version_number);
 232   streams = gst_structure_get_value (pmt, "streams");
 233   value = gst_structure_get_value (pmt, "descriptors");
 234   if (value != NULL) {
 235     program_descriptors = g_value_get_boxed (value);
 236     /* get the length of program level CA_descriptor()s */
 237     len = get_ca_descriptors_length (program_descriptors);
 238     if (len > 0)
 239       /* add one byte for the program level cmd_id */
 240       len += 1;
 241   }
 242   lengths = g_list_append (lengths, GINT_TO_POINTER (len));
 243   body_size += 6 + len;
 244
 245   /* get the length of stream level CA_descriptor()s */
 246   if (streams != NULL) {
 247     for (i = 0; i < gst_value_list_get_size (streams); ++i) {
 248       value = gst_value_list_get_value (streams, i);
 249       stream = g_value_get_boxed (value);
 250
 251       value = gst_structure_get_value (stream, "descriptors");
 252       if (value != NULL) {
 253         stream_descriptors = g_value_get_boxed (value);
 254
 255         len = get_ca_descriptors_length (stream_descriptors);
 256         if (len > 0)
 257           /* one byte for the stream level cmd_id */
 258           len += 1;
 259       }
 260
 261       lengths = g_list_append (lengths, GINT_TO_POINTER (len));
 262       body_size += 5 + len;
 263
 264     }
 265   }
 266   buffer = g_malloc0 (body_size);
 267   body = buffer;
 268
 269   *body++ = list_management;
 270
 271   GST_WRITE_UINT16_BE (body, program_number);
 272   body += 2;
 273
 274   *body++ = (version_number << 1) | 0x01;
 275
 276   len = GPOINTER_TO_INT (lengths->data);
 277   lengths = g_list_delete_link (lengths, lengths);
 278   GST_WRITE_UINT16_BE (body, len);
 279   body += 2;
 280
 281   if (len != 0) {
 282     *body++ = cmd_id;
 283
 284     body = write_ca_descriptors (body, program_descriptors);
 285   }
 286
 287   for (i = 0; i < gst_value_list_get_size (streams); ++i) {
 288     guint stream_type;
 289     guint stream_pid;
 290
 291     value = gst_value_list_get_value (streams, i);
 292     stream = g_value_get_boxed (value);
 293
 294     gst_structure_get_uint (stream, "stream-type", &stream_type);
 295     gst_structure_get_uint (stream, "pid", &stream_pid);
 296     value = gst_structure_get_value (stream, "descriptors");
 297     stream_descriptors = g_value_get_boxed (value);
 298
 299     *body++ = stream_type;
 300     GST_WRITE_UINT16_BE (body, stream_pid);
 301     body += 2;
 302     len = GPOINTER_TO_INT (lengths->data);
 303     lengths = g_list_delete_link (lengths, lengths);
 304     GST_WRITE_UINT16_BE (body, len);
 305     body += 2;
 306
 307     if (len != 0) {
 308       *body++ = cmd_id;
 309       body = write_ca_descriptors (body, stream_descriptors);
 310     }
 311   }
 312
 313   *size = body_size;
 314   return buffer;
 315 }