swfdec_net_stream.c

Swfdec still is development software, but has also followed a rigid no-crashes-allowed policy. I b

	    SWFDEC_DECODER (stream->flvdecoder)->rate, 
	    SWFDEC_DECODER (stream->flvdecoder)->width, 
	    SWFDEC_DECODER (stream->flvdecoder)->height);
      case SWFDEC_STATUS_IMAGE:
	recheck = TRUE;
	break;
      case SWFDEC_STATUS_ERROR:
      case SWFDEC_STATUS_NEEDBITS:
      case SWFDEC_STATUS_EOF:
	goto out;
      default:
	g_assert_not_reached ();
	return;
    }
  }
out:
  if (loader->eof) {
    guint first, last;
    swfdec_flv_decoder_eof (stream->flvdecoder);
    recheck = TRUE;
    swfdec_net_stream_onstatus (stream, "NetStream.Buffer.Flush", "status");
    swfdec_net_stream_video_goto (stream, stream->current_time);
    stream->buffering = FALSE;
    if (swfdec_flv_decoder_get_video_info (stream->flvdecoder, &first, &last) &&
	stream->current_time + stream->buffer_time <= last) {
      swfdec_net_stream_onstatus (stream, "NetStream.Buffer.Full", "status");
    }
  }
  if (recheck) {
    if (stream->buffering) {
      guint first, last;
      if (swfdec_flv_decoder_get_video_info (stream->flvdecoder, &first, &last)) {
	guint current = MAX (first, stream->current_time);
	if (current + stream->buffer_time <= last) {
	  swfdec_net_stream_video_goto (stream, current);
	  stream->buffering = FALSE;
	  swfdec_net_stream_onstatus (stream, "NetStream.Buffer.Full", "status");
	}
      } else {
	SWFDEC_ERROR ("no video stream, how do we update buffering?");
      }
    }
    swfdec_net_stream_update_playing (stream);
  }
}


static void
swfdec_net_stream_loader_target_init (SwfdecLoaderTargetInterface *iface)
{
  iface->get_player = swfdec_net_stream_loader_target_get_player;
  iface->parse = swfdec_net_stream_loader_target_parse;
}

/*** SWFDEC VIDEO MOVIE INPUT ***/

static void
swfdec_net_stream_input_connect (SwfdecVideoMovieInput *input, SwfdecVideoMovie *movie)
{
  SwfdecNetStream *stream = SWFDEC_NET_STREAM ((guchar *) input - G_STRUCT_OFFSET (SwfdecNetStream, input));

  stream->movies = g_list_prepend (stream->movies, movie);
  g_object_ref (stream);
}

static void
swfdec_net_stream_input_disconnect (SwfdecVideoMovieInput *input, SwfdecVideoMovie *movie)
{
  SwfdecNetStream *stream = SWFDEC_NET_STREAM ((guchar *) input - G_STRUCT_OFFSET (SwfdecNetStream, input));

  stream->movies = g_list_remove (stream->movies, movie);
  g_object_unref (stream);
}

/*** SWFDEC_NET_STREAM ***/

G_DEFINE_TYPE_WITH_CODE (SwfdecNetStream, swfdec_net_stream, SWFDEC_TYPE_SCRIPTABLE,
    G_IMPLEMENT_INTERFACE (SWFDEC_TYPE_LOADER_TARGET, swfdec_net_stream_loader_target_init))

static void
swfdec_net_stream_dispose (GObject *object)
{
  SwfdecNetStream *stream = SWFDEC_NET_STREAM (object);

  swfdec_net_stream_set_playing (stream, FALSE);
  if (stream->surface) {
    cairo_surface_destroy (stream->surface);
    stream->surface = NULL;
  }
  if (stream->decoder)
    swfdec_video_codec_finish (stream->codec, stream->decoder);
  swfdec_net_stream_set_loader (stream, NULL);
  g_object_unref (stream->conn);
  stream->conn = NULL;
  g_assert (stream->movies == NULL);

  G_OBJECT_CLASS (swfdec_net_stream_parent_class)->dispose (object);
}

extern const JSClass net_stream_class;
static void
swfdec_net_stream_class_init (SwfdecNetStreamClass *klass)
{
  GObjectClass *object_class = G_OBJECT_CLASS (klass);
  SwfdecScriptableClass *scriptable_class = SWFDEC_SCRIPTABLE_CLASS (klass);

  object_class->dispose = swfdec_net_stream_dispose;

  scriptable_class->jsclass = &net_stream_class;
}

static void
swfdec_net_stream_init (SwfdecNetStream *stream)
{
  stream->input.connect = swfdec_net_stream_input_connect;
  stream->input.disconnect = swfdec_net_stream_input_disconnect;

  stream->buffer_time = 100; /* msecs */
}

SwfdecNetStream *
swfdec_net_stream_new (SwfdecPlayer *player, SwfdecConnection *conn)
{
  SwfdecNetStream *stream;
  
  g_return_val_if_fail (SWFDEC_IS_PLAYER (player), NULL);
  g_return_val_if_fail (SWFDEC_IS_CONNECTION (conn), NULL);

  stream = g_object_new (SWFDEC_TYPE_NET_STREAM, NULL);
  stream->player = player;
  stream->conn = conn;
  SWFDEC_SCRIPTABLE (stream)->jscx = player->jscx;
  g_object_ref (conn);

  return stream;
}

void
swfdec_net_stream_set_url (SwfdecNetStream *stream, const char *url)
{
  SwfdecLoader *loader;

  g_return_if_fail (SWFDEC_IS_NET_STREAM (stream));
  g_return_if_fail (url != NULL);

  /* FIXME: use the connection once connections are implemented */
  loader = swfdec_player_load (stream->player, url);
  swfdec_net_stream_set_loader (stream, loader);
}

void
swfdec_net_stream_set_loader (SwfdecNetStream *stream, SwfdecLoader *loader)
{
  g_return_if_fail (SWFDEC_IS_NET_STREAM (stream));
  g_return_if_fail (loader == NULL || SWFDEC_IS_LOADER (loader));

  if (stream->loader)
    g_object_unref (stream->loader);
  if (stream->flvdecoder) {
    g_object_unref (stream->flvdecoder);
    stream->flvdecoder = NULL;
  }
  stream->loader = loader;
  stream->buffering = TRUE;
  if (loader) {
    g_object_ref (loader);
    swfdec_loader_set_target (loader, SWFDEC_LOADER_TARGET (stream));
    swfdec_loader_queue_parse (loader);
  }
  swfdec_net_stream_set_playing (stream, TRUE);
}

void
swfdec_net_stream_set_playing (SwfdecNetStream *stream, gboolean playing)
{
  g_return_if_fail (SWFDEC_IS_NET_STREAM (stream));

  stream->playing = playing;

  swfdec_net_stream_update_playing (stream);
}

gboolean
swfdec_net_stream_get_playing (SwfdecNetStream *stream)
{
  g_return_val_if_fail (SWFDEC_IS_NET_STREAM (stream), FALSE);

  return stream->playing;
}

void
swfdec_net_stream_set_buffer_time (SwfdecNetStream *stream, double secs)
{
  g_return_if_fail (SWFDEC_IS_NET_STREAM (stream));

  /* FIXME: is this correct? */
  if (secs <= 0)
    return;

  stream->buffer_time = secs * 1000;
}

double
swfdec_net_stream_get_buffer_time (SwfdecNetStream *stream)
{
  g_return_val_if_fail (SWFDEC_IS_NET_STREAM (stream), 0.1);

  return (double) stream->buffer_time / 1000.0;
}

void
swfdec_net_stream_seek (SwfdecNetStream *stream, double secs)
{
  guint first, last, msecs;

  g_return_if_fail (SWFDEC_IS_NET_STREAM (stream));

  if (stream->flvdecoder == NULL)
    return;
  if (!finite (secs) || secs < 0) {
    SWFDEC_ERROR ("seeking to %g doesn't work", secs);
    return;
  }
  if (!swfdec_flv_decoder_get_video_info (stream->flvdecoder, &first, &last)) {
    SWFDEC_ERROR ("FIXME: implement seeking in audio only NetStream");
    return;
  }
  msecs = secs * 1000;
  msecs += first;
  if (msecs > last)
    msecs = last;
  swfdec_flv_decoder_get_video (stream->flvdecoder, msecs, TRUE, NULL, &msecs, NULL);
  swfdec_net_stream_video_goto (stream, msecs);
  /* FIXME: this needs to be implemented correctly, but requires changes to audio handling:
   * - creating a new audio stream will cause attachAudio scripts to lose information 
   * - implementing seek on audio stream requires a SwfdecAudio::changed signal so audio
   *   backends can react correctly.
   */
  if (stream->audio) {
    SWFDEC_WARNING ("FIXME: restarting audio after seek");
    swfdec_audio_remove (stream->audio);
    g_object_unref (stream->audio);
    stream->audio = swfdec_audio_flv_new (stream->player, 
	stream->flvdecoder, stream->current_time);
  }
}