FFmpeg
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
dss.c
Go to the documentation of this file.
1 /*
2  * Digital Speech Standard (DSS) demuxer
3  * Copyright (c) 2014 Oleksij Rempel <linux@rempel-privat.de>
4  *
5  * This file is part of FFmpeg.
6  *
7  * FFmpeg is free software; you can redistribute it and/or
8  * modify it under the terms of the GNU Lesser General Public
9  * License as published by the Free Software Foundation; either
10  * version 2.1 of the License, or (at your option) any later version.
11  *
12  * FFmpeg is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15  * Lesser General Public License for more details.
16  *
17  * You should have received a copy of the GNU Lesser General Public
18  * License along with FFmpeg; if not, write to the Free Software
19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20  */
21 
22 #include "libavutil/attributes.h"
23 #include "libavutil/bswap.h"
25 #include "libavutil/intreadwrite.h"
26 
27 #include "avformat.h"
28 #include "internal.h"
29 
30 #define DSS_HEAD_OFFSET_AUTHOR 0xc
31 #define DSS_AUTHOR_SIZE 16
32 
33 #define DSS_HEAD_OFFSET_START_TIME 0x26
34 #define DSS_HEAD_OFFSET_END_TIME 0x32
35 #define DSS_TIME_SIZE 12
36 
37 #define DSS_HEAD_OFFSET_ACODEC 0x2a4
38 #define DSS_ACODEC_DSS_SP 0x0 /* SP mode */
39 #define DSS_ACODEC_G723_1 0x2 /* LP mode */
40 
41 #define DSS_HEAD_OFFSET_COMMENT 0x31e
42 #define DSS_COMMENT_SIZE 64
43 
44 #define DSS_BLOCK_SIZE 512
45 #define DSS_AUDIO_BLOCK_HEADER_SIZE 6
46 #define DSS_FRAME_SIZE 42
47 
48 static const uint8_t frame_size[4] = { 24, 20, 4, 1 };
49 
50 typedef struct DSSDemuxContext {
51  unsigned int audio_codec;
52  int counter;
53  int swap;
55  int8_t *dss_sp_buf;
56 
60 
61 static int dss_probe(AVProbeData *p)
62 {
63  if ( AV_RL32(p->buf) != MKTAG(0x2, 'd', 's', 's')
64  && AV_RL32(p->buf) != MKTAG(0x3, 'd', 's', 's'))
65  return 0;
66 
67  return AVPROBE_SCORE_MAX;
68 }
69 
70 static int dss_read_metadata_date(AVFormatContext *s, unsigned int offset,
71  const char *key)
72 {
73  AVIOContext *pb = s->pb;
74  char datetime[64], string[DSS_TIME_SIZE + 1] = { 0 };
75  int y, month, d, h, minute, sec;
76  int ret;
77 
78  avio_seek(pb, offset, SEEK_SET);
79 
80  ret = avio_read(s->pb, string, DSS_TIME_SIZE);
81  if (ret < DSS_TIME_SIZE)
82  return ret < 0 ? ret : AVERROR_EOF;
83 
84  if (sscanf(string, "%2d%2d%2d%2d%2d%2d", &y, &month, &d, &h, &minute, &sec) != 6)
85  return AVERROR_INVALIDDATA;
86  /* We deal with a two-digit year here, so set the default date to 2000
87  * and hope it will never be used in the next century. */
88  snprintf(datetime, sizeof(datetime), "%.4d-%.2d-%.2dT%.2d:%.2d:%.2d",
89  y + 2000, month, d, h, minute, sec);
90  return av_dict_set(&s->metadata, key, datetime, 0);
91 }
92 
94  unsigned int size, const char *key)
95 {
96  AVIOContext *pb = s->pb;
97  char *value;
98  int ret;
99 
100  avio_seek(pb, offset, SEEK_SET);
101 
102  value = av_mallocz(size + 1);
103  if (!value)
104  return AVERROR(ENOMEM);
105 
106  ret = avio_read(s->pb, value, size);
107  if (ret < size) {
108  ret = ret < 0 ? ret : AVERROR_EOF;
109  goto exit;
110  }
111 
112  ret = av_dict_set(&s->metadata, key, value, 0);
113 
114 exit:
115  av_free(value);
116  return ret;
117 }
118 
120 {
122  AVIOContext *pb = s->pb;
123  AVStream *st;
124  int ret, version;
125 
126  st = avformat_new_stream(s, NULL);
127  if (!st)
128  return AVERROR(ENOMEM);
129 
130  version = avio_r8(pb);
131  ctx->dss_header_size = version * DSS_BLOCK_SIZE;
132 
134  DSS_AUTHOR_SIZE, "author");
135  if (ret)
136  return ret;
137 
139  if (ret)
140  return ret;
141 
143  DSS_COMMENT_SIZE, "comment");
144  if (ret)
145  return ret;
146 
147  avio_seek(pb, DSS_HEAD_OFFSET_ACODEC, SEEK_SET);
148  ctx->audio_codec = avio_r8(pb);
149 
150  if (ctx->audio_codec == DSS_ACODEC_DSS_SP) {
152  st->codecpar->sample_rate = 11025;
153  } else if (ctx->audio_codec == DSS_ACODEC_G723_1) {
155  st->codecpar->sample_rate = 8000;
156  } else {
157  avpriv_request_sample(s, "Support for codec %x in DSS",
158  ctx->audio_codec);
159  return AVERROR_PATCHWELCOME;
160  }
161 
164  st->codecpar->channels = 1;
165 
166  avpriv_set_pts_info(st, 64, 1, st->codecpar->sample_rate);
167  st->start_time = 0;
168 
169  /* Jump over header */
170 
171  if (avio_seek(pb, ctx->dss_header_size, SEEK_SET) != ctx->dss_header_size)
172  return AVERROR(EIO);
173 
174  ctx->counter = 0;
175  ctx->swap = 0;
176 
177  ctx->dss_sp_buf = av_malloc(DSS_FRAME_SIZE + 1);
178  if (!ctx->dss_sp_buf)
179  return AVERROR(ENOMEM);
180 
181  return 0;
182 }
183 
185 {
187  AVIOContext *pb = s->pb;
188 
191 }
192 
194  uint8_t *dst, const uint8_t *src)
195 {
196  int i;
197 
198  if (ctx->swap) {
199  for (i = 3; i < DSS_FRAME_SIZE; i += 2)
200  dst[i] = src[i];
201 
202  for (i = 0; i < DSS_FRAME_SIZE - 2; i += 2)
203  dst[i] = src[i + 4];
204 
205  dst[1] = ctx->dss_sp_swap_byte;
206  } else {
207  memcpy(dst, src, DSS_FRAME_SIZE);
208  ctx->dss_sp_swap_byte = src[DSS_FRAME_SIZE - 2];
209  }
210 
211  /* make sure byte 40 is always 0 */
212  dst[DSS_FRAME_SIZE - 2] = 0;
213  ctx->swap ^= 1;
214 }
215 
217 {
219  AVStream *st = s->streams[0];
220  int read_size, ret, offset = 0, buff_offset = 0;
221  int64_t pos = avio_tell(s->pb);
222 
223  if (ctx->counter == 0)
224  dss_skip_audio_header(s, pkt);
225 
226  if (ctx->swap) {
227  read_size = DSS_FRAME_SIZE - 2;
228  buff_offset = 3;
229  } else
230  read_size = DSS_FRAME_SIZE;
231 
232  ctx->counter -= read_size;
233  ctx->packet_size = DSS_FRAME_SIZE - 1;
234 
235  ret = av_new_packet(pkt, DSS_FRAME_SIZE);
236  if (ret < 0)
237  return ret;
238 
239  pkt->duration = 264;
240  pkt->pos = pos;
241  pkt->stream_index = 0;
242  s->bit_rate = 8LL * ctx->packet_size * st->codecpar->sample_rate * 512 / (506 * pkt->duration);
243 
244  if (ctx->counter < 0) {
245  int size2 = ctx->counter + read_size;
246 
247  ret = avio_read(s->pb, ctx->dss_sp_buf + offset + buff_offset,
248  size2 - offset);
249  if (ret < size2 - offset)
250  goto error_eof;
251 
252  dss_skip_audio_header(s, pkt);
253  offset = size2;
254  }
255 
256  ret = avio_read(s->pb, ctx->dss_sp_buf + offset + buff_offset,
257  read_size - offset);
258  if (ret < read_size - offset)
259  goto error_eof;
260 
261  dss_sp_byte_swap(ctx, pkt->data, ctx->dss_sp_buf);
262 
263  if (ctx->dss_sp_swap_byte < 0) {
264  ret = AVERROR(EAGAIN);
265  goto error_eof;
266  }
267 
268  return pkt->size;
269 
270 error_eof:
271  av_packet_unref(pkt);
272  return ret < 0 ? ret : AVERROR_EOF;
273 }
274 
276 {
278  AVStream *st = s->streams[0];
279  int size, byte, ret, offset;
280  int64_t pos = avio_tell(s->pb);
281 
282  if (ctx->counter == 0)
283  dss_skip_audio_header(s, pkt);
284 
285  /* We make one byte-step here. Don't forget to add offset. */
286  byte = avio_r8(s->pb);
287  if (byte == 0xff)
288  return AVERROR_INVALIDDATA;
289 
290  size = frame_size[byte & 3];
291 
292  ctx->packet_size = size;
293  ctx->counter -= size;
294 
295  ret = av_new_packet(pkt, size);
296  if (ret < 0)
297  return ret;
298  pkt->pos = pos;
299 
300  pkt->data[0] = byte;
301  offset = 1;
302  pkt->duration = 240;
303  s->bit_rate = 8LL * size * st->codecpar->sample_rate * 512 / (506 * pkt->duration);
304 
305  pkt->stream_index = 0;
306 
307  if (ctx->counter < 0) {
308  int size2 = ctx->counter + size;
309 
310  ret = avio_read(s->pb, pkt->data + offset,
311  size2 - offset);
312  if (ret < size2 - offset) {
313  av_packet_unref(pkt);
314  return ret < 0 ? ret : AVERROR_EOF;
315  }
316 
317  dss_skip_audio_header(s, pkt);
318  offset = size2;
319  }
320 
321  ret = avio_read(s->pb, pkt->data + offset, size - offset);
322  if (ret < size - offset) {
323  av_packet_unref(pkt);
324  return ret < 0 ? ret : AVERROR_EOF;
325  }
326 
327  return pkt->size;
328 }
329 
331 {
333 
334  if (ctx->audio_codec == DSS_ACODEC_DSS_SP)
335  return dss_sp_read_packet(s, pkt);
336  else
337  return dss_723_1_read_packet(s, pkt);
338 }
339 
341 {
343 
344  av_freep(&ctx->dss_sp_buf);
345 
346  return 0;
347 }
348 
349 static int dss_read_seek(AVFormatContext *s, int stream_index,
350  int64_t timestamp, int flags)
351 {
353  int64_t ret, seekto;
355  int offset;
356 
357  if (ctx->audio_codec == DSS_ACODEC_DSS_SP)
358  seekto = timestamp / 264 * 41 / 506 * 512;
359  else
360  seekto = timestamp / 240 * ctx->packet_size / 506 * 512;
361 
362  if (seekto < 0)
363  seekto = 0;
364 
365  seekto += ctx->dss_header_size;
366 
367  ret = avio_seek(s->pb, seekto, SEEK_SET);
368  if (ret < 0)
369  return ret;
370 
372  ctx->swap = !!(header[0] & 0x80);
373  offset = 2*header[1] + 2*ctx->swap;
374  if (offset < DSS_AUDIO_BLOCK_HEADER_SIZE)
375  return AVERROR_INVALIDDATA;
376  if (offset == DSS_AUDIO_BLOCK_HEADER_SIZE) {
377  ctx->counter = 0;
379  } else {
380  ctx->counter = DSS_BLOCK_SIZE - offset;
381  offset = avio_skip(s->pb, offset - DSS_AUDIO_BLOCK_HEADER_SIZE);
382  }
383  ctx->dss_sp_swap_byte = -1;
384  return 0;
385 }
386 
387 
389  .name = "dss",
390  .long_name = NULL_IF_CONFIG_SMALL("Digital Speech Standard (DSS)"),
391  .priv_data_size = sizeof(DSSDemuxContext),
397  .extensions = "dss"
398 };
#define NULL
Definition: coverity.c:32
const char * s
Definition: avisynth_c.h:768
Bytestream IO Context.
Definition: avio.h:155
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
int64_t pos
byte position in stream, -1 if unknown
Definition: avcodec.h:1677
void avpriv_set_pts_info(AVStream *s, int pts_wrap_bits, unsigned int pts_num, unsigned int pts_den)
Set the time base and wrapping info for a given stream.
Definition: utils.c:4601
static int read_seek(AVFormatContext *ctx, int stream_index, int64_t timestamp, int flags)
Definition: libcdio.c:153
AVInputFormat ff_dss_demuxer
Definition: dss.c:388
enum AVCodecID codec_id
Specific type of the encoded data (the codec used).
Definition: avcodec.h:4066
int size
Definition: avcodec.h:1658
int64_t avio_seek(AVIOContext *s, int64_t offset, int whence)
fseek() equivalent for AVIOContext.
Definition: aviobuf.c:231
int64_t bit_rate
Total stream bitrate in bit/s, 0 if not available.
Definition: avformat.h:1451
#define DSS_AUDIO_BLOCK_HEADER_SIZE
Definition: dss.c:45
int64_t avio_skip(AVIOContext *s, int64_t offset)
Skip given number of bytes forward.
Definition: aviobuf.c:316
int version
Definition: avisynth_c.h:766
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
Definition: mem.c:222
static void dss_skip_audio_header(AVFormatContext *s, AVPacket *pkt)
Definition: dss.c:184
static AVPacket pkt
#define src
Definition: vp8dsp.c:254
Macro definitions for various function/variable attributes.
Format I/O context.
Definition: avformat.h:1349
#define DSS_HEAD_OFFSET_AUTHOR
Definition: dss.c:30
static int dss_read_seek(AVFormatContext *s, int stream_index, int64_t timestamp, int flags)
Definition: dss.c:349
void void avpriv_request_sample(void *avc, const char *msg,...) av_printf_format(2
Log a generic warning message about a missing feature.
uint8_t
#define av_malloc(s)
static int dss_723_1_read_packet(AVFormatContext *s, AVPacket *pkt)
Definition: dss.c:275
#define DSS_BLOCK_SIZE
Definition: dss.c:44
int64_t duration
Duration of this packet in AVStream->time_base units, 0 if unknown.
Definition: avcodec.h:1675
static int dss_read_close(AVFormatContext *s)
Definition: dss.c:340
AVStream * avformat_new_stream(AVFormatContext *s, const AVCodec *c)
Add a new stream to a media file.
Definition: utils.c:4231
AVStream ** streams
A list of all streams in the file.
Definition: avformat.h:1417
static int dss_read_header(AVFormatContext *s)
Definition: dss.c:119
uint8_t * data
Definition: avcodec.h:1657
static int flags
Definition: log.c:57
#define AVERROR_EOF
End of file.
Definition: error.h:55
static av_cold int read_close(AVFormatContext *ctx)
Definition: libcdio.c:145
int8_t * dss_sp_buf
Definition: dss.c:55
ptrdiff_t size
Definition: opengl_enc.c:101
static av_always_inline int64_t avio_tell(AVIOContext *s)
ftell() equivalent for AVIOContext.
Definition: avio.h:525
static const uint8_t header[24]
Definition: sdr2.c:67
uint64_t channel_layout
Audio only.
Definition: avcodec.h:4168
int avio_read(AVIOContext *s, unsigned char *buf, int size)
Read size bytes from AVIOContext into buf.
Definition: aviobuf.c:616
int av_new_packet(AVPacket *pkt, int size)
Allocate the payload of a packet and initialize its fields with default values.
Definition: avpacket.c:86
AVDictionary * metadata
Metadata that applies to the whole file.
Definition: avformat.h:1567
#define DSS_AUTHOR_SIZE
Definition: dss.c:31
#define AVERROR(e)
Definition: error.h:43
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:179
enum AVMediaType codec_type
General type of the encoded data.
Definition: avcodec.h:4062
static int dss_sp_read_packet(AVFormatContext *s, AVPacket *pkt)
Definition: dss.c:216
static const uint8_t offset[127][2]
Definition: vf_spp.c:92
static int dss_read_packet(AVFormatContext *s, AVPacket *pkt)
Definition: dss.c:330
int counter
Definition: dss.c:52
int avio_r8(AVIOContext *s)
Definition: aviobuf.c:607
unsigned char * buf
Buffer must have AVPROBE_PADDING_SIZE of extra allocated bytes filled with zero.
Definition: avformat.h:463
audio channel layout utility functions
#define DSS_HEAD_OFFSET_END_TIME
Definition: dss.c:34
static int dss_probe(AVProbeData *p)
Definition: dss.c:61
static int read_probe(AVProbeData *pd)
Definition: jvdec.c:55
#define DSS_COMMENT_SIZE
Definition: dss.c:42
GLsizei GLboolean const GLfloat * value
Definition: opengl_enc.c:109
static void dss_sp_byte_swap(DSSDemuxContext *ctx, uint8_t *dst, const uint8_t *src)
Definition: dss.c:193
AVFormatContext * ctx
Definition: movenc.c:48
#define DSS_HEAD_OFFSET_COMMENT
Definition: dss.c:41
static int dss_read_metadata_string(AVFormatContext *s, unsigned int offset, unsigned int size, const char *key)
Definition: dss.c:93
#define DSS_TIME_SIZE
Definition: dss.c:35
static int read_header(FFV1Context *f)
Definition: ffv1dec.c:510
Stream structure.
Definition: avformat.h:889
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
Definition: error.h:62
static int read_packet(void *opaque, uint8_t *buf, int buf_size)
Definition: avio_reading.c:42
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_WL24 unsigned int_TMPL AV_WL16 uint64_t_TMPL AV_WB64 unsigned int_TMPL AV_WB32 unsigned int_TMPL AV_WB24 unsigned int_TMPL AV_WB16 unsigned int_TMPL byte
Definition: bytestream.h:87
AVIOContext * pb
I/O context.
Definition: avformat.h:1391
#define DSS_HEAD_OFFSET_ACODEC
Definition: dss.c:37
void av_packet_unref(AVPacket *pkt)
Wipe the packet.
Definition: avpacket.c:589
int av_dict_set(AVDictionary **pm, const char *key, const char *value, int flags)
Set the given entry in *pm, overwriting an existing entry.
Definition: dict.c:70
byte swapping routines
static const uint8_t frame_size[4]
Definition: dss.c:48
#define snprintf
Definition: snprintf.h:34
int packet_size
Definition: dss.c:57
This structure contains the data a format has to probe a file.
Definition: avformat.h:461
int swap
Definition: dss.c:53
int dss_sp_swap_byte
Definition: dss.c:54
int sample_rate
Audio only.
Definition: avcodec.h:4176
#define AVPROBE_SCORE_MAX
maximum score
Definition: avformat.h:473
Main libavformat public API header.
#define DSS_FRAME_SIZE
Definition: dss.c:46
#define DSS_ACODEC_G723_1
Definition: dss.c:39
int64_t start_time
Decoding: pts of the first frame of the stream in presentation order, in stream time base...
Definition: avformat.h:936
#define DSS_ACODEC_DSS_SP
Definition: dss.c:38
#define av_free(p)
int dss_header_size
Definition: dss.c:58
void * priv_data
Format private data.
Definition: avformat.h:1377
static int dss_read_metadata_date(AVFormatContext *s, unsigned int offset, const char *key)
Definition: dss.c:70
int channels
Audio only.
Definition: avcodec.h:4172
#define av_freep(p)
const char * name
A comma separated list of short names for the format.
Definition: avformat.h:664
unsigned int audio_codec
Definition: dss.c:51
AVCodecParameters * codecpar
Definition: avformat.h:1252
int stream_index
Definition: avcodec.h:1659
#define AV_CH_LAYOUT_MONO
#define MKTAG(a, b, c, d)
Definition: common.h:342
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_RL32
Definition: bytestream.h:87
This structure stores compressed data.
Definition: avcodec.h:1634