sdk update

Author: chehefen

README.md

@@ -252,6 +252,12 @@ $ sudo reboot
 
 
 ## Release Notes
+### Release 1.2.0 (February 2018)
+* Bug fixes and performance enhancement
+* Streaming error recovery improvements
+* Minor API changes:
+  * create stream APIs return shared pointers instead of unique pointers
+  * Addition of StreamClosed callback to notify the caller application when the stream is finished draining the existing buffered frames before closing in the graceful termination case.
 ### Release 1.1.3 (February 2018)
 * Added RTSP Demo Sample
 ** AWS_ACCESS_KEY_ID=AKIASAMPLEKEYID AWS_SECRET_ACCESS_KEY=MYSECRETACCESSKEY ./kinesis_video_gstreamer_sample_rtsp_app rtspurl  stream-name

kinesis-video-gst-demo/README.md

@@ -192,8 +192,8 @@ set(PRODUCER_SOURCE_FILES
         ${KINESIS_VIDEO_PRODUCER_SRC}/src/StreamCallbackProvider.h
         ${KINESIS_VIDEO_PRODUCER_SRC}/src/CurlCallManager.h
         ${KINESIS_VIDEO_PRODUCER_SRC}/src/DefaultCallbackProvider.cpp
-        ${KINESIS_VIDEO_PRODUCER_SRC}/src/OngoingPutFrameState.cpp
-        ${KINESIS_VIDEO_PRODUCER_SRC}/src/OngoingPutFrameState.h
+        ${KINESIS_VIDEO_PRODUCER_SRC}/src/OngoingStreamState.cpp
+        ${KINESIS_VIDEO_PRODUCER_SRC}/src/OngoingStreamState.h
         ${KINESIS_VIDEO_PRODUCER_SRC}/src/DefaultCallbackProvider.h
         ${KINESIS_VIDEO_PRODUCER_SRC}/src/DefaultDeviceInfoProvider.cpp
         ${KINESIS_VIDEO_PRODUCER_SRC}/src/DefaultDeviceInfoProvider.h

kinesis-video-native-build/CMakeLists.txt

@@ -251,7 +251,7 @@ extern "C" {
 /**
  * The max streaming token expiration duration after which the ingestion host will force terminate the connection.
  */
-#define MAX_ENFORCED_TOKEN_EXPIRATION_DURATION      (40 * HUNDREDS_OF_NANOS_IN_AN_HOUR)
+#define MAX_ENFORCED_TOKEN_EXPIRATION_DURATION      (40 * HUNDREDS_OF_NANOS_IN_A_MINUTE)
 
 /**
  * Grace period for the streaming token expiration - 3 seconds
@@ -416,6 +416,20 @@ typedef UPLOAD_HANDLE* PUPLOAD_HANDLE;
 #define IS_VALID_UPLOAD_HANDLE(h) ((h) != INVALID_UPLOAD_HANDLE_VALUE)
 #endif
 
+/**
+ * This is a sentinel indicating an invalid timestamp value
+ */
+#ifndef INVALID_TIMESTAMP_VALUE
+#define INVALID_TIMESTAMP_VALUE ((UINT64) 0xFFFFFFFFFFFFFFFFULL)
+#endif
+
+/**
+ * Checks for the handle validity
+ */
+#ifndef IS_VALID_TIMESTAMP
+#define IS_VALID_TIMESTAMP(h) ((h) != INVALID_TIMESTAMP_VALUE)
+#endif
+
 ////////////////////////////////////////////////////
 // Main structure declarations
 ////////////////////////////////////////////////////
@@ -1243,27 +1257,31 @@ typedef STATUS (*StreamReadyFunc)(UINT64,
  *
  * @param 1 UINT64 - Custom handle passed by the caller.
  * @param 2 STREAM_HANDLE - The stream to report for.
+ * @param 3 UINT64 - Client upload handle.
  *
  * @return Status of the callback
  */
 typedef STATUS (*StreamClosedFunc)(UINT64,
-                                  STREAM_HANDLE);
+                                   STREAM_HANDLE,
+                                   UINT64);
 
 /**
  * Notifies that a given stream has data available.
  *
  * @param 1 UINT64 - Custom handle passed by the caller.
  * @param 2 STREAM_HANDLE - The stream to report for.
  * @param 3 PCHAR - Stream name.
- * @param 4 UINT64 - The duration of content currently available in 100ns.
- * @param 5 UINT64 - The size of content in bytes currently available.
+ * @param 4 UINT64 - Current client stream handle passed by the caller.
+ * @param 5 UINT64 - The duration of content currently available in 100ns.
+ * @param 6 UINT64 - The size of content in bytes currently available.
  *
  * @return Status of the callback
  */
 typedef STATUS (*StreamDataAvailableFunc)(UINT64,
                                           STREAM_HANDLE,
                                           PCHAR,
                                           UINT64,
+                                          UINT64,
                                           UINT64);
 
 ///////////////////////////////////////////////////////////////
@@ -1745,11 +1763,12 @@ PUBLIC_API STATUS getKinesisVideoStreamData(STREAM_HANDLE, PUINT64, PBYTE, UINT3
  * Streaming has been terminated unexpectedly
  *
  * @param 1 STREAM_HANDLE - the stream handle.
- * @param 2 SERVICE_CALL_RESULT - Result returned.
+ * @param 2 UINT64 - Stream upload handle returned by the client.
+ * @param 3 SERVICE_CALL_RESULT - Result returned.
  *
  * @return Status of the function call.
  */
-PUBLIC_API STATUS kinesisVideoStreamTerminated(STREAM_HANDLE, SERVICE_CALL_RESULT);
+PUBLIC_API STATUS kinesisVideoStreamTerminated(STREAM_HANDLE, UINT64, SERVICE_CALL_RESULT);
 
 /**
  * Stream fragment ACK received.
@@ -1762,11 +1781,13 @@ PUBLIC_API STATUS kinesisVideoStreamTerminated(STREAM_HANDLE, SERVICE_CALL_RESUL
  * 4) In case of an error we re-set the current to the fragment start frame timestamp.
  *
  * @param 1 STREAM_HANDLE - The stream handle to report ACKs for
- * @param 2 PFragmentAck - Reported ack.
+ * @param 2 UPLOAD_HANDLE - Stream upload handle.
+ * @param 3 PFragmentAck - Reported ack.
  *
  * @return Status of the function call.
  */
 PUBLIC_API STATUS kinesisVideoStreamFragmentAck(STREAM_HANDLE,
+                                                UPLOAD_HANDLE,
                                                 PFragmentAck);
 
 /**
@@ -1777,12 +1798,14 @@ PUBLIC_API STATUS kinesisVideoStreamFragmentAck(STREAM_HANDLE,
  * NOTE: See kinesisVideoStreamFragmentAck for more information about the successfully received ACK processing
  *
  * @param 1 STREAM_HANDLE - The stream handle to parse the ACKs for
- * @param 2 PCHAR - Reported ack segment - can be non-NULL terminated.
- * @param 3 UINT32 - Reported ack segment size in chars.
+ * @param 2 UPLOAD_HANDLE - Stream upload handle.
+ * @param 3 PCHAR - Reported ack segment - can be non-NULL terminated.
+ * @param 4 UINT32 - Reported ack segment size in chars.
  *
  * @return Status of the function call.
  */
 PUBLIC_API STATUS kinesisVideoStreamParseFragmentAck(STREAM_HANDLE,
+                                                     UPLOAD_HANDLE,
                                                      PCHAR,
                                                      UINT32);
 

kinesis-video-pic/src/client/include/com/amazonaws/kinesis/video/client/Include.h

@@ -18,14 +18,16 @@ STATUS resetAckParserState(PKinesisVideoStream pKinesisVideoStream) {
     pKinesisVideoStream->fragmentAckParser.curKeyName = FRAGMENT_ACK_KEY_NAME_UNKNOWN;
     pKinesisVideoStream->fragmentAckParser.fragmentAck.result = SERVICE_CALL_RESULT_OK;
     pKinesisVideoStream->fragmentAckParser.fragmentAck.version = FRAGMENT_ACK_CURRENT_VERSION;
+    pKinesisVideoStream->fragmentAckParser.uploadHandle = INVALID_UPLOAD_HANDLE_VALUE;
+    pKinesisVideoStream->fragmentAckParser.fragmentAck.timestamp = INVALID_TIMESTAMP_VALUE;
 
 CleanUp:
 
     LEAVES();
     return retStatus;
 }
 
-STATUS parseFragmentAck(PKinesisVideoStream pKinesisVideoStream, PCHAR ackSegment, UINT32 ackSegmentSize) {
+STATUS parseFragmentAck(PKinesisVideoStream pKinesisVideoStream, UPLOAD_HANDLE uploadHandle, PCHAR ackSegment, UINT32 ackSegmentSize) {
     ENTERS();
     STATUS retStatus = STATUS_SUCCESS;
     UINT32 index = 0;
@@ -41,6 +43,11 @@ STATUS parseFragmentAck(PKinesisVideoStream pKinesisVideoStream, PCHAR ackSegmen
         CHK(ackSegmentSize <= MAX_ACK_FRAGMENT_LEN, STATUS_INVALID_ACK_SEGMENT_LEN);
     }
 
+    // Set the upload handle
+    if (!IS_VALID_UPLOAD_HANDLE(pKinesisVideoStream->fragmentAckParser.uploadHandle)) {
+        pKinesisVideoStream->fragmentAckParser.uploadHandle = uploadHandle;
+    }
+
     for (index = 0; index < ackSegmentSize; index++) {
         curChar = ackSegment[index];
 
@@ -172,7 +179,7 @@ STATUS parseFragmentAck(PKinesisVideoStream pKinesisVideoStream, PCHAR ackSegmen
                     // Process the parsed ACK
                     CHK_STATUS(processParsedAck(pKinesisVideoStream));
                 } else if (curChar == ACK_PARSER_QUOTE
-                           || curChar == ACK_PARSER_OPEN_BRACKET
+                           || curChar == ACK_PARSER_OPEN_BRACE
                            || curChar == ACK_PARSER_OPEN_BRACKET
                            || curChar == ACK_PARSER_CLOSE_BRACKET
                            || curChar == ACK_PARSER_DELIMITER) {
@@ -259,7 +266,7 @@ STATUS processParsedAck(PKinesisVideoStream pKinesisVideoStream) {
     CHK_STATUS(validateParsedAck(&pKinesisVideoStream->fragmentAckParser));
 
     // Push the ACK
-    CHK_STATUS(streamFragmentAckEvent(pKinesisVideoStream, &pKinesisVideoStream->fragmentAckParser.fragmentAck));
+    CHK_STATUS(streamFragmentAckEvent(pKinesisVideoStream, pKinesisVideoStream->fragmentAckParser.uploadHandle, &pKinesisVideoStream->fragmentAckParser.fragmentAck));
 
     // Reset the parser state
     CHK_STATUS(resetAckParserState(pKinesisVideoStream));

kinesis-video-pic/src/client/src/AckParser.cpp

@@ -111,6 +111,7 @@ typedef enum {
 typedef struct __FragmentAckParser FragmentAckParser;
 struct __FragmentAckParser {
     FRAGMENT_ACK_PARSER_STATE state;
+    UPLOAD_HANDLE uploadHandle;
     FragmentAck fragmentAck;
     FRAGMENT_ACK_KEY_NAME curKeyName;
     UINT32 curPos;
@@ -136,12 +137,13 @@ STATUS resetAckParserState(PKinesisVideoStream);
  * Parses the consecutive ACK fragment, assembles the ACK and calls the ACK consumption on success.
  *
  * @param 1 PKinesisVideoStream - Kinesis Video stream to use
- * @param 2 PCHAR - current chunk to parse
- * @param 3 UINT32 - chunk size. If 0 is specified then the size will be till the NULL terminator.
+ * @param 2 UPLOAD_HANDLE - Stream upload handle.
+ * @param 3 PCHAR - current chunk to parse
+ * @param 4 UINT32 - chunk size. If 0 is specified then the size will be till the NULL terminator.
  *
  * @return STATUS of the operation
  */
-STATUS parseFragmentAck(PKinesisVideoStream, PCHAR, UINT32);
+STATUS parseFragmentAck(PKinesisVideoStream, UPLOAD_HANDLE, PCHAR, UINT32);
 
 /**
  * Tries to match a string to an ACK type. Returns Unknown if can't extract the type.

kinesis-video-pic/src/client/src/AckParser.h

@@ -81,10 +81,11 @@ STATUS defaultStreamReady(UINT64 customData, STREAM_HANDLE streamHandle)
 /**
  * Default end of stream callback functionality - NOOP
  */
-STATUS defaultEndOfStream(UINT64 customData, STREAM_HANDLE streamHandle)
+STATUS defaultEndOfStream(UINT64 customData, STREAM_HANDLE streamHandle, UINT64 streamUploadHandle)
 {
     UNUSED_PARAM(customData);
     UNUSED_PARAM(streamHandle);
+    UNUSED_PARAM(streamUploadHandle);
     return STATUS_SUCCESS;
 }