libao2/ao_mpegpes.c

   1 /*
   2  * MPEG-PES audio output driver
   3  *
   4  * This file is part of MPlayer.
   5  *
   6  * MPlayer is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License as published by
   8  * the Free Software Foundation; either version 2 of the License, or
   9  * (at your option) any later version.
  10  *
  11  * MPlayer is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  * GNU General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License along
  17  * with MPlayer; if not, write to the Free Software Foundation, Inc.,
  18  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  19  */
  20
  21 #include <stdio.h>
  22 #include <stdlib.h>
  23 #include <string.h>
  24 #include <sys/types.h>
  25 #include <sys/stat.h>
  26 #include <fcntl.h>
  27 #include <unistd.h>
  28 #include <inttypes.h>
  29 #include <errno.h>
  30
  31 #include "config.h"
  32
  33 #ifdef CONFIG_DVB
  34 #include <poll.h>
  35 #include <sys/ioctl.h>
  36 #endif
  37
  38 #include "audio_out.h"
  39 #include "audio_out_internal.h"
  40
  41 #include "libaf/af_format.h"
  42 #include "libmpdemux/mpeg_packetizer.h"
  43 #include "subopt-helper.h"
  44
  45 #include "mp_msg.h"
  46 #include "help_mp.h"
  47
  48 #ifdef CONFIG_DVB
  49 #ifndef CONFIG_DVB_HEAD
  50 #include <ost/audio.h>
  51 audioMixer_t dvb_mixer={255,255};
  52 #else
  53 #include <linux/dvb/audio.h>
  54 audio_mixer_t dvb_mixer={255,255};
  55 #endif
  56 #endif
  57
  58 #define true 1
  59 #define false 0
  60
  61 extern int vo_mpegpes_fd;
  62 int vo_mpegpes_fd2 = -1;
  63
  64 #include <errno.h>
  65
  66 static const ao_info_t info =
  67 {
  68 #ifdef CONFIG_DVB
  69         "DVB audio output",
  70 #else
  71         "MPEG-PES audio output",
  72 #endif
  73         "mpegpes",
  74         "A'rpi",
  75         ""
  76 };
  77
  78 LIBAO_EXTERN(mpegpes)
  79
  80
  81 // to set/get/query special features/parameters
  82 static int control(int cmd,void *arg){
  83 #ifdef CONFIG_DVB
  84     switch(cmd){
  85         case AOCONTROL_GET_VOLUME:
  86           if(vo_mpegpes_fd2>=0){
  87             ((ao_control_vol_t*)(arg))->left=dvb_mixer.volume_left/2.56;
  88             ((ao_control_vol_t*)(arg))->right=dvb_mixer.volume_right/2.56;
  89             return CONTROL_OK;
  90           }
  91           return CONTROL_ERROR;
  92         case AOCONTROL_SET_VOLUME:
  93           if(vo_mpegpes_fd2>=0){
  94             dvb_mixer.volume_left=((ao_control_vol_t*)(arg))->left*2.56;
  95             dvb_mixer.volume_right=((ao_control_vol_t*)(arg))->right*2.56;
  96             if(dvb_mixer.volume_left>255) dvb_mixer.volume_left=255;
  97             if(dvb_mixer.volume_right>255) dvb_mixer.volume_right=255;
  98             //   printf("Setting DVB volume: %d ; %d  \n",dvb_mixer.volume_left,dvb_mixer.volume_right);
  99             if ( (ioctl(vo_mpegpes_fd2,AUDIO_SET_MIXER, &dvb_mixer) < 0)){
 100                 mp_msg(MSGT_AO, MSGL_ERR, MSGTR_AO_MPEGPES_CantSetMixer,
 101                     strerror(errno));
 102               return CONTROL_ERROR;
 103             }
 104             return CONTROL_OK;
 105           }
 106           return CONTROL_ERROR;
 107     }
 108 #endif
 109     return CONTROL_UNKNOWN;
 110 }
 111
 112 static int freq=0;
 113 static int freq_id=0;
 114
 115 #ifdef CONFIG_DVB
 116 static int init_device(int card)
 117 {
 118         char ao_file[30];
 119 #ifndef CONFIG_DVB_HEAD
 120         mp_msg(MSGT_VO,MSGL_INFO, "Opening /dev/ost/audio\n");
 121         sprintf(ao_file, "/dev/ost/audio");
 122 #else
 123         mp_msg(MSGT_VO,MSGL_INFO, "Opening /dev/dvb/adapter%d/audio0\n", card);
 124         sprintf(ao_file, "/dev/dvb/adapter%d/audio0", card);
 125 #endif
 126         if((vo_mpegpes_fd2 = open(ao_file,O_RDWR|O_NONBLOCK)) < 0)
 127         {
 128                 mp_msg(MSGT_VO, MSGL_ERR, "DVB AUDIO DEVICE: %s\n", strerror(errno));
 129                 return -1;
 130         }
 131         if( (ioctl(vo_mpegpes_fd2,AUDIO_SELECT_SOURCE, AUDIO_SOURCE_MEMORY) < 0))
 132         {
 133                 mp_msg(MSGT_VO, MSGL_ERR, "DVB AUDIO SELECT SOURCE: %s\n", strerror(errno));
 134                 return -1;
 135         }
 136         if((ioctl(vo_mpegpes_fd2,AUDIO_PLAY) < 0))
 137         {
 138                 mp_msg(MSGT_VO, MSGL_ERR, "DVB AUDIO PLAY: %s\n", strerror(errno));
 139                 return -1;
 140         }
 141         if((ioctl(vo_mpegpes_fd2,AUDIO_SET_AV_SYNC, true) < 0))
 142         {
 143                 mp_msg(MSGT_VO, MSGL_ERR, "DVB AUDIO SET AV SYNC: %s\n", strerror(errno));
 144                 return -1;
 145         }
 146         //FIXME: in vo_mpegpes audio was initialized as MUTEd
 147         if((ioctl(vo_mpegpes_fd2,AUDIO_SET_MUTE, false) < 0))
 148         {
 149                 mp_msg(MSGT_VO, MSGL_ERR, "DVB AUDIO SET MUTE: %s\n", strerror(errno));
 150                 return -1;
 151         }
 152         return vo_mpegpes_fd2;
 153 }
 154 #endif
 155
 156 static int preinit(const char *arg)
 157 {
 158         int card = -1;
 159         char *ao_file = NULL;
 160
 161         const opt_t subopts[] = {
 162                 {"card", OPT_ARG_INT, &card, NULL},
 163                 {"file", OPT_ARG_MSTRZ, &ao_file, NULL},
 164                 {NULL}
 165         };
 166
 167         if(subopt_parse(ao_subdevice, subopts) != 0)
 168         {
 169                 mp_msg(MSGT_VO, MSGL_ERR, "AO_MPEGPES, Unrecognized options\n");
 170                 return -1;
 171         }
 172         if(card==-1)
 173         {
 174                 //search the first usable card
 175                 int n;
 176                 char file[30];
 177                 for(n=0; n<4; n++)
 178                 {
 179                         sprintf(file, "/dev/dvb/adapter%d/audio0", n);
 180                         if(access(file, F_OK | W_OK)==0)
 181                         {
 182                                 card = n+1;
 183                                 break;
 184                         }
 185                 }
 186         }
 187         if((card < 1) || (card > 4))
 188         {
 189                 mp_msg(MSGT_VO, MSGL_ERR, "DVB card number must be between 1 and 4\n");
 190                 return -1;
 191         }
 192         card--;
 193
 194 #ifdef CONFIG_DVB
 195         if(!ao_file)
 196                 return init_device(card);
 197 #else
 198         if(!ao_file)
 199                 return vo_mpegpes_fd;   //video fd
 200 #endif
 201
 202         vo_mpegpes_fd2=open(ao_file,O_WRONLY|O_CREAT,0666);
 203         if(vo_mpegpes_fd2<0)
 204         {
 205                 mp_msg(MSGT_VO, MSGL_ERR, "ao_mpegpes: %s\n", strerror(errno));
 206                 return -1;
 207         }
 208         return vo_mpegpes_fd2;
 209 }
 210
 211 static int my_ao_write(unsigned char* data,int len){
 212     int orig_len = len;
 213 #ifdef CONFIG_DVB
 214 #define NFD   1
 215     struct pollfd pfd[NFD];
 216
 217     pfd[0].fd = vo_mpegpes_fd2;
 218     pfd[0].events = POLLOUT;
 219
 220     while(len>0){
 221         if(poll(pfd,NFD,1)){
 222             if(pfd[0].revents & POLLOUT){
 223                 int ret=write(vo_mpegpes_fd2,data,len);
 224                 if(ret<=0){
 225                     mp_msg(MSGT_VO, MSGL_ERR, "ao_mpegpes write: %s\n", strerror(errno));
 226                     usleep(0);
 227                 } else {
 228                     len-=ret;
 229                     data+=ret;
 230                 }
 231             } else usleep(1000);
 232         }
 233     }
 234
 235 #else
 236     if(vo_mpegpes_fd2<0) return 0; // no file
 237     write(vo_mpegpes_fd2,data,len); // write to file
 238 #endif
 239     return orig_len;
 240 }
 241
 242
 243 // open & setup audio device
 244 // return: 1=success 0=fail
 245 static int init(int rate,int channels,int format,int flags){
 246     if(preinit(NULL)<0) return 0;
 247
 248     ao_data.channels=2;
 249     ao_data.outburst=2000;
 250     switch(format){
 251         case AF_FORMAT_S16_BE:
 252         case AF_FORMAT_MPEG2:
 253         case AF_FORMAT_AC3_BE:
 254             ao_data.format=format;
 255             break;
 256         case AF_FORMAT_AC3_LE:
 257             ao_data.format=AF_FORMAT_AC3_BE;
 258             break;
 259         default:
 260             ao_data.format=AF_FORMAT_S16_BE;
 261     }
 262
 263     switch(rate){
 264         case 48000:     freq_id=0;break;
 265         case 96000:     freq_id=1;break;
 266         case 44100:     freq_id=2;break;
 267         case 32000:     freq_id=3;break;
 268         default:
 269             mp_msg(MSGT_AO, MSGL_ERR, MSGTR_AO_MPEGPES_UnsupSamplerate, rate);
 270 #if 0
 271             if(rate>48000) rate=96000; else
 272             if(rate>44100) rate=48000; else
 273             if(rate>32000) rate=44100; else
 274             rate=32000;
 275             goto retry;
 276 #else
 277             rate=48000; freq_id=0;
 278 #endif
 279     }
 280
 281     ao_data.bps=rate*2*2;
 282     freq=ao_data.samplerate=rate;
 283
 284     return 1;
 285 }
 286
 287 // close audio device
 288 static void uninit(int immed){
 289
 290 }
 291
 292 // stop playing and empty buffers (for seeking/pause)
 293 static void reset(void){
 294
 295 }
 296
 297 // stop playing, keep buffers (for pause)
 298 static void audio_pause(void)
 299 {
 300     // for now, just call reset();
 301     reset();
 302 }
 303
 304 // resume playing, after audio_pause()
 305 static void audio_resume(void)
 306 {
 307 }
 308
 309 void send_pes_packet(unsigned char* data,int len,int id,int timestamp);
 310 void send_lpcm_packet(unsigned char* data,int len,int id,int timestamp,int freq_id);
 311 extern int vo_pts;
 312
 313 // return: how many bytes can be played without blocking
 314 static int get_space(void){
 315     float x=(float)(vo_pts-ao_data.pts)/90000.0;
 316     int y;
 317     //FIXME: is it correct?
 318     if(vo_mpegpes_fd < 0) return 32000; //not using -vo mpegpes
 319 //    printf("vo_pts: %5.3f  ao_pts: %5.3f\n",vo_pts/90000.0,ao_data.pts/90000.0);
 320     if(x<=0) return 0;
 321     y=freq*4*x;y/=ao_data.outburst;y*=ao_data.outburst;
 322     if(y>32000) y=32000;
 323 //    printf("diff: %5.3f -> %d  \n",x,y);
 324     return y;
 325 }
 326
 327 // plays 'len' bytes of 'data'
 328 // it should round it down to outburst*n
 329 // return: number of bytes played
 330 static int play(void* data,int len,int flags){
 331 //    printf("\nao_mpegpes: play(%d) freq=%d\n",len,freq_id);
 332     if(ao_data.format==AF_FORMAT_MPEG2)
 333         send_mpeg_pes_packet (data, len, 0x1C0, ao_data.pts, 1, my_ao_write);
 334     else {
 335         int i;
 336         unsigned short *s=data;
 337 //      if(len>2000) len=2000;
 338 //      printf("ao_mpegpes: len=%d  \n",len);
 339         send_mpeg_lpcm_packet(data, len, 0xA0, ao_data.pts, freq_id, my_ao_write);
 340     }
 341     return len;
 342 }
 343
 344 // return: delay in seconds between first and last sample in buffer
 345 static float get_delay(void){
 346
 347     return 0.0;
 348 }