自学教程：C++ stream_control函数代码示例

int demux_seek(demuxer_t *demuxer, float rel_seek_secs, float audio_delay,               int flags){    if (!demuxer->seekable) {        if (demuxer->file_format == DEMUXER_TYPE_AVI)            mp_tmsg(MSGT_SEEK, MSGL_WARN, "Cannot seek in raw AVI streams. (Index required, try with the -idx switch.)/n");#ifdef CONFIG_TV        else if (demuxer->file_format == DEMUXER_TYPE_TV)            mp_tmsg(MSGT_SEEK, MSGL_WARN, "TV input is not seekable! (Seeking will probably be for changing channels ;)/n");#endif        else            mp_tmsg(MSGT_SEEK, MSGL_WARN, "Cannot seek in this file./n");        return 0;    }    // clear demux buffers:    demux_flush(demuxer);    demuxer->video->eof = 0;    demuxer->audio->eof = 0;    demuxer->sub->eof = 0;    /* HACK: assume any demuxer used with these streams can cope with     * the stream layer suddenly seeking to a different position under it     * (nothing actually implements DEMUXER_CTRL_RESYNC now).     */    struct stream *stream = demuxer->stream;    if (stream->type == STREAMTYPE_DVD || stream->type == STREAMTYPE_DVDNAV) {        double pts;        if (flags & SEEK_ABSOLUTE)            pts = 0.0f;        else {            if (demuxer->stream_pts == MP_NOPTS_VALUE)                goto dmx_seek;            pts = demuxer->stream_pts;        }        if (flags & SEEK_FACTOR) {            double tmp = 0;            if (stream_control(demuxer->stream, STREAM_CTRL_GET_TIME_LENGTH,                               &tmp) == STREAM_UNSUPPORTED)                goto dmx_seek;            pts += tmp * rel_seek_secs;        } else            pts += rel_seek_secs;        if (stream_control(demuxer->stream, STREAM_CTRL_SEEK_TO_TIME, &pts)            != STREAM_UNSUPPORTED) {            demux_control(demuxer, DEMUXER_CTRL_RESYNC, NULL);            return 1;        }    }  dmx_seek:    if (demuxer->desc->seek)        demuxer->desc->seek(demuxer, rel_seek_secs, audio_delay, flags);    return 1;}

int mp_get_cache_percent(struct MPContext *mpctx){    if (mpctx->stream) {        int64_t size = -1;        int64_t fill = -1;        stream_control(mpctx->stream, STREAM_CTRL_GET_CACHE_SIZE, &size);        stream_control(mpctx->stream, STREAM_CTRL_GET_CACHE_FILL, &fill);        if (size > 0 && fill >= 0)            return fill / (size / 100);    }    return -1;}

static int64_t mp_seek(void *opaque, int64_t pos, int whence) {    demuxer_t *demuxer = opaque;    stream_t *stream = demuxer->stream;    int64_t current_pos;    mp_msg(MSGT_HEADER,MSGL_DBG2,"mp_seek(%p, %"PRId64", %d)/n", stream, pos, whence);    if(whence == SEEK_CUR)        pos +=stream_tell(stream);    else if(whence == SEEK_END && stream->end_pos > 0)        pos += stream->end_pos;    else if(whence == SEEK_SET)        pos += stream->start_pos;    else if(whence == AVSEEK_SIZE && stream->end_pos > 0) {        uint64_t size;        stream_control(stream, STREAM_CTRL_GET_SIZE, &size);        if (size > stream->end_pos)            stream->end_pos = size;        return stream->end_pos - stream->start_pos;    } else        return -1;    if(pos<0)        return -1;    current_pos = stream_tell(stream);    if(stream_seek(stream, pos)==0) {        stream_reset(stream);        stream_seek(stream, current_pos);        return -1;    }    return pos - stream->start_pos;}

int demuxer_seek_chapter(demuxer_t *demuxer, int chapter, double *seek_pts){    int ris;    if (!demuxer->num_chapters || !demuxer->chapters) {        demux_flush(demuxer);        ris = stream_control(demuxer->stream, STREAM_CTRL_SEEK_TO_CHAPTER,                             &chapter);        if (ris != STREAM_UNSUPPORTED)            demux_control(demuxer, DEMUXER_CTRL_RESYNC, NULL);        // exit status may be ok, but main() doesn't have to seek itself        // (because e.g. dvds depend on sectors, not on pts)        *seek_pts = -1.0;        return ris != STREAM_UNSUPPORTED ? chapter : -1;    } else {  // chapters structure is set in the demuxer        if (chapter >= demuxer->num_chapters)            return -1;        if (chapter < 0)            chapter = 0;        *seek_pts = demuxer->chapters[chapter].start / 1e9;        return chapter;    }}

static int open_f(stream_t *stream){    stream->fill_buffer = fill_buffer;    stream->seek = seek;    stream->seekable = true;    stream->control = control;    stream->read_chunk = 1024 * 1024;    struct priv *p = talloc_zero(stream, struct priv);    stream->priv = p;    // Initial data    bstr data = bstr0(stream->url);    bool use_hex = bstr_eatstart0(&data, "hex://");    if (!use_hex)        bstr_eatstart0(&data, "memory://");    stream_control(stream, STREAM_CTRL_SET_CONTENTS, &data);    if (use_hex && !bstr_decode_hex(stream, p->data, &p->data)) {        MP_FATAL(stream, "Invalid data./n");        return STREAM_ERROR;    }    return STREAM_OK;}

bool mp_get_cache_idle(struct MPContext *mpctx){    int idle = 0;    if (mpctx->stream)        stream_control(mpctx->stream, STREAM_CTRL_GET_CACHE_IDLE, &idle);    return idle;}

// Runs in the cache threadstatic void cache_execute_control(struct priv *s){    uint64_t old_pos = stream_tell(s->stream);    s->control_flush = false;    switch (s->control) {    case STREAM_CTRL_SET_CACHE_SIZE:        s->control_res = resize_cache(s, *(int64_t *)s->control_arg);        break;    default:        s->control_res = stream_control(s->stream, s->control, s->control_arg);    }    bool pos_changed = old_pos != stream_tell(s->stream);    bool ok = s->control_res == STREAM_OK;    if (pos_changed && !ok) {        MP_ERR(s, "STREAM_CTRL changed stream pos but "               "returned error, this is not allowed!/n");    } else if (pos_changed || (ok && control_needs_flush(s->control))) {        MP_VERBOSE(s, "Dropping cache due to control()/n");        s->read_filepos = stream_tell(s->stream);        s->control_flush = true;        cache_drop_contents(s);    }    update_cached_controls(s);    s->control = CACHE_CTRL_NONE;    pthread_cond_signal(&s->wakeup);}

void stream_dump(struct MPContext *mpctx){    struct MPOpts *opts = mpctx->opts;    char *filename = opts->stream_dump;    stream_t *stream = mpctx->stream;    assert(stream && filename);    int64_t size = 0;    stream_control(stream, STREAM_CTRL_GET_SIZE, &size);    stream_set_capture_file(stream, filename);    while (mpctx->stop_play == KEEP_PLAYING && !stream->eof) {        if (!opts->quiet && ((stream->pos / (1024 * 1024)) % 2) == 1) {            uint64_t pos = stream->pos;            MP_MSG(mpctx, MSGL_STATUS, "Dumping %lld/%lld...",                   (long long int)pos, (long long int)size);        }        stream_fill_buffer(stream);        for (;;) {            mp_cmd_t *cmd = mp_input_get_cmd(mpctx->input, 0, false);            if (!cmd)                break;            run_command(mpctx, cmd);            talloc_free(cmd);        }    }}

void mp_nav_reset(struct MPContext *mpctx){    struct mp_nav_state *nav = mpctx->nav_state;    if (!nav)        return;    struct mp_nav_cmd inp = {MP_NAV_CMD_RESUME};    stream_control(mpctx->stream, STREAM_CTRL_NAV_CMD, &inp);    osd_set_nav_highlight(mpctx->osd, NULL);    nav->hi_visible = 0;    nav->nav_menu = false;    nav->nav_draining = false;    nav->nav_still_frame = 0;    mp_input_disable_section(mpctx->input, "discnav-menu");    // Prevent demuxer init code to seek to the "start"    mpctx->stream->start_pos = stream_tell(mpctx->stream);    stream_control(mpctx->stream, STREAM_CTRL_RESUME_CACHE, NULL);}

int demuxer_get_current_angle(demuxer_t *demuxer){    int ris, curr_angle = -1;    ris = stream_control(demuxer->stream, STREAM_CTRL_GET_ANGLE, &curr_angle);    if (ris == STREAM_UNSUPPORTED)        return -1;    return curr_angle;}

static void update_cached_controls(struct priv *s){    unsigned int ui;    int64_t i64;    double d;    char **m;    char *t;    s->stream_time_length = 0;    if (stream_control(s->stream, STREAM_CTRL_GET_TIME_LENGTH, &d) == STREAM_OK)        s->stream_time_length = d;    s->stream_start_time = MP_NOPTS_VALUE;    if (stream_control(s->stream, STREAM_CTRL_GET_START_TIME, &d) == STREAM_OK)        s->stream_start_time = d;    s->stream_manages_timeline = false;    if (stream_control(s->stream, STREAM_CTRL_MANAGES_TIMELINE, NULL) == STREAM_OK)        s->stream_manages_timeline = true;    s->stream_num_chapters = 0;    if (stream_control(s->stream, STREAM_CTRL_GET_NUM_CHAPTERS, &ui) == STREAM_OK)        s->stream_num_chapters = ui;    if (stream_control(s->stream, STREAM_CTRL_GET_METADATA, &m) == STREAM_OK) {        talloc_free(s->stream_metadata);        s->stream_metadata = talloc_steal(s, m);    }    if (stream_control(s->stream, STREAM_CTRL_GET_DISC_NAME, &t) == STREAM_OK)    {        talloc_free(s->disc_name);        s->disc_name = talloc_steal(s, t);    }    s->stream_size = -1;    if (stream_control(s->stream, STREAM_CTRL_GET_SIZE, &i64) == STREAM_OK)        s->stream_size = i64;}

// If a demuxer is accessing the stream, we have to use demux_stream_control()// to avoid synchronization issues; otherwise access it directly.static int run_stream_control(struct MPContext *mpctx, int cmd, void *arg){    if (mpctx->demuxer) {        return demux_stream_control(mpctx->demuxer, cmd, arg);    } else if (mpctx->stream) {        return stream_control(mpctx->stream, cmd, arg);    }    return STREAM_ERROR;}

static void update_cached_controls(struct priv *s){    int64_t i64;    double d;    struct mp_tags *tags;    s->stream_time_length = 0;    if (stream_control(s->stream, STREAM_CTRL_GET_TIME_LENGTH, &d) == STREAM_OK)        s->stream_time_length = d;    if (stream_control(s->stream, STREAM_CTRL_GET_METADATA, &tags) == STREAM_OK) {        talloc_free(s->stream_metadata);        s->stream_metadata = talloc_steal(s, tags);    }    s->stream_size = s->eof_pos;    i64 = stream_get_size(s->stream);    if (i64 >= 0)        s->stream_size = i64;    s->has_avseek = stream_control(s->stream, STREAM_CTRL_HAS_AVSEEK, NULL) > 0;}

int demuxer_angles_count(demuxer_t *demuxer){    int ris, angles = -1;    ris = stream_control(demuxer->stream, STREAM_CTRL_GET_NUM_ANGLES, &angles);    if (ris == STREAM_UNSUPPORTED)        return -1;    return angles;}

int demuxer_chapter_count(demuxer_t *demuxer){    if (!demuxer->num_chapters || !demuxer->chapters) {        int num_chapters = 0;        if (stream_control(demuxer->stream, STREAM_CTRL_GET_NUM_CHAPTERS,                           &num_chapters) == STREAM_UNSUPPORTED)            num_chapters = 0;        return num_chapters;    } else        return demuxer->num_chapters;}

void mp_nav_user_input(struct MPContext *mpctx, char *command){    struct mp_nav_state *nav = mpctx->nav_state;    if (!nav)        return;    if (strcmp(command, "mouse_move") == 0) {        struct mp_image_params vid = {0};        if (mpctx->d_video)            vid = mpctx->d_video->decoder_output;        struct mp_nav_cmd inp = {MP_NAV_CMD_MOUSE_POS};        int x, y;        mp_input_get_mouse_pos(mpctx->input, &x, &y);        osd_coords_to_video(mpctx->osd, vid.w, vid.h, &x, &y);        inp.u.mouse_pos.x = x;        inp.u.mouse_pos.y = y;        stream_control(mpctx->stream, STREAM_CTRL_NAV_CMD, &inp);    } else {        struct mp_nav_cmd inp = {MP_NAV_CMD_MENU};        inp.u.menu.action = command;        stream_control(mpctx->stream, STREAM_CTRL_NAV_CMD, &inp);    }}

static int64_t mp_read_seek(void *opaque, int stream_idx, int64_t ts, int flags) {    demuxer_t *demuxer = opaque;    stream_t *stream = demuxer->stream;    lavf_priv_t *priv = demuxer->priv;    AVStream *st = priv->avfc->streams[stream_idx];    int ret;    double pts;    pts = (double)ts * st->time_base.num / st->time_base.den;    ret = stream_control(stream, STREAM_CTRL_SEEK_TO_TIME, &pts);    if (ret < 0)        ret = AVERROR(ENOSYS);    return ret;}

int demuxer_get_current_chapter(demuxer_t *demuxer, double time_now){    int chapter = -2;    if (!demuxer->num_chapters || !demuxer->chapters) {        if (stream_control(demuxer->stream, STREAM_CTRL_GET_CURRENT_CHAPTER,                           &chapter) == STREAM_UNSUPPORTED)            chapter = -2;    } else {        uint64_t now = time_now * 1e9 + 0.5;        for (chapter = demuxer->num_chapters - 1; chapter >= 0; --chapter) {            if (demuxer->chapters[chapter].start <= now)                break;        }    }    return chapter;}

static int fill_buffer(stream_t *s, char *buffer, int max_len){    struct priv *p = s->priv;    if (s->pos < 0)        return -1;    if (s->pos >= p->max_size) {        if (stream_seek(p->original, s->pos) < 1)            return -1;        return stream_read(p->original, buffer, max_len);    }    // Size of file changes -> invalidate last block    if (s->pos >= p->size - BLOCK_SIZE) {        int64_t new_size = -1;        stream_control(s, STREAM_CTRL_GET_SIZE, &new_size);        if (new_size != p->size)            set_bit(p, BLOCK_ALIGN(p->size), 0);        p->size = MPMIN(p->max_size, new_size);    }    int64_t aligned = BLOCK_ALIGN(s->pos);    if (!test_bit(p, aligned)) {        char tmp[BLOCK_SIZE];        stream_seek(p->original, aligned);        int r = stream_read(p->original, tmp, BLOCK_SIZE);        if (r < BLOCK_SIZE) {            if (p->size < 0) {                MP_WARN(s, "suspected EOF/n");            } else if (aligned + r < p->size) {                MP_ERR(s, "unexpected EOF/n");                return -1;            }        }        if (fseeko(p->cache_file, aligned, SEEK_SET))            return -1;        if (fwrite(tmp, r, 1, p->cache_file) != 1)            return -1;        set_bit(p, aligned, 1);    }    if (fseeko(p->cache_file, s->pos, SEEK_SET))        return -1;    // align/limit to blocks    max_len = MPMIN(max_len, BLOCK_SIZE - (s->pos % BLOCK_SIZE));    // Limit to max. known file size    max_len = MPMIN(max_len, p->size - s->pos);    return fread(buffer, 1, max_len, p->cache_file);}

static int d_open(demuxer_t *demuxer, enum demux_check check){    struct priv *p = demuxer->priv = talloc_zero(demuxer, struct priv);    if (check != DEMUX_CHECK_FORCE)        return -1;    char *demux = "+lavf";    if (demuxer->stream->uncached_type == STREAMTYPE_CDDA)        demux = "+rawaudio";    char *t = NULL;    stream_control(demuxer->stream, STREAM_CTRL_GET_DISC_NAME, &t);    if (t) {        mp_tags_set_bstr(demuxer->metadata, bstr0("TITLE"), bstr0(t));        talloc_free(t);    }    // Initialize the playback time. We need to read _some_ data to get the    // correct stream-layer time (at least with libdvdnav).    stream_peek(demuxer->stream, 1);    reset_pts(demuxer);    p->slave = demux_open(demuxer->stream, demux, NULL, demuxer->global);    if (!p->slave)        return -1;    // So that we don't miss initial packets of delayed subtitle streams.    demux_set_stream_autoselect(p->slave, true);    // Can be seekable even if the stream isn't.    demuxer->seekable = true;    // With cache enabled, the stream can be seekable. This causes demux_lavf.c    // (actually libavformat/mpegts.c) to seek sometimes when reading a packet.    // It does this to seek back a bit in case the current file position points    // into the middle of a packet.    demuxer->stream->seekable = false;    add_dvd_streams(demuxer);    add_streams(demuxer);    add_stream_chapters(demuxer);    return 0;}

int demuxer_set_angle(demuxer_t *demuxer, int angle){    int ris, angles = -1;    angles = demuxer_angles_count(demuxer);    if ((angles < 1) || (angle > angles))        return -1;    demux_flush(demuxer);    ris = stream_control(demuxer->stream, STREAM_CTRL_SET_ANGLE, &angle);    if (ris == STREAM_UNSUPPORTED)        return -1;    demux_control(demuxer, DEMUXER_CTRL_RESYNC, NULL);    return angle;}

static int open_f(stream_t *stream, int mode, void* opts, int* file_format){    stream->type = STREAMTYPE_MEMORY;    stream->fill_buffer = fill_buffer;    stream->seek = seek;    stream->control = control;    stream->read_chunk = 1024 * 1024;    struct priv *p = talloc_zero(stream, struct priv);    stream->priv = p;    // Initial data    bstr data = bstr0(stream->url);    bstr_eatstart0(&data, "memory://");    stream_control(stream, STREAM_CTRL_SET_CONTENTS, &data);    return STREAM_OK;}

static int d_control(demuxer_t *demuxer, int cmd, void *arg){    struct priv *p = demuxer->priv;    switch (cmd) {    case DEMUXER_CTRL_GET_TIME_LENGTH: {        double len;        if (stream_control(demuxer->stream, STREAM_CTRL_GET_TIME_LENGTH, &len) < 1)            break;        *(double *)arg = len;        return DEMUXER_CTRL_OK;    }    case DEMUXER_CTRL_RESYNC:        demux_flush(p->slave);        break; // relay to slave demuxer    case DEMUXER_CTRL_SWITCHED_TRACKS:        reselect_streams(demuxer);        return DEMUXER_CTRL_OK;    }    return demux_control(p->slave, cmd, arg);}

// Allocate state and enable navigation features. Must happen before// initializing cache, because the cache would read data. Since stream_dvdnav is// in a mode which skips all transitions on reading data (before enabling// navigation), this would skip some menu screens.void mp_nav_init(struct MPContext *mpctx){    assert(!mpctx->nav_state);    // dvdnav is interactive    if (mpctx->encode_lavc_ctx)        return;    struct mp_nav_cmd inp = {MP_NAV_CMD_ENABLE};    if (stream_control(mpctx->stream, STREAM_CTRL_NAV_CMD, &inp) < 1)        return;    mpctx->nav_state = talloc_zero(NULL, struct mp_nav_state);    mpctx->nav_state->log = mp_log_new(mpctx->nav_state, mpctx->log, "discnav");    MP_VERBOSE(mpctx->nav_state, "enabling/n");    mp_input_enable_section(mpctx->input, "discnav", 0);    mp_input_set_section_mouse_area(mpctx->input, "discnav-menu",                                    INT_MIN, INT_MIN, INT_MAX, INT_MAX);}

// Runs in the cache threadstatic void cache_execute_control(struct priv *s){    uint64_t old_pos = stream_tell(s->stream);    s->control_res = stream_control(s->stream, s->control, s->control_arg);    s->control_flush = false;    bool pos_changed = old_pos != stream_tell(s->stream);    bool ok = s->control_res == STREAM_OK;    if (pos_changed && !ok) {        mp_msg(MSGT_STREAM, MSGL_ERR, "STREAM_CTRL changed stream pos but "               "returned error, this is not allowed!/n");    } else if (pos_changed || (ok && control_needs_flush(s->control))) {        mp_msg(MSGT_CACHE, MSGL_V, "Dropping cache due to control()/n");        s->read_filepos = stream_tell(s->stream);        s->control_flush = true;        cache_drop_contents(s);    }    s->control = CACHE_CTRL_NONE;    pthread_cond_signal(&s->wakeup);}

static int64_t mp_seek(void *opaque, int64_t pos, int whence){	muxer_t *muxer = opaque;	if(whence == SEEK_CUR)	{		off_t cur = stream_tell(muxer->stream);		if(cur == -1)			return -1;		pos += cur;	}	else if(whence == SEEK_END)	{		uint64_t size=0;		if(stream_control(muxer->stream, STREAM_CTRL_GET_SIZE, &size) == STREAM_UNSUPPORTED || size < pos)			return -1;		pos = size - pos;	}	mp_msg(MSGT_MUXER, MSGL_DBG2, "SEEK %"PRIu64"/n", (int64_t)pos);	if(!stream_seek(muxer->stream, pos))		return -1;	return 0;}

void stream_dump(struct MPContext *mpctx){    struct MPOpts *opts = mpctx->opts;    char *filename = opts->stream_dump;    stream_t *stream = mpctx->stream;    assert(stream && filename);    int64_t size = 0;    stream_control(stream, STREAM_CTRL_GET_SIZE, &size);    stream_set_capture_file(stream, filename);    while (mpctx->stop_play == KEEP_PLAYING && !stream->eof) {        if (!opts->quiet && ((stream->pos / (1024 * 1024)) % 2) == 1) {            uint64_t pos = stream->pos;            MP_MSG(mpctx, MSGL_STATUS, "Dumping %lld/%lld...",                   (long long int)pos, (long long int)size);        }        stream_fill_buffer(stream);        mp_process_input(mpctx);    }}

static void set_dvdsub_fake_extradata(struct dec_sub *dec_sub, struct stream *st,                                      int width, int height){    if (!st)        return;    struct stream_dvd_info_req info;    if (stream_control(st, STREAM_CTRL_GET_DVD_INFO, &info) < 0)        return;    struct mp_csp_params csp = MP_CSP_PARAMS_DEFAULTS;    csp.int_bits_in = 8;    csp.int_bits_out = 8;    float cmatrix[3][4];    mp_get_yuv2rgb_coeffs(&csp, cmatrix);    if (width == 0 || height == 0) {        width = 720;        height = 480;    }    char *s = NULL;    s = talloc_asprintf_append(s, "size: %dx%d/n", width, height);    s = talloc_asprintf_append(s, "palette: ");    for (int i = 0; i < 16; i++) {        int color = info.palette[i];        int c[3] = {(color >> 16) & 0xff, (color >> 8) & 0xff, color & 0xff};        mp_map_int_color(cmatrix, 8, c);        color = (c[2] << 16) | (c[1] << 8) | c[0];        if (i != 0)            talloc_asprintf_append(s, ", ");        s = talloc_asprintf_append(s, "%06x", color);    }    s = talloc_asprintf_append(s, "/n");    sub_set_extradata(dec_sub, s, strlen(s));    talloc_free(s);}

//.........这里部分代码省略.........        {            guiInfo.sh_video = data;            if (data)            {                sh_video_t *sh = data;                codecname = sh->codec->name;                /* we have video, show the video window */                if(!IsWindowVisible(mygui->videowindow) || IsIconic(mygui->videowindow))                    ShowWindow(mygui->videowindow, SW_SHOWNORMAL);                if(WinID == -1)                    update_videowindow();            }            break;        }        case GUI_SETUP_VIDEO_WINDOW:        {            guiInfo.VideoWidth = vo_dwidth;            guiInfo.VideoHeight = vo_dheight;            video_aspect = (float)guiInfo.VideoWidth/guiInfo.VideoHeight;            if(WinID != -1)               update_videowindow();            break;        }        case GUI_SET_STREAM:        {            guiInfo.StreamType = stream->type;            switch(stream->type)            {                case STREAMTYPE_DVD:                    guiInfo.Tracks = 0;                    stream_control(stream, STREAM_CTRL_GET_NUM_TITLES, &guiInfo.Tracks);                    guiInfo.Chapters = 0;                    stream_control(stream, STREAM_CTRL_GET_NUM_CHAPTERS, &guiInfo.Chapters);                    guiInfo.Angles = 0;                    stream_control(stream, STREAM_CTRL_GET_NUM_ANGLES, &guiInfo.Angles);                    guiInfo.Track = 0;                    stream_control(stream, STREAM_CTRL_GET_CURRENT_TITLE, &guiInfo.Track);                    guiInfo.Track++;                    // guiInfo.Chapter will be set by mplayer                    guiInfo.Angle = 1;                    stream_control(stream, STREAM_CTRL_GET_ANGLE, &guiInfo.Angle);#ifdef CONFIG_DVDREAD                    dvdp = stream->priv;                    guiInfo.AudioStreams = dvdp->nr_of_channels;                    memcpy(guiInfo.AudioStream, dvdp->audio_streams, sizeof(dvdp->audio_streams));                    guiInfo.Subtitles = dvdp->nr_of_subtitles;                    memcpy(guiInfo.Subtitle, dvdp->subtitles, sizeof(dvdp->subtitles));#endif                    break;            }            break;        }        case GUI_REDRAW:            mygui->updatedisplay(mygui, mygui->mainwindow);            break;        case GUI_SET_AFILTER:            guiInfo.afilter = data;            break;        case GUI_SET_STATE:        {            guiInfo.Playing = (int) data;            switch (guiInfo.Playing)            {

/** * @brief Convert #guiInfo member Filename. * * @param how 0 (cut file path and extension), *            1 (additionally, convert lower case) or *            2 (additionally, convert upper case) or *            4 (unaltered title if available, otherwise like 0) * @param fname memory location of a buffer to receive the converted Filename * @param maxlen size of the @a fname buffer * * @return pointer to the @a fname buffer */static char *TranslateFilename (int how, char *fname, size_t maxlen){    char *p;    size_t len;    stream_t *stream;    switch (guiInfo.StreamType)    {        case STREAMTYPE_FILE:            if ((how == 4) && guiInfo.Title)                av_strlcpy(fname, guiInfo.Title, maxlen);            else if (guiInfo.Filename && *guiInfo.Filename)            {                p = strrchr(guiInfo.Filename, '//');                if (p) av_strlcpy(fname, p + 1, maxlen);                else av_strlcpy(fname, guiInfo.Filename, maxlen);                len = strlen(fname);                if (len > 3 && fname[len - 3] == '.') fname[len - 3] = 0;                else if (len > 4 && fname[len - 4] == '.') fname[len - 4] = 0;                else if (len > 5 && fname[len - 5] == '.') fname[len - 5] = 0;            }            else av_strlcpy(fname, MSGTR_GUI_MSG_NoFileLoaded, maxlen);            break;        case STREAMTYPE_STREAM:            av_strlcpy(fname, guiInfo.Filename, maxlen);            break;        case STREAMTYPE_CDDA:            snprintf(fname, maxlen, MSGTR_GUI_TitleN, guiInfo.Track);            break;        case STREAMTYPE_VCD:            snprintf(fname, maxlen, MSGTR_GUI_TitleN, guiInfo.Track - 1);            break;        case STREAMTYPE_DVD:            if (guiInfo.Chapter) snprintf(fname, maxlen, MSGTR_GUI_ChapterN, guiInfo.Chapter);            else av_strlcpy(fname, MSGTR_GUI_NoChapter, maxlen);            break;        case STREAMTYPE_TV:        case STREAMTYPE_DVB:            p = MSGTR_GUI_NoChannelName;            stream = mpctx_get_stream(guiInfo.mpcontext);            if (stream) stream_control(stream, STREAM_CTRL_GET_CURRENT_CHANNEL, &p);            av_strlcpy(fname, p, maxlen);            break;        default:            av_strlcpy(fname, MSGTR_GUI_MSG_NoMediaOpened, maxlen);            break;    }    if (how == 1) strlower(fname);    if (how == 2) strupper(fname);    return fname;}