stream: mp_msg conversions

We also drop some slave mode stuff from stream_vcd.

1 files changed, 54 insertions, 52 deletions

diff --git a/stream/stream_radio.c b/stream/stream_radio.c
index 3f60bb77c2..d6d7319ea9 100644
--- a/stream/stream_radio.c
+++ b/stream/stream_radio.c
@@ -87,6 +87,7 @@ radio_param_t stream_radio_defaults={
 };
 
 typedef struct radio_priv_s {
+    struct mp_log      *log;
     int                 radio_fd;          ///< radio device descriptor
     int                 frac;              ///< fraction value (see comment to init_frac)
     radio_channels_t*   radio_channel_list;
@@ -154,7 +155,7 @@ static int parse_channels(radio_priv_t* priv,float freq_channel,float* pfreq){
         /*parsing channels string*/
         channels=priv->radio_param->channels;
 
-        mp_msg(MSGT_RADIO, MSGL_INFO, "[radio] Radio channel names detected.\n");
+        MP_INFO(priv, "Radio channel names detected.\n");
         priv->radio_channel_list = malloc(sizeof(radio_channels_t));
         priv->radio_channel_list->index=1;
         priv->radio_channel_list->next=NULL;
@@ -172,7 +173,7 @@ static int parse_channels(radio_priv_t* priv,float freq_channel,float* pfreq){
             priv->radio_channel_current->freq=atof(tmp);
 
             if ((priv->radio_channel_current->freq>priv->rangehigh)||(priv->radio_channel_current->freq<priv->rangelow))
-                mp_msg(MSGT_RADIO, MSGL_ERR, "[radio] Wrong frequency for channel %s\n",
+                MP_ERR(priv, "Wrong frequency for channel %s\n",
                     priv->radio_channel_current->name);
 
             while ((sep=strchr(priv->radio_channel_current->name, '_'))) sep[0] = ' ';
@@ -198,17 +199,17 @@ static int parse_channels(radio_priv_t* priv,float freq_channel,float* pfreq){
                 priv->radio_channel_current = priv->radio_channel_current->next;
         if (priv->radio_channel_current->index!=channel){
             if (((float)((int)freq_channel))!=freq_channel)
-                mp_msg(MSGT_RADIO, MSGL_ERR, "[radio] Wrong channel number: %.2f\n",freq_channel);
+                MP_ERR(priv, "Wrong channel number: %.2f\n",freq_channel);
             else
-                mp_msg(MSGT_RADIO, MSGL_ERR, "[radio] Wrong channel number: %d\n",(int)freq_channel);
+                MP_ERR(priv, "Wrong channel number: %d\n",(int)freq_channel);
             return STREAM_ERROR;
         }
-        mp_msg(MSGT_RADIO, MSGL_INFO, "[radio] Selected channel: %d - %s (freq: %.2f)\n", priv->radio_channel_current->index,
+        MP_INFO(priv, "Selected channel: %d - %s (freq: %.2f)\n", priv->radio_channel_current->index,
             priv->radio_channel_current->name, priv->radio_channel_current->freq);
         *pfreq=priv->radio_channel_current->freq;
     }else{
         if (freq_channel){
-            mp_msg(MSGT_RADIO, MSGL_INFO, "[radio] Radio frequency parameter detected.\n");
+            MP_INFO(priv, "Radio frequency parameter detected.\n");
             priv->radio_channel_list=malloc(sizeof(radio_channels_t));
             priv->radio_channel_list->next=NULL;
             priv->radio_channel_list->prev=NULL;
@@ -219,7 +220,7 @@ static int parse_channels(radio_priv_t* priv,float freq_channel,float* pfreq){
             *pfreq=freq_channel;
         }
     }
-    mp_msg(MSGT_RADIO, MSGL_DBG2, "[radio] Done parsing channels.\n");
+    MP_DBG(priv, "Done parsing channels.\n");
     return STREAM_OK;
 }
 
@@ -242,25 +243,25 @@ static int init_frac_v4l2(radio_priv_t* priv){
     memset(&tuner,0,sizeof(tuner));
     tuner.index=0;
     if (ioctl(priv->radio_fd, VIDIOC_G_TUNER, &tuner)<0){
-        mp_msg(MSGT_RADIO,MSGL_WARN,"[radio] Warning: ioctl get tuner failed: %s. Setting frac to %d.\n",strerror(errno),priv->frac);
+        MP_WARN(priv, "Warning: ioctl get tuner failed: %s. Setting frac to %d.\n",strerror(errno),priv->frac);
         return  STREAM_ERROR;
     }
     if(tuner.type!=V4L2_TUNER_RADIO){
-        mp_msg(MSGT_RADIO,MSGL_ERR,"[radio] %s is no radio device!\n",priv->radio_param->device);
+        MP_ERR(priv, "%s is no radio device!\n",priv->radio_param->device);
         return STREAM_ERROR;
     }
     if(tuner.capability & V4L2_TUNER_CAP_LOW){
         priv->frac=16000;
-        mp_msg(MSGT_RADIO,MSGL_DBG2,"[radio] tuner is low:yes frac=%d\n",priv->frac);
+        MP_DBG(priv, "tuner is low:yes frac=%d\n",priv->frac);
     }
     else{
         priv->frac=16;
-        mp_msg(MSGT_RADIO,MSGL_DBG2,"[radio] tuner is low:no frac=%d\n",priv->frac);
+        MP_DBG(priv, "tuner is low:no frac=%d\n",priv->frac);
     }
 
     priv->rangelow=((float)tuner.rangelow)/priv->frac;
     priv->rangehigh=((float)tuner.rangehigh)/priv->frac;
-    mp_msg(MSGT_RADIO,MSGL_V,"[radio] Allowed frequency range is %.2f-%.2f MHz.\n",priv->rangelow,priv->rangehigh);
+    MP_VERBOSE(priv, "Allowed frequency range is %.2f-%.2f MHz.\n",priv->rangelow,priv->rangehigh);
     return STREAM_OK;
 }
 
@@ -277,7 +278,7 @@ static int set_frequency_v4l2(radio_priv_t* priv,float frequency){
     freq.type=V4L2_TUNER_RADIO;
     freq.frequency=frequency*priv->frac;
     if(ioctl(priv->radio_fd,VIDIOC_S_FREQUENCY,&freq)<0){
-        mp_msg(MSGT_RADIO,MSGL_ERR,"[radio] ioctl set frequency 0x%x (%.2f) failed: %s\n",freq.frequency,
+        MP_ERR(priv, "ioctl set frequency 0x%x (%.2f) failed: %s\n",freq.frequency,
         frequency,strerror(errno));
         return  STREAM_ERROR;
     }
@@ -293,7 +294,7 @@ static int get_frequency_v4l2(radio_priv_t* priv,float* frequency){
     struct v4l2_frequency freq;
     memset(&freq,0,sizeof(freq));
     if (ioctl(priv->radio_fd, VIDIOC_G_FREQUENCY, &freq) < 0) {
-        mp_msg(MSGT_RADIO,MSGL_ERR,"[radio] ioctl get frequency failed: %s\n",strerror(errno));
+        MP_ERR(priv, "ioctl get frequency failed: %s\n",strerror(errno));
         return  STREAM_ERROR;
     }
     *frequency=((float)freq.frequency)/priv->frac;
@@ -317,13 +318,13 @@ static void set_volume_v4l2(radio_priv_t* priv,int volume){
     control.id=V4L2_CID_AUDIO_MUTE;
     control.value = (volume==0?1:0);
     if (ioctl(priv->radio_fd, VIDIOC_S_CTRL, &control)<0){
-        mp_msg(MSGT_RADIO,MSGL_WARN,"[radio] ioctl set mute failed: %s\n",strerror(errno));
+        MP_WARN(priv, "ioctl set mute failed: %s\n",strerror(errno));
     }
 
     memset(&qctrl,0,sizeof(qctrl));
     qctrl.id = V4L2_CID_AUDIO_VOLUME;
     if (ioctl(priv->radio_fd, VIDIOC_QUERYCTRL, &qctrl) < 0) {
-        mp_msg(MSGT_RADIO, MSGL_WARN, "[radio] ioctl query control failed: %s\n",strerror(errno));
+        MP_WARN(priv, "ioctl query control failed: %s\n",strerror(errno));
         return;
     }
 
@@ -331,7 +332,7 @@ static void set_volume_v4l2(radio_priv_t* priv,int volume){
     control.id=V4L2_CID_AUDIO_VOLUME;
     control.value=qctrl.minimum+volume*(qctrl.maximum-qctrl.minimum)/100;
     if (ioctl(priv->radio_fd, VIDIOC_S_CTRL, &control) < 0) {
-        mp_msg(MSGT_RADIO, MSGL_WARN,"[radio] ioctl set volume failed: %s\n",strerror(errno));
+        MP_WARN(priv, "ioctl set volume failed: %s\n",strerror(errno));
     }
 }
 
@@ -347,14 +348,14 @@ static int get_volume_v4l2(radio_priv_t* priv,int* volume){
     memset(&qctrl,0,sizeof(qctrl));
     qctrl.id = V4L2_CID_AUDIO_VOLUME;
     if (ioctl(priv->radio_fd, VIDIOC_QUERYCTRL, &qctrl) < 0) {
-        mp_msg(MSGT_RADIO, MSGL_ERR, "[radio] ioctl query control failed: %s\n",strerror(errno));
+        MP_ERR(priv, "ioctl query control failed: %s\n",strerror(errno));
         return STREAM_ERROR;
     }
 
     memset(&control,0,sizeof(control));
     control.id=V4L2_CID_AUDIO_VOLUME;
     if (ioctl(priv->radio_fd, VIDIOC_G_CTRL, &control) < 0) {
-        mp_msg(MSGT_RADIO, MSGL_ERR,"[radio] ioctl get volume failed: %s\n",strerror(errno));
+        MP_ERR(priv, "ioctl get volume failed: %s\n",strerror(errno));
         return STREAM_ERROR;
     }
 
@@ -373,7 +374,7 @@ static int get_volume_v4l2(radio_priv_t* priv,int* volume){
 /* v4l2 driver info structure */
 static const radio_driver_t radio_driver_v4l2={
     "v4l2",
-    _("[radio] Using V4Lv2 radio interface.\n"),
+    _("Using V4Lv2 radio interface.\n"),
     init_frac_v4l2,
     set_volume_v4l2,
     get_volume_v4l2,
@@ -387,7 +388,7 @@ static inline int init_frac(radio_priv_t* priv){
 }
 static inline int set_frequency(radio_priv_t* priv,float frequency){
     if ((frequency<priv->rangelow)||(frequency>priv->rangehigh)){
-        mp_msg(MSGT_RADIO,MSGL_ERR,"[radio] Wrong frequency: %.2f\n",frequency);
+        MP_ERR(priv, "Wrong frequency: %.2f\n",frequency);
         return STREAM_ERROR;
     }
     if(priv->driver->set_frequency(priv,frequency)!=STREAM_OK)
@@ -395,7 +396,7 @@ static inline int set_frequency(radio_priv_t* priv,float frequency){
 
 #if HAVE_RADIO_CAPTURE
     if(clear_buffer(priv)!=STREAM_OK){
-        mp_msg(MSGT_RADIO,MSGL_ERR,"[radio] Clearing buffer failed: %s\n",strerror(errno));
+        MP_ERR(priv, "Clearing buffer failed: %s\n",strerror(errno));
         return  STREAM_ERROR;
     }
 #endif
@@ -450,16 +451,16 @@ static int read_chunk(audio_in_t *ai, unsigned char *buffer)
         if (ret != ai->alsa.chunk_size) {
             if (ret < 0) {
                 if (ret==-EAGAIN) return -1;
-                mp_msg(MSGT_RADIO, MSGL_ERR, "\nError reading audio: %s\n", snd_strerror(ret));
+                MP_ERR(ai, "\nError reading audio: %s\n", snd_strerror(ret));
                 if (ret == -EPIPE) {
                     if (ai_alsa_xrun(ai) == 0) {
-                        mp_msg(MSGT_RADIO, MSGL_ERR, "Recovered from cross-run, some frames may be left out!\n");
+                        MP_ERR(ai, "Recovered from cross-run, some frames may be left out!\n");
                     } else {
-                        mp_msg(MSGT_RADIO, MSGL_ERR, "Fatal error, cannot recover!\n");
+                        MP_ERR(ai, "Fatal error, cannot recover!\n");
                     }
                 }
             } else {
-                mp_msg(MSGT_RADIO, MSGL_ERR, "\nNot enough audio samples!\n");
+                MP_ERR(ai, "\nNot enough audio samples!\n");
             }
             return -1;
         }
@@ -481,7 +482,7 @@ static int read_chunk(audio_in_t *ai, unsigned char *buffer)
             if (ret<0){
                 if (errno==EAGAIN && bt==0) return -1; //no data avail yet
                 if (errno==EAGAIN) { usleep(1000); continue;} //nilling buffer to blocksize size
-                mp_msg(MSGT_RADIO, MSGL_ERR, "\nError reading audio: %s\n", strerror(errno));
+                MP_ERR(ai, "\nError reading audio: %s\n", strerror(errno));
                 return -1;
             }
             bt+=ret;
@@ -513,7 +514,7 @@ static int read_chunk(audio_in_t *ai, unsigned char *buffer)
 static int grab_audio_frame(radio_priv_t *priv, char *buffer, int len)
 {
     int i;
-    mp_msg(MSGT_RADIO, MSGL_DBG3, "[radio] %s: in buffer=%d dropped=%d\n","grab_audio_frame",priv->audio_cnt,priv->audio_drop);
+    MP_TRACE(priv, "%s: in buffer=%d dropped=%d\n","grab_audio_frame",priv->audio_cnt,priv->audio_drop);
     /* Cache buffer must be filled by some audio packets when playing starts.
        Otherwise MPlayer will quit with EOF error.
        Probably, there is need more carefull checking rather than simple 'for' loop
@@ -563,7 +564,7 @@ static int init_audio(radio_priv_t *priv)
     }
 
     priv->do_capture=1;
-    mp_msg(MSGT_RADIO,MSGL_V,"[radio] Starting capture stuff.\n");
+    MP_VERBOSE(priv, "Starting capture stuff.\n");
 #if HAVE_ALSA
     while ((tmp = strrchr(priv->radio_param->adevice, '='))){
         tmp[0] = ':';
@@ -574,8 +575,8 @@ static int init_audio(radio_priv_t *priv)
         tmp[0] = ',';
 #endif
 
-    if(audio_in_init(&priv->audio_in, mp_null_log, is_oss?AUDIO_IN_OSS:AUDIO_IN_ALSA)<0){
-        mp_msg(MSGT_RADIO, MSGL_ERR, "[radio] audio_in_init failed.\n");
+    if(audio_in_init(&priv->audio_in, priv->log, is_oss?AUDIO_IN_OSS:AUDIO_IN_ALSA)<0){
+        MP_ERR(priv, "audio_in_init failed.\n");
     }
 
     audio_in_set_device(&priv->audio_in, priv->radio_param->adevice);
@@ -583,7 +584,7 @@ static int init_audio(radio_priv_t *priv)
     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, "[radio] audio_in_setup call failed: %s\n", strerror(errno));
+        MP_ERR(priv, "audio_in_setup call failed: %s\n", strerror(errno));
         return STREAM_ERROR;
     }
 #if HAVE_OSS_AUDIO
@@ -599,12 +600,12 @@ static int init_audio(radio_priv_t *priv)
             priv->audio_in.bytes_per_sample+priv->audio_in.blocksize;
     if (priv->audio_buffer_size < 256*priv->audio_in.blocksize)
         priv->audio_buffer_size = 256*priv->audio_in.blocksize;
-    mp_msg(MSGT_RADIO, MSGL_V, "[radio] Audio capture - buffer=%d bytes (block=%d bytes).\n",
+    MP_VERBOSE(priv, "Audio capture - buffer=%d bytes (block=%d bytes).\n",
         priv->audio_buffer_size,priv->audio_in.blocksize);
     /* start capture */
     priv->audio_ringbuffer = calloc(1, priv->audio_buffer_size);
     if (!priv->audio_ringbuffer) {
-        mp_msg(MSGT_RADIO, MSGL_ERR, "[radio] cannot allocate audio buffer (block=%d,buf=%d): %s\n",priv->audio_in.blocksize, priv->audio_buffer_size, strerror(errno));
+        MP_ERR(priv, "cannot allocate audio buffer (block=%d,buf=%d): %s\n",priv->audio_in.blocksize, priv->audio_buffer_size, strerror(errno));
         return STREAM_ERROR;
     }
     priv->audio_head = 0;
@@ -652,7 +653,7 @@ int radio_set_freq(struct stream *stream, float frequency){
     if (get_frequency(priv,&frequency)!=STREAM_OK){
         return 0;
     }
-    mp_msg(MSGT_RADIO, MSGL_INFO, "[radio] Current frequency: %.2f\n",frequency);
+    MP_INFO(priv, "Current frequency: %.2f\n",frequency);
     return 1;
 }
 
@@ -697,7 +698,7 @@ int radio_step_channel(struct stream *stream, int direction) {
                     priv->radio_channel_current = priv->radio_channel_list;
                 if(!radio_set_freq(stream,priv->radio_channel_current->freq))
                     return 0;
-                mp_msg(MSGT_RADIO, MSGL_V, "[radio] Selected channel: %d - %s (freq: %.2f)\n",
+                MP_VERBOSE(priv, "Selected channel: %d - %s (freq: %.2f)\n",
                     priv->radio_channel_current->index, priv->radio_channel_current->name,
                     priv->radio_channel_current->freq);
             break;
@@ -709,13 +710,13 @@ int radio_step_channel(struct stream *stream, int direction) {
                         priv->radio_channel_current = priv->radio_channel_current->next;
                 if(!radio_set_freq(stream,priv->radio_channel_current->freq))
                     return 0;
-                mp_msg(MSGT_RADIO, MSGL_V, "[radio] Selected channel: %d - %s (freq: %.2f)\n",
+                MP_VERBOSE(priv, "Selected channel: %d - %s (freq: %.2f)\n",
                 priv->radio_channel_current->index, priv->radio_channel_current->name,
                 priv->radio_channel_current->freq);
             break;
         }
     }else
-        mp_msg(MSGT_RADIO, MSGL_ERR, "[radio] Can not change channel: no channel list given.\n");
+        MP_ERR(priv, "Can not change channel: no channel list given.\n");
     return 1;
 }
 
@@ -734,7 +735,7 @@ int radio_set_channel(struct stream *stream, char *channel) {
     char* endptr;
 
     if (*channel=='\0')
-        mp_msg(MSGT_RADIO,MSGL_ERR,"[radio] Wrong channel name: %s\n",channel);
+        MP_ERR(priv, "Wrong channel name: %s\n",channel);
 
     if (priv->radio_channel_list) {
         channel_int = strtol(channel,&endptr,10);
@@ -745,7 +746,7 @@ int radio_set_channel(struct stream *stream, char *channel) {
                 if (!strncmp(channel,tmp->name,sizeof(tmp->name)-1))
                     break;
                 if (!tmp){
-                mp_msg(MSGT_RADIO,MSGL_ERR,"[radio] Wrong channel name: %s\n",channel);
+                MP_ERR(priv, "Wrong channel name: %s\n",channel);
                 return 0;
             }
         }else{
@@ -755,17 +756,17 @@ int radio_set_channel(struct stream *stream, char *channel) {
             else
                 break;
         if (tmp->index!=channel_int){
-            mp_msg(MSGT_RADIO,MSGL_ERR,"[radio] Wrong channel number: %d\n",channel_int);
+            MP_ERR(priv, "Wrong channel number: %d\n",channel_int);
             return 0;
         }
         }
         priv->radio_channel_current=tmp;
-        mp_msg(MSGT_RADIO, MSGL_V, "[radio] Selected channel: %d - %s (freq: %.2f)\n", priv->radio_channel_current->index,
+        MP_VERBOSE(priv, "Selected channel: %d - %s (freq: %.2f)\n", priv->radio_channel_current->index,
             priv->radio_channel_current->name, priv->radio_channel_current->freq);
         if(!radio_set_freq(stream, priv->radio_channel_current->freq))
             return 0;
     } else
-        mp_msg(MSGT_RADIO, MSGL_ERR, "[radio] Can not change channel: no channel list given.\n");
+        MP_ERR(priv, "Can not change channel: no channel list given.\n");
     return 1;
 }
 
@@ -836,6 +837,7 @@ static int open_s(stream_t *stream,int mode)
         return STREAM_ERROR;
 
 
+    priv->log = stream->log;
     priv->radio_param=stream->priv;
     stream->priv=NULL;
 
@@ -853,18 +855,18 @@ static int open_s(stream_t *stream,int mode)
     else
         priv->driver=NULL;
 
-    mp_msg(MSGT_RADIO,MSGL_V,"[radio] Available drivers: ");
+    MP_VERBOSE(priv, "Available drivers: ");
     for(i=0;radio_drivers[i];i++){
-        mp_msg(MSGT_RADIO,MSGL_V,"%s, ",radio_drivers[i]->name);
+        MP_VERBOSE(priv, "%s, ",radio_drivers[i]->name);
         if(strcmp(priv->radio_param->driver,radio_drivers[i]->name)==0)
             priv->driver=radio_drivers[i];
     }
-    mp_msg(MSGT_RADIO,MSGL_V,"\n");
+    MP_VERBOSE(priv, "\n");
 
     if(priv->driver)
-        mp_msg(MSGT_RADIO, MSGL_INFO, priv->driver->info);
+        MP_INFO(priv, priv->driver->info);
     else{
-        mp_msg(MSGT_RADIO, MSGL_INFO, "[radio] Unknown driver name: %s\n",priv->radio_param->driver);
+        MP_INFO(priv, "Unknown driver name: %s\n",priv->radio_param->driver);
         close_s(stream);
         return STREAM_ERROR;
     }
@@ -884,12 +886,12 @@ static int open_s(stream_t *stream,int mode)
 
     priv->radio_fd = open(priv->radio_param->device, O_RDONLY | O_CLOEXEC);
     if (priv->radio_fd < 0) {
-        mp_msg(MSGT_RADIO, MSGL_ERR, "[radio] Unable to open '%s': %s\n",
+        MP_ERR(priv, "Unable to open '%s': %s\n",
             priv->radio_param->device, strerror(errno));
         close_s(stream);
         return STREAM_ERROR;
     }
-    mp_msg(MSGT_RADIO, MSGL_V, "[radio] Radio fd: %d, %s\n", priv->radio_fd,priv->radio_param->device);
+    MP_VERBOSE(priv, "Radio fd: %d, %s\n", priv->radio_fd,priv->radio_param->device);
     fcntl(priv->radio_fd, F_SETFD, FD_CLOEXEC);
 
     get_volume(priv, &priv->old_snd_volume);
@@ -906,11 +908,11 @@ static int open_s(stream_t *stream,int mode)
     }
 
     if ((frequency<priv->rangelow)||(frequency>priv->rangehigh)){
-        mp_msg(MSGT_RADIO, MSGL_ERR, "[radio] Wrong frequency: %.2f\n",frequency);
+        MP_ERR(priv, "Wrong frequency: %.2f\n",frequency);
         close_s(stream);
         return STREAM_ERROR;
     }else
-        mp_msg(MSGT_RADIO, MSGL_INFO, "[radio] Using frequency: %.2f.\n",frequency);
+        MP_INFO(priv, "Using frequency: %.2f.\n",frequency);
 
     if(set_frequency(priv,frequency)!=STREAM_OK){
         close_s(stream);