Mercurial > mplayer.hg

changeset 23890:4587edae1790

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Replacing global variables in radio:// with context-sensitive structure.
author voroshil
date Sun, 29 Jul 2007 12:20:25 +0000
parents 0ad7037df91f
children 542d4cda34c3
files cfg-common.h stream/stream_radio.c stream/stream_radio.h
diffstat 3 files changed, 87 insertions(+), 83 deletions(-) [+]
line wrap: on
line diff
--- a/cfg-common.h	Sun Jul 29 10:30:41 2007 +0000
+++ b/cfg-common.h	Sun Jul 29 12:20:25 2007 +0000
@@ -402,17 +402,17 @@
 
 #ifdef USE_RADIO
 m_option_t radioopts_conf[]={
-    {"device", &radio_param_device, CONF_TYPE_STRING, 0, 0 ,0, NULL},
-    {"driver", &radio_param_driver, CONF_TYPE_STRING, 0, 0 ,0, NULL},
+    {"device", &stream_radio_defaults.device, CONF_TYPE_STRING, 0, 0 ,0, NULL},
+    {"driver", &stream_radio_defaults.driver, CONF_TYPE_STRING, 0, 0 ,0, NULL},
 #ifdef RADIO_BSDBT848_HDR
-    {"freq_min", &radio_param_freq_min, CONF_TYPE_FLOAT, 0, 0 ,0, NULL},
-    {"freq_max", &radio_param_freq_max, CONF_TYPE_FLOAT, 0, 0 ,0, NULL},
+    {"freq_min", &stream_radio_defaults.freq_min, CONF_TYPE_FLOAT, 0, 0 ,0, NULL},
+    {"freq_max", &stream_radio_defaults.freq_max, CONF_TYPE_FLOAT, 0, 0 ,0, NULL},
 #endif
-    {"channels", &radio_param_channels, CONF_TYPE_STRING_LIST, 0, 0 ,0, NULL},
-    {"volume", &radio_param_volume, CONF_TYPE_INT, CONF_RANGE, 0 ,100, NULL},
-    {"adevice", &radio_param_adevice, CONF_TYPE_STRING, 0, 0 ,0, NULL},
-    {"arate", &radio_param_arate, CONF_TYPE_INT, CONF_MIN, 0 ,0, NULL},
-    {"achannels", &radio_param_achannels, CONF_TYPE_INT, CONF_MIN, 0 ,0, NULL},
+    {"channels", &stream_radio_defaults.channels, CONF_TYPE_STRING_LIST, 0, 0 ,0, NULL},
+    {"volume", &stream_radio_defaults.volume, CONF_TYPE_INT, CONF_RANGE, 0 ,100, NULL},
+    {"adevice", &stream_radio_defaults.adevice, CONF_TYPE_STRING, 0, 0 ,0, NULL},
+    {"arate", &stream_radio_defaults.arate, CONF_TYPE_INT, CONF_MIN, 0 ,0, NULL},
+    {"achannels", &stream_radio_defaults.achannels, CONF_TYPE_INT, CONF_MIN, 0 ,0, NULL},
     {NULL, NULL, 0, 0, 0, 0, NULL}
 };
 #endif
--- a/stream/stream_radio.c	Sun Jul 29 10:30:41 2007 +0000
+++ b/stream/stream_radio.c	Sun Jul 29 12:20:25 2007 +0000
@@ -88,39 +88,23 @@
     struct radio_channels_s * prev;
 } radio_channels_t;
 
+/// default values for options
+radio_param_t stream_radio_defaults={
 #ifdef HAVE_RADIO_BSDBT848
-/** (device,string, "/dev/tuner0") name of radio device file */
-char*   radio_param_device="/dev/tuner0";
-/** radio_param_freq_min (freq_min,float,87.5) minimal allowed frequency */
-float radio_param_freq_min=87.50;
-/** radio_param_freq_min (freq_min,float,108.0) maximal allowed frequency */
-float radio_param_freq_max=108.00;
+    "/dev/tuner0", //device
+    87.50,         //freq_min
+    108.00,        //freq_max
 #else
-/** (device,string, "/dev/radio0") name of radio device file */
-char*   radio_param_device="/dev/radio0";
+    "/dev/radio0", //device;
 #endif
-/** (driver,string, "v4l2") radio driver (v4l,v4l2) */
-char*   radio_param_driver="default";
-/** radio_param_channels (channels,string,NULL) channels list (see man page) */
-char**  radio_param_channels;
-/** radio_param_volume (volume,number,100) initial volume for radio device */
-int     radio_param_volume=100;
-/** radio_param_adevice (adevice,string,NULL) name of audio device file to grab data from */
-char*   radio_param_adevice;
-/** radio_param_arate (arate,number,44100) audio framerate
-(please also set -rawaudio rate parameter to the same value) */
-int     radio_param_arate=44100;
-/** radio_param_achannels (achannels,number,2) number of audio channels */
-int     radio_param_achannels=2;
-extern int demux_rawaudio_packs_per_sec;
-
-static struct stream_priv_s {
-    /* if channels parameter exist here will be channel number otherwise - frequency */
-    float radio_param_freq_channel;
-    char* capture;
-} stream_priv_dflts = {
-    0,
-    NULL
+    "default",     //driver
+    NULL,          //channels
+    100,           //volume
+    NULL,          //adevice
+    44100,         //arate
+    2,             //achannels
+    0,             //freq_channel
+    NULL,          //capture
 };
 
 typedef struct radio_priv_s {
@@ -143,6 +127,7 @@
     int                 audio_drop;        ///< number of dropped bytes
     int                 audio_inited;
 #endif
+    radio_param_t       *radio_param;
 } radio_priv_t;
 
 typedef struct radio_driver_s {
@@ -155,17 +140,17 @@
     int (*get_frequency)(radio_priv_t* priv,float* frequency);
 } radio_driver_t;
 
-#define ST_OFF(f) M_ST_OFF(struct stream_priv_s,f)
+#define ST_OFF(f) M_ST_OFF(radio_param_t,f)
 static m_option_t stream_opts_fields[] = {
-    {"hostname", ST_OFF(radio_param_freq_channel), CONF_TYPE_FLOAT, 0, 0 ,0, NULL},
+    {"hostname", ST_OFF(freq_channel), CONF_TYPE_FLOAT, 0, 0 ,0, NULL},
     {"filename", ST_OFF(capture), CONF_TYPE_STRING, 0, 0 ,0, NULL},
     { NULL, NULL, 0, 0, 0, 0,  NULL }
 };
 
 static struct m_struct_st stream_opts = {
     "radio",
-    sizeof(struct stream_priv_s),
-    &stream_priv_dflts,
+    sizeof(radio_param_t),
+    &stream_radio_defaults,
     stream_opts_fields
 };
 
@@ -176,26 +161,26 @@
 
 
 /*****************************************************************
- * \brief parse radio_param_channels parameter and store result into list
- * \param freq_channel if radio_param_channels!=NULL this mean channel number, otherwise - frequency
+ * \brief parse channels parameter and store result into list
+ * \param freq_channel if channels!=NULL this mean channel number, otherwise - frequency
  * \param pfreq selected frequency (from selected channel or from URL)
  * \result STREAM_OK if success, STREAM_ERROR otherwise
  *
- *  radio_param_channels (channels options) must be in the following format
+ *  channels option must be in the following format
  *  <frequency>-<name>,<frequency>-<name>,...
  *
  *  '_' will be replaced with spaces.
  *
- *  If radio_param_channels is not null, number in movie URL will be treated as
+ *  If channels option is not null, number in movie URL will be treated as
  *  channel position in channel list.
  */
 static int parse_channels(radio_priv_t* priv,float freq_channel,float* pfreq){
     char** channels;
     int i;
     int channel = 0;
-    if (radio_param_channels){
+    if (priv->radio_param->channels){
         /*parsing channels string*/
-        channels =radio_param_channels;
+        channels=priv->radio_param->channels;
 
         mp_msg(MSGT_RADIO, MSGL_INFO, MSGTR_RADIO_ChannelNamesDetected);
         priv->radio_channel_list = malloc(sizeof(radio_channels_t));
@@ -289,7 +274,7 @@
         return  STREAM_ERROR;
     }
     if(tuner.type!=V4L2_TUNER_RADIO){
-        mp_msg(MSGT_RADIO,MSGL_ERR,MSGTR_RADIO_NotRadioDevice,radio_param_device);
+        mp_msg(MSGT_RADIO,MSGL_ERR,MSGTR_RADIO_NotRadioDevice,priv->radio_param->device);
         return STREAM_ERROR;
     }
     if(tuner.capability & V4L2_TUNER_CAP_LOW){
@@ -576,8 +561,8 @@
 */
 static int init_frac_bsdbt848(radio_priv_t* priv){
     priv->frac=100;
-    priv->rangelow=radio_param_freq_min;
-    priv->rangehigh=radio_param_freq_max;
+    priv->rangelow=priv->radio_param->freq_min;
+    priv->rangehigh=priv->radio_param->freq_max;
     return STREAM_OK;
 }
 
@@ -843,7 +828,7 @@
     if(!priv->do_capture)
         return STREAM_OK;
 
-    if (!radio_param_adevice){
+    if (!priv->radio_param->adevice){
         priv->do_capture=0;
         return STREAM_OK;
     }
@@ -851,12 +836,12 @@
     priv->do_capture=1;
     mp_msg(MSGT_RADIO,MSGL_V,MSGTR_RADIO_CaptureStarting);
 #if defined(HAVE_ALSA9) || defined(HAVE_ALSA1X)
-    while ((tmp = strrchr(radio_param_adevice, '='))){
+    while ((tmp = strrchr(priv->radio_param->adevice, '='))){
         tmp[0] = ':';
-        //radio_param_adevice looks like ALSA device name. Switching to ALSA
+        //adevice option looks like ALSA device name. Switching to ALSA
         is_oss=0;
     }
-    while ((tmp = strrchr(radio_param_adevice, '.')))
+    while ((tmp = strrchr(priv->radio_param->adevice, '.')))
         tmp[0] = ',';
 #endif
 
@@ -864,9 +849,9 @@
         mp_msg(MSGT_RADIO, MSGL_ERR, MSGTR_RADIO_AudioInInitFailed,strerror(errno));
     }
 
-    audio_in_set_device(&priv->audio_in, radio_param_adevice);
-    audio_in_set_channels(&priv->audio_in, radio_param_achannels);
-    audio_in_set_samplerate(&priv->audio_in, radio_param_arate);
+    audio_in_set_device(&priv->audio_in, priv->radio_param->adevice);
+    audio_in_set_channels(&priv->audio_in, priv->radio_param->achannels);
+    audio_in_set_samplerate(&priv->audio_in, priv->radio_param->arate);
 
     if (audio_in_setup(&priv->audio_in) < 0) {
         mp_msg(MSGT_RADIO, MSGL_ERR, MSGTR_RADIO_AudioInSetupFailed, strerror(errno));
@@ -966,7 +951,7 @@
  * \parameter direction RADIO_CHANNEL_LOWER - go to prev channel,RADIO_CHANNEL_HIGHER - to next
  * \return 1 if success,0 - otherwise
  *
- *  if radio_param_channel is NULL function prints error message and does nothing, otherwise
+ *  if channel parameter is NULL function prints error message and does nothing, otherwise
  *  changes channel to prev or next in list
  */
 int radio_step_channel(struct stream_st *stream, int direction) {
@@ -1008,7 +993,7 @@
  * \parameter channel string, containing channel number
  * \return 1 if success,0 - otherwise
  *
- *  if radio_param_channel is NULL function prints error message and does nothing, otherwise
+ *  if channel parameter is NULL function prints error message and does nothing, otherwise
  *  changes channel to given
  */
 int radio_set_channel(struct stream_st *stream, char *channel) {
@@ -1109,7 +1094,6 @@
  * \return STREAM_OK if success, STREAM_ERROR otherwise
  */
 static int open_s(stream_t *stream,int mode, void* opts, int* file_format) {
-    struct stream_priv_s* p=(struct stream_priv_s*)opts;
     radio_priv_t* priv;
     float frequency=0;
     int i;
@@ -1120,16 +1104,16 @@
     if(mode != STREAM_READ)
         return STREAM_UNSUPORTED;
 
-    priv=malloc(sizeof(radio_priv_t));
+    priv=calloc(1,sizeof(radio_priv_t));
 
     if (!priv)
         return STREAM_ERROR;
 
 
-    memset(priv,0,sizeof(radio_priv_t));
+    priv->radio_param=opts;
 
 #ifdef USE_RADIO_CAPTURE
-    if (p->capture && strncmp("capture",p->capture,7)==0)
+    if (priv->radio_param->capture && strncmp("capture",priv->radio_param->capture,7)==0)
         priv->do_capture=1;
     else
         priv->do_capture=0;
@@ -1137,7 +1121,7 @@
 
 
 
-    if (strncmp(radio_param_driver,"default",7)==0)
+    if (strncmp(priv->radio_param->driver,"default",7)==0)
         priv->driver=radio_drivers[0];
     else
         priv->driver=NULL;
@@ -1145,7 +1129,7 @@
     mp_msg(MSGT_RADIO,MSGL_V,MSGTR_RADIO_AvailableDrivers);
     for(i=0;radio_drivers[i];i++){
         mp_msg(MSGT_RADIO,MSGL_V,"%s, ",radio_drivers[i]->name);
-        if(strcmp(radio_param_driver,radio_drivers[i]->name)==0)
+        if(strcmp(priv->radio_param->driver,radio_drivers[i]->name)==0)
             priv->driver=radio_drivers[i];
     }
     mp_msg(MSGT_RADIO,MSGL_V,"\n");
@@ -1153,7 +1137,7 @@
     if(priv->driver)
         mp_msg(MSGT_RADIO, MSGL_INFO, priv->driver->info);
     else{
-        mp_msg(MSGT_RADIO, MSGL_INFO, MSGTR_RADIO_DriverUnknownStr,radio_param_driver);
+        mp_msg(MSGT_RADIO, MSGL_INFO, MSGTR_RADIO_DriverUnknownStr,priv->radio_param->driver);
         close_s(stream);
         return STREAM_ERROR;
     }
@@ -1171,14 +1155,14 @@
     stream->close=close_s;
     stream->fill_buffer=fill_buffer_s;
 
-    priv->radio_fd = open(radio_param_device, O_RDONLY);
+    priv->radio_fd = open(priv->radio_param->device, O_RDONLY);
     if (priv->radio_fd < 0) {
         mp_msg(MSGT_RADIO, MSGL_ERR, MSGTR_RADIO_UnableOpenDevice,
-            radio_param_device, strerror(errno));
+            priv->radio_param->device, strerror(errno));
         close_s(stream);
         return STREAM_ERROR;
     }
-    mp_msg(MSGT_RADIO, MSGL_V, MSGTR_RADIO_RadioDevice, priv->radio_fd,radio_param_device);
+    mp_msg(MSGT_RADIO, MSGL_V, MSGTR_RADIO_RadioDevice, priv->radio_fd,priv->radio_param->device);
     fcntl(priv->radio_fd, F_SETFD, FD_CLOEXEC);
 
     get_volume(priv, &priv->old_snd_volume);
@@ -1189,7 +1173,7 @@
         return STREAM_ERROR;
     };
 
-    if (parse_channels(priv,p->radio_param_freq_channel,&frequency)!=STREAM_OK){
+    if (parse_channels(priv,priv->radio_param->freq_channel,&frequency)!=STREAM_OK){
         close_s(stream);
         return STREAM_ERROR;
     }
@@ -1225,7 +1209,7 @@
     }
 #endif
 
-    set_volume(priv,radio_param_volume);
+    set_volume(priv,priv->radio_param->volume);
 
     return STREAM_OK;
 }
@@ -1260,6 +1244,8 @@
         close(priv->radio_fd);
     }
 
+    if(priv->radio_param)
+        m_struct_free(&stream_opts,priv->radio_param);
     free(priv);
     stream->priv=NULL;
 }
--- a/stream/stream_radio.h	Sun Jul 29 10:30:41 2007 +0000
+++ b/stream/stream_radio.h	Sun Jul 29 12:20:25 2007 +0000
@@ -4,17 +4,35 @@
 #define RADIO_CHANNEL_LOWER 1
 #define RADIO_CHANNEL_HIGHER 2
 
-extern char *radio_param_device;
-extern char *radio_param_driver;
-#ifdef RADIO_BSDBT848_HDR
-extern float radio_param_freq_min;
-extern float radio_param_freq_max;
+typedef struct radio_param_s{
+    /** name of radio device file */
+    char*   device;
+#ifdef HAVE_RADIO_BSDBT848
+    /** minimal allowed frequency */
+    float   freq_min;
+    /** maximal allowed frequency */
+    float   freq_max;
 #endif
-extern char **radio_param_channels;
-extern int radio_param_volume;
-extern char* radio_param_adevice;
-extern int radio_param_arate;
-extern int radio_param_achannels;
+    /** radio driver (v4l,v4l2) */
+    char*   driver;
+    /** channels list (see man page) */
+    char**  channels;
+    /** initial volume for radio device */
+    int     volume;
+    /** name of audio device file to grab data from */
+    char*   adevice;
+    /** audio framerate (please also set -rawaudio rate
+        parameter to the same value) */
+    int     arate;
+    /** number of audio channels */
+    int     achannels;
+    /** if channels parameter exist, here will be channel
+        number otherwise - frequency */
+    float   freq_channel;
+    char*   capture;
+} radio_param_t;
+
+extern radio_param_t stream_radio_defaults;
 
 int radio_set_freq(struct stream_st *stream, float freq);
 int radio_get_freq(struct stream_st *stream, float* freq);