@@ -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:

@@ -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

@@ -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

@@ -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);

new file mode 100644

@@ -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"

+};

@@ -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, \