FFmpeg
subtitles.c
Go to the documentation of this file.
1 /*
2  * Copyright (c) 2012-2013 Clément Bœsch <u pkh me>
3  *
4  * This file is part of FFmpeg.
5  *
6  * FFmpeg is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU Lesser General Public
8  * License as published by the Free Software Foundation; either
9  * version 2.1 of the License, or (at your option) any later version.
10  *
11  * FFmpeg is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14  * Lesser General Public License for more details.
15  *
16  * You should have received a copy of the GNU Lesser General Public
17  * License along with FFmpeg; if not, write to the Free Software
18  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
19  */
20 
21 #include "avformat.h"
22 #include "subtitles.h"
23 #include "avio_internal.h"
24 #include "libavutil/avstring.h"
25 
27 {
28  int i;
29  r->pb = pb;
30  r->buf_pos = r->buf_len = 0;
31  r->type = FF_UTF_8;
32  for (i = 0; i < 2; i++)
33  r->buf[r->buf_len++] = avio_r8(r->pb);
34  if (strncmp("\xFF\xFE", r->buf, 2) == 0) {
35  r->type = FF_UTF16LE;
36  r->buf_pos += 2;
37  } else if (strncmp("\xFE\xFF", r->buf, 2) == 0) {
38  r->type = FF_UTF16BE;
39  r->buf_pos += 2;
40  } else {
41  r->buf[r->buf_len++] = avio_r8(r->pb);
42  if (strncmp("\xEF\xBB\xBF", r->buf, 3) == 0) {
43  // UTF8
44  r->buf_pos += 3;
45  }
46  }
47  if (s && (r->type == FF_UTF16LE || r->type == FF_UTF16BE))
49  "UTF16 is automatically converted to UTF8, do not specify a character encoding\n");
50 }
51 
52 void ff_text_init_buf(FFTextReader *r, void *buf, size_t size)
53 {
54  memset(&r->buf_pb, 0, sizeof(r->buf_pb));
55  ffio_init_context(&r->buf_pb, buf, size, 0, NULL, NULL, NULL, NULL);
56  ff_text_init_avio(NULL, r, &r->buf_pb);
57 }
58 
60 {
61  return avio_tell(r->pb) - r->buf_len + r->buf_pos;
62 }
63 
65 {
66  uint32_t val;
67  uint8_t tmp;
68  if (r->buf_pos < r->buf_len)
69  return r->buf[r->buf_pos++];
70  if (r->type == FF_UTF16LE) {
71  GET_UTF16(val, avio_rl16(r->pb), return 0;)
72  } else if (r->type == FF_UTF16BE) {
73  GET_UTF16(val, avio_rb16(r->pb), return 0;)
74  } else {
75  return avio_r8(r->pb);
76  }
77  if (!val)
78  return 0;
79  r->buf_pos = 0;
80  r->buf_len = 0;
81  PUT_UTF8(val, tmp, r->buf[r->buf_len++] = tmp;)
82  return r->buf[r->buf_pos++]; // buf_len is at least 1
83 }
84 
85 void ff_text_read(FFTextReader *r, char *buf, size_t size)
86 {
87  for ( ; size > 0; size--)
88  *buf++ = ff_text_r8(r);
89 }
90 
92 {
93  return r->buf_pos >= r->buf_len && avio_feof(r->pb);
94 }
95 
97 {
98  int c;
99  if (r->buf_pos < r->buf_len)
100  return r->buf[r->buf_pos];
101  c = ff_text_r8(r);
102  if (!avio_feof(r->pb)) {
103  r->buf_pos = 0;
104  r->buf_len = 1;
105  r->buf[0] = c;
106  }
107  return c;
108 }
109 
111  const uint8_t *event, size_t len, int merge)
112 {
113  AVPacket **subs, *sub;
114 
115  if (merge && q->nb_subs > 0) {
116  /* merge with previous event */
117 
118  int old_len;
119  sub = q->subs[q->nb_subs - 1];
120  old_len = sub->size;
121  if (av_grow_packet(sub, len) < 0)
122  return NULL;
123  memcpy(sub->data + old_len, event, len);
124  } else {
125  /* new event */
126 
127  if (q->nb_subs >= INT_MAX/sizeof(*q->subs) - 1)
128  return NULL;
129  subs = av_fast_realloc(q->subs, &q->allocated_size,
130  (q->nb_subs + 1) * sizeof(*q->subs));
131  if (!subs)
132  return NULL;
133  q->subs = subs;
134  sub = av_packet_alloc();
135  if (!sub)
136  return NULL;
137  if (av_new_packet(sub, len) < 0) {
139  return NULL;
140  }
141  subs[q->nb_subs++] = sub;
142  sub->flags |= AV_PKT_FLAG_KEY;
143  sub->pts = sub->dts = 0;
144  memcpy(sub->data, event, len);
145  }
146  return sub;
147 }
148 
149 static int cmp_pkt_sub_ts_pos(const void *a, const void *b)
150 {
151  const AVPacket *s1 = *(const AVPacket **)a;
152  const AVPacket *s2 = *(const AVPacket **)b;
153  if (s1->pts == s2->pts)
154  return FFDIFFSIGN(s1->pos, s2->pos);
155  return FFDIFFSIGN(s1->pts , s2->pts);
156 }
157 
158 static int cmp_pkt_sub_pos_ts(const void *a, const void *b)
159 {
160  const AVPacket *s1 = *(const AVPacket **)a;
161  const AVPacket *s2 = *(const AVPacket **)b;
162  if (s1->pos == s2->pos) {
163  if (s1->pts == s2->pts)
164  return 0;
165  return s1->pts > s2->pts ? 1 : -1;
166  }
167  return s1->pos > s2->pos ? 1 : -1;
168 }
169 
170 static void drop_dups(void *log_ctx, FFDemuxSubtitlesQueue *q)
171 {
172  int i, drop = 0;
173 
174  for (i = 1; i < q->nb_subs; i++) {
175  const int last_id = i - 1 - drop;
176  const AVPacket *last = q->subs[last_id];
177 
178  if (q->subs[i]->pts == last->pts &&
179  q->subs[i]->duration == last->duration &&
180  q->subs[i]->stream_index == last->stream_index &&
181  !strcmp(q->subs[i]->data, last->data)) {
182 
183  av_packet_free(&q->subs[i]);
184  drop++;
185  } else if (drop) {
186  q->subs[last_id + 1] = q->subs[i];
187  q->subs[i] = NULL;
188  }
189  }
190 
191  if (drop) {
192  q->nb_subs -= drop;
193  av_log(log_ctx, AV_LOG_WARNING, "Dropping %d duplicated subtitle events\n", drop);
194  }
195 }
196 
198 {
199  int i;
200 
201  if (!q->nb_subs)
202  return;
203 
204  qsort(q->subs, q->nb_subs, sizeof(*q->subs),
207  for (i = 0; i < q->nb_subs; i++)
208  if (q->subs[i]->duration < 0 && i < q->nb_subs - 1 && q->subs[i + 1]->pts - (uint64_t)q->subs[i]->pts <= INT64_MAX)
209  q->subs[i]->duration = q->subs[i + 1]->pts - q->subs[i]->pts;
210 
211  if (!q->keep_duplicates)
212  drop_dups(log_ctx, q);
213 }
214 
216 {
217  AVPacket *sub;
218  int ret;
219 
220  if (q->current_sub_idx == q->nb_subs)
221  return AVERROR_EOF;
222  sub = q->subs[q->current_sub_idx];
223  if ((ret = av_packet_ref(pkt, sub)) < 0) {
224  return ret;
225  }
226 
227  pkt->dts = pkt->pts;
228  q->current_sub_idx++;
229  return 0;
230 }
231 
232 static int search_sub_ts(const FFDemuxSubtitlesQueue *q, int64_t ts)
233 {
234  int s1 = 0, s2 = q->nb_subs - 1;
235 
236  if (s2 < s1)
237  return AVERROR(ERANGE);
238 
239  for (;;) {
240  int mid;
241 
242  if (s1 == s2)
243  return s1;
244  if (s1 == s2 - 1)
245  return q->subs[s1]->pts <= q->subs[s2]->pts ? s1 : s2;
246  mid = (s1 + s2) / 2;
247  if (q->subs[mid]->pts <= ts)
248  s1 = mid;
249  else
250  s2 = mid;
251  }
252 }
253 
255  int64_t min_ts, int64_t ts, int64_t max_ts, int flags)
256 {
257  if (flags & AVSEEK_FLAG_BYTE) {
258  return AVERROR(ENOSYS);
259  } else if (flags & AVSEEK_FLAG_FRAME) {
260  if (ts < 0 || ts >= q->nb_subs)
261  return AVERROR(ERANGE);
262  q->current_sub_idx = ts;
263  } else {
264  int i, idx = search_sub_ts(q, ts);
265  int64_t ts_selected;
266 
267  if (idx < 0)
268  return idx;
269  for (i = idx; i < q->nb_subs && q->subs[i]->pts < min_ts; i++)
270  if (stream_index == -1 || q->subs[i]->stream_index == stream_index)
271  idx = i;
272  for (i = idx; i > 0 && q->subs[i]->pts > max_ts; i--)
273  if (stream_index == -1 || q->subs[i]->stream_index == stream_index)
274  idx = i;
275 
276  ts_selected = q->subs[idx]->pts;
277  if (ts_selected < min_ts || ts_selected > max_ts)
278  return AVERROR(ERANGE);
279 
280  /* look back in the latest subtitles for overlapping subtitles */
281  for (i = idx - 1; i >= 0; i--) {
282  int64_t pts = q->subs[i]->pts;
283  if (q->subs[i]->duration <= 0 ||
284  (stream_index != -1 && q->subs[i]->stream_index != stream_index))
285  continue;
286  if (pts >= min_ts && pts > ts_selected - q->subs[i]->duration)
287  idx = i;
288  else
289  break;
290  }
291 
292  /* If the queue is used to store multiple subtitles streams (like with
293  * VobSub) and the stream index is not specified, we need to make sure
294  * to focus on the smallest file position offset for a same timestamp;
295  * queue is ordered by pts and then filepos, so we can take the first
296  * entry for a given timestamp. */
297  if (stream_index == -1)
298  while (idx > 0 && q->subs[idx - 1]->pts == q->subs[idx]->pts)
299  idx--;
300 
301  q->current_sub_idx = idx;
302  }
303  return 0;
304 }
305 
307 {
308  int i;
309 
310  for (i = 0; i < q->nb_subs; i++)
311  av_packet_free(&q->subs[i]);
312  av_freep(&q->subs);
313  q->nb_subs = q->allocated_size = q->current_sub_idx = 0;
314 }
315 
317 {
318  FFDemuxSubtitlesQueue *q = s->priv_data;
320 }
321 
322 int ff_subtitles_read_seek(AVFormatContext *s, int stream_index,
323  int64_t min_ts, int64_t ts, int64_t max_ts, int flags)
324 {
325  FFDemuxSubtitlesQueue *q = s->priv_data;
326  return ff_subtitles_queue_seek(q, s, stream_index,
327  min_ts, ts, max_ts, flags);
328 }
329 
331 {
332  FFDemuxSubtitlesQueue *q = s->priv_data;
334  return 0;
335 }
336 
337 int ff_smil_extract_next_text_chunk(FFTextReader *tr, AVBPrint *buf, char *c)
338 {
339  int i = 0;
340  char end_chr;
341 
342  if (!*c) // cached char?
343  *c = ff_text_r8(tr);
344  if (!*c)
345  return 0;
346 
347  end_chr = *c == '<' ? '>' : '<';
348  do {
349  av_bprint_chars(buf, *c, 1);
350  *c = ff_text_r8(tr);
351  i++;
352  } while (*c != end_chr && *c);
353  if (end_chr == '>') {
354  av_bprint_chars(buf, '>', 1);
355  *c = 0;
356  }
357  return i;
358 }
359 
360 const char *ff_smil_get_attr_ptr(const char *s, const char *attr)
361 {
362  int in_quotes = 0;
363  const size_t len = strlen(attr);
364 
365  while (*s) {
366  while (*s) {
367  if (!in_quotes && av_isspace(*s))
368  break;
369  in_quotes ^= *s == '"'; // XXX: support escaping?
370  s++;
371  }
372  while (av_isspace(*s))
373  s++;
374  if (!av_strncasecmp(s, attr, len) && s[len] == '=')
375  return s + len + 1 + (s[len + 1] == '"');
376  }
377  return NULL;
378 }
379 
380 static inline int is_eol(char c)
381 {
382  return c == '\r' || c == '\n';
383 }
384 
386 {
387  char eol_buf[5], last_was_cr = 0;
388  int n = 0, i = 0, nb_eol = 0;
389 
390  av_bprint_clear(buf);
391 
392  for (;;) {
393  char c = ff_text_r8(tr);
394 
395  if (!c)
396  break;
397 
398  /* ignore all initial line breaks */
399  if (n == 0 && is_eol(c))
400  continue;
401 
402  /* line break buffering: we don't want to add the trailing \r\n */
403  if (is_eol(c)) {
404  nb_eol += c == '\n' || last_was_cr;
405  if (nb_eol == 2)
406  break;
407  eol_buf[i++] = c;
408  if (i == sizeof(eol_buf) - 1)
409  break;
410  last_was_cr = c == '\r';
411  continue;
412  }
413 
414  /* only one line break followed by data: we flush the line breaks
415  * buffer */
416  if (i) {
417  eol_buf[i] = 0;
418  av_bprintf(buf, "%s", eol_buf);
419  i = nb_eol = 0;
420  }
421 
422  av_bprint_chars(buf, c, 1);
423  n++;
424  }
425 }
426 
427 void ff_subtitles_read_chunk(AVIOContext *pb, AVBPrint *buf)
428 {
429  FFTextReader tr;
430  tr.buf_pos = tr.buf_len = 0;
431  tr.type = 0;
432  tr.pb = pb;
434 }
435 
436 ptrdiff_t ff_subtitles_read_line(FFTextReader *tr, char *buf, size_t size)
437 {
438  size_t cur = 0;
439  if (!size)
440  return 0;
441  while (cur + 1 < size) {
442  unsigned char c = ff_text_r8(tr);
443  if (!c)
444  return ff_text_eof(tr) ? cur : AVERROR_INVALIDDATA;
445  if (c == '\r' || c == '\n')
446  break;
447  buf[cur++] = c;
448  buf[cur] = '\0';
449  }
450  while (ff_text_peek_r8(tr) == '\r')
451  ff_text_r8(tr);
452  if (ff_text_peek_r8(tr) == '\n')
453  ff_text_r8(tr);
454  return cur;
455 }
ff_subtitles_read_close
int ff_subtitles_read_close(AVFormatContext *s)
Definition: subtitles.c:330
is_eol
static int is_eol(char c)
Definition: subtitles.c:380
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:186
ff_text_r8
int ff_text_r8(FFTextReader *r)
Return the next byte.
Definition: subtitles.c:64
PUT_UTF8
#define PUT_UTF8(val, tmp, PUT_BYTE)
Definition: common.h:552
r
const char * r
Definition: vf_curves.c:116
AVERROR
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
ff_smil_extract_next_text_chunk
int ff_smil_extract_next_text_chunk(FFTextReader *tr, AVBPrint *buf, char *c)
SMIL helper to load next chunk ("<...>" or untagged content) in buf.
Definition: subtitles.c:337
FFTextReader::buf_pos
int buf_pos
Definition: subtitles.h:44
AVSEEK_FLAG_FRAME
#define AVSEEK_FLAG_FRAME
seeking based on frame number
Definition: avformat.h:2170
sub
static float sub(float src0, float src1)
Definition: dnn_backend_native_layer_mathbinary.c:31
AVERROR_EOF
#define AVERROR_EOF
End of file.
Definition: error.h:55
FFDemuxSubtitlesQueue::nb_subs
int nb_subs
number of subtitles packets
Definition: subtitles.h:104
av_grow_packet
int av_grow_packet(AVPacket *pkt, int grow_by)
Increase packet size, correctly zeroing padding.
Definition: avpacket.c:117
FFTextReader::type
int type
Definition: subtitles.h:41
av_isspace
static av_const int av_isspace(int c)
Locale-independent conversion of ASCII isspace.
Definition: avstring.h:227
merge
static void merge(GetBitContext *gb, uint8_t *dst, uint8_t *src, int size)
Merge two consequent lists of equal size depending on bits read.
Definition: bink.c:220
tmp
static uint8_t tmp[11]
Definition: aes_ctr.c:26
AVPacket::data
uint8_t * data
Definition: packet.h:373
b
#define b
Definition: input.c:40
FFDemuxSubtitlesQueue::keep_duplicates
int keep_duplicates
set to 1 to keep duplicated subtitle events
Definition: subtitles.h:108
AVSEEK_FLAG_BYTE
#define AVSEEK_FLAG_BYTE
seeking based on position in bytes
Definition: avformat.h:2168
AVPacket::duration
int64_t duration
Duration of this packet in AVStream->time_base units, 0 if unknown.
Definition: packet.h:391
FF_UTF16LE
@ FF_UTF16LE
Definition: subtitles.h:36
FFTextReader
Definition: subtitles.h:40
ff_subtitles_read_line
ptrdiff_t ff_subtitles_read_line(FFTextReader *tr, char *buf, size_t size)
Read a line of text.
Definition: subtitles.c:436
AV_PKT_FLAG_KEY
#define AV_PKT_FLAG_KEY
The packet contains a keyframe.
Definition: packet.h:404
av_packet_free
void av_packet_free(AVPacket **pkt)
Free the packet, if the packet is reference counted, it will be unreferenced first.
Definition: avpacket.c:70
FFDemuxSubtitlesQueue::current_sub_idx
int current_sub_idx
current position for the read packet callback
Definition: subtitles.h:106
cmp_pkt_sub_ts_pos
static int cmp_pkt_sub_ts_pos(const void *a, const void *b)
Definition: subtitles.c:149
avio_tell
static av_always_inline int64_t avio_tell(AVIOContext *s)
ftell() equivalent for AVIOContext.
Definition: avio.h:538
val
static double val(void *priv, double ch)
Definition: aeval.c:75
pts
static int64_t pts
Definition: transcode_aac.c:653
avio_rl16
unsigned int avio_rl16(AVIOContext *s)
Definition: aviobuf.c:717
ff_subtitles_queue_seek
int ff_subtitles_queue_seek(FFDemuxSubtitlesQueue *q, AVFormatContext *s, int stream_index, int64_t min_ts, int64_t ts, int64_t max_ts, int flags)
Update current_sub_idx to emulate a seek.
Definition: subtitles.c:254
pkt
AVPacket * pkt
Definition: movenc.c:59
ff_text_init_buf
void ff_text_init_buf(FFTextReader *r, void *buf, size_t size)
Similar to ff_text_init_avio(), but sets it up to read from a bounded buffer.
Definition: subtitles.c:52
ff_subtitles_read_packet
int ff_subtitles_read_packet(AVFormatContext *s, AVPacket *pkt)
Definition: subtitles.c:316
av_fast_realloc
void * av_fast_realloc(void *ptr, unsigned int *size, size_t min_size)
Reallocate the given buffer if it is not large enough, otherwise do nothing.
Definition: mem.c:484
s
#define s(width, name)
Definition: cbs_vp9.c:257
av_new_packet
int av_new_packet(AVPacket *pkt, int size)
Allocate the payload of a packet and initialize its fields with default values.
Definition: avpacket.c:94
ff_subtitles_read_text_chunk
void ff_subtitles_read_text_chunk(FFTextReader *tr, AVBPrint *buf)
Read a subtitles chunk from FFTextReader.
Definition: subtitles.c:385
s1
#define s1
Definition: regdef.h:38
FFTextReader::pb
AVIOContext * pb
Definition: subtitles.h:42
ff_subtitles_queue_read_packet
int ff_subtitles_queue_read_packet(FFDemuxSubtitlesQueue *q, AVPacket *pkt)
Generic read_packet() callback for subtitles demuxers using this queue system.
Definition: subtitles.c:215
AVFormatContext
Format I/O context.
Definition: avformat.h:1107
ff_text_read
void ff_text_read(FFTextReader *r, char *buf, size_t size)
Read the given number of bytes (in UTF-8).
Definition: subtitles.c:85
NULL
#define NULL
Definition: coverity.c:32
av_packet_ref
int av_packet_ref(AVPacket *dst, const AVPacket *src)
Setup a new reference to the data described by a given packet.
Definition: avpacket.c:411
ff_subtitles_queue_insert
AVPacket * ff_subtitles_queue_insert(FFDemuxSubtitlesQueue *q, const uint8_t *event, size_t len, int merge)
Insert a new subtitle event.
Definition: subtitles.c:110
c
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
Definition: undefined.txt:32
ff_text_init_avio
void ff_text_init_avio(void *s, FFTextReader *r, AVIOContext *pb)
Initialize the FFTextReader from the given AVIOContext.
Definition: subtitles.c:26
av_strncasecmp
int av_strncasecmp(const char *a, const char *b, size_t n)
Locale-independent case-insensitive compare.
Definition: avstring.c:225
s2
#define s2
Definition: regdef.h:39
AVIOContext
Bytestream IO Context.
Definition: avio.h:161
ffio_init_context
int ffio_init_context(AVIOContext *s, unsigned char *buffer, int buffer_size, int write_flag, void *opaque, int(*read_packet)(void *opaque, uint8_t *buf, int buf_size), int(*write_packet)(void *opaque, uint8_t *buf, int buf_size), int64_t(*seek)(void *opaque, int64_t offset, int whence))
Definition: aviobuf.c:78
size
int size
Definition: twinvq_data.h:10344
ff_subtitles_queue_finalize
void ff_subtitles_queue_finalize(void *log_ctx, FFDemuxSubtitlesQueue *q)
Set missing durations, sort subtitles by PTS (and then byte position), and drop duplicated events.
Definition: subtitles.c:197
FFDIFFSIGN
#define FFDIFFSIGN(x, y)
Comparator.
Definition: common.h:101
FFDemuxSubtitlesQueue
Definition: subtitles.h:102
AVPacket::dts
int64_t dts
Decompression timestamp in AVStream->time_base units; the time at which the packet is decompressed.
Definition: packet.h:372
avio_r8
int avio_r8(AVIOContext *s)
Definition: aviobuf.c:607
a
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
Definition: undefined.txt:41
ff_subtitles_queue_clean
void ff_subtitles_queue_clean(FFDemuxSubtitlesQueue *q)
Remove and destroy all the subtitles packets.
Definition: subtitles.c:306
av_packet_alloc
AVPacket * av_packet_alloc(void)
Allocate an AVPacket and set its fields to default values.
Definition: avpacket.c:59
AV_LOG_INFO
#define AV_LOG_INFO
Standard information.
Definition: log.h:191
FF_UTF16BE
@ FF_UTF16BE
Definition: subtitles.h:37
drop_dups
static void drop_dups(void *log_ctx, FFDemuxSubtitlesQueue *q)
Definition: subtitles.c:170
i
int i
Definition: input.c:406
AVPacket::pts
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
Definition: packet.h:366
FFDemuxSubtitlesQueue::subs
AVPacket ** subs
array of subtitles packets
Definition: subtitles.h:103
avio_internal.h
SUB_SORT_TS_POS
@ SUB_SORT_TS_POS
sort by timestamps, then position
Definition: subtitles.h:30
ff_text_pos
int64_t ff_text_pos(FFTextReader *r)
Return the byte position of the next byte returned by ff_text_r8().
Definition: subtitles.c:59
ff_subtitles_read_seek
int ff_subtitles_read_seek(AVFormatContext *s, int stream_index, int64_t min_ts, int64_t ts, int64_t max_ts, int flags)
Definition: subtitles.c:322
GET_UTF16
#define GET_UTF16(val, GET_16BIT, ERROR)
Convert a UTF-16 character (2 or 4 bytes) to its 32-bit UCS-4 encoded form.
Definition: common.h:524
len
int len
Definition: vorbis_enc_data.h:426
ret
ret
Definition: filter_design.txt:187
avio_rb16
unsigned int avio_rb16(AVIOContext *s)
Definition: aviobuf.c:749
ff_subtitles_read_chunk
void ff_subtitles_read_chunk(AVIOContext *pb, AVBPrint *buf)
Same as ff_subtitles_read_text_chunk(), but read from an AVIOContext.
Definition: subtitles.c:427
avformat.h
av_bprintf
void av_bprintf(AVBPrint *buf, const char *fmt,...)
Definition: bprint.c:93
ff_text_peek_r8
int ff_text_peek_r8(FFTextReader *r)
Like ff_text_r8(), but don't remove the byte from the buffer.
Definition: subtitles.c:96
av_bprint_clear
void av_bprint_clear(AVBPrint *buf)
Reset the string to "" but keep internal allocated data.
Definition: bprint.c:226
subtitles.h
search_sub_ts
static int search_sub_ts(const FFDemuxSubtitlesQueue *q, int64_t ts)
Definition: subtitles.c:232
AVPacket::stream_index
int stream_index
Definition: packet.h:375
FFTextReader::buf_len
int buf_len
Definition: subtitles.h:44
FF_UTF_8
@ FF_UTF_8
Definition: subtitles.h:35
ff_text_eof
int ff_text_eof(FFTextReader *r)
Return non-zero if EOF was reached.
Definition: subtitles.c:91
AVPacket
This structure stores compressed data.
Definition: packet.h:350
FFDemuxSubtitlesQueue::allocated_size
int allocated_size
allocated size for subs
Definition: subtitles.h:105
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:35
flags
#define flags(name, subs,...)
Definition: cbs_av1.c:561
FFDemuxSubtitlesQueue::sort
enum sub_sort sort
sort method to use when finalizing subtitles
Definition: subtitles.h:107
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:28
AVERROR_INVALIDDATA
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
cmp_pkt_sub_pos_ts
static int cmp_pkt_sub_pos_ts(const void *a, const void *b)
Definition: subtitles.c:158
avstring.h
av_bprint_chars
void av_bprint_chars(AVBPrint *buf, char c, unsigned n)
Append char c n times to a print buffer.
Definition: bprint.c:139
ff_smil_get_attr_ptr
const char * ff_smil_get_attr_ptr(const char *s, const char *attr)
SMIL helper to point on the value of an attribute in the given tag.
Definition: subtitles.c:360
avio_feof
int avio_feof(AVIOContext *s)
Similar to feof() but also returns nonzero on read errors.
Definition: aviobuf.c:354