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

/***************************************************************************** * Local functions *****************************************************************************/static int ChunkFind( demux_t *p_demux, const char *fcc, unsigned int *pi_size ){    const uint8_t *p_peek;    for( ;; )    {        uint32_t i_size;        if( stream_Peek( p_demux->s, &p_peek, 8 ) < 8 )        {            msg_Err( p_demux, "cannot peek" );            return VLC_EGENERIC;        }        i_size = GetDWLE( p_peek + 4 );        msg_Dbg( p_demux, "chunk: fcc=`%4.4s` size=%"PRIu32, p_peek, i_size );        if( !memcmp( p_peek, fcc, 4 ) )        {            if( pi_size )            {                *pi_size = i_size;            }            return VLC_SUCCESS;        }        /* Skip chunk */        if( stream_Read( p_demux->s, NULL, 8 ) != 8 ||                stream_Read( p_demux->s, NULL, i_size ) != (int)i_size ||                ( (i_size & 1) && stream_Read( p_demux->s, NULL, 1 ) != 1 ) )            return VLC_EGENERIC;    }}

int main(void){    ssize_t val;    char buf[16];    bool b;    test_init();    vlc = libvlc_new(0, NULL);    assert(vlc != NULL);    parent = VLC_OBJECT(vlc->p_libvlc_int);    s = vlc_stream_fifo_New(parent);    assert(s != NULL);    val = stream_Control(s, STREAM_CAN_SEEK, &b);    assert(val == VLC_SUCCESS && !b);    val = stream_GetSize(s, &(uint64_t){ 0 });    assert(val < 0);    val = stream_Control(s, STREAM_GET_PTS_DELAY, &(int64_t){ 0 });    assert(val == VLC_SUCCESS);    stream_Delete(s);    vlc_stream_fifo_Close(s);    s = vlc_stream_fifo_New(parent);    assert(s != NULL);    val = vlc_stream_fifo_Write(s, "123", 3);    vlc_stream_fifo_Close(s);    val = stream_Read(s, buf, sizeof (buf));    assert(val == 3);    assert(memcmp(buf, "123", 3) == 0);    val = stream_Read(s, buf, sizeof (buf));    assert(val == 0);    stream_Delete(s);    s = vlc_stream_fifo_New(parent);    assert(s != NULL);    val = vlc_stream_fifo_Write(s, "Hello ", 6);    assert(val == 6);    val = vlc_stream_fifo_Write(s, "world!/n", 7);    assert(val == 7);    val = vlc_stream_fifo_Write(s, "blahblah", 8);    assert(val == 8);    val = stream_Read(s, buf, 13);    assert(val == 13);    assert(memcmp(buf, "Hello world!/n", 13) == 0);    stream_Delete(s);    val = vlc_stream_fifo_Write(s, "cough cough", 11);    assert(val == -1 && errno == EPIPE);    vlc_stream_fifo_Close(s);    libvlc_release(vlc);    return 0;}

static int SkipEnd(stream_t *s, const rar_block_t *hdr){    if (!(hdr->flags & RAR_BLOCK_END_HAS_NEXT))        return VLC_EGENERIC;    if (SkipBlock(s, hdr))        return VLC_EGENERIC;    /* Now, we need to look for a marker block,     * It seems that there is garbage at EOF */    for (;;) {        const uint8_t *peek;        if (stream_Peek(s, &peek, rar_marker_size) < rar_marker_size)            return VLC_EGENERIC;        if (!memcmp(peek, rar_marker, rar_marker_size))            break;        if (stream_Read(s, NULL, 1) != 1)            return VLC_EGENERIC;    }    /* Skip marker and archive blocks */    if (IgnoreBlock(s, RAR_BLOCK_MARKER))        return VLC_EGENERIC;    if (IgnoreBlock(s, RAR_BLOCK_ARCHIVE))        return VLC_EGENERIC;    return VLC_SUCCESS;}

static ssize_t SkipCallback(struct archive *p_archive, void *p_object, ssize_t i_request){    VLC_UNUSED(p_archive);    callback_data_t *p_data = (callback_data_t *) p_object;    access_sys_t *p_sys = p_data->p_access->p_sys;    ssize_t i_skipped = 0;    /* be smart as small seeks converts to reads */    if (p_sys->b_source_canseek)    {        int64_t i_pos = stream_Tell(p_sys->p_stream);        if (i_pos >=0)            stream_Seek(p_sys->p_stream, i_pos + i_request);        i_skipped = stream_Tell(p_sys->p_stream) - i_pos;    }    else while(i_request)    {        int i_skip = __MIN(INT32_MAX, i_request);        int i_read = stream_Read(p_sys->p_stream, NULL, i_skip);        if (i_read > 0)            i_skipped += i_read;        else            break;        i_request -= i_read;    }    return i_skipped;}

static int64_t get_data( demux_t *p_demux, int64_t i_bytes_to_read ){    demux_sys_t *p_sys  = p_demux->p_sys;    char *buf;    int64_t i_result;    if ( p_sys->i_total_length > 0 )    {        if ( p_sys->i_input_position + i_bytes_to_read > p_sys->i_total_length )        {            i_bytes_to_read = p_sys->i_total_length - p_sys->i_input_position;            if ( i_bytes_to_read <= 0 ) {                return 0;            }        }    }    seek_byte ( p_demux, p_sys->i_input_position );    buf = ogg_sync_buffer( &p_sys->oy, i_bytes_to_read );    i_result = stream_Read( p_demux->s, buf, i_bytes_to_read );    p_sys->b_page_waiting = false;    ogg_sync_wrote( &p_sys->oy, i_result );    return i_result;}

static ssize_t Read(access_t *access, uint8_t *data, size_t size){    access_sys_t *sys = access->p_sys;    size_t total = 0;    while (total < size) {        const uint64_t chunk_end = sys->chunk->cummulated_size + sys->chunk->size;        int max = __MIN(__MIN((int64_t)(size - total), (int64_t)(chunk_end - access->info.i_pos)), INT_MAX);        if (max <= 0)            break;        int r = sys->s ? stream_Read(sys->s, data, max) : -1;        if (r <= 0)            break;        total += r;        if( data )            data += r;        access->info.i_pos += r;        if (access->info.i_pos >= chunk_end &&            Seek(access, access->info.i_pos))            break;    }    if (size > 0 && total <= 0)        access->info.b_eof = true;    return total;}

/** ************************************************************************** * /brief read something from stream into buffer * /param opaque should be the stream * /param stream stream created by ZipIO_Open * /param buf buffer to read the file * /param size length of this buffer * /return return the number of bytes read (<= size) *****************************************************************************/static unsigned long ZCALLBACK ZipIO_Read( void *opaque, void *stream,                                           void *buf, unsigned long size ){    (void) stream;    stream_t *s = (stream_t*) opaque;    return (unsigned long) stream_Read( s->p_source, buf, (int) size );}

uint32 vlc_stream_io_callback::read( void *p_buffer, size_t i_size ){    if( i_size <= 0 || mb_eof )        return 0;    return stream_Read( s, p_buffer, i_size );}

static block_t *Load(demux_t *demux){    const unsigned max_size = 4096 * 4096 * 8;    uint64_t size;    if (stream_GetSize(demux->s, &size) == VLC_SUCCESS) {        if (size > max_size) {            msg_Err(demux, "image too large (%"PRIu64" > %u), rejected",                    size, max_size);            return NULL;        }    } else        size = max_size;    block_t *block = block_Alloc(size);    if (block == NULL)        return NULL;    ssize_t val = stream_Read(demux->s, block->p_buffer, size);    if (val < 0) {        block_Release(block);        return NULL;    }    block->i_buffer = val;    return block;}

/** Replacement for luaL_dofile, using VLC's input capabilities */int vlclua_dofile( vlc_object_t *p_this, lua_State *L, const char *uri ){    if( !strstr( uri, "://" ) )        return luaL_dofile( L, uri );    if( !strncasecmp( uri, "file://", 7 ) )        return luaL_dofile( L, uri + 7 );    stream_t *s = stream_UrlNew( p_this, uri );    if( !s )    {        return 1;    }    int64_t i_size = stream_Size( s );    char *p_buffer = ( i_size > 0 ) ? malloc( i_size ) : NULL;    if( !p_buffer )    {        // FIXME: read the whole stream until we reach the end (if no size)        stream_Delete( s );        return 1;    }    int64_t i_read = stream_Read( s, p_buffer, (int) i_size );    int i_ret = ( i_read == i_size ) ? 0 : 1;    if( !i_ret )        i_ret = luaL_loadbuffer( L, p_buffer, (size_t) i_size, uri );    if( !i_ret )        i_ret = lua_pcall( L, 0, LUA_MULTRET, 0 );    stream_Delete( s );    free( p_buffer );    return i_ret;}

static int AStreamRefillStream(stream_t *s){    stream_sys_t *sys = s->p_sys;    stream_track_t *tk = &sys->tk[sys->i_tk];    /* We read but won't increase i_start after initial start + offset */    int i_toread =        __MIN(sys->i_used, STREAM_CACHE_TRACK_SIZE -               (tk->i_end - tk->i_start - sys->i_offset));    if (i_toread <= 0) return VLC_SUCCESS; /* EOF */#ifdef STREAM_DEBUG    msg_Dbg(s, "AStreamRefillStream: used=%d toread=%d",                 sys->i_used, i_toread);#endif    mtime_t start = mdate();    while (i_toread > 0)    {        int i_off = tk->i_end % STREAM_CACHE_TRACK_SIZE;        int i_read;        if (vlc_killed())            return VLC_EGENERIC;        i_read = __MIN(i_toread, STREAM_CACHE_TRACK_SIZE - i_off);        i_read = stream_Read(s->p_source, &tk->p_buffer[i_off], i_read);        /* msg_Dbg(s, "AStreamRefillStream: read=%d", i_read); */        if (i_read <  0)        {            continue;        }        else if (i_read == 0)            return VLC_SUCCESS;        /* Update end */        tk->i_end += i_read;        /* Windows of STREAM_CACHE_TRACK_SIZE */        if (tk->i_start + STREAM_CACHE_TRACK_SIZE < tk->i_end)        {            unsigned i_invalid = tk->i_end - tk->i_start - STREAM_CACHE_TRACK_SIZE;            tk->i_start += i_invalid;            sys->i_offset -= i_invalid;        }        i_toread -= i_read;        sys->i_used -= i_read;        sys->stat.i_bytes += i_read;        sys->stat.i_read_count++;    }    sys->stat.i_read_time += mdate() - start;    return VLC_SUCCESS;}

static gme_err_t ReaderStream (void *data, void *buf, int length){    stream_t *s = data;    if (stream_Read (s, buf, length) < length)        return "short read";    return NULL;}

uint32 vlc_stream_io_callback::read( void *p_buffer, size_t i_size ){    if( i_size <= 0 || mb_eof )        return 0;    int i_ret = stream_Read( s, p_buffer, i_size );    return i_ret < 0 ? 0 : i_ret;}

static void *Thread (void *data){    stream_t *stream = data;    stream_sys_t *p_sys = stream->p_sys;#ifdef HAVE_VMSPLICE    ssize_t page_mask = sysconf (_SC_PAGE_SIZE) - 1;#endif    int fd = p_sys->write_fd;    bool error = false;    do    {        ssize_t len;        int canc = vlc_savecancel ();#ifdef HAVE_VMSPLICE        unsigned char *buf = mmap (NULL, bufsize, PROT_READ|PROT_WRITE,                                   MAP_PRIVATE|MAP_ANONYMOUS, -1, 0);        vlc_cleanup_push (cleanup_mmap, buf);#else        unsigned char buf[bufsize];#endif        len = stream_Read (stream->p_source, buf, bufsize);        vlc_restorecancel (canc);        error = len <= 0;        for (ssize_t i = 0, j; i < len; i += j)        {#ifdef HAVE_VMSPLICE            if ((len - i) <= page_mask) /* incomplete last page */                j = write (fd, buf + i, len - i);            else            {                struct iovec iov = { buf + i, (len - i) & ~page_mask, };                j = vmsplice (fd, &iov, 1, SPLICE_F_GIFT);            }            if (j == -1 && errno == ENOSYS) /* vmsplice() not supported */#endif            j = write (fd, buf + i, len - i);            if (j <= 0)            {                if (j == 0)                    errno = EPIPE;                msg_Err (stream, "cannot write data (%m)");                error = true;                break;            }        }#ifdef HAVE_VMSPLICE        vlc_cleanup_run (); /* munmap (buf, bufsize) */#endif    }    while (!error);    msg_Dbg (stream, "compressed stream at EOF");    return NULL;}

static ssize_t ReadCallback(struct archive *p_archive, void *p_object, const void **pp_buffer){    VLC_UNUSED(p_archive);    callback_data_t *p_data = (callback_data_t *) p_object;    access_sys_t *p_sys = p_data->p_access->p_sys;    *pp_buffer = &p_sys->buffer;    return stream_Read(p_sys->p_stream, &p_sys->buffer, ARCHIVE_READ_SIZE);}

static int vlclua_demux_read( lua_State *L ){    demux_t *p_demux = (demux_t *)vlclua_get_this( L );    const uint8_t *p_read;    int n = luaL_checkint( L, 1 );    int i_read = stream_Peek( p_demux->s, &p_read, n );    lua_pushlstring( L, (const char *)p_read, i_read );    int i_seek = stream_Read( p_demux->s, NULL, i_read );    assert(i_read==i_seek);    return 1;}

static int InstallFile( addons_storage_t *p_this, const char *psz_downloadlink,                        const char *psz_dest ){    stream_t *p_stream;    FILE *p_destfile;    char buffer[1<<10];    int i_read = 0;    p_stream = stream_UrlNew( p_this, psz_downloadlink );    if( !p_stream )    {        msg_Err( p_this, "Failed to access Addon download url %s", psz_downloadlink );        return VLC_EGENERIC;    }    char *psz_path = strdup( psz_dest );    if ( !psz_path )    {        stream_Delete( p_stream );        return VLC_ENOMEM;    }    char *psz_buf = strrchr( psz_path, DIR_SEP_CHAR );    if( psz_buf )    {        *++psz_buf = '/0';        /* ensure directory exists */        if( !EMPTY_STR( psz_path ) ) recursive_mkdir( VLC_OBJECT(p_this), psz_path );        free( psz_path );    }    p_destfile = vlc_fopen( psz_dest, "w" );    if( !p_destfile )    {        msg_Err( p_this, "Failed to open Addon storage file %s", psz_dest );        stream_Delete( p_stream );        return VLC_EGENERIC;    }    while ( ( i_read = stream_Read( p_stream, &buffer, 1<<10 ) ) > 0 )    {        if ( fwrite( &buffer, i_read, 1, p_destfile ) < 1 )        {            msg_Err( p_this, "Failed to write to Addon file" );            fclose( p_destfile );            stream_Delete( p_stream );            return VLC_EGENERIC;        }    }    fclose( p_destfile );    stream_Delete( p_stream );    return VLC_SUCCESS;}

static int SkipBlock(stream_t *s, const rar_block_t *hdr){    uint64_t size = (uint64_t)hdr->size + hdr->add_size;    while (size > 0) {        int skip = __MIN(size, INT_MAX);        if (stream_Read(s, NULL, skip) < skip)            return VLC_EGENERIC;        size -= skip;    }    return VLC_SUCCESS;}

/***************************************************************************** * Demux: reads and demuxes data packets ***************************************************************************** * Returns -1 in case of error, 0 in case of EOF, 1 otherwise *****************************************************************************/static int Demux( demux_t *p_demux ){    demux_sys_t *p_sys  = p_demux->p_sys;    block_t     *p_block;    mtime_t i_pcr = date_Get( &p_sys->pcr );    /* Call the pace control */    es_out_Control( p_demux->out, ES_OUT_SET_PCR, VLC_TS_0 + i_pcr );    if( p_sys->b_y4m )    {        /* Skip the frame header */        /* Skip "FRAME" */        if( stream_Read( p_demux->s, NULL, 5 ) < 5 )            return 0;        /* Find /n */        for( ;; )        {            uint8_t b;            if( stream_Read( p_demux->s, &b, 1 ) < 1 )                return 0;            if( b == 0x0a )                break;        }    }    if( ( p_block = stream_Block( p_demux->s, p_sys->frame_size ) ) == NULL )    {        /* EOF */        return 0;    }    p_block->i_dts = p_block->i_pts = VLC_TS_0 + i_pcr;    es_out_Send( p_demux->out, p_sys->p_es_video, p_block );    date_Increment( &p_sys->pcr, 1 );    return 1;}

static void AStreamPrebufferStream(stream_t *s){    stream_sys_t *sys = s->p_sys;    mtime_t start = mdate();    bool first = true;    msg_Dbg(s, "starting pre-buffering");    for (;;)    {        stream_track_t *tk = &sys->tk[sys->i_tk];        mtime_t now = mdate();        int i_read;        int i_buffered = tk->i_end - tk->i_start;        if (vlc_killed() || i_buffered >= STREAM_CACHE_PREBUFFER_SIZE)        {            int64_t i_byterate;            /* Update stat */            sys->stat.i_bytes = i_buffered;            sys->stat.i_read_time = now - start;            i_byterate = (CLOCK_FREQ * sys->stat.i_bytes) /                         (sys->stat.i_read_time+1);            msg_Dbg(s, "pre-buffering done %"PRId64" bytes in %"PRId64"s - "                    "%"PRId64" KiB/s", sys->stat.i_bytes,                    sys->stat.i_read_time / CLOCK_FREQ, i_byterate / 1024);            break;        }        i_read = STREAM_CACHE_TRACK_SIZE - i_buffered;        i_read = __MIN((int)sys->i_read_size, i_read);        i_read = stream_Read(s->p_source, &tk->p_buffer[i_buffered], i_read);        if (i_read <  0)            continue;        else if (i_read == 0)            break;  /* EOF */        if (first)        {            msg_Dbg(s, "received first data after %"PRId64" ms",                    (mdate() - start) / 1000);            first = false;        }        tk->i_end += i_read;        sys->stat.i_read_count++;    }}

static int vlclua_stream_read( lua_State *L ){    int i_read;    stream_t **pp_stream = (stream_t **)luaL_checkudata( L, 1, "stream" );    int n = luaL_checkint( L, 2 );    uint8_t *p_read = malloc( n );    if( !p_read ) return vlclua_error( L );    i_read = stream_Read( *pp_stream, p_read, n );    if( i_read > 0 )        lua_pushlstring( L, (const char *)p_read, i_read );    else        lua_pushnil( L );    free( p_read );    return 1;}

/** * Reads MIDI variable length (7, 14, 21 or 28 bits) integer. * @return read value, or -1 on EOF/error. */static int32_t ReadVarInt (stream_t *s){    uint32_t val = 0;    uint8_t byte;    for (unsigned i = 0; i < 4; i++)    {        if (stream_Read (s, &byte, 1) < 1)            return -1;        val = (val << 7) | (byte & 0x7f);        if ((byte & 0x80) == 0)            return val;    }    return -1;}

static picture_t *ImageReadUrl( image_handler_t *p_image, const char *psz_url,                                video_format_t *p_fmt_in,                                video_format_t *p_fmt_out ){    block_t *p_block;    picture_t *p_pic;    stream_t *p_stream = NULL;    int i_size;    p_stream = stream_UrlNew( p_image->p_parent, psz_url );    if( !p_stream )    {        msg_Dbg( p_image->p_parent, "could not open %s for reading",                 psz_url );        return NULL;    }    i_size = stream_Size( p_stream );    p_block = block_New( p_image->p_parent, i_size );    stream_Read( p_stream, p_block->p_buffer, i_size );    if( !p_fmt_in->i_chroma )    {        char *psz_mime = NULL;        stream_Control( p_stream, STREAM_GET_CONTENT_TYPE, &psz_mime );        if( psz_mime )            p_fmt_in->i_chroma = image_Mime2Fourcc( psz_mime );        free( psz_mime );    }    stream_Delete( p_stream );    if( !p_fmt_in->i_chroma )    {        /* Try to guess format from file name */        p_fmt_in->i_chroma = image_Ext2Fourcc( psz_url );    }    p_pic = ImageRead( p_image, p_block, p_fmt_in, p_fmt_out );    return p_pic;}

OBJECT_ID ic_file_readline(VM_ID vm,TUPLE_ID locals,TUPLE_ID kw_locals){	OBJECT_ID self = tuple_GetItem(locals,0);	UNICODE_ID file_name = obj_CreateUnicode(mem_create_string("__file__"));	OBJECT_ID file_tag_id = obj_GetAttribute(self,file_name);	obj_IncRefCount(file_name);	obj_DecRefCount(file_name);	tag_object *file_tag = (tag_object*)mem_lock(file_tag_id);	if(file_tag->type == TYPE_TAG && file_tag->tag != 0);	{		MEM_ID buf_id = mem_create_buf(512);		char *buf = (char*)mem_lock(buf_id);		INDEX i = 0;		while(i<512)		{			if(!stream_Read(file_tag->tag,buf_id,i,1))			{				break;			}			if(buf[i] == '/n')			{				break;			}			i++;		}		if(i>0)		{			buf[i] = 0;			UNICODE_ID line = obj_CreateUnicode(mem_create_string(buf));			mem_unlock(buf_id,1);			mem_free(buf_id);			mem_unlock(file_tag_id,0);			return(line);		}		mem_unlock(buf_id,1);		mem_free(buf_id);		mem_unlock(file_tag_id,0);	}		OBJECT_ID tmp = obj_CreateEmpty(TYPE_NONE);	return(tmp);}

/**************************************************************************** * Stream filters functions ****************************************************************************/static int Read( stream_t *s, void *p_read, unsigned int i_read ){    stream_sys_t *p_sys = s->p_sys;    void *p_record = p_read;    /* Allocate a temporary buffer for record when no p_read */    if( p_sys->f && !p_record )        p_record = malloc( i_read );    /* */    const int i_record = stream_Read( s->p_source, p_record, i_read );    /* Dump read data */    if( p_sys->f )    {        if( p_record && i_record > 0 )            Write( s, p_record, i_record );        if( !p_read )            free( p_record );    }    return i_record;}

/** * Copy data from input stream to dump file. */static int Demux( demux_t *p_demux ){    sout_access_out_t *out = (void *)p_demux->p_sys;    block_t *block = block_Alloc( DUMP_BLOCKSIZE );    if( unlikely(block == NULL) )        return -1;    int rd = stream_Read( p_demux->s, block->p_buffer, DUMP_BLOCKSIZE );    if ( rd <= 0 )    {        block_Release( block );        return rd;    }    block->i_buffer = rd;    size_t wr = sout_AccessOutWrite( out, block );    if( wr != (size_t)rd )    {        msg_Err( p_demux, "cannot write data" );        return -1;    }    return 1;}

int DoAcoustIdWebRequest( vlc_object_t *p_obj, acoustid_fingerprint_t *p_data ){    int i_ret;    int i_status;    struct webrequest_t request = { NULL, NULL, NULL };    if ( !p_data->psz_fingerprint ) return VLC_SUCCESS;    i_ret = asprintf( & request.psz_url,              "http://fingerprint.videolan.org/acoustid.php?meta=recordings+tracks+usermeta+releases&duration=%d&fingerprint=%s",              p_data->i_duration, p_data->psz_fingerprint );    if ( i_ret < 1 ) return VLC_EGENERIC;    vlc_cleanup_push( cancelDoAcoustIdWebRequest, &request );    msg_Dbg( p_obj, "Querying AcoustID from %s", request.psz_url );    request.p_stream = stream_UrlNew( p_obj, request.psz_url );    if ( !request.p_stream )    {        i_status = VLC_EGENERIC;        goto cleanup;    }    /* read answer */    i_ret = 0;    for( ;; )    {        int i_read = 65536;        if( i_ret >= INT_MAX - i_read )            break;        request.p_buffer = realloc_or_free( request.p_buffer, 1 + i_ret + i_read );        if( !request.p_buffer )        {            i_status = VLC_ENOMEM;            goto cleanup;        }        i_read = stream_Read( request.p_stream, &request.p_buffer[i_ret], i_read );        if( i_read <= 0 )            break;        i_ret += i_read;    }    stream_Delete( request.p_stream );    request.p_stream = NULL;    request.p_buffer[ i_ret ] = 0;    int i_canc = vlc_savecancel();    if ( ParseJson( p_obj, request.p_buffer, & p_data->results ) )    {        msg_Dbg( p_obj, "results count == %d", p_data->results.count );    } else {        msg_Dbg( p_obj, "No results" );    }    vlc_restorecancel( i_canc );    i_status = VLC_SUCCESS;cleanup:    vlc_cleanup_run( );    return i_status;}

static int Retrieve( addons_finder_t *p_finder, addon_entry_t *p_entry ){    if ( !p_entry->psz_archive_uri )        return VLC_EGENERIC;    /* get archive and parse manifest */    stream_t *p_stream;    if ( p_entry->psz_archive_uri[0] == '/' )    {        /* Relative path */        char *psz_uri;        if ( ! asprintf( &psz_uri, ADDONS_REPO_SCHEMEHOST"%s", p_entry->psz_archive_uri ) )            return VLC_ENOMEM;        p_stream = stream_UrlNew( p_finder, psz_uri );        free( psz_uri );    }    else    {        p_stream = stream_UrlNew( p_finder, p_entry->psz_archive_uri );    }    msg_Dbg( p_finder, "downloading archive %s", p_entry->psz_archive_uri );    if ( !p_stream ) return VLC_EGENERIC;    /* In case of pf_ reuse */    if ( p_finder->p_sys->psz_tempfile )    {        vlc_unlink( p_finder->p_sys->psz_tempfile );        FREENULL( p_finder->p_sys->psz_tempfile );    }    p_finder->p_sys->psz_tempfile = tempnam( NULL, "vlp" );    if ( !p_finder->p_sys->psz_tempfile )    {        msg_Err( p_finder, "Can't create temp storage file" );        stream_Delete( p_stream );        return VLC_EGENERIC;    }    FILE *p_destfile = vlc_fopen( p_finder->p_sys->psz_tempfile, "w" );    if( !p_destfile )    {        msg_Err( p_finder, "Failed to open addon temp storage file" );        FREENULL(p_finder->p_sys->psz_tempfile);        stream_Delete( p_stream );        return VLC_EGENERIC;    }    char buffer[1<<10];    int i_read = 0;    while ( ( i_read = stream_Read( p_stream, &buffer, 1<<10 ) ) )    {        if ( fwrite( &buffer, i_read, 1, p_destfile ) < 1 )        {            msg_Err( p_finder, "Failed to write to Addon file" );            fclose( p_destfile );            stream_Delete( p_stream );            return VLC_EGENERIC;        }    }    fclose( p_destfile );    stream_Delete( p_stream );    msg_Dbg( p_finder, "Reading manifest from %s", p_finder->p_sys->psz_tempfile );    char *psz_manifest;    if ( asprintf( &psz_manifest, "unzip://%s!/manifest.xml",                   p_finder->p_sys->psz_tempfile ) < 1 )        return VLC_ENOMEM;    p_stream = stream_UrlNew( p_finder, psz_manifest );    free( psz_manifest );    int i_ret = ( ParseManifest( p_finder, p_entry,                                 p_finder->p_sys->psz_tempfile, p_stream ) > 0 )                    ? VLC_SUCCESS : VLC_EGENERIC;    stream_Delete( p_stream );    return i_ret;}