git.sesse.net Git - ffmpeg/blob - libavformat/pp_bnk.c

   1 /*
   2  * Pro Pinball Series Soundbank (44c, 22c, 11c, 5c) demuxer.
   3  *
   4  * Copyright (C) 2020 Zane van Iperen (zane@zanevaniperen.com)
   5  *
   6  * This file is part of FFmpeg.
   7  *
   8  * FFmpeg is free software; you can redistribute it and/or
   9  * modify it under the terms of the GNU Lesser General Public
  10  * License as published by the Free Software Foundation; either
  11  * version 2.1 of the License, or (at your option) any later version.
  12  *
  13  * FFmpeg 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  * Lesser General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU Lesser General Public
  19  * License along with FFmpeg; if not, write to the Free Software
  20  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  21  */
  22 #include "avformat.h"
  23 #include "internal.h"
  24 #include "libavutil/intreadwrite.h"
  25 #include "libavutil/avassert.h"
  26 #include "libavutil/internal.h"
  27
  28 #define PP_BNK_MAX_READ_SIZE    4096
  29 #define PP_BNK_FILE_HEADER_SIZE 20
  30 #define PP_BNK_TRACK_SIZE       20
  31
  32 typedef struct PPBnkHeader {
  33     uint32_t        bank_id;        /*< Bank ID, useless for our purposes. */
  34     uint32_t        sample_rate;    /*< Sample rate of the contained tracks. */
  35     uint32_t        always1;        /*< Unknown, always seems to be 1. */
  36     uint32_t        track_count;    /*< Number of tracks in the file. */
  37     uint32_t        flags;          /*< Flags. */
  38 } PPBnkHeader;
  39
  40 typedef struct PPBnkTrack {
  41     uint32_t        id;             /*< Track ID. Usually track[i].id == track[i-1].id + 1, but not always */
  42     uint32_t        size;           /*< Size of the data in bytes. */
  43     uint32_t        sample_rate;    /*< Sample rate. */
  44     uint32_t        always1_1;      /*< Unknown, always seems to be 1. */
  45     uint32_t        always1_2;      /*< Unknown, always seems to be 1. */
  46 } PPBnkTrack;
  47
  48 typedef struct PPBnkCtxTrack {
  49     int64_t         data_offset;
  50     uint32_t        data_size;
  51     uint32_t        bytes_read;
  52 } PPBnkCtxTrack;
  53
  54 typedef struct PPBnkCtx {
  55     int             track_count;
  56     PPBnkCtxTrack   *tracks;
  57     uint32_t        current_track;
  58     int             is_music;
  59 } PPBnkCtx;
  60
  61 enum {
  62     PP_BNK_FLAG_PERSIST = (1 << 0), /*< This is a large file, keep in memory. */
  63     PP_BNK_FLAG_MUSIC   = (1 << 1), /*< This is music. */
  64     PP_BNK_FLAG_MASK    = (PP_BNK_FLAG_PERSIST | PP_BNK_FLAG_MUSIC)
  65 };
  66
  67 static void pp_bnk_parse_header(PPBnkHeader *hdr, const uint8_t *buf)
  68 {
  69     hdr->bank_id        = AV_RL32(buf +  0);
  70     hdr->sample_rate    = AV_RL32(buf +  4);
  71     hdr->always1        = AV_RL32(buf +  8);
  72     hdr->track_count    = AV_RL32(buf + 12);
  73     hdr->flags          = AV_RL32(buf + 16);
  74 }
  75
  76 static void pp_bnk_parse_track(PPBnkTrack *trk, const uint8_t *buf)
  77 {
  78     trk->id             = AV_RL32(buf +  0);
  79     trk->size           = AV_RL32(buf +  4);
  80     trk->sample_rate    = AV_RL32(buf +  8);
  81     trk->always1_1      = AV_RL32(buf + 12);
  82     trk->always1_2      = AV_RL32(buf + 16);
  83 }
  84
  85 static int pp_bnk_probe(const AVProbeData *p)
  86 {
  87     uint32_t sample_rate = AV_RL32(p->buf +  4);
  88     uint32_t track_count = AV_RL32(p->buf + 12);
  89     uint32_t flags       = AV_RL32(p->buf + 16);
  90
  91     if (track_count == 0 || track_count > INT_MAX)
  92         return 0;
  93
  94     if ((sample_rate !=  5512) && (sample_rate != 11025) &&
  95         (sample_rate != 22050) && (sample_rate != 44100))
  96         return 0;
  97
  98     /* Check the first track header. */
  99     if (AV_RL32(p->buf + 28) != sample_rate)
 100         return 0;
 101
 102     if ((flags & ~PP_BNK_FLAG_MASK) != 0)
 103         return 0;
 104
 105     return AVPROBE_SCORE_MAX / 4 + 1;
 106 }
 107
 108 static int pp_bnk_read_header(AVFormatContext *s)
 109 {
 110     int64_t ret;
 111     AVStream *st;
 112     AVCodecParameters *par;
 113     PPBnkCtx *ctx = s->priv_data;
 114     uint8_t buf[FFMAX(PP_BNK_FILE_HEADER_SIZE, PP_BNK_TRACK_SIZE)];
 115     PPBnkHeader hdr;
 116
 117     if ((ret = avio_read(s->pb, buf, PP_BNK_FILE_HEADER_SIZE)) < 0)
 118         return ret;
 119     else if (ret != PP_BNK_FILE_HEADER_SIZE)
 120         return AVERROR(EIO);
 121
 122     pp_bnk_parse_header(&hdr, buf);
 123
 124     if (hdr.track_count == 0 || hdr.track_count > INT_MAX)
 125         return AVERROR_INVALIDDATA;
 126
 127     if (hdr.sample_rate == 0 || hdr.sample_rate > INT_MAX)
 128         return AVERROR_INVALIDDATA;
 129
 130     if (hdr.always1 != 1) {
 131         avpriv_request_sample(s, "Non-one header value");
 132         return AVERROR_PATCHWELCOME;
 133     }
 134
 135     ctx->track_count = hdr.track_count;
 136
 137     if (!(ctx->tracks = av_malloc_array(hdr.track_count, sizeof(PPBnkCtxTrack))))
 138         return AVERROR(ENOMEM);
 139
 140     /* Parse and validate each track. */
 141     for (int i = 0; i < hdr.track_count; i++) {
 142         PPBnkTrack e;
 143         PPBnkCtxTrack *trk = ctx->tracks + i;
 144
 145         ret = avio_read(s->pb, buf, PP_BNK_TRACK_SIZE);
 146         if (ret < 0 && ret != AVERROR_EOF)
 147             goto fail;
 148
 149         /* Short byte-count or EOF, we have a truncated file. */
 150         if (ret != PP_BNK_TRACK_SIZE) {
 151             av_log(s, AV_LOG_WARNING, "File truncated at %d/%u track(s)\n",
 152                    i, hdr.track_count);
 153             ctx->track_count = i;
 154             break;
 155         }
 156
 157         pp_bnk_parse_track(&e, buf);
 158
 159         /* The individual sample rates of all tracks must match that of the file header. */
 160         if (e.sample_rate != hdr.sample_rate) {
 161             ret = AVERROR_INVALIDDATA;
 162             goto fail;
 163         }
 164
 165         if (e.always1_1 != 1 || e.always1_2 != 1) {
 166             avpriv_request_sample(s, "Non-one track header values");
 167             ret = AVERROR_PATCHWELCOME;
 168             goto fail;
 169         }
 170
 171         trk->data_offset = avio_tell(s->pb);
 172         trk->data_size   = e.size;
 173         trk->bytes_read  = 0;
 174
 175         /*
 176          * Skip over the data to the next stream header.
 177          * Sometimes avio_skip() doesn't detect EOF. If it doesn't, either:
 178          *   - the avio_read() above will, or
 179          *   - pp_bnk_read_packet() will read a truncated last track.
 180          */
 181         if ((ret = avio_skip(s->pb, e.size)) == AVERROR_EOF) {
 182             ctx->track_count = i + 1;
 183             av_log(s, AV_LOG_WARNING,
 184                    "Track %d has truncated data, assuming track count == %d\n",
 185                    i, ctx->track_count);
 186             break;
 187         } else if (ret < 0) {
 188             goto fail;
 189         }
 190     }
 191
 192     /* File is only a header. */
 193     if (ctx->track_count == 0) {
 194         ret = AVERROR_INVALIDDATA;
 195         goto fail;
 196     }
 197
 198     ctx->is_music = (hdr.flags & PP_BNK_FLAG_MUSIC) &&
 199                     (ctx->track_count == 2) &&
 200                     (ctx->tracks[0].data_size == ctx->tracks[1].data_size);
 201
 202     /* Build the streams. */
 203     for (int i = 0; i < (ctx->is_music ? 1 : ctx->track_count); i++) {
 204         if (!(st = avformat_new_stream(s, NULL))) {
 205             ret = AVERROR(ENOMEM);
 206             goto fail;
 207         }
 208
 209         par                         = st->codecpar;
 210         par->codec_type             = AVMEDIA_TYPE_AUDIO;
 211         par->codec_id               = AV_CODEC_ID_ADPCM_IMA_CUNNING;
 212         par->format                 = AV_SAMPLE_FMT_S16P;
 213
 214         if (ctx->is_music) {
 215             par->channel_layout     = AV_CH_LAYOUT_STEREO;
 216             par->channels           = 2;
 217         } else {
 218             par->channel_layout     = AV_CH_LAYOUT_MONO;
 219             par->channels           = 1;
 220         }
 221
 222         par->sample_rate            = hdr.sample_rate;
 223         par->bits_per_coded_sample  = 4;
 224         par->bits_per_raw_sample    = 16;
 225         par->block_align            = 1;
 226         par->bit_rate               = par->sample_rate * par->bits_per_coded_sample * par->channels;
 227
 228         avpriv_set_pts_info(st, 64, 1, par->sample_rate);
 229         st->start_time              = 0;
 230         st->duration                = ctx->tracks[i].data_size * 2;
 231     }
 232
 233     return 0;
 234
 235 fail:
 236     av_freep(&ctx->tracks);
 237     return ret;
 238 }
 239
 240 static int pp_bnk_read_packet(AVFormatContext *s, AVPacket *pkt)
 241 {
 242     PPBnkCtx *ctx = s->priv_data;
 243
 244     /*
 245      * Read a packet from each track, round-robin style.
 246      * This method is nasty, but needed to avoid "Too many packets buffered" errors.
 247      */
 248     for (int i = 0; i < ctx->track_count; i++, ctx->current_track++)
 249     {
 250         int64_t ret;
 251         int size;
 252         PPBnkCtxTrack *trk;
 253
 254         ctx->current_track %= ctx->track_count;
 255
 256         trk = ctx->tracks + ctx->current_track;
 257
 258         if (trk->bytes_read == trk->data_size)
 259             continue;
 260
 261         if ((ret = avio_seek(s->pb, trk->data_offset + trk->bytes_read, SEEK_SET)) < 0)
 262             return ret;
 263         else if (ret != trk->data_offset + trk->bytes_read)
 264             return AVERROR(EIO);
 265
 266         size = FFMIN(trk->data_size - trk->bytes_read, PP_BNK_MAX_READ_SIZE);
 267
 268         if (!ctx->is_music) {
 269             ret = av_get_packet(s->pb, pkt, size);
 270             if (ret == AVERROR_EOF) {
 271                 /* If we've hit EOF, don't attempt this track again. */
 272                 trk->data_size = trk->bytes_read;
 273                 continue;
 274             }
 275         } else {
 276             if (!pkt->data && (ret = av_new_packet(pkt, size * 2)) < 0)
 277                 return ret;
 278             ret = avio_read(s->pb, pkt->data + size * ctx->current_track, size);
 279             if (ret >= 0 && ret != size) {
 280                 /* Only return stereo packets if both tracks could be read. */
 281                 ret = AVERROR_EOF;
 282             }
 283         }
 284         if (ret < 0)
 285             return ret;
 286
 287         trk->bytes_read    += ret;
 288         pkt->flags         &= ~AV_PKT_FLAG_CORRUPT;
 289         pkt->stream_index   = ctx->current_track;
 290         pkt->duration       = ret * 2;
 291
 292         if (ctx->is_music) {
 293             if (pkt->stream_index == 0)
 294                 continue;
 295
 296             pkt->stream_index = 0;
 297         }
 298
 299         ctx->current_track++;
 300         return 0;
 301     }
 302
 303     /* If we reach here, we're done. */
 304     return AVERROR_EOF;
 305 }
 306
 307 static int pp_bnk_read_close(AVFormatContext *s)
 308 {
 309     PPBnkCtx *ctx = s->priv_data;
 310
 311     av_freep(&ctx->tracks);
 312
 313     return 0;
 314 }
 315
 316 static int pp_bnk_seek(AVFormatContext *s, int stream_index,
 317                        int64_t pts, int flags)
 318 {
 319     PPBnkCtx *ctx = s->priv_data;
 320
 321     if (pts != 0)
 322         return AVERROR(EINVAL);
 323
 324     if (ctx->is_music) {
 325         av_assert0(stream_index == 0);
 326         ctx->tracks[0].bytes_read = 0;
 327         ctx->tracks[1].bytes_read = 0;
 328     } else {
 329         ctx->tracks[stream_index].bytes_read = 0;
 330     }
 331
 332     return 0;
 333 }
 334
 335 AVInputFormat ff_pp_bnk_demuxer = {
 336     .name           = "pp_bnk",
 337     .long_name      = NULL_IF_CONFIG_SMALL("Pro Pinball Series Soundbank"),
 338     .priv_data_size = sizeof(PPBnkCtx),
 339     .read_probe     = pp_bnk_probe,
 340     .read_header    = pp_bnk_read_header,
 341     .read_packet    = pp_bnk_read_packet,
 342     .read_close     = pp_bnk_read_close,
 343     .read_seek      = pp_bnk_seek,
 344 };