Recherche avancée
Autres articles (74)
-
Amélioration de la version de base
13 septembre 2013Jolie sélection multiple
Le plugin Chosen permet d’améliorer l’ergonomie des champs de sélection multiple. Voir les deux images suivantes pour comparer.
Il suffit pour cela d’activer le plugin Chosen (Configuration générale du site > Gestion des plugins), puis de configurer le plugin (Les squelettes > Chosen) en activant l’utilisation de Chosen dans le site public et en spécifiant les éléments de formulaires à améliorer, par exemple select[multiple] pour les listes à sélection multiple (...) -
Menus personnalisés
14 novembre 2010, parMediaSPIP utilise le plugin Menus pour gérer plusieurs menus configurables pour la navigation.
Cela permet de laisser aux administrateurs de canaux la possibilité de configurer finement ces menus.
Menus créés à l’initialisation du site
Par défaut trois menus sont créés automatiquement à l’initialisation du site : Le menu principal ; Identifiant : barrenav ; Ce menu s’insère en général en haut de la page après le bloc d’entête, son identifiant le rend compatible avec les squelettes basés sur Zpip ; (...) -
Gestion de la ferme
2 mars 2010, parLa ferme est gérée dans son ensemble par des "super admins".
Certains réglages peuvent être fais afin de réguler les besoins des différents canaux.
Dans un premier temps il utilise le plugin "Gestion de mutualisation"
Sur d’autres sites (11440)
-
Imagemagick convert -fill does not change edges from a particular palette area
30 décembre 2017, par Amit PatilWhen I am trying to remove
Green (#09f80c)color from this image using below commandmagick convert images/img001.png - fill transparent -opaque #09f80c images/tp.pngI am getting below image :
This image I get as an output for above command. This image still has some green dots at the edges. How to remove them completely ?
I want converted image not to have those extra pixels.
Your help would be highly appreciated.
-
Scheduling an RTMP stream remotely - using an intermediary server for storing + sending video stream packets before deploying to streaming service
25 février 2020, par hedgehog90This is more of a curiosity than something I really need, but I thought I’d ask anyway.
If I just want setup a normal livestream, I would use something like OBS, capture my input, encode it into something manageable for my network and send it to a remote rtmp server.
But I’d like to know if it’s possible to put an intermediary remote server between myself and the streaming service’s server. Basically so I can manage the stream (if it’s a playlist) and schedule when to send it to broadcast on the streaming service.
It’s also worth noting that there may be limited bandwidth on the client-side (my computer), assuming the intermediary has greater bandwidth, this method should eliminate the common issue of dropping frames while streaming.
Now for an example :
To make it simpler, instead of using OBS + capture hardware, I’m using a video file.
I want to encode that video in the same way that OBS does when streaming to a remote server via an rtmp protocol using ffmpeg.Now I upload that data, at my own rate, to a remote server that I control (running Ubuntu) for storage and eventual deployment. Importantly, I do not want or require any video-processing done on the intermediary server, as we have already encoded the data for deployment on the client-side. This is just simply managing and storing the data.
A day later, I want to run a script on my intermediary server that will then send the processed stream data, packet by packet, to the targeted streaming server.
I’m an experienced coder, with lots of experience with data handling and video encoding. It should be simple, but I’m not all that clued up on the way video streaming via RTMP works.
-
Android FFmpegPlayer Streaming Service onClick notification
8 octobre 2013, par agonyI have a MainActivity class that displays the list of streams available for my project and the StreamingActivity class where the streaming is done.
If the user selected an item from the list it will start the StreamingActivity and start playing the stream.
I'm having trouble to continue streaming music when the user pressed the notification and returning it to the StreamingActivity class if the user pressed or clicked the home menu or when the app goes to onDestroy().I'm using FFmpegPlayer for my project 'coz it requires to play mms :// live streams for local FM station.
Here's my code :
public class StreamingActivity extends BaseActivity implements ActionBar.TabListener,
PlayerControlListener, IMediaPlayerServiceClient {
private StatefulMediaPlayer mMediaPlayer;
private FFmpegService mService;
private boolean mBound;
public static final String TAG = "StationActivity";
private static Bundle mSavedInstanceState;
private static PlayerFragment mPlayerFragment;
private static DJListFragment mDjListFragment;
private SectionsPagerAdapter mSectionsPagerAdapter;
private ViewPager mViewPager;
private String stream = "";
private String fhz = "";
private String page = "0";
private Dialog shareDialog;
private ProgressDialog dialog;
private boolean isStreaming;
/*************************************************************************************************************/
@Override
public void onCreate(Bundle savedInstanceState){
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_station);
Bundle bundle = getIntent().getExtras();
if(bundle !=null){
fhz = bundle.getString("fhz");
stream = bundle.getString("stream");
}
Log.d(TAG, "page: " + page + " fhz: " + fhz + " stream: " + stream + " isStreaming: " + isStreaming);
getSupportActionBar().setTitle("Radio \n" + fhz);
getSupportActionBar().setDisplayHomeAsUpEnabled(true);
getSupportActionBar().setNavigationMode(ActionBar.NAVIGATION_MODE_TABS);
mPlayerFragment = (PlayerFragment) Fragment.instantiate(this, PlayerFragment.class.getName(), null);
mDjListFragment = (DJListFragment) Fragment.instantiate(this, DJListFragment.class.getName(), null);
mSectionsPagerAdapter = new SectionsPagerAdapter(getSupportFragmentManager());
mViewPager = (ViewPager) findViewById(R.id.pager);
mViewPager.setAdapter(mSectionsPagerAdapter);
mViewPager.setCurrentItem(Integer.parseInt(page));
mSavedInstanceState = savedInstanceState;
Tab playingTab = getSupportActionBar().newTab();
playingTab.setText(getString(R.string.playing_label));
playingTab.setTabListener(this);
Tab djTab = getSupportActionBar().newTab();
djTab.setText(getString(R.string.dj_label));
djTab.setTabListener(this);
getSupportActionBar().addTab(playingTab);
getSupportActionBar().addTab(djTab);
// When swiping between different sections, select the corresponding
// tab. We can also use ActionBar.Tab#select() to do this if we have
// a reference to the Tab.
mViewPager.setOnPageChangeListener(new ViewPager.SimpleOnPageChangeListener() {
@Override
public void onPageSelected(int position) {
StationActivity.this.getSupportActionBar().setSelectedNavigationItem(position);
}
});
if (mSavedInstanceState != null) {
getSupportActionBar().setSelectedNavigationItem(mSavedInstanceState.getInt("tab", 0));
}
dialog = new ProgressDialog(this);
bindToService();
UriBean.getInstance().setStream(stream);
Log.d(TAG ,"stream: " + UriBean.getInstance().getStream());
}
/********************************************************************************************************/
public class SectionsPagerAdapter extends FragmentPagerAdapter {
public SectionsPagerAdapter(FragmentManager fm) {
super(fm);
}
@Override
public Fragment getItem(int position) {
if (position == 0) {
return mPlayerFragment;
} else {
return mDjListFragment;
}
}
@Override
public int getCount() {
return 2;
}
}
@Override
public void onTabSelected(Tab tab, FragmentTransaction ft) {
// When the given tab is selected, switch to the corresponding page in the ViewPager.
mViewPager.setCurrentItem(tab.getPosition());
}
@Override
public void onTabUnselected(Tab tab, FragmentTransaction ft) { }
@Override
public void onTabReselected(Tab tab, FragmentTransaction ft) { }
/********************************************************************************************************/
public void showLoadingDialog() {
dialog.setMessage("Buffering...");
dialog.show();
}
public void dismissLoadingDialog() {
dialog.dismiss();
}
/********************************************************************************************************/
/**
* Binds to the instance of MediaPlayerService. If no instance of MediaPlayerService exists, it first starts
* a new instance of the service.
*/
public void bindToService() {
Intent intent = new Intent(this, FFmpegService.class);
if (Util.isFFmpegServiceRunning(getApplicationContext())){
// Bind to Service
Log.i(TAG, "bindService");
bindService(intent, mConnection, Context.BIND_AUTO_CREATE);
} else {
//start service and bind to it
Log.i(TAG, "startService & bindService");
startService(intent);
bindService(intent, mConnection, Context.BIND_AUTO_CREATE);
}
}
/**
* Defines callbacks for service binding, passed to bindService()
*/
private ServiceConnection mConnection = new ServiceConnection() {
@Override
public void onServiceConnected(ComponentName className, IBinder serviceBinder) {
Log.d(TAG,"service connected");
//bound with Service. get Service instance
MediaPlayerBinder binder = (FFmpegService.MediaPlayerBinder) serviceBinder;
mService = binder.getService();
//send this instance to the service, so it can make callbacks on this instance as a client
mService.setClient(StationActivity.this);
mBound = true;
Log.d(TAG, "isPlaying === SERVICE: " + mService.isPlaying());
//if
startStreaming();
}
@Override
public void onServiceDisconnected(ComponentName arg0) {
mBound = false;
mService = null;
}
};
/********************************************************************************************************/
@Override
public void onPlayerPlayStop() {
Log.d(TAG, "onPlayerPlayStop");
Log.v(TAG, "isStreaming: " + isStreaming);
Log.v(TAG, "mBound: " + mBound);
if (mBound) {
Log.d(TAG, "bound.............");
mMediaPlayer = mService.getMediaPlayer();
//pressed pause ->pause
if (!PlayerFragment.play.isChecked()) {
if (mMediaPlayer.isStarted()) {
Log.d(TAG, "pause");
mService.pauseMediaPlayer();
}
} else { //pressed play
// STOPPED, CREATED, EMPTY, -> initialize
if (mMediaPlayer.isStopped() || mMediaPlayer.isCreated() || mMediaPlayer.isEmpty()) {
startStreaming();
} else if (mMediaPlayer.isPrepared() || mMediaPlayer.isPaused()) { //prepared, paused -> resume play
Log.d(TAG, "start");
mService.startMediaPlayer();
}
}
Log.d(TAG, "isPlaying === SERVICE: " + mService.isPlaying());
}
}
/********************************************************************************************************/
@Override
public void onDownload() {
Toast.makeText(this, "Not yet available...", Toast.LENGTH_SHORT).show();
}
@Override
public void onComment() {
FragmentManager fm = getSupportFragmentManager();
DialogFragment newFragment = MyAlertDialogFragment.newInstance();
newFragment.show(fm, "comment_dialog");
}
@Override
public void onShare() {
showShareDialog();
}
/********************************************************************************************************/
private void startStreaming() {
Log.d(TAG, "@startLoading");
boolean isNetworkFound = Util.checkConnectivity(getApplicationContext());
if(isNetworkFound) {
Log.d(TAG, "network found");
mService.initializePlayer(stream);
isStreaming = true;
} else {
Toast.makeText(getApplicationContext(), "No internet connection found...", Toast.LENGTH_SHORT).show();
}
Log.d(TAG, "isStreaming: " + isStreaming);
Log.d(TAG, "isPlaying === SERVICE: " + mService.isPlaying());
}
@Override
public void onInitializePlayerStart() {
showLoadingDialog();
}
@Override
public void onInitializePlayerSuccess() {
dismissLoadingDialog();
PlayerFragment.play.setChecked(true);
Log.d(TAG, "isPlaying === SERVICE: " + mService.isPlaying());
}
@Override
public void onError() {
Toast.makeText(getApplicationContext(), "Not connected to the server...", Toast.LENGTH_SHORT).show();
}
@Override
public void onDestroy() {
Log.d(TAG, "onDestroy");
super.onDestroy();
uiHelper.onDestroy();
Log.d(TAG, "isPlaying === SERVICE: " + mService.isPlaying());
if (mBound) {
mService.unRegister();
unbindService(mConnection);
mBound = false;
}
Log.d(TAG, "service: " + Util.isFFmpegServiceRunning(getApplicationContext()));
}
@Override
public void onStop(){
Log.d(TAG, "onStop");
super.onStop();
}
/*******************************************************************************************************/
@Override
public boolean onOptionsItemSelected(MenuItem item) {
int itemId = item.getItemId();
switch (itemId){
case android.R.id.home:
onBackPressed();
break;
default:
break;
}
return true;
}
@Override
public boolean onKeyDown(int keyCode, KeyEvent event) {
Log.d(TAG, "@onKeyDown");
if (keyCode == KeyEvent.KEYCODE_BACK && event.getRepeatCount() == 0){
//this.moveTaskToBack(true);
onBackPressed();
return true;
}
return super.onKeyDown(keyCode, event);
}
}
public class FFmpegService extends Service implements IMediaPlayerThreadClient {
private FFmpegPlayerThread mMediaPlayerThread = new FFmpegPlayerThread(this);
private final Binder mBinder = new MediaPlayerBinder();
private IMediaPlayerServiceClient mClient;
//private StreamStation mCurrentStation;
private boolean mIsSupposedToBePlaying = false;
private boolean isPausedInCall = false;
private PhoneStateListener phoneStateListener;
private TelephonyManager telephonyManager;
@Override
public void onCreate(){
mMediaPlayerThread.start();
}
/**
* A class for clients binding to this service. The client will be passed an object of this class
* via its onServiceConnected(ComponentName, IBinder) callback.
*/
public class MediaPlayerBinder extends Binder {
/**
* Returns the instance of this service for a client to make method calls on it.
* @return the instance of this service.
*/
public FFmpegService getService() {
return FFmpegService.this;
}
}
/**
* Returns the contained StatefulMediaPlayer
* @return
*/
public StatefulMediaPlayer getMediaPlayer() {
return mMediaPlayerThread.getMediaPlayer();
}
public boolean isPlaying() {
return mIsSupposedToBePlaying;
}
@Override
public IBinder onBind(Intent arg0) {
return mBinder;
}
@Override
public int onStartCommand(Intent intent, int flags, int startId) {
telephonyManager = (TelephonyManager) getSystemService(Context.TELEPHONY_SERVICE);
phoneStateListener = new PhoneStateListener() {
@Override
public void onCallStateChanged(int state, String incomingNumber) {
// String stateString = "N/A";
Log.v("FFmpegService", "Starting CallStateChange");
switch (state) {
case TelephonyManager.CALL_STATE_OFFHOOK:
case TelephonyManager.CALL_STATE_RINGING:
if (mMediaPlayerThread != null) {
pauseMediaPlayer();
isPausedInCall = true;
}
break;
case TelephonyManager.CALL_STATE_IDLE:
// Phone idle. Start playing.
if (mMediaPlayerThread != null) {
if (isPausedInCall) {
isPausedInCall = false;
startMediaPlayer();
}
}
break;
}
}
};
// Register the listener with the telephony manager
telephonyManager.listen(phoneStateListener, PhoneStateListener.LISTEN_CALL_STATE);
return START_STICKY;
}
/**
* Sets the client using this service.
* @param client The client of this service, which implements the IMediaPlayerServiceClient interface
*/
public void setClient(IMediaPlayerServiceClient client) {
this.mClient = client;
}
public void initializePlayer(final String station) {
//mCurrentStation = station;
mMediaPlayerThread.initializePlayer(station);
}
public void startMediaPlayer() {
Intent notificationIntent = new Intent(getApplicationContext(), StreamingActivity.class);
//notificationIntent.putExtra("page", "0");
//notificationIntent.putExtra("isPlaying", isPlaying());
notificationIntent.addFlags(Intent.FLAG_ACTIVITY_SINGLE_TOP | Intent.FLAG_ACTIVITY_CLEAR_TOP);
PendingIntent contentIntent = PendingIntent.getActivity(getApplicationContext(), 0 , notificationIntent , PendingIntent.FLAG_UPDATE_CURRENT);
NotificationCompat.Builder mBuilder = new NotificationCompat.Builder(this)
.setSmallIcon(R.drawable.ic_launcher)
.setContentTitle("You are listening to Radio...")
.setContentText("test!!!")
.setContentIntent(contentIntent);
startForeground(1, mBuilder.build());
NotificationManager notificationManager = (NotificationManager) getSystemService(Context.NOTIFICATION_SERVICE);
notificationManager.notify(1, mBuilder.build());
mIsSupposedToBePlaying = true;
mMediaPlayerThread.startMediaPlayer();
}
public void dismissNotification(Context context) {
String ns = Context.NOTIFICATION_SERVICE;
NotificationManager mNotificationManager = (NotificationManager) getSystemService(ns);
mNotificationManager.cancel(1);
}
/**
* Pauses playback
*/
public void pauseMediaPlayer() {
Log.d("MediaPlayerService","pauseMediaPlayer() called");
mMediaPlayerThread.pauseMediaPlayer();
stopForeground(true);
mIsSupposedToBePlaying = false;
dismissNotification(this);
}
/**
* Stops playback
*/
public void stopMediaPlayer() {
stopForeground(true);
mMediaPlayerThread.stopMediaPlayer();
mIsSupposedToBePlaying = false;
dismissNotification(this);
}
public void resetMediaPlayer() {
mIsSupposedToBePlaying = false;
stopForeground(true);
mMediaPlayerThread.resetMediaPlayer();
dismissNotification(this);
}
@Override
public void onError() {
mIsSupposedToBePlaying = false;
mClient.onError();
dismissNotification(this);
}
@Override
public void onInitializePlayerStart() {
mClient.onInitializePlayerStart();
}
@Override
public void onInitializePlayerSuccess() {
startMediaPlayer();
mClient.onInitializePlayerSuccess();
mIsSupposedToBePlaying = true;
}
public void unRegister() {
this.mClient = null;
mIsSupposedToBePlaying = false;
dismissNotification(this);
}
}Hoping someone can help me here...
Syndiquer tout le site
