Add release note for v1.5.1

chehefen · chehefen · commit c7cc8503a004 · 2018-09-28T20:44:34.000Z
Rename end of session tag
Adding limits for the number of metadata
diff --git a/README.md b/README.md
@@ -44,6 +44,10 @@ This library is licensed under the Amazon Software License.
 
 ----
 ### Release notes
+#### Release 1.5.1 (24th Aug 2018)
+* Fragment Metadata Support for Producer SDK
+* Add fallback frame rate to avoid negotiation issue on certain machines like macbook air
+
 #### Release 1.5.0 (24th Aug 2018)
 * Windows Support for Producer SDK
 * Intermittent producer support
diff --git a/kinesis-video-gst-demo/kinesis_video_gstreamer_sample_app.cpp b/kinesis-video-gst-demo/kinesis_video_gstreamer_sample_app.cpp
@@ -386,7 +386,7 @@ int gstreamer_init(int argc, char* argv[]) {
 
     /* init stream format */
     char stream_name[MAX_STREAM_NAME_LEN];
-    int width = 0, height = 0, framerate = 30, bitrateInKBPS = 512;
+    int width = 0, height = 0, framerate = 25, bitrateInKBPS = 512;
     for (int i = 1; i < argc; i++) {
         if (i < argc - 1) {
             if ((0 == STRCMPI(argv[i], "-w")) ||
@@ -521,12 +521,19 @@ int gstreamer_init(int argc, char* argv[]) {
     } else {
         vector<int> res_width = {640, 1280, 1920};
         vector<int> res_height = {480, 720, 1080};
+        vector<int> fps = {30, 25, 20};
         bool found_resolution = false;
         for (int i = 0; i < res_width.size(); i++) {
             width = res_width[i];
             height = res_height[i];
-            if (resolution_supported(src_caps, query_caps_raw, query_caps_h264, data, width, height, framerate)) {
-                found_resolution = true;
+            for (int j = 0; j < fps.size(); j++) {
+                framerate = fps[j];
+                if (resolution_supported(src_caps, query_caps_raw, query_caps_h264, data, width, height, framerate)) {
+                    found_resolution = true;
+                    break;
+                }
+            }
+            if (found_resolution) {
                 break;
             }
         }
diff --git a/kinesis-video-pic/src/client/include/com/amazonaws/kinesis/video/client/Include.h b/kinesis-video-pic/src/client/include/com/amazonaws/kinesis/video/client/Include.h
@@ -166,6 +166,10 @@ extern "C" {
 #define STATUS_INVALID_ACK_SEGMENT_LEN                                              STATUS_CLIENT_BASE + 0x00000071
 #define STATUS_AWAITING_PERSISTED_ACK                                               STATUS_CLIENT_BASE + 0x00000072
 #define STATUS_PERSISTED_ACK_TIMEOUT                                                STATUS_CLIENT_BASE + 0x00000073
+#define STATUS_MAX_FRAGMENT_METADATA_COUNT                                          STATUS_CLIENT_BASE + 0x00000074
+#define STATUS_ACK_ERR_FRAGMENT_METADATA_LIMIT_REACHED                              STATUS_CLIENT_BASE + 0x00000075
+#define STATUS_BLOCKING_PUT_INTERRUPTED_STREAM_TERMINATED                           STATUS_CLIENT_BASE + 0x00000076
+#define STATUS_INVALID_METADATA_NAME                                                STATUS_CLIENT_BASE + 0x00000077
 
 ////////////////////////////////////////////////////
 // Main defines
@@ -240,6 +244,11 @@ extern "C" {
  */
 #define MIN_RETENTION_PERIOD                     (1 * HUNDREDS_OF_NANOS_IN_AN_HOUR)
 
+/**
+ * Maximal size of the metadata queue for a fragment
+ */
+#define MAX_FRAGMENT_METADATA_COUNT              10
+
 /**
  * Max length of the fragment sequence number
  */
@@ -600,6 +609,9 @@ typedef enum {
     // Inactive stream
     SERVICE_CALL_RESULT_STREAM_NOT_ACTIVE = 4008,
 
+    // Fragment metadata name/value/count limit reached
+    SERVICE_CALL_RESULT_FRAGMENT_METADATA_LIMIT_REACHED = 4009,
+
     // KMS specific error - KMS access denied while encrypting data
     SERVICE_CALL_RESULT_KMS_KEY_ACCESS_DENIED = 4500,
 
diff --git a/kinesis-video-pic/src/client/src/AckParser.cpp b/kinesis-video-pic/src/client/src/AckParser.cpp
@@ -410,6 +410,7 @@ SERVICE_CALL_RESULT getAckErrorTypeFromErrorId(UINT64 errorId) {
         case SERVICE_CALL_RESULT_INVALID_MKV_DATA:
         case SERVICE_CALL_RESULT_INVALID_PRODUCER_TIMESTAMP:
         case SERVICE_CALL_RESULT_STREAM_NOT_ACTIVE:
+        case SERVICE_CALL_RESULT_FRAGMENT_METADATA_LIMIT_REACHED:
         case SERVICE_CALL_RESULT_KMS_KEY_ACCESS_DENIED:
         case SERVICE_CALL_RESULT_KMS_KEY_DISABLED:
         case SERVICE_CALL_RESULT_KMS_KEY_VALIDATION_ERROR:
diff --git a/kinesis-video-pic/src/client/src/Stream.cpp b/kinesis-video-pic/src/client/src/Stream.cpp
@@ -1119,7 +1119,7 @@ STATUS putFragmentMetadata(PKinesisVideoStream pKinesisVideoStream, PCHAR name,
     STATUS retStatus = STATUS_SUCCESS;
     PKinesisVideoClient pKinesisVideoClient = NULL;
     BOOL streamLocked = FALSE;
-    UINT32 packagedSize = 0, metadataNameSize, metadataValueSize;
+    UINT32 packagedSize = 0, metadataNameSize, metadataValueSize, metadataQueueSize;
     PSerializedMetadata pSerializedMetadata = NULL, pExistingSerializedMetadata;
     StackQueueIterator iterator;
     UINT64 data;
@@ -1147,6 +1147,10 @@ STATUS putFragmentMetadata(PKinesisVideoStream pKinesisVideoStream, PCHAR name,
                                            STREAM_STATE_STOPPED));
     }
 
+    // Validate if the customer is not attempting to add an internal metadata
+    CHK(0 != STRNCMP(AWS_INTERNAL_METADATA_PREFIX, name, (SIZEOF(AWS_INTERNAL_METADATA_PREFIX) - 1) / SIZEOF(CHAR)),
+        STATUS_INVALID_METADATA_NAME);
+
     // Check whether we are OK to package the metadata but do not package.
     CHK_STATUS(mkvgenGenerateTag(pKinesisVideoStream->pMkvGenerator,
                                  NULL,
@@ -1160,7 +1164,7 @@ STATUS putFragmentMetadata(PKinesisVideoStream pKinesisVideoStream, PCHAR name,
 
     // Check if the metadata exists in case of persistent metadata
     if (persistent) {
-        // Iterate linearly and find the first ready state handle
+        // Iterate linearly and see if we have a match with the name
         CHK_STATUS(stackQueueGetIterator(pKinesisVideoStream->pMetadataQueue, &iterator));
         while (IS_VALID_ITERATOR(iterator)) {
             CHK_STATUS(stackQueueIteratorGetItem(iterator, &data));
@@ -1188,6 +1192,10 @@ STATUS putFragmentMetadata(PKinesisVideoStream pKinesisVideoStream, PCHAR name,
         }
     }
 
+    // Ensure we don't have more than MAX size of the metadata queue
+    CHK_STATUS(stackQueueGetCount(pKinesisVideoStream->pMetadataQueue, &metadataQueueSize));
+    CHK(metadataQueueSize < MAX_FRAGMENT_METADATA_COUNT, STATUS_MAX_FRAGMENT_METADATA_COUNT);
+
     // Allocate and store the data in sized allocation.
     // NOTE: We add NULL terminator for both name and value
     pSerializedMetadata = (PSerializedMetadata) MEMALLOC((metadataNameSize + 1 + metadataValueSize + 1) * SIZEOF(CHAR) + SIZEOF(SerializedMetadata));
diff --git a/kinesis-video-pic/src/client/src/Stream.h b/kinesis-video-pic/src/client/src/Stream.h
@@ -71,7 +71,12 @@ typedef __FragmentAckParser* PFragmentAckParser;
 /**
  * End-of-stream metadata name
  */
-#define EOS_METADATA_NAME                    "aws:KVS_END_OF_SESSION"
+#define EOS_METADATA_NAME                    "AWS_KINESISVIDEO_END_OF_SESSION"
+
+/**
+ * Internal AWS metadata prefix
+ */
+#define AWS_INTERNAL_METADATA_PREFIX         "AWS"
 
 /**
  * Max packaged size for the EOS metadata including EOS metadata name len, max stream name + delta for packaging
diff --git a/kinesis-video-pic/src/client/src/StreamEvent.cpp b/kinesis-video-pic/src/client/src/StreamEvent.cpp
@@ -86,6 +86,8 @@ STATUS serviceCallResultCheck(SERVICE_CALL_RESULT callResult)
             return STATUS_ACK_ERR_INVALID_PRODUCER_TIMESTAMP;
         case SERVICE_CALL_RESULT_STREAM_NOT_ACTIVE:
             return STATUS_ACK_ERR_STREAM_NOT_ACTIVE;
+        case SERVICE_CALL_RESULT_FRAGMENT_METADATA_LIMIT_REACHED:
+            return STATUS_ACK_ERR_FRAGMENT_METADATA_LIMIT_REACHED;
         case SERVICE_CALL_RESULT_KMS_KEY_ACCESS_DENIED:
             return STATUS_ACK_ERR_KMS_KEY_ACCESS_DENIED;
         case SERVICE_CALL_RESULT_KMS_KEY_DISABLED:
diff --git a/kinesis-video-pic/src/client/tst/ClientTestFixture.h b/kinesis-video-pic/src/client/tst/ClientTestFixture.h
@@ -10,7 +10,7 @@
 
 #define TEST_DEVICE_NAME                "Test device name"
 #define MAX_TEST_STREAM_COUNT           10
-#define TEST_DEVICE_STORAGE_SIZE        MIN_STORAGE_ALLOCATION_SIZE
+#define TEST_DEVICE_STORAGE_SIZE        ((UINT64) 10 * 1024 * 1024)
 
 #define TEST_CLIENT_MAGIC_NUMBER        0x1234567890ULL
 
diff --git a/kinesis-video-pic/src/client/tst/StreamApiTest.cpp b/kinesis-video-pic/src/client/tst/StreamApiTest.cpp
@@ -238,6 +238,95 @@ TEST_F(StreamApiTest, insertKinesisVideoTag_NULL_Invalid)
     EXPECT_NE(STATUS_SUCCESS, putKinesisVideoFragmentMetadata(mStreamHandle, "tagName", tagValue, FALSE));
     EXPECT_NE(STATUS_SUCCESS, putKinesisVideoFragmentMetadata(mStreamHandle, tagName, tagValue, TRUE));
     EXPECT_NE(STATUS_SUCCESS, putKinesisVideoFragmentMetadata(mStreamHandle, tagName, tagValue, FALSE));
+
+    // Validate the negative case with state
+    EXPECT_EQ(STATUS_INVALID_STREAM_STATE, putKinesisVideoFragmentMetadata(mStreamHandle, "tagName", "tagValue", TRUE));
+    EXPECT_EQ(STATUS_INVALID_STREAM_STATE, putKinesisVideoFragmentMetadata(mStreamHandle, "tagName", "tagValue", FALSE));
+}
+
+
+TEST_F(StreamApiTest, insertKinesisVideoTag_Invalid_Name)
+{
+    // Create and ready stream
+    ReadyStream();
+
+    EXPECT_EQ(STATUS_INVALID_METADATA_NAME, putKinesisVideoFragmentMetadata(mStreamHandle, "AWS", "Tag Value", FALSE));
+    EXPECT_EQ(STATUS_INVALID_METADATA_NAME, putKinesisVideoFragmentMetadata(mStreamHandle, "AWS", "Tag Value", TRUE));
+    EXPECT_EQ(STATUS_INVALID_METADATA_NAME, putKinesisVideoFragmentMetadata(mStreamHandle, "AWS ", "Tag Value", FALSE));
+    EXPECT_EQ(STATUS_INVALID_METADATA_NAME, putKinesisVideoFragmentMetadata(mStreamHandle, "AWS ", "Tag Value", TRUE));
+    EXPECT_EQ(STATUS_INVALID_METADATA_NAME, putKinesisVideoFragmentMetadata(mStreamHandle, "AWSTag", "Tag Value", FALSE));
+    EXPECT_EQ(STATUS_INVALID_METADATA_NAME, putKinesisVideoFragmentMetadata(mStreamHandle, "AWSTag", "Tag Value", TRUE));
+    EXPECT_EQ(STATUS_INVALID_METADATA_NAME, putKinesisVideoFragmentMetadata(mStreamHandle, "AWS:", "Tag Value", FALSE));
+    EXPECT_EQ(STATUS_INVALID_METADATA_NAME, putKinesisVideoFragmentMetadata(mStreamHandle, "AWS:", "Tag Value", TRUE));
+
+    EXPECT_EQ(STATUS_SUCCESS, putKinesisVideoFragmentMetadata(mStreamHandle, "aWS", "Tag Value", FALSE));
+    EXPECT_EQ(STATUS_SUCCESS, putKinesisVideoFragmentMetadata(mStreamHandle, "aWS", "Tag Value", TRUE));
+    EXPECT_EQ(STATUS_SUCCESS, putKinesisVideoFragmentMetadata(mStreamHandle, "aws", "Tag Value", FALSE));
+    EXPECT_EQ(STATUS_SUCCESS, putKinesisVideoFragmentMetadata(mStreamHandle, "aws", "Tag Value", TRUE));
+}
+
+TEST_F(StreamApiTest, insertKinesisVideoTag_Stream_State_Error) {
+    // Create the stream which is not yet in ready state
+    CreateStream();
+
+    // Should throw stream state error
+    EXPECT_EQ(STATUS_INVALID_STREAM_STATE, putKinesisVideoFragmentMetadata(mStreamHandle, "tagName", "tagValue", TRUE));
+    EXPECT_EQ(STATUS_INVALID_STREAM_STATE, putKinesisVideoFragmentMetadata(mStreamHandle, "tagName", "tagValue", FALSE));
+}
+
+TEST_F(StreamApiTest, insertKinesisVideoTag_Non_Persistent_Count) {
+    UINT32 i;
+    CHAR tagName[MKV_MAX_TAG_NAME_LEN + 1];
+    CHAR tagValue[MKV_MAX_TAG_VALUE_LEN + 1];
+
+    // Create and ready a stream
+    ReadyStream();
+
+    for (i = 0; i < MAX_FRAGMENT_METADATA_COUNT; i++) {
+        SPRINTF(tagName, "tagName_%d", i);
+        SPRINTF(tagValue, "tagValue_%d", i);
+        EXPECT_EQ(STATUS_SUCCESS, putKinesisVideoFragmentMetadata(mStreamHandle, tagName, tagValue, FALSE));
+    }
+
+    // Adding one more will cause a limit error
+    EXPECT_EQ(STATUS_MAX_FRAGMENT_METADATA_COUNT, putKinesisVideoFragmentMetadata(mStreamHandle, "tagName", "tagValue", FALSE));
+}
+
+TEST_F(StreamApiTest, insertKinesisVideoTag_Persistent_Count) {
+    UINT32 i;
+    CHAR tagName[MKV_MAX_TAG_NAME_LEN + 1];
+    CHAR tagValue[MKV_MAX_TAG_VALUE_LEN + 1];
+
+    // Create and ready a stream
+    ReadyStream();
+
+    for (i = 0; i < MAX_FRAGMENT_METADATA_COUNT; i++) {
+        SPRINTF(tagName, "tagName_%d", i);
+        SPRINTF(tagValue, "tagValue_%d", i);
+        EXPECT_EQ(STATUS_SUCCESS, putKinesisVideoFragmentMetadata(mStreamHandle, tagName, tagValue, TRUE));
+    }
+
+    // Adding one more will cause a limit error
+    EXPECT_EQ(STATUS_MAX_FRAGMENT_METADATA_COUNT, putKinesisVideoFragmentMetadata(mStreamHandle, "tagName", "tagValue", TRUE));
+}
+
+TEST_F(StreamApiTest, insertKinesisVideoTag_Mixed_Count) {
+    UINT32 i;
+    CHAR tagName[MKV_MAX_TAG_NAME_LEN + 1];
+    CHAR tagValue[MKV_MAX_TAG_VALUE_LEN + 1];
+
+    // Create and ready a stream
+    ReadyStream();
+
+    for (i = 0; i < MAX_FRAGMENT_METADATA_COUNT; i++) {
+        SPRINTF(tagName, "tagName_%d", i);
+        SPRINTF(tagValue, "tagValue_%d", i);
+        EXPECT_EQ(STATUS_SUCCESS, putKinesisVideoFragmentMetadata(mStreamHandle, tagName, tagValue, i % 2 == 0));
+    }
+
+    // Adding one more will cause a limit error
+    EXPECT_EQ(STATUS_MAX_FRAGMENT_METADATA_COUNT, putKinesisVideoFragmentMetadata(mStreamHandle, "tagName", "tagValue", TRUE));
+    EXPECT_EQ(STATUS_MAX_FRAGMENT_METADATA_COUNT, putKinesisVideoFragmentMetadata(mStreamHandle, "tagName", "tagValue", FALSE));
 }
 
 TEST_F(StreamApiTest, kinesisVideoGetData_NULL_Invalid)
diff --git a/kinesis-video-pic/src/client/tst/StreamPutGetTest.cpp b/kinesis-video-pic/src/client/tst/StreamPutGetTest.cpp
diff --git a/kinesis-video-pic/src/heap/include/com/amazonaws/kinesis/video/heap/Include.h b/kinesis-video-pic/src/heap/include/com/amazonaws/kinesis/video/heap/Include.h
diff --git a/kinesis-video-pic/src/heap/tst/HeapApiFunctionalityTest.cpp b/kinesis-video-pic/src/heap/tst/HeapApiFunctionalityTest.cpp
diff --git a/kinesis-video-pic/src/mkvgen/include/com/amazonaws/kinesis/video/mkvgen/Include.h b/kinesis-video-pic/src/mkvgen/include/com/amazonaws/kinesis/video/mkvgen/Include.h
