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, "https://fingerprint.videolan.org/"
"acoustid.php?meta=recordings+tracks+usermeta+"
"releases&duration=%d&fingerprint=%s",
p_data->i_duration, p_data->psz_fingerprint ) < 1 ) )
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_NewURL( p_obj, psz_url );
free( psz_url );
p_obj->obj.flags = i_saved_flags;
if ( p_stream == NULL )
return VLC_EGENERIC;
stream_t *p_chain = vlc_stream_FilterNew( p_stream, "inflate" );
if( p_chain )
p_stream = p_chain;
/* 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" );
free( p_buffer );
return VLC_SUCCESS;
}
static module_config_t *vlc_config_create (module_t *module, int type)
{
unsigned confsize = module->confsize;
module_config_t *tab = module->p_config;
if ((confsize & 0xf) == 0)
{
tab = realloc_or_free (tab, (confsize + 17) * sizeof (*tab));
if (tab == NULL)
return NULL;
module->p_config = tab;
}
memset (tab + confsize, 0, sizeof (tab[confsize]));
if (IsConfigIntegerType (type))
{
tab[confsize].max.i = INT_MAX;
tab[confsize].min.i = INT_MIN;
}
tab[confsize].i_type = type;
if (type & CONFIG_ITEM)
{
module->i_config_items++;
if (type == CONFIG_ITEM_BOOL)
module->i_bool_items++;
}
module->confsize++;
return tab + confsize;
}
ssize_t ListAdd( list_t *p_list, overlay_t *p_new )
{
/* Find an available slot */
for( overlay_t **pp_cur = p_list->pp_head;
pp_cur < p_list->pp_tail;
++pp_cur )
{
if( *pp_cur == NULL )
{
*pp_cur = p_new;
return pp_cur - p_list->pp_head;
}
}
/* Have to expand */
size_t i_size = p_list->pp_tail - p_list->pp_head;
size_t i_newsize = i_size * 2;
p_list->pp_head = realloc_or_free( p_list->pp_head,
i_newsize * sizeof( overlay_t * ) );
if( p_list->pp_head == NULL )
return VLC_ENOMEM;
p_list->pp_tail = p_list->pp_head + i_newsize;
memset( p_list->pp_head + i_size, 0, i_size * sizeof( overlay_t * ) );
p_list->pp_head[i_size] = p_new;
return i_size;
}
/* Create the p_sys->p_csd that will be sent via PutInput */
static int CSDDup(decoder_t *p_dec, const struct csd *p_csd, size_t i_count)
{
decoder_sys_t *p_sys = p_dec->p_sys;
unsigned int i_last_csd_count = p_sys->i_csd_count;
p_sys->i_csd_count = i_count;
/* free previous p_buf if old count is bigger */
for (size_t i = p_sys->i_csd_count; i < i_last_csd_count; ++i)
free(p_sys->p_csd[i].p_buf);
p_sys->p_csd = realloc_or_free(p_sys->p_csd, p_sys->i_csd_count *
sizeof(struct csd));
if (!p_sys->p_csd)
{
CSDFree(p_dec);
return VLC_ENOMEM;
}
if (p_sys->i_csd_count > i_last_csd_count)
memset(&p_sys->p_csd[i_last_csd_count], 0,
(p_sys->i_csd_count - i_last_csd_count) * sizeof(struct csd));
for (size_t i = 0; i < p_sys->i_csd_count; ++i)
{
p_sys->p_csd[i].p_buf = realloc_or_free(p_sys->p_csd[i].p_buf,
p_csd[i].i_size);
if (!p_sys->p_csd[i].p_buf)
{
CSDFree(p_dec);
return VLC_ENOMEM;
}
memcpy(p_sys->p_csd[i].p_buf, p_csd[i].p_buf, p_csd[i].i_size);
p_sys->p_csd[i].i_size = p_csd[i].i_size;
}
return VLC_SUCCESS;
}
static char *ParseText(uint8_t *data, int size, const char *charset)
{
char *text = strdup("");
int text_size = 0;
for (int i = 0; i < size; i++) {
uint8_t code = data[i];
if (code == 0x8f)
break;
char tmp[16] = "";
char *t = tmp;
if ((code >= 0x20 && code <= 0x7e) ||
(code >= 0xa0 && code <= 0xff) )
snprintf(tmp, sizeof(tmp), "%c", code);
#if 0
else if (code == 0x80)
snprintf(tmp, sizeof(tmp), "<i>");
else if (code == 0x81)
snprintf(tmp, sizeof(tmp), "</i>");
else if (code == 0x82)
snprintf(tmp, sizeof(tmp), "<u>");
else if (code == 0x83)
snprintf(tmp, sizeof(tmp), "</u>");
else if (code == 0x8a)
snprintf(tmp, sizeof(tmp), "\n");
#endif
else {
t = NULL;
}
if (!t)
continue;
size_t t_size = strlen(t);
text = realloc_or_free(text, t_size + text_size + 1);
if (!text)
continue;
memcpy(&text[text_size], t, t_size);
text_size += t_size;
text[text_size] = '\0';
}
return FromCharset(charset, text, text_size);
}
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 picture_t *Filter( filter_t *p_filter, picture_t *p_pic )
{
picture_t *p_outpic;
filter_sys_t *p_sys = p_filter->p_sys;
const int i_dim = p_sys->i_dim;
type_t *pt_buffer;
type_t *pt_scale;
const type_t *pt_distribution = p_sys->pt_distribution;
if( !p_pic ) return NULL;
p_outpic = filter_NewPicture( p_filter );
if( !p_outpic )
{
picture_Release( p_pic );
return NULL;
}
if( !p_sys->pt_buffer )
{
p_sys->pt_buffer = realloc_or_free( p_sys->pt_buffer,
p_pic->p[Y_PLANE].i_visible_lines *
p_pic->p[Y_PLANE].i_pitch * sizeof( type_t ) );
}
pt_buffer = p_sys->pt_buffer;
if( !p_sys->pt_scale )
{
const int i_visible_lines = p_pic->p[Y_PLANE].i_visible_lines;
const int i_visible_pitch = p_pic->p[Y_PLANE].i_visible_pitch;
const int i_pitch = p_pic->p[Y_PLANE].i_pitch;
p_sys->pt_scale = xmalloc( i_visible_lines * i_pitch * sizeof( type_t ) );
pt_scale = p_sys->pt_scale;
for( int i_line = 0; i_line < i_visible_lines; i_line++ )
{
for( int i_col = 0; i_col < i_visible_pitch; i_col++ )
{
type_t t_value = 0;
for( int y = __MAX( -i_dim, -i_line );
y <= __MIN( i_dim, i_visible_lines - i_line - 1 );
y++ )
{
for( int x = __MAX( -i_dim, -i_col );
x <= __MIN( i_dim, i_visible_pitch - i_col + 1 );
x++ )
{
t_value += pt_distribution[y+i_dim] *
pt_distribution[x+i_dim];
}
}
pt_scale[i_line*i_pitch+i_col] = t_value;
}
}
}
pt_scale = p_sys->pt_scale;
for( int i_plane = 0 ; i_plane < p_pic->i_planes ; i_plane++ )
{
uint8_t *p_in = p_pic->p[i_plane].p_pixels;
uint8_t *p_out = p_outpic->p[i_plane].p_pixels;
const int i_visible_lines = p_pic->p[i_plane].i_visible_lines;
const int i_visible_pitch = p_pic->p[i_plane].i_visible_pitch;
const int i_in_pitch = p_pic->p[i_plane].i_pitch;
const int x_factor = p_pic->p[Y_PLANE].i_visible_pitch/i_visible_pitch-1;
const int y_factor = p_pic->p[Y_PLANE].i_visible_lines/i_visible_lines-1;
for( int i_line = 0; i_line < i_visible_lines; i_line++ )
{
for( int i_col = 0; i_col < i_visible_pitch; i_col++ )
{
type_t t_value = 0;
const int c = i_line*i_in_pitch+i_col;
for( int x = __MAX( -i_dim, -i_col*(x_factor+1) );
x <= __MIN( i_dim, (i_visible_pitch - i_col)*(x_factor+1) + 1 );
x++ )
{
t_value += pt_distribution[x+i_dim] *
p_in[c+(x>>x_factor)];
}
pt_buffer[c] = t_value;
}
}
for( int i_line = 0; i_line < i_visible_lines; i_line++ )
{
for( int i_col = 0; i_col < i_visible_pitch; i_col++ )
{
type_t t_value = 0;
const int c = i_line*i_in_pitch+i_col;
for( int y = __MAX( -i_dim, (-i_line)*(y_factor+1) );
y <= __MIN( i_dim, (i_visible_lines - i_line)*(y_factor+1) - 1 );
y++ )
{
t_value += pt_distribution[y+i_dim] *
pt_buffer[c+(y>>y_factor)*i_in_pitch];
}
const type_t t_scale = pt_scale[(i_line<<y_factor)*(i_in_pitch<<x_factor)+(i_col<<x_factor)];
p_out[i_line * p_outpic->p[i_plane].i_pitch + i_col] = (uint8_t)(t_value / t_scale); // FIXME wouldn't it be better to round instead of trunc ?
}
}
}
return CopyInfoAndRelease( p_outpic, p_pic );
}
char *stream_ReadLine( stream_t *s )
{
stream_priv_t *priv = (stream_priv_t *)s;
char *p_line = NULL;
int i_line = 0, i_read = 0;
/* Let's fail quickly if this is a readdir access */
if( s->pf_read == NULL )
return NULL;
for( ;; )
{
char *psz_eol;
const uint8_t *p_data;
int i_data;
int64_t i_pos;
/* Probe new data */
i_data = stream_Peek( s, &p_data, STREAM_PROBE_LINE );
if( i_data <= 0 ) break; /* No more data */
/* BOM detection */
i_pos = stream_Tell( s );
if( i_pos == 0 && i_data >= 2 )
{
const char *psz_encoding = NULL;
if( !memcmp( p_data, "\xFF\xFE", 2 ) )
{
psz_encoding = "UTF-16LE";
priv->text.little_endian = true;
}
else if( !memcmp( p_data, "\xFE\xFF", 2 ) )
{
psz_encoding = "UTF-16BE";
}
/* Open the converter if we need it */
if( psz_encoding != NULL )
{
msg_Dbg( s, "UTF-16 BOM detected" );
priv->text.char_width = 2;
priv->text.conv = vlc_iconv_open( "UTF-8", psz_encoding );
if( priv->text.conv == (vlc_iconv_t)-1 )
msg_Err( s, "iconv_open failed" );
}
}
if( i_data % priv->text.char_width )
{
/* keep i_char_width boundary */
i_data = i_data - ( i_data % priv->text.char_width );
msg_Warn( s, "the read is not i_char_width compatible");
}
if( i_data == 0 )
break;
/* Check if there is an EOL */
if( priv->text.char_width == 1 )
{
/* UTF-8: 0A <LF> */
psz_eol = memchr( p_data, '\n', i_data );
if( psz_eol == NULL )
/* UTF-8: 0D <CR> */
psz_eol = memchr( p_data, '\r', i_data );
}
else
{
const uint8_t *p_last = p_data + i_data - priv->text.char_width;
uint16_t eol = priv->text.little_endian ? 0x0A00 : 0x00A0;
assert( priv->text.char_width == 2 );
psz_eol = NULL;
/* UTF-16: 000A <LF> */
for( const uint8_t *p = p_data; p <= p_last; p += 2 )
{
if( U16_AT( p ) == eol )
{
psz_eol = (char *)p + 1;
break;
}
}
if( psz_eol == NULL )
{ /* UTF-16: 000D <CR> */
eol = priv->text.little_endian ? 0x0D00 : 0x00D0;
for( const uint8_t *p = p_data; p <= p_last; p += 2 )
{
if( U16_AT( p ) == eol )
{
psz_eol = (char *)p + 1;
break;
}
}
}
}
if( psz_eol )
{
i_data = (psz_eol - (char *)p_data) + 1;
p_line = realloc_or_free( p_line,
i_line + i_data + priv->text.char_width ); /* add \0 */
if( !p_line )
goto error;
i_data = stream_Read( s, &p_line[i_line], i_data );
if( i_data <= 0 ) break; /* Hmmm */
i_line += i_data - priv->text.char_width; /* skip \n */;
i_read += i_data;
/* We have our line */
break;
}
/* Read data (+1 for easy \0 append) */
p_line = realloc_or_free( p_line,
i_line + STREAM_PROBE_LINE + priv->text.char_width );
if( !p_line )
goto error;
i_data = stream_Read( s, &p_line[i_line], STREAM_PROBE_LINE );
if( i_data <= 0 ) break; /* Hmmm */
i_line += i_data;
i_read += i_data;
if( i_read >= STREAM_LINE_MAX )
goto error; /* line too long */
}
if( i_read > 0 )
{
memset(p_line + i_line, 0, priv->text.char_width);
i_line += priv->text.char_width; /* the added \0 */
if( priv->text.char_width > 1 )
{
int i_new_line = 0;
size_t i_in = 0, i_out = 0;
const char * p_in = NULL;
char * p_out = NULL;
char * psz_new_line = NULL;
/* iconv */
/* UTF-8 needs at most 150% of the buffer as many as UTF-16 */
i_new_line = i_line * 3 / 2;
psz_new_line = malloc( i_new_line );
if( psz_new_line == NULL )
goto error;
i_in = (size_t)i_line;
i_out = (size_t)i_new_line;
p_in = p_line;
p_out = psz_new_line;
if( vlc_iconv( priv->text.conv, &p_in, &i_in, &p_out, &i_out ) == (size_t)-1 )
{
msg_Err( s, "iconv failed" );
msg_Dbg( s, "original: %d, in %d, out %d", i_line, (int)i_in, (int)i_out );
}
free( p_line );
p_line = psz_new_line;
i_line = (size_t)i_new_line - i_out; /* does not include \0 */
}
/* Remove trailing LF/CR */
while( i_line >= 2 && ( p_line[i_line-2] == '\r' ||
p_line[i_line-2] == '\n') ) i_line--;
/* Make sure the \0 is there */
p_line[i_line-1] = '\0';
return p_line;
}
error:
/* We failed to read any data, probably EOF */
free( p_line );
/* */
if( priv->text.conv != (vlc_iconv_t)(-1) )
{
vlc_iconv_close( priv->text.conv );
priv->text.conv = (vlc_iconv_t)(-1);
}
return NULL;
}
