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

   1 /*
   2  * Digital Pictures SGA game demuxer
   3  *
   4  * Copyright (C) 2021 Paul B Mahol
   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
  23 #include "libavutil/intreadwrite.h"
  24 #include "libavutil/avassert.h"
  25 #include "libavutil/internal.h"
  26 #include "avformat.h"
  27 #include "internal.h"
  28 #include "avio_internal.h"
  29
  30 #define SEGA_CD_PCM_NUM 12500000
  31 #define SEGA_CD_PCM_DEN 786432
  32
  33 typedef struct SGADemuxContext {
  34     int video_stream_index;
  35     int audio_stream_index;
  36
  37     uint8_t sector[65536 * 2];
  38     int sector_headers;
  39     int sample_rate;
  40     int first_audio_size;
  41     int payload_size;
  42     int packet_type;
  43     int flags;
  44     int idx;
  45     int left;
  46     int64_t pkt_pos;
  47 } SGADemuxContext;
  48
  49 static int sga_probe(const AVProbeData *p)
  50 {
  51     const uint8_t *src = p->buf;
  52     int score = 0, sectors = 1;
  53     int last_left = 0;
  54     int sample_rate = -1;
  55
  56     if (p->buf_size < 2048)
  57         return 0;
  58
  59     for (int i = 0; i + 2 < p->buf_size; i += 2048) {
  60         int header = AV_RB16(src + i);
  61
  62         if ((header > 0x07FE && header < 0x8100) ||
  63             (header > 0x8200 && header < 0xA100) ||
  64             (header > 0xA200 && header < 0xC100)) {
  65             sectors = 0;
  66             break;
  67         }
  68     }
  69
  70     for (int i = 0; i + 4 < p->buf_size;) {
  71         int header = AV_RB16(src + i);
  72         int left   = AV_RB16(src + i + 2);
  73         int offset, type, size;
  74
  75         if (last_left < 0)
  76             return 0;
  77         if (sectors && header && last_left == 0) {
  78             if (header >> 12) {
  79                 last_left = left;
  80             } else {
  81                 last_left = left = header;
  82             }
  83         } else if (sectors && header) {
  84             left = header;
  85             last_left -= left;
  86             if (header != 0x7FE && left < 7)
  87                 return 0;
  88         } else if (sectors) {
  89             if (left <= 8)
  90                 return 0;
  91             i += sectors ? 2048 : left + 4;
  92             last_left = 0;
  93             continue;
  94         }
  95
  96         if (sectors && (i > 0 && left < 0x7fe) &&
  97             (i + left + 14 < p->buf_size)) {
  98             offset = i + left + 2;
  99         } else if (sectors && i > 0) {
 100             i += 2048;
 101             last_left -= FFMIN(last_left, 2046);
 102             continue;
 103         } else {
 104             offset = 0;
 105             last_left = left;
 106         }
 107
 108         header = AV_RB16(src + offset);
 109         size   = AV_RB16(src + offset + 2) + 4;
 110
 111         while ((header & 0xFF00) == 0) {
 112             offset++;
 113             if (offset + 4 >= p->buf_size)
 114                 break;
 115             header = AV_RB16(src + offset);
 116             size   = AV_RB16(src + offset + 2) + 4;
 117         }
 118
 119         if (offset + 12 >= p->buf_size)
 120             break;
 121         if ((header & 0xFF) > 1)
 122             return 0;
 123         type = header >> 8;
 124
 125         if (type == 0xAA ||
 126             type == 0xA1 ||
 127             type == 0xA2 ||
 128             type == 0xA3) {
 129             int new_rate;
 130
 131             if (size <= 12)
 132                 return 0;
 133             new_rate = AV_RB16(src + offset + 8);
 134             if (sample_rate < 0)
 135                 sample_rate = new_rate;
 136             if (sample_rate == 0 || new_rate != sample_rate)
 137                 return 0;
 138             if (src[offset + 10] != 1)
 139                 return 0;
 140
 141             score += 10;
 142         } else if (type == 0xC1 ||
 143                    type == 0xC6 ||
 144                    type == 0xC7 ||
 145                    type == 0xC8 ||
 146                    type == 0xC9 ||
 147                    type == 0xCB ||
 148                    type == 0xCD ||
 149                    type == 0xE7) {
 150             int nb_pals = src[offset + 9];
 151             int tiles_w = src[offset + 10];
 152             int tiles_h = src[offset + 11];
 153
 154             if (size <= 12)
 155                 return 0;
 156             if (nb_pals == 0 || nb_pals > 4)
 157                 return 0;
 158             if (tiles_w == 0 || tiles_w > 80)
 159                 return 0;
 160             if (tiles_h == 0 || tiles_h > 60)
 161                 return 0;
 162
 163             score += 10;
 164         } else if (header == 0x7FE) {
 165             ;
 166         } else {
 167             return 0;
 168         }
 169
 170         i += sectors ? 2048 : size + 4;
 171         last_left -= FFMIN(last_left, 2046);
 172
 173         if (score < 0)
 174             break;
 175     }
 176
 177     return av_clip(score, 0, AVPROBE_SCORE_MAX);
 178 }
 179
 180 static int sga_read_header(AVFormatContext *s)
 181 {
 182     SGADemuxContext *sga = s->priv_data;
 183     AVIOContext *pb = s->pb;
 184
 185     sga->sector_headers = 1;
 186     sga->first_audio_size = 0;
 187     sga->video_stream_index = -1;
 188     sga->audio_stream_index = -1;
 189     sga->left = 2048;
 190     sga->idx = 0;
 191
 192     s->ctx_flags |= AVFMTCTX_NOHEADER;
 193
 194     if (pb->seekable & AVIO_SEEKABLE_NORMAL) {
 195         while (!avio_feof(pb)) {
 196             int header = avio_rb16(pb);
 197             int type = header >> 8;
 198             int skip = 2046;
 199             int clock;
 200
 201             if (!sga->first_audio_size &&
 202                 (type == 0xAA ||
 203                  type == 0xA1 ||
 204                  type == 0xA2 ||
 205                  type == 0xA3)) {
 206                 sga->first_audio_size = avio_rb16(pb);
 207                 avio_skip(pb, 4);
 208                 clock = avio_rb16(pb);
 209                 sga->sample_rate = av_rescale(clock,
 210                                               SEGA_CD_PCM_NUM,
 211                                               SEGA_CD_PCM_DEN);
 212                 skip -= 8;
 213             }
 214             if ((header > 0x07FE && header < 0x8100) ||
 215                 (header > 0x8200 && header < 0xA100) ||
 216                 (header > 0xA200 && header < 0xC100)) {
 217                 sga->sector_headers = 0;
 218                 break;
 219             }
 220
 221             avio_skip(pb, skip);
 222         }
 223
 224         avio_seek(pb, 0, SEEK_SET);
 225     }
 226
 227     return 0;
 228 }
 229
 230 static void print_stats(AVFormatContext *s, const char *where)
 231 {
 232     SGADemuxContext *sga = s->priv_data;
 233
 234     av_log(s, AV_LOG_DEBUG, "START %s\n", where);
 235     av_log(s, AV_LOG_DEBUG, "pos: %"PRIX64"\n", avio_tell(s->pb));
 236     av_log(s, AV_LOG_DEBUG, "idx: %X\n", sga->idx);
 237     av_log(s, AV_LOG_DEBUG, "packet_type: %X\n", sga->packet_type);
 238     av_log(s, AV_LOG_DEBUG, "payload_size: %X\n", sga->payload_size);
 239     av_log(s, AV_LOG_DEBUG, "SECTOR: %016"PRIX64"\n", AV_RB64(sga->sector));
 240     av_log(s, AV_LOG_DEBUG, "stream: %X\n", sga->sector[1]);
 241     av_log(s, AV_LOG_DEBUG, "END %s\n", where);
 242 }
 243
 244 static void update_type_size(AVFormatContext *s)
 245 {
 246     SGADemuxContext *sga = s->priv_data;
 247
 248     if (sga->idx >= 4) {
 249         sga->packet_type  = sga->sector[0];
 250         sga->payload_size = AV_RB16(sga->sector + 2);
 251     } else {
 252         sga->packet_type  = 0;
 253         sga->payload_size = 0;
 254     }
 255 }
 256
 257 static int sga_video_packet(AVFormatContext *s, AVPacket *pkt)
 258 {
 259     SGADemuxContext *sga = s->priv_data;
 260     int ret;
 261
 262     if (sga->payload_size <= 8)
 263         return AVERROR_INVALIDDATA;
 264
 265     if (sga->video_stream_index == -1) {
 266         AVRational frame_rate;
 267
 268         AVStream *st = avformat_new_stream(s, NULL);
 269         if (!st)
 270             return AVERROR(ENOMEM);
 271
 272         st->start_time              = 0;
 273         st->codecpar->codec_type    = AVMEDIA_TYPE_VIDEO;
 274         st->codecpar->codec_tag     = 0;
 275         st->codecpar->codec_id      = AV_CODEC_ID_SGA_VIDEO;
 276         sga->video_stream_index     = st->index;
 277
 278         if (sga->first_audio_size > 0 && sga->sample_rate > 0) {
 279             frame_rate.num = sga->sample_rate;
 280             frame_rate.den = sga->first_audio_size;
 281         } else {
 282             frame_rate.num = 15;
 283             frame_rate.den = 1;
 284         }
 285         avpriv_set_pts_info(st, 64, frame_rate.den, frame_rate.num);
 286     }
 287
 288     ret = av_new_packet(pkt, sga->payload_size + 4);
 289     if (ret < 0)
 290         return AVERROR(ENOMEM);
 291     memcpy(pkt->data, sga->sector, sga->payload_size + 4);
 292     av_assert0(sga->idx >= sga->payload_size + 4);
 293     memmove(sga->sector, sga->sector + sga->payload_size + 4, sga->idx - sga->payload_size - 4);
 294
 295     pkt->stream_index = sga->video_stream_index;
 296     pkt->duration = 1;
 297     pkt->pos = sga->pkt_pos;
 298     pkt->flags |= sga->flags;
 299     sga->idx -= sga->payload_size + 4;
 300     sga->flags = 0;
 301     update_type_size(s);
 302
 303     av_log(s, AV_LOG_DEBUG, "VIDEO PACKET: %d:%016"PRIX64" i:%X\n", pkt->size, AV_RB64(sga->sector), sga->idx);
 304
 305     return 0;
 306 }
 307
 308 static int sga_audio_packet(AVFormatContext *s, AVPacket *pkt)
 309 {
 310     SGADemuxContext *sga = s->priv_data;
 311     int ret;
 312
 313     if (sga->payload_size <= 8)
 314         return AVERROR_INVALIDDATA;
 315
 316     if (sga->audio_stream_index == -1) {
 317         AVStream *st = avformat_new_stream(s, NULL);
 318         if (!st)
 319             return AVERROR(ENOMEM);
 320
 321         st->start_time              = 0;
 322         st->codecpar->codec_type    = AVMEDIA_TYPE_AUDIO;
 323         st->codecpar->codec_tag     = 0;
 324         st->codecpar->codec_id      = AV_CODEC_ID_PCM_SGA;
 325         st->codecpar->channels      = 1;
 326         st->codecpar->channel_layout= AV_CH_LAYOUT_MONO;
 327         st->codecpar->sample_rate   = av_rescale(AV_RB16(sga->sector + 8),
 328                                                  SEGA_CD_PCM_NUM,
 329                                                  SEGA_CD_PCM_DEN);
 330         sga->audio_stream_index     = st->index;
 331
 332         avpriv_set_pts_info(st, 64, 1, st->codecpar->sample_rate);
 333     }
 334
 335     ret = av_new_packet(pkt, sga->payload_size - 8);
 336     if (ret < 0)
 337         return AVERROR(ENOMEM);
 338     memcpy(pkt->data, sga->sector + 12, sga->payload_size - 8);
 339     av_assert0(sga->idx >= sga->payload_size + 4);
 340     memmove(sga->sector, sga->sector + sga->payload_size + 4, sga->idx - sga->payload_size - 4);
 341
 342     pkt->stream_index = sga->audio_stream_index;
 343     pkt->duration = pkt->size;
 344     pkt->pos = sga->pkt_pos;
 345     pkt->flags |= sga->flags;
 346     sga->idx -= sga->payload_size + 4;
 347     sga->flags = 0;
 348     update_type_size(s);
 349
 350     av_log(s, AV_LOG_DEBUG, "AUDIO PACKET: %d:%016"PRIX64" i:%X\n", pkt->size, AV_RB64(sga->sector), sga->idx);
 351
 352     return 0;
 353 }
 354
 355 static int sga_packet(AVFormatContext *s, AVPacket *pkt)
 356 {
 357     SGADemuxContext *sga = s->priv_data;
 358     int ret = 0;
 359
 360     if (sga->packet_type == 0xCD ||
 361         sga->packet_type == 0xCB ||
 362         sga->packet_type == 0xC9 ||
 363         sga->packet_type == 0xC8 ||
 364         sga->packet_type == 0xC7 ||
 365         sga->packet_type == 0xC6 ||
 366         sga->packet_type == 0xC1 ||
 367         sga->packet_type == 0xE7) {
 368         ret = sga_video_packet(s, pkt);
 369     } else if (sga->packet_type == 0xA1 ||
 370                sga->packet_type == 0xA2 ||
 371                sga->packet_type == 0xA3 ||
 372                sga->packet_type == 0xAA) {
 373         ret = sga_audio_packet(s, pkt);
 374     } else {
 375         if (sga->idx == 0)
 376             return AVERROR_EOF;
 377         if (sga->sector[0])
 378             return AVERROR_INVALIDDATA;
 379         memmove(sga->sector, sga->sector + 1, sga->idx - 1);
 380         sga->idx--;
 381         return AVERROR(EAGAIN);
 382     }
 383
 384     return ret;
 385 }
 386
 387 static int try_packet(AVFormatContext *s, AVPacket *pkt)
 388 {
 389     SGADemuxContext *sga = s->priv_data;
 390     int ret = AVERROR(EAGAIN);
 391
 392     update_type_size(s);
 393     if (sga->idx >= sga->payload_size + 4) {
 394         print_stats(s, "before sga_packet");
 395         ret = sga_packet(s, pkt);
 396         print_stats(s,  "after sga_packet");
 397         if (ret != AVERROR(EAGAIN))
 398             return ret;
 399     }
 400
 401     return sga->idx < sga->payload_size + 4 ? AVERROR(EAGAIN) : ret;
 402 }
 403
 404 static int sga_read_packet(AVFormatContext *s, AVPacket *pkt)
 405 {
 406     SGADemuxContext *sga = s->priv_data;
 407     AVIOContext *pb = s->pb;
 408     int header, ret = 0;
 409
 410     sga->pkt_pos = avio_tell(pb);
 411
 412 retry:
 413     update_type_size(s);
 414
 415     print_stats(s, "start");
 416     if (avio_feof(pb) &&
 417         (!sga->payload_size || sga->idx < sga->payload_size + 4))
 418         return AVERROR_EOF;
 419
 420     if (sga->idx < sga->payload_size + 4) {
 421         ret = ffio_ensure_seekback(pb, 2);
 422         if (ret < 0)
 423             return ret;
 424
 425         print_stats(s, "before read header");
 426         header = avio_rb16(pb);
 427         if (!header) {
 428             avio_skip(pb, 2046);
 429             sga->left = 0;
 430         } else if (!avio_feof(pb) &&
 431                    ((header >> 15) ||
 432                     !sga->sector_headers)) {
 433             avio_seek(pb, -2, SEEK_CUR);
 434             sga->flags = AV_PKT_FLAG_KEY;
 435             sga->left = 2048;
 436         } else {
 437             sga->left = 2046;
 438         }
 439
 440         av_assert0(sga->idx + sga->left < sizeof(sga->sector));
 441         ret = avio_read(pb, sga->sector + sga->idx, sga->left);
 442         if (ret > 0)
 443             sga->idx += ret;
 444         else if (ret != AVERROR_EOF && ret)
 445             return ret;
 446         print_stats(s, "after read header");
 447
 448         update_type_size(s);
 449     }
 450
 451     ret = try_packet(s, pkt);
 452     if (ret == AVERROR(EAGAIN))
 453         goto retry;
 454
 455     return ret;
 456 }
 457
 458 static int sga_seek(AVFormatContext *s, int stream_index,
 459                      int64_t timestamp, int flags)
 460 {
 461     SGADemuxContext *sga = s->priv_data;
 462
 463     sga->packet_type = sga->payload_size = sga->idx = 0;
 464     memset(sga->sector, 0, sizeof(sga->sector));
 465
 466     return -1;
 467 }
 468
 469 AVInputFormat ff_sga_demuxer = {
 470     .name           = "sga",
 471     .long_name      = NULL_IF_CONFIG_SMALL("Digital Pictures SGA"),
 472     .priv_data_size = sizeof(SGADemuxContext),
 473     .read_probe     = sga_probe,
 474     .read_header    = sga_read_header,
 475     .read_packet    = sga_read_packet,
 476     .read_seek      = sga_seek,
 477     .extensions     = "sga",
 478     .flags          = AVFMT_GENERIC_INDEX,
 479 };