static int Seek(access_t *access, uint64_t position)
{
access_sys_t *sys = access->p_sys;
const rar_file_t *file = sys->file;
if (position > file->real_size)
position = file->real_size;
sys->position = position;
/* Search the chunk */
const rar_file_chunk_t *old_chunk = sys->chunk;
for (int i = 0; i < file->chunk_count; i++) {
sys->chunk = file->chunk[i];
if (position < sys->chunk->cummulated_size + sys->chunk->size)
break;
}
const uint64_t offset = sys->chunk->offset +
(position - sys->chunk->cummulated_size);
if (strcmp(old_chunk->mrl, sys->chunk->mrl)) {
if (sys->s)
vlc_stream_Delete(sys->s);
sys->s = vlc_stream_NewMRL(access, sys->chunk->mrl);
}
return sys->s ? vlc_stream_Seek(sys->s, offset) : VLC_EGENERIC;
}
int DoAcoustIdWebRequest( vlc_object_t *p_obj, acoustid_fingerprint_t *p_data )
{
if ( !p_data->psz_fingerprint ) return VLC_SUCCESS;
char *psz_url;
if( unlikely(asprintf( &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 )) )
return VLC_EGENERIC;
msg_Dbg( p_obj, "Querying AcoustID from %s", psz_url );
int i_saved_flags = p_obj->obj.flags;
p_obj->obj.flags |= OBJECT_FLAGS_NOINTERACT;
stream_t *p_stream = vlc_stream_NewMRL( p_obj, psz_url );
free( psz_url );
p_obj->obj.flags = i_saved_flags;
if ( p_stream == NULL )
return VLC_EGENERIC;
/* read answer */
char *p_buffer = NULL;
int i_ret = 0;
for( ;; )
{
int i_read = 65536;
if( i_ret >= INT_MAX - i_read )
break;
p_buffer = realloc_or_free( p_buffer, 1 + i_ret + i_read );
if( unlikely(p_buffer == NULL) )
{
vlc_stream_Delete( p_stream );
return VLC_ENOMEM;
}
i_read = vlc_stream_Read( p_stream, &p_buffer[i_ret], i_read );
if( i_read <= 0 )
break;
i_ret += i_read;
}
vlc_stream_Delete( p_stream );
p_buffer[i_ret] = 0;
if ( ParseJson( p_obj, p_buffer, & p_data->results ) )
msg_Dbg( p_obj, "results count == %d", p_data->results.count );
else
msg_Dbg( p_obj, "No results" );
return VLC_SUCCESS;
}
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;
uint64_t i_size;
p_stream = vlc_stream_NewMRL( 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;
}
if( vlc_stream_GetSize( p_stream, &i_size ) || i_size > SSIZE_MAX )
{
msg_Dbg( p_image->p_parent, "could not read %s", psz_url );
goto error;
}
p_block = vlc_stream_Block( p_stream, i_size );
if( p_block == NULL )
goto error;
if( !p_fmt_in->i_chroma )
{
char *psz_mime = stream_ContentType( p_stream );
if( psz_mime != NULL )
{
p_fmt_in->i_chroma = image_Mime2Fourcc( psz_mime );
free( psz_mime );
}
}
vlc_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;
error:
vlc_stream_Delete( p_stream );
return NULL;
}
static int FindDesignated( addons_finder_t *p_finder )
{
char *psz_manifest;
const char *psz_path = p_finder->psz_uri + 7; // remove scheme
if ( asprintf( &psz_manifest, "file://%s#!/manifest.xml",
psz_path ) < 1 )
return VLC_ENOMEM;
stream_t *p_stream = vlc_stream_NewMRL( p_finder, psz_manifest );
free( psz_manifest );
if ( !p_stream ) return VLC_EGENERIC;
if ( ParseCategoriesInfo( p_finder, p_stream ) )
{
/* Do archive uri fixup */
FOREACH_ARRAY( addon_entry_t *p_entry, p_finder->entries )
if ( likely( !p_entry->psz_archive_uri ) )
p_entry->psz_archive_uri = strdup( p_finder->psz_uri );
FOREACH_END()
}
else
{
static int Retrieve( addons_finder_t *p_finder, addon_entry_t *p_entry )
{
vlc_mutex_lock( &p_entry->lock );
if ( !p_entry->psz_archive_uri )
{
vlc_mutex_unlock( &p_entry->lock );
return VLC_EGENERIC;
}
char *psz_archive_uri = strdup( p_entry->psz_archive_uri );
vlc_mutex_unlock( &p_entry->lock );
if ( !psz_archive_uri )
return VLC_ENOMEM;
/* get archive and parse manifest */
stream_t *p_stream;
if ( psz_archive_uri[0] == '/' )
{
/* Relative path */
char *psz_uri;
if ( ! asprintf( &psz_uri, ADDONS_REPO_SCHEMEHOST"%s", psz_archive_uri ) )
{
free( psz_archive_uri );
return VLC_ENOMEM;
}
p_stream = vlc_stream_NewURL_ND( p_finder, psz_uri );
free( psz_uri );
}
else
{
p_stream = vlc_stream_NewURL_ND( p_finder, psz_archive_uri );
}
msg_Dbg( p_finder, "downloading archive %s", psz_archive_uri );
free ( 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" );
vlc_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);
vlc_stream_Delete( p_stream );
return VLC_EGENERIC;
}
char buffer[1<<10];
int i_read = 0;
while ( ( i_read = vlc_stream_Read( p_stream, &buffer, 1<<10 ) ) > 0 )
{
if ( fwrite( &buffer, i_read, 1, p_destfile ) < 1 )
{
msg_Err( p_finder, "Failed to write to Addon file" );
fclose( p_destfile );
vlc_stream_Delete( p_stream );
return VLC_EGENERIC;
}
}
fclose( p_destfile );
vlc_stream_Delete( p_stream );
msg_Dbg( p_finder, "Reading manifest from %s", p_finder->p_sys->psz_tempfile );
char *psz_tempfileuri = vlc_path2uri( p_finder->p_sys->psz_tempfile, NULL );
if ( !psz_tempfileuri )
return VLC_ENOMEM;
char *psz_manifest_uri;
if ( asprintf( &psz_manifest_uri, "%s#!/manifest.xml", psz_tempfileuri ) < 1 )
{
free( psz_tempfileuri );
return VLC_ENOMEM;
}
p_stream = vlc_stream_NewMRL( p_finder, psz_manifest_uri );
free( psz_manifest_uri );
if ( !p_stream )
{
free( psz_tempfileuri );
return VLC_EGENERIC;
}
vlc_mutex_lock( &p_entry->lock );
int i_ret = ( ParseManifest( p_finder, p_entry, psz_tempfileuri, p_stream ) > 0 )
? VLC_SUCCESS : VLC_EGENERIC;
vlc_mutex_unlock( &p_entry->lock );
free( psz_tempfileuri );
vlc_stream_Delete( p_stream );
return i_ret;
}
int RarAccessOpen(vlc_object_t *object)
{
access_t *access = (access_t*)object;
const char *name = strchr(access->psz_location, '|');
if (name == NULL)
return VLC_EGENERIC;
char *base = strndup(access->psz_location, name - access->psz_location);
if (unlikely(base == NULL))
return VLC_ENOMEM;
name++;
vlc_uri_decode(base);
stream_t *s = vlc_stream_NewMRL(access, base);
if (!s || RarProbe(s))
goto error;
struct
{
int filescount;
rar_file_t **files;
unsigned int i_nbvols;
} newscheme = { 0, NULL, 0 }, oldscheme = { 0, NULL, 0 }, *p_scheme;
if (RarParse(s, &newscheme.filescount, &newscheme.files, &newscheme.i_nbvols, false)
|| newscheme.filescount < 1 || newscheme.i_nbvols < 2 )
{
/* We might want to lookup old naming scheme, could be a part1.rar,part1.r00 */
vlc_stream_Seek(s, 0);
RarParse(s, &oldscheme.filescount, &oldscheme.files, &oldscheme.i_nbvols, true);
}
if (oldscheme.filescount >= newscheme.filescount && oldscheme.i_nbvols > newscheme.i_nbvols)
{
for (int i = 0; i < newscheme.filescount; i++)
RarFileDelete(newscheme.files[i]);
free(newscheme.files);
p_scheme = &oldscheme;
msg_Dbg(s, "using rar old naming for %d files nbvols %u", p_scheme->filescount, oldscheme.i_nbvols);
}
else if (newscheme.filescount)
{
for (int i = 0; i < oldscheme.filescount; i++)
RarFileDelete(oldscheme.files[i]);
free(oldscheme.files);
p_scheme = &newscheme;
msg_Dbg(s, "using rar new naming for %d files nbvols %u", p_scheme->filescount, oldscheme.i_nbvols);
}
else
{
msg_Info(s, "Invalid or unsupported RAR archive");
for (int i = 0; i < oldscheme.filescount; i++)
RarFileDelete(oldscheme.files[i]);
free(oldscheme.files);
for (int i = 0; i < newscheme.filescount; i++)
RarFileDelete(newscheme.files[i]);
free(newscheme.files);
goto error;
}
rar_file_t *file = NULL;
for (int i = 0; i < p_scheme->filescount; i++) {
if (!file && !strcmp(p_scheme->files[i]->name, name))
file = p_scheme->files[i];
else
RarFileDelete(p_scheme->files[i]);
}
free(p_scheme->files);
if (!file)
goto error;
access_sys_t *sys = access->p_sys = malloc(sizeof(*sys));
sys->s = s;
sys->file = file;
access->pf_read = Read;
access->pf_block = NULL;
access->pf_control = Control;
access->pf_seek = Seek;
rar_file_chunk_t dummy = {
.mrl = base,
};
sys->chunk = &dummy;
Seek(access, 0);
free(base);
return VLC_SUCCESS;
error:
if (s)
vlc_stream_Delete(s);
free(base);
return VLC_EGENERIC;
}
