flac.c

   1 /*
   2  * Copyright 2005 Timo Hirvonen
   3  *
   4  * This program is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU General Public License as
   6  * published by the Free Software Foundation; either version 2 of the
   7  * License, or (at your option) any later version.
   8  *
   9  * This program is distributed in the hope that it will be useful, but
  10  * WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU General Public License
  15  * along with this program; if not, write to the Free Software
  16  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
  17  * 02111-1307, USA.
  18  */
  19
  20 #include <ip.h>
  21 #include <comment.h>
  22 #include <xmalloc.h>
  23 #include <debug.h>
  24
  25 #include <FLAC/seekable_stream_decoder.h>
  26 #include <FLAC/metadata.h>
  27 #include <inttypes.h>
  28 #include <sys/types.h>
  29 #include <unistd.h>
  30 #include <errno.h>
  31
  32 #ifndef UINT64_MAX
  33 #define UINT64_MAX ((uint64_t)-1)
  34 #endif
  35
  36 /* Reduce typing.  Namespaces are nice but FLAC API is fscking ridiculous.  */
  37
  38 /* functions, types, enums */
  39 #define F(s) FLAC__seekable_stream_decoder_ ## s
  40 #define T(s) FLAC__SeekableStreamDecoder ## s
  41 #define Dec FLAC__SeekableStreamDecoder
  42 #define E(s) FLAC__SEEKABLE_STREAM_DECODER_ ## s
  43
  44 struct flac_private {
  45         /* file/stream position and length */
  46         uint64_t pos;
  47         uint64_t len;
  48
  49         Dec *dec;
  50
  51         /* PCM data */
  52         char *buf;
  53         unsigned int buf_size;
  54         unsigned int buf_wpos;
  55         unsigned int buf_rpos;
  56
  57         struct keyval *comments;
  58         int duration;
  59
  60         unsigned int eof : 1;
  61         unsigned int ignore_next_write : 1;
  62 };
  63
  64 static T(ReadStatus) read_cb(const Dec *dec, unsigned char *buf, unsigned *size, void *data)
  65 {
  66         struct input_plugin_data *ip_data = data;
  67         struct flac_private *priv = ip_data->private;
  68         int rc;
  69
  70         if (priv->eof) {
  71                 *size = 0;
  72                 d_print("EOF! EOF! EOF!\n");
  73                 return E(READ_STATUS_OK);
  74         }
  75         if (*size == 0)
  76                 return E(READ_STATUS_OK);
  77
  78         rc = read(ip_data->fd, buf, *size);
  79         if (rc == -1) {
  80                 *size = 0;
  81                 if (errno == EINTR || errno == EAGAIN) {
  82                         /* FIXME: not sure how the flac decoder handles this */
  83                         d_print("interrupted\n");
  84                         return E(READ_STATUS_OK);
  85                 }
  86                 return E(READ_STATUS_ERROR);
  87         }
  88         if (*size != rc) {
  89                 d_print("%d != %d\n", rc, *size);
  90         }
  91         priv->pos += rc;
  92         *size = rc;
  93         if (rc == 0) {
  94                 /* never reached! */
  95                 priv->eof = 1;
  96                 d_print("EOF\n");
  97                 return E(READ_STATUS_OK);
  98         }
  99         return E(READ_STATUS_OK);
 100 }
 101
 102 static T(SeekStatus) seek_cb(const Dec *dec, uint64_t offset, void *data)
 103 {
 104         struct input_plugin_data *ip_data = data;
 105         struct flac_private *priv = ip_data->private;
 106         off_t off;
 107
 108         if (priv->len == UINT64_MAX)
 109                 return E(SEEK_STATUS_ERROR);
 110         off = lseek(ip_data->fd, offset, SEEK_SET);
 111         if (off == -1) {
 112                 return E(SEEK_STATUS_ERROR);
 113         }
 114         priv->pos = off;
 115         return E(SEEK_STATUS_OK);
 116 }
 117
 118 static T(TellStatus) tell_cb(const Dec *dec, uint64_t *offset, void *data)
 119 {
 120         struct input_plugin_data *ip_data = data;
 121         struct flac_private *priv = ip_data->private;
 122
 123         d_print("\n");
 124         *offset = priv->pos;
 125         return E(TELL_STATUS_OK);
 126 }
 127
 128 static T(LengthStatus) length_cb(const Dec *dec, uint64_t *len, void *data)
 129 {
 130         struct input_plugin_data *ip_data = data;
 131         struct flac_private *priv = ip_data->private;
 132
 133         d_print("\n");
 134         if (ip_data->remote) {
 135                 return E(LENGTH_STATUS_ERROR);
 136         }
 137         *len = priv->len;
 138         return E(LENGTH_STATUS_OK);
 139 }
 140
 141 static int eof_cb(const Dec *dec, void *data)
 142 {
 143         struct input_plugin_data *ip_data = data;
 144         struct flac_private *priv = ip_data->private;
 145
 146         d_print("%d\n", priv->eof);
 147         return priv->eof;
 148 }
 149
 150 static FLAC__StreamDecoderWriteStatus write_cb(const Dec *dec, const FLAC__Frame *frame,
 151                 const int32_t * const *buf, void *data)
 152 {
 153         struct input_plugin_data *ip_data = data;
 154         struct flac_private *priv = ip_data->private;
 155         int samples, bytes, size, channels, bits;
 156
 157         if (ip_data->sf == 0) {
 158                 return FLAC__STREAM_DECODER_WRITE_STATUS_CONTINUE;
 159         }
 160
 161         if (priv->ignore_next_write) {
 162                 priv->ignore_next_write = 0;
 163                 return FLAC__STREAM_DECODER_WRITE_STATUS_CONTINUE;
 164         }
 165
 166         samples = frame->header.blocksize;
 167         channels = sf_get_channels(ip_data->sf);
 168         bits = sf_get_bits(ip_data->sf);
 169         bytes = samples * frame->header.bits_per_sample / 8 * channels;
 170         size = priv->buf_size;
 171
 172         if (size - priv->buf_wpos < bytes) {
 173                 if (size < bytes)
 174                         size = bytes;
 175                 size *= 2;
 176                 priv->buf = xrenew(char, priv->buf, size);
 177                 priv->buf_size = size;
 178         }
 179
 180         if (bits == 8) {
 181                 char *b = priv->buf + priv->buf_wpos;
 182                 int ch, i, j = 0;
 183
 184                 for (i = 0; i < samples; i++) {
 185                         for (ch = 0; ch < channels; ch++)
 186                                 b[j++] = buf[ch][i];
 187                 }
 188         } else if (bits == 16) {
 189                 int16_t *b = (int16_t *)(priv->buf + priv->buf_wpos);
 190                 int ch, i, j = 0;
 191
 192                 for (i = 0; i < samples; i++) {
 193                         for (ch = 0; ch < channels; ch++)
 194                                 b[j++] = buf[ch][i];
 195                 }
 196         } else if (bits == 24) {
 197                 char *b = (char *)(priv->buf + priv->buf_wpos);
 198                 int ch, i, j = 0;
 199
 200                 /* NOT TESTED! */
 201                 for (i = 0; i < samples; i++) {
 202                         for (ch = 0; ch < channels; ch++) {
 203                                 int32_t sample = buf[ch][i];
 204
 205                                 /* FIXME: doesn't work with bin-endian machines? */
 206                                 b[j++] = sample & 0xff; sample >>= 8;
 207                                 b[j++] = sample & 0xff; sample >>= 8;
 208                                 b[j++] = sample & 0xff;
 209                         }
 210                 }
 211         } else { /* 32 */
 212                 int32_t *b = (int32_t *)(priv->buf + priv->buf_wpos);
 213                 int ch, i, j = 0;
 214
 215                 /* NOT TESTED! */
 216                 for (i = 0; i < samples; i++) {
 217                         for (ch = 0; ch < channels; ch++)
 218                                 b[j++] = buf[ch][i];
 219                 }
 220         }
 221
 222         priv->buf_wpos += bytes;
 223         return FLAC__STREAM_DECODER_WRITE_STATUS_CONTINUE;
 224 }
 225
 226 /* You should make a copy of metadata with FLAC__metadata_object_clone() if you will
 227  * need it elsewhere. Since metadata blocks can potentially be large, by
 228  * default the decoder only calls the metadata callback for the STREAMINFO
 229  * block; you can instruct the decoder to pass or filter other blocks with
 230  * FLAC__stream_decoder_set_metadata_*() calls.
 231  */
 232 static void metadata_cb(const Dec *dec, const FLAC__StreamMetadata *metadata, void *data)
 233 {
 234         struct input_plugin_data *ip_data = data;
 235         struct flac_private *priv = ip_data->private;
 236
 237         switch (metadata->type) {
 238         case FLAC__METADATA_TYPE_STREAMINFO:
 239                 {
 240                         const FLAC__StreamMetadata_StreamInfo *si = &metadata->data.stream_info;
 241
 242                         d_print("STREAMINFO\n");
 243                         ip_data->sf = sf_rate(si->sample_rate) | sf_bits(si->bits_per_sample) |
 244                                 sf_signed(1) | sf_channels(si->channels);
 245                         if (!ip_data->remote && si->total_samples)
 246                                 priv->duration = si->total_samples / si->sample_rate;
 247                 }
 248                 break;
 249         case FLAC__METADATA_TYPE_VORBIS_COMMENT:
 250                 d_print("VORBISCOMMENT\n");
 251                 if (priv->comments) {
 252                         d_print("Ignoring\n");
 253                 } else {
 254                         struct keyval *c;
 255                         int s, d, nr;
 256
 257                         nr = metadata->data.vorbis_comment.num_comments;
 258                         c = xnew0(struct keyval, nr + 1);
 259                         for (s = 0, d = 0; s < nr; s++) {
 260                                 char *key, *val;
 261
 262                                 /* until you have finished reading this function name
 263                                  * you have already forgot WTF you're doing */
 264                                 if (!FLAC__metadata_object_vorbiscomment_entry_to_name_value_pair(
 265                                                         metadata->data.vorbis_comment.comments[s],
 266                                                         &key, &val))
 267                                         continue;
 268
 269                                 if (!is_interesting_key(key)) {
 270                                         free(key);
 271                                         free(val);
 272                                         continue;
 273                                 }
 274                                 if (!strcasecmp(key, "tracknumber") || !strcasecmp(key, "discnumber"))
 275                                         fix_track_or_disc(val);
 276
 277                                 d_print("comment: '%s=%s'\n", key, val);
 278                                 c[d].key = key;
 279                                 c[d].val = val;
 280                                 d++;
 281                         }
 282                         priv->comments = c;
 283                 }
 284                 break;
 285         default:
 286                 d_print("something else\n");
 287                 break;
 288         }
 289 }
 290
 291 static void error_cb(const Dec *dec, FLAC__StreamDecoderErrorStatus status, void *data)
 292 {
 293 /*      struct input_plugin_data *ip_data = data; */
 294 /*      struct flac_private *priv = ip_data->private; */
 295
 296         d_print("\n");
 297 }
 298
 299 static int flac_open(struct input_plugin_data *ip_data)
 300 {
 301         struct flac_private *priv;
 302         Dec *dec;
 303
 304         dec = F(new)();
 305         if (dec == NULL)
 306                 return -IP_ERROR_INTERNAL;
 307
 308         priv = xnew(struct flac_private, 1);
 309         priv->dec = dec;
 310         priv->buf = NULL;
 311         priv->buf_size = 0;
 312         priv->buf_wpos = 0;
 313         priv->buf_rpos = 0;
 314         priv->eof = 0;
 315         priv->ignore_next_write = 0;
 316         priv->pos = 0;
 317         priv->comments = NULL;
 318         priv->duration = -1;
 319         if (ip_data->remote) {
 320                 priv->len = UINT64_MAX;
 321         } else {
 322                 off_t off = lseek(ip_data->fd, 0, SEEK_END);
 323
 324                 if (off == -1 || lseek(ip_data->fd, 0, SEEK_SET) == -1) {
 325                         int save = errno;
 326
 327                         F(delete)(dec);
 328                         free(priv);
 329                         errno = save;
 330                         return -IP_ERROR_ERRNO;
 331                 }
 332                 priv->len = off;
 333         }
 334         ip_data->private = priv;
 335
 336         F(set_read_callback)(dec, read_cb);
 337         F(set_seek_callback)(dec, seek_cb);
 338         F(set_tell_callback)(dec, tell_cb);
 339         F(set_length_callback)(dec, length_cb);
 340         F(set_eof_callback)(dec, eof_cb);
 341         F(set_write_callback)(dec, write_cb);
 342         F(set_metadata_callback)(dec, metadata_cb);
 343         F(set_error_callback)(dec, error_cb);
 344         F(set_client_data)(dec, ip_data);
 345
 346         /* FLAC__METADATA_TYPE_STREAMINFO already accepted */
 347         F(set_metadata_respond)(dec, FLAC__METADATA_TYPE_VORBIS_COMMENT);
 348
 349         if (F(init)(dec) != E(OK)) {
 350                 int save = errno;
 351
 352                 d_print("init failed\n");
 353                 F(delete)(priv->dec);
 354                 free(priv);
 355                 ip_data->private = NULL;
 356                 errno = save;
 357                 return -IP_ERROR_ERRNO;
 358         }
 359
 360         ip_data->sf = 0;
 361         while (priv->buf_wpos == 0 && !priv->eof) {
 362                 if (!F(process_single)(priv->dec)) {
 363                         int save = errno;
 364
 365                         d_print("process_single failed\n");
 366                         F(finish)(priv->dec);
 367                         F(delete)(priv->dec);
 368                         if (priv->comments)
 369                                 free(priv->comments);
 370                         free(priv->buf);
 371                         free(priv);
 372                         ip_data->private = NULL;
 373                         errno = save;
 374                         return -IP_ERROR_ERRNO;
 375                 }
 376         }
 377         BUG_ON(ip_data->sf == 0);
 378         d_print("sr: %d, ch: %d, bits: %d\n", sf_get_rate(ip_data->sf),
 379                         sf_get_channels(ip_data->sf), sf_get_bits(ip_data->sf));
 380         return 0;
 381 }
 382
 383 static int flac_close(struct input_plugin_data *ip_data)
 384 {
 385         struct flac_private *priv = ip_data->private;
 386
 387         F(finish)(priv->dec);
 388         F(delete)(priv->dec);
 389         if (priv->comments)
 390                 comments_free(priv->comments);
 391         free(priv->buf);
 392         free(priv);
 393         ip_data->private = NULL;
 394         return 0;
 395 }
 396
 397 static int flac_read(struct input_plugin_data *ip_data, char *buffer, int count)
 398 {
 399         struct flac_private *priv = ip_data->private;
 400         int avail;
 401         int libflac_suck_count = 0;
 402
 403         while (1) {
 404                 int old_pos = priv->buf_wpos;
 405
 406                 avail = priv->buf_wpos - priv->buf_rpos;
 407                 BUG_ON(avail < 0);
 408                 if (avail > 0)
 409                         break;
 410                 if (priv->eof)
 411                         return 0;
 412                 if (!F(process_single)(priv->dec)) {
 413                         d_print("process_single failed\n");
 414                         return -1;
 415                 }
 416                 if (old_pos == priv->buf_wpos) {
 417                         libflac_suck_count++;
 418                 } else {
 419                         libflac_suck_count = 0;
 420                 }
 421                 if (libflac_suck_count > 5) {
 422                         d_print("libflac sucks\n");
 423                         priv->eof = 1;
 424                         return 0;
 425                 }
 426         }
 427         if (count > avail)
 428                 count = avail;
 429         memcpy(buffer, priv->buf + priv->buf_rpos, count);
 430         priv->buf_rpos += count;
 431         BUG_ON(priv->buf_rpos > priv->buf_wpos);
 432         if (priv->buf_rpos == priv->buf_wpos) {
 433                 priv->buf_rpos = 0;
 434                 priv->buf_wpos = 0;
 435         }
 436         return count;
 437 }
 438
 439 /* Flush the input and seek to an absolute sample. Decoding will resume at the
 440  * given sample. Note that because of this, the next write callback may contain
 441  * a partial block.
 442  */
 443 static int flac_seek(struct input_plugin_data *ip_data, double offset)
 444 {
 445         struct flac_private *priv = ip_data->private;
 446         uint64_t sample;
 447
 448         if (ip_data->remote)
 449                 return -IP_ERROR_ERRNO;
 450
 451         sample = (uint64_t)(offset * (double)sf_get_rate(ip_data->sf) + 0.5);
 452         if (!F(seek_absolute)(priv->dec, sample)) {
 453                 return -IP_ERROR_ERRNO;
 454         }
 455         priv->ignore_next_write = 1;
 456         priv->buf_rpos = 0;
 457         priv->buf_wpos = 0;
 458         return 0;
 459 }
 460
 461 static int flac_read_comments(struct input_plugin_data *ip_data, struct keyval **comments)
 462 {
 463         struct flac_private *priv = ip_data->private;
 464
 465         if (priv->comments) {
 466                 *comments = comments_dup(priv->comments);
 467         } else {
 468                 *comments = xnew0(struct keyval, 1);
 469         }
 470         return 0;
 471 }
 472
 473 static int flac_duration(struct input_plugin_data *ip_data)
 474 {
 475         struct flac_private *priv = ip_data->private;
 476
 477         return priv->duration;
 478 }
 479
 480 const struct input_plugin_ops ip_ops = {
 481         .open = flac_open,
 482         .close = flac_close,
 483         .read = flac_read,
 484         .seek = flac_seek,
 485         .read_comments = flac_read_comments,
 486         .duration = flac_duration
 487 };
 488
 489 const char * const ip_extensions[] = { "flac", "fla", NULL };
 490 const char * const ip_mime_types[] = { NULL };