/**
  * Stop transcoding a stream.
  *
  * @param aStream The stream to stop transcoding.
  * @param aScope The application scope.
  */
 public synchronized void stopTranscodingStream(IBroadcastStream aStream, IScope aScope) {
   System.out.println(
       "stopTranscodingStream(" + aStream.getPublishedName() + "," + aScope.getName() + ")");
   String inputName = aStream.getPublishedName();
   Transcoder transcoder = mTranscoders.get(inputName);
   if (transcoder != null) {
     transcoder.stop();
   }
   BroadcastStream outputStream = mOutputStreams.get(inputName);
   if (outputStream != null) {
     outputStream.stop();
   }
 }
示例#2
0
  /**
   * A hook to record a sample stream. A file is written in webapps/sip/streams/
   *
   * @param stream
   */
  private void recordStream(IBroadcastStream stream) {
    IConnection conn = Red5.getConnectionLocal();
    String streamName = stream.getPublishedName();

    try {
      ClientBroadcastStream cstream =
          (ClientBroadcastStream)
              this.getBroadcastStream(conn.getScope(), stream.getPublishedName());
      cstream.saveAs(streamName, false);
    } catch (Exception e) {
      System.out.println("ERROR while recording stream " + e.getMessage());
      e.printStackTrace();
    }
  }
  /**
   * Starts transcoding this stream. This method is a no-op if this stream is already a stream copy
   * created by this transcoder.
   *
   * @param aStream The stream to copy.
   * @param aScope The application scope.
   */
  public synchronized void startTranscodingStream(IBroadcastStream aStream, IScope aScope) {
    System.out.println(
        "startTranscodingStream(" + aStream.getPublishedName() + "," + aScope.getName() + ")");
    if (aStream.getPublishedName().startsWith(getStreamPrefix())) {
      System.out.println("Not making a copy of a copy: " + aStream.getPublishedName());
      return;
    }
    System.out.println("Making transcoded version of: " + aStream.getPublishedName());

    /*
     * Now, we need to set up the output stream we want to broadcast to.
     * Turns out aaffmpeg-red5 provides one of those.
     */
    String outputName = getStreamPrefix() + aStream.getPublishedName();
    BroadcastStream outputStream = new BroadcastStream(outputName);
    outputStream.setPublishedName(outputName);
    outputStream.setScope(aScope);

    IContext context = aScope.getContext();

    IProviderService providerService =
        (IProviderService) context.getBean(IProviderService.BEAN_NAME);
    if (providerService.registerBroadcastStream(aScope, outputName, outputStream)) {
      IBroadcastScope bsScope =
          (BroadcastScope) providerService.getLiveProviderInput(aScope, outputName, true);

      bsScope.setAttribute(IBroadcastScope.STREAM_ATTRIBUTE, outputStream);
    } else {
      System.out.println("Got a fatal error; could not register broadcast stream");
      throw new RuntimeException("fooey!");
    }
    mOutputStreams.put(aStream.getPublishedName(), outputStream);
    outputStream.start();

    /** Now let's give aaffmpeg-red5 some information about what we want to transcode as. */
    ISimpleMediaFile outputStreamInfo = new SimpleMediaFile();
    outputStreamInfo.setHasAudio(true);
    outputStreamInfo.setAudioBitRate(32000);
    outputStreamInfo.setAudioChannels(1);
    outputStreamInfo.setAudioSampleRate(22050);
    outputStreamInfo.setAudioCodec(ICodec.ID.CODEC_ID_MP3);
    outputStreamInfo.setHasVideo(true);
    // Unfortunately the Trans-coder needs to know the width and height
    // you want to output as; even if you don't know yet.
    outputStreamInfo.setVideoWidth(640);
    outputStreamInfo.setVideoHeight(480);
    outputStreamInfo.setVideoBitRate(320000);
    outputStreamInfo.setVideoCodec(ICodec.ID.CODEC_ID_FLV1);
    outputStreamInfo.setVideoGlobalQuality(0);

    /** And finally, let's create out transcoder */
    Transcoder transcoder =
        new Transcoder(aStream, outputStream, outputStreamInfo, null, null, mVideoPictureListener);
    Thread transcoderThread = new Thread(transcoder);
    transcoderThread.setDaemon(true);
    mTranscoders.put(aStream.getPublishedName(), transcoder);
    System.out.println("Starting transcoding thread for: " + aStream.getPublishedName());
    transcoderThread.start();
  }
示例#4
0
  @Override
  public void streamPublishStart(IBroadcastStream stream) {
    String clientId = Red5.getConnectionLocal().getClient().getId();
    String userid = getUserId();
    String username = getUsername();

    log.debug(
        "{} has started publishing stream [{}]",
        username + "[uid=" + userid + "][clientid=" + clientId + "]",
        stream.getPublishedName());
    System.out.println("streamPublishStart: " + stream.getPublishedName());
    IConnection conn = Red5.getConnectionLocal();
    String peerId = (String) conn.getAttribute("VOICE_CONF_PEER");
    if (peerId != null) {
      super.streamPublishStart(stream);
      sipPeerManager.startTalkStream(peerId, clientId, stream, conn.getScope());
      //	    	recordStream(stream);
    }
  }
 /** {@inheritDoc} */
 public boolean unregisterBroadcastStream(IScope scope, String name, IBroadcastStream bs) {
   if (log.isDebugEnabled()) {
     log.debug("Unregistering - name: {} stream: {} scope: {}", new Object[] {name, bs, scope});
     ((Scope) scope).dump();
   }
   IBroadcastScope broadcastScope = scope.getBroadcastScope(name);
   if (bs != null) {
     log.debug("Unsubscribing scope {} from provider {}", broadcastScope, bs.getProvider());
     broadcastScope.unsubscribe(bs.getProvider());
   }
   // if the scope has no listeners try to remove it
   if (!((BasicScope) broadcastScope).hasEventListeners()) {
     if (log.isDebugEnabled()) {
       log.debug("Scope has no event listeners attempting removal");
     }
     scope.removeChildScope(broadcastScope);
   }
   // verify that scope was removed
   return scope.getBasicScope(ScopeType.BROADCAST, name) == null;
 }
 /** {@inheritDoc} */
 public void publish(Boolean dontStop) {
   if (!dontStop) {
     IConnection conn = Red5.getConnectionLocal();
     if (conn instanceof IStreamCapableConnection) {
       IStreamCapableConnection streamConn = (IStreamCapableConnection) conn;
       int streamId = conn.getStreamId();
       IClientStream stream = streamConn.getStreamById(streamId);
       if (stream instanceof IBroadcastStream) {
         IBroadcastStream bs = (IBroadcastStream) stream;
         if (bs.getPublishedName() != null) {
           IBroadcastScope bsScope = getBroadcastScope(conn.getScope(), bs.getPublishedName());
           if (bsScope != null) {
             bsScope.unsubscribe(bs.getProvider());
             if (conn instanceof BaseConnection) {
               ((BaseConnection) conn).unregisterBasicScope(bsScope);
             }
           }
           bs.close();
           streamConn.deleteStreamById(streamId);
         }
       }
     }
   }
 }
 /** {@inheritDoc} */
 public boolean registerBroadcastStream(IScope scope, String name, IBroadcastStream bs) {
   if (log.isDebugEnabled()) {
     log.debug("Registering - name: {} stream: {} scope: {}", new Object[] {name, bs, scope});
     ((Scope) scope).dump();
   }
   IBroadcastScope broadcastScope = scope.getBroadcastScope(name);
   if (broadcastScope == null) {
     log.debug("Creating a new scope");
     broadcastScope = new BroadcastScope(scope, name);
     if (scope.addChildScope(broadcastScope)) {
       log.debug("Broadcast scope added");
     } else {
       log.warn("Broadcast scope was not added to {}", scope);
     }
   }
   // set the client broadcast stream if we have a broadcast scope
   if (broadcastScope != null && bs instanceof IClientBroadcastStream) {
     broadcastScope.setClientBroadcastStream((IClientBroadcastStream) bs);
   }
   if (log.isDebugEnabled()) {
     log.debug("Subscribing scope {} to provider {}", broadcastScope, bs.getProvider());
   }
   return broadcastScope.subscribe(bs.getProvider(), null);
 }
 public void streamBroadcastStart(IBroadcastStream stream) {
   loginfo("Red5SIP Stream broadcast start: " + stream.getPublishedName());
 }
 public void streamBroadcastClose(IBroadcastStream stream) {
   loginfo("Red5SIP Stream broadcast close: " + stream.getPublishedName());
 }
 public void streamPublishStart(IBroadcastStream stream) {
   loginfo("Red5SIP Stream publish start: " + stream.getPublishedName());
   IConnection current = Red5.getConnectionLocal();
 }