static bool
nfs_check_status(access_t *p_access, int i_status, const char *psz_error,
const char *psz_func)
{
access_sys_t *sys = p_access->p_sys;
if (i_status < 0)
{
if (i_status != -EINTR)
{
msg_Err(p_access, "%s failed: %d, '%s'", psz_func, i_status,
psz_error);
if (!sys->b_error)
vlc_dialog_display_error(p_access,
_("NFS operation failed"), "%s",
psz_error);
}
else
msg_Warn(p_access, "%s interrupted", psz_func);
sys->b_error = true;
return true;
}
else
return false;
}
/*****************************************************************************
* Close the current file and open another
*****************************************************************************/
static bool SwitchFile( access_t *p_access, unsigned i_file )
{
access_sys_t *p_sys = p_access->p_sys;
/* requested file already open? */
if( p_sys->fd != -1 && p_sys->i_current_file == i_file )
return true;
/* close old file */
if( p_sys->fd != -1 )
{
vlc_close( p_sys->fd );
p_sys->fd = -1;
}
/* switch */
if( i_file >= FILE_COUNT )
return false;
p_sys->i_current_file = i_file;
/* open new file */
char *psz_path = GetFilePath( p_access, i_file );
if( !psz_path )
return false;
p_sys->fd = vlc_open( psz_path, O_RDONLY );
if( p_sys->fd == -1 )
{
msg_Err( p_access, "Failed to open %s: %s", psz_path,
vlc_strerror_c(errno) );
goto error;
}
/* cannot handle anything except normal files */
struct stat st;
if( fstat( p_sys->fd, &st ) || !S_ISREG( st.st_mode ) )
{
msg_Err( p_access, "%s is not a regular file", psz_path );
goto error;
}
OptimizeForRead( p_sys->fd );
msg_Dbg( p_access, "opened %s", psz_path );
free( psz_path );
return true;
error:
vlc_dialog_display_error (p_access, _("File reading failed"), _("VLC could not"
" open the file \"%s\" (%s)."), psz_path, vlc_strerror(errno) );
if( p_sys->fd != -1 )
{
vlc_close( p_sys->fd );
p_sys->fd = -1;
}
free( psz_path );
return false;
}
static int Open (vlc_object_t *obj)
{
access_t *access = (access_t *)obj;
access_sys_t *sys = malloc (sizeof (*sys));
if (unlikely(sys == NULL))
return VLC_ENOMEM;
var_LocationParse (obj, access->psz_location, "dvb-");
dvb_device_t *dev = dvb_open (obj);
if (dev == NULL)
{
free (sys);
return VLC_EGENERIC;
}
sys->dev = dev;
sys->signal_poll = 0;
sys->pf_setup = NULL;
access->p_sys = sys;
uint64_t freq = var_InheritFrequency (obj);
if (freq != 0)
{
dtv_delivery_t d = GuessSystem (access->psz_name, dev);
if(d != DTV_DELIVERY_NONE)
sys->pf_setup = dtv_get_delivery_tuner_setup(d);
if (sys->pf_setup == NULL || Tune (obj, dev, sys->pf_setup, freq))
{
msg_Err (obj, "tuning to %"PRIu64" Hz failed", freq);
vlc_dialog_display_error (obj, N_("Digital broadcasting"),
N_("The selected digital tuner does not support "
"the specified parameters.\n"
"Please check the preferences."));
goto error;
}
}
dvb_add_pid (dev, 0);
access->pf_block = Read;
access->pf_control = Control;
return VLC_SUCCESS;
error:
Close (obj);
access->p_sys = NULL;
return VLC_EGENERIC;
}
/*****************************************************************************
* Read and concatenate files
*****************************************************************************/
static ssize_t Read( access_t *p_access, void *p_buffer, size_t i_len )
{
access_sys_t *p_sys = p_access->p_sys;
if( p_sys->fd == -1 )
/* no more data */
return 0;
ssize_t i_ret = read( p_sys->fd, p_buffer, i_len );
if( i_ret > 0 )
{
/* success */
p_sys->offset += i_ret;
UpdateFileSize( p_access );
FindSeekpoint( p_access );
return i_ret;
}
else if( i_ret == 0 )
{
/* check for new files in case the recording is still active */
if( p_sys->i_current_file >= FILE_COUNT - 1 )
ImportNextFile( p_access );
/* play next file */
SwitchFile( p_access, p_sys->i_current_file + 1 );
return -1;
}
else if( errno == EINTR )
{
/* try again later */
return -1;
}
else
{
/* abort on read error */
msg_Err( p_access, "failed to read (%s)", vlc_strerror_c(errno) );
vlc_dialog_display_error( p_access, _("File reading failed"),
_("VLC could not read the file (%s)."),
vlc_strerror(errno) );
SwitchFile( p_access, -1 );
return 0;
}
}
/* see http://www.iana.org/assignments/rtp-parameters */
void rtp_autodetect (demux_t *demux, rtp_session_t *session,
const block_t *block)
{
uint8_t ptype = rtp_ptype (block);
rtp_pt_t pt = {
.init = NULL,
.destroy = codec_destroy,
.decode = codec_decode,
.frequency = 0,
.number = ptype,
};
/* Remember to keep this in sync with modules/services_discovery/sap.c */
switch (ptype)
{
case 0:
msg_Dbg (demux, "detected G.711 mu-law");
pt.init = pcmu_init;
pt.frequency = 8000;
break;
case 3:
msg_Dbg (demux, "detected GSM");
pt.init = gsm_init;
pt.frequency = 8000;
break;
case 8:
msg_Dbg (demux, "detected G.711 A-law");
pt.init = pcma_init;
pt.frequency = 8000;
break;
case 10:
msg_Dbg (demux, "detected stereo PCM");
pt.init = l16s_init;
pt.frequency = 44100;
break;
case 11:
msg_Dbg (demux, "detected mono PCM");
pt.init = l16m_init;
pt.frequency = 44100;
break;
case 12:
msg_Dbg (demux, "detected QCELP");
pt.init = qcelp_init;
pt.frequency = 8000;
break;
case 14:
msg_Dbg (demux, "detected MPEG Audio");
pt.init = mpa_init;
pt.decode = mpa_decode;
pt.frequency = 90000;
break;
case 32:
msg_Dbg (demux, "detected MPEG Video");
pt.init = mpv_init;
pt.decode = mpv_decode;
pt.frequency = 90000;
break;
case 33:
msg_Dbg (demux, "detected MPEG2 TS");
pt.init = ts_init;
pt.destroy = stream_destroy;
pt.decode = stream_decode;
pt.frequency = 90000;
break;
default:
/*
* If the rtp payload type is unknown then check demux if it is specified
*/
if (!strcmp(demux->psz_demux, "h264")
|| !strcmp(demux->psz_demux, "ts"))
{
msg_Dbg (demux, "dynamic payload format %s specified by demux",
demux->psz_demux);
pt.init = demux_init;
pt.destroy = stream_destroy;
pt.decode = stream_decode;
pt.frequency = 90000;
break;
}
if (ptype >= 96)
{
char *dynamic = var_InheritString(demux, "rtp-dynamic-pt");
if (dynamic == NULL)
;
else if (!strcmp(dynamic, "theora"))
{
msg_Dbg (demux, "assuming Theora Encoded Video");
pt.init = theora_init;
pt.destroy = xiph_destroy;
pt.decode = xiph_decode;
pt.frequency = 90000;
}
else
msg_Err (demux, "unknown dynamic payload format `%s' "
"specified", dynamic);
free (dynamic);
}
msg_Err (demux, "unspecified payload format (type %"PRIu8")", ptype);
msg_Info (demux, "A valid SDP is needed to parse this RTP stream.");
vlc_dialog_display_error (demux, N_("SDP required"),
N_("A description in SDP format is required to receive the RTP "
"stream. Note that rtp:// URIs cannot work with dynamic "
"RTP payload format (%"PRIu8")."), ptype);
return;
}
rtp_add_type (demux, session, &pt);
}
/*****************************************************************************
* Run : call Handshake() then submit songs
*****************************************************************************/
static void *Run(void *data)
{
intf_thread_t *p_intf = data;
uint8_t p_buffer[1024];
int canc = vlc_savecancel();
bool b_handshaked = false;
bool b_nowp_submission_ongoing = false;
/* data about audioscrobbler session */
mtime_t next_exchange = 0; /**< when can we send data */
unsigned int i_interval = 0; /**< waiting interval (secs)*/
intf_sys_t *p_sys = p_intf->p_sys;
/* main loop */
for (;;)
{
vlc_restorecancel(canc);
mwait(next_exchange);
vlc_mutex_lock(&p_sys->lock);
mutex_cleanup_push(&p_sys->lock);
while (p_sys->i_songs == 0 && p_sys->b_submit_nowp == false)
vlc_cond_wait(&p_sys->wait, &p_sys->lock);
vlc_cleanup_pop();
vlc_mutex_unlock(&p_sys->lock);
canc = vlc_savecancel();
/* handshake if needed */
if (!b_handshaked)
{
msg_Dbg(p_intf, "Handshaking with last.fm ...");
switch(Handshake(p_intf))
{
case VLC_ENOMEM:
goto out;
case VLC_ENOVAR:
/* username not set */
vlc_dialog_display_error(p_intf,
_("Last.fm username not set"),
"%s", _("Please set a username or disable the "
"audioscrobbler plugin, and restart VLC.\n"
"Visit http://www.last.fm/join/ to get an account."));
goto out;
case VLC_SUCCESS:
msg_Dbg(p_intf, "Handshake successful :)");
b_handshaked = true;
i_interval = 0;
next_exchange = 0;
break;
case VLC_AUDIOSCROBBLER_EFATAL:
msg_Warn(p_intf, "Exiting...");
goto out;
case VLC_EGENERIC:
default:
/* protocol error : we'll try later */
HandleInterval(&next_exchange, &i_interval);
break;
}
/* if handshake failed let's restart the loop */
if (!b_handshaked)
continue;
}
msg_Dbg(p_intf, "Going to submit some data...");
char *psz_submit;
vlc_url_t *url;
char *psz_submit_song, *psz_submit_tmp;
if (asprintf(&psz_submit, "s=%s", p_sys->psz_auth_token) == -1)
break;
/* forge the HTTP POST request */
vlc_mutex_lock(&p_sys->lock);
if (p_sys->b_submit_nowp)
{
b_nowp_submission_ongoing = true;
url = &p_sys->p_nowp_url;
if (asprintf(&psz_submit_song,
"&a=%s"
"&t=%s"
"&b=%s"
"&l=%d"
"&n=%s"
"&m=%s",
p_sys->p_current_song.psz_a,
p_sys->p_current_song.psz_t,
p_sys->p_current_song.psz_b ? p_sys->p_current_song.psz_b : "",
p_sys->p_current_song.i_l,
p_sys->p_current_song.psz_n ? p_sys->p_current_song.psz_n : "",
p_sys->p_current_song.psz_m ? p_sys->p_current_song.psz_m : ""
) == -1)
{ /* Out of memory */
vlc_mutex_unlock(&p_sys->lock);
goto out;
}
}
else
{
url = &p_sys->p_submit_url;
audioscrobbler_song_t *p_song;
for (int i_song = 0 ; i_song < p_sys->i_songs ; i_song++)
{
p_song = &p_sys->p_queue[i_song];
if (asprintf(&psz_submit_song,
"&a%%5B%d%%5D=%s"
"&t%%5B%d%%5D=%s"
"&i%%5B%d%%5D=%u"
"&o%%5B%d%%5D=P"
"&r%%5B%d%%5D="
"&l%%5B%d%%5D=%d"
"&b%%5B%d%%5D=%s"
"&n%%5B%d%%5D=%s"
"&m%%5B%d%%5D=%s",
i_song, p_song->psz_a,
i_song, p_song->psz_t,
i_song, (unsigned)p_song->date, /* HACK: %ju (uintmax_t) unsupported on Windows */
i_song,
i_song,
i_song, p_song->i_l,
i_song, p_song->psz_b ? p_song->psz_b : "",
i_song, p_song->psz_n ? p_song->psz_n : "",
i_song, p_song->psz_m ? p_song->psz_m : ""
) == -1)
{ /* Out of memory */
vlc_mutex_unlock(&p_sys->lock);
goto out;
}
}
}
psz_submit_tmp = psz_submit;
int print_ret = asprintf(&psz_submit, "%s%s",
psz_submit_tmp, psz_submit_song);
free(psz_submit_tmp);
free(psz_submit_song);
vlc_mutex_unlock(&p_sys->lock);
if (print_ret == -1)
{ /* Out of memory */
goto out;
}
int i_post_socket = net_ConnectTCP(p_intf, url->psz_host,
url->i_port);
if (i_post_socket == -1)
{
/* If connection fails, we assume we must handshake again */
HandleInterval(&next_exchange, &i_interval);
b_handshaked = false;
free(psz_submit);
continue;
}
/* we transmit the data */
int i_net_ret = net_Printf(p_intf, i_post_socket,
"POST %s HTTP/1.1\r\n"
"Host: %s\r\n"
"User-Agent: "PACKAGE_NAME"/"PACKAGE_VERSION"\r\n"
"Connection: close\r\n"
"Accept-Encoding: identity\r\n"
"Content-Type: application/x-www-form-urlencoded\r\n"
"Content-Length: %zu\r\n"
"\r\n"
"%s\r\n"
"\r\n",
url->psz_path, url->psz_host, strlen(psz_submit), psz_submit);
free(psz_submit);
if (i_net_ret == -1)
{
/* If connection fails, we assume we must handshake again */
HandleInterval(&next_exchange, &i_interval);
b_handshaked = false;
net_Close(i_post_socket);
continue;
}
/* FIXME: this might wait forever */
struct pollfd ufd = { .fd = i_post_socket, .events = POLLIN };
while( poll( &ufd, 1, -1 ) == -1 );
/* FIXME: With TCP, you should never assume that a single read will
* return the entire response... */
i_net_ret = recv(i_post_socket, p_buffer, sizeof(p_buffer) - 1, 0);
if (i_net_ret <= 0)
{
/* if we get no answer, something went wrong : try again */
net_Close(i_post_socket);
continue;
}
net_Close(i_post_socket);
p_buffer[i_net_ret] = '\0';
char *failed = strstr((char *) p_buffer, "FAILED");
if (failed)
{
msg_Warn(p_intf, "%s", failed);
HandleInterval(&next_exchange, &i_interval);
continue;
}
if (strstr((char *) p_buffer, "BADSESSION"))
{
msg_Err(p_intf, "Authentication failed (BADSESSION), are you connected to last.fm with another program ?");
b_handshaked = false;
HandleInterval(&next_exchange, &i_interval);
continue;
}
if (strstr((char *) p_buffer, "OK"))
{
if (b_nowp_submission_ongoing)
{
b_nowp_submission_ongoing = false;
p_sys->b_submit_nowp = false;
}
else
{
for (int i = 0; i < p_sys->i_songs; i++)
DeleteSong(&p_sys->p_queue[i]);
p_sys->i_songs = 0;
}
i_interval = 0;
next_exchange = 0;
msg_Dbg(p_intf, "Submission successful!");
}
else
{
msg_Err(p_intf, "Authentication failed, handshaking again (%s)",
p_buffer);
b_handshaked = false;
HandleInterval(&next_exchange, &i_interval);
}
}
out:
vlc_restorecancel(canc);
return NULL;
}
/*****************************************************************************
* Handshake : Init audioscrobbler connection
*****************************************************************************/
static int Handshake(intf_thread_t *p_this)
{
char *psz_username, *psz_password;
char *psz_scrobbler_url;
time_t timestamp;
char psz_timestamp[21];
struct md5_s p_struct_md5;
stream_t *p_stream;
char *psz_handshake_url;
uint8_t p_buffer[1024];
char *p_buffer_pos;
int i_ret;
char *psz_url;
intf_thread_t *p_intf = (intf_thread_t*) p_this;
intf_sys_t *p_sys = p_this->p_sys;
psz_username = var_InheritString(p_this, "lastfm-username");
psz_password = var_InheritString(p_this, "lastfm-password");
/* username or password have not been setup */
if (EMPTY_STR(psz_username) || EMPTY_STR(psz_password))
{
free(psz_username);
free(psz_password);
return VLC_ENOVAR;
}
time(×tamp);
/* generates a md5 hash of the password */
InitMD5(&p_struct_md5);
AddMD5(&p_struct_md5, (uint8_t*) psz_password, strlen(psz_password));
EndMD5(&p_struct_md5);
free(psz_password);
char *psz_password_md5 = psz_md5_hash(&p_struct_md5);
if (!psz_password_md5)
{
free(psz_username);
return VLC_ENOMEM;
}
snprintf(psz_timestamp, sizeof(psz_timestamp), "%"PRIu64,
(uint64_t)timestamp);
/* generates a md5 hash of :
* - md5 hash of the password, plus
* - timestamp in clear text
*/
InitMD5(&p_struct_md5);
AddMD5(&p_struct_md5, (uint8_t*) psz_password_md5, 32);
AddMD5(&p_struct_md5, (uint8_t*) psz_timestamp, strlen(psz_timestamp));
EndMD5(&p_struct_md5);
free(psz_password_md5);
char *psz_auth_token = psz_md5_hash(&p_struct_md5);
if (!psz_auth_token)
{
free(psz_username);
return VLC_ENOMEM;
}
psz_scrobbler_url = var_InheritString(p_this, "scrobbler-url");
if (!psz_scrobbler_url)
{
free(psz_auth_token);
free(psz_username);
return VLC_ENOMEM;
}
i_ret = asprintf(&psz_handshake_url,
"http://%s/?hs=true&p=1.2&c="CLIENT_NAME"&v="CLIENT_VERSION"&u=%s&t=%s&a=%s"
, psz_scrobbler_url, psz_username, psz_timestamp, psz_auth_token);
free(psz_auth_token);
free(psz_scrobbler_url);
free(psz_username);
if (i_ret == -1)
return VLC_ENOMEM;
/* send the http handshake request */
p_stream = stream_UrlNew(p_intf, psz_handshake_url);
free(psz_handshake_url);
if (!p_stream)
return VLC_EGENERIC;
/* read answer */
i_ret = stream_Read(p_stream, p_buffer, sizeof(p_buffer) - 1);
if (i_ret <= 0)
{
stream_Delete(p_stream);
return VLC_EGENERIC;
}
p_buffer[i_ret] = '\0';
stream_Delete(p_stream);
p_buffer_pos = strstr((char*) p_buffer, "FAILED ");
if (p_buffer_pos)
{
/* handshake request failed, sorry */
msg_Err(p_this, "last.fm handshake failed: %s", p_buffer_pos + 7);
return VLC_EGENERIC;
}
if (strstr((char*) p_buffer, "BADAUTH"))
{
/* authentication failed, bad username/password combination */
vlc_dialog_display_error(p_this,
_("last.fm: Authentication failed"),
"%s", _("last.fm username or password is incorrect. "
"Please verify your settings and relaunch VLC."));
return VLC_AUDIOSCROBBLER_EFATAL;
}
if (strstr((char*) p_buffer, "BANNED"))
{
/* oops, our version of vlc has been banned by last.fm servers */
msg_Err(p_intf, "This version of VLC has been banned by last.fm. "
"You should upgrade VLC, or disable the last.fm plugin.");
return VLC_AUDIOSCROBBLER_EFATAL;
}
if (strstr((char*) p_buffer, "BADTIME"))
{
/* The system clock isn't good */
msg_Err(p_intf, "last.fm handshake failed because your clock is too "
"much shifted. Please correct it, and relaunch VLC.");
return VLC_AUDIOSCROBBLER_EFATAL;
}
p_buffer_pos = strstr((char*) p_buffer, "OK");
if (!p_buffer_pos)
goto proto;
p_buffer_pos = strstr(p_buffer_pos, "\n");
if (!p_buffer_pos || strlen(p_buffer_pos) < 33)
goto proto;
p_buffer_pos++; /* we skip the '\n' */
/* save the session ID */
memcpy(p_sys->psz_auth_token, p_buffer_pos, 32);
p_sys->psz_auth_token[32] = '\0';
p_buffer_pos = strstr(p_buffer_pos, "http://");
if (!p_buffer_pos || strlen(p_buffer_pos) == 7)
goto proto;
/* We need to read the nowplaying url */
p_buffer_pos += 7; /* we skip "http://" */
psz_url = strndup(p_buffer_pos, strcspn(p_buffer_pos, "\n"));
if (!psz_url)
goto oom;
vlc_UrlParse(&p_sys->p_nowp_url, psz_url);
free(psz_url);
if (p_sys->p_nowp_url.psz_host == NULL ||
p_sys->p_nowp_url.i_port == 0)
{
vlc_UrlClean(&p_sys->p_nowp_url);
goto proto;
}
p_buffer_pos = strstr(p_buffer_pos, "http://");
if (!p_buffer_pos || strlen(p_buffer_pos) == 7)
goto proto;
/* We need to read the submission url */
p_buffer_pos += 7; /* we skip "http://" */
psz_url = strndup(p_buffer_pos, strcspn(p_buffer_pos, "\n"));
if (!psz_url)
goto oom;
/* parse the submission url */
vlc_UrlParse(&p_sys->p_submit_url, psz_url);
free(psz_url);
if (p_sys->p_submit_url.psz_host == NULL ||
p_sys->p_submit_url.i_port == 0)
{
vlc_UrlClean(&p_sys->p_nowp_url);
vlc_UrlClean(&p_sys->p_submit_url);
goto proto;
}
return VLC_SUCCESS;
oom:
return VLC_ENOMEM;
proto:
msg_Err(p_intf, "Handshake: can't recognize server protocol");
return VLC_EGENERIC;
}
/*****************************************************************************
* Run : call Handshake() then submit songs
*****************************************************************************/
static void *Run(void *data)
{
intf_thread_t *p_intf = data;
uint8_t p_buffer[1024];
int canc = vlc_savecancel();
bool b_handshaked = false;
bool b_nowp_submission_ongoing = false;
/* data about audioscrobbler session */
vlc_tick_t next_exchange = VLC_TICK_INVALID; /**< when can we send data */
unsigned int i_interval = 0; /**< waiting interval (secs)*/
intf_sys_t *p_sys = p_intf->p_sys;
/* main loop */
for (;;)
{
vlc_restorecancel(canc);
if (next_exchange != VLC_TICK_INVALID)
vlc_tick_wait(next_exchange);
vlc_mutex_lock(&p_sys->lock);
mutex_cleanup_push(&p_sys->lock);
while (p_sys->i_songs == 0 && p_sys->b_submit_nowp == false)
vlc_cond_wait(&p_sys->wait, &p_sys->lock);
vlc_cleanup_pop();
vlc_mutex_unlock(&p_sys->lock);
canc = vlc_savecancel();
/* handshake if needed */
if (!b_handshaked)
{
msg_Dbg(p_intf, "Handshaking with last.fm ...");
switch(Handshake(p_intf))
{
case VLC_ENOMEM:
goto out;
case VLC_ENOVAR:
/* username not set */
vlc_dialog_display_error(p_intf,
_("Last.fm username not set"),
"%s", _("Please set a username or disable the "
"audioscrobbler plugin, and restart VLC.\n"
"Visit http://www.last.fm/join/ to get an account."));
goto out;
case VLC_SUCCESS:
msg_Dbg(p_intf, "Handshake successful :)");
b_handshaked = true;
i_interval = 0;
next_exchange = VLC_TICK_INVALID;
break;
case VLC_AUDIOSCROBBLER_EFATAL:
msg_Warn(p_intf, "Exiting...");
goto out;
case VLC_EGENERIC:
default:
/* protocol error : we'll try later */
HandleInterval(&next_exchange, &i_interval);
break;
}
/* if handshake failed let's restart the loop */
if (!b_handshaked)
continue;
}
msg_Dbg(p_intf, "Going to submit some data...");
vlc_url_t *url;
struct vlc_memstream req, payload;
vlc_memstream_open(&payload);
vlc_memstream_printf(&payload, "s=%s", p_sys->psz_auth_token);
/* forge the HTTP POST request */
vlc_mutex_lock(&p_sys->lock);
if (p_sys->b_submit_nowp)
{
audioscrobbler_song_t *p_song = &p_sys->p_current_song;
b_nowp_submission_ongoing = true;
url = &p_sys->p_nowp_url;
vlc_memstream_printf(&payload, "&a=%s", p_song->psz_a);
vlc_memstream_printf(&payload, "&t=%s", p_song->psz_t);
vlc_memstream_puts(&payload, "&b=");
if (p_song->psz_b != NULL)
vlc_memstream_puts(&payload, p_song->psz_b);
vlc_memstream_printf(&payload, "&l=%d", p_song->i_l);
vlc_memstream_puts(&payload, "&n=");
if (p_song->psz_n != NULL)
vlc_memstream_puts(&payload, p_song->psz_n);
vlc_memstream_puts(&payload, "&m=");
if (p_song->psz_m != NULL)
vlc_memstream_puts(&payload, p_song->psz_m);
}
else
{
url = &p_sys->p_submit_url;
for (int i_song = 0 ; i_song < p_sys->i_songs ; i_song++)
{
audioscrobbler_song_t *p_song = &p_sys->p_queue[i_song];
vlc_memstream_printf(&payload, "&a%%5B%d%%5D=%s",
i_song, p_song->psz_a);
vlc_memstream_printf(&payload, "&t%%5B%d%%5D=%s",
i_song, p_song->psz_t);
vlc_memstream_printf(&payload, "&i%%5B%d%%5D=%"PRIu64,
i_song, (uint64_t)p_song->date);
vlc_memstream_printf(&payload, "&o%%5B%d%%5D=P", i_song);
vlc_memstream_printf(&payload, "&r%%5B%d%%5D=", i_song);
vlc_memstream_printf(&payload, "&l%%5B%d%%5D=%d",
i_song, p_song->i_l);
vlc_memstream_printf(&payload, "&b=%%5B%d%%5D=", i_song);
if (p_song->psz_b != NULL)
vlc_memstream_puts(&payload, p_song->psz_b);
vlc_memstream_printf(&payload, "&n=%%5B%d%%5D=", i_song);
if (p_song->psz_n != NULL)
vlc_memstream_puts(&payload, p_song->psz_n);
vlc_memstream_printf(&payload, "&m=%%5B%d%%5D=", i_song);
if (p_song->psz_m != NULL)
vlc_memstream_puts(&payload, p_song->psz_m);
}
}
vlc_mutex_unlock(&p_sys->lock);
if (vlc_memstream_close(&payload))
goto out;
vlc_memstream_open(&req);
vlc_memstream_printf(&req, "POST %s HTTP/1.1\r\n", url->psz_path);
vlc_memstream_printf(&req, "Host: %s\r\n", url->psz_host);
vlc_memstream_puts(&req, "User-Agent:"
" "PACKAGE_NAME"/"PACKAGE_VERSION"\r\n");
vlc_memstream_puts(&req, "Connection: close\r\n");
vlc_memstream_puts(&req, "Accept-Encoding: identity\r\n");
vlc_memstream_puts(&req, "Content-Type:"
" application/x-www-form-urlencoded\r\n");
vlc_memstream_printf(&req, "Content-Length: %zu\r\n", payload.length);
vlc_memstream_puts(&req, "\r\n");
/* Could avoid copying payload with iovec... but efforts */
vlc_memstream_write(&req, payload.ptr, payload.length);
vlc_memstream_puts(&req, "\r\n\r\n");
free(payload.ptr);
if (vlc_memstream_close(&req)) /* Out of memory */
goto out;
vlc_tls_t *sock = vlc_tls_SocketOpenTCP(VLC_OBJECT(p_intf),
url->psz_host, url->i_port);
if (sock == NULL)
{
/* If connection fails, we assume we must handshake again */
HandleInterval(&next_exchange, &i_interval);
b_handshaked = false;
free(req.ptr);
continue;
}
/* we transmit the data */
int i_net_ret = vlc_tls_Write(sock, req.ptr, req.length);
free(req.ptr);
if (i_net_ret == -1)
{
/* If connection fails, we assume we must handshake again */
HandleInterval(&next_exchange, &i_interval);
b_handshaked = false;
vlc_tls_Close(sock);
continue;
}
/* FIXME: this might wait forever */
/* FIXME: With TCP, you should never assume that a single read will
* return the entire response... */
i_net_ret = vlc_tls_Read(sock, p_buffer, sizeof(p_buffer) - 1, false);
vlc_tls_Close(sock);
if (i_net_ret <= 0)
{
/* if we get no answer, something went wrong : try again */
continue;
}
p_buffer[i_net_ret] = '\0';
char *failed = strstr((char *) p_buffer, "FAILED");
if (failed)
{
msg_Warn(p_intf, "%s", failed);
HandleInterval(&next_exchange, &i_interval);
continue;
}
if (strstr((char *) p_buffer, "BADSESSION"))
{
msg_Err(p_intf, "Authentication failed (BADSESSION), are you connected to last.fm with another program ?");
b_handshaked = false;
HandleInterval(&next_exchange, &i_interval);
continue;
}
if (strstr((char *) p_buffer, "OK"))
{
if (b_nowp_submission_ongoing)
{
b_nowp_submission_ongoing = false;
p_sys->b_submit_nowp = false;
}
else
{
for (int i = 0; i < p_sys->i_songs; i++)
DeleteSong(&p_sys->p_queue[i]);
p_sys->i_songs = 0;
}
i_interval = 0;
next_exchange = VLC_TICK_INVALID;
msg_Dbg(p_intf, "Submission successful!");
}
else
{
msg_Err(p_intf, "Authentication failed, handshaking again (%s)",
p_buffer);
b_handshaked = false;
HandleInterval(&next_exchange, &i_interval);
}
}
out:
vlc_restorecancel(canc);
return NULL;
}
/**
* Probes and initializes.
*/
static int Open (vlc_object_t *obj)
{
services_discovery_t *sd = (services_discovery_t *)obj;
services_discovery_sys_t *p_sys = malloc (sizeof (*p_sys));
if (p_sys == NULL)
return VLC_ENOMEM;
sd->p_sys = p_sys;
sd->description = _("Screen capture");
/* Connect to X server */
char *display = var_InheritString (obj, "x11-display");
int snum;
xcb_connection_t *conn = xcb_connect (display, &snum);
free (display);
if (xcb_connection_has_error (conn))
{
free (p_sys);
return VLC_EGENERIC;
}
p_sys->conn = conn;
/* Find configured screen */
const xcb_setup_t *setup = xcb_get_setup (conn);
const xcb_screen_t *scr = NULL;
for (xcb_screen_iterator_t i = xcb_setup_roots_iterator (setup);
i.rem > 0; xcb_screen_next (&i))
{
if (snum == 0)
{
scr = i.data;
break;
}
snum--;
}
if (scr == NULL)
{
msg_Err (obj, "bad X11 screen number");
goto error;
}
/* Add a permanent item for the entire desktop */
AddDesktop (sd);
p_sys->root_window = scr->root;
xcb_change_window_attributes (conn, scr->root, XCB_CW_EVENT_MASK,
&(uint32_t) { XCB_EVENT_MASK_PROPERTY_CHANGE });
/* TODO: check that _NET_CLIENT_LIST is in _NET_SUPPORTED
* (and _NET_SUPPORTING_WM_CHECK) */
xcb_intern_atom_reply_t *r;
xcb_intern_atom_cookie_t ncl, nwn;
ncl = xcb_intern_atom (conn, 1, strlen ("_NET_CLIENT_LIST"),
"_NET_CLIENT_LIST");
nwn = xcb_intern_atom (conn, 0, strlen ("_NET_WM_NAME"), "_NET_WM_NAME");
r = xcb_intern_atom_reply (conn, ncl, NULL);
if (r == NULL || r->atom == 0)
{
vlc_dialog_display_error (sd, _("Screen capture"),
_("Your window manager does not provide a list of applications."));
msg_Err (sd, "client list not supported (_NET_CLIENT_LIST absent)");
}
p_sys->net_client_list = r ? r->atom : 0;
free (r);
r = xcb_intern_atom_reply (conn, nwn, NULL);
if (r != NULL)
{
p_sys->net_wm_name = r->atom;
free (r);
}
p_sys->apps = NULL;
p_sys->apps_root = input_item_NewExt("vlc://nop", _("Applications"), -1,
ITEM_TYPE_NODE, ITEM_LOCAL);
if (likely(p_sys->apps_root != NULL))
services_discovery_AddItem(sd, p_sys->apps_root);
UpdateApps (sd);
if (vlc_clone (&p_sys->thread, Run, sd, VLC_THREAD_PRIORITY_LOW))
goto error;
return VLC_SUCCESS;
error:
xcb_disconnect (p_sys->conn);
tdestroy (p_sys->apps, DelApp);
if (p_sys->apps_root != NULL)
input_item_Release(p_sys->apps_root);
free (p_sys);
return VLC_EGENERIC;
}
static int Open (vlc_object_t *p_this)
{
decoder_t *p_dec = (decoder_t *)p_this;
if (p_dec->fmt_in.i_codec != VLC_CODEC_MIDI)
return VLC_EGENERIC;
decoder_sys_t *p_sys = malloc (sizeof (*p_sys));
if (unlikely(p_sys == NULL))
return VLC_ENOMEM;
p_sys->settings = new_fluid_settings ();
p_sys->synth = new_fluid_synth (p_sys->settings);
p_sys->soundfont = -1;
char *font_path = var_InheritString (p_this, "soundfont");
if (font_path != NULL)
{
msg_Dbg (p_this, "loading sound fonts file %s", font_path);
p_sys->soundfont = fluid_synth_sfload (p_sys->synth, font_path, 1);
if (p_sys->soundfont == -1)
msg_Err (p_this, "cannot load sound fonts file %s", font_path);
free (font_path);
}
#if defined( _POSIX_VERSION ) && !defined(__ANDROID__)
else
{
glob_t gl;
glob ("/usr/share/sounds/sf2/*.sf2", GLOB_NOESCAPE, NULL, &gl);
for (size_t i = 0; i < gl.gl_pathc; i++)
{
const char *path = gl.gl_pathv[i];
msg_Dbg (p_this, "loading sound fonts file %s", path);
p_sys->soundfont = fluid_synth_sfload (p_sys->synth, path, 1);
if (p_sys->soundfont != -1)
break; /* it worked! */
msg_Err (p_this, "cannot load sound fonts file %s", path);
}
globfree (&gl);
}
#endif
if (p_sys->soundfont == -1)
{
msg_Err (p_this, "sound font file required for synthesis");
vlc_dialog_display_error (p_this, _("MIDI synthesis not set up"),
_("A sound font file (.SF2) is required for MIDI synthesis.\n"
"Please install a sound font and configure it "
"from the VLC preferences "
"(Input / Codecs > Audio codecs > FluidSynth).\n"));
delete_fluid_synth (p_sys->synth);
delete_fluid_settings (p_sys->settings);
free (p_sys);
return VLC_EGENERIC;
}
fluid_synth_set_chorus_on (p_sys->synth,
var_InheritBool (p_this, "synth-chorus"));
fluid_synth_set_gain (p_sys->synth,
var_InheritFloat (p_this, "synth-gain"));
fluid_synth_set_polyphony (p_sys->synth,
var_InheritInteger (p_this, "synth-polyphony"));
fluid_synth_set_reverb_on (p_sys->synth,
var_InheritBool (p_this, "synth-reverb"));
p_dec->fmt_out.i_cat = AUDIO_ES;
p_dec->fmt_out.audio.i_rate =
var_InheritInteger (p_this, "synth-sample-rate");;
fluid_synth_set_sample_rate (p_sys->synth, p_dec->fmt_out.audio.i_rate);
p_dec->fmt_out.audio.i_channels = 2;
p_dec->fmt_out.audio.i_original_channels =
p_dec->fmt_out.audio.i_physical_channels =
AOUT_CHAN_LEFT | AOUT_CHAN_RIGHT;
p_dec->fmt_out.i_codec = VLC_CODEC_FL32;
p_dec->fmt_out.audio.i_bitspersample = 32;
date_Init (&p_sys->end_date, p_dec->fmt_out.audio.i_rate, 1);
date_Set (&p_sys->end_date, 0);
p_dec->p_sys = p_sys;
p_dec->pf_decode_audio = DecodeBlock;
p_dec->pf_flush = Flush;
return VLC_SUCCESS;
}
