Go to the documentation of this file.
36 #define SBG_SCALE (1 << 16)
37 #define DAY (24 * 60 * 60)
38 #define DAY_TS ((int64_t)DAY * AV_TIME_BASE)
163 int *
size,
int *max_size)
167 if (*
size == *max_size) {
168 int m =
FFMAX(32,
FFMIN(*max_size, INT_MAX / 2) * 2);
177 memset(
ret, 0, elsize);
184 const char *cur = str;
190 if (*cur < '0' || *cur >
'9')
192 hours = strtol(cur, &end, 10);
193 if (end == cur || *end !=
':' || end[1] <
'0' || end[1] >
'9')
196 minutes = strtol(cur, &end, 10);
201 seconds =
strtod(cur + 1, &end);
212 return c ==
' ' ||
c ==
'\t' ||
c ==
'\r';
218 if (m < INT_MIN || m >= INT_MAX) {
290 if (
s == p->
end || *
s ==
'\n')
292 while (c < p->end && *
c !=
'\n' && !
is_space(*
c))
304 while (c < p->end && ((*
c >=
'a' && *
c <=
'z') || (*
c >=
'A' && *
c <=
'Z')
305 || (*
c >=
'0' && *
c <=
'9') || *
c ==
'_' || *
c ==
'-'))
321 #define FORWARD_ERROR(c) \
325 return errcode ? errcode : AVERROR_INVALIDDATA; \
331 "immediate sequences not yet implemented");
338 "preprogrammed sequences not yet implemented");
346 "option '%c' requires an argument", o);
363 for (; ostr.
s < ostr.
e; ostr.
s++) {
381 if (oarg.
e != tptr) {
383 "syntax error for option -F");
393 "syntax error for option -L");
400 if (oarg.
e != oarg.
s +
r) {
402 "syntax error for option -T");
411 memcpy(tptr, oarg.
s, oarg.
e - oarg.
s);
412 tptr[oarg.
e - oarg.
s] = 0;
419 if (oarg.
e != tptr) {
421 "syntax error for option -q");
426 "speed factor other than 1 not supported");
432 r = strtol(oarg.
s, &tptr, 10);
433 if (oarg.
e != tptr) {
435 "syntax error for option -r");
440 "invalid sample rate");
447 "unknown option: '%c'", *ostr.
s);
543 "relative time without previous absolute time");
581 "waveform definitions not yet implemented");
630 double carrierf, beatf;
631 int carrier, beat, vol;
696 double carrierf, beatf;
697 int carrier, beat, vol;
768 char *cursor_save = p->
cursor;
776 if (
name.e -
name.s == 6 && !memcmp(
name.s,
"wave", 4) &&
777 name.s[4] >=
'0' &&
name.s[4] <=
'9' &&
778 name.s[5] >=
'0' &&
name.s[5] <=
'9') {
779 int wavenum = (
name.s[4] -
'0') * 10 + (
name.s[5] -
'0');
809 .end =
script + script_len,
816 .sample_rate = 44100,
850 int lctx = ectx -
ctx;
851 const char *quote =
"\"";
852 if (lctx > 0 &&
ctx[lctx - 1] ==
'\r')
855 ctx =
"the end of line";
886 for (
i = 0;
i <
s->nb_tseq;
i++)
887 nb_rel +=
s->tseq[
i].ts.type ==
'N';
888 if (nb_rel ==
s->nb_tseq) {
893 "Start time ignored in a purely relative script.\n");
895 s->opt_start_at_first) {
898 s->start_ts =
s->tseq[0].ts.t;
903 struct tm *tm, tmpbuf;
906 "Scripts with mixed absolute and relative timestamps can give "
907 "unexpected results (pause, seeking, time zone change).\n");
911 now = tm ? tm->tm_hour * 3600 + tm->tm_min * 60 + tm->tm_sec :
914 (
int)(now / 3600), (
int)(now / 60) % 60, (
int)now % 60);
916 for (
i = 0;
i <
s->nb_tseq;
i++) {
917 if (
s->tseq[
i].ts.type ==
'N') {
918 s->tseq[
i].ts.t += now;
919 s->tseq[
i].ts.type =
'T';
924 s->start_ts = (
s->opt_start_at_first &&
s->tseq) ?
s->tseq[0].ts.t : now;
925 if (
s->start_ts > INT64_MAX -
s->opt_duration)
928 s->end_ts =
s->opt_duration ?
s->start_ts +
s->opt_duration :
931 for (
i = 0;
i <
s->nb_tseq;
i++) {
934 if (
s->tseq[
i].ts.t +
delta < cur_ts)
936 cur_ts =
s->tseq[
i].ts.t +=
delta;
958 for (
i = 0;
i <
s->nb_def;
i++) {
963 if (
i >=
s->nb_def) {
969 if (def->
type ==
'B') {
978 &
s->nb_events, nb_ev_max);
992 int i,
r, nb_events_max = 0;
997 for (
i = 0;
i <
s->nb_tseq;
i++) {
1002 if (!
s->nb_events) {
1006 if (
s->opt_end_at_last)
1007 s->end_ts =
s->events[
s->nb_events - 1].ts;
1041 i->phi =
ref >= 0 ?
ref | 0x80000000 : 0;
1064 ts3,
f,
a, ts4,
f, cpoints[
i][1]);
1088 if (s1->
beat == 0 && s2->
beat == 0) {
1112 if (transition == 2) {
1121 "using pink noise instead.\n");
1146 "Type %d is not implemented\n", s1->
type);
1188 int64_t tsmid = (ts1 >> 1) + (ts2 >> 1) + (ts1 & ts2 & 1);
1194 for (pass = 0; pass < 2; pass++) {
1202 for (
i = 0;
i < nb_elements;
i++) {
1226 ts1, ts2, &s1mod, &s2mod, 3);
1237 ts1, tsmid, &s1mod, &smid, 1);
1244 tsmid, ts2, &smid, &s2mod, 2);
1270 int64_t trans_time =
s->opt_fade_time / 2;
1278 period =
s->events[
s->nb_events - 1].ts - (uint64_t)
s->events[0].ts;
1286 for (
i = 0;
i <
s->nb_events;
i++) {
1287 ev1 = &
s->events[
i];
1288 ev2 = &
s->events[(
i + 1) %
s->nb_events];
1295 : ev2->
ts + (ev1 < ev2 ? 0 :
period);
1297 for (
i = 0;
i <
s->nb_events;
i++) {
1298 ev1 = &
s->events[
i];
1299 ev2 = &
s->events[(
i + 1) %
s->nb_events];
1308 ev0 =
s->events[
s->nb_events - 1];
1316 for (
i = -1;
i <
s->nb_events;
i++) {
1317 ev1 =
i < 0 ? &ev0 : &
s->events[
i];
1324 for (
i = 0;
i <
s->nb_synth;
i++)
1325 s->synth[
i].ref.l =
s->synth[
i].ref.r = -1;
1326 for (
i = -1;
i <
s->nb_events;
i++) {
1327 ev1 =
i < 0 ? &ev0 : &
s->events[
i];
1328 ev2 = &
s->events[(
i + 1) %
s->nb_events];
1344 int i, edata_size = 4,
ret;
1357 #define ADD_EDATA32(v) do { AV_WL32(edata, (v)); edata += 4; } while(0)
1358 #define ADD_EDATA64(v) do { AV_WL64(edata, (v)); edata += 8; } while(0)
1379 if (edata != par->
extradata + edata_size)
1422 "-m is ignored and mix channels will be silent.\n");
1490 packet->
dts = packet->
pts = ts;
1494 return packet->
size;
1500 if (
flags || stream_index > 0)
1502 if (stream_index < 0)
1521 {
"max_file_size",
"", offsetof(
struct sbg_demuxer, max_file_size),
1537 .p.extensions =
"sbg",
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it be(in the first position) for now. Options ------- Then comes the options array. This is what will define the user accessible options. For example
static int read_whole_file(AVIOContext *io, int max_size, AVBPrint *rbuf)
enum ws_interval_type type
#define AV_LOG_WARNING
Something somehow does not look correct.
uint8_t * extradata
Extra binary data needed for initializing the decoder, codec-dependent.
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf default minimum maximum flags name is the option name
static int parse_synth_channel(struct sbg_parser *p)
static int av_bprint_is_complete(const AVBPrint *buf)
Test if the print buffer is complete (not truncated).
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later. That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another. Frame references ownership and permissions
static int scale_double(void *log, double d, double m, int *r)
enum AVMediaType codec_type
General type of the encoded data.
#define AV_CHANNEL_LAYOUT_STEREO
void av_bprint_init(AVBPrint *buf, unsigned size_init, unsigned size_max)
static int str_to_time(const char *str, int64_t *rtime)
This struct describes the properties of an encoded stream.
double strtod(const char *, char **)
AVStream * avformat_new_stream(AVFormatContext *s, const struct AVCodec *c)
Add a new stream to a media file.
#define AVERROR_EOF
End of file.
#define AV_TIME_BASE_Q
Internal time base represented as fractional value.
static int lex_char(struct sbg_parser *p, char c)
static int parse_synth_channel_pink(struct sbg_parser *p, struct sbg_script_synth *synth)
static int expand_timestamps(void *log, struct sbg_script *s)
struct sbg_script_tseq * block_tseq
AVStream ** streams
A list of all streams in the file.
struct sbg_timestamp current_time
static int lex_time(struct sbg_parser *p, int64_t *rt)
static int sbg_read_seek2(AVFormatContext *avf, int stream_index, int64_t min_ts, int64_t ts, int64_t max_ts, int flags)
int64_t duration
Duration of this packet in AVStream->time_base units, 0 if unknown.
int buf_size
Size of buf except extra allocated bytes.
struct ws_interval * inter
static int is_space(char c)
static int sbg_read_packet(AVFormatContext *avf, AVPacket *packet)
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf type
int64_t duration
Decoding: duration of the stream, in stream time base.
static double a2(void *priv, double x, double y)
@ AV_CODEC_ID_FFWAVESYNTH
struct sbg_script_synth * synth
static int lex_space(struct sbg_parser *p)
static int add_interval(struct ws_intervals *inter, enum ws_interval_type type, uint32_t channels, int ref, int64_t ts1, int32_t f1, int32_t a1, int64_t ts2, int32_t f2, int32_t a2)
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
#define FF_ARRAY_ELEMS(a)
static int generate_plateau(void *log, struct sbg_script *s, struct ws_intervals *inter, struct sbg_script_event *ev1)
int frame_size
Audio only.
static int expand_tseq(void *log, struct sbg_script *s, int *nb_ev_max, int64_t t0, struct sbg_script_tseq *tseq)
int av_new_packet(AVPacket *pkt, int size)
Allocate the payload of a packet and initialize its fields with default values.
static int parse_wave_def(struct sbg_parser *p, int wavenum)
int avio_read_to_bprint(AVIOContext *h, struct AVBPrint *pb, size_t max_size)
Read contents of h into print buffer, up to max_size bytes, or up to EOF.
unsigned char * buf
Buffer must have AVPROBE_PADDING_SIZE of extra allocated bytes filled with zero.
static int lex_name(struct sbg_parser *p, struct sbg_string *rs)
static int parse_optarg(struct sbg_parser *p, char o, struct sbg_string *r)
int64_t av_rescale_q(int64_t a, AVRational bq, AVRational cq)
Rescale a 64-bit integer by 2 rational numbers.
static const AVOption sbg_options[]
static int lex_fixed(struct sbg_parser *p, const char *t, int l)
const FFInputFormat ff_sbg_demuxer
struct sbg_script_tseq * tseq
static int sbg_read_seek(AVFormatContext *avf, int stream_index, int64_t ts, int flags)
#define av_realloc_f(p, o, n)
static int parse_synth_channel_sine(struct sbg_parser *p, struct sbg_script_synth *synth)
static int parse_synth_channel_spin(struct sbg_parser *p, struct sbg_script_synth *synth)
AVCodecParameters * codecpar
Codec parameters associated with this stream.
#define LIBAVUTIL_VERSION_INT
static int generate_intervals(void *log, struct sbg_script *s, int sample_rate, struct ws_intervals *inter)
Describe the class of an AVClass context structure.
AVRational time_base
This is the fundamental unit of time (in seconds) in terms of which frame timestamps are represented.
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
struct sbg_script_definition * def
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf default minimum maximum flags name is the option keep it simple and lowercase description are in without period
const char * av_default_item_name(void *ptr)
Return the context name.
AVIOContext * pb
I/O context.
struct sbg_script_synth::@404 ref
static int lex_wsword(struct sbg_parser *p, struct sbg_string *rs)
This structure contains the data a format has to probe a file.
static int parse_script(void *log, char *script, int script_len, struct sbg_script *rscript)
static const AVClass sbg_demuxer_class
struct sbg_script_event * events
static int parse_fade(struct sbg_parser *p, struct sbg_fade *fr)
AVChannelLayout ch_layout
Audio only.
Undefined Behavior In the C some operations are like signed integer dereferencing freed accessing outside allocated Undefined Behavior must not occur in a C it is not safe even if the output of undefined operations is unused The unsafety may seem nit picking but Optimizing compilers have in fact optimized code on the assumption that no undefined Behavior occurs Optimizing code based on wrong assumptions can and has in some cases lead to effects beyond the output of computations The signed integer overflow problem in speed critical code Code which is highly optimized and works with signed integers sometimes has the problem that often the output of the computation does not c
int sample_rate
Audio only.
static int parse_named_def(struct sbg_parser *p)
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.
int av_bprint_finalize(AVBPrint *buf, char **ret_str)
Finalize a print buffer.
An AVChannelLayout holds information about the channel layout of audio data.
static int parse_synth_channel_bell(struct sbg_parser *p, struct sbg_script_synth *synth)
static int add_bell(struct ws_intervals *inter, struct sbg_script *s, int64_t ts1, int64_t ts2, int32_t f, int32_t a)
#define AV_NOPTS_VALUE
Undefined timestamp value.
int64_t dts
Decompression timestamp in AVStream->time_base units; the time at which the packet is decompressed.
The reader does not expect b to be semantically here and if the code is changed by maybe adding a a division or other the signedness will almost certainly be mistaken To avoid this confusion a new type was SUINT is the C unsigned type but it holds a signed int to use the same example SUINT a
static int parse_time_sequence(struct sbg_parser *p, int inblock)
int probe_packets
Number of packets to buffer for codec probing.
#define AV_LOG_INFO
Standard information.
static av_cold int sbg_read_header(AVFormatContext *avf)
static int parse_block_def(struct sbg_parser *p, struct sbg_script_definition *def)
#define i(width, name, range_min, range_max)
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
#define AV_TIME_BASE
Internal time base represented as integer.
static int parse_options(struct sbg_parser *p)
static int parse_volume(struct sbg_parser *p, int *vol)
static void fade(uint8_t *dst, ptrdiff_t dst_linesize, const uint8_t *src, ptrdiff_t src_linesize, int width, int height, int alpha, int beta)
int64_t av_rescale(int64_t a, int64_t b, int64_t c)
Rescale a 64-bit integer with rounding to nearest.
static int parse_immediate(struct sbg_parser *p)
static int array[MAX_W *MAX_W]
static int parse_timestamp(struct sbg_parser *p, struct sbg_timestamp *rts, int64_t *rrel)
const char * class_name
The name of the class; usually it is the same name as the context structure type to which the AVClass...
static int parse_synth_def(struct sbg_parser *p, struct sbg_script_definition *def)
static av_cold int sbg_read_probe(const AVProbeData *p)
static int generate_transition(void *log, struct sbg_script *s, struct ws_intervals *inter, struct sbg_script_event *ev1, struct sbg_script_event *ev2)
@ AV_OPT_TYPE_INT
Underlying C type is int.
static int ref[MAX_W *MAX_W]
int eof_reached
true if was unable to read due to error or eof
#define AV_OPT_FLAG_DECODING_PARAM
A generic parameter which can be set by the user for demuxing or decoding.
static int read_probe(const AVProbeData *p)
uint8_t opt_start_at_first
static void free_script(struct sbg_script *s)
enum AVCodecID codec_id
Specific type of the encoded data (the codec used).
static void * alloc_array_elem(void **array, size_t elsize, int *size, int *max_size)
This structure stores compressed data.
#define flags(name, subs,...)
#define AVERROR_BUG
Internal bug, also see AVERROR_BUG2.
static int parse_preprogrammed(struct sbg_parser *p)
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
static double a1(void *priv, double x, double y)
#define MKTAG(a, b, c, d)
int64_t start_time
Decoding: pts of the first frame of the stream in presentation order, in stream time base.
static int encode_intervals(struct sbg_script *s, AVCodecParameters *par, struct ws_intervals *inter)
void * priv_data
Format private data.
static int lex_line_end(struct sbg_parser *p)
static int lex_double(struct sbg_parser *p, double *r)
static int parse_synth_channel_mix(struct sbg_parser *p, struct sbg_script_synth *synth)
static void * av_x_if_null(const void *p, const void *x)
Return x default pointer in case p is NULL.
static int expand_script(void *log, struct sbg_script *s)
static int generate_interval(void *log, struct sbg_script *s, struct ws_intervals *inter, int64_t ts1, int64_t ts2, struct sbg_script_synth *s1, struct sbg_script_synth *s2, int transition)