libmpdemux/demux_nemesi.c

   1 /*
   2  * Copyright (C) 2007 Alessandro Molina <amol.wrk@gmail.com>
   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 #include <stdlib.h>
  21 #include <stdio.h>
  22 #include "stream/stream.h"
  23 #include "demuxer.h"
  24 #include "stheader.h"
  25 #define HAVE_STRUCT_SOCKADDR_STORAGE
  26 #include "nemesi/rtsp.h"
  27 #include "nemesi/rtp.h"
  28 #include <sched.h>
  29
  30 int rtsp_transport_http = 0;
  31 int rtsp_transport_tcp = 0;
  32 int rtsp_transport_sctp = 0;
  33 int rtsp_port = 0;
  34
  35 typedef struct {
  36     char * mime;
  37     unsigned int fourcc;
  38 } MIMEto4CC;
  39
  40 #define NMS_MAX_FORMATS 16
  41
  42 MIMEto4CC supported_audio[NMS_MAX_FORMATS] = {
  43     {"MPA", 0x55},
  44     {"vorbis", mmioFOURCC('v','r','b','s')},
  45     {"mpeg4-generic", mmioFOURCC('M','P','4','A')},
  46     {NULL, 0},
  47 };
  48
  49 MIMEto4CC supported_video[NMS_MAX_FORMATS] = {
  50     {"MPV", mmioFOURCC('M','P','E','G')},
  51     {"theora",mmioFOURCC('t','h','e','o')},
  52     {"H264", mmioFOURCC('H','2','6','4')},
  53     {"H263-1998", mmioFOURCC('H','2','6','3')},
  54     {"MP4V-ES", mmioFOURCC('M','P','4','V')},
  55     {NULL, 0},
  56 };
  57
  58 typedef enum { NEMESI_SESSION_VIDEO,
  59                NEMESI_SESSION_AUDIO } Nemesi_SessionType;
  60
  61 typedef struct {
  62     rtsp_ctrl * rtsp;
  63     rtp_session * session[2];
  64     rtp_frame first_pkt[2];
  65     double time[2];
  66     double seek;
  67 } Nemesi_DemuxerStreamData;
  68
  69
  70 #define STYPE_TO_DS(demuxer, stype) \
  71     ((stype) == NEMESI_SESSION_VIDEO ? (demuxer)->video : (demuxer)->audio)
  72
  73 #define DS_TO_STYPE(demuxer, ds) \
  74     ((ds) == (demuxer)->video ? NEMESI_SESSION_VIDEO : NEMESI_SESSION_AUDIO)
  75
  76 #define INVERT_STYPE(stype) ((stype + 1) % 2)
  77
  78 static unsigned int get4CC(MIMEto4CC * supported_formats, char const * format)
  79 {
  80     unsigned i;
  81
  82     for(i = 0; i < NMS_MAX_FORMATS; ++i) {
  83         if (!supported_formats[i].mime)
  84             return 0;
  85         else if ( strcmp(supported_formats[i].mime, format) == 0 )
  86             return supported_formats[i].fourcc;
  87     }
  88
  89     return 0;
  90 }
  91
  92 static rtp_ssrc *wait_for_packets(Nemesi_DemuxerStreamData * ndsd, Nemesi_SessionType stype)
  93 {
  94     rtp_ssrc *ssrc = NULL;
  95
  96     /* Wait for prebuffering (prebuffering must be enabled in nemesi) */
  97     int terminated = rtp_fill_buffers(rtsp_get_rtp_th(ndsd->rtsp));
  98
  99     /* Wait for the ssrc to be registered, if prebuffering is on in nemesi
 100        this will just get immediatly the correct ssrc */
 101     if (!terminated) {
 102         while ( !(ssrc = rtp_session_get_ssrc(ndsd->session[stype], ndsd->rtsp)) )
 103             sched_yield();
 104     }
 105
 106     return ssrc;
 107 }
 108
 109 static void link_session_and_fetch_conf(Nemesi_DemuxerStreamData * ndsd,
 110                                         Nemesi_SessionType stype,
 111                                         rtp_session * sess,
 112                                         rtp_buff * buff, unsigned int * fps)
 113 {
 114     extern double force_fps;
 115     rtp_ssrc *ssrc = NULL;
 116     rtp_frame * fr = &ndsd->first_pkt[stype];
 117     rtp_buff trash_buff;
 118     int must_prefetch = ((fps != NULL) || (buff != NULL)) ? 1 : 0;
 119
 120     ndsd->session[stype] = sess;
 121
 122     ssrc = wait_for_packets(ndsd, stype);
 123
 124     if ( ((ssrc) && (must_prefetch)) ) {
 125         if (buff == NULL)
 126             buff = &trash_buff;
 127
 128         rtp_fill_buffer(ssrc, fr, buff); //Prefetch the first packet
 129
 130         /* Packet prefecthing must be done anyway or we won't be
 131            able to get the metadata, but fps calculation happens
 132            only if the user didn't specify the FPS */
 133         if ( ((!force_fps) && (fps != NULL)) ) {
 134             while ( *fps <= 0 ) {
 135                 //Wait more pkts to calculate FPS and try again
 136                 sched_yield();
 137                 *fps = rtp_get_fps(ssrc);
 138             }
 139         }
 140     }
 141 }
 142
 143 static demuxer_t* demux_open_rtp(demuxer_t* demuxer)
 144 {
 145     nms_rtsp_hints hints;
 146     char * url = demuxer->stream->streaming_ctrl->url->url;
 147     rtsp_ctrl * ctl;
 148     RTSP_Error reply;
 149     rtsp_medium * media;
 150     Nemesi_DemuxerStreamData * ndsd = calloc(1, sizeof(Nemesi_DemuxerStreamData));
 151
 152     memset(&hints,0,sizeof(hints));
 153     if (rtsp_port) hints.first_rtp_port = rtsp_port;
 154     if (rtsp_transport_tcp) {
 155         hints.pref_rtsp_proto = TCP;
 156         hints.pref_rtp_proto = TCP;
 157     }
 158     if (rtsp_transport_sctp) {
 159         hints.pref_rtsp_proto = SCTP;
 160         hints.pref_rtp_proto = SCTP;
 161     }
 162
 163     mp_msg(MSGT_DEMUX, MSGL_INFO, "Initializing libNemesi\n");
 164     if ((ctl = rtsp_init(&hints)) == NULL) {
 165         free(ndsd);
 166         return STREAM_ERROR;
 167     }
 168
 169     ndsd->rtsp = ctl;
 170     demuxer->priv = ndsd;
 171     //nms_verbosity_set(1);
 172
 173     mp_msg(MSGT_DEMUX, MSGL_INFO, "Opening: %s\n", url);
 174     if (rtsp_open(ctl, url)) {
 175         mp_msg(MSGT_DEMUX, MSGL_ERR, "rtsp_open failed.\n");
 176         return demuxer;
 177     }
 178
 179     reply = rtsp_wait(ctl);
 180     if (reply.got_error) {
 181         mp_msg(MSGT_DEMUX, MSGL_ERR,
 182                "OPEN Error from the server: %s\n",
 183                reply.message.reply_str);
 184         return demuxer;
 185     }
 186
 187     rtsp_play(ctl, 0, 0);
 188     reply = rtsp_wait(ctl);
 189     if (reply.got_error) {
 190         mp_msg(MSGT_DEMUX, MSGL_ERR,
 191                "PLAY Error from the server: %s\n",
 192                reply.message.reply_str);
 193         return demuxer;
 194     }
 195
 196     if (!ctl->rtsp_queue)
 197         return demuxer;
 198
 199     media = ctl->rtsp_queue->media_queue;
 200     for (; media; media=media->next) {
 201         sdp_medium_info * info = media->medium_info;
 202         rtp_session * sess = media->rtp_sess;
 203         rtp_buff buff;
 204
 205         int media_format = atoi(info->fmts);
 206         rtp_pt * ptinfo = rtp_get_pt_info(sess, media_format);
 207         char const * format_name = ptinfo ? ptinfo->name : NULL;
 208
 209         memset(&buff, 0, sizeof(rtp_buff));
 210
 211         if (sess->parsers[media_format] == NULL) {
 212             mp_msg(MSGT_DEMUX, MSGL_ERR,
 213                    "libNemesi unsupported media format: %s\n",
 214                    format_name ? format_name : info->fmts);
 215             continue;
 216         }
 217         else {
 218             mp_msg(MSGT_DEMUX, MSGL_INFO,
 219                    "libNemesi supported media: %s\n",
 220                    format_name);
 221         }
 222
 223         if (ptinfo->type == AU) {
 224             if (ndsd->session[NEMESI_SESSION_AUDIO] == NULL) {
 225                 sh_audio_t* sh_audio = new_sh_audio(demuxer,0);
 226                 WAVEFORMATEX* wf;
 227                 demux_stream_t* d_audio = demuxer->audio;
 228                 demuxer->audio->id = 0;
 229
 230                 mp_msg(MSGT_DEMUX, MSGL_INFO, "Detected as AUDIO stream...\n");
 231
 232                 link_session_and_fetch_conf(ndsd, NEMESI_SESSION_AUDIO,
 233                                             sess, &buff, NULL);
 234
 235                 wf = calloc(1,sizeof(*wf)+buff.len);
 236                 wf->cbSize = buff.len;
 237                 memcpy(wf+1, buff.data, buff.len);
 238
 239                 sh_audio->wf = wf;
 240                 d_audio->sh = sh_audio;
 241                 sh_audio->ds = d_audio;
 242                 wf->nSamplesPerSec = 0;
 243
 244                 wf->wFormatTag =
 245                 sh_audio->format = get4CC(supported_audio, format_name);
 246                 if ( !(wf->wFormatTag) )
 247                     mp_msg(MSGT_DEMUX, MSGL_WARN,
 248                            "Unknown MPlayer format code for MIME"
 249                            " type \"audio/%s\"\n", format_name);
 250             } else {
 251                 mp_msg(MSGT_DEMUX, MSGL_ERR,
 252                        "There is already an audio session registered,"
 253                        " ignoring...\n");
 254             }
 255         } else if (ptinfo->type == VI) {
 256             if (ndsd->session[NEMESI_SESSION_VIDEO] == NULL) {
 257                 sh_video_t* sh_video;
 258                 BITMAPINFOHEADER* bih;
 259                 demux_stream_t* d_video;
 260                 int fps = 0;
 261
 262                 mp_msg(MSGT_DEMUX, MSGL_INFO, "Detected as VIDEO stream...\n");
 263
 264                 link_session_and_fetch_conf(ndsd, NEMESI_SESSION_VIDEO,
 265                                             sess, &buff, &fps);
 266
 267                 bih = calloc(1,sizeof(*bih)+buff.len);
 268                 bih->biSize = sizeof(*bih)+buff.len;
 269                 memcpy(bih+1, buff.data, buff.len);
 270
 271                 sh_video = new_sh_video(demuxer,0);
 272                 sh_video->bih = bih;
 273                 d_video = demuxer->video;
 274                 d_video->sh = sh_video;
 275                 sh_video->ds = d_video;
 276
 277                 if (fps) {
 278                     sh_video->fps = fps;
 279                     sh_video->frametime = 1.0/fps;
 280                 }
 281
 282                 bih->biCompression =
 283                 sh_video->format = get4CC(supported_video, format_name);
 284                 if ( !(bih->biCompression) ) {
 285                     mp_msg(MSGT_DEMUX, MSGL_WARN,
 286                         "Unknown MPlayer format code for MIME"
 287                         " type \"video/%s\"\n", format_name);
 288                 }
 289             } else {
 290                 mp_msg(MSGT_DEMUX, MSGL_ERR,
 291                        "There is already a video session registered,"
 292                        " ignoring...\n");
 293             }
 294         } else {
 295             mp_msg(MSGT_DEMUX, MSGL_ERR, "Unsupported media type\n");
 296         }
 297     }
 298
 299     demuxer->stream->eof = 0;
 300
 301     return demuxer;
 302 }
 303
 304 static int get_data_for_session(Nemesi_DemuxerStreamData * ndsd,
 305                                 Nemesi_SessionType stype, rtp_ssrc * ssrc,
 306                                 rtp_frame * fr)
 307 {
 308     if (ndsd->first_pkt[stype].len != 0) {
 309         fr->data = ndsd->first_pkt[stype].data;
 310         fr->time_sec = ndsd->first_pkt[stype].time_sec;
 311         fr->len = ndsd->first_pkt[stype].len;
 312         ndsd->first_pkt[stype].len = 0;
 313         return RTP_FILL_OK;
 314     } else {
 315         rtp_buff buff;
 316         return rtp_fill_buffer(ssrc, fr, &buff);
 317     }
 318 }
 319
 320 static void stream_add_packet(Nemesi_DemuxerStreamData * ndsd,
 321                               Nemesi_SessionType stype,
 322                               demux_stream_t* ds, rtp_frame * fr)
 323 {
 324     demux_packet_t* dp = new_demux_packet(fr->len);
 325     memcpy(dp->buffer, fr->data, fr->len);
 326
 327     fr->time_sec += ndsd->seek;
 328     ndsd->time[stype] = dp->pts = fr->time_sec;
 329
 330     ds_add_packet(ds, dp);
 331 }
 332
 333 static int demux_rtp_fill_buffer(demuxer_t* demuxer, demux_stream_t* ds)
 334 {
 335     Nemesi_DemuxerStreamData * ndsd = demuxer->priv;
 336     Nemesi_SessionType stype;
 337     rtp_ssrc * ssrc;
 338     rtp_frame fr;
 339
 340     if ( (!ndsd->rtsp->rtsp_queue) || (demuxer->stream->eof) ) {
 341         mp_msg(MSGT_DEMUX, MSGL_INFO, "End of Stream...\n");
 342         demuxer->stream->eof = 1;
 343         return 0;
 344     }
 345
 346     memset(&fr, 0, sizeof(fr));
 347
 348     stype = DS_TO_STYPE(demuxer, ds);
 349     if ( (ssrc = wait_for_packets(ndsd, stype)) == NULL ) {
 350         mp_msg(MSGT_DEMUX, MSGL_INFO, "Bye...\n");
 351         demuxer->stream->eof = 1;
 352         return 0;
 353     }
 354
 355     if(!get_data_for_session(ndsd, stype, ssrc, &fr))
 356         stream_add_packet(ndsd, stype, ds, &fr);
 357     else {
 358         stype = INVERT_STYPE(stype);
 359
 360         //Must check if we actually have a stream of the other type
 361         if (!ndsd->session[stype])
 362             return 1;
 363
 364         ds = STYPE_TO_DS(demuxer, stype);
 365         ssrc = wait_for_packets(ndsd, stype);
 366
 367         if(!get_data_for_session(ndsd, stype, ssrc, &fr))
 368             stream_add_packet(ndsd, stype, ds, &fr);
 369     }
 370
 371     return 1;
 372 }
 373
 374
 375 static void demux_close_rtp(demuxer_t* demuxer)
 376 {
 377     Nemesi_DemuxerStreamData * ndsd = demuxer->priv;
 378     rtsp_ctrl * ctl = ndsd->rtsp;
 379     RTSP_Error err;
 380
 381     mp_msg(MSGT_DEMUX, MSGL_INFO, "Closing libNemesi RTSP Stream...\n");
 382
 383     if (ndsd == NULL)
 384         return;
 385
 386     free(ndsd);
 387
 388     if (rtsp_close(ctl)) {
 389         err = rtsp_wait(ctl);
 390         if (err.got_error)
 391             mp_msg(MSGT_DEMUX, MSGL_ERR,
 392                    "Error Closing Stream: %s\n",
 393                    err.message.reply_str);
 394     }
 395
 396     rtsp_uninit(ctl);
 397 }
 398
 399 static void demux_seek_rtp(demuxer_t *demuxer, float rel_seek_secs,
 400                            float audio_delay, int flags)
 401 {
 402     Nemesi_DemuxerStreamData * ndsd = demuxer->priv;
 403     rtsp_ctrl * ctl = ndsd->rtsp;
 404     sdp_attr * r_attr = NULL;
 405     sdp_range r = {0, 0};
 406     double time = ndsd->time[NEMESI_SESSION_VIDEO] ?
 407                   ndsd->time[NEMESI_SESSION_VIDEO] :
 408                   ndsd->time[NEMESI_SESSION_AUDIO];
 409
 410     if (!ctl->rtsp_queue)
 411         return;
 412
 413     r_attr = sdp_get_attr(ctl->rtsp_queue->info->attr_list, "range");
 414     if (r_attr)
 415         r = sdp_parse_range(r_attr->value);
 416
 417     //flags & 1 -> absolute seek
 418     //flags & 2 -> percent seek
 419     if (flags == 0) {
 420         time += rel_seek_secs;
 421         if (time < r.begin)
 422             time = r.begin;
 423         else if (time > r.end)
 424             time = r.end;
 425         ndsd->seek = time;
 426
 427         mp_msg(MSGT_DEMUX,MSGL_WARN,"libNemesi SEEK %f on %f - %f)\n",
 428            time, r.begin, r.end);
 429
 430         if (!rtsp_seek(ctl, time, 0)) {
 431             RTSP_Error err = rtsp_wait(ctl);
 432             if (err.got_error) {
 433                 mp_msg(MSGT_DEMUX, MSGL_ERR,
 434                        "Error Performing Seek: %s\n",
 435                        err.message.reply_str);
 436                 demuxer->stream->eof = 1;
 437             }
 438             else
 439                 mp_msg(MSGT_DEMUX, MSGL_INFO, "Seek, performed\n");
 440         }
 441         else {
 442             mp_msg(MSGT_DEMUX, MSGL_ERR, "Unable to pause stream to perform seek\n");
 443             demuxer->stream->eof = 1;
 444         }
 445     }
 446     else
 447         mp_msg(MSGT_DEMUX, MSGL_ERR, "Unsupported seek type\n");
 448 }
 449
 450 static int demux_rtp_control(struct demuxer *demuxer, int cmd, void *arg)
 451 {
 452     Nemesi_DemuxerStreamData * ndsd = demuxer->priv;
 453     rtsp_ctrl * ctl = ndsd->rtsp;
 454     sdp_attr * r_attr = NULL;
 455     sdp_range r = {0, 0};
 456     double time = ndsd->time[NEMESI_SESSION_VIDEO] ?
 457                   ndsd->time[NEMESI_SESSION_VIDEO] :
 458                   ndsd->time[NEMESI_SESSION_AUDIO];
 459
 460     if (!ctl->rtsp_queue)
 461         return DEMUXER_CTRL_DONTKNOW;
 462
 463     r_attr = sdp_get_attr(ctl->rtsp_queue->info->attr_list, "range");
 464     if (r_attr)
 465         r = sdp_parse_range(r_attr->value);
 466
 467     switch (cmd) {
 468         case DEMUXER_CTRL_GET_TIME_LENGTH:
 469             if (r.end == 0)
 470                 return DEMUXER_CTRL_DONTKNOW;
 471
 472             *((double *)arg) = ((double)r.end) - ((double)r.begin);
 473             return DEMUXER_CTRL_OK;
 474
 475         case DEMUXER_CTRL_GET_PERCENT_POS:
 476             if (r.end == 0)
 477                 return DEMUXER_CTRL_DONTKNOW;
 478
 479             *((int *)arg) = (int)( time * 100 / (r.end - r.begin) );
 480             return DEMUXER_CTRL_OK;
 481         default:
 482            return DEMUXER_CTRL_DONTKNOW;
 483     }
 484 }
 485
 486 const demuxer_desc_t demuxer_desc_rtp_nemesi = {
 487   "libnemesi RTP demuxer",
 488   "nemesi",
 489   "",
 490   "Alessandro Molina",
 491   "requires libnemesi",
 492   DEMUXER_TYPE_RTP_NEMESI,
 493   0, // no autodetect
 494   NULL,
 495   demux_rtp_fill_buffer,
 496   demux_open_rtp,
 497   demux_close_rtp,
 498   demux_seek_rtp,
 499   demux_rtp_control
 500 };