gmyth: gst-plugins-mythtv/src/gstmythtvsrc.c@d5f5855e7800

     1 /* vim: set sw=2: -*- Mode: C; tab-width: 2; indent-tabs-mode: t; c-basic-offset: 2; c-indent-level: 2 -*- */

     2 /* GStreamer MythTV Plug-in

     3  * Copyright (C) <2006> Rosfran Borges <rosfran.borges@indt.org.br>

     4  *

     5  * This library is free software; you can redistribute it and/or

     6  * modify it under the terms of the GNU Library Lesser General

     7  * Public License as published by the Free Software Foundation; either

     8  * version 2 of the License, or (at your option) any later version.

     9  *

    10  * This library is distributed in the hope that it will be useful,

    11  * but WITHOUT ANY WARRANTY; without even the implied warranty of

    12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

    13  * Library General Public License for more

    14  */

    16 #ifdef HAVE_CONFIG_H

    17 #include "config.h"

    18 #endif

    20 #include "gstmythtvsrc.h"

    21 #include "myth_file_transfer.h"

    22 #include "myth_livetv.h"

    24 #include <gmyth/gmyth_socket.h>

    25 #include <gmyth/gmyth_tvchain.h>

    27 #include <string.h>

    28 #include <unistd.h>

    30 GST_DEBUG_CATEGORY_STATIC (mythtvsrc_debug);

    31 #define GST_CAT_DEFAULT mythtvsrc_debug

    33 #define GST_MYTHTV_ID_NUM		1

    35 #define MYTHTV_VERSION_DEFAULT		30

    37 #define MYTHTV_TRANSFER_MAX_WAITS	100

    39 #define MYTHTV_TRANSFER_MAX_BUFFER	1024*1024

    40 //( 32*1024  )

    42 /* 4*1024 ??? */

    43 #define MAX_READ_SIZE              	12*1024

    44 //( 32*1024 )

    46 #define ENABLE_TIMING_POSITION		0

    48 /* stablish a maximum iteration value to the IS_RECORDING message */

    49 static guint wait_to_transfer = 0;

    51 static const GstElementDetails gst_mythtv_src_details =

    52 GST_ELEMENT_DETAILS ( "MythTV client source",

    53     "Source/Network",

    54     "Control and receive data as a client over the network via raw socket connections using the MythTV protocol",

    55     "Rosfran Borges <rosfran.borges@indt.org.br>" );

    57 static GstStaticPadTemplate srctemplate = GST_STATIC_PAD_TEMPLATE ("src",

    58     GST_PAD_SRC,

    59     GST_PAD_ALWAYS,

    60     GST_STATIC_CAPS ("video/x-nuv") );

    61     //GST_STATIC_CAPS_ANY);

    63 static GThread *update_size_task = NULL;

    65 static GStaticMutex update_size_mutex = G_STATIC_MUTEX_INIT;

    67 enum

    68 {

    69   PROP_0,

    70   PROP_LOCATION,

    71   PROP_URI,

    72 #ifndef GST_DISABLE_GST_DEBUG

    73   PROP_MYTHTV_DBG,

    74 #endif

    75   PROP_MYTHTV_VERSION,

    76   PROP_MYTHTV_LIVE,

    77   PROP_MYTHTV_LIVEID,

    78   PROP_MYTHTV_LIVE_CHAINID

    79 };

    81 static void gst_mythtv_src_finalize (GObject * gobject);

    83 static GstFlowReturn gst_mythtv_src_create (GstBaseSrc * psrc, guint64 offset,

    84 	guint size, GstBuffer ** outbuf);

    85 //static GstFlowReturn gst_mythtv_src_create (GstPushSrc * psrc, GstBuffer ** outbuf);

    86 static gboolean gst_mythtv_src_start (GstBaseSrc * bsrc);

    87 static gboolean gst_mythtv_src_stop (GstBaseSrc * bsrc);

    88 static gboolean gst_mythtv_src_get_size (GstBaseSrc * bsrc, guint64 * size);

    89 static gboolean gst_mythtv_src_is_seekable( GstBaseSrc *push_src );

    90 //static gboolean gst_mythtv_new_segment ( GstBaseSrc * psrc );

    92 static void gst_mythtv_src_set_property (GObject * object, guint prop_id,

    93     const GValue * value, GParamSpec * pspec);

    94 static void gst_mythtv_src_get_property (GObject * object, guint prop_id,

    95     GValue * value, GParamSpec * pspec);

    97 //static GstFlowReturn gst_mythtv_src_chain (GstPad * pad, GstBuffer * buf);

    99 static void gst_mythtv_src_uri_handler_init (gpointer g_iface, gpointer iface_data);

   101 static gboolean gst_mythtv_src_handle_event (GstPad * pad, GstEvent * event);

   102 //static gboolean gst_mythtv_src_query ( GstPad * pad, GstQuery * query );

   104 static gint do_read_request_response (GstMythtvSrc *src, guint64 offset,

   105 		guint size, GstBuffer **outbuf);

   106 //static gboolean gst_mythtv_src_sink_activate_pull (GstPad * srcpad, gboolean active);

   108   static void

   109 _urihandler_init (GType type)

   110 {

   111   static const GInterfaceInfo urihandler_info = {

   112     gst_mythtv_src_uri_handler_init,

   113     NULL,

   114     NULL

   115   };

   117   g_type_add_interface_static (type, GST_TYPE_URI_HANDLER, &urihandler_info);

   119   GST_DEBUG_CATEGORY_INIT (mythtvsrc_debug, "mythtvsrc", 0,

   120       "MythTV src");

   121 }

   123 GST_BOILERPLATE_FULL (GstMythtvSrc, gst_mythtv_src, GstBaseSrc,

   124     GST_TYPE_BASE_SRC, _urihandler_init)

   126 //GST_BOILERPLATE_FULL (GstMythtvSrc, gst_mythtv_src, GstPushSrc,

   127 //    GST_TYPE_PUSH_SRC, _urihandler_init)

   129   static void

   130 gst_mythtv_src_base_init (gpointer g_class)

   131 {

   132   GstElementClass *element_class = GST_ELEMENT_CLASS (g_class);

   134   gst_element_class_add_pad_template (element_class,

   135       gst_static_pad_template_get (&srctemplate));

   137   gst_element_class_set_details (element_class, &gst_mythtv_src_details);

   138 }

   140 static void

   141 gst_mythtv_src_class_init (GstMythtvSrcClass * klass)

   142 {

   143   GObjectClass *gobject_class;

   144   //GstPushSrcClass *gstpushsrc_class;

   145   GstBaseSrcClass *gstbasesrc_class;

   147   gobject_class = (GObjectClass *) klass;

   148   gstbasesrc_class = (GstBaseSrcClass *) klass;

   149   //gstpushsrc_class = (GstPushSrcClass *) klass;

   151   gobject_class->set_property = gst_mythtv_src_set_property;

   152   gobject_class->get_property = gst_mythtv_src_get_property;

   153   gobject_class->finalize = gst_mythtv_src_finalize;

   155   g_object_class_install_property

   156     (gobject_class, PROP_LOCATION,

   157      g_param_spec_string ("location", "Location",

   158        "The location. In the form:"

   159        "\n\t\t\tmyth://a.com/file.nuv"

   160        "\n\t\t\tmyth://a.com:23223/file.nuv "

   161        "\n\t\t\ta.com/file.nuv - default scheme 'myth'",

   162        "", G_PARAM_READWRITE));

   164   g_object_class_install_property

   165     (gobject_class, PROP_URI,

   166      g_param_spec_string ("uri", "Uri",

   167        "The location in form of a URI (deprecated; use location)",

   168        "", G_PARAM_READWRITE));

   170   g_object_class_install_property

   171     (gobject_class, PROP_MYTHTV_VERSION,

   172      g_param_spec_int ("mythtv-version", "mythtv-version",

   173        "Change Myth TV version",

   174        26, 30, 26, G_PARAM_READWRITE));

   176   g_object_class_install_property

   177     (gobject_class, PROP_MYTHTV_LIVEID,

   178      g_param_spec_int ("mythtv-live-id", "mythtv-live-id",

   179        "Change Myth TV version",

   180        0, 200, GST_MYTHTV_ID_NUM, G_PARAM_READWRITE));

   182   g_object_class_install_property

   183     (gobject_class, PROP_MYTHTV_LIVE_CHAINID,

   184      g_param_spec_string ("mythtv-live-chainid", "mythtv-live-chainid",

   185        "Sets the Myth TV chain ID (from TV Chain)",

   186        "", G_PARAM_READWRITE));

   188   g_object_class_install_property

   189     (gobject_class, PROP_MYTHTV_LIVE,

   190      g_param_spec_boolean ("mythtv-live", "mythtv-live",

   191        "Enable MythTV Live TV content streaming",

   192        FALSE, G_PARAM_READWRITE));

   194 #ifndef GST_DISABLE_GST_DEBUG

   195   g_object_class_install_property

   196     (gobject_class, PROP_MYTHTV_DBG,

   197      g_param_spec_boolean ("mythtv-debug", "mythtv-debug",

   198        "Enable MythTV debug messages",

   199        FALSE, G_PARAM_READWRITE));

   200 #endif

   202   gstbasesrc_class->start = gst_mythtv_src_start;

   203   gstbasesrc_class->stop = gst_mythtv_src_stop;

   204   gstbasesrc_class->get_size = gst_mythtv_src_get_size;

   205   gstbasesrc_class->is_seekable = gst_mythtv_src_is_seekable;

   206   //gstpushsrc_class->newsegment = gst_mythtv_src_new_segment;

   208   gstbasesrc_class->create = gst_mythtv_src_create;

   210   GST_DEBUG_CATEGORY_INIT (mythtvsrc_debug, "mythtvsrc", 0,

   211       "MythTV Client Source");

   212 }

   214 static void

   215 gst_mythtv_src_init (GstMythtvSrc * this, GstMythtvSrcClass * g_class)

   216 {

   217   this->file_transfer = NULL;

   219   this->unique_setup = FALSE;

   221   this->mythtv_version = MYTHTV_VERSION_DEFAULT;

   223   this->bytes_read = 0;

   225   this->content_size = -1;

   226   this->read_offset = 0;

   228   this->live_tv = FALSE;

   230   this->user_agent = g_strdup ("mythtvsrc");

   231   this->mythtv_caps = NULL;

   233   gst_base_src_set_format( GST_BASE_SRC( this ), GST_FORMAT_BYTES );

   235   gst_base_src_set_live ( GST_BASE_SRC( this ), TRUE );

   237   //gst_pad_set_chain_function ( GST_BASE_SRC_PAD(GST_BASE_SRC(this)),

   238   //    gst_mythtv_src_chain );

   240   gst_pad_set_event_function ( GST_BASE_SRC_PAD(GST_BASE_SRC(this)),

   241       gst_mythtv_src_handle_event );

   242 /*

   243   gst_pad_set_query_function ( GST_BASE_SRC_PAD(GST_BASE_SRC(this)),

   244       gst_mythtv_src_query );

   245 */

   246   //gst_pad_set_activatepull_function( GST_BASE_SRC_PAD(GST_BASE_SRC(this)),

   247   //    gst_mythtv_src_sink_activate_pull );

   249 }

   251 static void

   252 gst_mythtv_src_finalize (GObject * gobject)

   253 {

   254   GstMythtvSrc *this = GST_MYTHTV_SRC (gobject);

   256   g_free (this->user_agent);

   258   if (this->mythtv_caps) {

   259     gst_caps_unref (this->mythtv_caps);

   260     this->mythtv_caps = NULL;

   261   }

   263   if (this->file_transfer) {

   264     g_object_unref (this->file_transfer);

   265     this->file_transfer = NULL;

   266   }

   268   if (this->uri_name) {

   269     g_free (this->uri_name);

   270   }

   272   if (this->user_agent) {

   273     g_free (this->user_agent);

   274   }

   276   G_OBJECT_CLASS (parent_class)->finalize (gobject);

   277 }

   279 static gint

   280 do_read_request_response (GstMythtvSrc * src, guint64 offset, guint size, GstBuffer **outbuf)

   281 {

   282   gint read = 0;

   283   guint sizetoread = size; //GST_BUFFER_SIZE (outbuf);

   284   //GstBuffer *buffer = gst_buffer_new_and_alloc( size );

   286   g_print( "Starting: [%s] Reading %d bytes...\n", __FUNCTION__, sizetoread );

   288   /* Loop sending the Myth File Transfer request:

   289    * Retry whilst authentication fails and we supply it. */

   290   gint len = 0;

   292   GST_OBJECT_LOCK(src);

   294   while ( sizetoread > 0 ) {

   296   	len = myth_file_transfer_read( src->file_transfer,

   297 			GST_BUFFER_DATA( *outbuf ) + read, sizetoread, TRUE );

   299     if ( len > 0 ) {

   300       read += len;

   301       sizetoread -= len;

   302     } else if ( len <= 0 ) {

   304       if ( src->live_tv == FALSE ) {

   305 		goto done;

   306       } else if ( /*src->content_size >= src->read_offset &&

   307       			abs ( src->content_size - src->read_offset ) <= 1024 ) ||*/

   308       			( src->content_size <= ( src->read_offset + size + MYTHTV_TRANSFER_MAX_BUFFER ) ) )

   309   {

   310 #if ENABLE_TIMING_POSITION == 1

   311     guint64 size_tmp = 0;

   312     if (src->live_tv == TRUE) {

   313 get_file_pos:

   314       size_tmp = myth_file_transfer_get_file_position( src->file_transfer );

   315       if ( size_tmp > ( src->content_size + MYTHTV_TRANSFER_MAX_BUFFER ) )

   316 	src->content_size = size_tmp;

   317       else

   318 	goto get_file_pos;

   319       g_print( "\t[%s]\tGET_POSITION: file_position = %llu\n",

   320 	  __FUNCTION__, size_tmp );

   321     }

   322 #else

   323   	guint64 new_offset = myth_file_transfer_get_file_position( src->file_transfer );

   324   	if ( src->content_size < new_offset ) {

   325   	  src->content_size = new_offset;

   326   	}

   327 #endif

   328 	goto done;

   329   }

   331     }

   333     if ( read == sizetoread )

   334       break;

   335   }

   337   if ( read > 0 ) {

   338   	src->read_offset += read;

   339     src->bytes_read += read;

   341   g_print( "[%s]\tBYTES READ (actual) = %d, BYTES READ (cumulative) = %llu, "\

   342       "OFFSET = %llu, CONTENT SIZE = %llu.\n", __FUNCTION__, read, src->bytes_read,

   343       src->read_offset, src->content_size );

   345   //GST_BUFFER_TIMESTAMP( buffer ) = GST_BUFFER_TIMESTAMP ( *outbuf );

   346   GST_BUFFER_SIZE (*outbuf) = read; //GST_BUFFER_SIZE (buffer) = read;

   347   GST_BUFFER_OFFSET (*outbuf) = offset; //GST_BUFFER_OFFSET (buffer) = offset;

   348   GST_BUFFER_OFFSET_END (*outbuf) = offset + read;//GST_BUFFER_OFFSET_END (buffer) = offset + read;

   349   //memcpy( GST_BUFFER_DATA( *outbuf ), GST_BUFFER_DATA( buffer ), read );

   351   g_print( "Stopping: [%s]\t\tBUFFER --->SIZE = %d, OFFSET = %llu, "\

   352       "OFFSET_END = %llu.\n\n", __FUNCTION__, GST_BUFFER_SIZE (*outbuf),

   353       GST_BUFFER_OFFSET (*outbuf), GST_BUFFER_OFFSET_END (*outbuf) );

   355   } else if ( !src->live_tv )

   356   	goto eos;

   358   goto done;

   360 eos:

   361   src->eos = TRUE;

   363 done:

   364   GST_OBJECT_UNLOCK(src);

   366   return read;

   367 }

   369 static GstFlowReturn

   370 gst_mythtv_src_create ( GstBaseSrc * psrc, guint64 offset, guint size, GstBuffer **outbuf)

   371 {

   372   GstMythtvSrc *src;

   373   GstFlowReturn ret = GST_FLOW_OK;

   374   gint read = -1;

   376   src = GST_MYTHTV_SRC (psrc);

   377   /* The caller should know the number of bytes and not read beyond EOS. */

   378   if (G_UNLIKELY (src->eos))

   379     goto eos;

   381   //GST_OBJECT_LOCK(src);

   383   if (G_UNLIKELY (src->read_offset != offset)) {

   384     guint64 new_offset = myth_file_transfer_seek(src->file_transfer, offset, SEEK_SET);

   385     g_print( "[%s] SRC Offset = %llu, NEW actual backend SEEK Offset = %llu.\n",

   386     	__FUNCTION__, src->read_offset, new_offset );

   387     if (G_UNLIKELY (new_offset < 0 ) )//|| new_offset != src->read_offset)) {

   388     {

   389       //GST_OBJECT_UNLOCK(src);

   390       goto seek_failed;

   391     }

   393     src->read_offset = offset;

   394   }

   395   //GST_OBJECT_UNLOCK(src);

   397   /* Create the buffer. */

   398   ret = gst_pad_alloc_buffer (GST_BASE_SRC_PAD (GST_BASE_SRC (psrc)),

   399       src->read_offset, size,

   400       //src->icy_caps ? src->icy_caps :

   401       GST_PAD_CAPS (GST_BASE_SRC_PAD (GST_BASE_SRC (psrc))), outbuf);

   403   if (G_UNLIKELY (ret != GST_FLOW_OK))

   404     goto done;

   406   //g_static_mutex_lock( &update_size_mutex );

   407   read = do_read_request_response ( src, src->read_offset, size, outbuf );

   408   //g_static_mutex_unlock( &update_size_mutex );

   410   if (G_UNLIKELY (read < 0) || *outbuf == NULL) {

   411   	//if ( src->live_tv )

   412     //	goto done;

   413     //else

   414     goto read_error;

   415   }

   417 /*

   418   if (G_UNLIKELY(src->eos))

   419     goto eos;

   420   else

   421     goto done;

   422 */

   424 done:

   425  {

   426     const gchar *reason = gst_flow_get_name (ret);

   428     GST_DEBUG_OBJECT (src, "DONE task, reason %s", reason);

   429   	return ret;

   430  }

   431 eos:

   432   {

   433     const gchar *reason = gst_flow_get_name (ret);

   435     GST_DEBUG_OBJECT (src, "pausing task, reason %s", reason);

   436     return GST_FLOW_UNEXPECTED;

   437   }

   438   /* ERRORS */

   439 read_error:

   440   {

   441     GST_ELEMENT_ERROR (src, RESOURCE, READ,

   442 	(NULL), ("Could not read any bytes (%i, %s)", read,

   443 	  src->uri_name));

   444     return GST_FLOW_ERROR;

   445   }

   446 seek_failed:

   447   {

   448     GST_ELEMENT_ERROR (src, RESOURCE, READ,

   449 	(NULL), ("Seek failed, go to the next program info... (%i, %s)", read,

   450 	  src->uri_name));

   451 	// go to the next program chain

   452 	src->unique_setup = FALSE;

   453 	gst_mythtv_src_start( psrc );

   455     return GST_FLOW_OK;

   456   }

   458 }

   460 void

   461 update_size_func( void *mythtv_data )

   462 {

   463   GstMythtvSrc *src;

   465   g_return_if_fail( mythtv_data != NULL );

   467   src = GST_MYTHTV_SRC ( mythtv_data );

   469   g_static_mutex_lock( &update_size_mutex );

   471   if ( src->do_start ) {

   472 #if ENABLE_TIMING_POSITION == 1

   473     guint64 size_tmp = 0;

   474     if (src->live_tv == TRUE) {

   475 get_file_pos:

   476       g_usleep( 50 );

   477       size_tmp = myth_file_transfer_get_file_position( src->file_transfer );

   478       if ( size_tmp > ( src->content_size + MYTHTV_TRANSFER_MAX_BUFFER ) )

   479 	src->content_size = size_tmp;

   480       else

   481 	goto get_file_pos;

   482       g_print( "\t[%s]\tGET_POSITION: file_position = %llu\n",

   483 	  __FUNCTION__, size_tmp );

   484     }

   485 #endif

   486   }

   487   g_static_mutex_unlock( &update_size_mutex );

   489 }

   491 guint64

   492 gst_mythtv_src_get_position ( GstMythtvSrc* src )

   493 {

   495   if ( src->do_start ) {

   496 #if ENABLE_TIMING_POSITION == 1

   497     guint64 size_tmp = 0;

   498     if (src->live_tv == TRUE) {

   499 get_file_pos:

   500       g_usleep( 50 );

   501       size_tmp = myth_file_transfer_get_file_position( src->file_transfer );

   502       if ( size_tmp > ( src->content_size + MYTHTV_TRANSFER_MAX_BUFFER ) )

   503 		src->content_size = size_tmp;

   504       else

   505 	goto get_file_pos;

   506       g_print( "\t[%s]\tGET_POSITION: file_position = %llu\n",

   507 	  __FUNCTION__, size_tmp );

   508     }

   509 #endif

   510   }

   512   return src->content_size;

   514 }

   516 /* create a socket for connecting to remote server */

   517 static gboolean

   518 gst_mythtv_src_start ( GstBaseSrc * bsrc )

   519 {

   520   GstMythtvSrc *src = GST_MYTHTV_SRC (bsrc);

   522   GString *chain_id_local = NULL;

   524   gboolean ret = TRUE;

   526   if (src->unique_setup == FALSE) {

   527     src->unique_setup = TRUE;

   528   } else {

   529     goto done;

   530   }

   532   GST_OBJECT_LOCK(src);

   534   if ( src->live_tv ) {

   535     src->spawn_livetv = myth_livetv_new( );

   536     if ( myth_livetv_setup( src->spawn_livetv ) == FALSE ) {

   537       ret = FALSE;

   538       goto init_failed;

   539     }

   540     /* set up the uri variable */

   541     src->uri_name = g_strdup( src->spawn_livetv->proginfo->pathname->str );

   542     chain_id_local = gmyth_tvchain_get_id( src->spawn_livetv->tvchain );

   543     if ( chain_id_local != NULL ) {

   544       src->live_chain_id = g_strdup( chain_id_local->str );

   545       g_print( "\t[%s]\tLocal chain ID = %s.\n", __FUNCTION__, src->live_chain_id );

   546     }

   547     src->live_tv_id = src->spawn_livetv->remote_encoder->recorder_num;

   548     g_print ( "[%s] LiveTV id = %d, URI path = %s.\n", __FUNCTION__, src->live_tv_id, src->uri_name );

   549   }

   551   src->file_transfer = myth_file_transfer_new( src->live_tv_id,

   552       g_string_new( src->uri_name ), -1, src->mythtv_version );

   554   if ( src->file_transfer == NULL ) {

   555     GST_OBJECT_UNLOCK(src);

   557     goto init_failed;

   558   }

   560   /* sets the Playback monitor connection */

   561   ret = myth_file_transfer_playback_setup( &(src->file_transfer), src->live_tv );

   563   if ( src->live_tv == TRUE && ret == TRUE ) {

   564     /* loop finished, set the max tries variable to zero again... */

   565     wait_to_transfer = 0;

   567     while ( wait_to_transfer++ < MYTHTV_TRANSFER_MAX_WAITS && ( myth_file_transfer_is_recording( src->file_transfer ) == FALSE

   568 	  /*|| ( myth_file_transfer_get_file_position( src->file_transfer ) < ( src->content_size + 327680 ) )*/ ) )

   569       g_usleep( 100 );

   570   }

   572   /* sets the FileTransfer instance connection (video/audio download) */

   573   ret = myth_file_transfer_setup( &(src->file_transfer), src->live_tv );

   575   if ( ret == FALSE ) {

   576     GST_OBJECT_UNLOCK(src);

   577 #ifndef GST_DISABLE_GST_DEBUG

   578     if ( src->mythtv_msgs_dbg )

   579       g_printerr( "MythTV FileTransfer request failed when setting up socket connection!\n" );

   580 #endif

   581     goto begin_req_failed;

   582   }

   584   src->content_size = src->file_transfer->filesize;

   586   GST_OBJECT_UNLOCK(src);

   587   if ( src->live_tv ) {

   589     //GError* error;

   590     //update_size_task = g_thread_create( (GThreadFunc)update_size_func, src, FALSE, &error );

   591     g_print( "[%s] Update Size task = %s\n", __FUNCTION__, update_size_task != NULL ?  "OK !" : "ERROR!!!" );

   593   }

   594   src->do_start = TRUE;

   596 done:

   597   return TRUE;

   599   /* ERRORS */

   600 init_failed:

   601   {

   602     if (src->spawn_livetv != NULL )

   603       g_object_unref( src->spawn_livetv );

   605     GST_ELEMENT_ERROR (src, LIBRARY, INIT,

   606 	(NULL), ("Could not initialize MythTV library (%i, %s)", ret, src->uri_name));

   607     return FALSE;

   608   }

   609 begin_req_failed:

   610   {

   611     GST_ELEMENT_ERROR (src, LIBRARY, INIT,

   612 	(NULL), ("Could not begin request sent to MythTV server (%i, %s)", ret, src->uri_name));

   613     return FALSE;

   614   }

   615 }

   617 #if 0

   618 /* handles queries for location in the stream in the requested format */

   619 static gboolean

   620 gst_mythtv_src_query ( GstPad * pad, GstQuery * query )

   621 {

   622   gboolean res = TRUE;

   623   GstMythtvSrc *mythtv;

   625   guint64 size = 0;

   627   mythtv = GST_MYTHTV_SRC( GST_PAD_PARENT (pad) );

   629   size = gst_mythtv_src_get_position (mythtv);

   631   switch (GST_QUERY_TYPE (query)) {

   633     case GST_QUERY_POSITION:

   634       {

   636 	//GstFormat format;

   637 	gint64 cur = 0;

   639 	/* save requested format */

   640 	gst_query_parse_position (query, NULL, &cur);

   642 	/* query peer for current position in time */

   643 	g_print( "[%s] Actual size is %s than current size from sink. [ %lld, %lld ]\n", __FUNCTION__,

   644 	    ( size > cur ) ? "greater" : "lower", size, cur );

   645 	gst_query_set_position (query, GST_FORMAT_BYTES, size);

   646 	if ( size < cur )

   647 	  goto error;

   649 	break;

   650       }

   651      #if 0

   652     case GST_QUERY_DURATION:

   653       {

   654 	//GstFormat format;

   655 	gint64 cur = 0;

   657 	/* save requested format */

   658 	gst_query_parse_position (query, NULL, &cur);

   660 	/* query peer for current position in time */

   661 	g_print( "[%s] Actual size is %s than current size from sink. [ %lld, %lld ]\n", __FUNCTION__,

   662 	    ( size * GST_SECOND > cur * GST_SECOND ) ? "greater" : "lower", size * GST_SECOND,

   663 	    cur * GST_SECOND );

   664 	gst_query_set_position (query, GST_FORMAT_TIME, size * GST_SECOND );

   666 	if ( size * GST_SECOND < cur * GST_SECOND )

   667 	  goto error;

   669 	break;

   670       }

   671 	#endif

   672     default:

   673       res = FALSE;

   674       break;

   675   }

   677   return res;

   679 error:

   681   return FALSE;

   682 }

   683 #endif

   685 static gboolean

   686 gst_mythtv_src_get_size (GstBaseSrc * bsrc, guint64 * size)

   687 {

   688   GstMythtvSrc *src = GST_MYTHTV_SRC (bsrc);

   689   gboolean ret = TRUE;

   691   if (src->content_size <= 0) {

   692     ret= FALSE;

   693   } else if ( abs ( src->content_size - src->read_offset ) <= MYTHTV_TRANSFER_MAX_BUFFER ) {

   694     //g_static_mutex_lock( &update_size_mutex );

   695     GST_OBJECT_LOCK(src);

   697   	guint64 new_offset = myth_file_transfer_get_file_position( src->file_transfer );

   698   	if ( src->content_size < new_offset ) {

   699   	  src->content_size = new_offset;

   700   	}

   702 #if ENABLE_TIMING_POSITION == 1

   703     guint64 size_tmp = 0;

   704     if (src->live_tv == TRUE) {

   705 get_file_pos:

   706       g_usleep( 5 );

   707       size_tmp = myth_file_transfer_get_file_position( src->file_transfer );

   708       if ( size_tmp > ( src->content_size + MYTHTV_TRANSFER_MAX_BUFFER ) )

   709 	src->content_size = size_tmp;

   710       else

   711 	goto get_file_pos;

   712       g_print( "\t[%s]\tGET_POSITION: file_position = %llu\n",

   713 	  __FUNCTION__, size_tmp );

   714     }

   715 #endif

   716 	GST_OBJECT_UNLOCK(src);

   717     //g_static_mutex_unlock( &update_size_mutex );

   719   }

   721   *size = src->content_size;

   722   g_print( "[%s] Content size = %llu\n", __FUNCTION__, src->content_size );

   724   return ret;

   726 }

   728 /* close the socket and associated resources

   729  * used both to recover from errors and go to NULL state */

   730   static gboolean

   731 gst_mythtv_src_stop (GstBaseSrc * bsrc)

   732 {

   733   GstMythtvSrc *src;

   735   src = GST_MYTHTV_SRC (bsrc);

   737   if (src->uri_name) {

   738     g_free (src->uri_name);

   739     src->uri_name = NULL;

   740   }

   742   if (src->mythtv_caps) {

   743     gst_caps_unref (src->mythtv_caps);

   744     src->mythtv_caps = NULL;

   745   }

   747   src->eos = FALSE;

   749   return TRUE;

   750 }

   752 static gboolean

   753 gst_mythtv_src_handle_event (GstPad * pad, GstEvent * event)

   754 {

   755   GstMythtvSrc *src = GST_MYTHTV_SRC (GST_PAD_PARENT (pad));

   757   switch (GST_EVENT_TYPE (event)) {

   758 #if 0

   759     case GST_EVENT_FLUSH_START:

   760       src->eos = FALSE;

   761       break;

   762       //return TRUE;

   763     case GST_EVENT_FLUSH_STOP:

   764       src->do_start = TRUE;

   765       src->eos = FALSE;

   766       gst_element_set_state (GST_ELEMENT(src), GST_STATE_NULL);

   767       //gst_element_set_locked_state (GST_ELEMENT(src), TRUE);

   768       break;

   769 #endif

   770     case GST_EVENT_EOS:

   771       g_print( "[%s] Got EOS event!!!\n", __FUNCTION__ );

   772 	  guint64 cont_size = gst_mythtv_src_get_position (src);

   773 	  if ( !src->live_tv ) {

   774 		  if ( cont_size > src->content_size ) {

   775 		  	src->content_size = cont_size;

   776 		  	src->eos = FALSE;

   777 	  	  } else {

   778 	      	src->eos = TRUE;

   779 	      	gst_element_set_state ( GST_ELEMENT (src), GST_STATE_NULL );

   780 	      	gst_element_set_locked_state ( GST_ELEMENT (src), FALSE );

   781 	  	  }

   782 	  } else

   783 	  	src->eos = TRUE;

   784       break;

   785 #if 0

   786     case GST_EVENT_NEWSEGMENT:

   787       g_print( "[%s] Got NEWSEGMENT!!!\n", __FUNCTION__ );

   788       src->eos = FALSE;

   789       break;

   790     case GST_EVENT_SEEK:

   791       {

   792 	g_print( "[%s] Got EVENT_SEEK!!!\n", __FUNCTION__ );

   793 	gdouble rate;

   794 	//gboolean update = TRUE;

   795 	GstFormat format;

   796 	GstSeekType cur_type, stop_type;

   797 	GstSeekFlags flags;

   798 	gint64 cur = 0, stop = 0;

   799 	gst_event_parse_seek ( event, &rate, &format,

   800 	    &flags, &cur_type, &cur,

   801 	    &stop_type, &stop );

   803 	g_print( "[%s] Got EVENT_SEEK.\n", __FUNCTION__ );

   804 	if ( !( flags & GST_SEEK_FLAG_FLUSH ) ) {

   805 	  g_print( "[%s] Could get the FLAG_FLUSH message.\n", __FUNCTION__ );

   806 	}

   807 	//gboolean ret = gst_event_parse_new_segment ( event,

   808 	//    &update, &rate, &format, &start, &stop,

   809 	//    &position );

   810 	//GstFlowReturn flow_ret = gst_mythtv_src_create (GST_BASE_SRC( GST_PAD_PARENT( psrc ) ),

   811 	//			cur, stop - cur + 1, GstBuffer)

   812       }

   813 #endif

   814     default:

   815       return gst_pad_event_default (pad, event);

   816   }

   818   return gst_pad_event_default (pad, event);

   819 }

   821 static gboolean

   822 gst_mythtv_src_is_seekable( GstBaseSrc *push_src )

   823 {

   824   return TRUE;

   825 }

   827 static void

   828 gst_mythtv_src_set_property (GObject * object, guint prop_id,

   829     const GValue * value, GParamSpec * pspec)

   830 {

   831   GstMythtvSrc *mythtvsrc = GST_MYTHTV_SRC (object);

   833   GST_OBJECT_LOCK (mythtvsrc);

   834   switch (prop_id) {

   835     case PROP_URI:

   836     case PROP_LOCATION:

   837       {

   838 	if (!g_value_get_string (value)) {

   839 	  GST_WARNING ("location property cannot be NULL");

   840 	  goto done;

   841 	}

   843 	if (mythtvsrc->uri_name != NULL) {

   844 	  g_free (mythtvsrc->uri_name);

   845 	  mythtvsrc->uri_name = NULL;

   846 	}

   847 	mythtvsrc->uri_name = g_value_dup_string (value);

   849 	break;

   850       }

   851 #ifndef GST_DISABLE_GST_DEBUG

   852     case PROP_MYTHTV_DBG:

   853       {

   854 	mythtvsrc->mythtv_msgs_dbg = g_value_get_boolean (value);

   855 	break;

   856       }

   857 #endif

   858     case PROP_MYTHTV_VERSION:

   859       {

   860 	mythtvsrc->mythtv_version = g_value_get_int (value);

   861 	break;

   862       }

   863     case PROP_MYTHTV_LIVEID:

   864       {

   865 	mythtvsrc->live_tv_id = g_value_get_int (value);

   866 	break;

   867       }

   868     case PROP_MYTHTV_LIVE:

   869       {

   870 	mythtvsrc->live_tv = g_value_get_boolean (value);

   871 	break;

   872       }

   873     case PROP_MYTHTV_LIVE_CHAINID:

   874       {

   875 	if (!g_value_get_string (value)) {

   876 	  GST_WARNING ("MythTV Live chainid property cannot be NULL");

   877 	  goto done;

   878 	}

   880 	if (mythtvsrc->live_chain_id != NULL) {

   881 	  g_free (mythtvsrc->live_chain_id);

   882 	  mythtvsrc->live_chain_id = NULL;

   883 	}

   884 	mythtvsrc->live_chain_id = g_value_dup_string (value);

   886 	break;

   887       }

   889     default:

   890       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);

   891       break;

   892   }

   893   GST_OBJECT_UNLOCK (mythtvsrc);

   894 done:

   895   return;

   896 }

   898   static void

   899 gst_mythtv_src_get_property (GObject * object, guint prop_id,

   900     GValue * value, GParamSpec * pspec)

   901 {

   902   GstMythtvSrc *mythtvsrc = GST_MYTHTV_SRC (object);

   904   GST_OBJECT_LOCK (mythtvsrc);

   905   switch (prop_id) {

   906     case PROP_URI:

   907     case PROP_LOCATION:

   908       {

   909 	gchar *str = g_strdup( "" );

   911 	if ( mythtvsrc->uri_name == NULL ) {

   912 	  g_free (mythtvsrc->uri_name);

   913 	  mythtvsrc->uri_name = NULL;

   914 	} else {

   915 	  str = g_strdup( mythtvsrc->uri_name );

   916 	}

   917 	g_value_set_string ( value, str );

   918 	break;

   919       }

   920 #ifndef GST_DISABLE_GST_DEBUG

   921     case PROP_MYTHTV_DBG:

   922       g_value_set_boolean ( value, mythtvsrc->mythtv_msgs_dbg );

   923       break;

   924 #endif

   925     case PROP_MYTHTV_VERSION:

   926       {

   927 	g_value_set_int ( value, mythtvsrc->mythtv_version );

   928 	break;

   929       }

   930     case PROP_MYTHTV_LIVEID:

   931       {

   932 	g_value_set_int ( value, mythtvsrc->live_tv_id );

   933 	break;

   934       }

   935     case PROP_MYTHTV_LIVE:

   936       g_value_set_boolean ( value, mythtvsrc->live_tv );

   937       break;

   938     case PROP_MYTHTV_LIVE_CHAINID:

   939       {

   940 	gchar *str = g_strdup( "" );

   942 	if ( mythtvsrc->live_chain_id == NULL ) {

   943 	  g_free (mythtvsrc->live_chain_id);

   944 	  mythtvsrc->live_chain_id = NULL;

   945 	} else {

   946 	  str = g_strdup( mythtvsrc->live_chain_id );

   947 	}

   948 	g_value_set_string ( value, str );

   949 	break;

   950       }

   951     default:

   952       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);

   953       break;

   954   }

   955   GST_OBJECT_UNLOCK (mythtvsrc);

   956 }

   958 /* entry point to initialize the plug-in

   959  * initialize the plug-in itself

   960  * register the element factories and pad templates

   961  * register the features

   962  */

   963   static gboolean

   964 plugin_init (GstPlugin * plugin)

   965 {

   966   return gst_element_register (plugin, "mythtvsrc", GST_RANK_NONE,

   967       GST_TYPE_MYTHTV_SRC);

   968 }

   970 /* this is the structure that gst-register looks for

   971  * so keep the name plugin_desc, or you cannot get your plug-in registered */

   972 GST_PLUGIN_DEFINE (GST_VERSION_MAJOR,

   973     GST_VERSION_MINOR,

   974     "mythtv",

   975     "lib MythTV src",

   976     plugin_init, VERSION, "LGPL", "GStreamer", "http://gstreamer.net/")

   979 /*** GSTURIHANDLER INTERFACE *************************************************/

   980   static guint

   981 gst_mythtv_src_uri_get_type (void)

   982 {

   983   return GST_URI_SRC;

   984 }

   986   static gchar **

   987 gst_mythtv_src_uri_get_protocols (void)

   988 {

   989   static gchar *protocols[] = { "myth", "myths", NULL };

   991   return protocols;

   992 }

   994   static const gchar *

   995 gst_mythtv_src_uri_get_uri (GstURIHandler * handler)

   996 {

   997   GstMythtvSrc *src = GST_MYTHTV_SRC (handler);

   999   return src->uri_name;

  1000 }

  1002   static gboolean

  1003 gst_mythtv_src_uri_set_uri (GstURIHandler * handler, const gchar * uri)

  1004 {

  1005   GstMythtvSrc *src = GST_MYTHTV_SRC (handler);

  1007   gchar *protocol;

  1009   protocol = gst_uri_get_protocol (uri);

  1010   if ((strcmp (protocol, "myth") != 0) && (strcmp (protocol, "myths") != 0)) {

  1011     g_free (protocol);

  1012     return FALSE;

  1013   }

  1014   g_free (protocol);

  1015   g_object_set (src, "location", uri, NULL);

  1017   return TRUE;

  1018 }

  1020   static void

  1021 gst_mythtv_src_uri_handler_init (gpointer g_iface, gpointer iface_data)

  1022 {

  1023   GstURIHandlerInterface *iface = (GstURIHandlerInterface *) g_iface;

  1025   iface->get_type = gst_mythtv_src_uri_get_type;

  1026   iface->get_protocols = gst_mythtv_src_uri_get_protocols;

  1027   iface->get_uri = gst_mythtv_src_uri_get_uri;

  1028   iface->set_uri = gst_mythtv_src_uri_set_uri;

  1029 }

  1031   void

  1032 size_header_handler (void *userdata, const char *value)

  1033 {

  1034   GstMythtvSrc *src = GST_MYTHTV_SRC (userdata);

  1036   //src->content_size = g_ascii_strtoull (value, NULL, 10);

  1038   GST_DEBUG_OBJECT (src, "content size = %lld bytes", src->content_size);

  1039 }

author	melunko
	Mon Oct 23 14:41:30 2006 +0100 (2006-10-23)
branch	trunk
changeset 38	d5f5855e7800
parent 34	c71d37b93734
child 40	ba5dc9bff3a1
permissions	-rwxr-xr-x