lavf: Add DSS demuxer

Signed-off-by: Oleksij Rempel <linux@rempel-privat.de>
Signed-off-by: Luca Barbato <lu_zero@gentoo.org>
Signed-off-by: Vittorio Giovara <vittorio.giovara@gmail.com>

Changelog

@@ -15,7 +15,7 @@ version <next>:
 - DXVA2-accelerated HEVC decoding
 - AAC ELD 480 decoding
 - Intel QSV-accelerated H.264 decoding
-- DSS SP decoder
+- DSS SP decoder and DSS demuxer
 
 
 version 11:

doc/general.texi

@@ -221,6 +221,7 @@ library:
     @tab Used in the game Cyberia from Interplay.
 @item Delphine Software International CIN @tab   @tab X
     @tab Multimedia format used by Delphine Software games.
+@item Digital Speech Standard (DSS) @tab   @tab X
 @item CD+G                      @tab   @tab X
     @tab Video format used by CD+G karaoke disks
 @item Commodore CDXL            @tab   @tab X

libavformat/Makefile

@@ -100,6 +100,7 @@ OBJS-$(CONFIG_DIRAC_MUXER)               += rawenc.o
 OBJS-$(CONFIG_DNXHD_DEMUXER)             += dnxhddec.o rawdec.o
 OBJS-$(CONFIG_DNXHD_MUXER)               += rawenc.o
 OBJS-$(CONFIG_DSICIN_DEMUXER)            += dsicin.o
+OBJS-$(CONFIG_DSS_DEMUXER)               += dss.o
 OBJS-$(CONFIG_DTS_DEMUXER)               += dtsdec.o rawdec.o
 OBJS-$(CONFIG_DTS_MUXER)                 += rawenc.o
 OBJS-$(CONFIG_DV_DEMUXER)                += dv.o

libavformat/allformats.c

@@ -94,6 +94,7 @@ void av_register_all(void)
     REGISTER_MUXDEMUX(DIRAC,            dirac);
     REGISTER_MUXDEMUX(DNXHD,            dnxhd);
     REGISTER_DEMUXER (DSICIN,           dsicin);
+    REGISTER_DEMUXER (DSS,              dss);
     REGISTER_MUXDEMUX(DTS,              dts);
     REGISTER_MUXDEMUX(DV,               dv);
     REGISTER_DEMUXER (DXA,              dxa);

libavformat/dss.c

@@ -0,0 +1,342 @@
+/*
+ * Digital Speech Standard (DSS) demuxer
+ * Copyright (c) 2014 Oleksij Rempel <linux@rempel-privat.de>
+ *
+ * This file is part of Libav.
+ *
+ * Libav is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * Libav is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with Libav; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#include "libavutil/attributes.h"
+#include "libavutil/bswap.h"
+#include "libavutil/channel_layout.h"
+#include "libavutil/intreadwrite.h"
+
+#include "avformat.h"
+#include "internal.h"
+
+#define DSS_HEAD_OFFSET_AUTHOR        0xc
+#define DSS_AUTHOR_SIZE               16
+
+#define DSS_HEAD_OFFSET_START_TIME    0x26
+#define DSS_HEAD_OFFSET_END_TIME      0x32
+#define DSS_TIME_SIZE                 12
+
+#define DSS_HEAD_OFFSET_ACODEC        0x2a4
+#define DSS_ACODEC_DSS_SP             0x0    /* SP mode */
+#define DSS_ACODEC_G723_1             0x2    /* LP mode */
+
+#define DSS_HEAD_OFFSET_COMMENT       0x31e
+#define DSS_COMMENT_SIZE              64
+
+#define DSS_BLOCK_SIZE                512
+#define DSS_HEADER_SIZE              (DSS_BLOCK_SIZE * 2)
+#define DSS_AUDIO_BLOCK_HEADER_SIZE   6
+#define DSS_FRAME_SIZE                42
+
+static const uint8_t frame_size[4] = { 24, 20, 4, 1 };
+
+typedef struct DSSDemuxContext {
+    unsigned int audio_codec;
+    int counter;
+    int swap;
+    int dss_sp_swap_byte;
+    int8_t *dss_sp_buf;
+} DSSDemuxContext;
+
+static int dss_probe(AVProbeData *p)
+{
+    if (AV_RL32(p->buf) != MKTAG(0x2, 'd', 's', 's'))
+        return 0;
+
+    return AVPROBE_SCORE_MAX;
+}
+
+static int dss_read_metadata_date(AVFormatContext *s, unsigned int offset,
+                                  const char *key)
+{
+    AVIOContext *pb = s->pb;
+    char datetime[64], string[DSS_TIME_SIZE + 1] = { 0 };
+    int y, month, d, h, minute, sec;
+    int ret;
+
+    avio_seek(pb, offset, SEEK_SET);
+
+    ret = avio_read(s->pb, string, DSS_TIME_SIZE);
+    if (ret < DSS_TIME_SIZE)
+        return ret < 0 ? ret : AVERROR_EOF;
+
+    sscanf(string, "%2d%2d%2d%2d%2d%2d", &y, &month, &d, &h, &minute, &sec);
+    /* We deal with a two-digit year here, so set the default date to 2000
+     * and hope it will never be used in the next century. */
+    snprintf(datetime, sizeof(datetime), "%.4d-%.2d-%.2dT%.2d:%.2d:%.2d",
+             y + 2000, month, d, h, minute, sec);
+    return av_dict_set(&s->metadata, key, datetime, 0);
+}
+
+static int dss_read_metadata_string(AVFormatContext *s, unsigned int offset,
+                                    unsigned int size, const char *key)
+{
+    AVIOContext *pb = s->pb;
+    char *value;
+    int ret;
+
+    avio_seek(pb, offset, SEEK_SET);
+
+    value = av_mallocz(size + 1);
+    if (!value)
+        return AVERROR(ENOMEM);
+
+    ret = avio_read(s->pb, value, size);
+    if (ret < size) {
+        ret = ret < 0 ? ret : AVERROR_EOF;
+        goto exit;
+    }
+
+    ret = av_dict_set(&s->metadata, key, value, 0);
+
+exit:
+    av_free(value);
+    return ret;
+}
+
+static int dss_read_header(AVFormatContext *s)
+{
+    DSSDemuxContext *ctx = s->priv_data;
+    AVIOContext *pb = s->pb;
+    AVStream *st;
+    int ret;
+
+    st = avformat_new_stream(s, NULL);
+    if (!st)
+        return AVERROR(ENOMEM);
+
+    ret = dss_read_metadata_string(s, DSS_HEAD_OFFSET_AUTHOR,
+                                   DSS_AUTHOR_SIZE, "author");
+    if (ret)
+        return ret;
+
+    ret = dss_read_metadata_date(s, DSS_HEAD_OFFSET_END_TIME, "date");
+    if (ret)
+        return ret;
+
+    ret = dss_read_metadata_string(s, DSS_HEAD_OFFSET_COMMENT,
+                                   DSS_COMMENT_SIZE, "comment");
+    if (ret)
+        return ret;
+
+    avio_seek(pb, DSS_HEAD_OFFSET_ACODEC, SEEK_SET);
+    ctx->audio_codec = avio_r8(pb);
+
+    if (ctx->audio_codec == DSS_ACODEC_DSS_SP) {
+        st->codec->codec_id    = AV_CODEC_ID_DSS_SP;
+        st->codec->sample_rate = 12000;
+    } else if (ctx->audio_codec == DSS_ACODEC_G723_1) {
+        st->codec->codec_id    = AV_CODEC_ID_G723_1;
+        st->codec->sample_rate = 8000;
+    } else {
+        avpriv_request_sample(s, "Support for codec %x in DSS",
+                              ctx->audio_codec);
+        return AVERROR_PATCHWELCOME;
+    }
+
+    st->codec->codec_type     = AVMEDIA_TYPE_AUDIO;
+    st->codec->channel_layout = AV_CH_LAYOUT_MONO;
+    st->codec->channels       = 1;
+
+    avpriv_set_pts_info(st, 64, 1, st->codec->sample_rate);
+    st->start_time = 0;
+
+    /* Jump over header */
+
+    if (avio_seek(pb, DSS_HEADER_SIZE, SEEK_SET) != DSS_HEADER_SIZE)
+        return AVERROR(EIO);
+
+    ctx->counter = 0;
+    ctx->swap    = 0;
+
+    ctx->dss_sp_buf = av_malloc(DSS_FRAME_SIZE + 1);
+    if (!ctx->dss_sp_buf)
+        return AVERROR(ENOMEM);
+
+    return 0;
+}
+
+static void dss_skip_audio_header(AVFormatContext *s, AVPacket *pkt)
+{
+    DSSDemuxContext *ctx = s->priv_data;
+    AVIOContext *pb = s->pb;
+
+    avio_skip(pb, DSS_AUDIO_BLOCK_HEADER_SIZE);
+    ctx->counter += DSS_BLOCK_SIZE - DSS_AUDIO_BLOCK_HEADER_SIZE;
+}
+
+static void dss_sp_byte_swap(DSSDemuxContext *ctx,
+                             uint8_t *dst, const uint8_t *src)
+{
+    int i;
+
+    if (ctx->swap) {
+        for (i = 3; i < DSS_FRAME_SIZE; i += 2)
+            dst[i] = src[i];
+
+        for (i = 0; i < DSS_FRAME_SIZE - 2; i += 2)
+            dst[i] = src[i + 4];
+
+        dst[1] = ctx->dss_sp_swap_byte;
+    } else {
+        memcpy(dst, src, DSS_FRAME_SIZE);
+        ctx->dss_sp_swap_byte = src[DSS_FRAME_SIZE - 2];
+    }
+
+    /* make sure byte 40 is always 0 */
+    dst[DSS_FRAME_SIZE - 2] = 0;
+    ctx->swap             ^= 1;
+}
+
+static int dss_sp_read_packet(AVFormatContext *s, AVPacket *pkt)
+{
+    DSSDemuxContext *ctx = s->priv_data;
+    int read_size, ret, offset = 0, buff_offset = 0;
+
+    if (ctx->counter == 0)
+        dss_skip_audio_header(s, pkt);
+
+    pkt->pos = avio_tell(s->pb);
+
+    if (ctx->swap) {
+        read_size   = DSS_FRAME_SIZE - 2;
+        buff_offset = 3;
+    } else
+        read_size = DSS_FRAME_SIZE;
+
+    ctx->counter -= read_size;
+
+    ret = av_new_packet(pkt, DSS_FRAME_SIZE);
+    if (ret < 0)
+        return ret;
+
+    pkt->duration     = 0;
+    pkt->stream_index = 0;
+
+    if (ctx->counter < 0) {
+        int size2 = ctx->counter + read_size;
+
+        ret = avio_read(s->pb, ctx->dss_sp_buf + offset + buff_offset,
+                        size2 - offset);
+        if (ret < size2 - offset)
+            goto error_eof;
+
+        dss_skip_audio_header(s, pkt);
+        offset = size2;
+    }
+
+    ret = avio_read(s->pb, ctx->dss_sp_buf + offset + buff_offset,
+                    read_size - offset);
+    if (ret < read_size - offset)
+        goto error_eof;
+
+    dss_sp_byte_swap(ctx, pkt->data, ctx->dss_sp_buf);
+
+    if (pkt->data[0] == 0xff)
+        return AVERROR_INVALIDDATA;
+
+    return pkt->size;
+
+error_eof:
+    av_free_packet(pkt);
+    return ret < 0 ? ret : AVERROR_EOF;
+}
+
+static int dss_723_1_read_packet(AVFormatContext *s, AVPacket *pkt)
+{
+    DSSDemuxContext *ctx = s->priv_data;
+    int size, byte, ret, offset;
+
+    if (ctx->counter == 0)
+        dss_skip_audio_header(s, pkt);
+
+    pkt->pos = avio_tell(s->pb);
+    /* We make one byte-step here. Don't forget to add offset. */
+    byte = avio_r8(s->pb);
+    if (byte == 0xff)
+        return AVERROR_INVALIDDATA;
+
+    size = frame_size[byte & 3];
+
+    ctx->counter -= size;
+
+    ret = av_new_packet(pkt, size);
+    if (ret < 0)
+        return ret;
+
+    pkt->data[0]  = byte;
+    offset        = 1;
+    pkt->duration = 240;
+
+    pkt->stream_index = 0;
+
+    if (ctx->counter < 0) {
+        int size2 = ctx->counter + size;
+
+        ret = avio_read(s->pb, pkt->data + offset,
+                        size2 - offset);
+        if (ret < size2 - offset) {
+            av_free_packet(pkt);
+            return ret < 0 ? ret : AVERROR_EOF;
+        }
+
+        dss_skip_audio_header(s, pkt);
+        offset = size2;
+    }
+
+    ret = avio_read(s->pb, pkt->data + offset, size - offset);
+    if (ret < size - offset) {
+        av_free_packet(pkt);
+        return ret < 0 ? ret : AVERROR_EOF;
+    }
+
+    return pkt->size;
+}
+
+static int dss_read_packet(AVFormatContext *s, AVPacket *pkt)
+{
+    DSSDemuxContext *ctx = s->priv_data;
+
+    if (ctx->audio_codec == DSS_ACODEC_DSS_SP)
+        return dss_sp_read_packet(s, pkt);
+    else
+        return dss_723_1_read_packet(s, pkt);
+}
+
+static int dss_read_close(AVFormatContext *s)
+{
+    DSSDemuxContext *ctx = s->priv_data;
+
+    av_free(ctx->dss_sp_buf);
+
+    return 0;
+}
+
+AVInputFormat ff_dss_demuxer = {
+    .name           = "dss",
+    .long_name      = NULL_IF_CONFIG_SMALL("Digital Speech Standard (DSS)"),
+    .priv_data_size = sizeof(DSSDemuxContext),
+    .read_probe     = dss_probe,
+    .read_header    = dss_read_header,
+    .read_packet    = dss_read_packet,
+    .read_close     = dss_read_close,
+    .extensions     = "dss"
+};

libavformat/version.h

@@ -30,7 +30,7 @@
 #include "libavutil/version.h"
 
 #define LIBAVFORMAT_VERSION_MAJOR 56
-#define LIBAVFORMAT_VERSION_MINOR 11
+#define LIBAVFORMAT_VERSION_MINOR 12
 #define LIBAVFORMAT_VERSION_MICRO  0
 
 #define LIBAVFORMAT_VERSION_INT AV_VERSION_INT(LIBAVFORMAT_VERSION_MAJOR, \