1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
|
/*
* copyright (c) 2001 Fabrice Bellard
*
* This file is part of FFmpeg.
*
* FFmpeg 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.
*
* FFmpeg 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 FFmpeg; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
#ifndef AVFORMAT_INTERNAL_H
#define AVFORMAT_INTERNAL_H
#include <stdint.h>
#include "avformat.h"
#define MAX_URL_SIZE 4096
typedef struct AVCodecTag {
enum CodecID id;
unsigned int tag;
} AVCodecTag;
void ff_dynarray_add(intptr_t **tab_ptr, int *nb_ptr, intptr_t elem);
#ifdef __GNUC__
#define dynarray_add(tab, nb_ptr, elem)\
do {\
__typeof__(tab) _tab = (tab);\
__typeof__(elem) _elem = (elem);\
(void)sizeof(**_tab == _elem); /* check that types are compatible */\
ff_dynarray_add((intptr_t **)_tab, nb_ptr, (intptr_t)_elem);\
} while(0)
#else
#define dynarray_add(tab, nb_ptr, elem)\
do {\
ff_dynarray_add((intptr_t **)(tab), nb_ptr, (intptr_t)(elem));\
} while(0)
#endif
time_t mktimegm(struct tm *tm);
struct tm *brktimegm(time_t secs, struct tm *tm);
const char *small_strptime(const char *p, const char *fmt,
struct tm *dt);
char *ff_data_to_hex(char *buf, const uint8_t *src, int size, int lowercase);
/**
* Parse a string of hexadecimal strings. Any space between the hexadecimal
* digits is ignored.
*
* @param data if non-null, the parsed data is written to this pointer
* @param p the string to parse
* @return the number of bytes written (or to be written, if data is null)
*/
int ff_hex_to_data(uint8_t *data, const char *p);
void ff_program_add_stream_index(AVFormatContext *ac, int progid, unsigned int idx);
/**
* Add packet to AVFormatContext->packet_buffer list, determining its
* interleaved position using compare() function argument.
*/
void ff_interleave_add_packet(AVFormatContext *s, AVPacket *pkt,
int (*compare)(AVFormatContext *, AVPacket *, AVPacket *));
void ff_read_frame_flush(AVFormatContext *s);
#define NTP_OFFSET 2208988800ULL
#define NTP_OFFSET_US (NTP_OFFSET * 1000000ULL)
/** Get the current time since NTP epoch in microseconds. */
uint64_t ff_ntp_time(void);
/**
* Probe a bytestream to determine the input format. Each time a probe returns
* with a score that is too low, the probe buffer size is increased and another
* attempt is made. When the maximum probe size is reached, the input format
* with the highest score is returned.
*
* @param pb the bytestream to probe, it may be closed and opened again
* @param fmt the input format is put here
* @param filename the filename of the stream
* @param logctx the log context
* @param offset the offset within the bytestream to probe from
* @param max_probe_size the maximum probe buffer size (zero for default)
* @return 0 in case of success, a negative value corresponding to an
* AVERROR code otherwise
*/
int ff_probe_input_buffer(ByteIOContext **pb, AVInputFormat **fmt,
const char *filename, void *logctx,
unsigned int offset, unsigned int max_probe_size);
#if LIBAVFORMAT_VERSION_MAJOR < 53
/**
* @deprecated use av_url_split() instead
*/
void ff_url_split(char *proto, int proto_size,
char *authorization, int authorization_size,
char *hostname, int hostname_size,
int *port_ptr,
char *path, int path_size,
const char *url);
#endif
/**
* Assemble a URL string from components. This is the reverse operation
* of av_url_split.
*
* Note, this requires networking to be initialized, so the caller must
* ensure ff_network_init has been called.
*
* @see av_url_split
*
* @param str the buffer to fill with the url
* @param size the size of the str buffer
* @param proto the protocol identifier, if null, the separator
* after the identifier is left out, too
* @param authorization an optional authorization string, may be null.
* An empty string is treated the same as a null string.
* @param hostname the host name string
* @param port the port number, left out from the string if negative
* @param fmt a generic format string for everything to add after the
* host/port, may be null
* @return the number of characters written to the destination buffer
*/
int ff_url_join(char *str, int size, const char *proto,
const char *authorization, const char *hostname,
int port, const char *fmt, ...);
/**
* Append the media-specific SDP fragment for the media stream c
* to the buffer buff.
*
* Note, the buffer needs to be initialized, since it is appended to
* existing content.
*
* @param buff the buffer to append the SDP fragment to
* @param size the size of the buff buffer
* @param c the AVCodecContext of the media to describe
* @param dest_addr the destination address of the media stream, may be NULL
* @param dest_type the destination address type, may be NULL
* @param port the destination port of the media stream, 0 if unknown
* @param ttl the time to live of the stream, 0 if not multicast
*/
void ff_sdp_write_media(char *buff, int size, AVCodecContext *c,
const char *dest_addr, const char *dest_type,
int port, int ttl);
/**
* Write a packet to another muxer than the one the user originally
* intended. Useful when chaining muxers, where one muxer internally
* writes a received packet to another muxer.
*
* @param dst the muxer to write the packet to
* @param dst_stream the stream index within dst to write the packet to
* @param pkt the packet to be written
* @param src the muxer the packet originally was intended for
* @return the value av_write_frame returned
*/
int ff_write_chained(AVFormatContext *dst, int dst_stream, AVPacket *pkt,
AVFormatContext *src);
/**
* Get the length in bytes which is needed to store val as v.
*/
int ff_get_v_length(uint64_t val);
/**
* Put val using a variable number of bytes.
*/
void ff_put_v(ByteIOContext *bc, uint64_t val);
/**
* Read a whole line of text from ByteIOContext. Stop reading after reaching
* either a \n, a \0 or EOF. The returned string is always \0 terminated,
* and may be truncated if the buffer is too small.
*
* @param s the read-only ByteIOContext
* @param buf buffer to store the read line
* @param maxlen size of the buffer
* @return the length of the string written in the buffer, not including the
* final \0
*/
int ff_get_line(ByteIOContext *s, char *buf, int maxlen);
#define SPACE_CHARS " \t\r\n"
/**
* Callback function type for ff_parse_key_value.
*
* @param key a pointer to the key
* @param key_len the number of bytes that belong to the key, including the '='
* char
* @param dest return the destination pointer for the value in *dest, may
* be null to ignore the value
* @param dest_len the length of the *dest buffer
*/
typedef void (*ff_parse_key_val_cb)(void *context, const char *key,
int key_len, char **dest, int *dest_len);
/**
* Parse a string with comma-separated key=value pairs. The value strings
* may be quoted and may contain escaped characters within quoted strings.
*
* @param str the string to parse
* @param callback_get_buf function that returns where to store the
* unescaped value string.
* @param context the opaque context pointer to pass to callback_get_buf
*/
void ff_parse_key_value(const char *str, ff_parse_key_val_cb callback_get_buf,
void *context);
#endif /* AVFORMAT_INTERNAL_H */
|
