How to append recorded files.

Question

Two questions.
I am using adobe dvrcast to record my live streams. the problem I am having is when I stop the encode during a live stream, a new file is not created, the existing stream is written over. How can I preventive this from occuring.
Is there a way to have all vod files that are in one folder to roll over to the next file during play back.

Answer 1

Thanks for the quick response. I am using FMLE 3 and FMS 3.5. I have changed the code per your suggestion. However, the file still does not append when i press the stop button in FMLE. After pressing stop, when I press start button in FMLE again, the file size starts at zero.
here is my code: ExDVRStream.asc
/*----------------------------------------------------------------------------+
|       ___     _       _                                                    |
|      /   |   | |     | |                                                   |
|     / /| | __| | ___ | |__   ___                                           |
|    / /_| |/ _  |/ _ \|  _ \ / _ \                                          |
|   / ___  | (_| | (_) | |_) |  __/                                          |
|  /_/   |_|\__,_|\___/|____/ \___|                                          |
|                                                                            |
|                                                                            |
|  ADOBE CONFIDENTIAL                                                        |
|  __________________                                                        |
|                                                                            |
|  Copyright (c) 2008, Adobe Systems Incorporated. All rights reserved.      |
|                                                                            |
|  NOTICE:  All information contained herein is, and remains the property    |
|  of Adobe Systems Incorporated and its suppliers, if any. The intellectual |
|  and technical concepts contained herein are proprietary to Adobe Systems  |
|  Incorporated and its suppliers and may be covered by U.S. and Foreign     |
|  Patents, patents in process, and are protected by trade secret or         |
|  copyright law. Dissemination of this information or reproduction of this  |
|  material is strictly forbidden unless prior written permission is         |
|  obtained from Adobe Systems Incorporated.                                 |
|                                                                            |
|          Adobe Systems Incorporated       415.832.2000                     |
|          601 Townsend Street              415.832.2020 fax                 |
|          San Francisco, CA 94103                                           |
|                                                                            |
+----------------------------------------------------------------------------*/
load("ExUtil.asc");
* An example dvr stream class that handlings requests initiated from the
* publisher and subscribers.
* @param name    live streams name as visible to the client subscribers
* @param numsubscriber  number of subscribers
* @param subscribers  a map of subscribing client based on the client id
* @param publisher   publishing client
* @param streamInfo  holds default DVR stream info or stream info provided
*       by the publisher
* @param startRecTimer  Id returned by the scheduler to start recording
* @param stopRecTimer  Id returned by the scheduler to stop recording
* @param broadcastTimer Id returned by the scheduler to broadcast stream info
*       to down stream servers
* @param broadcastInterval how often to broadcast stream info
function ExDVRStream( name ) {
this.name = name;     // clients subscribe to this stream name
this.numsubscriber = null;   // number of subscribers
this.subscribers = new Object(); // map of current subscribers
this.publisher = null;    // client publisher, this is only set in the origin
this.streamInfo = null;    // streamInfo provided by the publisher
this.startRecTimer = null;   // scheduler id to start recording
this.stopRecTimer = null;   // scheduler id to stop recording
this.broadcastTimer = null;   // scheduler id for broadcasting
this.broadcastInterval = 5000;  // set the interval to 5 sec by default
this.isRecording = false;   // flag to indicate if the stream is recording
// Public interface
* This function gets call when a client is added as a subcriber of the stream.
* If the client is already a subscriber, it will be a no-op.
ExDVRStream.prototype.addSubscriber = function( client )
if (this.subscribers[client.id] == null)
  this.subscribers[client.id] = client;
  this.numsubscriber++;
* Removes a client from the subscriber list. 
ExDVRStream.prototype.removeSubscriber = function( client )
if (this.subscribers[client.id])
  this.subscribers[client.id] = null;
  delete this.subscribers[client.id];
  this.numsubscriber--;
* This function broadcast streamInfo to all the subscriber which
* is acting as a server
ExDVRStream.prototype.broadcastStreamInfo = function()
debug("Inside ExDVRStream.broadcastStreamInfo - stream name: " +
  this.name);
for (i in this.subscribers)
  subscriber = this.subscribers[i];
  if (subscriber.isProxyServer)
   subscriber.call("DVRSetStreamInfo", null, this.getStreamInfo());
* Set the publishing client
ExDVRStream.prototype.publish = function( client )
this.publisher = client;
* Clear the publishing client
ExDVRStream.prototype.unpublish = function()
this.publisher = null;
* This function returns a boolean to indicate whether the stream is in use
ExDVRStream.prototype.isInUse = function()
if (this.numsubscriber > 0 || this.publisher)
  return true;
return false;
* This function cleans up all the resources used by this stream
ExDVRStream.prototype.shutdown = function()
debug("Inside ExDVRStream.shutdown");
clearInterval(this.startRecTimer);
clearInterval(this.stopRecTimer);
clearInterval(this.broadcastTimer);
this.startRecTimer = null;
this.stopRecTimer = null;
this.broadcastTimer = null;
* Returns the default streamInfo if no streamInfo has been
* set by the publisher
ExDVRStream.prototype.getDefaultStreamInfo = function( DVRStreamInfo )
//If server restarts and no publisher is coming in, we check
//the length of the recorded stream and see if we should make
//the dvr content available.  However, user can customize this
//function and make an external call.
streamLen = Stream.length(this.name);
if (streamLen || this.publisher)
  //found a dvr stream, so return it
  DVRStreamInfo.code = "NetStream.DVRStreamInfo.Success";
  this.streamInfo = new Object();
  //setup default value
  this.streamInfo.streamName = this.name;
  this.streamInfo.callTime = new Date();
  this.streamInfo.startRec = new Date();
  this.streamInfo.stopRec = new Date();
  this.streamInfo.maxLen = Stream.length(this.name);
  this.streamInfo.begOffset = 0;
  this.streamInfo.endOffset = 0;
  this.streamInfo.append = false;
  this.streamInfo.offline = false;
  this.streamInfo.currLen = Stream.length(this.name);
  this.streamInfo.isRec = false;
  DVRStreamInfo.data = this.streamInfo;
else
  DVRStreamInfo.code = "NetStream.DVRStreamInfo.Failed";
  DVRStreamInfo.data = null;
* Get streamInfo and create a default one if no streamInfo
* has been set.
ExDVRStream.prototype.getStreamInfo = function()
debug("Inside ExDVRStream.getStreamInfo");
DVRStreamInfo = new Object();
if (this.streamInfo == null)
  this.getDefaultStreamInfo(DVRStreamInfo);
else if (this.streamInfo.offline)
  DVRStreamInfo.code = "NetStream.DVRStreamInfo.Failed";
  DVRStreamInfo.data = null;
else
  DVRStreamInfo.code = "NetStream.DVRStreamInfo.Success";
  DVRStreamInfo.data = this.streamInfo;
  DVRStreamInfo.data.isRec = this.isRecording;
  DVRStreamInfo.data.currLen = Stream.length(this.name);
return DVRStreamInfo;
* Set streamInfo, also handleStreamInfo to start/stop a recording
ExDVRStream.prototype.setStreamInfo = function( streamInfo )
debug("Inside ExDVRStream.setStreamInfo");
//Right now, this only get called from the FMLE when
//the publisher start/stop a recording
currDate = new Date();
currTime = currDate.getTime();
this.streamInfo = streamInfo;
this.streamInfo.lastUpdate = currDate;
startRecTime = 0;
stopRecTime = 0;
if (streamInfo.startRec == -1 || streamInfo.startRec == undefined)
  startRecTime = -1000;
else if (streamInfo.startRec instanceof Date)
  startRecTime = streamInfo.startRec.getTime();
else
  //invalid startRec format
  return;
if (streamInfo.stopRec == -1 || streamInfo.stopRec == undefined)
  stopRecTime = -1000;
else if (streamInfo.stopRec instanceof Date)
  stopRecTime = streamInfo.stopRec.getTime();
else
  //invalid stopRec format
  return;
if ( startRecTime == -1000 && stopRecTime == -1000 )
  //broadcast the change to all the downstream server
  this.broadcastStreamInfo(streamInfo);
  return;
if (stopRecTime != -1000)
  //We are about to stop a recording, so clear the timer
  clearInterval(this.stopRecTimer);
  this.stopRecTimer = null;
  if (currTime < stopRecTime)
   timeDiff = stopRecTime - currTime;
   //we will broadcast the streamInfo to all the downstream server
   //when we actually stop the recording inside onStopRecord
   this.stopRecTimer = setInterval(this, "onStopRecord", timeDiff);
  else
   //stop recording immediately
   this.onStopRecord();
if (startRecTime != -1000)
  //We are about to start a recording, so clear the timer
  clearInterval(this.startRecTimer);
  this.startRecTimer = null;
  if (currTime < startRecTime)
   timeDiff = startRecTime - currTime;
   //we will broadcast the streamInfo to all the downstream server
   //when we actually start the recording inside onStartRecord
   this.startRecTimer = setInterval(this, "onStartRecord", timeDiff);
  else
   //start recording immediately
   this.onStartRecord();
* This is called when we are about to stop a recording
ExDVRStream.prototype.onStopRecord = function()
this.isRecording = false;
clearInterval(this.stopRecTimer);
this.stopRecTimer = null;
s = Stream.get(this.name);
s.record(false);
//notify the downstream server immediately
this.broadcastStreamInfo(this.streamInfo);
//also stop the periodic broadcast because the stream is not growing
this.stopStreamInfoBroadcast();
* This is called when we are about to start a recording
ExDVRStream.prototype.onStartRecord = function()
debug("Inside ExDVRStream.onStartRecord");
this.isRecording = true;
clearInterval(this.startRecTimer);
this.startRecTimer = null;
s = Stream.get(this.name);
if (this.streamInfo.append)
  s.record("append");
else
  s.record("append");
//notify the downstream server immediately
this.broadcastStreamInfo(this.streamInfo);
//also start the periodic broadcast because the stream is growing
this.startStreamInfoBroadcast();
* Stop the timer to broadcast streamInfo to downstream servers
ExDVRStream.prototype.stopStreamInfoBroadcast = function()
clearInterval(this.broadcastTimer);
this.broadcastTimer = null;
* Start the timer to broadcast streamInfo to downstream servers
ExDVRStream.prototype.startStreamInfoBroadcast = function()
debug("ExDVRStream.Inside startStreamInfoBroadcast");
this.stopStreamInfoBroadcast();
this.broadcastTimer = setInterval( this, "onStreamInfoBroadcast",
  this.broadcastInterval)
* This is called by scheduler to broadcast streamInfo to the
* downstream servers
ExDVRStream.prototype.onStreamInfoBroadcast = function()
debug("Inside ExDVRStream.onStreamInfoBroadcast");
this.broadcastStreamInfo();