FFmpeg  4.4.5
bintext.c
Go to the documentation of this file.
1 /*
2  * Binary text demuxer
3  * eXtended BINary text (XBIN) demuxer
4  * Artworx Data Format demuxer
5  * iCEDraw File demuxer
6  * Copyright (c) 2010 Peter Ross <pross@xvid.org>
7  *
8  * This file is part of FFmpeg.
9  *
10  * FFmpeg is free software; you can redistribute it and/or
11  * modify it under the terms of the GNU Lesser General Public
12  * License as published by the Free Software Foundation; either
13  * version 2.1 of the License, or (at your option) any later version.
14  *
15  * FFmpeg is distributed in the hope that it will be useful,
16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
18  * Lesser General Public License for more details.
19  *
20  * You should have received a copy of the GNU Lesser General Public
21  * License along with FFmpeg; if not, write to the Free Software
22  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
23  */
24 
25 /**
26  * @file
27  * Binary text demuxer
28  * eXtended BINary text (XBIN) demuxer
29  * Artworx Data Format demuxer
30  * iCEDraw File demuxer
31  */
32 
33 #include "libavutil/intreadwrite.h"
34 #include "libavutil/opt.h"
35 #include "libavutil/parseutils.h"
36 #include "avformat.h"
37 #include "internal.h"
38 #include "sauce.h"
39 #include "libavcodec/bintext.h"
40 
41 typedef struct {
42  const AVClass *class;
43  int chars_per_frame; /**< characters to send decoder per frame;
44  set by private options as characters per second, and then
45  converted to characters per frame at runtime */
46  int width, height; /**< video size (WxH pixels) (private option) */
47  AVRational framerate; /**< frames per second (private option) */
48  uint64_t fsize; /**< file size less metadata buffer */
50 
52 {
53  BinDemuxContext *bin = s->priv_data;
55  if (!st)
56  return NULL;
57  st->codecpar->codec_tag = 0;
59 
60  if (!bin->width) {
61  st->codecpar->width = (80<<3);
62  st->codecpar->height = (25<<4);
63  }
64 
65  avpriv_set_pts_info(st, 60, bin->framerate.den, bin->framerate.num);
66 
67  /* simulate tty display speed */
68  bin->chars_per_frame = av_clip(av_q2d(st->time_base) * bin->chars_per_frame, 1, INT_MAX);
69 
70  return st;
71 }
72 
73 #if CONFIG_BINTEXT_DEMUXER | CONFIG_ADF_DEMUXER | CONFIG_IDF_DEMUXER
74 /**
75  * Given filesize and width, calculate height (assume font_height of 16)
76  */
77 static void calculate_height(AVCodecParameters *par, uint64_t fsize)
78 {
79  par->height = (fsize / ((par->width>>3)*2)) << 4;
80 }
81 #endif
82 
83 #if CONFIG_BINTEXT_DEMUXER
84 static const uint8_t next_magic[]={
85  0x1A, 0x1B, '[', '0', ';', '3', '0', ';', '4', '0', 'm', 'N', 'E', 'X', 'T', 0x00
86 };
87 
88 static int next_tag_read(AVFormatContext *avctx, uint64_t *fsize)
89 {
90  AVIOContext *pb = avctx->pb;
91  char buf[36];
92  int len;
93  int64_t start_pos = avio_size(pb);
94 
95  if (start_pos < 256)
96  return AVERROR_INVALIDDATA;
97 
98  avio_seek(pb, start_pos - 256, SEEK_SET);
99  if (avio_read(pb, buf, sizeof(next_magic)) != sizeof(next_magic))
100  return -1;
101  if (memcmp(buf, next_magic, sizeof(next_magic)))
102  return -1;
103  if (avio_r8(pb) != 0x01)
104  return -1;
105 
106  *fsize -= 256;
107 
108 #define GET_EFI2_META(name,size) \
109  len = avio_r8(pb); \
110  if (len < 1 || len > size) \
111  return -1; \
112  if (avio_read(pb, buf, size) == size && *buf) { \
113  buf[len] = 0; \
114  av_dict_set(&avctx->metadata, name, buf, 0); \
115  }
116 
117  GET_EFI2_META("filename", 12)
118  GET_EFI2_META("author", 20)
119  GET_EFI2_META("publisher", 20)
120  GET_EFI2_META("title", 35)
121 
122  return 0;
123 }
124 
125 static void predict_width(AVCodecParameters *par, uint64_t fsize, int got_width)
126 {
127  /** attempt to guess width */
128  if (!got_width)
129  par->width = fsize > 4000 ? (160<<3) : (80<<3);
130 }
131 
132 static int bin_probe(const AVProbeData *p)
133 {
134  const uint8_t *d = p->buf;
135  int magic = 0, sauce = 0;
136  int invisible = 0;
137  int i;
138 
139  if (p->buf_size > 256)
140  magic = !memcmp(d + p->buf_size - 256, next_magic, sizeof(next_magic));
141  if (p->buf_size > 128)
142  sauce = !memcmp(d + p->buf_size - 128, "SAUCE00", 7);
143 
144  if (magic)
145  return AVPROBE_SCORE_EXTENSION + 1;
146 
147  if (av_match_ext(p->filename, "bin")) {
148  AVCodecParameters par;
149  int got_width = 0;
150  par.width = par.height = 0;
151  if (sauce)
152  return AVPROBE_SCORE_EXTENSION + 1;
153 
154  predict_width(&par, p->buf_size, got_width);
155  if (par.width < 8)
156  return 0;
157  calculate_height(&par, p->buf_size);
158  if (par.height <= 0)
159  return 0;
160 
161  for (i = 0; i < p->buf_size - 256; i+=2) {
162  if ((d[i+1] & 15) == (d[i+1] >> 4) && d[i] && d[i] != 0xFF && d[i] != ' ') {
163  invisible ++;
164  }
165  }
166 
167  if (par.width * par.height * 2 / (8*16) == p->buf_size)
168  return AVPROBE_SCORE_MAX / 2;
169  return 0;
170  }
171 
172  if (sauce)
173  return 1;
174 
175  return 0;
176 }
177 
178 
179 static int bintext_read_header(AVFormatContext *s)
180 {
181  BinDemuxContext *bin = s->priv_data;
182  AVIOContext *pb = s->pb;
183  int ret;
184  AVStream *st = init_stream(s);
185  if (!st)
186  return AVERROR(ENOMEM);
188 
189  if ((ret = ff_alloc_extradata(st->codecpar, 2)) < 0)
190  return ret;
191  st->codecpar->extradata[0] = 16;
192  st->codecpar->extradata[1] = 0;
193 
194  if (pb->seekable & AVIO_SEEKABLE_NORMAL) {
195  int got_width = 0;
196  bin->fsize = avio_size(pb);
197  if (ff_sauce_read(s, &bin->fsize, &got_width, 0) < 0)
198  next_tag_read(s, &bin->fsize);
199  if (!bin->width) {
200  predict_width(st->codecpar, bin->fsize, got_width);
201  if (st->codecpar->width < 8)
202  return AVERROR_INVALIDDATA;
203  calculate_height(st->codecpar, bin->fsize);
204  }
205  avio_seek(pb, 0, SEEK_SET);
206  }
207  return 0;
208 }
209 #endif /* CONFIG_BINTEXT_DEMUXER */
210 
211 #if CONFIG_XBIN_DEMUXER
212 static int xbin_probe(const AVProbeData *p)
213 {
214  const uint8_t *d = p->buf;
215 
216  if (AV_RL32(d) == MKTAG('X','B','I','N') && d[4] == 0x1A &&
217  AV_RL16(d+5) > 0 && AV_RL16(d+5) <= 160 &&
218  d[9] > 0 && d[9] <= 32)
219  return AVPROBE_SCORE_MAX;
220  return 0;
221 }
222 
223 static int xbin_read_header(AVFormatContext *s)
224 {
225  BinDemuxContext *bin = s->priv_data;
226  AVIOContext *pb = s->pb;
227  char fontheight, flags;
228  int ret;
229  AVStream *st = init_stream(s);
230  if (!st)
231  return AVERROR(ENOMEM);
232 
233  avio_skip(pb, 5);
234  st->codecpar->width = avio_rl16(pb)<<3;
235  st->codecpar->height = avio_rl16(pb);
236  fontheight = avio_r8(pb);
237  st->codecpar->height *= fontheight;
238  flags = avio_r8(pb);
239 
240  st->codecpar->extradata_size = 2;
241  if ((flags & BINTEXT_PALETTE))
242  st->codecpar->extradata_size += 48;
243  if ((flags & BINTEXT_FONT))
244  st->codecpar->extradata_size += fontheight * (flags & 0x10 ? 512 : 256);
246 
248  if (ret < 0)
249  return ret;
250  st->codecpar->extradata[0] = fontheight;
251  st->codecpar->extradata[1] = flags;
252  if (avio_read(pb, st->codecpar->extradata + 2, st->codecpar->extradata_size - 2) < 0)
253  return AVERROR(EIO);
254 
255  if (pb->seekable & AVIO_SEEKABLE_NORMAL) {
256  int64_t fsize = avio_size(pb);
257  if (fsize < 9 + st->codecpar->extradata_size)
258  return 0;
259  bin->fsize = fsize - 9 - st->codecpar->extradata_size;
260  ff_sauce_read(s, &bin->fsize, NULL, 0);
261  avio_seek(pb, 9 + st->codecpar->extradata_size, SEEK_SET);
262  }
263 
264  return 0;
265 }
266 #endif /* CONFIG_XBIN_DEMUXER */
267 
268 #if CONFIG_ADF_DEMUXER
269 static int adf_read_header(AVFormatContext *s)
270 {
271  BinDemuxContext *bin = s->priv_data;
272  AVIOContext *pb = s->pb;
273  AVStream *st;
274  int ret;
275 
276  if (avio_r8(pb) != 1)
277  return AVERROR_INVALIDDATA;
278 
279  st = init_stream(s);
280  if (!st)
281  return AVERROR(ENOMEM);
283 
284  if ((ret = ff_alloc_extradata(st->codecpar, 2 + 48 + 4096)) < 0)
285  return ret;
286  st->codecpar->extradata[0] = 16;
288 
289  if (avio_read(pb, st->codecpar->extradata + 2, 24) < 0)
290  return AVERROR(EIO);
291  avio_skip(pb, 144);
292  if (avio_read(pb, st->codecpar->extradata + 2 + 24, 24) < 0)
293  return AVERROR(EIO);
294  if (avio_read(pb, st->codecpar->extradata + 2 + 48, 4096) < 0)
295  return AVERROR(EIO);
296 
297  if (pb->seekable & AVIO_SEEKABLE_NORMAL) {
298  int got_width = 0;
299  int64_t fsize = avio_size(pb);
300  if (fsize < 1 + 192 + 4096)
301  return 0;
302  bin->fsize = fsize - 1 - 192 - 4096;
303  st->codecpar->width = 80<<3;
304  ff_sauce_read(s, &bin->fsize, &got_width, 0);
305  if (st->codecpar->width < 8)
306  return AVERROR_INVALIDDATA;
307  if (!bin->width)
308  calculate_height(st->codecpar, bin->fsize);
309  avio_seek(pb, 1 + 192 + 4096, SEEK_SET);
310  }
311  return 0;
312 }
313 #endif /* CONFIG_ADF_DEMUXER */
314 
315 #if CONFIG_IDF_DEMUXER
316 static const uint8_t idf_magic[] = {
317  0x04, 0x31, 0x2e, 0x34, 0x00, 0x00, 0x00, 0x00, 0x4f, 0x00, 0x15, 0x00
318 };
319 
320 static int idf_probe(const AVProbeData *p)
321 {
322  if (p->buf_size < sizeof(idf_magic))
323  return 0;
324  if (!memcmp(p->buf, idf_magic, sizeof(idf_magic)))
325  return AVPROBE_SCORE_MAX;
326  return 0;
327 }
328 
329 static int idf_read_header(AVFormatContext *s)
330 {
331  BinDemuxContext *bin = s->priv_data;
332  AVIOContext *pb = s->pb;
333  AVStream *st;
334  int got_width = 0, ret;
335  int64_t fsize;
336 
337  if (!(pb->seekable & AVIO_SEEKABLE_NORMAL))
338  return AVERROR(EIO);
339 
340  st = init_stream(s);
341  if (!st)
342  return AVERROR(ENOMEM);
344 
345  if ((ret = ff_alloc_extradata(st->codecpar, 2 + 48 + 4096)) < 0)
346  return ret;
347  st->codecpar->extradata[0] = 16;
349 
350  fsize = avio_size(pb);
351  if (fsize < 12 + 4096 + 48)
352  return AVERROR_INVALIDDATA;
353  bin->fsize = fsize - 12 - 4096 - 48;
354 
355  avio_seek(pb, bin->fsize + 12, SEEK_SET);
356 
357  if (avio_read(pb, st->codecpar->extradata + 2 + 48, 4096) < 0)
358  return AVERROR(EIO);
359  if (avio_read(pb, st->codecpar->extradata + 2, 48) < 0)
360  return AVERROR(EIO);
361 
362  ff_sauce_read(s, &bin->fsize, &got_width, 0);
363  if (st->codecpar->width < 8)
364  return AVERROR_INVALIDDATA;
365  if (!bin->width)
366  calculate_height(st->codecpar, bin->fsize);
367  avio_seek(pb, 12, SEEK_SET);
368  return 0;
369 }
370 #endif /* CONFIG_IDF_DEMUXER */
371 
373  AVPacket *pkt)
374 {
375  BinDemuxContext *bin = s->priv_data;
376 
377  if (bin->fsize > 0) {
378  if (av_get_packet(s->pb, pkt, bin->fsize) < 0)
379  return AVERROR(EIO);
380  bin->fsize = -1; /* done */
381  } else if (!bin->fsize) {
382  if (avio_feof(s->pb))
383  return AVERROR(EIO);
384  if (av_get_packet(s->pb, pkt, bin->chars_per_frame) < 0)
385  return AVERROR(EIO);
386  } else {
387  return AVERROR(EIO);
388  }
389 
391  return 0;
392 }
393 
394 #define OFFSET(x) offsetof(BinDemuxContext, x)
395 static const AVOption options[] = {
396  { "linespeed", "set simulated line speed (bytes per second)", OFFSET(chars_per_frame), AV_OPT_TYPE_INT, {.i64 = 6000}, 1, INT_MAX, AV_OPT_FLAG_DECODING_PARAM},
397  { "video_size", "set video size, such as 640x480 or hd720.", OFFSET(width), AV_OPT_TYPE_IMAGE_SIZE, {.str = NULL}, 0, 0, AV_OPT_FLAG_DECODING_PARAM },
398  { "framerate", "set framerate (frames per second)", OFFSET(framerate), AV_OPT_TYPE_VIDEO_RATE, {.str = "25"}, 0, INT_MAX, AV_OPT_FLAG_DECODING_PARAM },
399  { NULL },
400 };
401 
402 #define CLASS(name) \
403 (const AVClass[1]){{ \
404  .class_name = name, \
405  .item_name = av_default_item_name, \
406  .option = options, \
407  .version = LIBAVUTIL_VERSION_INT, \
408 }}
409 
410 #if CONFIG_BINTEXT_DEMUXER
412  .name = "bin",
413  .long_name = NULL_IF_CONFIG_SMALL("Binary text"),
414  .priv_data_size = sizeof(BinDemuxContext),
415  .read_probe = bin_probe,
416  .read_header = bintext_read_header,
418  .priv_class = CLASS("Binary text demuxer"),
419 };
420 #endif
421 
422 #if CONFIG_XBIN_DEMUXER
424  .name = "xbin",
425  .long_name = NULL_IF_CONFIG_SMALL("eXtended BINary text (XBIN)"),
426  .priv_data_size = sizeof(BinDemuxContext),
427  .read_probe = xbin_probe,
428  .read_header = xbin_read_header,
430  .priv_class = CLASS("eXtended BINary text (XBIN) demuxer"),
431 };
432 #endif
433 
434 #if CONFIG_ADF_DEMUXER
436  .name = "adf",
437  .long_name = NULL_IF_CONFIG_SMALL("Artworx Data Format"),
438  .priv_data_size = sizeof(BinDemuxContext),
439  .read_header = adf_read_header,
441  .extensions = "adf",
442  .priv_class = CLASS("Artworx Data Format demuxer"),
443 };
444 #endif
445 
446 #if CONFIG_IDF_DEMUXER
448  .name = "idf",
449  .long_name = NULL_IF_CONFIG_SMALL("iCE Draw File"),
450  .priv_data_size = sizeof(BinDemuxContext),
451  .read_probe = idf_probe,
452  .read_header = idf_read_header,
454  .extensions = "idf",
455  .priv_class = CLASS("iCE Draw File demuxer"),
456 };
457 #endif
AVInputFormat ff_idf_demuxer
AVInputFormat ff_bintext_demuxer
AVInputFormat ff_adf_demuxer
AVInputFormat ff_xbin_demuxer
return
uint8_t
static int64_t fsize(FILE *f)
Definition: audiomatch.c:29
Main libavformat public API header.
#define AVPROBE_SCORE_MAX
maximum score
Definition: avformat.h:453
#define AVPROBE_SCORE_EXTENSION
score for file extension
Definition: avformat.h:451
int av_get_packet(AVIOContext *s, AVPacket *pkt, int size)
Allocate and read the payload of a packet and initialize its fields with default values.
Definition: utils.c:310
int64_t avio_seek(AVIOContext *s, int64_t offset, int whence)
fseek() equivalent for AVIOContext.
Definition: aviobuf.c:253
#define AVIO_SEEKABLE_NORMAL
Seeking works like for a local file.
Definition: avio.h:40
int64_t avio_size(AVIOContext *s)
Get the filesize.
Definition: aviobuf.c:342
int avio_feof(AVIOContext *s)
Similar to feof() but also returns nonzero on read errors.
Definition: aviobuf.c:364
unsigned int avio_rl16(AVIOContext *s)
Definition: aviobuf.c:734
int64_t avio_skip(AVIOContext *s, int64_t offset)
Skip given number of bytes forward.
Definition: aviobuf.c:337
int avio_read(AVIOContext *s, unsigned char *buf, int size)
Read size bytes from AVIOContext into buf.
Definition: aviobuf.c:633
int avio_r8(AVIOContext *s)
Definition: aviobuf.c:624
#define AV_RL16
Definition: intreadwrite.h:42
#define AV_RL32
Definition: intreadwrite.h:146
Binary text decoder.
#define BINTEXT_FONT
Definition: bintext.h:35
#define BINTEXT_PALETTE
Definition: bintext.h:34
#define flags(name, subs,...)
Definition: cbs_av1.c:572
#define s(width, name)
Definition: cbs_vp9.c:257
#define MKTAG(a, b, c, d)
Definition: common.h:478
#define av_clip
Definition: common.h:122
#define NULL
Definition: coverity.c:32
long long int64_t
Definition: coverity.c:34
static int read_header(FFV1Context *f)
Definition: ffv1dec.c:545
@ AV_OPT_TYPE_IMAGE_SIZE
offset must point to two consecutive integers
Definition: opt.h:235
@ AV_OPT_TYPE_VIDEO_RATE
offset must point to AVRational
Definition: opt.h:238
@ AV_OPT_TYPE_INT
Definition: opt.h:225
@ AV_CODEC_ID_IDF
Definition: codec_id.h:559
@ AV_CODEC_ID_XBIN
Definition: codec_id.h:558
@ AV_CODEC_ID_BINTEXT
Definition: codec_id.h:557
#define AV_PKT_FLAG_KEY
The packet contains a keyframe.
Definition: packet.h:410
AVStream * avformat_new_stream(AVFormatContext *s, const AVCodec *c)
Add a new stream to a media file.
Definition: utils.c:4509
int av_match_ext(const char *filename, const char *extensions)
Return a positive value if the given filename has one of the given extensions, 0 otherwise.
Definition: format.c:38
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
#define AVERROR(e)
Definition: error.h:43
static double av_q2d(AVRational a)
Convert an AVRational to a double.
Definition: rational.h:104
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
int i
Definition: input.c:407
static const AVOption options[]
Definition: bintext.c:395
static int read_packet(AVFormatContext *s, AVPacket *pkt)
Definition: bintext.c:372
#define CLASS(name)
Definition: bintext.c:402
static AVStream * init_stream(AVFormatContext *s)
Definition: bintext.c:51
#define OFFSET(x)
Definition: bintext.c:394
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:4945
int ff_alloc_extradata(AVCodecParameters *par, int size)
Allocate extradata with additional AV_INPUT_BUFFER_PADDING_SIZE at end which is always set to 0.
Definition: utils.c:3314
static int read_probe(const AVProbeData *pd)
Definition: jvdec.c:55
common internal API header
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.
Definition: internal.h:117
AVOptions.
#define AV_OPT_FLAG_DECODING_PARAM
a generic parameter which can be set by the user for demuxing or decoding
Definition: opt.h:279
misc parsing utilities
int ff_sauce_read(AVFormatContext *avctx, uint64_t *fsize, int *got_width, int get_height)
Definition: sauce.c:32
SAUCE header parser.
Describe the class of an AVClass context structure.
Definition: log.h:67
This struct describes the properties of an encoded stream.
Definition: codec_par.h:52
int extradata_size
Size of the extradata content in bytes.
Definition: codec_par.h:78
int width
Video only.
Definition: codec_par.h:126
enum AVMediaType codec_type
General type of the encoded data.
Definition: codec_par.h:56
uint32_t codec_tag
Additional information about the codec (corresponds to the AVI FOURCC).
Definition: codec_par.h:64
uint8_t * extradata
Extra binary data needed for initializing the decoder, codec-dependent.
Definition: codec_par.h:74
enum AVCodecID codec_id
Specific type of the encoded data (the codec used).
Definition: codec_par.h:60
Format I/O context.
Definition: avformat.h:1232
AVIOContext * pb
I/O context.
Definition: avformat.h:1274
Bytestream IO Context.
Definition: avio.h:161
int seekable
A combination of AVIO_SEEKABLE_ flags or 0 when the stream is not seekable.
Definition: avio.h:260
const char * name
A comma separated list of short names for the format.
Definition: avformat.h:645
AVOption.
Definition: opt.h:248
This structure stores compressed data.
Definition: packet.h:346
int flags
A combination of AV_PKT_FLAG values.
Definition: packet.h:375
This structure contains the data a format has to probe a file.
Definition: avformat.h:441
const char * filename
Definition: avformat.h:442
int buf_size
Size of buf except extra allocated bytes.
Definition: avformat.h:444
unsigned char * buf
Buffer must have AVPROBE_PADDING_SIZE of extra allocated bytes filled with zero.
Definition: avformat.h:443
Rational number (pair of numerator and denominator).
Definition: rational.h:58
int num
Numerator.
Definition: rational.h:59
int den
Denominator.
Definition: rational.h:60
Stream structure.
Definition: avformat.h:873
AVCodecParameters * codecpar
Codec parameters associated with this stream.
Definition: avformat.h:1038
AVRational time_base
This is the fundamental unit of time (in seconds) in terms of which frame timestamps are represented.
Definition: avformat.h:902
int height
video size (WxH pixels) (private option)
Definition: bintext.c:46
uint64_t fsize
file size less metadata buffer
Definition: bintext.c:48
AVRational framerate
frames per second (private option)
Definition: bintext.c:47
int chars_per_frame
characters to send decoder per frame; set by private options as characters per second,...
Definition: bintext.c:43
int framerate
Definition: h264_levels.c:65
AVPacket * pkt
Definition: movenc.c:59
#define width
int len