rne-player.cpp

/*
 * If not stated otherwise in this file or this component's Licenses.txt file the
 * following copyright and licenses apply:
 *
 * Copyright 2016 RDK Management
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
 
#ifdef ENABLE_BREAKPAD
#include "client/linux/handler/exception_handler.h"
#endif
 
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <signal.h>
#include <gst/gst.h>
 
#include "wayland-client.h"
 
#define UNUSED( x ) ((void)(x))
 
typedef struct _AppCtx
{
   struct wl_display *display;
   struct wl_registry *registry;
   struct wl_output *output;
   GstElement *pipeline;
   GstElement *player;
   GstElement *westerossink;
   GstBus *bus;
   GMainLoop *loop;
} AppCtx;
#ifdef ENABLE_BREAKPAD
static bool breakpadDumpCallback(const google_breakpad::MinidumpDescriptor& descriptor,
                                                               void* context,
                                                               bool succeeded)
{
       printf("\nbreakpadDumpCallback: application  crashed ---- Dump path: %s\n",descriptor.path());
       return succeeded;
}
 
#endif
 
 
static void showUsage()
{
   printf("usage:\n");
   printf(" rne_player [options] <uri>\n" );
   printf("  uri - URI of video asset to play\n" );
   printf("where [options] are:\n" );
   printf("  -? : show usage\n" );
   printf("\n" );   
}
 
static void outputHandleGeometry( void *data, 
                                  struct wl_output *output,
                                  int x,
                                  int y,
                                  int mmWidth,
                                  int mmHeight,
                                  int subPixel,
                                  const char *make,
                                  const char *model,
                                  int transform )
{
   UNUSED(data);
   UNUSED(output);
   UNUSED(x);
   UNUSED(y);
   UNUSED(mmWidth);
   UNUSED(mmHeight);
   UNUSED(subPixel);
   UNUSED(make);
   UNUSED(model);
   UNUSED(transform);
}
 
static void outputHandleMode( void *data,
                              struct wl_output *output,
                              uint32_t flags,
                              int width,
                              int height,
                              int refreshRate )
{
   AppCtx *ctx= (AppCtx*)data;
   char work[32];
   
   if ( flags & WL_OUTPUT_MODE_CURRENT )
   {
      printf("outputMode: %dx%d flags %X\n", width, height, flags);
   
      if ( ctx->westerossink )
      {
         sprintf( work, "%d,%d,%d,%d", 0, 0, width, height );
         g_object_set(G_OBJECT(ctx->westerossink), "window-set", work, NULL );      
      }
   }
}
 
static void outputHandleDone( void *data,
                              struct wl_output *output )
{
   UNUSED(data);
   UNUSED(output);
}
 
static void outputHandleScale( void *data,
                               struct wl_output *output,
                               int32_t scale )
{
   UNUSED(data);
   UNUSED(output);
   UNUSED(scale);
}
 
static const struct wl_output_listener outputListener = {
   outputHandleGeometry,
   outputHandleMode,
   outputHandleDone,
   outputHandleScale
};
 
static void registryHandleGlobal(void *data, 
                                 struct wl_registry *registry, uint32_t id,
                                           const char *interface, uint32_t version)
{
   AppCtx *ctx= (AppCtx*)data;
   int len;
  
   len= strlen(interface);
   if ( (len==9) && !strncmp(interface, "wl_output", len) ) {
      ctx->output= (struct wl_output*)wl_registry_bind(registry, id, &wl_output_interface, 2);
                wl_output_add_listener(ctx->output, &outputListener, ctx);
                wl_display_roundtrip( ctx->display );
   } 
}
 
static void registryHandleGlobalRemove(void *data, 
                                       struct wl_registry *registry,
                                                      uint32_t name)
{
   UNUSED(data);
   UNUSED(registry);
   UNUSED(name);
}
 
static const struct wl_registry_listener registryListener = 
{
        registryHandleGlobal,
        registryHandleGlobalRemove
};
 
static gboolean busCallback(GstBus *bus, GstMessage *message, gpointer data)
{
   AppCtx *ctx= (AppCtx*)data;
   
   switch ( GST_MESSAGE_TYPE(message) ) 
   {
      case GST_MESSAGE_ERROR: 
         {
            GError *error;
            gchar *debug;
            
            gst_message_parse_error(message, &error, &debug);
            g_print("Error: %s\n", error->message);
            if ( debug )
            {
               g_print("Debug info: %s\n", debug);
            }
            g_error_free(error);
            g_free(debug);
            g_main_loop_quit( ctx->loop );
         }
         break;
     case GST_MESSAGE_EOS:
         g_print( "EOS ctx %p\n", ctx );
         g_main_loop_quit( ctx->loop );
         break;
     case GST_MESSAGE_BUFFERING:
         {
           gint percent;
           static bool triggerPlay = false;
           gst_message_parse_buffering (message, &percent);
           if(percent >= 50 && !triggerPlay)
           {
             triggerPlay = true;
             printf("50 percent buffered, going to play!\n");
             gst_element_set_state(ctx->pipeline, GST_STATE_PLAYING);
           }
         }
         break;
     default:
         break;
    }
    return TRUE;
}
 
/* Function demonstrating how to setup proxy for accessing URLs */
static void cb_playbin_source_setup( GObject *obj ) 
{ 
    const char* rne_proxy = getenv("RNE_PROXY");
    GObject *source_element; 
 
    if( g_object_class_find_property( G_OBJECT_GET_CLASS( obj ), "source" ) ) 
    {
        /* Get source element of playbin*/
        g_object_get(obj, "source", &source_element, NULL);
 
        if( NULL != rne_proxy )
        {
            printf( "The proxy is %s\n", rne_proxy );
            if( g_object_class_find_property ( G_OBJECT_GET_CLASS( source_element ), "proxy" ) )
            {
                g_object_set( G_OBJECT( source_element ), "proxy", rne_proxy, NULL );
            }
        }
        //Set strict-tls property to false
        if( g_object_class_find_property ( G_OBJECT_GET_CLASS( source_element ), "ssl-strict" ) )
        {
               g_object_set( G_OBJECT( source_element ), "ssl-strict", FALSE , NULL );
        }
        g_object_unref( source_element );
    }
}
 
bool createPipeline( AppCtx *ctx )
{
   bool result= false;
   int argc= 0;
   char **argv= 0;
   gint64 bufferDuration =  10 * GST_SECOND;
 
   gst_init( &argc, &argv );
 
   ctx->pipeline= gst_pipeline_new("pipeline");
   if ( !ctx->pipeline )
   {
      printf("Error: unable to create pipeline instance\n" );
      goto exit;
   }
 
   ctx->bus= gst_pipeline_get_bus( GST_PIPELINE(ctx->pipeline) );
   if ( !ctx->bus )
   {
      printf("Error: unable to get pipeline bus\n");
      goto exit;
   }
   gst_bus_add_watch( ctx->bus, busCallback, ctx );
   
   ctx->player= gst_element_factory_make( "playbin", "player" );
   g_object_set(G_OBJECT(ctx->player),"buffer-duration",bufferDuration,NULL);
 
   if ( !ctx->player )
   {
      printf("Error: unable to create playbin instance\n" );
      goto exit;
   }
   gst_object_ref( ctx->player );
 
   ctx->westerossink= gst_element_factory_make( "westerossink", "vsink" );
   if ( !ctx->westerossink )
   {
      printf("Error: unable to create westerossink instance\n" );
      goto exit;
   }
   gst_object_ref( ctx->westerossink );
   
   g_object_set(G_OBJECT(ctx->player), "video-sink", ctx->westerossink, NULL );
  
   /* Secure video path - SVP is available for Broadcom platform 16.2 and above  */
   if( g_object_class_find_property( G_OBJECT_GET_CLASS( ctx->westerossink ), "secure-video" ) )
   {
       g_object_set( G_OBJECT( ctx->westerossink ), "secure-video", true, NULL );
   }
   
   if ( !gst_bin_add( GST_BIN(ctx->pipeline), ctx->player) )
   {
      printf("Error: unable to add playbin to pipeline\n");
      goto exit;
   }
   
   g_signal_connect( G_OBJECT( ctx->player ), "source-setup", G_CALLBACK( cb_playbin_source_setup ), NULL );
 
   result= true;   
 
exit:
   
   return result;
}
 
void destroyPipeline( AppCtx *ctx )
{
   if ( ctx->pipeline )
   {
      gst_element_set_state(ctx->pipeline, GST_STATE_NULL);
   }
   if ( ctx->westerossink )
   {
      gst_object_unref( ctx->westerossink );
      ctx->westerossink= 0;
   }
   if ( ctx->player )
   {
      gst_object_unref( ctx->player );
      ctx->player= 0;
   }
   if ( ctx->bus )
   {
      gst_object_unref( ctx->bus );
      ctx->bus= 0;
   }
   if ( ctx->pipeline )
   {
      gst_object_unref( GST_OBJECT(ctx->pipeline) );
      ctx->pipeline= 0;
   }
}
 
static AppCtx *g_ctx= 0;
 
static void signalHandler(int signum)
{
   printf("signalHandler: signum %d\n", signum);
   if ( g_ctx )
   {
           g_main_loop_quit( g_ctx->loop );
           g_ctx= 0;
        }
}
 
int main( int argc, char **argv )
{
   int result= -1;
   int argidx;
   const char *uri= "http://download.blender.org/peach/bigbuckbunny_movies/big_buck_bunny_720p_h264.mov";
   AppCtx *ctx= 0;
   struct sigaction sigint;
#ifdef ENABLE_BREAKPAD
   google_breakpad::MinidumpDescriptor descriptor("/tmp");
   google_breakpad::ExceptionHandler eh(descriptor, NULL, breakpadDumpCallback, NULL, true, -1);
#endif
   printf("rne_player: v1.0\n\n" );
/*   
   if ( argc < 2 )
   {
      showUsage();
      goto exit;
   }
*/
   argidx= 1;   
   while ( argidx < argc )
   {
      if ( argv[argidx][0] == '-' )
      {
         switch( argv[argidx][1] )
         {
            case '?':
               showUsage();
               goto exit;
            default:
               printf( "unknown option %s\n\n", argv[argidx] );
               exit( -1 );
               break;
         }
      }
      else
      {
         uri= argv[argidx];
/*
         if ( !uri )
         {
            uri= argv[argidx];
         }
         else
         {
            printf( "ignoring extra argument: %s\n", argv[argidx] );
         }
*/
      }
      
      ++argidx;
   }
   
   if ( !uri )
   {
      printf( "missing uri argument\n" );
      goto exit;
   }
         
   printf( "playing asset: %s\n", uri );
 
   ctx= (AppCtx*)calloc( 1, sizeof(AppCtx) );
   if ( !ctx )
   {
      printf("Error: unable to allocate application context\n");
      goto exit;
   }
   
   ctx->display= wl_display_connect( NULL );
   if ( !ctx->display )
   {
      printf("Error: unable to open default wayland display\n");
      goto exit;
   }
   ctx->registry= wl_display_get_registry(ctx->display);
   if ( !ctx->registry )
   {
      printf("Error: unable to get wayland registry\n");
      goto exit;
   }
   wl_registry_add_listener(ctx->registry, &registryListener, ctx);   
   wl_display_roundtrip(ctx->display);
   
   if ( createPipeline( ctx ) )
   {
      printf("pipeline created\n");
      ctx->loop= g_main_loop_new(NULL,FALSE);
      
      if ( ctx->loop )
      {
         g_object_set(G_OBJECT(ctx->player), "uri", uri, NULL );
         
         if ( GST_STATE_CHANGE_FAILURE != gst_element_set_state(ctx->pipeline, GST_STATE_PAUSED) )
         {
            sigint.sa_handler = signalHandler;
            sigemptyset(&sigint.sa_mask);
            sigint.sa_flags = SA_RESETHAND;
            sigaction(SIGINT, &sigint, NULL);
 
            g_ctx= ctx;
 
            g_main_loop_run( ctx->loop );
         }
      }
      else
      {
         printf( "Error: unable to create main loop\n");
      }
   }
   else
   {
      printf( "Error: unable to create player pipeline\n" );
   }
 
   
   result= 0;
      
exit:
 
   if ( ctx )
   {
      if ( ctx->output )
      {
         wl_output_destroy( ctx->output );
         ctx->output= 0;
      }
      
      if ( ctx->registry )
      {
         wl_registry_destroy(ctx->registry);
         ctx->registry= 0;
      }
      
      if ( ctx->display )
      {
         wl_display_disconnect(ctx->display);
         ctx->display= 0;
      }
      
      destroyPipeline( ctx );
      
      if ( ctx->loop )
      {
         g_main_loop_unref(ctx->loop);
         ctx->loop= 0;
      }
      
      free( ctx );
   }
 
   return result;   
}