void show_help_options(const OptionDef *options, const char *msg, int req_flags, int rej_flags, int alt_flags) { const OptionDef *po; int first; first = 1; for (po = options; po->name != NULL; po++) { char buf[64]; if (((po->flags & req_flags) != req_flags) || (alt_flags && !(po->flags & alt_flags)) || (po->flags & rej_flags)) continue; if (first) { printf("%s\n", msg); first = 0; } av_strlcpy(buf, po->name, sizeof(buf)); if (po->argname) { av_strlcat(buf, " ", sizeof(buf)); av_strlcat(buf, po->argname, sizeof(buf)); } printf("-%-17s %s\n", buf, po->help); } printf("\n"); }
void av_get_channel_layout_string(char *buf, int buf_size, int nb_channels, int64_t channel_layout) { int i; if (nb_channels <= 0) nb_channels = av_get_channel_layout_nb_channels(channel_layout); for (i = 0; channel_layout_map[i].name; i++) if (nb_channels == channel_layout_map[i].nb_channels && channel_layout == channel_layout_map[i].layout) { av_strlcpy(buf, channel_layout_map[i].name, buf_size); return; } snprintf(buf, buf_size, "%d channels", nb_channels); if (channel_layout) { int i,ch; av_strlcat(buf, " (", buf_size); for(i=0,ch=0; i<64; i++) { if ((channel_layout & (1L<<i))) { const char *name = get_channel_name(i); if (name) { if (ch>0) av_strlcat(buf, "|", buf_size); av_strlcat(buf, name, buf_size); } ch++; } } av_strlcat(buf, ")", buf_size); } }
static int rtsp_send_reply(AVFormatContext *s, enum RTSPStatusCode code, const char *extracontent, uint16_t seq) { RTSPState *rt = s->priv_data; char message[4096]; int index = 0; while (status_messages[index].code) { if (status_messages[index].code == code) { snprintf(message, sizeof(message), "RTSP/1.0 %d %s\r\n", code, status_messages[index].message); break; } index++; } if (!status_messages[index].code) return AVERROR(EINVAL); av_strlcatf(message, sizeof(message), "CSeq: %d\r\n", seq); av_strlcatf(message, sizeof(message), "Server: %s\r\n", LIBAVFORMAT_IDENT); if (extracontent) av_strlcat(message, extracontent, sizeof(message)); av_strlcat(message, "\r\n", sizeof(message)); av_dlog(s, "Sending response:\n%s", message); ffurl_write(rt->rtsp_hd, message, strlen(message)); return 0; }
/** * Open RTMP connection and verify that the stream can be played. * * URL syntax: rtmp://server[:port][/app][/playpath][ keyword=value]... * where 'app' is first one or two directories in the path * (e.g. /ondemand/, /flash/live/, etc.) * and 'playpath' is a file name (the rest of the path, * may be prefixed with "mp4:") * * Additional RTMP library options may be appended as * space-separated key-value pairs. */ static int rtmp_open(URLContext *s, const char *uri, int flags) { LibRTMPContext *ctx = s->priv_data; RTMP *r = &ctx->rtmp; int rc = 0, level; char *filename = s->filename; switch (av_log_get_level()) { default: case AV_LOG_FATAL: level = RTMP_LOGCRIT; break; case AV_LOG_ERROR: level = RTMP_LOGERROR; break; case AV_LOG_WARNING: level = RTMP_LOGWARNING; break; case AV_LOG_INFO: level = RTMP_LOGINFO; break; case AV_LOG_VERBOSE: level = RTMP_LOGDEBUG; break; case AV_LOG_DEBUG: level = RTMP_LOGDEBUG2; break; } RTMP_LogSetLevel(level); RTMP_LogSetCallback(rtmp_log); if (ctx->app || ctx->playpath) { int len = strlen(s->filename) + 1; if (ctx->app) len += strlen(ctx->app) + sizeof(" app="); if (ctx->playpath) len += strlen(ctx->playpath) + sizeof(" playpath="); if (!(filename = av_malloc(len))) return AVERROR(ENOMEM); av_strlcpy(filename, s->filename, len); if (ctx->app) { av_strlcat(filename, " app=", len); av_strlcat(filename, ctx->app, len); } if (ctx->playpath) { av_strlcat(filename, " playpath=", len); av_strlcat(filename, ctx->playpath, len); } } RTMP_Init(r); if (!RTMP_SetupURL(r, filename)) { rc = AVERROR_UNKNOWN; goto fail; } if (flags & AVIO_FLAG_WRITE) RTMP_EnableWrite(r); if (!RTMP_Connect(r, NULL) || !RTMP_ConnectStream(r, 0)) { rc = AVERROR_UNKNOWN; goto fail; } s->is_streamed = 1; rc = 0; fail: if (filename != s->filename) av_freep(&filename); return rc; }
int av_dict_set(AVDictionary **pm, const char *key, const char *value, int flags) { AVDictionary *m = *pm; AVDictionaryEntry *tag = av_dict_get(m, key, NULL, flags); char *oldval = NULL; if (!m) m = *pm = av_mallocz(sizeof(*m)); if (tag) { if (flags & AV_DICT_DONT_OVERWRITE) { if (flags & AV_DICT_DONT_STRDUP_KEY) av_free(key); if (flags & AV_DICT_DONT_STRDUP_VAL) av_free(value); return 0; } if (flags & AV_DICT_APPEND) oldval = tag->value; else av_free(tag->value); av_free(tag->key); *tag = m->elems[--m->count]; } else { AVDictionaryEntry *tmp = av_realloc(m->elems, (m->count + 1) * sizeof(*m->elems)); if (tmp) m->elems = tmp; else return AVERROR(ENOMEM); } if (value) { if (flags & AV_DICT_DONT_STRDUP_KEY) m->elems[m->count].key = (char*)(intptr_t)key; else m->elems[m->count].key = av_strdup(key); if (flags & AV_DICT_DONT_STRDUP_VAL) { m->elems[m->count].value = (char*)(intptr_t)value; } else if (oldval && flags & AV_DICT_APPEND) { int len = strlen(oldval) + strlen(value) + 1; char *newval = av_mallocz(len); if (!newval) return AVERROR(ENOMEM); av_strlcat(newval, oldval, len); av_freep(&oldval); av_strlcat(newval, value, len); m->elems[m->count].value = newval; } else m->elems[m->count].value = av_strdup(value); m->count++; } if (!m->count) { av_free(m->elems); av_freep(pm); } return 0; }
/** * @brief Build the skin file path for a skin name. * * @param dir skins directory * @param sname name of the skin * * @return skin file path * * @note As a side effect, variable #path gets set to the skin path. */ static char *setname(char *dir, char *sname) { static char skinfname[512]; av_strlcpy(skinfname, dir, sizeof(skinfname)); av_strlcat(skinfname, "/", sizeof(skinfname)); av_strlcat(skinfname, sname, sizeof(skinfname)); av_strlcat(skinfname, "/", sizeof(skinfname)); av_strlcpy(path, skinfname, sizeof(path)); av_strlcat(skinfname, "skin", sizeof(skinfname)); return skinfname; }
static av_printf_format(3, 4) void url_add_option(char *buf, int buf_size, const char *fmt, ...) { char buf1[1024]; va_list ap; va_start(ap, fmt); if (strchr(buf, '?')) av_strlcat(buf, "&", buf_size); else av_strlcat(buf, "?", buf_size); vsnprintf(buf1, sizeof(buf1), fmt, ap); av_strlcat(buf, buf1, buf_size); va_end(ap); }
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); }
/** * @brief Parse a @a selected definition. * * Syntax: selected=image * * @param in definition to be analyzed * * @return 0 (ok) or 1 (error) */ static int item_selected(char *in) { unsigned char file[512]; wItem *currItem; if (!window_item("selected")) return 1; if (in_window("main")) return 1; if (in_window("video")) return 1; if (in_window("playbar")) return 1; mp_msg(MSGT_GPLAYER, MSGL_DBG2, "[skin] image selected: %s\n", in); currItem = &skin->menuSelected; currItem->type = itBase; av_strlcpy(file, path, sizeof(file)); av_strlcat(file, in, sizeof(file)); if (skinImageRead(file, &currItem->Bitmap) != 0) return 1; currItem->width = currItem->Bitmap.Width; currItem->height = currItem->Bitmap.Height; mp_msg(MSGT_GPLAYER, MSGL_DBG2, "[skin] bitmap: %dx%d\n", currItem->width, currItem->height); return 0; }
char *ff_http_auth_create_response(HTTPAuthState *state, const char *auth, const char *path, const char *method) { char *authstr = NULL; if (!auth || !strchr(auth, ':')) return NULL; if (state->auth_type == HTTP_AUTH_BASIC) { int auth_b64_len = AV_BASE64_SIZE(strlen(auth)); int len = auth_b64_len + 30; char *ptr; authstr = av_malloc(len); if (!authstr) return NULL; snprintf(authstr, len, "Authorization: Basic "); ptr = authstr + strlen(authstr); av_base64_encode(ptr, auth_b64_len, auth, strlen(auth)); av_strlcat(ptr, "\r\n", len - (ptr - authstr)); } else if (state->auth_type == HTTP_AUTH_DIGEST) { char *username = av_strdup(auth), *password; if (!username) return NULL; if ((password = strchr(username, ':'))) { *password++ = 0; authstr = make_digest_auth(state, username, password, path, method); } av_free(username); } return authstr; }
int av_dict_set(AVDictionary **pm, const char *key, const char *value, int flags) { AVDictionary *m = *pm; AVDictionaryEntry *tag = av_dict_get(m, key, NULL, flags); char *oldval = NULL; int allocated = !!m; if (!m) m = *pm = av_mallocz(sizeof(*m)); if (!m) return AVERROR(ENOMEM); if (tag) { if (flags & AV_DICT_DONT_OVERWRITE) { if (flags & AV_DICT_DONT_STRDUP_KEY) av_free(key); if (flags & AV_DICT_DONT_STRDUP_VAL) av_free(value); return 0; } if (flags & AV_DICT_APPEND) oldval = tag->value; else av_free(tag->value); av_free(tag->key); *tag = m->elems[--m->count]; } else { int ret = av_reallocp_array(&m->elems, m->count + 1, sizeof(*m->elems)); if (ret < 0) { if (allocated) av_freep(pm); return ret; } } if (value) { if (flags & AV_DICT_DONT_STRDUP_KEY) m->elems[m->count].key = key; else m->elems[m->count].key = av_strdup(key); if (flags & AV_DICT_DONT_STRDUP_VAL) { m->elems[m->count].value = value; } else if (oldval && flags & AV_DICT_APPEND) { int len = strlen(oldval) + strlen(value) + 1; if (!(oldval = av_realloc(oldval, len))) return AVERROR(ENOMEM); av_strlcat(oldval, value, len); m->elems[m->count].value = oldval; } else m->elems[m->count].value = av_strdup(value); m->count++; } if (!m->count) { av_free(m->elems); av_freep(pm); } return 0; }
static int applehttp_open(URLContext *h, const char *uri, int flags) { AppleHTTPContext *s; int ret, i; const char *nested_url; if (flags & AVIO_FLAG_WRITE) return AVERROR(ENOSYS); s = av_mallocz(sizeof(AppleHTTPContext)); if (!s) return AVERROR(ENOMEM); h->priv_data = s; h->is_streamed = 1; if (av_strstart(uri, "applehttp+", &nested_url)) { av_strlcpy(s->playlisturl, nested_url, sizeof(s->playlisturl)); } else if (av_strstart(uri, "applehttp://", &nested_url)) { av_strlcpy(s->playlisturl, "http://", sizeof(s->playlisturl)); av_strlcat(s->playlisturl, nested_url, sizeof(s->playlisturl)); } else { av_log(h, AV_LOG_ERROR, "Unsupported url %s\n", uri); ret = AVERROR(EINVAL); goto fail; } if ((ret = parse_playlist(h, s->playlisturl)) < 0) goto fail; if (s->n_segments == 0 && s->n_variants > 0) { int max_bandwidth = 0, maxvar = -1; for (i = 0; i < s->n_variants; i++) { if (s->variants[i]->bandwidth > max_bandwidth || i == 0) { max_bandwidth = s->variants[i]->bandwidth; maxvar = i; } } av_strlcpy(s->playlisturl, s->variants[maxvar]->url, sizeof(s->playlisturl)); if ((ret = parse_playlist(h, s->playlisturl)) < 0) goto fail; } if (s->n_segments == 0) { av_log(h, AV_LOG_WARNING, "Empty playlist\n"); ret = AVERROR(EIO); goto fail; } s->cur_seq_no = s->start_seq_no; if (!s->finished && s->n_segments >= 3) s->cur_seq_no = s->start_seq_no + s->n_segments - 3; return 0; fail: av_free(s); return ret; }
int ff_url_join(char *str, int size, const char *proto, const char *authorization, const char *hostname, int port, const char *fmt, ...) { #if CONFIG_NETWORK struct addrinfo hints = { 0 }, *ai; #endif str[0] = '\0'; if (proto) av_strlcatf(str, size, "%s://", proto); if (authorization && authorization[0]) av_strlcatf(str, size, "%s@", authorization); #if CONFIG_NETWORK && defined(AF_INET6) /* Determine if hostname is a numerical IPv6 address, * properly escape it within [] in that case. */ hints.ai_flags = AI_NUMERICHOST; if (!getaddrinfo(hostname, NULL, &hints, &ai)) { if (ai->ai_family == AF_INET6) { av_strlcat(str, "[", size); av_strlcat(str, hostname, size); av_strlcat(str, "]", size); } else { av_strlcat(str, hostname, size); } freeaddrinfo(ai); } else #endif /* Not an IPv6 address, just output the plain string. */ av_strlcat(str, hostname, size); if (port >= 0) av_strlcatf(str, size, ":%d", port); if (fmt) { va_list vl; size_t len = strlen(str); va_start(vl, fmt); vsnprintf(str + len, size > len ? size - len : 0, fmt, vl); va_end(vl); } return strlen(str); }
static void plex_log_callback(void* ptr, int level, const char* fmt, va_list vl) { int print_prefix = 1; char line[1024]; va_list vl2; #if HAVE_PTHREADS char *cur_line; pthread_once(&key_once, make_keys); #else static __thread char cur_line[LOG_LINE_SIZE] = {0}; static __thread int logging = 0; #endif va_copy(vl2, vl); av_log_default_callback(ptr, level, fmt, vl2); if (level > av_log_level_plex) return; //Avoid recusive logging #if HAVE_PTHREADS if (pthread_getspecific(logging_key)) return; cur_line = pthread_getspecific(cur_line_key); if (!cur_line) { cur_line = av_mallocz(LOG_LINE_SIZE); if (!cur_line) return; pthread_setspecific(cur_line_key, cur_line); } pthread_setspecific(logging_key, (void*)1); #else if (logging) return; logging = 1; #endif av_log_format_line(ptr, level, fmt, vl, line, sizeof(line), &print_prefix); av_strlcat(cur_line, line, LOG_LINE_SIZE); if (print_prefix) { int len = strlen(cur_line); if (len) { cur_line[len - 1] = 0; PMS_Log(level < AV_LOG_ERROR ? LOG_LEVEL_ERROR : (level / 8) - 2, "%s", cur_line); cur_line[0] = 0; } } #if HAVE_PTHREADS pthread_setspecific(logging_key, NULL); #else logging = 0; #endif }
static int ffm_append_recommended_configuration(AVStream *st, char **conf) { int ret; size_t newsize; av_assert0(conf && st); if (!*conf) return 0; if (!st->recommended_encoder_configuration) { st->recommended_encoder_configuration = *conf; *conf = 0; return 0; } newsize = strlen(*conf) + strlen(st->recommended_encoder_configuration) + 2; if ((ret = av_reallocp(&st->recommended_encoder_configuration, newsize)) < 0) return ret; av_strlcat(st->recommended_encoder_configuration, ",", newsize); av_strlcat(st->recommended_encoder_configuration, *conf, newsize); av_freep(conf); return 0; }
static int trace_headers(AVBSFContext *bsf, AVPacket *out) { TraceHeadersContext *ctx = bsf->priv_data; CodedBitstreamFragment au; AVPacket *in; char tmp[256] = { 0 }; int err; err = ff_bsf_get_packet(bsf, &in); if (err < 0) return err; if (in->flags & AV_PKT_FLAG_KEY) av_strlcat(tmp, ", key frame", sizeof(tmp)); if (in->flags & AV_PKT_FLAG_CORRUPT) av_strlcat(tmp, ", corrupt", sizeof(tmp)); if (in->pts != AV_NOPTS_VALUE) av_strlcatf(tmp, sizeof(tmp), ", pts %"PRId64, in->pts); else av_strlcat(tmp, ", no pts", sizeof(tmp)); if (in->dts != AV_NOPTS_VALUE) av_strlcatf(tmp, sizeof(tmp), ", dts %"PRId64, in->dts); else av_strlcat(tmp, ", no dts", sizeof(tmp)); if (in->duration > 0) av_strlcatf(tmp, sizeof(tmp), ", duration %"PRId64, in->duration); av_log(bsf, AV_LOG_INFO, "Packet: %d bytes%s.\n", in->size, tmp); err = ff_cbs_read_packet(&ctx->cbc, &au, in); if (err < 0) return err; ff_cbs_fragment_uninit(&ctx->cbc, &au); av_packet_move_ref(out, in); av_packet_free(&in); return 0; }
static int hash_write_trailer(struct AVFormatContext *s) { struct HashContext *c = s->priv_data; char buf[256]; av_strlcpy(buf, av_hash_get_name(c->hash), sizeof(buf) - 200); av_strlcat(buf, "=", sizeof(buf) - 200); hash_finish(s, buf); av_hash_freep(&c->hash); return 0; }
void show_help_options(const OptionDef *options, const char *msg, int mask, int value) { const OptionDef *po; int first; first = 1; for(po = options; po->name != NULL; po++) { char buf[64]; if ((po->flags & mask) == value) { if (first) { printf("%s", msg); first = 0; } av_strlcpy(buf, po->name, sizeof(buf)); if (po->flags & HAS_ARG) { av_strlcat(buf, " ", sizeof(buf)); av_strlcat(buf, po->argname, sizeof(buf)); } printf("-%-17s %s\n", buf, po->help); } } }
static struct variant *new_variant(struct list_mgt *mgt, int bandwidth, const char *url, const char *base) { struct variant *var = av_mallocz(sizeof(struct variant)); if (!var) return NULL; var->bandwidth = bandwidth; if(base){ av_strlcpy(var->url, base, sizeof(var->url)); } av_strlcat(var->url, url, sizeof(var->url)); dynarray_add(&mgt->variants, &mgt->n_variants, var); return var; }
char *ff_http_auth_create_response(HTTPAuthState *state, const char *auth, const char *path, const char *method) { char *authstr = NULL; /* Clear the stale flag, we assume the auth is ok now. It is reset * by the server headers if there's a new issue. */ state->stale = 0; if (!auth || !strchr(auth, ':')) return NULL; if (state->auth_type == HTTP_AUTH_BASIC) { int auth_b64_len, len; char *ptr, *decoded_auth = ff_urldecode(auth); if (!decoded_auth) return NULL; auth_b64_len = AV_BASE64_SIZE(strlen(decoded_auth)); len = auth_b64_len + 30; authstr = av_malloc(len); if (!authstr) { av_free(decoded_auth); return NULL; } snprintf(authstr, len, "Authorization: Basic "); ptr = authstr + strlen(authstr); av_base64_encode(ptr, auth_b64_len, decoded_auth, strlen(decoded_auth)); av_strlcat(ptr, "\r\n", len - (ptr - authstr)); av_free(decoded_auth); } else if (state->auth_type == HTTP_AUTH_DIGEST) { char *username = ff_urldecode(auth), *password; if (!username) return NULL; if ((password = strchr(username, ':'))) { *password++ = 0; authstr = make_digest_auth(state, username, password, path, method); } av_free(username); } return authstr; }
static inline void TranslateFilename( int c,char * tmp,size_t tmplen ) { int i; char * p; switch ( guiIntfStruct.StreamType ) { case STREAMTYPE_STREAM: av_strlcpy(tmp, guiIntfStruct.Filename, tmplen); break; case STREAMTYPE_FILE: if ( ( guiIntfStruct.Filename )&&( guiIntfStruct.Filename[0] ) ) { if ( (p = strrchr(guiIntfStruct.Filename, '/')) ) av_strlcpy(tmp, p + 1, tmplen); else av_strlcpy(tmp, guiIntfStruct.Filename, tmplen); if ( tmp[strlen( tmp ) - 4] == '.' ) tmp[strlen( tmp ) - 4]=0; if ( tmp[strlen( tmp ) - 5] == '.' ) tmp[strlen( tmp ) - 5]=0; } else av_strlcpy( tmp,MSGTR_NoFileLoaded,tmplen ); break; #ifdef CONFIG_DVDREAD case STREAMTYPE_DVD: if ( guiIntfStruct.DVD.current_chapter ) snprintf(tmp,tmplen,MSGTR_Chapter,guiIntfStruct.DVD.current_chapter ); else av_strlcat( tmp,MSGTR_NoChapter,tmplen ); break; #endif #ifdef CONFIG_VCD case STREAMTYPE_VCD: snprintf( tmp,tmplen,MSGTR_VCDTrack,guiIntfStruct.Track ); break; #endif default: av_strlcpy( tmp,MSGTR_NoMediaOpened,tmplen ); } if ( c ) { for ( i=0;i < (int)strlen( tmp );i++ ) { int t=0; if ( c == 1 ) { if ( ( tmp[i] >= 'A' )&&( tmp[i] <= 'Z' ) ) t=32; } if ( c == 2 ) { if ( ( tmp[i] >= 'a' )&&( tmp[i] <= 'z' ) ) t=-32; } tmp[i]=(char)( tmp[i] + t ); } } }
int ff_rtsp_setup_input_streams(AVFormatContext *s, RTSPMessageHeader *reply) { RTSPState *rt = s->priv_data; char cmd[1024]; unsigned char *content = NULL; int ret; /* describe the stream */ snprintf(cmd, sizeof(cmd), "Accept: application/sdp\r\n"); av_strlcatf(cmd, sizeof(cmd), "User-Agent: %s\r\n", rt->user_agent); if (rt->server_type == RTSP_SERVER_REAL) { /** * The Require: attribute is needed for proper streaming from * Realmedia servers. */ av_strlcat(cmd, "Require: com.real.retain-entity-for-setup\r\n", sizeof(cmd)); } ff_rtsp_send_cmd(s, "DESCRIBE", rt->control_uri, cmd, reply, &content); if (!content) return AVERROR_INVALIDDATA; if (reply->status_code != RTSP_STATUS_OK) { av_freep(&content); return AVERROR_INVALIDDATA; } av_log(s, AV_LOG_VERBOSE, "SDP:\n%s\n", content); /* now we got the SDP description, we parse it */ ret = ff_sdp_parse(s, (const char *)content); av_freep(&content); if (ret < 0) return ret; return 0; }
/** * @brief Translate all variables in the @a text. * * @param text text containing variables * * @return new text with all variables translated */ static char *TranslateVariables(const char *text) { static char translation[512]; char trans[512]; unsigned int i, c; int t; *translation = 0; for (c = 0, i = 0; i < strlen(text); i++) { if (text[i] != '$') { if (c + 1 < sizeof(translation)) { translation[c++] = text[i]; translation[c] = 0; } } else { switch (text[++i]) { case '1': t = guiInfo.ElapsedTime; HH_MM_SS: snprintf(trans, sizeof(trans), "%02d:%02d:%02d", t / 3600, t / 60 % 60, t % 60); av_strlcat(translation, trans, sizeof(translation)); break; case '2': t = guiInfo.ElapsedTime; MMMM_SS: snprintf(trans, sizeof(trans), "%04d:%02d", t / 60, t % 60); av_strlcat(translation, trans, sizeof(translation)); break; case '3': snprintf(trans, sizeof(trans), "%02d", guiInfo.ElapsedTime / 3600); av_strlcat(translation, trans, sizeof(translation)); break; case '4': snprintf(trans, sizeof(trans), "%02d", guiInfo.ElapsedTime / 60 % 60); av_strlcat(translation, trans, sizeof(translation)); break; case '5': snprintf(trans, sizeof(trans), "%02d", guiInfo.ElapsedTime % 60); av_strlcat(translation, trans, sizeof(translation)); break; case '6': t = guiInfo.RunningTime; goto HH_MM_SS; case '7': t = guiInfo.RunningTime; goto MMMM_SS; case '8': snprintf(trans, sizeof(trans), "%01d:%02d:%02d", guiInfo.ElapsedTime / 3600, (guiInfo.ElapsedTime / 60) % 60, guiInfo.ElapsedTime % 60); av_strlcat(translation, trans, sizeof(translation)); break; case 'a': switch (guiInfo.AudioChannels) { case 0: av_strlcat(translation, "n", sizeof(translation)); break; case 1: av_strlcat(translation, "m", sizeof(translation)); break; case 2: av_strlcat(translation, guiInfo.AudioPassthrough ? "r" : "t", sizeof(translation)); break; default: av_strlcat(translation, "r", sizeof(translation)); break; } break; case 'b': snprintf(trans, sizeof(trans), "%3.2f%%", guiInfo.Balance); av_strlcat(translation, trans, sizeof(translation)); break; case 'B': snprintf(trans, sizeof(trans), "%3.1f", guiInfo.Balance); av_strlcat(translation, trans, sizeof(translation)); break; case 'C': snprintf(trans, sizeof(trans), "%s", guiInfo.CodecName ? guiInfo.CodecName : ""); av_strlcat(translation, trans, sizeof(translation)); break; case 'D': snprintf(trans, sizeof(trans), "%3.0f", guiInfo.Balance); av_strlcat(translation, trans, sizeof(translation)); break; case 'e': if (guiInfo.Playing == GUI_PAUSE) av_strlcat(translation, "e", sizeof(translation)); break; case 'f': TranslateFilename(1, trans, sizeof(trans)); av_strlcat(translation, trans, sizeof(translation)); break; case 'F': TranslateFilename(2, trans, sizeof(trans)); av_strlcat(translation, trans, sizeof(translation)); break; case 'o': TranslateFilename(0, trans, sizeof(trans)); av_strlcat(translation, trans, sizeof(translation)); break; case 'O': TranslateFilename(4, trans, sizeof(trans)); av_strlcat(translation, trans, sizeof(translation)); break; case 'l': // legacy case 'p': if (guiInfo.Playing == GUI_PLAY) av_strlcat(translation, "p", sizeof(translation)); break; case 'P': switch (guiInfo.Playing) { case GUI_STOP: av_strlcat(translation, "s", sizeof(translation)); break; case GUI_PLAY: av_strlcat(translation, "p", sizeof(translation)); break; case GUI_PAUSE: av_strlcat(translation, "e", sizeof(translation)); break; } break; case 's': if (guiInfo.Playing == GUI_STOP) av_strlcat(translation, "s", sizeof(translation)); break; case 't': snprintf(trans, sizeof(trans), "%02d", guiInfo.Track); av_strlcat(translation, trans, sizeof(translation)); break; case 'T': switch (guiInfo.StreamType) { case STREAMTYPE_FILE: av_strlcat(translation, "f", sizeof(translation)); break; case STREAMTYPE_STREAM: av_strlcat(translation, "u", sizeof(translation)); break; case STREAMTYPE_CDDA: av_strlcat(translation, "a", sizeof(translation)); break; case STREAMTYPE_VCD: av_strlcat(translation, "v", sizeof(translation)); break; case STREAMTYPE_DVD: av_strlcat(translation, "d", sizeof(translation)); break; case STREAMTYPE_TV: case STREAMTYPE_DVB: av_strlcat(translation, "b", sizeof(translation)); break; case STREAMTYPE_BINCUE: av_strlcat(translation, "c", sizeof(translation)); break; default: av_strlcat(translation, " ", sizeof(translation)); break; } break; case 'U': snprintf(trans, sizeof(trans), "%3.0f", guiInfo.Volume); av_strlcat(translation, trans, sizeof(translation)); break; case 'v': snprintf(trans, sizeof(trans), "%3.2f%%", guiInfo.Volume); av_strlcat(translation, trans, sizeof(translation)); break; case 'V': snprintf(trans, sizeof(trans), "%3.1f", guiInfo.Volume); av_strlcat(translation, trans, sizeof(translation)); break; case 'x': snprintf(trans, sizeof(trans), "%d", guiInfo.VideoWidth); av_strlcat(translation, trans, sizeof(translation)); break; case 'y': snprintf(trans, sizeof(trans), "%d", guiInfo.VideoHeight); av_strlcat(translation, trans, sizeof(translation)); break; case '$': av_strlcat(translation, "$", sizeof(translation)); break; default: continue; } c = strlen(translation); } } return translation; }
int av_dict_set(AVDictionary **pm, const char *key, const char *value, int flags) { AVDictionary *m = *pm; AVDictionaryEntry *tag = NULL; char *oldval = NULL, *copy_key = NULL, *copy_value = NULL; if (!(flags & AV_DICT_MULTIKEY)) { tag = av_dict_get(m, key, NULL, flags); } if (flags & AV_DICT_DONT_STRDUP_KEY) copy_key = (void *)key; else copy_key = av_strdup(key); if (flags & AV_DICT_DONT_STRDUP_VAL) copy_value = (void *)value; else if (copy_key) copy_value = av_strdup(value); if (!m) m = *pm = av_mallocz(sizeof(*m)); if (!m || (key && !copy_key) || (value && !copy_value)) goto err_out; if (tag) { if (flags & AV_DICT_DONT_OVERWRITE) { av_free(copy_key); av_free(copy_value); return 0; } if (flags & AV_DICT_APPEND) oldval = tag->value; else av_free(tag->value); av_free(tag->key); *tag = m->elems[--m->count]; } else if (copy_value) { AVDictionaryEntry *tmp = av_realloc(m->elems, (m->count + 1) * sizeof(*m->elems)); if (!tmp) goto err_out; m->elems = tmp; } if (copy_value) { m->elems[m->count].key = copy_key; m->elems[m->count].value = copy_value; if (oldval && flags & AV_DICT_APPEND) { size_t len = strlen(oldval) + strlen(copy_value) + 1; char *newval = av_mallocz(len); if (!newval) goto err_out; av_strlcat(newval, oldval, len); av_freep(&oldval); av_strlcat(newval, copy_value, len); m->elems[m->count].value = newval; av_freep(©_value); } m->count++; } else { av_freep(©_key); } if (!m->count) { av_freep(&m->elems); av_freep(pm); } return 0; err_out: if (m && !m->count) { av_freep(&m->elems); av_freep(pm); } av_free(copy_key); av_free(copy_value); return AVERROR(ENOMEM); }
static int rtsp_read_packet(AVFormatContext *s, AVPacket *pkt) { RTSPState *rt = s->priv_data; int ret; RTSPMessageHeader reply1, *reply = &reply1; char cmd[1024]; retry: if (rt->server_type == RTSP_SERVER_REAL) { int i; for (i = 0; i < s->nb_streams; i++) rt->real_setup[i] = s->streams[i]->discard; if (!rt->need_subscription) { if (memcmp (rt->real_setup, rt->real_setup_cache, sizeof(enum AVDiscard) * s->nb_streams)) { snprintf(cmd, sizeof(cmd), "Unsubscribe: %s\r\n", rt->last_subscription); ff_rtsp_send_cmd(s, "SET_PARAMETER", rt->control_uri, cmd, reply, NULL); if (reply->status_code != RTSP_STATUS_OK) return AVERROR_INVALIDDATA; rt->need_subscription = 1; } } if (rt->need_subscription) { int r, rule_nr, first = 1; memcpy(rt->real_setup_cache, rt->real_setup, sizeof(enum AVDiscard) * s->nb_streams); rt->last_subscription[0] = 0; snprintf(cmd, sizeof(cmd), "Subscribe: "); for (i = 0; i < rt->nb_rtsp_streams; i++) { rule_nr = 0; for (r = 0; r < s->nb_streams; r++) { if (s->streams[r]->id == i) { if (s->streams[r]->discard != AVDISCARD_ALL) { if (!first) av_strlcat(rt->last_subscription, ",", sizeof(rt->last_subscription)); ff_rdt_subscribe_rule( rt->last_subscription, sizeof(rt->last_subscription), i, rule_nr); first = 0; } rule_nr++; } } } av_strlcatf(cmd, sizeof(cmd), "%s\r\n", rt->last_subscription); ff_rtsp_send_cmd(s, "SET_PARAMETER", rt->control_uri, cmd, reply, NULL); if (reply->status_code != RTSP_STATUS_OK) return AVERROR_INVALIDDATA; rt->need_subscription = 0; if (rt->state == RTSP_STATE_STREAMING) rtsp_read_play (s); } } ret = ff_rtsp_fetch_packet(s, pkt); if (ret < 0) { if (ret == AVERROR(ETIMEDOUT) && !rt->packets) { if (rt->lower_transport == RTSP_LOWER_TRANSPORT_UDP && rt->lower_transport_mask & (1 << RTSP_LOWER_TRANSPORT_TCP)) { RTSPMessageHeader reply1, *reply = &reply1; av_log(s, AV_LOG_WARNING, "UDP timeout, retrying with TCP\n"); if (rtsp_read_pause(s) != 0) return -1; // TEARDOWN is required on Real-RTSP, but might make // other servers close the connection. if (rt->server_type == RTSP_SERVER_REAL) ff_rtsp_send_cmd(s, "TEARDOWN", rt->control_uri, NULL, reply, NULL); rt->session_id[0] = '\0'; if (resetup_tcp(s) == 0) { rt->state = RTSP_STATE_IDLE; rt->need_subscription = 1; if (rtsp_read_play(s) != 0) return -1; goto retry; } } } return ret; } rt->packets++; /* send dummy request to keep TCP connection alive */ if ((av_gettime() - rt->last_cmd_time) / 1000000 >= rt->timeout / 2 || rt->auth_state.stale) { if (rt->server_type == RTSP_SERVER_WMS || (rt->server_type != RTSP_SERVER_REAL && rt->get_parameter_supported)) { ff_rtsp_send_cmd_async(s, "GET_PARAMETER", rt->control_uri, NULL); } else { ff_rtsp_send_cmd_async(s, "OPTIONS", "*", NULL); } /* The stale flag should be reset when creating the auth response in * ff_rtsp_send_cmd_async, but reset it here just in case we never * called the auth code (if we didn't have any credentials set). */ rt->auth_state.stale = 0; } return 0; }
/** * @brief Parse a @a button definition. * * Syntax: button=image,x,y,width,height,message * * @param in definition to be analyzed * * @return 0 (ok) or 1 (error) */ static int item_button(char *in) { unsigned char fname[256]; unsigned char file[512]; int x, y, w, h, message; char msg[32]; wItem *item; if (!window_item("button")) return 1; if (in_window("video")) return 1; if (in_window("menu")) return 1; cutItem(in, fname, ',', 0); x = cutItemToInt(in, ',', 1); y = cutItemToInt(in, ',', 2); w = cutItemToInt(in, ',', 3); h = cutItemToInt(in, ',', 4); cutItem(in, msg, ',', 5); message = appFindMessage(msg); if (message == -1) { skin_error(MSGTR_SKIN_UnknownMessage, msg); return 1; } mp_msg(MSGT_GPLAYER, MSGL_DBG2, "[skin] button image: %s %d,%d\n", fname, x, y); mp_msg(MSGT_GPLAYER, MSGL_DBG2, "[skin] message: %s (#%d)\n", msg, message); mp_msg(MSGT_GPLAYER, MSGL_DBG2, "[skin] size: %dx%d\n", w, h); item = next_item(); if (!item) return 1; item->type = itButton; item->x = x; item->y = y; item->width = w; item->height = h; item->message = message; item->pressed = btnReleased; if (item->message == evPauseSwitchToPlay) item->pressed = btnDisabled; item->Bitmap.Image = NULL; if (strcmp(fname, "NULL") != 0) { av_strlcpy(file, path, sizeof(file)); av_strlcat(file, fname, sizeof(file)); if (skinImageRead(file, &item->Bitmap) != 0) return 1; mp_msg(MSGT_GPLAYER, MSGL_DBG2, "[skin] (bitmap: %lux%lu)\n", item->Bitmap.Width, item->Bitmap.Height); } return 0; }
static int mmsh_open(URLContext *h, const char *uri, int flags) { int i, port, err; char httpname[256], path[256], host[128], location[1024]; char *stream_selection = NULL; char headers[1024]; MMSHContext *mmsh; MMSContext *mms; mmsh = h->priv_data = av_mallocz(sizeof(MMSHContext)); if (!h->priv_data) return AVERROR(ENOMEM); mmsh->request_seq = h->is_streamed = 1; mms = &mmsh->mms; av_strlcpy(location, uri, sizeof(location)); av_url_split(NULL, 0, NULL, 0, host, sizeof(host), &port, path, sizeof(path), location); if (port<0) port = 80; // default mmsh protocol port ff_url_join(httpname, sizeof(httpname), "http", NULL, host, port, path); if (url_alloc(&mms->mms_hd, httpname, URL_RDONLY) < 0) { return AVERROR(EIO); } snprintf(headers, sizeof(headers), "Accept: */*\r\n" USERAGENT "Host: %s:%d\r\n" "Pragma: no-cache,rate=1.000000,stream-time=0," "stream-offset=0:0,request-context=%u,max-duration=0\r\n" CLIENTGUID "Connection: Close\r\n\r\n", host, port, mmsh->request_seq++); ff_http_set_headers(mms->mms_hd, headers); err = url_connect(mms->mms_hd); if (err) { goto fail; } err = get_http_header_data(mmsh); if (err) { av_log(NULL, AV_LOG_ERROR, "Get http header data failed!\n"); goto fail; } // close the socket and then reopen it for sending the second play request. url_close(mms->mms_hd); memset(headers, 0, sizeof(headers)); if (url_alloc(&mms->mms_hd, httpname, URL_RDONLY) < 0) { return AVERROR(EIO); } stream_selection = av_mallocz(mms->stream_num * 19 + 1); if (!stream_selection) return AVERROR(ENOMEM); for (i = 0; i < mms->stream_num; i++) { char tmp[20]; err = snprintf(tmp, sizeof(tmp), "ffff:%d:0 ", mms->streams[i].id); if (err < 0) goto fail; av_strlcat(stream_selection, tmp, mms->stream_num * 19 + 1); } // send play request err = snprintf(headers, sizeof(headers), "Accept: */*\r\n" USERAGENT "Host: %s:%d\r\n" "Pragma: no-cache,rate=1.000000,request-context=%u\r\n" "Pragma: xPlayStrm=1\r\n" CLIENTGUID "Pragma: stream-switch-count=%d\r\n" "Pragma: stream-switch-entry=%s\r\n" "Connection: Close\r\n\r\n", host, port, mmsh->request_seq++, mms->stream_num, stream_selection); av_freep(&stream_selection); if (err < 0) { av_log(NULL, AV_LOG_ERROR, "Build play request failed!\n"); goto fail; } av_dlog(NULL, "out_buffer is %s", headers); ff_http_set_headers(mms->mms_hd, headers); err = url_connect(mms->mms_hd); if (err) { goto fail; } err = get_http_header_data(mmsh); if (err) { av_log(NULL, AV_LOG_ERROR, "Get http header data failed!\n"); goto fail; } av_dlog(NULL, "Connection successfully open\n"); return 0; fail: av_freep(&stream_selection); mmsh_close(h); av_dlog(NULL, "Connection failed with error %d\n", err); return err; }
/** * Open RTMP connection and verify that the stream can be played. * * URL syntax: rtmp://server[:port][/app][/playpath][ keyword=value]... * where 'app' is first one or two directories in the path * (e.g. /ondemand/, /flash/live/, etc.) * and 'playpath' is a file name (the rest of the path, * may be prefixed with "mp4:") * * Additional RTMP library options may be appended as * space-separated key-value pairs. */ static int rtmp_open(URLContext *s, const char *uri, int flags) { LibRTMPContext *ctx = s->priv_data; RTMP *r = &ctx->rtmp; int rc = 0, level; char *filename = s->filename; int len = strlen(s->filename) + 1; switch (av_log_get_level()) { default: case AV_LOG_FATAL: level = RTMP_LOGCRIT; break; case AV_LOG_ERROR: level = RTMP_LOGERROR; break; case AV_LOG_WARNING: level = RTMP_LOGWARNING; break; case AV_LOG_INFO: level = RTMP_LOGINFO; break; case AV_LOG_VERBOSE: level = RTMP_LOGDEBUG; break; case AV_LOG_DEBUG: level = RTMP_LOGDEBUG2; break; } RTMP_LogSetLevel(level); RTMP_LogSetCallback(rtmp_log); if (ctx->app) len += strlen(ctx->app) + sizeof(" app="); if (ctx->tcurl) len += strlen(ctx->tcurl) + sizeof(" tcUrl="); if (ctx->pageurl) len += strlen(ctx->pageurl) + sizeof(" pageUrl="); if (ctx->flashver) len += strlen(ctx->flashver) + sizeof(" flashver="); if (ctx->conn) { char *sep, *p = ctx->conn; int options = 0; while (p) { options++; p += strspn(p, " "); if (!*p) break; sep = strchr(p, ' '); if (sep) p = sep + 1; else break; } len += options * sizeof(" conn="); len += strlen(ctx->conn); } if (ctx->playpath) len += strlen(ctx->playpath) + sizeof(" playpath="); if (ctx->live) len += sizeof(" live=1"); if (ctx->subscribe) len += strlen(ctx->subscribe) + sizeof(" subscribe="); if (ctx->client_buffer_time) len += strlen(ctx->client_buffer_time) + sizeof(" buffer="); if (ctx->swfurl || ctx->swfverify) { len += sizeof(" swfUrl="); if (ctx->swfverify) len += strlen(ctx->swfverify) + sizeof(" swfVfy=1"); else len += strlen(ctx->swfurl); } if (!(ctx->temp_filename = filename = av_malloc(len))) return AVERROR(ENOMEM); av_strlcpy(filename, s->filename, len); if (ctx->app) { av_strlcat(filename, " app=", len); av_strlcat(filename, ctx->app, len); } if (ctx->tcurl) { av_strlcat(filename, " tcUrl=", len); av_strlcat(filename, ctx->tcurl, len); } if (ctx->pageurl) { av_strlcat(filename, " pageUrl=", len); av_strlcat(filename, ctx->pageurl, len); } if (ctx->swfurl) { av_strlcat(filename, " swfUrl=", len); av_strlcat(filename, ctx->swfurl, len); } if (ctx->flashver) { av_strlcat(filename, " flashVer=", len); av_strlcat(filename, ctx->flashver, len); } if (ctx->conn) { char *sep, *p = ctx->conn; while (p) { av_strlcat(filename, " conn=", len); p += strspn(p, " "); if (!*p) break; sep = strchr(p, ' '); if (sep) *sep = '\0'; av_strlcat(filename, p, len); if (sep) p = sep + 1; else break; } } if (ctx->playpath) { av_strlcat(filename, " playpath=", len); av_strlcat(filename, ctx->playpath, len); } if (ctx->live) av_strlcat(filename, " live=1", len); if (ctx->subscribe) { av_strlcat(filename, " subscribe=", len); av_strlcat(filename, ctx->subscribe, len); } if (ctx->client_buffer_time) { av_strlcat(filename, " buffer=", len); av_strlcat(filename, ctx->client_buffer_time, len); } if (ctx->swfurl || ctx->swfverify) { av_strlcat(filename, " swfUrl=", len); if (ctx->swfverify) { av_strlcat(filename, ctx->swfverify, len); av_strlcat(filename, " swfVfy=1", len); } else { av_strlcat(filename, ctx->swfurl, len); } } RTMP_Init(r); if (!RTMP_SetupURL(r, filename)) { rc = AVERROR_UNKNOWN; goto fail; } if (flags & AVIO_FLAG_WRITE) RTMP_EnableWrite(r); if (!RTMP_Connect(r, NULL) || !RTMP_ConnectStream(r, 0)) { rc = AVERROR_UNKNOWN; goto fail; } #if CONFIG_NETWORK if (ctx->buffer_size >= 0 && (flags & AVIO_FLAG_WRITE)) { int tmp = ctx->buffer_size; setsockopt(r->m_sb.sb_socket, SOL_SOCKET, SO_SNDBUF, &tmp, sizeof(tmp)); } #endif s->is_streamed = 1; return 0; fail: av_freep(&ctx->temp_filename); if (rc) RTMP_Close(r); return rc; }
/** * @brief Parse a @a potmeter definition. * * Syntax: potmeter=phases,numphases,default,x,y,width,height,message * * @param in definition to be analyzed * * @return 0 (ok) or 1 (error) */ static int item_potmeter(char *in) { unsigned char phfname[256]; unsigned char buf[512]; int ph, d, x, y, w, h, message; wItem *item; if (!window_item("potmeter")) return 1; if (in_window("video")) return 1; if (in_window("menu")) return 1; cutItem(in, phfname, ',', 0); ph = cutItemToInt(in, ',', 1); d = cutItemToInt(in, ',', 2); x = cutItemToInt(in, ',', 3); y = cutItemToInt(in, ',', 4); w = cutItemToInt(in, ',', 5); h = cutItemToInt(in, ',', 6); cutItem(in, buf, ',', 7); message = appFindMessage(buf); if (message == -1) { skin_error(MSGTR_SKIN_UnknownMessage, buf); return 1; } mp_msg(MSGT_GPLAYER, MSGL_DBG2, "[skin] potmeter image: %s %d,%d %dx%d\n", phfname, x, y, w, h); mp_msg(MSGT_GPLAYER, MSGL_DBG2, "[skin] numphases: %d, default: %d%%\n", ph, d); mp_msg(MSGT_GPLAYER, MSGL_DBG2, "[skin] message: %s (#%d)\n", buf, message); item = next_item(); if (!item) return 1; item->type = itPotmeter; item->x = x; item->y = y; item->width = w; item->height = h; item->numphases = ph; item->value = (float)d; item->message = message; item->Bitmap.Image = NULL; if (strcmp(phfname, "NULL") != 0) { av_strlcpy(buf, path, sizeof(buf)); av_strlcat(buf, phfname, sizeof(buf)); if (skinImageRead(buf, &item->Bitmap) != 0) return 1; mp_msg(MSGT_GPLAYER, MSGL_DBG2, "[skin] (bitmap: %lux%lu)\n", item->Bitmap.Width, item->Bitmap.Height); } return 0; }
static demuxer_t* demux_open_lavf(demuxer_t *demuxer){ AVFormatContext *avfc; AVDictionaryEntry *t = NULL; lavf_priv_t *priv= demuxer->priv; int i; char mp_filename[256]="mp:"; stream_seek(demuxer->stream, 0); avfc = avformat_alloc_context(); if (opt_cryptokey) parse_cryptokey(avfc, opt_cryptokey); if (user_correct_pts != 0) avfc->flags |= AVFMT_FLAG_GENPTS; if (index_mode == 0) avfc->flags |= AVFMT_FLAG_IGNIDX; if(opt_probesize) { if (av_opt_set_int(avfc, "probesize", opt_probesize, 0) < 0) mp_msg(MSGT_HEADER,MSGL_ERR, "demux_lavf, couldn't set option probesize to %u\n", opt_probesize); } if(opt_analyzeduration) { if (av_opt_set_int(avfc, "analyzeduration", opt_analyzeduration * AV_TIME_BASE, 0) < 0) mp_msg(MSGT_HEADER,MSGL_ERR, "demux_lavf, couldn't set option analyzeduration to %u\n", opt_analyzeduration); } if(opt_avopt){ if(parse_avopts(avfc, opt_avopt) < 0){ mp_msg(MSGT_HEADER,MSGL_ERR, "Your options /%s/ look like gibberish to me pal\n", opt_avopt); return NULL; } } if(demuxer->stream->url) { if (!strncmp(demuxer->stream->url, "ffmpeg://rtsp:", 14)) av_strlcpy(mp_filename, demuxer->stream->url + 9, sizeof(mp_filename)); else av_strlcat(mp_filename, demuxer->stream->url, sizeof(mp_filename)); } else av_strlcat(mp_filename, "foobar.dummy", sizeof(mp_filename)); if (!(priv->avif->flags & AVFMT_NOFILE)) { priv->pb = avio_alloc_context(priv->buffer, BIO_BUFFER_SIZE, 0, demuxer, mp_read, NULL, mp_seek); priv->pb->read_seek = mp_read_seek; if (!demuxer->stream->end_pos || (demuxer->stream->flags & MP_STREAM_SEEK) != MP_STREAM_SEEK) priv->pb->seekable = 0; avfc->pb = priv->pb; } if(avformat_open_input(&avfc, mp_filename, priv->avif, NULL)<0){ mp_msg(MSGT_HEADER,MSGL_ERR,"LAVF_header: av_open_input_stream() failed\n"); return NULL; } priv->avfc= avfc; if(avformat_find_stream_info(avfc, NULL) < 0){ mp_msg(MSGT_HEADER,MSGL_ERR,"LAVF_header: av_find_stream_info() failed\n"); return NULL; } /* Add metadata. */ while((t = av_dict_get(avfc->metadata, "", t, AV_DICT_IGNORE_SUFFIX))) demux_info_add(demuxer, t->key, t->value); for(i=0; i < avfc->nb_chapters; i++) { AVChapter *c = avfc->chapters[i]; uint64_t start = av_rescale_q(c->start, c->time_base, (AVRational){1,1000}); uint64_t end = av_rescale_q(c->end, c->time_base, (AVRational){1,1000}); t = av_dict_get(c->metadata, "title", NULL, 0); demuxer_add_chapter(demuxer, t ? t->value : NULL, start, end); } for(i=0; i<avfc->nb_streams; i++) handle_stream(demuxer, avfc, i); priv->nb_streams_last = avfc->nb_streams; if(avfc->nb_programs) { int p; for (p = 0; p < avfc->nb_programs; p++) { AVProgram *program = avfc->programs[p]; t = av_dict_get(program->metadata, "title", NULL, 0); mp_msg(MSGT_HEADER,MSGL_INFO,"LAVF: Program %d %s\n", program->id, t ? t->value : ""); mp_msg(MSGT_IDENTIFY, MSGL_V, "PROGRAM_ID=%d\n", program->id); } } mp_msg(MSGT_HEADER,MSGL_V,"LAVF: %d audio and %d video streams found\n",priv->audio_streams,priv->video_streams); mp_msg(MSGT_HEADER,MSGL_V,"LAVF: build %d\n", LIBAVFORMAT_BUILD); if(!priv->audio_streams) demuxer->audio->id=-2; // nosound // else if(best_audio > 0 && demuxer->audio->id == -1) demuxer->audio->id=best_audio; if(!priv->video_streams){ if(!priv->audio_streams){ mp_msg(MSGT_HEADER,MSGL_ERR,"LAVF: no audio or video headers found - broken file?\n"); return NULL; } demuxer->video->id=-2; // audio-only } //else if (best_video > 0 && demuxer->video->id == -1) demuxer->video->id = best_video; return demuxer; }