github/chiaki
1
0
Fork 0
mirror of https://git.sr.ht/~thestr4ng3r/chiaki synced 2025-08-20 05:23:12 -07:00
Code Issues Projects Releases Packages Wiki Activity Actions

Add Takion V7 AV Parsing

Browse source
This commit is contained in:
Florian Märkl 2019-08-10 11:58:48 +02:00
commit c957ef690e
No known key found for this signature in database
GPG key ID: 125BC8A5A6A1E857
4 changed files with 133 additions and 61 deletions
Download patch file Download diff file Expand all files Collapse all files

4
lib/include/chiaki/takion.h
View file

@ -224,10 +224,12 @@ CHIAKI_EXPORT ChiakiErrorCode chiaki_takion_send_feedback_state(ChiakiTakion *ta
*/ */
CHIAKI_EXPORT ChiakiErrorCode chiaki_takion_send_feedback_history(ChiakiTakion *takion, ChiakiSeqNum16 seq_num, uint8_t *payload, size_t payload_size); CHIAKI_EXPORT ChiakiErrorCode chiaki_takion_send_feedback_history(ChiakiTakion *takion, ChiakiSeqNum16 seq_num, uint8_t *payload, size_t payload_size);
CHIAKI_EXPORT ChiakiErrorCode chiaki_takion_v9_av_packet_parse(ChiakiTakionAVPacket *packet, uint8_t base_type, uint8_t *buf, size_t buf_size); CHIAKI_EXPORT ChiakiErrorCode chiaki_takion_v9_av_packet_parse(ChiakiTakionAVPacket *packet, uint8_t *buf, size_t buf_size);
CHIAKI_EXPORT ChiakiErrorCode chiaki_takion_v7_av_packet_format_header(uint8_t *buf, size_t buf_size, size_t *header_size_out, ChiakiTakionAVPacket *packet); CHIAKI_EXPORT ChiakiErrorCode chiaki_takion_v7_av_packet_format_header(uint8_t *buf, size_t buf_size, size_t *header_size_out, ChiakiTakionAVPacket *packet);
CHIAKI_EXPORT ChiakiErrorCode chiaki_takion_v7_av_packet_parse(ChiakiTakionAVPacket *packet, uint8_t *buf, size_t buf_size);
#ifdef __cplusplus #ifdef __cplusplus
} }
#endif #endif

94
lib/src/takion.c
View file

@ -1138,7 +1138,7 @@ static void takion_handle_packet_av(ChiakiTakion *takion, uint8_t base_type, uin
assert(base_type == TAKION_PACKET_TYPE_VIDEO || base_type == TAKION_PACKET_TYPE_AUDIO); assert(base_type == TAKION_PACKET_TYPE_VIDEO || base_type == TAKION_PACKET_TYPE_AUDIO);
ChiakiTakionAVPacket packet; ChiakiTakionAVPacket packet;
ChiakiErrorCode err = chiaki_takion_v9_av_packet_parse(&packet, base_type, buf, buf_size); ChiakiErrorCode err = chiaki_takion_v9_av_packet_parse(&packet, buf, buf_size);
if(err != CHIAKI_ERR_SUCCESS) if(err != CHIAKI_ERR_SUCCESS)
{ {
if(err == CHIAKI_ERR_BUF_TOO_SMALL) if(err == CHIAKI_ERR_BUF_TOO_SMALL)
@ -1158,18 +1158,21 @@ static void takion_handle_packet_av(ChiakiTakion *takion, uint8_t base_type, uin
#define CHIAKI_TAKION_V9_AV_HEADER_SIZE_VIDEO 0x17 #define CHIAKI_TAKION_V9_AV_HEADER_SIZE_VIDEO 0x17
#define CHIAKI_TAKION_V9_AV_HEADER_SIZE_AUDIO 0x12 #define CHIAKI_TAKION_V9_AV_HEADER_SIZE_AUDIO 0x12
CHIAKI_EXPORT ChiakiErrorCode chiaki_takion_v9_av_packet_parse(ChiakiTakionAVPacket *packet, uint8_t base_type, uint8_t *buf, size_t buf_size) CHIAKI_EXPORT ChiakiErrorCode chiaki_takion_v9_av_packet_parse(ChiakiTakionAVPacket *packet, uint8_t *buf, size_t buf_size)
{ {
memset(packet, 0, sizeof(ChiakiTakionAVPacket)); memset(packet, 0, sizeof(ChiakiTakionAVPacket));
if(base_type != TAKION_PACKET_TYPE_VIDEO && base_type != TAKION_PACKET_TYPE_AUDIO)
return CHIAKI_ERR_INVALID_DATA;
if(buf_size < 1) if(buf_size < 1)
return CHIAKI_ERR_BUF_TOO_SMALL; return CHIAKI_ERR_BUF_TOO_SMALL;
uint8_t base_type = buf[0] & TAKION_PACKET_BASE_TYPE_MASK;
if(base_type != TAKION_PACKET_TYPE_VIDEO && base_type != TAKION_PACKET_TYPE_AUDIO)
return CHIAKI_ERR_INVALID_DATA;
packet->is_video = base_type == TAKION_PACKET_TYPE_VIDEO; packet->is_video = base_type == TAKION_PACKET_TYPE_VIDEO;
packet->uses_nalu_info_structs = ((buf[0] >> 4) & 1) != 0; // TODO: is this really correct? packet->uses_nalu_info_structs = ((buf[0] >> 4) & 1) != 0;
uint8_t *av = buf+1; uint8_t *av = buf+1;
size_t av_size = buf_size-1; size_t av_size = buf_size-1;
@ -1200,15 +1203,21 @@ CHIAKI_EXPORT ChiakiErrorCode chiaki_takion_v9_av_packet_parse(ChiakiTakionAVPac
uint8_t unknown_1 = av[0x11]; uint8_t unknown_1 = av[0x11];
av += 0x12; av += 0x11;
av_size -= 0x12; av_size -= 0x11;
if(packet->is_video) if(packet->is_video)
{ {
packet->word_at_0x18 = ntohs(*((uint16_t *)(av + 0))); packet->word_at_0x18 = ntohs(*((uint16_t *)(av + 0)));
packet->adaptive_stream_index = av[1] >> 5; packet->adaptive_stream_index = av[2] >> 5;
av += 2; av += 3;
av_size -= 2; av_size -= 3;
}
else
{
av += 1;
av_size -= 1;
// unknown
} }
// TODO: parsing for uses_nalu_info_structs (before: packet.byte_at_0x1a) // TODO: parsing for uses_nalu_info_structs (before: packet.byte_at_0x1a)
@ -1270,15 +1279,76 @@ CHIAKI_EXPORT ChiakiErrorCode chiaki_takion_v7_av_packet_format_header(uint8_t *
if(packet->is_video) if(packet->is_video)
{ {
*(uint16_t *)cur = htons(packet->word_at_0x18); *(uint16_t *)cur = htons(packet->word_at_0x18);
cur[3] = packet->adaptive_stream_index << 5; cur[2] = packet->adaptive_stream_index << 5;
cur += 3; cur += 3;
} }
if(packet->uses_nalu_info_structs) if(packet->uses_nalu_info_structs)
{ {
*(uint16_t *)cur = 0; // unknown *(uint16_t *)cur = 0; // unknown
cur[3] = 0; // unknown cur[2] = 0; // unknown
} }
return CHIAKI_ERR_BUF_TOO_SMALL; return CHIAKI_ERR_BUF_TOO_SMALL;
} }
CHIAKI_EXPORT ChiakiErrorCode chiaki_takion_v7_av_packet_parse(ChiakiTakionAVPacket *packet, uint8_t *buf, size_t buf_size)
{
memset(packet, 0, sizeof(ChiakiTakionAVPacket));
if(buf_size < 1)
return CHIAKI_ERR_BUF_TOO_SMALL;
uint8_t base_type = buf[0] & TAKION_PACKET_BASE_TYPE_MASK;
if(base_type != TAKION_PACKET_TYPE_VIDEO && base_type != TAKION_PACKET_TYPE_AUDIO)
return CHIAKI_ERR_INVALID_DATA;
packet->is_video = base_type == TAKION_PACKET_TYPE_VIDEO;
packet->uses_nalu_info_structs = ((buf[0] >> 4) & 1) != 0;
size_t header_size = CHIAKI_TAKION_V7_AV_HEADER_SIZE_BASE;
if(packet->is_video)
header_size += CHIAKI_TAKION_V7_AV_HEADER_SIZE_VIDEO_ADD;
if(packet->uses_nalu_info_structs)
header_size += CHIAKI_TAKION_V7_AV_HEADER_SIZE_NALU_INFO_STRUCTS_ADD;
if(buf_size < header_size)
return CHIAKI_ERR_BUF_TOO_SMALL;
packet->packet_index = ntohs(*((uint16_t *)(buf + 1)));
packet->frame_index = ntohs(*((uint16_t *)(buf + 3)));
uint32_t dword_2 = ntohl(*((uint32_t *)(buf + 5)));
packet->unit_index = (uint16_t)((dword_2 >> 0x15) & 0x7ff);
packet->units_in_frame_total = (uint16_t)(((dword_2 >> 0xa) & 0x7ff) + 1);
packet->units_in_frame_fec = (uint16_t)(dword_2 & 0x3ff);
packet->codec = buf[9];
// unknown *(uint32_t *)(buf + 0xa)
packet->key_pos = ntohl(*((uint32_t *)(buf + 0xe)));
buf += 0x12;
buf_size -= 0x12;
if(packet->is_video)
{
packet->word_at_0x18 = ntohs(*((uint16_t *)(buf + 0)));
packet->adaptive_stream_index = buf[2] >> 5;
buf += 3;
buf_size -= 3;
}
if(packet->uses_nalu_info_structs)
{
buf += 3;
buf_size -= 3;
// unknown
}
packet->data = buf;
packet->data_size = buf_size;
return CHIAKI_ERR_SUCCESS;
}

2
test/takion.c
View file

@ -45,7 +45,7 @@ static MunitResult test_av_packet_parse(const MunitParameter params[], void *use
ChiakiTakionAVPacket av_packet; ChiakiTakionAVPacket av_packet;
ChiakiErrorCode err = chiaki_takion_av_packet_parse(&av_packet, 2, packet, sizeof(packet)); ChiakiErrorCode err = chiaki_takion_v9_av_packet_parse(&av_packet, packet, sizeof(packet));
munit_assert_int(err, ==, CHIAKI_ERR_SUCCESS); munit_assert_int(err, ==, CHIAKI_ERR_SUCCESS);
munit_assert(av_packet.is_video); munit_assert(av_packet.is_video);

48
test/takion_av_packet_parse_real_video.inl
View file

@ -17,7 +17,7 @@ uint8_t nalu_0[105]; size_t nalu_0_size = sizeof(nalu_0); if(chiaki_base64_decod
ChiakiTakionAVPacket av_packet_0; ChiakiTakionAVPacket av_packet_0;
memset(&av_packet_0, 0, sizeof(av_packet_0)); memset(&av_packet_0, 0, sizeof(av_packet_0));
chiaki_takion_av_packet_parse(&av_packet_0, 2, packet_0, sizeof(packet_0)); chiaki_takion_v9_av_packet_parse(&av_packet_0, packet_0, sizeof(packet_0));
munit_assert(av_packet_0.is_video); munit_assert(av_packet_0.is_video);
munit_assert_size(av_packet_0.data_size, ==, sizeof(nalu_0)); munit_assert_size(av_packet_0.data_size, ==, sizeof(nalu_0));
chiaki_gkcrypt_decrypt(&gkcrypt, av_packet_0.key_pos + CHIAKI_GKCRYPT_BLOCK_SIZE, av_packet_0.data, av_packet_0.data_size); chiaki_gkcrypt_decrypt(&gkcrypt, av_packet_0.key_pos + CHIAKI_GKCRYPT_BLOCK_SIZE, av_packet_0.data, av_packet_0.data_size);
@ -30,7 +30,7 @@ uint8_t nalu_1[108]; size_t nalu_1_size = sizeof(nalu_1); if(chiaki_base64_decod
ChiakiTakionAVPacket av_packet_1; ChiakiTakionAVPacket av_packet_1;
memset(&av_packet_1, 0, sizeof(av_packet_1)); memset(&av_packet_1, 0, sizeof(av_packet_1));
chiaki_takion_av_packet_parse(&av_packet_1, 2, packet_1, sizeof(packet_1)); chiaki_takion_v9_av_packet_parse(&av_packet_1, packet_1, sizeof(packet_1));
munit_assert(av_packet_1.is_video); munit_assert(av_packet_1.is_video);
munit_assert_size(av_packet_1.data_size, ==, sizeof(nalu_1)); munit_assert_size(av_packet_1.data_size, ==, sizeof(nalu_1));
chiaki_gkcrypt_decrypt(&gkcrypt, av_packet_1.key_pos + CHIAKI_GKCRYPT_BLOCK_SIZE, av_packet_1.data, av_packet_1.data_size); chiaki_gkcrypt_decrypt(&gkcrypt, av_packet_1.key_pos + CHIAKI_GKCRYPT_BLOCK_SIZE, av_packet_1.data, av_packet_1.data_size);
@ -43,7 +43,7 @@ uint8_t nalu_2[1400]; size_t nalu_2_size = sizeof(nalu_2); if(chiaki_base64_deco
ChiakiTakionAVPacket av_packet_2; ChiakiTakionAVPacket av_packet_2;
memset(&av_packet_2, 0, sizeof(av_packet_2)); memset(&av_packet_2, 0, sizeof(av_packet_2));
chiaki_takion_av_packet_parse(&av_packet_2, 2, packet_2, sizeof(packet_2)); chiaki_takion_v9_av_packet_parse(&av_packet_2, packet_2, sizeof(packet_2));
munit_assert(av_packet_2.is_video); munit_assert(av_packet_2.is_video);
munit_assert_size(av_packet_2.data_size, ==, sizeof(nalu_2)); munit_assert_size(av_packet_2.data_size, ==, sizeof(nalu_2));
chiaki_gkcrypt_decrypt(&gkcrypt, av_packet_2.key_pos + CHIAKI_GKCRYPT_BLOCK_SIZE, av_packet_2.data, av_packet_2.data_size); chiaki_gkcrypt_decrypt(&gkcrypt, av_packet_2.key_pos + CHIAKI_GKCRYPT_BLOCK_SIZE, av_packet_2.data, av_packet_2.data_size);
@ -56,7 +56,7 @@ uint8_t nalu_3[12]; size_t nalu_3_size = sizeof(nalu_3); if(chiaki_base64_decode
ChiakiTakionAVPacket av_packet_3; ChiakiTakionAVPacket av_packet_3;
memset(&av_packet_3, 0, sizeof(av_packet_3)); memset(&av_packet_3, 0, sizeof(av_packet_3));
chiaki_takion_av_packet_parse(&av_packet_3, 2, packet_3, sizeof(packet_3)); chiaki_takion_v9_av_packet_parse(&av_packet_3, packet_3, sizeof(packet_3));
munit_assert(av_packet_3.is_video); munit_assert(av_packet_3.is_video);
munit_assert_size(av_packet_3.data_size, ==, sizeof(nalu_3)); munit_assert_size(av_packet_3.data_size, ==, sizeof(nalu_3));
chiaki_gkcrypt_decrypt(&gkcrypt, av_packet_3.key_pos + CHIAKI_GKCRYPT_BLOCK_SIZE, av_packet_3.data, av_packet_3.data_size); chiaki_gkcrypt_decrypt(&gkcrypt, av_packet_3.key_pos + CHIAKI_GKCRYPT_BLOCK_SIZE, av_packet_3.data, av_packet_3.data_size);
@ -69,7 +69,7 @@ uint8_t nalu_4[1400]; size_t nalu_4_size = sizeof(nalu_4); if(chiaki_base64_deco
ChiakiTakionAVPacket av_packet_4; ChiakiTakionAVPacket av_packet_4;
memset(&av_packet_4, 0, sizeof(av_packet_4)); memset(&av_packet_4, 0, sizeof(av_packet_4));
chiaki_takion_av_packet_parse(&av_packet_4, 2, packet_4, sizeof(packet_4)); chiaki_takion_v9_av_packet_parse(&av_packet_4, packet_4, sizeof(packet_4));
munit_assert(av_packet_4.is_video); munit_assert(av_packet_4.is_video);
munit_assert_size(av_packet_4.data_size, ==, sizeof(nalu_4)); munit_assert_size(av_packet_4.data_size, ==, sizeof(nalu_4));
chiaki_gkcrypt_decrypt(&gkcrypt, av_packet_4.key_pos + CHIAKI_GKCRYPT_BLOCK_SIZE, av_packet_4.data, av_packet_4.data_size); chiaki_gkcrypt_decrypt(&gkcrypt, av_packet_4.key_pos + CHIAKI_GKCRYPT_BLOCK_SIZE, av_packet_4.data, av_packet_4.data_size);
@ -82,7 +82,7 @@ uint8_t nalu_5[139]; size_t nalu_5_size = sizeof(nalu_5); if(chiaki_base64_decod
ChiakiTakionAVPacket av_packet_5; ChiakiTakionAVPacket av_packet_5;
memset(&av_packet_5, 0, sizeof(av_packet_5)); memset(&av_packet_5, 0, sizeof(av_packet_5));
chiaki_takion_av_packet_parse(&av_packet_5, 2, packet_5, sizeof(packet_5)); chiaki_takion_v9_av_packet_parse(&av_packet_5, packet_5, sizeof(packet_5));
munit_assert(av_packet_5.is_video); munit_assert(av_packet_5.is_video);
munit_assert_size(av_packet_5.data_size, ==, sizeof(nalu_5)); munit_assert_size(av_packet_5.data_size, ==, sizeof(nalu_5));
chiaki_gkcrypt_decrypt(&gkcrypt, av_packet_5.key_pos + CHIAKI_GKCRYPT_BLOCK_SIZE, av_packet_5.data, av_packet_5.data_size); chiaki_gkcrypt_decrypt(&gkcrypt, av_packet_5.key_pos + CHIAKI_GKCRYPT_BLOCK_SIZE, av_packet_5.data, av_packet_5.data_size);
@ -95,7 +95,7 @@ uint8_t nalu_6[1339]; size_t nalu_6_size = sizeof(nalu_6); if(chiaki_base64_deco
ChiakiTakionAVPacket av_packet_6; ChiakiTakionAVPacket av_packet_6;
memset(&av_packet_6, 0, sizeof(av_packet_6)); memset(&av_packet_6, 0, sizeof(av_packet_6));
chiaki_takion_av_packet_parse(&av_packet_6, 2, packet_6, sizeof(packet_6)); chiaki_takion_v9_av_packet_parse(&av_packet_6, packet_6, sizeof(packet_6));
munit_assert(av_packet_6.is_video); munit_assert(av_packet_6.is_video);
munit_assert_size(av_packet_6.data_size, ==, sizeof(nalu_6)); munit_assert_size(av_packet_6.data_size, ==, sizeof(nalu_6));
chiaki_gkcrypt_decrypt(&gkcrypt, av_packet_6.key_pos + CHIAKI_GKCRYPT_BLOCK_SIZE, av_packet_6.data, av_packet_6.data_size); chiaki_gkcrypt_decrypt(&gkcrypt, av_packet_6.key_pos + CHIAKI_GKCRYPT_BLOCK_SIZE, av_packet_6.data, av_packet_6.data_size);
@ -108,7 +108,7 @@ uint8_t nalu_7[1400]; size_t nalu_7_size = sizeof(nalu_7); if(chiaki_base64_deco
ChiakiTakionAVPacket av_packet_7; ChiakiTakionAVPacket av_packet_7;
memset(&av_packet_7, 0, sizeof(av_packet_7)); memset(&av_packet_7, 0, sizeof(av_packet_7));
chiaki_takion_av_packet_parse(&av_packet_7, 2, packet_7, sizeof(packet_7)); chiaki_takion_v9_av_packet_parse(&av_packet_7, packet_7, sizeof(packet_7));
munit_assert(av_packet_7.is_video); munit_assert(av_packet_7.is_video);
munit_assert_size(av_packet_7.data_size, ==, sizeof(nalu_7)); munit_assert_size(av_packet_7.data_size, ==, sizeof(nalu_7));
chiaki_gkcrypt_decrypt(&gkcrypt, av_packet_7.key_pos + CHIAKI_GKCRYPT_BLOCK_SIZE, av_packet_7.data, av_packet_7.data_size); chiaki_gkcrypt_decrypt(&gkcrypt, av_packet_7.key_pos + CHIAKI_GKCRYPT_BLOCK_SIZE, av_packet_7.data, av_packet_7.data_size);
@ -121,7 +121,7 @@ uint8_t nalu_8[172]; size_t nalu_8_size = sizeof(nalu_8); if(chiaki_base64_decod
ChiakiTakionAVPacket av_packet_8; ChiakiTakionAVPacket av_packet_8;
memset(&av_packet_8, 0, sizeof(av_packet_8)); memset(&av_packet_8, 0, sizeof(av_packet_8));
chiaki_takion_av_packet_parse(&av_packet_8, 2, packet_8, sizeof(packet_8)); chiaki_takion_v9_av_packet_parse(&av_packet_8, packet_8, sizeof(packet_8));
munit_assert(av_packet_8.is_video); munit_assert(av_packet_8.is_video);
munit_assert_size(av_packet_8.data_size, ==, sizeof(nalu_8)); munit_assert_size(av_packet_8.data_size, ==, sizeof(nalu_8));
chiaki_gkcrypt_decrypt(&gkcrypt, av_packet_8.key_pos + CHIAKI_GKCRYPT_BLOCK_SIZE, av_packet_8.data, av_packet_8.data_size); chiaki_gkcrypt_decrypt(&gkcrypt, av_packet_8.key_pos + CHIAKI_GKCRYPT_BLOCK_SIZE, av_packet_8.data, av_packet_8.data_size);
@ -134,7 +134,7 @@ uint8_t nalu_9[1351]; size_t nalu_9_size = sizeof(nalu_9); if(chiaki_base64_deco
ChiakiTakionAVPacket av_packet_9; ChiakiTakionAVPacket av_packet_9;
memset(&av_packet_9, 0, sizeof(av_packet_9)); memset(&av_packet_9, 0, sizeof(av_packet_9));
chiaki_takion_av_packet_parse(&av_packet_9, 2, packet_9, sizeof(packet_9)); chiaki_takion_v9_av_packet_parse(&av_packet_9, packet_9, sizeof(packet_9));
munit_assert(av_packet_9.is_video); munit_assert(av_packet_9.is_video);
munit_assert_size(av_packet_9.data_size, ==, sizeof(nalu_9)); munit_assert_size(av_packet_9.data_size, ==, sizeof(nalu_9));
chiaki_gkcrypt_decrypt(&gkcrypt, av_packet_9.key_pos + CHIAKI_GKCRYPT_BLOCK_SIZE, av_packet_9.data, av_packet_9.data_size); chiaki_gkcrypt_decrypt(&gkcrypt, av_packet_9.key_pos + CHIAKI_GKCRYPT_BLOCK_SIZE, av_packet_9.data, av_packet_9.data_size);
@ -147,7 +147,7 @@ uint8_t nalu_10[1400]; size_t nalu_10_size = sizeof(nalu_10); if(chiaki_base64_d
ChiakiTakionAVPacket av_packet_10; ChiakiTakionAVPacket av_packet_10;
memset(&av_packet_10, 0, sizeof(av_packet_10)); memset(&av_packet_10, 0, sizeof(av_packet_10));
chiaki_takion_av_packet_parse(&av_packet_10, 2, packet_10, sizeof(packet_10)); chiaki_takion_v9_av_packet_parse(&av_packet_10, packet_10, sizeof(packet_10));
munit_assert(av_packet_10.is_video); munit_assert(av_packet_10.is_video);
munit_assert_size(av_packet_10.data_size, ==, sizeof(nalu_10)); munit_assert_size(av_packet_10.data_size, ==, sizeof(nalu_10));
chiaki_gkcrypt_decrypt(&gkcrypt, av_packet_10.key_pos + CHIAKI_GKCRYPT_BLOCK_SIZE, av_packet_10.data, av_packet_10.data_size); chiaki_gkcrypt_decrypt(&gkcrypt, av_packet_10.key_pos + CHIAKI_GKCRYPT_BLOCK_SIZE, av_packet_10.data, av_packet_10.data_size);
@ -160,7 +160,7 @@ uint8_t nalu_11[11]; size_t nalu_11_size = sizeof(nalu_11); if(chiaki_base64_dec
ChiakiTakionAVPacket av_packet_11; ChiakiTakionAVPacket av_packet_11;
memset(&av_packet_11, 0, sizeof(av_packet_11)); memset(&av_packet_11, 0, sizeof(av_packet_11));
chiaki_takion_av_packet_parse(&av_packet_11, 2, packet_11, sizeof(packet_11)); chiaki_takion_v9_av_packet_parse(&av_packet_11, packet_11, sizeof(packet_11));
munit_assert(av_packet_11.is_video); munit_assert(av_packet_11.is_video);
munit_assert_size(av_packet_11.data_size, ==, sizeof(nalu_11)); munit_assert_size(av_packet_11.data_size, ==, sizeof(nalu_11));
chiaki_gkcrypt_decrypt(&gkcrypt, av_packet_11.key_pos + CHIAKI_GKCRYPT_BLOCK_SIZE, av_packet_11.data, av_packet_11.data_size); chiaki_gkcrypt_decrypt(&gkcrypt, av_packet_11.key_pos + CHIAKI_GKCRYPT_BLOCK_SIZE, av_packet_11.data, av_packet_11.data_size);
@ -173,7 +173,7 @@ uint8_t nalu_12[1400]; size_t nalu_12_size = sizeof(nalu_12); if(chiaki_base64_d
ChiakiTakionAVPacket av_packet_12; ChiakiTakionAVPacket av_packet_12;
memset(&av_packet_12, 0, sizeof(av_packet_12)); memset(&av_packet_12, 0, sizeof(av_packet_12));
chiaki_takion_av_packet_parse(&av_packet_12, 2, packet_12, sizeof(packet_12)); chiaki_takion_v9_av_packet_parse(&av_packet_12, packet_12, sizeof(packet_12));
munit_assert(av_packet_12.is_video); munit_assert(av_packet_12.is_video);
munit_assert_size(av_packet_12.data_size, ==, sizeof(nalu_12)); munit_assert_size(av_packet_12.data_size, ==, sizeof(nalu_12));
chiaki_gkcrypt_decrypt(&gkcrypt, av_packet_12.key_pos + CHIAKI_GKCRYPT_BLOCK_SIZE, av_packet_12.data, av_packet_12.data_size); chiaki_gkcrypt_decrypt(&gkcrypt, av_packet_12.key_pos + CHIAKI_GKCRYPT_BLOCK_SIZE, av_packet_12.data, av_packet_12.data_size);
@ -186,7 +186,7 @@ uint8_t nalu_13[10]; size_t nalu_13_size = sizeof(nalu_13); if(chiaki_base64_dec
ChiakiTakionAVPacket av_packet_13; ChiakiTakionAVPacket av_packet_13;
memset(&av_packet_13, 0, sizeof(av_packet_13)); memset(&av_packet_13, 0, sizeof(av_packet_13));
chiaki_takion_av_packet_parse(&av_packet_13, 2, packet_13, sizeof(packet_13)); chiaki_takion_v9_av_packet_parse(&av_packet_13, packet_13, sizeof(packet_13));
munit_assert(av_packet_13.is_video); munit_assert(av_packet_13.is_video);
munit_assert_size(av_packet_13.data_size, ==, sizeof(nalu_13)); munit_assert_size(av_packet_13.data_size, ==, sizeof(nalu_13));
chiaki_gkcrypt_decrypt(&gkcrypt, av_packet_13.key_pos + CHIAKI_GKCRYPT_BLOCK_SIZE, av_packet_13.data, av_packet_13.data_size); chiaki_gkcrypt_decrypt(&gkcrypt, av_packet_13.key_pos + CHIAKI_GKCRYPT_BLOCK_SIZE, av_packet_13.data, av_packet_13.data_size);
@ -199,7 +199,7 @@ uint8_t nalu_14[1378]; size_t nalu_14_size = sizeof(nalu_14); if(chiaki_base64_d
ChiakiTakionAVPacket av_packet_14; ChiakiTakionAVPacket av_packet_14;
memset(&av_packet_14, 0, sizeof(av_packet_14)); memset(&av_packet_14, 0, sizeof(av_packet_14));
chiaki_takion_av_packet_parse(&av_packet_14, 2, packet_14, sizeof(packet_14)); chiaki_takion_v9_av_packet_parse(&av_packet_14, packet_14, sizeof(packet_14));
munit_assert(av_packet_14.is_video); munit_assert(av_packet_14.is_video);
munit_assert_size(av_packet_14.data_size, ==, sizeof(nalu_14)); munit_assert_size(av_packet_14.data_size, ==, sizeof(nalu_14));
chiaki_gkcrypt_decrypt(&gkcrypt, av_packet_14.key_pos + CHIAKI_GKCRYPT_BLOCK_SIZE, av_packet_14.data, av_packet_14.data_size); chiaki_gkcrypt_decrypt(&gkcrypt, av_packet_14.key_pos + CHIAKI_GKCRYPT_BLOCK_SIZE, av_packet_14.data, av_packet_14.data_size);
@ -212,7 +212,7 @@ uint8_t nalu_15[1353]; size_t nalu_15_size = sizeof(nalu_15); if(chiaki_base64_d
ChiakiTakionAVPacket av_packet_15; ChiakiTakionAVPacket av_packet_15;
memset(&av_packet_15, 0, sizeof(av_packet_15)); memset(&av_packet_15, 0, sizeof(av_packet_15));
chiaki_takion_av_packet_parse(&av_packet_15, 2, packet_15, sizeof(packet_15)); chiaki_takion_v9_av_packet_parse(&av_packet_15, packet_15, sizeof(packet_15));
munit_assert(av_packet_15.is_video); munit_assert(av_packet_15.is_video);
munit_assert_size(av_packet_15.data_size, ==, sizeof(nalu_15)); munit_assert_size(av_packet_15.data_size, ==, sizeof(nalu_15));
chiaki_gkcrypt_decrypt(&gkcrypt, av_packet_15.key_pos + CHIAKI_GKCRYPT_BLOCK_SIZE, av_packet_15.data, av_packet_15.data_size); chiaki_gkcrypt_decrypt(&gkcrypt, av_packet_15.key_pos + CHIAKI_GKCRYPT_BLOCK_SIZE, av_packet_15.data, av_packet_15.data_size);
@ -225,7 +225,7 @@ uint8_t nalu_16[1332]; size_t nalu_16_size = sizeof(nalu_16); if(chiaki_base64_d
ChiakiTakionAVPacket av_packet_16; ChiakiTakionAVPacket av_packet_16;
memset(&av_packet_16, 0, sizeof(av_packet_16)); memset(&av_packet_16, 0, sizeof(av_packet_16));
chiaki_takion_av_packet_parse(&av_packet_16, 2, packet_16, sizeof(packet_16)); chiaki_takion_v9_av_packet_parse(&av_packet_16, packet_16, sizeof(packet_16));
munit_assert(av_packet_16.is_video); munit_assert(av_packet_16.is_video);
munit_assert_size(av_packet_16.data_size, ==, sizeof(nalu_16)); munit_assert_size(av_packet_16.data_size, ==, sizeof(nalu_16));
chiaki_gkcrypt_decrypt(&gkcrypt, av_packet_16.key_pos + CHIAKI_GKCRYPT_BLOCK_SIZE, av_packet_16.data, av_packet_16.data_size); chiaki_gkcrypt_decrypt(&gkcrypt, av_packet_16.key_pos + CHIAKI_GKCRYPT_BLOCK_SIZE, av_packet_16.data, av_packet_16.data_size);
@ -238,7 +238,7 @@ uint8_t nalu_17[1357]; size_t nalu_17_size = sizeof(nalu_17); if(chiaki_base64_d
ChiakiTakionAVPacket av_packet_17; ChiakiTakionAVPacket av_packet_17;
memset(&av_packet_17, 0, sizeof(av_packet_17)); memset(&av_packet_17, 0, sizeof(av_packet_17));
chiaki_takion_av_packet_parse(&av_packet_17, 2, packet_17, sizeof(packet_17)); chiaki_takion_v9_av_packet_parse(&av_packet_17, packet_17, sizeof(packet_17));
munit_assert(av_packet_17.is_video); munit_assert(av_packet_17.is_video);
munit_assert_size(av_packet_17.data_size, ==, sizeof(nalu_17)); munit_assert_size(av_packet_17.data_size, ==, sizeof(nalu_17));
chiaki_gkcrypt_decrypt(&gkcrypt, av_packet_17.key_pos + CHIAKI_GKCRYPT_BLOCK_SIZE, av_packet_17.data, av_packet_17.data_size); chiaki_gkcrypt_decrypt(&gkcrypt, av_packet_17.key_pos + CHIAKI_GKCRYPT_BLOCK_SIZE, av_packet_17.data, av_packet_17.data_size);
@ -254,7 +254,7 @@ uint8_t nalu_18[575]; size_t nalu_18_size = sizeof(nalu_18); if(chiaki_base64_de
ChiakiTakionAVPacket av_packet_18; ChiakiTakionAVPacket av_packet_18;
memset(&av_packet_18, 0, sizeof(av_packet_18)); memset(&av_packet_18, 0, sizeof(av_packet_18));
chiaki_takion_av_packet_parse(&av_packet_18, 2, packet_18, sizeof(packet_18)); chiaki_takion_v9_av_packet_parse(&av_packet_18, packet_18, sizeof(packet_18));
munit_assert(av_packet_18.is_video); munit_assert(av_packet_18.is_video);
munit_assert_size(av_packet_18.data_size, ==, sizeof(nalu_18)); munit_assert_size(av_packet_18.data_size, ==, sizeof(nalu_18));
chiaki_gkcrypt_decrypt(&gkcrypt, av_packet_18.key_pos + CHIAKI_GKCRYPT_BLOCK_SIZE, av_packet_18.data, av_packet_18.data_size); chiaki_gkcrypt_decrypt(&gkcrypt, av_packet_18.key_pos + CHIAKI_GKCRYPT_BLOCK_SIZE, av_packet_18.data, av_packet_18.data_size);
@ -267,7 +267,7 @@ uint8_t nalu_19[1400]; size_t nalu_19_size = sizeof(nalu_19); if(chiaki_base64_d
ChiakiTakionAVPacket av_packet_19; ChiakiTakionAVPacket av_packet_19;
memset(&av_packet_19, 0, sizeof(av_packet_19)); memset(&av_packet_19, 0, sizeof(av_packet_19));
chiaki_takion_av_packet_parse(&av_packet_19, 2, packet_19, sizeof(packet_19)); chiaki_takion_v9_av_packet_parse(&av_packet_19, packet_19, sizeof(packet_19));
munit_assert(av_packet_19.is_video); munit_assert(av_packet_19.is_video);
munit_assert_size(av_packet_19.data_size, ==, sizeof(nalu_19)); munit_assert_size(av_packet_19.data_size, ==, sizeof(nalu_19));
chiaki_gkcrypt_decrypt(&gkcrypt, av_packet_19.key_pos + CHIAKI_GKCRYPT_BLOCK_SIZE, av_packet_19.data, av_packet_19.data_size); chiaki_gkcrypt_decrypt(&gkcrypt, av_packet_19.key_pos + CHIAKI_GKCRYPT_BLOCK_SIZE, av_packet_19.data, av_packet_19.data_size);
@ -280,7 +280,7 @@ uint8_t nalu_20[1328]; size_t nalu_20_size = sizeof(nalu_20); if(chiaki_base64_d
ChiakiTakionAVPacket av_packet_20; ChiakiTakionAVPacket av_packet_20;
memset(&av_packet_20, 0, sizeof(av_packet_20)); memset(&av_packet_20, 0, sizeof(av_packet_20));
chiaki_takion_av_packet_parse(&av_packet_20, 2, packet_20, sizeof(packet_20)); chiaki_takion_v9_av_packet_parse(&av_packet_20, packet_20, sizeof(packet_20));
munit_assert(av_packet_20.is_video); munit_assert(av_packet_20.is_video);
munit_assert_size(av_packet_20.data_size, ==, sizeof(nalu_20)); munit_assert_size(av_packet_20.data_size, ==, sizeof(nalu_20));
chiaki_gkcrypt_decrypt(&gkcrypt, av_packet_20.key_pos + CHIAKI_GKCRYPT_BLOCK_SIZE, av_packet_20.data, av_packet_20.data_size); chiaki_gkcrypt_decrypt(&gkcrypt, av_packet_20.key_pos + CHIAKI_GKCRYPT_BLOCK_SIZE, av_packet_20.data, av_packet_20.data_size);
@ -293,7 +293,7 @@ uint8_t nalu_21[1313]; size_t nalu_21_size = sizeof(nalu_21); if(chiaki_base64_d
ChiakiTakionAVPacket av_packet_21; ChiakiTakionAVPacket av_packet_21;
memset(&av_packet_21, 0, sizeof(av_packet_21)); memset(&av_packet_21, 0, sizeof(av_packet_21));
chiaki_takion_av_packet_parse(&av_packet_21, 2, packet_21, sizeof(packet_21)); chiaki_takion_v9_av_packet_parse(&av_packet_21, packet_21, sizeof(packet_21));
munit_assert(av_packet_21.is_video); munit_assert(av_packet_21.is_video);
munit_assert_size(av_packet_21.data_size, ==, sizeof(nalu_21)); munit_assert_size(av_packet_21.data_size, ==, sizeof(nalu_21));
chiaki_gkcrypt_decrypt(&gkcrypt, av_packet_21.key_pos + CHIAKI_GKCRYPT_BLOCK_SIZE, av_packet_21.data, av_packet_21.data_size); chiaki_gkcrypt_decrypt(&gkcrypt, av_packet_21.key_pos + CHIAKI_GKCRYPT_BLOCK_SIZE, av_packet_21.data, av_packet_21.data_size);
@ -306,7 +306,7 @@ uint8_t nalu_22[1331]; size_t nalu_22_size = sizeof(nalu_22); if(chiaki_base64_d
ChiakiTakionAVPacket av_packet_22; ChiakiTakionAVPacket av_packet_22;
memset(&av_packet_22, 0, sizeof(av_packet_22)); memset(&av_packet_22, 0, sizeof(av_packet_22));
chiaki_takion_av_packet_parse(&av_packet_22, 2, packet_22, sizeof(packet_22)); chiaki_takion_v9_av_packet_parse(&av_packet_22, packet_22, sizeof(packet_22));
munit_assert(av_packet_22.is_video); munit_assert(av_packet_22.is_video);
munit_assert_size(av_packet_22.data_size, ==, sizeof(nalu_22)); munit_assert_size(av_packet_22.data_size, ==, sizeof(nalu_22));
chiaki_gkcrypt_decrypt(&gkcrypt, av_packet_22.key_pos + CHIAKI_GKCRYPT_BLOCK_SIZE, av_packet_22.data, av_packet_22.data_size); chiaki_gkcrypt_decrypt(&gkcrypt, av_packet_22.key_pos + CHIAKI_GKCRYPT_BLOCK_SIZE, av_packet_22.data, av_packet_22.data_size);
@ -319,7 +319,7 @@ uint8_t nalu_23[1307]; size_t nalu_23_size = sizeof(nalu_23); if(chiaki_base64_d
ChiakiTakionAVPacket av_packet_23; ChiakiTakionAVPacket av_packet_23;
memset(&av_packet_23, 0, sizeof(av_packet_23)); memset(&av_packet_23, 0, sizeof(av_packet_23));
chiaki_takion_av_packet_parse(&av_packet_23, 2, packet_23, sizeof(packet_23)); chiaki_takion_v9_av_packet_parse(&av_packet_23, packet_23, sizeof(packet_23));
munit_assert(av_packet_23.is_video); munit_assert(av_packet_23.is_video);
munit_assert_size(av_packet_23.data_size, ==, sizeof(nalu_23)); munit_assert_size(av_packet_23.data_size, ==, sizeof(nalu_23));
chiaki_gkcrypt_decrypt(&gkcrypt, av_packet_23.key_pos + CHIAKI_GKCRYPT_BLOCK_SIZE, av_packet_23.data, av_packet_23.data_size); chiaki_gkcrypt_decrypt(&gkcrypt, av_packet_23.key_pos + CHIAKI_GKCRYPT_BLOCK_SIZE, av_packet_23.data, av_packet_23.data_size);