libvo/vo_mpegpes.c

   1 // Don't change for DVB card, it must be 2048
   2 #define PES_MAX_SIZE 2048
   3
   4 /*
   5  * Based on:
   6  *
   7  * test_av.c - Test program for new API
   8  *
   9  * Copyright (C) 2000 Ralph  Metzler <ralph@convergence.de>
  10  *                  & Marcus Metzler <marcus@convergence.de>
  11  *                    for convergence integrated media GmbH
  12  *
  13  * libav - MPEG-PS multiplexer, part of ffmpeg
  14  * Copyright Gerard Lantau  (see http://ffmpeg.sf.net)
  15  *
  16  */
  17
  18 #include "config.h"
  19 #include <stdio.h>
  20 #include <stdlib.h>
  21 #include <string.h>
  22 #include <errno.h>
  23 #include <sys/types.h>
  24 #include <sys/stat.h>
  25 #include <fcntl.h>
  26 #include <unistd.h>
  27
  28 #include "mp_msg.h"
  29 #ifdef HAVE_DVB_HEAD
  30 #define HAVE_DVB 1
  31 #endif
  32 #ifdef HAVE_DVB
  33 #ifndef HAVE_DVB_HEAD
  34 #include <sys/poll.h>
  35
  36 #include <sys/ioctl.h>
  37 #include <stdio.h>
  38 #include <time.h>
  39
  40 #include <ost/dmx.h>
  41 #include <ost/frontend.h>
  42 #include <ost/sec.h>
  43 #include <ost/video.h>
  44 #include <ost/audio.h>
  45
  46 #else
  47 #define true 1
  48 #define false 0
  49 #include <sys/poll.h>
  50
  51 #include <sys/ioctl.h>
  52 #include <stdio.h>
  53 #include <time.h>
  54
  55 #include <linux/dvb/dmx.h>
  56 #include <linux/dvb/frontend.h>
  57 #include <linux/dvb/video.h>
  58 #include <linux/dvb/audio.h>
  59 #endif
  60 #endif
  61
  62 #include "config.h"
  63 #include "video_out.h"
  64 #include "video_out_internal.h"
  65
  66 int vo_mpegpes_fd=-1;
  67 int vo_mpegpes_fd2=-1;
  68
  69 static vo_info_t info =
  70 {
  71 #ifdef HAVE_DVB
  72         "Mpeg-PES to DVB card",
  73 #else
  74         "Mpeg-PES file",
  75 #endif
  76         "mpegpes",
  77         "A'rpi",
  78         ""
  79 };
  80
  81 LIBVO_EXTERN (mpegpes)
  82
  83 static int
  84 config(uint32_t s_width, uint32_t s_height, uint32_t width, uint32_t height, uint32_t flags, char *title, uint32_t format)
  85 {
  86 #ifdef HAVE_DVB
  87     switch(s_height){
  88     case 288:
  89     case 576:
  90     case 240:
  91     case 480:
  92         break;
  93     default:
  94         mp_msg(MSGT_VO,MSGL_ERR,"DVB: height=%d not supported (try 240/480 (ntsc) or 288/576 (pal)\n",s_height);
  95         return -1;
  96     }
  97 #endif
  98     return 0;
  99 }
 100
 101 static int preinit(const char *arg){
 102 #ifdef HAVE_DVB
 103     int card = 0;
 104     char vo_file[30], ao_file[30], *tmp;
 105
 106     if(arg != NULL){
 107         if((tmp = strstr(arg, "card=")) != NULL) {
 108             card = atoi(&tmp[5]);
 109             if((card < 1) || (card > 4)) {
 110                 mp_msg(MSGT_VO, MSGL_ERR, "DVB card number must be between 1 and 4\n");
 111                 return -1;
 112             }
 113             card--;
 114             arg = NULL;
 115         }
 116     }
 117
 118     if(!arg){
 119     //|O_NONBLOCK
 120 #ifndef HAVE_DVB_HEAD
 121         mp_msg(MSGT_VO,MSGL_INFO, "Opening /dev/ost/video+audio\n");
 122         sprintf(vo_file, "/dev/ost/video");
 123         sprintf(ao_file, "/dev/ost/audio");
 124 #else
 125         mp_msg(MSGT_VO,MSGL_INFO, "Opening /dev/dvb/adapter%d/video0+audio0\n", card);
 126         sprintf(vo_file, "/dev/dvb/adapter%d/video0", card);
 127         sprintf(ao_file, "/dev/dvb/adapter%d/audio0", card);
 128 #endif
 129         if((vo_mpegpes_fd = open(vo_file,O_RDWR)) < 0){
 130                 perror("DVB VIDEO DEVICE: ");
 131                 return -1;
 132         }
 133         if((vo_mpegpes_fd2 = open(ao_file,O_RDWR|O_NONBLOCK)) < 0){
 134                 perror("DVB AUDIO DEVICE: ");
 135                 return -1;
 136         }
 137         if ( (ioctl(vo_mpegpes_fd,VIDEO_SET_BLANK, false) < 0)){
 138                 perror("DVB VIDEO SET BLANK: ");
 139                 return -1;
 140         }
 141         if ( (ioctl(vo_mpegpes_fd,VIDEO_SELECT_SOURCE, VIDEO_SOURCE_MEMORY) < 0)){
 142                 perror("DVB VIDEO SELECT SOURCE: ");
 143                 return -1;
 144         }
 145 #if 1
 146         if ( (ioctl(vo_mpegpes_fd2,AUDIO_SELECT_SOURCE, AUDIO_SOURCE_MEMORY) < 0)){
 147                 perror("DVB AUDIO SELECT SOURCE: ");
 148                 return -1;
 149         }
 150         if ( (ioctl(vo_mpegpes_fd2,AUDIO_PLAY) < 0)){
 151                 perror("DVB AUDIO PLAY: ");
 152                 return -1;
 153         }
 154 #else
 155         if ( (ioctl(vo_mpegpes_fd2,AUDIO_STOP,0) < 0)){
 156                 perror("DVB AUDIO STOP: ");
 157                 return -1;
 158         }
 159 #endif
 160         if ( (ioctl(vo_mpegpes_fd,VIDEO_PLAY) < 0)){
 161                 perror("DVB VIDEO PLAY: ");
 162                 return -1;
 163         }
 164         if ( (ioctl(vo_mpegpes_fd2,AUDIO_SET_AV_SYNC, true) < 0)){
 165                 perror("DVB AUDIO SET AV SYNC: ");
 166                 return -1;
 167         }
 168 //      if ( (ioctl(vo_mpegpes_fd2,AUDIO_SET_MUTE, false) < 0)){
 169         if ( (ioctl(vo_mpegpes_fd2,AUDIO_SET_MUTE, true) < 0)){
 170                 perror("DVB AUDIO SET MUTE: ");
 171                 return -1;
 172         }
 173         return 0;
 174     }
 175 #endif
 176     arg = (arg ? arg : "grab.mpg");
 177     mp_msg(MSGT_VO,MSGL_INFO, "Saving PES stream to %s\n", arg);
 178     vo_mpegpes_fd=open(arg,O_WRONLY|O_CREAT,0666);
 179     if(vo_mpegpes_fd<0){
 180         perror("vo_mpegpes");
 181         return -1;
 182     }
 183     vo_mpegpes_fd2=vo_mpegpes_fd;
 184     return 0;
 185 }
 186
 187
 188 static void draw_osd(void)
 189 {
 190 }
 191
 192
 193 static void my_write(unsigned char* data,int len){
 194 #ifdef HAVE_DVB
 195 #define NFD   2
 196     struct pollfd pfd[NFD];
 197
 198 //    printf("write %d bytes  \n",len);
 199
 200         pfd[0].fd = vo_mpegpes_fd;
 201         pfd[0].events = POLLOUT;
 202
 203         pfd[1].fd = vo_mpegpes_fd2;
 204         pfd[1].events = POLLOUT;
 205
 206     while(len>0){
 207         if (poll(pfd,NFD,1)){
 208             if (pfd[0].revents & POLLOUT){
 209                 int ret=write(vo_mpegpes_fd,data,len);
 210 //              printf("ret=%d  \n",ret);
 211                 if(ret<=0){
 212                     perror("write");
 213                     usleep(0);
 214                 } else {
 215                     len-=ret; data+=ret;
 216                 }
 217             } else usleep(1000);
 218         }
 219     }
 220
 221 #else
 222     write(vo_mpegpes_fd,data,len); // write to file
 223 #endif
 224 }
 225
 226 static unsigned char pes_header[PES_MAX_SIZE];
 227
 228 void send_pes_packet(unsigned char* data,int len,int id,int timestamp){
 229     int ptslen=timestamp?5:1;
 230
 231               // startcode:
 232               pes_header[0]=pes_header[1]=0;
 233               pes_header[2]=id>>8; pes_header[3]=id&255;
 234
 235     while(len>0){
 236             int payload_size=len;  // data + PTS
 237             if(6+ptslen+payload_size>PES_MAX_SIZE) payload_size=PES_MAX_SIZE-(6+ptslen);
 238
 239     // construct PES header:  (code from ffmpeg's libav)
 240               // packetsize:
 241               pes_header[4]=(ptslen+payload_size)>>8;
 242               pes_header[5]=(ptslen+payload_size)&255;
 243
 244         if(ptslen==5){
 245               int x;
 246               // presentation time stamp:
 247               x=(0x02 << 4) | (((timestamp >> 30) & 0x07) << 1) | 1;
 248               pes_header[6]=x;
 249               x=((((timestamp >> 15) & 0x7fff) << 1) | 1);
 250               pes_header[7]=x>>8; pes_header[8]=x&255;
 251               x=((((timestamp) & 0x7fff) << 1) | 1);
 252               pes_header[9]=x>>8; pes_header[10]=x&255;
 253         } else {
 254               // stuffing and header bits:
 255               pes_header[6]=0x0f;
 256         }
 257
 258         memcpy(&pes_header[6+ptslen],data,payload_size);
 259         my_write(pes_header,6+ptslen+payload_size);
 260
 261         len-=payload_size; data+=payload_size;
 262         ptslen=1; // store PTS only once, at first packet!
 263     }
 264
 265 //    printf("PES: draw frame!  pts=%d   size=%d  \n",timestamp,len);
 266
 267 }
 268
 269 void send_lpcm_packet(unsigned char* data,int len,int id,unsigned int timestamp,int freq_id){
 270
 271     int ptslen=timestamp?5:0;
 272
 273               // startcode:
 274               pes_header[0]=pes_header[1]=0;
 275               pes_header[2]=1; pes_header[3]=0xBD;
 276
 277     while(len>=4){
 278             int payload_size;
 279
 280             payload_size=PES_MAX_SIZE-6-20; // max possible data len
 281             if(payload_size>len) payload_size=len;
 282             payload_size&=(~3); // align!
 283
 284             //if(6+payload_size>PES_MAX_SIZE) payload_size=PES_MAX_SIZE-6;
 285
 286               // packetsize:
 287               pes_header[4]=(payload_size+3+ptslen+7)>>8;
 288               pes_header[5]=(payload_size+3+ptslen+7)&255;
 289
 290               // stuffing:
 291               // TTCCxxxx  CC=css TT=type: 1=STD 0=mpeg1 2=vob
 292               pes_header[6]=0x81;
 293
 294               // FFxxxxxx   FF=pts flags=2 vs 0
 295               pes_header[7]=ptslen ? 0x80 : 0;
 296
 297               // hdrlen:
 298               pes_header[8]=ptslen;
 299
 300           if(ptslen){
 301               int x;
 302               // presentation time stamp:
 303               x=(0x02 << 4) | (((timestamp >> 30) & 0x07) << 1) | 1;
 304               pes_header[9]=x;
 305               x=((((timestamp >> 15) & 0x7fff) << 1) | 1);
 306               pes_header[10]=x>>8; pes_header[11]=x&255;
 307               x=((((timestamp) & 0x7fff) << 1) | 1);
 308               pes_header[12]=x>>8; pes_header[13]=x&255;
 309           }
 310
 311 // ============ LPCM header: (7 bytes) =================
 312 // Info by mocm@convergence.de
 313
 314 //         ID:
 315               pes_header[ptslen+9]=id;
 316
 317 //         number of frames:
 318               pes_header[ptslen+10]=0x07;
 319
 320 //         first acces unit pointer, i.e. start of audio frame:
 321               pes_header[ptslen+11]=0x00;
 322               pes_header[ptslen+12]=0x04;
 323
 324 //         audio emphasis on-off                                  1 bit
 325 //         audio mute on-off                                      1 bit
 326 //         reserved                                               1 bit
 327 //         audio frame number                                     5 bit
 328               pes_header[ptslen+13]=0x0C;
 329
 330 //         quantization word length                               2 bit
 331 //         audio sampling frequency (48khz = 0, 96khz = 1)        2 bit
 332 //         reserved                                               1 bit
 333 //         number of audio channels - 1 (e.g. stereo = 1)         3 bit
 334               pes_header[ptslen+14]=1|(freq_id<<4);
 335
 336 //         dynamic range control (0x80 if off)
 337               pes_header[ptslen+15]=0x80;
 338
 339         memcpy(&pes_header[6+3+ptslen+7],data,payload_size);
 340         my_write(pes_header,6+3+ptslen+7+payload_size);
 341
 342         len-=payload_size; data+=payload_size;
 343         ptslen=0; // store PTS only once, at first packet!
 344     }
 345
 346 //    printf("PES: draw frame!  pts=%d   size=%d  \n",timestamp,len);
 347
 348 }
 349
 350
 351 static int draw_frame(uint8_t * src[])
 352 {
 353     vo_mpegpes_t *p=(vo_mpegpes_t *)src[0];
 354     send_pes_packet(p->data,p->size,p->id,(p->timestamp>0)?p->timestamp:vo_pts);  // video data
 355     return 0;
 356 }
 357
 358 static void flip_page (void)
 359 {
 360 }
 361
 362 static int draw_slice(uint8_t *srcimg[], int stride[], int w,int h,int x0,int y0)
 363 {
 364     return 0;
 365 }
 366
 367
 368 static int
 369 query_format(uint32_t format)
 370 {
 371     if(format==IMGFMT_MPEGPES) return VFCAP_CSP_SUPPORTED|VFCAP_CSP_SUPPORTED_BY_HW|VFCAP_TIMER;
 372     return 0;
 373 }
 374
 375 static void
 376 uninit(void)
 377 {
 378     if(vo_mpegpes_fd2>=0 && vo_mpegpes_fd2!=vo_mpegpes_fd) close(vo_mpegpes_fd2);
 379     vo_mpegpes_fd2=-1;
 380     if(vo_mpegpes_fd>=0){ close(vo_mpegpes_fd);vo_mpegpes_fd=-1;}
 381 }
 382
 383
 384 static void check_events(void)
 385 {
 386 }
 387
 388 static int control(uint32_t request, void *data, ...)
 389 {
 390   switch (request) {
 391   case VOCTRL_QUERY_FORMAT:
 392     return query_format(*((uint32_t*)data));
 393   }
 394   return VO_NOTIMPL;
 395 }