30 #define MAX_BUFFER_BLOCKS 257 63 #define OFFSET(x) offsetof(CryptoContext, x) 64 #define D AV_OPT_FLAG_DECODING_PARAM 65 #define E AV_OPT_FLAG_ENCODING_PARAM 84 uint8_t *default_buf,
int default_buf_len,
88 if (!default_buf_len) {
91 }
else if (default_buf_len !=
BLOCKSIZE) {
93 "invalid %s size (%d bytes, block size is %d)\n",
97 *buf =
av_memdup(default_buf, default_buf_len);
100 *buf_len = default_buf_len;
103 "invalid %s size (%d bytes, block size is %d)\n",
112 const char *nested_url;
126 c->
key, c->
keylen,
"decryption key")) < 0)
129 c->
iv, c->
ivlen,
"decryption IV")) < 0)
135 c->
key, c->
keylen,
"encryption key")) < 0)
139 c->
iv, c->
ivlen,
"encryption IV")) < 0)
150 if (flags & AVIO_FLAG_READ) {
165 if (flags & AVIO_FLAG_WRITE) {
190 memcpy(buf, c->
outptr, size);
241 "Crypto: seek not supported for write\r\n");
259 "Crypto: seek_end - can't get file size (pos=%lld)\r\n", (
long long int)pos);
268 "Crypto: no support for seek where 'whence' is %d\r\n", whence);
296 "Crypto: nested protocol no support for seek or seek failed\n");
317 char errbuf[100] =
"unknown error";
320 "Crypto: discard read did not get all the bytes (%d remain) - read returned (%d)-%s\n",
335 total_size = size + c->
pad_len;
337 out_size = total_size -
pad_len;
361 memcpy(c->
pad, &buf[size - pad_len], pad_len);
399 .priv_data_class = &crypto_class,
static int crypto_close(URLContext *h)
int ffurl_open_whitelist(URLContext **puc, const char *filename, int flags, const AVIOInterruptCB *int_cb, AVDictionary **options, const char *whitelist, const char *blacklist, URLContext *parent)
Create an URLContext for accessing to the resource indicated by url, and open it. ...
#define LIBAVUTIL_VERSION_INT
int ffurl_write(URLContext *h, const unsigned char *buf, int size)
Write size bytes from buf to the resource accessed by h.
int is_streamed
true if streamed (no seek possible), default = false
AVIOInterruptCB interrupt_callback
static int crypto_read(URLContext *h, uint8_t *buf, int size)
#define AVIO_FLAG_READ
read-only
const char * av_default_item_name(void *ptr)
Return the context name.
void av_aes_crypt(AVAES *a, uint8_t *dst, const uint8_t *src, int count, uint8_t *iv, int decrypt)
Encrypt or decrypt a buffer using a previously initialized context.
#define AVIO_FLAG_WRITE
write-only
static const AVOption options[]
unsigned int write_buf_size
uint8_t inbuffer[BLOCKSIZE *MAX_BUFFER_BLOCKS]
static int set_aes_arg(URLContext *h, uint8_t **buf, int *buf_len, uint8_t *default_buf, int default_buf_len, const char *desc)
uint8_t outbuffer[BLOCKSIZE *MAX_BUFFER_BLOCKS]
const char * class_name
The name of the class; usually it is the same name as the context structure type to which the AVClass...
The exact code depends on how similar the blocks are and how related they are to the block
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
#define AVERROR_EOF
End of file.
static int crypto_open2(URLContext *h, const char *uri, int flags, AVDictionary **options)
#define MAX_BUFFER_BLOCKS
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
struct AVAES * aes_decrypt
const char * protocol_whitelist
#define URL_PROTOCOL_FLAG_NESTED_SCHEME
struct AVAES * av_aes_alloc(void)
Allocate an AVAES context.
struct AVAES * aes_encrypt
void * av_memdup(const void *p, size_t size)
Duplicate a buffer with av_malloc().
void av_fast_malloc(void *ptr, unsigned int *size, size_t min_size)
Allocate a buffer, reusing the given one if large enough.
static const AVClass crypto_class
offset must point to a pointer immediately followed by an int for the length
int ffurl_closep(URLContext **hh)
Close the resource accessed by the URLContext h, and free the memory used by it.
int av_aes_init(AVAES *a, const uint8_t *key, int key_bits, int decrypt)
Initialize an AVAES context.
const char * protocol_blacklist
const URLProtocol ff_crypto_protocol
static int64_t crypto_seek(URLContext *h, int64_t pos, int whence)
Describe the class of an AVClass context structure.
static int crypto_write(URLContext *h, const unsigned char *buf, int size)
int av_strerror(int errnum, char *errbuf, size_t errbuf_size)
Put a description of the AVERROR code errnum in errbuf.
int av_strstart(const char *str, const char *pfx, const char **ptr)
Return non-zero if pfx is a prefix of str.
int64_t ffurl_seek(URLContext *h, int64_t pos, int whence)
Change the position that will be used by the next read/write operation on the resource accessed by h...
#define AVSEEK_SIZE
ORing this as the "whence" parameter to a seek function causes it to return the filesize without seek...
unbuffered private I/O API
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
int ffurl_read(URLContext *h, unsigned char *buf, int size)
Read up to size bytes from the resource accessed by h, and store the read bytes in buf...