| The MKV timecode scale in milliseconds, which specifies the granularity of the timecodes for the frames within the MKV cluster. The MKV frame timecode is always relative to the start of the cluster. MKV uses a signed 16-bit value (0-32767) to represent the timecode within the cluster (fragment). Verify that the frame timecode can be represented with the given timecode scale. The default timecode scale value of 1 ms ensures that the largest frame that can be represented is 32767 ms \~= 32 seconds. This is over the maximum fragment duration that is specified in [Amazon Kinesis Video Streams service quotas](limits.md), which is 10 seconds. | 1 |
| key\_frame\_fragmentation | bool | Whether to produce fragments on a key frame. If true, the SDK produces a start of the fragment every time there is a key frame. If false, Kinesis Video Streams waits for at least fragment\_duration and produces a new fragment on the key frame following it. | true |
| frame\_timecodes | bool | Whether to use frame timecodes or generate timestamps using the current time callback. Many encoders don't produce timestamps with the frames. So specifying false for this parameter ensures that the frames are timestamped as they are put into Kinesis Video Streams. | true |
| absolute\_fragment\_times | bool | Kinesis Video Streams uses MKV as its underlying packaging mechanism. The MKV specification is strict about frame timecodes being relative to the beginning of the cluster (fragment). However, the cluster timecodes can be either absolute or relative to the starting time for the stream. If the timestamps are relative, the PutMedia service API call uses the optional stream start timestamp and adjust the cluster timestamps. The service always stores the fragments with their absolute timestamps. | true |
| fragment\_acks | bool | Whether to receive application level fragment ACKs (acknowledgements). | true, meaning that the SDK will receive the ACKs and act accordingly. |
| restart\_on\_error | bool | Whether to restart on specific errors. | true, meaning that the SDK tries to restart the streaming if any errors occur. |
| recalculate\_metrics | bool | Whether to recalculate the metrics. Each call to retrieve the metrics can recalculate those to get the latest "running" value, which might create a small CPU impact. You might need to set this to false on extremely low-power/footprint devices to spare the CPU cycles. Otherwise, we don't recommend using false for this value. | true |
| nal\_adaptation\_flags | uint32\_t | Specifies the Network Abstraction Layer unit (NALU) adaptation flags. If the bitstream is H.264 encoded, it can then be processed as raw or packaged in NALUs. Those are either in the Annex-B or AVCC format. Most of the elementary stream producers and consumers (read encoders and decoders) use the Annex-B format because it has advantages, such as error recovery. Higher-level systems use the AVCC format, which is the default format for MPEG, HLS, DASH, and so on. The console playback uses the browser's MSE (media source extensions) to decode and play back the stream that uses the AVCC format. For H.264 (and for M-JPEG and H.265), the SDK provides adaptation capabilities.
Many elementary streams are in the following format. In this example, `Ab` is the Annex-B start code (001 or 0001).Ab(Sps)Ab(Pps)Ab(I-frame)Ab(P/B-frame) Ab(P/B-frame)…. Ab(Sps)Ab(Pps)Ab(I-frame)Ab(P/B-frame) Ab(P/B-frame)
In the case of H.264, the codec private data (CPD) is in the SPS (sequence parameter set) and PPS (picture parameter set) parameters, and can be adapted to the AVCC format. Unless the media pipeline gives the CPD separately, the application can extract the CPD from the frame. It can do this by looking for the first IDR frame (which should contain the SPS and PPS), extract the two NALUs (which are `Ab(Sps)Ab(Pps)`), and set it in the CPD in `StreamDefinition`.
For more information, see [Network Abstraction Layer (NAL) adaptation flag reference](producer-reference-nal.md). | The default is to adapt Annex-B format to AVCC format for both the frame data and for the codec private data. |
| frame\_rate | uint32\_t | The expected frame rate. This value is used to better calculate buffering needs. | 25 |
| avg\_bandwidth\_bps | uint32\_t | The expected average bandwidth for the stream. This value is used to better calculate buffering needs. | 4 \* 1024 \* 1024 |
| buffer\_duration | duration | The stream buffer duration, in seconds. The SDK keeps the frames in the content store for up to the buffer\_duration, after which the previous frames are dropped as the window moves forward. If the frame that's being dropped hasn't been sent to the backend, the dropped frame callback is called. If the current buffer duration is greater than max\_latency, then the stream latency pressure callback is called. The buffer is trimmed to the next fragment start when the fragment persisted ACK is received. This indicates that the content has been durably persisted in the cloud, so storing the content on the local device is no longer needed. | 120 |
| replay\_duration | duration | The duration, in seconds, to roll the current reader backward to replay during an error if restarting is enabled. The rollback stops at the buffer start (in case it has just started streaming or the persisted ACK has come along). The rollback tries to land on a key frame that indicates a fragment start. If the error that ' causing the restart isn't indicative of a dead host (the host is still alive and contains the frame data in its internal buffers), the rollback stops at the last received ACK frame. It then rolls forward to the next key frame, because the entire fragment is already stored in the host memory. | 40 |
| connection\_staleness | duration | The time, in seconds, after which the stream staleness callback is called if the SDK doesn't receive the buffering ACK. It indicates that the frames are being sent from the device, but the backend isn't acknowledging them. This condition indicates a severed connection at the intermediate hop or at the load balancer. | 30 |
| codec\_id | string | The codec ID for the MKV track. | V\_MPEG4/ISO/AVC |
| track\_name | string | The MKV track name. | kinesis\_video |
| codecPrivateData | unsigned char\* | The codec private data (CPD) buffer. If the media pipeline has the information about the CPD before the stream starts, it can be set in StreamDefinition.codecPrivateData. The bits are copied, and the buffer can be reused or freed after the call to create the stream. However, if the data isn't available when the stream is created, it can be set in one of the overloads of the KinesisVideoStream.start(cpd) function. | null |
| codecPrivateDataSize | uint32\_t | The codec private data buffer size. | 0 |
## ClientMetrics
The **ClientMetrics** object is filled by calling `getKinesisVideoMetrics`.
### Member fields
****
| Field | Data type | Description |
| --- | --- | --- |
| version | UINT32 | The version of the structure, defined in the CLIENT\_METRICS\_CURRENT\_VERSION macro. |
| contentStoreSize | UINT64 | The overall content store size in bytes. This is the value specified in DeviceInfo.StorageInfo.storageSize. |
| contentStoreAvailableSize | UINT64 | Current available storage size in bytes. |
| contentStoreAllocatedSize | UINT64 | Current allocated size. The allocated plus the available sizes should be slightly smaller than the overall storage size, due to the internal bookkeeping and the implementation of the content store. |
| totalContentViewsSize | UINT64 | The size of the memory allocated for all content views for all streams. This isn't counted against the storage size. This memory is allocated using the MEMALLOC macro, which can be overwritten to provide a custom allocator. |
| totalFrameRate | UINT64 | The total observed frame rate across all the streams. |
| totalTransferRate | UINT64 | The total observed stream rate in bytes per second across all the streams. |
## StreamMetrics
The **StreamMetrics** object is filled by calling `getKinesisVideoMetrics`.
### Member fields
****
| Field | Data type | Description |
| --- | --- | --- |
| version | UINT32 | The version of the structure, defined in the STREAM\_METRICS\_CURRENT\_VERSION macro. |
| currentViewDuration | UINT64 | The duration of the accumulated frames. In the fast networking case, this duration is either zero or the frame duration (as the frame is being transmitted). If the duration becomes longer than the max\_latency specified in the StreamDefinition, the stream latency callback is called if it's specified. The duration is specified in 100 ns units, which is the default time unit for the PIC layer. |
| overallViewDuration | UINT64 | The overall view duration. If the stream is configured with no ACKs or persistence, this value grows as the frames are put into the Kinesis video stream and becomes equal to the buffer\_duration in the StreamDefinition. When ACKs are enabled and the persisted ACK is received, the buffer is trimmed to the next key frame. This is because the ACK timestamp indicates the beginning of the entire fragment. The duration is specified in 100-ns units, which is the default time unit for the PIC layer. |
| currentViewSize | UINT64 | The size in bytes of the current buffer. |
| overallViewSize | UINT64 | The overall view size in bytes. |
| currentFrameRate | UINT64 | The observed frame rate for the current stream. |
| currentTransferRate | UINT64 | The observed transfer rate in bytes per second for the current stream. |