fecdec_filter.c

   1 /*
   2  * Copyright (C) 2009 Andre Noll <maan@systemlinux.org>
   3  *
   4  * Licensed under the GPL v2. For licencing details see COPYING.
   5  */
   6
   7 /** \file fecdec_filter.c A filter fec-decodes an audio stream. */
   8
   9 #include <dirent.h>
  10 #include "para.h"
  11 #include "error.h"
  12 #include "list.h"
  13 #include "sched.h"
  14 #include "ggo.h"
  15 #include "filter.h"
  16 #include "string.h"
  17 #include "portable_io.h"
  18 #include "fec.h"
  19 #include "fd.h"
  20
  21 /**
  22  * How many FEC groups to store in memory.
  23  *
  24  * Packet reordering requires to keep more than one FEC group in memory because
  25  * slices belonging to the next FEC group may arrive before the current FEC group
  26  * is complete.
  27  */
  28 #define NUM_FEC_GROUPS 3
  29
  30 /** Default size of the output buffer of the fecdec filter. */
  31 #define FECDEC_DEFAULT_OUTBUF_SIZE (3 * 1024)
  32 /** Maximal size of the output buffer of the fecdec filter. */
  33 #define FECDEC_MAX_OUTBUF_SIZE (1024 * 1024)
  34
  35 /** Data read from the header of a slice. */
  36 struct fec_header {
  37         /** Total number of slices in this group. */
  38         uint8_t slices_per_group;
  39         /** Number of slices needed to start decoding. */
  40         uint8_t data_slices_per_group;
  41         /** Size of the ogg vorbis header (zero for mp3, aac). */
  42         uint32_t audio_header_size;
  43         /** Number of the FEC group this slice belongs to. */
  44         uint32_t group_num;
  45         /** Size of the data in this FEC group. */
  46         uint32_t group_bytes;
  47         /** Number of this slice in the group. */
  48         uint8_t slice_num;
  49         /** Used data bytes of this slice. */
  50         uint16_t slice_bytes;
  51         /** Non-zero if this group is the beginning of the stream. */
  52         uint8_t bos;
  53         /** Non-zero if this stream embedds audio headers into fec groups. */
  54         uint8_t header_stream;
  55 };
  56
  57 /**
  58  * The status of one partially received FEC group.
  59  */
  60 struct fecdec_group {
  61         /** The header read from the last slice. */
  62         struct fec_header h;
  63         /** How many slices received so far. */
  64         int num_received_slices;
  65         /** The size of the \a idx and the \a data arrays below. */
  66         int num_slices;
  67         /** Array of indices of the received slices. */
  68         int *idx;
  69         /** Content of the received slices. */
  70         unsigned char **data;
  71 };
  72
  73 /**
  74  * Data private to the fecdec filter.
  75  */
  76 struct private_fecdec_data {
  77         /** Used by the fec core code. */
  78         struct fec_parms *fec;
  79         /** Keeps track of what was received so far. */
  80         struct fecdec_group groups[NUM_FEC_GROUPS];
  81         /** Whether an audio file header was already received. */
  82         int have_header;
  83 };
  84
  85 /** Iterate over all fecdec groups. */
  86 #define FOR_EACH_FECDEC_GROUP(g, d) for (g = (d)->groups; \
  87         (g) - (d)->groups < NUM_FEC_GROUPS; (g)++)
  88
  89 static int group_complete(struct fecdec_group *fg)
  90 {
  91         return fg->num_received_slices >= fg->h.data_slices_per_group;
  92 }
  93
  94 static int group_empty(struct fecdec_group *fg)
  95 {
  96         return fg->num_received_slices == 0;
  97 }
  98
  99 static void clear_group(struct fecdec_group *fg)
 100 {
 101         int i;
 102
 103         for (i = 0; i < fg->num_slices; i++) {
 104                 free(fg->data[i]);
 105                 fg->data[i] = NULL;
 106                 fg->idx[i] = -1;
 107         }
 108         free(fg->data);
 109         free(fg->idx);
 110         fg->num_slices = 0;
 111         memset(&fg->h, 0, sizeof(struct fec_header));
 112         fg->num_received_slices = 0;
 113 }
 114
 115 static int find_group(struct fec_header *h,
 116                 struct private_fecdec_data *pfd, struct fecdec_group **result)
 117 {
 118         struct fecdec_group *fg;
 119
 120         FOR_EACH_FECDEC_GROUP(fg, pfd) {
 121                 if (fg->h.group_num != h->group_num)
 122                         continue;
 123                 if (fg->num_received_slices == 0)
 124                         goto success;
 125                 if (fg->h.slices_per_group != h->slices_per_group)
 126                         return -E_BAD_FEC_HEADER;
 127                 if (fg->h.data_slices_per_group != h->data_slices_per_group)
 128                         return -E_BAD_FEC_HEADER;
 129                 if (fg->h.group_bytes != h->group_bytes)
 130                         return -E_BAD_FEC_HEADER;
 131 success:
 132                 *result = fg;
 133                 return 1;
 134         }
 135         return 0;
 136 }
 137
 138 static struct fecdec_group *find_unused_group(struct private_fecdec_data *pfd)
 139 {
 140         struct fecdec_group *fg;
 141
 142         FOR_EACH_FECDEC_GROUP(fg, pfd) {
 143                 if (fg->num_received_slices == 0)
 144                         return fg;
 145         }
 146         return NULL;
 147 }
 148
 149 static struct fecdec_group *try_to_free_group(struct private_fecdec_data *pfd)
 150 {
 151         struct fecdec_group *fg;
 152
 153         FOR_EACH_FECDEC_GROUP(fg, pfd) {
 154                 if (!group_complete(fg))
 155                         continue;
 156                 clear_group(fg);
 157                 return fg;
 158         }
 159         return NULL;
 160 }
 161
 162 static struct fecdec_group *free_oldest_group(struct private_fecdec_data *pfd)
 163 {
 164         struct fecdec_group *fg, *oldest = NULL;
 165
 166         FOR_EACH_FECDEC_GROUP(fg, pfd) {
 167                 if (!oldest || oldest->h.group_num > fg->h.group_num)
 168                         oldest = fg;
 169         }
 170         if (!group_complete(oldest) && !group_empty(oldest))
 171                 PARA_WARNING_LOG("Clearing incomplete group %d "
 172                         "(contains %d slices)\n", oldest->h.group_num,
 173                         oldest->num_received_slices);
 174         clear_group(oldest);
 175         return oldest;
 176 }
 177
 178 /* returns 1 if the group was found, 0 if not, negative on errors */
 179 static int get_group(struct fec_header *h, struct private_fecdec_data *pfd,
 180                 struct fecdec_group **result)
 181 {
 182         struct fecdec_group *fg;
 183         int ret = find_group(h, pfd, &fg);
 184
 185         if (ret < 0)
 186                 return ret;
 187         if (ret > 0) /* found group */
 188                 goto success;
 189         /* group not found */
 190         fg = find_unused_group(pfd);
 191         if (fg)
 192                 goto success;
 193         fg = try_to_free_group(pfd);
 194         if (fg)
 195                 goto success;
 196         fg = free_oldest_group(pfd);
 197         ret = 0;
 198 success:
 199         fg->h = *h;
 200         *result = fg;
 201         return ret;
 202 }
 203
 204 /*
 205  * returns 1 if slice was added, zero otherwise (because the group was already
 206  * complete). In any case the number of received slices is being increased by
 207  * one.
 208  */
 209 static int add_slice(char *buf, struct fecdec_group *fg)
 210 {
 211         int r, slice_num;
 212
 213         if (group_complete(fg)) {
 214                 PARA_DEBUG_LOG("group complete, ignoring slice %d\n",
 215                         fg->h.slice_num);
 216                 fg->num_received_slices++;
 217                 return 0;
 218         }
 219         slice_num = fg->h.slice_num;
 220         if (fg->num_slices == 0) {
 221                 fg->num_slices = fg->h.slices_per_group;
 222                 fg->idx = malloc(fg->num_slices * sizeof(int));
 223                 fg->data = malloc(fg->num_slices * sizeof(unsigned char *));
 224                 memset(fg->data, 0, fg->num_slices * sizeof(unsigned char *));
 225         }
 226         r = fg->num_received_slices;
 227         fg->idx[r] = slice_num;
 228         fg->data[r] = malloc(fg->h.slice_bytes);
 229         memcpy(fg->data[r], buf, fg->h.slice_bytes);
 230         fg->num_received_slices++;
 231         return 1;
 232 }
 233
 234 enum fec_group_usability {
 235         FEC_GROUP_UNUSABLE,
 236         FEC_GROUP_USABLE,
 237         FEC_GROUP_USABLE_SKIP_HEADER,
 238 };
 239
 240 static enum fec_group_usability group_is_usable(struct fecdec_group *fg,
 241                 struct private_fecdec_data *pfd)
 242 {
 243         struct fec_header *h = &fg->h;
 244
 245         if (!h->header_stream)
 246                 return FEC_GROUP_USABLE;
 247         if (pfd->have_header) {
 248                 if (h->audio_header_size)
 249                         return FEC_GROUP_USABLE_SKIP_HEADER;
 250                 return FEC_GROUP_USABLE;
 251         }
 252         if (fg->h.bos)
 253                 return FEC_GROUP_USABLE;
 254         if (fg->h.audio_header_size)
 255                 return FEC_GROUP_USABLE;
 256         return FEC_GROUP_UNUSABLE;
 257 }
 258
 259 static int decode_group(struct fecdec_group *fg, struct filter_node *fn)
 260 {
 261         int i, ret, sb = fg->h.slice_bytes;
 262         size_t written = 0, need;
 263         struct private_fecdec_data *pfd = fn->private_data;
 264         enum fec_group_usability u = group_is_usable(fg, pfd);
 265
 266         if (u == FEC_GROUP_UNUSABLE) {
 267                 PARA_INFO_LOG("dropping unusable group %d\n", fg->h.group_num);
 268                 return 0;
 269         }
 270         PARA_DEBUG_LOG("decoding group %d %d slices\n", fg->h.group_num,
 271                 fg->h.data_slices_per_group);
 272         ret = fec_decode(pfd->fec, fg->data, fg->idx, sb);
 273         if (ret < 0)
 274                 return ret;
 275         pfd->have_header = 1;
 276         i = 0;
 277         if (u == FEC_GROUP_USABLE_SKIP_HEADER) {
 278                 i = ROUND_UP(fg->h.audio_header_size, fg->h.slice_bytes)
 279                         / fg->h.slice_bytes;
 280                 PARA_DEBUG_LOG("skipping %d header slices\n", i);
 281         }
 282         PARA_DEBUG_LOG("writing group %d (%d/%d decoded data bytes)\n",
 283                 fg->h.group_num, fg->h.group_bytes,
 284                 fg->h.data_slices_per_group * sb);
 285         need = fn->loaded + (fg->h.data_slices_per_group - i)* sb;
 286         if (need > fn->bufsize) {
 287                 fn->bufsize = PARA_MAX(fn->bufsize * 2, need);
 288                 if (fn->bufsize > FECDEC_MAX_OUTBUF_SIZE)
 289                         return -E_FECDEC_OVERRUN;
 290                 PARA_INFO_LOG("increasing fec buf to %zu\n", fn->bufsize);
 291                 fn->buf = para_realloc(fn->buf, fn->bufsize);
 292         }
 293         for (; i < fg->h.data_slices_per_group; i++) {
 294                 size_t n = sb;
 295                 if (n + written > fg->h.group_bytes)
 296                         n = fg->h.group_bytes - written;
 297                 memcpy(fn->buf + fn->loaded, fg->data[i], n);
 298                 fn->loaded += n;
 299                 written += n;
 300         }
 301         return 0;
 302 }
 303
 304 /**
 305  * Read a fec header from a buffer.
 306  *
 307  * \param buf The buffer to write to.
 308  * \param h The fec header to write.
 309  */
 310 static int read_fec_header(char *buf, size_t len, struct fec_header *h)
 311 {
 312         uint32_t magic;
 313
 314         if (len < FEC_HEADER_SIZE)
 315                 return 0;
 316         magic = read_u32(buf);
 317         if (magic != FEC_MAGIC)
 318                 return -E_BAD_FEC_HEADER;
 319         h->slices_per_group = read_u8(buf + 4);
 320         h->data_slices_per_group = read_u8(buf + 5);
 321         h->audio_header_size = read_u32(buf + 6);
 322
 323         h->group_num = read_u32(buf + 10);
 324         h->group_bytes = read_u32(buf + 14);
 325
 326         h->slice_num = read_u8(buf + 18);
 327         h->slice_bytes = read_u16(buf + 20);
 328         h->bos = read_u8(buf + 22);
 329         h->header_stream = read_u8(buf + 23);
 330         if (!memcmp(buf, FEC_EOF_PACKET, FEC_EOF_PACKET_LEN))
 331                 return -E_FECDEC_EOF;
 332 //      PARA_DEBUG_LOG("group %u, slize %u, slices per group: %u\n",
 333 //              h->group_num, h->slice_num, h->slices_per_group);
 334         return 1;
 335 }
 336
 337 /* returns 1 if we used the buffer, 0 if we didn't, negative on errors */
 338 static int dispatch_slice(char *buf, size_t len, struct fec_header *h,
 339                 struct filter_node *fn)
 340 {
 341         struct fecdec_group *fg;
 342         int ret;
 343         struct private_fecdec_data *pfd = fn->private_data;
 344
 345         if (h->slice_bytes > len) /* can not use the thing, try to read more */
 346                 return 0;
 347         ret = get_group(h, pfd, &fg);
 348         if (ret < 0)
 349                 return ret;
 350         if (!add_slice(buf, fg))
 351                 return 1;
 352         if (group_complete(fg)) {
 353                 if (!pfd->fec) {
 354                         int k = h->data_slices_per_group, n = h->slices_per_group;
 355                         PARA_NOTICE_LOG("init fec (%d, %d)\n", k, n);
 356                         ret = fec_new(k, n, &pfd->fec);
 357                         if (ret < 0)
 358                                 return ret;
 359                 }
 360                 ret = decode_group(fg, fn);
 361                 if (ret < 0)
 362                         return ret;
 363         }
 364         return 1;
 365 }
 366
 367 static ssize_t fecdec(char *buf, size_t len, struct filter_node *fn)
 368 {
 369         int ret;
 370         struct fec_header h;
 371
 372         ret = read_fec_header(buf, len, &h);
 373         if (ret <= 0)
 374                 return ret;
 375         if (!h.slice_bytes)
 376                 return -E_BAD_SLICE_SIZE;
 377         if (h.slice_num > h.slices_per_group)
 378                 return -E_BAD_SLICE_NUM;
 379         ret = dispatch_slice(buf + FEC_HEADER_SIZE, len - FEC_HEADER_SIZE,
 380                 &h, fn);
 381         //PARA_INFO_LOG("ret: %d, len: %d, slice_bytes: %d\n", ret, len, h.slice_bytes);
 382         if (ret <= 0)
 383                 return ret;
 384         return FEC_HEADER_SIZE + h.slice_bytes;
 385 }
 386
 387 static void fecdec_close(struct filter_node *fn)
 388 {
 389         struct private_fecdec_data *pfd = fn->private_data;
 390         struct fecdec_group *fg;
 391
 392         FOR_EACH_FECDEC_GROUP(fg, pfd)
 393                 clear_group(fg);
 394         free(fn->buf);
 395         fn->buf = NULL;
 396         fec_free(pfd->fec);
 397         free(fn->private_data);
 398         fn->private_data = NULL;
 399 }
 400
 401 static void fecdec_open(struct filter_node *fn)
 402 {
 403         fn->bufsize = FECDEC_DEFAULT_OUTBUF_SIZE;
 404         fn->buf = para_malloc(fn->bufsize);
 405         fn->private_data = para_calloc(sizeof(struct private_fecdec_data));
 406         fn->loaded = 0;
 407 }
 408
 409 /**
 410  * The init function of the fecdec filter.
 411  *
 412  * \param f struct to initialize.
 413  */
 414 void fecdec_filter_init(struct filter *f)
 415 {
 416         f->convert = fecdec;
 417         f->close = fecdec_close;
 418         f->open = fecdec_open;
 419 }