flac.c

   1 #include "ip.h"
   2 #include "comment.h"
   3 #include "xmalloc.h"
   4 #include "debug.h"
   5
   6 #include <FLAC/export.h>
   7
   8 #ifdef FLAC_API_VERSION_CURRENT
   9 /* flac 1.1.3 */
  10 #define FLAC_NEW_API 1
  11 #endif
  12
  13 #ifdef FLAC_NEW_API
  14 #include <FLAC/stream_decoder.h>
  15 #else
  16 #include <FLAC/seekable_stream_decoder.h>
  17 #endif
  18
  19 #include <FLAC/metadata.h>
  20 #include <inttypes.h>
  21 #include <sys/types.h>
  22 #include <unistd.h>
  23 #include <errno.h>
  24
  25 #ifndef UINT64_MAX
  26 #define UINT64_MAX ((uint64_t)-1)
  27 #endif
  28
  29 /* Reduce typing.  Namespaces are nice but FLAC API is fscking ridiculous.  */
  30
  31 /* functions, types, enums */
  32 #ifdef FLAC_NEW_API
  33 #define F(s) FLAC__stream_decoder_ ## s
  34 #define T(s) FLAC__StreamDecoder ## s
  35 #define Dec FLAC__StreamDecoder
  36 #define E(s) FLAC__STREAM_DECODER_ ## s
  37 #else
  38 #define F(s) FLAC__seekable_stream_decoder_ ## s
  39 #define T(s) FLAC__SeekableStreamDecoder ## s
  40 #define Dec FLAC__SeekableStreamDecoder
  41 #define E(s) FLAC__SEEKABLE_STREAM_DECODER_ ## s
  42 #endif
  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 #ifdef FLAC_NEW_API
  65 static T(ReadStatus) read_cb(const Dec *dec, unsigned char *buf, size_t *size, void *data)
  66 #else
  67 static T(ReadStatus) read_cb(const Dec *dec, unsigned char *buf, unsigned *size, void *data)
  68 #endif
  69 {
  70         struct input_plugin_data *ip_data = data;
  71         struct flac_private *priv = ip_data->private;
  72         int rc;
  73
  74         if (priv->eof) {
  75                 *size = 0;
  76                 d_print("EOF! EOF! EOF!\n");
  77 #ifdef FLAC_NEW_API
  78                 return E(READ_STATUS_END_OF_STREAM);
  79 #else
  80                 return E(READ_STATUS_OK);
  81 #endif
  82         }
  83         if (*size == 0)
  84 #ifdef FLAC_NEW_API
  85                 return E(READ_STATUS_CONTINUE);
  86 #else
  87                 return E(READ_STATUS_OK);
  88 #endif
  89
  90         rc = read(ip_data->fd, buf, *size);
  91         if (rc == -1) {
  92                 *size = 0;
  93                 if (errno == EINTR || errno == EAGAIN) {
  94                         /* FIXME: not sure how the flac decoder handles this */
  95                         d_print("interrupted\n");
  96 #ifdef FLAC_NEW_API
  97                         return E(READ_STATUS_CONTINUE);
  98 #else
  99                         return E(READ_STATUS_OK);
 100 #endif
 101                 }
 102 #ifdef FLAC_NEW_API
 103                 return E(READ_STATUS_ABORT);
 104 #else
 105                 return E(READ_STATUS_ERROR);
 106 #endif
 107         }
 108
 109         priv->pos += rc;
 110         *size = rc;
 111         if (rc == 0) {
 112                 /* never reached! */
 113                 priv->eof = 1;
 114                 d_print("EOF\n");
 115 #ifdef FLAC_NEW_API
 116                 return E(READ_STATUS_END_OF_STREAM);
 117 #else
 118                 return E(READ_STATUS_OK);
 119 #endif
 120         }
 121 #ifdef FLAC_NEW_API
 122         return E(READ_STATUS_CONTINUE);
 123 #else
 124         return E(READ_STATUS_OK);
 125 #endif
 126 }
 127
 128 static T(SeekStatus) seek_cb(const Dec *dec, uint64_t offset, void *data)
 129 {
 130         struct input_plugin_data *ip_data = data;
 131         struct flac_private *priv = ip_data->private;
 132         off_t off;
 133
 134         if (priv->len == UINT64_MAX)
 135                 return E(SEEK_STATUS_ERROR);
 136         off = lseek(ip_data->fd, offset, SEEK_SET);
 137         if (off == -1) {
 138                 return E(SEEK_STATUS_ERROR);
 139         }
 140         priv->pos = off;
 141         return E(SEEK_STATUS_OK);
 142 }
 143
 144 static T(TellStatus) tell_cb(const Dec *dec, uint64_t *offset, void *data)
 145 {
 146         struct input_plugin_data *ip_data = data;
 147         struct flac_private *priv = ip_data->private;
 148
 149         d_print("\n");
 150         *offset = priv->pos;
 151         return E(TELL_STATUS_OK);
 152 }
 153
 154 static T(LengthStatus) length_cb(const Dec *dec, uint64_t *len, void *data)
 155 {
 156         struct input_plugin_data *ip_data = data;
 157         struct flac_private *priv = ip_data->private;
 158
 159         d_print("\n");
 160         if (ip_data->remote) {
 161                 return E(LENGTH_STATUS_ERROR);
 162         }
 163         *len = priv->len;
 164         return E(LENGTH_STATUS_OK);
 165 }
 166
 167 static int eof_cb(const Dec *dec, void *data)
 168 {
 169         struct input_plugin_data *ip_data = data;
 170         struct flac_private *priv = ip_data->private;
 171         int eof = priv->eof;
 172
 173         if (eof)
 174                 d_print("EOF\n");
 175         return eof;
 176 }
 177
 178 #if defined(WORDS_BIGENDIAN)
 179
 180 static inline uint16_t LE16(uint16_t x)
 181 {
 182         return (x >> 8) | (x << 8);
 183 }
 184
 185 static inline uint32_t LE32(uint32_t x)
 186 {
 187         uint32_t x3 = x << 24;
 188         uint32_t x0 = x >> 24;
 189         uint32_t x2 = (x & 0xff00) << 8;
 190         uint32_t x1 = (x >> 8) & 0xff00;
 191         return x3 | x2 | x1 | x0;
 192 }
 193
 194 #else
 195
 196 #define LE16(x) (x)
 197 #define LE32(x) (x)
 198
 199 #endif
 200
 201 static FLAC__StreamDecoderWriteStatus write_cb(const Dec *dec, const FLAC__Frame *frame,
 202                 const int32_t * const *buf, void *data)
 203 {
 204         struct input_plugin_data *ip_data = data;
 205         struct flac_private *priv = ip_data->private;
 206         int frames, bytes, size, channels, bits, depth;
 207         int ch, i, j = 0;
 208
 209         if (ip_data->sf == 0) {
 210                 return FLAC__STREAM_DECODER_WRITE_STATUS_CONTINUE;
 211         }
 212
 213         if (priv->ignore_next_write) {
 214                 priv->ignore_next_write = 0;
 215                 return FLAC__STREAM_DECODER_WRITE_STATUS_CONTINUE;
 216         }
 217
 218         frames = frame->header.blocksize;
 219         channels = sf_get_channels(ip_data->sf);
 220         bits = sf_get_bits(ip_data->sf);
 221         bytes = frames * bits / 8 * channels;
 222         size = priv->buf_size;
 223
 224         if (size - priv->buf_wpos < bytes) {
 225                 if (size < bytes)
 226                         size = bytes;
 227                 size *= 2;
 228                 priv->buf = xrenew(char, priv->buf, size);
 229                 priv->buf_size = size;
 230         }
 231
 232         depth = frame->header.bits_per_sample;
 233         if (depth == 8) {
 234                 char *b = priv->buf + priv->buf_wpos;
 235
 236                 for (i = 0; i < frames; i++) {
 237                         for (ch = 0; ch < channels; ch++)
 238                                 b[j++] = buf[ch][i];
 239                 }
 240         } else if (depth == 16) {
 241                 int16_t *b = (int16_t *)(priv->buf + priv->buf_wpos);
 242
 243                 for (i = 0; i < frames; i++) {
 244                         for (ch = 0; ch < channels; ch++)
 245                                 b[j++] = LE16(buf[ch][i]);
 246                 }
 247         } else if (depth == 32) {
 248                 int32_t *b = (int32_t *)(priv->buf + priv->buf_wpos);
 249
 250                 for (i = 0; i < frames; i++) {
 251                         for (ch = 0; ch < channels; ch++)
 252                                 b[j++] = LE32(buf[ch][i]);
 253                 }
 254         } else if (depth == 12) { /* -> 16 */
 255                 int16_t *b = (int16_t *)(priv->buf + priv->buf_wpos);
 256
 257                 for (i = 0; i < frames; i++) {
 258                         for (ch = 0; ch < channels; ch++)
 259                                 b[j++] = LE16(buf[ch][i] << 4);
 260                 }
 261         } else if (depth == 20) { /* -> 32 */
 262                 int32_t *b = (int32_t *)(priv->buf + priv->buf_wpos);
 263
 264                 for (i = 0; i < frames; i++) {
 265                         for (ch = 0; ch < channels; ch++)
 266                                 b[j++] = LE32(buf[ch][i] << 12);
 267                 }
 268         } else if (depth == 24) { /* -> 32 */
 269                 int32_t *b = (int32_t *)(priv->buf + priv->buf_wpos);
 270
 271                 for (i = 0; i < frames; i++) {
 272                         for (ch = 0; ch < channels; ch++)
 273                                 b[j++] = LE32(buf[ch][i] << 8);
 274                 }
 275         } else {
 276                 d_print("bits per sample changed to %d\n", depth);
 277         }
 278
 279         priv->buf_wpos += bytes;
 280         return FLAC__STREAM_DECODER_WRITE_STATUS_CONTINUE;
 281 }
 282
 283 /* You should make a copy of metadata with FLAC__metadata_object_clone() if you will
 284  * need it elsewhere. Since metadata blocks can potentially be large, by
 285  * default the decoder only calls the metadata callback for the STREAMINFO
 286  * block; you can instruct the decoder to pass or filter other blocks with
 287  * FLAC__stream_decoder_set_metadata_*() calls.
 288  */
 289 static void metadata_cb(const Dec *dec, const FLAC__StreamMetadata *metadata, void *data)
 290 {
 291         struct input_plugin_data *ip_data = data;
 292         struct flac_private *priv = ip_data->private;
 293
 294         switch (metadata->type) {
 295         case FLAC__METADATA_TYPE_STREAMINFO:
 296                 {
 297                         const FLAC__StreamMetadata_StreamInfo *si = &metadata->data.stream_info;
 298                         int bits = 0;
 299
 300                         switch (si->bits_per_sample) {
 301                         case 8:
 302                         case 16:
 303                         case 32:
 304                                 bits = si->bits_per_sample;
 305                                 break;
 306                         case 12:
 307                                 bits = 16;
 308                                 break;
 309                         case 20:
 310                         case 24:
 311                                 bits = 32;
 312                                 break;
 313                         }
 314
 315                         ip_data->sf = sf_rate(si->sample_rate) |
 316                                 sf_bits(bits) |
 317                                 sf_signed(1) |
 318                                 sf_channels(si->channels);
 319                         if (!ip_data->remote && si->total_samples)
 320                                 priv->duration = si->total_samples / si->sample_rate;
 321                 }
 322                 break;
 323         case FLAC__METADATA_TYPE_VORBIS_COMMENT:
 324                 d_print("VORBISCOMMENT\n");
 325                 if (priv->comments) {
 326                         d_print("Ignoring\n");
 327                 } else {
 328                         GROWING_KEYVALS(c);
 329                         int i, nr;
 330
 331                         nr = metadata->data.vorbis_comment.num_comments;
 332                         for (i = 0; i < nr; i++) {
 333                                 const char *str = metadata->data.vorbis_comment.comments[i].entry;
 334                                 char *key, *val;
 335
 336                                 val = strchr(str, '=');
 337                                 if (!val)
 338                                         continue;
 339                                 key = xstrndup(str, val - str);
 340                                 val = xstrdup(val + 1);
 341                                 comments_add(&c, key, val);
 342                                 free(key);
 343                         }
 344                         keyvals_terminate(&c);
 345                         priv->comments = c.keyvals;
 346                 }
 347                 break;
 348         default:
 349                 d_print("something else\n");
 350                 break;
 351         }
 352 }
 353
 354 static void error_cb(const Dec *dec, FLAC__StreamDecoderErrorStatus status, void *data)
 355 {
 356         static const char *strings[3] = {
 357                 "lost sync",
 358                 "bad header",
 359                 "frame crc mismatch"
 360         };
 361         const char *str = "unknown error";
 362
 363         if (status >= 0 && status < 3)
 364                 str = strings[status];
 365         d_print("%d %s\n", status, str);
 366 }
 367
 368 static void free_priv(struct input_plugin_data *ip_data)
 369 {
 370         struct flac_private *priv = ip_data->private;
 371         int save = errno;
 372
 373         F(finish)(priv->dec);
 374         F(delete)(priv->dec);
 375         if (priv->comments)
 376                 keyvals_free(priv->comments);
 377         free(priv->buf);
 378         free(priv);
 379         ip_data->private = NULL;
 380         errno = save;
 381 }
 382
 383 static int flac_open(struct input_plugin_data *ip_data)
 384 {
 385         struct flac_private *priv;
 386         Dec *dec;
 387
 388         dec = F(new)();
 389         if (dec == NULL)
 390                 return -IP_ERROR_INTERNAL;
 391
 392         priv = xnew0(struct flac_private, 1);
 393         priv->dec = dec;
 394         priv->duration = -1;
 395         if (ip_data->remote) {
 396                 priv->len = UINT64_MAX;
 397         } else {
 398                 off_t off = lseek(ip_data->fd, 0, SEEK_END);
 399
 400                 if (off == -1 || lseek(ip_data->fd, 0, SEEK_SET) == -1) {
 401                         int save = errno;
 402
 403                         F(delete)(dec);
 404                         free(priv);
 405                         errno = save;
 406                         return -IP_ERROR_ERRNO;
 407                 }
 408                 priv->len = off;
 409         }
 410         ip_data->private = priv;
 411
 412 #ifndef FLAC_NEW_API
 413         F(set_read_callback)(dec, read_cb);
 414         F(set_seek_callback)(dec, seek_cb);
 415         F(set_tell_callback)(dec, tell_cb);
 416         F(set_length_callback)(dec, length_cb);
 417         F(set_eof_callback)(dec, eof_cb);
 418         F(set_write_callback)(dec, write_cb);
 419         F(set_metadata_callback)(dec, metadata_cb);
 420         F(set_error_callback)(dec, error_cb);
 421         F(set_client_data)(dec, ip_data);
 422 #endif
 423
 424 #ifdef FLAC_NEW_API
 425         FLAC__stream_decoder_set_metadata_respond_all(dec);
 426         if (FLAC__stream_decoder_init_stream(dec, read_cb, seek_cb, tell_cb,
 427                                 length_cb, eof_cb, write_cb, metadata_cb,
 428                                 error_cb, ip_data) != E(INIT_STATUS_OK)) {
 429 #else
 430         /* FLAC__METADATA_TYPE_STREAMINFO already accepted */
 431         F(set_metadata_respond)(dec, FLAC__METADATA_TYPE_VORBIS_COMMENT);
 432
 433         if (F(init)(dec) != E(OK)) {
 434 #endif
 435                 int save = errno;
 436
 437                 d_print("init failed\n");
 438                 F(delete)(priv->dec);
 439                 free(priv);
 440                 ip_data->private = NULL;
 441                 errno = save;
 442                 return -IP_ERROR_ERRNO;
 443         }
 444
 445         ip_data->sf = 0;
 446         while (priv->buf_wpos == 0 && !priv->eof) {
 447                 if (!F(process_single)(priv->dec)) {
 448                         free_priv(ip_data);
 449                         return -IP_ERROR_ERRNO;
 450                 }
 451         }
 452
 453         if (!ip_data->sf) {
 454                 free_priv(ip_data);
 455                 return -IP_ERROR_FILE_FORMAT;
 456         }
 457         if (!sf_get_bits(ip_data->sf)) {
 458                 free_priv(ip_data);
 459                 return -IP_ERROR_SAMPLE_FORMAT;
 460         }
 461
 462         d_print("sr: %d, ch: %d, bits: %d\n",
 463                         sf_get_rate(ip_data->sf),
 464                         sf_get_channels(ip_data->sf),
 465                         sf_get_bits(ip_data->sf));
 466         return 0;
 467 }
 468
 469 static int flac_close(struct input_plugin_data *ip_data)
 470 {
 471         free_priv(ip_data);
 472         return 0;
 473 }
 474
 475 static int flac_read(struct input_plugin_data *ip_data, char *buffer, int count)
 476 {
 477         struct flac_private *priv = ip_data->private;
 478         int avail;
 479         int libflac_suck_count = 0;
 480
 481         while (1) {
 482                 int old_pos = priv->buf_wpos;
 483
 484                 avail = priv->buf_wpos - priv->buf_rpos;
 485                 BUG_ON(avail < 0);
 486                 if (avail > 0)
 487                         break;
 488                 if (priv->eof)
 489                         return 0;
 490                 if (!F(process_single)(priv->dec)) {
 491                         d_print("process_single failed\n");
 492                         return -1;
 493                 }
 494                 if (old_pos == priv->buf_wpos) {
 495                         libflac_suck_count++;
 496                 } else {
 497                         libflac_suck_count = 0;
 498                 }
 499                 if (libflac_suck_count > 5) {
 500                         d_print("libflac sucks\n");
 501                         priv->eof = 1;
 502                         return 0;
 503                 }
 504         }
 505         if (count > avail)
 506                 count = avail;
 507         memcpy(buffer, priv->buf + priv->buf_rpos, count);
 508         priv->buf_rpos += count;
 509         BUG_ON(priv->buf_rpos > priv->buf_wpos);
 510         if (priv->buf_rpos == priv->buf_wpos) {
 511                 priv->buf_rpos = 0;
 512                 priv->buf_wpos = 0;
 513         }
 514         return count;
 515 }
 516
 517 /* Flush the input and seek to an absolute sample. Decoding will resume at the
 518  * given sample. Note that because of this, the next write callback may contain
 519  * a partial block.
 520  */
 521 static int flac_seek(struct input_plugin_data *ip_data, double offset)
 522 {
 523         struct flac_private *priv = ip_data->private;
 524         uint64_t sample;
 525
 526         sample = (uint64_t)(offset * (double)sf_get_rate(ip_data->sf) + 0.5);
 527         if (!F(seek_absolute)(priv->dec, sample)) {
 528                 return -IP_ERROR_ERRNO;
 529         }
 530         priv->ignore_next_write = 1;
 531         priv->buf_rpos = 0;
 532         priv->buf_wpos = 0;
 533         return 0;
 534 }
 535
 536 static int flac_read_comments(struct input_plugin_data *ip_data, struct keyval **comments)
 537 {
 538         struct flac_private *priv = ip_data->private;
 539
 540         if (priv->comments) {
 541                 *comments = keyvals_dup(priv->comments);
 542         } else {
 543                 *comments = xnew0(struct keyval, 1);
 544         }
 545         return 0;
 546 }
 547
 548 static int flac_duration(struct input_plugin_data *ip_data)
 549 {
 550         struct flac_private *priv = ip_data->private;
 551
 552         return priv->duration;
 553 }
 554
 555 const struct input_plugin_ops ip_ops = {
 556         .open = flac_open,
 557         .close = flac_close,
 558         .read = flac_read,
 559         .seek = flac_seek,
 560         .read_comments = flac_read_comments,
 561         .duration = flac_duration
 562 };
 563
 564 const char * const ip_extensions[] = { "flac", "fla", NULL };
 565 const char * const ip_mime_types[] = { NULL };