static int asfrtp_parse_sdp_line(AVFormatContext *s, int stream_index, PayloadContext *asf, const char *line) { if (stream_index < 0) return 0; if (av_strstart(line, "stream:", &line)) { RTSPState *rt = s->priv_data; s->streams[stream_index]->id = strtol(line, NULL, 10); if (rt->asf_ctx) { int i; for (i = 0; i < rt->asf_ctx->nb_streams; i++) { if (s->streams[stream_index]->id == rt->asf_ctx->streams[i]->id) { *s->streams[stream_index]->codec = *rt->asf_ctx->streams[i]->codec; rt->asf_ctx->streams[i]->codec->extradata_size = 0; rt->asf_ctx->streams[i]->codec->extradata = NULL; avpriv_set_pts_info(s->streams[stream_index], 32, 1, 1000); } } } } return 0; }
int ff_wms_parse_sdp_a_line(AVFormatContext *s, const char *p) { int ret = 0; if (av_strstart(p, "pgmpu:data:application/vnd.ms.wms-hdr.asfv1;base64,", &p)) { AVIOContext pb; RTSPState *rt = s->priv_data; AVDictionary *opts = NULL; int len = strlen(p) * 6 / 8; char *buf = av_mallocz(len); av_base64_decode(buf, p, len); if (rtp_asf_fix_header(buf, len) < 0) av_log(s, AV_LOG_ERROR, "Failed to fix invalid RTSP-MS/ASF min_pktsize\n"); init_packetizer(&pb, buf, len); if (rt->asf_ctx) { avformat_close_input(&rt->asf_ctx); } if (!(rt->asf_ctx = avformat_alloc_context())) return AVERROR(ENOMEM); rt->asf_ctx->pb = &pb; av_dict_set(&opts, "no_resync_search", "1", 0); ret = avformat_open_input(&rt->asf_ctx, "", &ff_asf_demuxer, &opts); av_dict_free(&opts); if (ret < 0) return ret; av_dict_copy(&s->metadata, rt->asf_ctx->metadata, 0); rt->asf_pb_pos = avio_tell(&pb); av_free(buf); rt->asf_ctx->pb = NULL; } return ret; }
int ff_wms_parse_sdp_a_line(AVFormatContext *s, const char *p) { int ret = 0; if (av_strstart(p, "pgmpu:data:application/vnd.ms.wms-hdr.asfv1;base64,", &p)) { AVIOContext pb; RTSPState *rt = s->priv_data; int len = strlen(p) * 6 / 8; char *buf = av_mallocz(len); av_base64_decode(buf, p, len); if (rtp_asf_fix_header(buf, len) < 0) av_log(s, AV_LOG_ERROR, "Failed to fix invalid RTSP-MS/ASF min_pktsize\n"); init_packetizer(&pb, buf, len); if (rt->asf_ctx) { av_close_input_stream(rt->asf_ctx); rt->asf_ctx = NULL; } ret = av_open_input_stream(&rt->asf_ctx, &pb, "", &ff_asf_demuxer, NULL); if (ret < 0) return ret; av_metadata_copy(&s->metadata, rt->asf_ctx->metadata, 0); rt->asf_pb_pos = avio_tell(&pb); av_free(buf); rt->asf_ctx->pb = NULL; } return ret; }
static int cache_open(URLContext *h, const char *arg, int flags) { int ret; Context *c= (Context*)h->priv_data; c->local_buffer_path = getLocalCachePath(h); if(!c->local_buffer_path){ c->fd = -1; return -1; } av_strstart(arg, "ucache:", &arg); av_log(h, AV_LOG_INFO, "cache_open:local_buffer_path:%s\n",c->local_buffer_path); c->fd = open(c->local_buffer_path, O_RDWR | O_CREAT | O_TRUNC, 0666); if (c->fd < 0){ av_log(h, AV_LOG_ERROR, "ucache_protocol.cache_open:Failed to create tempfile\n"); //return c->fd; } ret = ffurl_open(&c->inner, arg, flags, &h->interrupt_callback, NULL); if(ret && c->fd >= 0){ //删除文件 close(c->fd); c->fd = -1; unlink(c->local_buffer_path); } return ret; }
static int file_open(URLContext *h, const char *filename, int flags) { FileContext *c = h->priv_data; int access; int fd; struct stat st; av_strstart(filename, "file:", &filename); if (flags & AVIO_FLAG_WRITE && flags & AVIO_FLAG_READ) { access = O_CREAT | O_RDWR; if (c->trunc) access |= O_TRUNC; } else if (flags & AVIO_FLAG_WRITE) { access = O_CREAT | O_WRONLY; if (c->trunc) access |= O_TRUNC; } else { access = O_RDONLY; } #ifdef O_BINARY access |= O_BINARY; #endif fd = avpriv_open(filename, access, 0666); if (fd == -1) return AVERROR(errno); c->fd = fd; h->is_streamed = !fstat(fd, &st) && S_ISFIFO(st.st_mode); return 0; }
static int file_check(URLContext *h, int mask) { int ret = 0; const char *filename = h->filename; av_strstart(filename, "file:", &filename); { #if HAVE_ACCESS && defined(R_OK) if (access(filename, F_OK) < 0) return AVERROR(errno); if (mask&AVIO_FLAG_READ) if (access(filename, R_OK) >= 0) ret |= AVIO_FLAG_READ; if (mask&AVIO_FLAG_WRITE) if (access(filename, W_OK) >= 0) ret |= AVIO_FLAG_WRITE; #else struct stat st; ret = stat(filename, &st); if (ret < 0) return AVERROR(errno); ret |= st.st_mode&S_IRUSR ? mask&AVIO_FLAG_READ : 0; ret |= st.st_mode&S_IWUSR ? mask&AVIO_FLAG_WRITE : 0; #endif } return ret; }
static int file_move(URLContext *h_src, URLContext *h_dst) { #if HAVE_UNISTD_H const char *filename_src = h_src->filename; const char *filename_dst = h_dst->filename; av_strstart(filename_src, "file:", &filename_src); av_strstart(filename_dst, "file:", &filename_src); if (rename(filename_src, filename_dst) < 0) return AVERROR(errno); return 0; #else return AVERROR(ENOSYS); #endif /* HAVE_UNISTD_H */ }
static int md5_close(URLContext *h) { struct MD5Context *c = h->priv_data; const char *filename = h->filename; uint8_t md5[16], buf[64]; URLContext *out; int i, err = 0; av_md5_final(c->md5, md5); for (i = 0; i < sizeof(md5); i++) snprintf(buf + i*2, 3, "%02x", md5[i]); buf[i*2] = '\n'; av_strstart(filename, "md5:", &filename); if (*filename) { err = ffurl_open_whitelist(&out, filename, AVIO_FLAG_WRITE, &h->interrupt_callback, NULL, h->protocol_whitelist, h->protocol_blacklist); if (err) return err; err = ffurl_write(out, buf, i*2+1); ffurl_close(out); } else { if (fwrite(buf, 1, i*2+1, stdout) < i*2+1) err = AVERROR(errno); } av_freep(&c->md5); return err; }
static int amr_parse_sdp_line(AVFormatContext *s, int st_index, PayloadContext *data, const char *line) { const char *p; int ret; if (st_index < 0) return 0; /* Parse an fmtp line this one: * a=fmtp:97 octet-align=1; interleaving=0 * That is, a normal fmtp: line followed by semicolon & space * separated key/value pairs. */ if (av_strstart(line, "fmtp:", &p)) { ret = ff_parse_fmtp(s, s->streams[st_index], data, p, amr_parse_fmtp); if (!data->octet_align || data->crc || data->interleaving || data->channels != 1) { av_log(s, AV_LOG_ERROR, "Unsupported RTP/AMR configuration!\n"); return -1; } return ret; } return 0; }
static int md5_close(URLContext *h) { const char *filename = h->filename; uint8_t md5[16], buf[64]; URLContext *out; int i, err = 0; av_md5_final(h->priv_data, md5); for (i = 0; i < sizeof(md5); i++) snprintf(buf + i*2, 3, "%02x", md5[i]); buf[i*2] = '\n'; av_strstart(filename, "md5:", &filename); if (*filename) { err = url_open(&out, filename, URL_WRONLY); if (err) return err; err = url_write(out, buf, i*2+1); url_close(out); } else { if (fwrite(buf, 1, i*2+1, stdout) < i*2+1) err = AVERROR(errno); } return err; }
static int http_open_cnx_internal(URLContext *h, AVDictionary **options) { const char *path, *proxy_path, *lower_proto = "tcp", *local_path; char hostname[1024], hoststr[1024], proto[10]; char auth[1024], proxyauth[1024] = ""; char path1[MAX_URL_SIZE]; char buf[1024], urlbuf[MAX_URL_SIZE]; int port, use_proxy, err, location_changed = 0; HTTPContext *s = h->priv_data; av_url_split(proto, sizeof(proto), auth, sizeof(auth), hostname, sizeof(hostname), &port, path1, sizeof(path1), s->location); ff_url_join(hoststr, sizeof(hoststr), NULL, NULL, hostname, port, NULL); proxy_path = getenv("http_proxy"); use_proxy = !ff_http_match_no_proxy(getenv("no_proxy"), hostname) && proxy_path && av_strstart(proxy_path, "http://", NULL); if (!strcmp(proto, "https")) { lower_proto = "tls"; use_proxy = 0; if (port < 0) port = 443; } if (port < 0) port = 80; if (path1[0] == '\0') path = "/"; else path = path1; local_path = path; if (use_proxy) { /* Reassemble the request URL without auth string - we don't * want to leak the auth to the proxy. */ ff_url_join(urlbuf, sizeof(urlbuf), proto, NULL, hostname, port, "%s", path1); path = urlbuf; av_url_split(NULL, 0, proxyauth, sizeof(proxyauth), hostname, sizeof(hostname), &port, NULL, 0, proxy_path); } ff_url_join(buf, sizeof(buf), lower_proto, NULL, hostname, port, NULL); if (!s->hd) { err = ffurl_open(&s->hd, buf, AVIO_FLAG_READ_WRITE, &h->interrupt_callback, options); if (err < 0) return err; } err = http_connect(h, path, local_path, hoststr, auth, proxyauth, &location_changed); if (err < 0) return err; return location_changed; }
static int file_open(URLContext *h, const char *filename, int flags) { int access; int fd; av_strstart(filename, "file:", &filename); if (flags & URL_RDWR) { access = O_CREAT | O_TRUNC | O_RDWR; } else if (flags & URL_WRONLY) { access = O_CREAT | O_TRUNC | O_WRONLY; } else { access = O_RDONLY; } #ifdef O_BINARY access |= O_BINARY; #endif #ifdef __MINGW32__ // Check for UTF-8 unicode pathname int strl = strlen(filename); wchar_t* wfilename = av_malloc(sizeof(wchar_t) * (1 + strl)); int wpos = 0; int i = 0; for (i = 0; i < strl; i++) { wfilename[wpos] = 0; if ((filename[i] & 0x80) == 0) { // ASCII character wfilename[wpos++] = filename[i]; } else if (i + 1 < strl && ((filename[i] & 0xE0) == 0xC0) && ((filename[i + 1] & 0xC0) == 0x80)) { // two octets for this character wfilename[wpos++] = ((filename[i] & 0x1F) << 6) + (filename[i + 1] & 0x3F); i++; } else if (i + 2 < strl && ((filename[i] & 0xF0) == 0xE0) && ((filename[i + 1] & 0xC0) == 0x80) && ((filename[i + 2] & 0xC0) == 0x80)) { // three octets for this character wfilename[wpos++] = ((filename[i] & 0x0F) << 12) + ((filename[i + 1] & 0x3F) << 6) + (filename[i + 2] & 0x3F); i+=2; } else wfilename[wpos++] = filename[i]; } wfilename[wpos] = 0; fd = _wopen(wfilename, access, 0666); av_free(wfilename); #else fd = open(filename, access, 0666); #endif if (fd == -1) return AVERROR(errno); h->priv_data = (void *) (intptr_t) fd; return 0; }
static av_cold int data_open(URLContext *h, const char *uri, int flags) { DataContext *dc = h->priv_data; const char *data, *opt, *next; char *ddata; int ret, base64 = 0; size_t in_size; /* data:content/type[;base64],payload */ av_strstart(uri, "data:", &uri); data = strchr(uri, ','); if (!data) { av_log(h, AV_LOG_ERROR, "No ',' delimiter in URI\n"); return AVERROR(EINVAL); } opt = uri; while (opt < data) { next = av_x_if_null(memchr(opt, ';', data - opt), data); if (opt == uri) { if (!memchr(opt, '/', next - opt)) { /* basic validity check */ av_log(h, AV_LOG_ERROR, "Invalid content-type '%.*s'\n", (int)(next - opt), opt); return AVERROR(EINVAL); } av_log(h, AV_LOG_VERBOSE, "Content-type: %.*s\n", (int)(next - opt), opt); } else { if (!av_strncasecmp(opt, "base64", next - opt)) { base64 = 1; } else { av_log(h, AV_LOG_VERBOSE, "Ignoring option '%.*s'\n", (int)(next - opt), opt); } } opt = next + 1; } data++; in_size = strlen(data); if (base64) { size_t out_size = 3 * (in_size / 4) + 1; if (out_size > INT_MAX || !(ddata = av_malloc(out_size))) return AVERROR(ENOMEM); if ((ret = av_base64_decode(ddata, data, out_size)) < 0) { av_free(ddata); av_log(h, AV_LOG_ERROR, "Invalid base64 in URI\n"); return ret; } dc->data = dc->tofree = ddata; dc->size = ret; } else { dc->data = data; dc->size = in_size; } return 0; }
void ff_real_parse_sdp_a_line (AVFormatContext *s, int stream_index, const char *line) { const char *p = line; if (av_strstart(p, "ASMRuleBook:string;", &p)) real_parse_asm_rulebook(s, s->streams[stream_index], p); }
static int latm_parse_sdp_line(AVFormatContext *s, int st_index, PayloadContext *data, const char *line) { const char *p; if (av_strstart(line, "fmtp:", &p)) return ff_parse_fmtp(s->streams[st_index], data, p, parse_fmtp); return 0; }
static int rdt_parse_sdp_line (AVFormatContext *s, int st_index, PayloadContext *rdt, const char *line) { AVStream *stream = s->streams[st_index]; const char *p = line; if (av_strstart(p, "OpaqueData:buffer;", &p)) { rdt->mlti_data = rdt_parse_b64buf(&rdt->mlti_data_size, p); } else if (av_strstart(p, "StartTime:integer;", &p)) stream->first_dts = atoi(p); else if (av_strstart(p, "ASMRuleBook:string;", &p)) { int n, first = -1; for (n = 0; n < (int)s->nb_streams; n++) if (s->streams[n]->id == stream->id) { int count = s->streams[n]->index + 1; if (first == -1) first = n; if (rdt->nb_rmst < count) { RMStream **rmst= av_realloc(rdt->rmst, count*sizeof(*rmst)); if (!rmst) return AVERROR(ENOMEM); memset(rmst + rdt->nb_rmst, 0, (count - rdt->nb_rmst) * sizeof(*rmst)); rdt->rmst = rmst; rdt->nb_rmst = count; } rdt->rmst[s->streams[n]->index] = ff_rm_alloc_rmstream(); rdt_load_mdpr(rdt, s->streams[n], (n - first) * 2); if (s->streams[n]->codec->codec_id == CODEC_ID_AAC) s->streams[n]->codec->frame_size = 1; // FIXME } } return 0; }
static int crypto_open(URLContext *h, const char *uri, int flags) { const char *nested_url; int ret = 0; CryptoContext *c = h->priv_data; if (!av_strstart(uri, "crypto+", &nested_url) && !av_strstart(uri, "crypto:", &nested_url)) { av_log(h, AV_LOG_ERROR, "Unsupported url %s\n", uri); ret = AVERROR(EINVAL); goto err; } if (c->keylen < BLOCKSIZE || c->ivlen < BLOCKSIZE) { av_log(h, AV_LOG_ERROR, "Key or IV not set\n"); ret = AVERROR(EINVAL); goto err; } if (flags & AVIO_FLAG_WRITE) { av_log(h, AV_LOG_ERROR, "Only decryption is supported currently\n"); ret = AVERROR(ENOSYS); goto err; } if ((ret = ffurl_open(&c->hd, nested_url, AVIO_FLAG_READ, &h->interrupt_callback, NULL, h->protocols, h)) < 0) { av_log(h, AV_LOG_ERROR, "Unable to open input\n"); goto err; } c->aes = av_aes_alloc(); if (!c->aes) { ret = AVERROR(ENOMEM); goto err; } av_aes_init(c->aes, c->key, 128, 1); h->is_streamed = 1; err: return ret; }
static int parse_h264_sdp_line(AVFormatContext *s, int st_index, PayloadContext *h264_data, const char *line) { AVStream *stream; const char *p = line; if (st_index < 0) return 0; stream = s->streams[st_index]; if (av_strstart(p, "framesize:", &p)) { ff_h264_parse_framesize(stream->codecpar, p); } else if (av_strstart(p, "fmtp:", &p)) { return ff_parse_fmtp(s, stream, h264_data, p, sdp_parse_fmtp_config_h264); } else if (av_strstart(p, "cliprect:", &p)) { // could use this if we wanted. } return 0; }
static void make_absolute_url(char *buf, int size, const char *base, const char *rel) { char *sep; /* Absolute path, relative to the current server */ if (base && strstr(base, "://") && rel[0] == '/') { if (base != buf) av_strlcpy(buf, base, size); sep = strstr(buf, "://"); if (sep) { sep += 3; sep = strchr(sep, '/'); if (sep) *sep = '\0'; } av_strlcat(buf, rel, size); return; } /* If rel actually is an absolute url, just copy it */ if (!base || strstr(rel, "://") || rel[0] == '/') { av_strlcpy(buf, rel, size); return; } if (base != buf) av_strlcpy(buf, base, size); /* Remove the file name from the base url */ sep = strrchr(buf, '/'); if (sep) sep[1] = '\0'; else buf[0] = '\0'; while (av_strstart(rel, "../", NULL) && sep) { /* Remove the path delimiter at the end */ sep[0] = '\0'; sep = strrchr(buf, '/'); /* If the next directory name to pop off is "..", break here */ if (!strcmp(sep ? &sep[1] : buf, "..")) { /* Readd the slash we just removed */ av_strlcat(buf, "/", size); break; } /* Cut off the directory name */ if (sep) sep[1] = '\0'; else buf[0] = '\0'; rel += 3; } av_strlcat(buf, rel, size); }
int ff_tls_open_underlying(TLSShared *c, URLContext *parent, const char *uri, AVDictionary **options) { int port; const char *p; char buf[200], opts[50] = ""; struct addrinfo hints = { 0 }, *ai = NULL; const char *proxy_path; int use_proxy; if (c->listen) snprintf(opts, sizeof(opts), "?listen=1"); av_url_split(NULL, 0, NULL, 0, c->host, sizeof(c->host), &port, NULL, 0, uri); p = strchr(uri, '?'); if (!p) { p = opts; } else { if (av_find_info_tag(opts, sizeof(opts), "listen", p)) c->listen = 1; } ff_url_join(buf, sizeof(buf), "tcp", NULL, c->host, port, "%s", p); hints.ai_flags = AI_NUMERICHOST; if (!getaddrinfo(c->host, NULL, &hints, &ai)) { c->numerichost = 1; freeaddrinfo(ai); } proxy_path = getenv("http_proxy"); use_proxy = !ff_http_match_no_proxy(getenv("no_proxy"), c->host) && proxy_path && av_strstart(proxy_path, "http://", NULL); if (use_proxy) { char proxy_host[200], proxy_auth[200], dest[200]; int proxy_port; av_url_split(NULL, 0, proxy_auth, sizeof(proxy_auth), proxy_host, sizeof(proxy_host), &proxy_port, NULL, 0, proxy_path); ff_url_join(dest, sizeof(dest), NULL, NULL, c->host, port, NULL); ff_url_join(buf, sizeof(buf), "httpproxy", proxy_auth, proxy_host, proxy_port, "/%s", dest); } return ffurl_open(&c->tcp, buf, AVIO_FLAG_READ_WRITE, &parent->interrupt_callback, options, parent->protocols, parent); }
int ffurl_alloc(URLContext **puc, const char *filename, int flags, const AVIOInterruptCB *int_cb) { const URLProtocol *p = NULL; p = url_find_protocol(filename); if (p) return url_alloc_for_protocol(puc, p, filename, flags, int_cb); *puc = NULL; if (av_strstart(filename, "https:", NULL)) av_log(NULL, AV_LOG_WARNING, "https protocol not found, recompile FFmpeg with " "openssl, gnutls " "or securetransport enabled.\n"); return AVERROR_PROTOCOL_NOT_FOUND; }
static int sdp_probe(AVProbeData *p1) { const char *p = p1->buf, *p_end = p1->buf + p1->buf_size; /* we look for a line beginning "c=IN IP4" */ while (p < p_end && *p != '\0') { if (p + sizeof("c=IN IP4") - 1 < p_end && av_strstart(p, "c=IN IP4", NULL)) return AVPROBE_SCORE_MAX / 2; while(p < p_end - 1 && *p != '\n') p++; if (++p >= p_end) break; if (*p == '\r') p++; } return 0; }
static int file_delete(URLContext *h) { #if HAVE_UNISTD_H int ret; const char *filename = h->filename; av_strstart(filename, "file:", &filename); ret = rmdir(filename); if (ret < 0 && errno == ENOTDIR) ret = unlink(filename); if (ret < 0) return AVERROR(errno); return ret; #else return AVERROR(ENOSYS); #endif /* HAVE_UNISTD_H */ }
static int cache_open(URLContext *h, const char *arg, int flags) { const char *buffername; Context *c= (Context *)h->priv_data; av_strstart(arg, "cache:", &arg); c->fd = av_tempfile("ffcache", (char **)&buffername, 0, h); if (c->fd < 0){ av_log(h, AV_LOG_ERROR, "Failed to create tempfile\n"); return c->fd; } unlink(buffername); av_freep(&buffername); return ffurl_open(&c->inner, arg, flags, &h->interrupt_callback, NULL); }
static int file_open(URLContext * h, const char *filename, int flags) { BVFileContext *c = h->priv_data; int access; int bvfs_handle; struct stat st; av_strstart(filename, "bvfs:", &filename); if (flags & AVIO_FLAG_WRITE) { access = O_CREAT | O_WRONLY; } else { access = O_RDONLY; } c->bvfs_handle = bvfs_handle; return 0; }
static int pipe_open(URLContext *h, const char *filename, int flags) { int fd; char *final; av_strstart(filename, "pipe:", &filename); fd = strtol(filename, &final, 10); if((filename == final) || *final ) {/* No digits found, or something like 10ab */ if (flags & URL_WRONLY) { fd = 1; } else { fd = 0; } } #if HAVE_SETMODE setmode(fd, O_BINARY); #endif h->priv_data = (void *) (intptr_t) fd; h->is_streamed = 1; return 0; }
static int ilbc_parse_sdp_line(AVFormatContext *s, int st_index, PayloadContext *data, const char *line) { const char *p; AVStream *st; if (st_index < 0) return 0; st = s->streams[st_index]; if (av_strstart(line, "fmtp:", &p)) { int ret = ff_parse_fmtp(st, data, p, ilbc_parse_fmtp); if (ret < 0) return ret; if (!st->codec->block_align) { av_log(s, AV_LOG_ERROR, "No iLBC mode set\n"); return AVERROR(EINVAL); } } return 0; }
static int unix_open(URLContext *h, const char *filename, int flags) { UnixContext *s = h->priv_data; int fd, ret; av_strstart(filename, "unix:", &filename); s->addr.sun_family = AF_UNIX; av_strlcpy(s->addr.sun_path, filename, sizeof(s->addr.sun_path)); if ((fd = ff_socket(AF_UNIX, s->type, 0)) < 0) return ff_neterrno(); if (s->timeout < 0 && h->rw_timeout) s->timeout = h->rw_timeout / 1000; if (s->listen) { ret = ff_listen_bind(fd, (struct sockaddr *)&s->addr, sizeof(s->addr), s->timeout, h); if (ret < 0) goto fail; fd = ret; } else { ret = ff_listen_connect(fd, (struct sockaddr *)&s->addr, sizeof(s->addr), s->timeout, h, 0); if (ret < 0) goto fail; } s->fd = fd; return 0; fail: if (s->listen && AVUNERROR(ret) != EADDRINUSE) unlink(s->addr.sun_path); if (fd >= 0) closesocket(fd); return ret; }
static int pipe_open(URLContext *h, const char *filename, int flags) { FileContext *c = h->priv_data; int fd; char *final; av_strstart(filename, "pipe:", &filename); fd = strtol(filename, &final, 10); if((filename == final) || *final ) {/* No digits found, or something like 10ab */ if (flags & AVIO_FLAG_WRITE) { fd = 1; } else { fd = 0; } } #if HAVE_SETMODE setmode(fd, O_BINARY); #endif c->fd = fd; h->is_streamed = 1; return 0; }
static int ffms_lavf_file_open(URLContext *h, const char *filename, int flags) { int access; int fd; av_strstart(filename, "file:", &filename); if (flags & URL_RDWR) { access = _O_CREAT | _O_TRUNC | _O_RDWR; } else if (flags & URL_WRONLY) { access = _O_CREAT | _O_TRUNC | _O_WRONLY; } else { access = _O_RDONLY; } #ifdef _O_BINARY access |= _O_BINARY; #endif fd = ffms_wchar_open(filename, access, 0666); if (fd == -1) return AVERROR(ENOENT); h->priv_data = (void *) (intptr_t) fd; return 0; }