mirror of https://bitbucket.org/ausocean/av.git
Porting alot of encoding decoding funcs
This commit is contained in:
saxon
parent
c86bede9d0
commit
736e96142c
364
rtmp/rtmp.go
364
rtmp/rtmp.go
|
|
@ -803,7 +803,8 @@ func handShake(r *C.RTMP, FP9HandShake int32) int {
|
|||
func sendConnectPacket(r *C.RTMP, cp *C.RTMPPacket) int {
|
||||
var packet C.RTMPPacket
|
||||
var pbuf [4096]byte
|
||||
pend := incBytePtr(unsafe.Pointer(&pbuf[0]), int(unsafe.Sizeof(pbuf)))
|
||||
pend := (*byte)(unsafe.Pointer(incBytePtr(unsafe.Pointer(&pbuf[0]),
|
||||
int(unsafe.Sizeof(pbuf)))))
|
||||
var enc *byte
|
||||
|
||||
if cp != nil {
|
||||
|
|
@ -820,25 +821,20 @@ func sendConnectPacket(r *C.RTMP, cp *C.RTMPPacket) int {
|
|||
RTMP_MAX_HEADER_SIZE))
|
||||
|
||||
enc = (*byte)(unsafe.Pointer(packet.m_body))
|
||||
enc = afmEncodeString(enc, (*byte)(pend), &av_connect)
|
||||
enc = amfEncodeString(enc, (*byte)(pend), &av_connect)
|
||||
r.m_numInvokes += 1
|
||||
// TODO: port this
|
||||
enc = (*byte)(unsafe.Pointer(C.AMF_EncodeNumber((*C.char)(unsafe.Pointer(enc)),
|
||||
(*C.char)(unsafe.Pointer(pend)),
|
||||
C.double(r.m_numInvokes))))
|
||||
enc = amfEncodeNumber(enc, pend, float64(r.m_numInvokes))
|
||||
// TODO: port this const
|
||||
*indxBytePtr(unsafe.Pointer(enc), 0) = C.AMF_OBJECT
|
||||
|
||||
// TODO: port this
|
||||
enc = (*byte)(unsafe.Pointer(C.AMF_EncodeNamedString((*C.char)(unsafe.Pointer(
|
||||
enc)), (*C.char)(unsafe.Pointer(pend)), &av_app, &r.Link.app)))
|
||||
|
||||
enc = amfEncodeNamedString(enc, pend, &av_app, &r.Link.app)
|
||||
if enc == nil {
|
||||
return 0
|
||||
}
|
||||
if r.Link.protocol&RTMP_FEATURE_WRITE != 0 {
|
||||
enc = (*byte)(unsafe.Pointer(C.AMF_EncodeNamedString((*C.char)(unsafe.Pointer(enc)),
|
||||
(*C.char)(unsafe.Pointer(pend)), &av_type, &av_nonprivate)))
|
||||
enc = amfEncodeNamedString(enc, pend, &av_type, &av_nonprivate)
|
||||
|
||||
if enc == nil {
|
||||
return 0
|
||||
|
|
@ -846,23 +842,20 @@ func sendConnectPacket(r *C.RTMP, cp *C.RTMPPacket) int {
|
|||
}
|
||||
|
||||
if r.Link.flashVer.av_len != 0 {
|
||||
enc = (*byte)(unsafe.Pointer(C.AMF_EncodeNamedString((*C.char)(unsafe.Pointer(enc)),
|
||||
(*C.char)(unsafe.Pointer(pend)), &av_flashVer, &r.Link.flashVer)))
|
||||
enc = amfEncodeNamedString(enc, pend, &av_flashVer, &r.Link.flashVer)
|
||||
if enc == nil {
|
||||
return 0
|
||||
}
|
||||
}
|
||||
if r.Link.swfUrl.av_len != 0 {
|
||||
enc = (*byte)(unsafe.Pointer(C.AMF_EncodeNamedString((*C.char)(unsafe.Pointer(enc)),
|
||||
(*C.char)(unsafe.Pointer(pend)), &av_swfUrl, &r.Link.swfUrl)))
|
||||
enc = amfEncodeNamedString(enc, pend, &av_swfUrl, &r.Link.swfUrl)
|
||||
if enc == nil {
|
||||
return 0
|
||||
}
|
||||
}
|
||||
|
||||
if r.Link.tcUrl.av_len != 0 {
|
||||
enc = (*byte)(unsafe.Pointer(C.AMF_EncodeNamedString((*C.char)(unsafe.Pointer(enc)),
|
||||
(*C.char)(unsafe.Pointer(pend)), &av_tcUrl, &r.Link.tcUrl)))
|
||||
enc = amfEncodeNamedString(enc, pend, &av_tcUrl, &r.Link.tcUrl)
|
||||
if enc == nil {
|
||||
return 0
|
||||
}
|
||||
|
|
@ -870,35 +863,28 @@ func sendConnectPacket(r *C.RTMP, cp *C.RTMPPacket) int {
|
|||
|
||||
if r.Link.protocol&RTMP_FEATURE_WRITE == 0 {
|
||||
// TODO: port this
|
||||
enc = (*byte)(unsafe.Pointer(C.AMF_EncodeNamedBoolean((*C.char)(
|
||||
unsafe.Pointer(enc)), (*C.char)(unsafe.Pointer(pend)), &av_fpad, 0)))
|
||||
enc = C.AMF_EncodeNamedBoolean(enc, pend, &av_fpad, 0)
|
||||
if enc == nil {
|
||||
return 0
|
||||
}
|
||||
enc = (*byte)(unsafe.Pointer(C.AMF_EncodeNamedNumber((*C.char)(
|
||||
unsafe.Pointer(enc)), (*C.char)(unsafe.Pointer(pend)), &av_capabilities,
|
||||
15.0)))
|
||||
enc = C.AMF_EncodeNamedNumber(enc, pend, &av_capabilities, 15.0)
|
||||
if enc == nil {
|
||||
return 0
|
||||
}
|
||||
enc = (*byte)(unsafe.Pointer(C.AMF_EncodeNamedNumber((*C.char)(unsafe.Pointer(enc)), (*C.char)(
|
||||
unsafe.Pointer(pend)), &av_audioCodecs, r.m_fAudioCodecs)))
|
||||
enc = C.AMF_EncodeNamedNumber(enc, pend, &av_audioCodecs, r.m_fAudioCodecs)
|
||||
if enc == nil {
|
||||
return 0
|
||||
}
|
||||
enc = (*byte)(unsafe.Pointer(C.AMF_EncodeNamedNumber((*C.char)(unsafe.Pointer(enc)), (*C.char)(
|
||||
unsafe.Pointer(pend)), &av_videoCodecs, r.m_fVideoCodecs)))
|
||||
enc = C.AMF_EncodeNamedNumber(enc, pend, &av_videoCodecs, r.m_fVideoCodecs)
|
||||
if enc == nil {
|
||||
return 0
|
||||
}
|
||||
enc = (*byte)(unsafe.Pointer(C.AMF_EncodeNamedNumber((*C.char)(unsafe.Pointer(enc)), (*C.char)(
|
||||
unsafe.Pointer(pend)), &av_videoFunction, 1.0)))
|
||||
enc = C.AMF_EncodeNamedNumber(enc, pend, &av_videoFunction, 1.0)
|
||||
if enc == nil {
|
||||
return 0
|
||||
}
|
||||
if r.Link.pageUrl.av_len != 0 {
|
||||
enc = (*byte)(unsafe.Pointer(C.AMF_EncodeNamedString((*C.char)(unsafe.Pointer(enc)), (*C.char)(
|
||||
unsafe.Pointer(pend)), &av_pageUrl, &r.Link.pageUrl)))
|
||||
enc = amfEncodeNamedString(enc, pend, &av_pageUrl, &r.Link.pageUrl)
|
||||
if enc == nil {
|
||||
return 0
|
||||
}
|
||||
|
|
@ -906,8 +892,7 @@ func sendConnectPacket(r *C.RTMP, cp *C.RTMPPacket) int {
|
|||
}
|
||||
|
||||
if r.m_fEncoding != 0.0 || r.m_bSendEncoding != 0 {
|
||||
enc = (*byte)(unsafe.Pointer(C.AMF_EncodeNamedNumber((*C.char)(unsafe.Pointer(enc)), (*C.char)(
|
||||
unsafe.Pointer(pend)), &av_objectEncoding, r.m_fEncoding)))
|
||||
enc = C.AMF_EncodeNamedNumber(enc, pend, &av_objectEncoding, r.m_fEncoding)
|
||||
if enc == nil {
|
||||
return 0
|
||||
}
|
||||
|
|
@ -933,7 +918,7 @@ func sendConnectPacket(r *C.RTMP, cp *C.RTMPPacket) int {
|
|||
if enc == nil {
|
||||
return 0
|
||||
}
|
||||
enc = afmEncodeString(enc, (*byte)(pend), &r.Link.auth)
|
||||
enc = amfEncodeString(enc, (*byte)(pend), &r.Link.auth)
|
||||
if enc == nil {
|
||||
return 0
|
||||
}
|
||||
|
|
@ -952,8 +937,8 @@ func sendConnectPacket(r *C.RTMP, cp *C.RTMPPacket) int {
|
|||
}
|
||||
}
|
||||
|
||||
packet.m_nBodySize = C.uint32_t(int(uintptr(decBytePtr(unsafe.Pointer(enc), int(uintptr(
|
||||
unsafe.Pointer(packet.m_body)))))))
|
||||
packet.m_nBodySize = C.uint32_t(int(uintptr(decBytePtr(unsafe.Pointer(enc),
|
||||
int(uintptr(unsafe.Pointer(packet.m_body)))))))
|
||||
|
||||
return sendPacket(r, &packet, 1)
|
||||
}
|
||||
|
|
@ -1037,9 +1022,9 @@ func rtmpWrite(r *C.RTMP, data []byte) int {
|
|||
|
||||
pkt.m_packetType = C.uint8_t(*indxBytePtr(buf, 0))
|
||||
buf = incBytePtr(buf, 1)
|
||||
pkt.m_nBodySize = C.uint32_t(afmDecodeInt24((*byte)(buf)))
|
||||
pkt.m_nBodySize = C.uint32_t(amfDecodeInt24((*byte)(buf)))
|
||||
buf = incBytePtr(buf, 3)
|
||||
pkt.m_nTimeStamp = C.uint32_t(afmDecodeInt24((*byte)(buf)))
|
||||
pkt.m_nTimeStamp = C.uint32_t(amfDecodeInt24((*byte)(buf)))
|
||||
buf = incBytePtr(buf, 3)
|
||||
pkt.m_nTimeStamp |= C.uint32_t(*indxBytePtr(buf, 0)) << 24
|
||||
buf = incBytePtr(buf, 4)
|
||||
|
|
@ -1067,7 +1052,7 @@ func rtmpWrite(r *C.RTMP, data []byte) int {
|
|||
pend = incBytePtr(enc, int(pkt.m_nBodySize))
|
||||
|
||||
if pkt.m_packetType == RTMP_PACKET_TYPE_INFO {
|
||||
enc = unsafe.Pointer(afmEncodeString((*byte)(enc), (*byte)(pend), &setDataFrame))
|
||||
enc = unsafe.Pointer(amfEncodeString((*byte)(enc), (*byte)(pend), &setDataFrame))
|
||||
pkt.m_nBytesRead = C.uint32_t(math.Abs(float64(uintptr(enc) -
|
||||
uintptr(unsafe.Pointer(pkt.m_body)))))
|
||||
}
|
||||
|
|
@ -1103,93 +1088,6 @@ func rtmpWrite(r *C.RTMP, data []byte) int {
|
|||
return size + s2
|
||||
}
|
||||
|
||||
// afmDecodeInt24 decodes data into an unsigned int
|
||||
func afmDecodeInt24(data *byte) uint32 {
|
||||
// TODO Understand logic and simplify
|
||||
c := (*uint8)(unsafe.Pointer(data))
|
||||
dst := uint32(int32(*c) << 16)
|
||||
dst |= uint32(int32(*((*uint8)(unsafe.Pointer(uintptr(unsafe.Pointer(c)) +
|
||||
(uintptr)(int32(1))*unsafe.Sizeof(*c))))) << 8)
|
||||
dst |= uint32(int32(*((*uint8)(unsafe.Pointer(uintptr(unsafe.Pointer(c)) +
|
||||
(uintptr)(int32(2))*unsafe.Sizeof(*c))))))
|
||||
return dst
|
||||
}
|
||||
|
||||
func afmEncodeString(output *byte, outend *byte, bv *C.AVal) *byte {
|
||||
outputPtr := unsafe.Pointer(output)
|
||||
outendPtr := unsafe.Pointer(outend)
|
||||
if (bv.av_len < 65536 && uintptr(incBytePtr(outputPtr, 1+2+int(bv.av_len))) >
|
||||
uintptr(outendPtr)) || uintptr(incBytePtr(outputPtr, 1+4+int(bv.av_len))) >
|
||||
uintptr(outendPtr) {
|
||||
return nil
|
||||
}
|
||||
|
||||
if bv.av_len < 65536 {
|
||||
*(*C.char)(outputPtr) = C.AMF_STRING
|
||||
incBytePtr(outputPtr, 1)
|
||||
|
||||
outputPtr = unsafe.Pointer(afmEncodeInt16((*byte)(outputPtr),
|
||||
(*byte)(outendPtr), (int16)(bv.av_len)))
|
||||
} else {
|
||||
*(*C.char)(outputPtr) = C.AMF_LONG_STRING
|
||||
incBytePtr(outputPtr, 1)
|
||||
|
||||
outputPtr = unsafe.Pointer(afmEncodeInt32((*byte)(outputPtr),
|
||||
(*byte)(outendPtr), (int32)(bv.av_len)))
|
||||
}
|
||||
memmove(unsafe.Pointer(outputPtr), unsafe.Pointer(bv.av_val), uintptr(bv.av_len))
|
||||
//C.memcpy(unsafe.Pointer(outputPtr), unsafe.Pointer(bv.av_val), (C.size_t)(bv.av_len))
|
||||
incBytePtr(outputPtr, int(bv.av_len))
|
||||
|
||||
return (*byte)(outputPtr)
|
||||
}
|
||||
|
||||
// afmEncodeInt16 encodes a int16 into data
|
||||
func afmEncodeInt16(output *byte, outend *byte, nVal int16) *byte {
|
||||
outputPtr := unsafe.Pointer(output)
|
||||
outendPtr := unsafe.Pointer(outend)
|
||||
if uintptr(outputPtr)+2 > uintptr(outendPtr) {
|
||||
// length < 2
|
||||
return nil
|
||||
}
|
||||
|
||||
// Assign output[1]
|
||||
second := (*byte)(incBytePtr(outputPtr, 1))
|
||||
*second = (byte)(nVal & 0xff)
|
||||
|
||||
// Assign output[0]
|
||||
*output = (byte)(nVal >> 8)
|
||||
|
||||
return (*byte)(incBytePtr(outputPtr, 2))
|
||||
}
|
||||
|
||||
// afmEncodeInt32 encodes a int32 into data
|
||||
func afmEncodeInt32(output *byte, outend *byte, nVal int32) *byte {
|
||||
outputPtr := unsafe.Pointer(output)
|
||||
outendPtr := unsafe.Pointer(outend)
|
||||
if uintptr(outputPtr)+4 > uintptr(outendPtr) {
|
||||
// length < 4
|
||||
return nil
|
||||
}
|
||||
|
||||
// Assign output[3]
|
||||
forth := (*byte)(incBytePtr(outputPtr, 3))
|
||||
*forth = (byte)(nVal & 0xff)
|
||||
|
||||
// Assign output[2]
|
||||
third := (*byte)(incBytePtr(outputPtr, 2))
|
||||
*third = (byte)(nVal >> 8)
|
||||
|
||||
// Assign output[1]
|
||||
second := (*byte)(incBytePtr(outputPtr, 1))
|
||||
*second = (byte)(nVal >> 16)
|
||||
|
||||
// Assign output[0]
|
||||
*output = (byte)(nVal >> 24)
|
||||
|
||||
return (*byte)(incBytePtr(outputPtr, 4))
|
||||
}
|
||||
|
||||
// send packet version 1 - less C stuff
|
||||
func sendPacket(r *C.RTMP, packet *C.RTMPPacket, queue int) int {
|
||||
var prevPacket *C.RTMPPacket
|
||||
|
|
@ -1310,11 +1208,11 @@ func sendPacket(r *C.RTMP, packet *C.RTMPPacket, queue int) int {
|
|||
if t > 0xffffff {
|
||||
res = 0xffffff
|
||||
}
|
||||
hptr = unsafe.Pointer(afmEncodeInt24((*byte)(hptr), (*byte)(hend), res))
|
||||
hptr = unsafe.Pointer(amfEncodeInt24((*byte)(hptr), (*byte)(hend), res))
|
||||
}
|
||||
|
||||
if nSize > 4 {
|
||||
hptr = unsafe.Pointer(afmEncodeInt24((*byte)(hptr), (*byte)(hend), (int32(packet.m_nBodySize))))
|
||||
hptr = unsafe.Pointer(amfEncodeInt24((*byte)(hptr), (*byte)(hend), (int32(packet.m_nBodySize))))
|
||||
*(*byte)(hptr) = byte(packet.m_packetType)
|
||||
hptr = incBytePtr(hptr, 1)
|
||||
}
|
||||
|
|
@ -1325,7 +1223,7 @@ func sendPacket(r *C.RTMP, packet *C.RTMPPacket, queue int) int {
|
|||
}
|
||||
|
||||
if t >= 0xffffff {
|
||||
hptr = unsafe.Pointer(afmEncodeInt32((*byte)(hptr), (*byte)(hend), (int32)(t)))
|
||||
hptr = unsafe.Pointer(amfEncodeInt32((*byte)(hptr), (*byte)(hend), (int32)(t)))
|
||||
}
|
||||
|
||||
nSize = int(packet.m_nBodySize)
|
||||
|
|
@ -1402,7 +1300,7 @@ func sendPacket(r *C.RTMP, packet *C.RTMPPacket, queue int) int {
|
|||
}
|
||||
if t >= 0xffffff {
|
||||
extendedTimestamp := incBytePtr(header, 1+cSize)
|
||||
afmEncodeInt32((*byte)(extendedTimestamp),
|
||||
amfEncodeInt32((*byte)(extendedTimestamp),
|
||||
(*byte)(incBytePtr(extendedTimestamp, 4)), (int32)(t))
|
||||
}
|
||||
}
|
||||
|
|
@ -1427,7 +1325,7 @@ func sendPacket(r *C.RTMP, packet *C.RTMPPacket, queue int) int {
|
|||
var method C.AVal
|
||||
var ptr unsafe.Pointer
|
||||
ptr = incBytePtr(unsafe.Pointer(packet.m_body), 1)
|
||||
afmDecodeString((*byte)(ptr), &method)
|
||||
amfDecodeString((*byte)(ptr), &method)
|
||||
|
||||
if debugMode {
|
||||
log.Printf("Invoking %v", method.av_val)
|
||||
|
|
@ -1454,53 +1352,9 @@ func sendPacket(r *C.RTMP, packet *C.RTMPPacket, queue int) int {
|
|||
memmove(unsafe.Pointer(*(**C.RTMPPacket)(incPtr(unsafe.Pointer(r.m_vecChannelsOut),
|
||||
int(packet.m_nChannel), int(unsafe.Sizeof(packet))))), unsafe.Pointer(packet),
|
||||
uintptr(unsafe.Sizeof(*packet)))
|
||||
//C.memcpy(unsafe.Pointer(*(**C.RTMPPacket)(incPtr(unsafe.Pointer(r.m_vecChannelsOut),
|
||||
//int(packet.m_nChannel), int(unsafe.Sizeof(packet))))), unsafe.Pointer(packet),
|
||||
//C.size_t(uintptr(unsafe.Sizeof(*packet))))
|
||||
return 1
|
||||
}
|
||||
|
||||
// afmDecodeString decodes data into a string inside a AVal
|
||||
func afmDecodeString(data *byte, bv *C.AVal) {
|
||||
dataPtr := unsafe.Pointer(data)
|
||||
bv.av_len = C.int(afmDecodeInt16((*byte)(dataPtr)))
|
||||
|
||||
if bv.av_len > 0 {
|
||||
bv.av_val = (*C.char)(incBytePtr(dataPtr, 2))
|
||||
} else {
|
||||
bv.av_val = nil
|
||||
}
|
||||
}
|
||||
|
||||
// afmDecodeInt16 decodes data into a 16 bit number
|
||||
func afmDecodeInt16(data *byte) uint16 {
|
||||
c := unsafe.Pointer(data)
|
||||
return (uint16(*(*uint8)(c)) << 8) | *(*uint16)(incBytePtr(c, 1))
|
||||
}
|
||||
|
||||
// afmEncodeInt24 encodes a int24 into data
|
||||
func afmEncodeInt24(output *byte, outend *byte, nVal int32) *byte {
|
||||
outputPtr := unsafe.Pointer(output)
|
||||
outendPtr := unsafe.Pointer(outend)
|
||||
if uintptr(outputPtr)+3 > uintptr(outendPtr) {
|
||||
// length < 3
|
||||
return nil
|
||||
}
|
||||
|
||||
// Assign output[2]
|
||||
third := (*byte)(incBytePtr(outputPtr, 2))
|
||||
*third = (byte)(nVal & 0xff)
|
||||
|
||||
// Assign output[1]
|
||||
second := (*byte)(incBytePtr(outputPtr, 1))
|
||||
*second = (byte)(nVal >> 8)
|
||||
|
||||
// Assign output[0]
|
||||
*output = (byte)(nVal >> 16)
|
||||
|
||||
return (*byte)(incBytePtr(outputPtr, 3))
|
||||
}
|
||||
|
||||
func writeN(r *C.RTMP, buffer unsafe.Pointer, n int) int {
|
||||
ptr := buffer
|
||||
for n > 0 {
|
||||
|
|
@ -1566,6 +1420,170 @@ func avQueue(vals **C.RTMP_METHOD, num *int, av *C.AVal, txn int) {
|
|||
int(unsafe.Sizeof(rtmpMethodPtr))))).name.av_val = (*C.char)(tmp)
|
||||
}
|
||||
|
||||
func amfEncodeNamedNumber(output *byte, outend *byte, strName *C.AVal, dVal float64) *byte {
|
||||
if int(uintptr(unsafe.Pointer(output)))+2+int(strName.av_len) > int(uintptr(unsafe.Pointer(outend))) {
|
||||
return nil
|
||||
}
|
||||
output = amfEncodeInt16(output, outend, int16(strName.av_len))
|
||||
memmove(unsafe.Pointer(output), unsafe.Pointer(outend), uintptr(strName.av_len))
|
||||
output = (*byte)(incBytePtr(unsafe.Pointer(output), int(strName.av_len)))
|
||||
return amfEncodeNumber(output, outend, dVal)
|
||||
}
|
||||
|
||||
func amfEncodeNamedBoolean(output *byte, outend *byte, strName *AVal, bVal int) *byte {
|
||||
if int(uintptr(unsafe.Pointer(output)))+2+int(strName.av_len) > int(uintptr(unsafe.Pointer(outend))) {
|
||||
return nil
|
||||
}
|
||||
output = amfEncodeInt16(output, outend, int16(strName.av_len))
|
||||
memmove(unsafe.Pointer(output), unsafe.Pointer(outend), uintptr(strName.av_len))
|
||||
output = (*byte)(incBytePtr(unsafe.Pointer(output), int(strName.av_len)))
|
||||
|
||||
return amfEncodeBoolean(output, outend, dVal)
|
||||
}
|
||||
|
||||
func amfEncodeNumber(output *byte, outend *byte, dVal float64) *byte {
|
||||
if int(uintptr(unsafe.Pointer(output)))+1+8 > int(uintptr(unsafe.Pointer(outend))) {
|
||||
return nil
|
||||
}
|
||||
|
||||
// TODO: port this
|
||||
*(*byte)(unsafe.Pointer(enc)) = C.AMF_NUMBER
|
||||
output = (*byte)(incBytePtr(unsafe.Pointer(output), 1))
|
||||
|
||||
// NOTE: here we are assuming little endian for both byte order and float
|
||||
// word order
|
||||
var ci, co *uint8
|
||||
ci = (*uint8)(unsafe.Pointer(&dVal))
|
||||
co = (*uint8)(unsafe.Pointer(output))
|
||||
|
||||
for i := 0; i < 8; i++ {
|
||||
*indxBytePtr(unsafe.Pointer(co), i) = *indxBytePtr(unsafe.Pointer(ci), 7-i)
|
||||
}
|
||||
|
||||
return (*Byte)(incBytePtr(unsafe.Pointer(output), 8))
|
||||
}
|
||||
|
||||
func amfEncodeNamedString(output *byte, outend *byte, strName *C.AVal, strValue *C.AVal) *byte {
|
||||
if int(uintptr(unsafe.Pointer(output)))+2+int(strName.av_len) > int(uintptr(unsafe.Pointer(outend))) {
|
||||
return nil
|
||||
}
|
||||
output = amfEncodeInt16(output, outend, int16(strName.av_len))
|
||||
memmove(unsafe.Pointer(output), unsafe.Pointer(outend), uintptr(strName.av_len))
|
||||
output = (*byte)(incBytePtr(unsafe.Pointer(output), int(strName.av_len)))
|
||||
return amfEncodeString(output, outend, strValue)
|
||||
}
|
||||
|
||||
// amfDecodeString decodes data into a string inside a AVal
|
||||
func amfDecodeString(data *byte, bv *C.AVal) {
|
||||
dataPtr := unsafe.Pointer(data)
|
||||
bv.av_len = C.int(amfDecodeInt16((*byte)(dataPtr)))
|
||||
if bv.av_len > 0 {
|
||||
bv.av_val = (*C.char)(incBytePtr(dataPtr, 2))
|
||||
} else {
|
||||
bv.av_val = nil
|
||||
}
|
||||
}
|
||||
|
||||
// amfDecodeInt16 decodes data into a 16 bit number
|
||||
func amfDecodeInt16(data *byte) uint16 {
|
||||
c := unsafe.Pointer(data)
|
||||
return (uint16(*(*uint8)(c)) << 8) | *(*uint16)(incBytePtr(c, 1))
|
||||
}
|
||||
|
||||
// amfEncodeInt24 encodes a int24 into data
|
||||
func amfEncodeInt24(output *byte, outend *byte, nVal int32) *byte {
|
||||
outputPtr := unsafe.Pointer(output)
|
||||
outendPtr := unsafe.Pointer(outend)
|
||||
if uintptr(outputPtr)+3 > uintptr(outendPtr) {
|
||||
// length < 3
|
||||
return nil
|
||||
}
|
||||
// Assign output[2]
|
||||
third := (*byte)(incBytePtr(outputPtr, 2))
|
||||
*third = (byte)(nVal & 0xff)
|
||||
// Assign output[1]
|
||||
second := (*byte)(incBytePtr(outputPtr, 1))
|
||||
*second = (byte)(nVal >> 8)
|
||||
// Assign output[0]
|
||||
*output = (byte)(nVal >> 16)
|
||||
return (*byte)(incBytePtr(outputPtr, 3))
|
||||
}
|
||||
|
||||
// amfDecodeInt24 decodes data into an unsigned int
|
||||
func amfDecodeInt24(data *byte) uint32 {
|
||||
// TODO Understand logic and simplify
|
||||
c := (*uint8)(unsafe.Pointer(data))
|
||||
dst := uint32(int32(*c) << 16)
|
||||
dst |= uint32(int32(*((*uint8)(unsafe.Pointer(uintptr(unsafe.Pointer(c)) +
|
||||
(uintptr)(int32(1))*unsafe.Sizeof(*c))))) << 8)
|
||||
dst |= uint32(int32(*((*uint8)(unsafe.Pointer(uintptr(unsafe.Pointer(c)) +
|
||||
(uintptr)(int32(2))*unsafe.Sizeof(*c))))))
|
||||
return dst
|
||||
}
|
||||
|
||||
func amfEncodeString(output *byte, outend *byte, bv *C.AVal) *byte {
|
||||
outputPtr := unsafe.Pointer(output)
|
||||
outendPtr := unsafe.Pointer(outend)
|
||||
if (bv.av_len < 65536 && uintptr(incBytePtr(outputPtr, 1+2+int(bv.av_len))) >
|
||||
uintptr(outendPtr)) || uintptr(incBytePtr(outputPtr, 1+4+int(bv.av_len))) >
|
||||
uintptr(outendPtr) {
|
||||
return nil
|
||||
}
|
||||
if bv.av_len < 65536 {
|
||||
*(*C.char)(outputPtr) = C.AMF_STRING
|
||||
incBytePtr(outputPtr, 1)
|
||||
outputPtr = unsafe.Pointer(amfEncodeInt16((*byte)(outputPtr),
|
||||
(*byte)(outendPtr), (int16)(bv.av_len)))
|
||||
} else {
|
||||
*(*C.char)(outputPtr) = C.AMF_LONG_STRING
|
||||
incBytePtr(outputPtr, 1)
|
||||
outputPtr = unsafe.Pointer(amfEncodeInt32((*byte)(outputPtr),
|
||||
(*byte)(outendPtr), (int32)(bv.av_len)))
|
||||
}
|
||||
memmove(unsafe.Pointer(outputPtr), unsafe.Pointer(bv.av_val), uintptr(bv.av_len))
|
||||
//C.memcpy(unsafe.Pointer(outputPtr), unsafe.Pointer(bv.av_val), (C.size_t)(bv.av_len))
|
||||
incBytePtr(outputPtr, int(bv.av_len))
|
||||
return (*byte)(outputPtr)
|
||||
}
|
||||
|
||||
// amfEncodeInt16 encodes a int16 into data
|
||||
func amfEncodeInt16(output *byte, outend *byte, nVal int16) *byte {
|
||||
outputPtr := unsafe.Pointer(output)
|
||||
outendPtr := unsafe.Pointer(outend)
|
||||
if uintptr(outputPtr)+2 > uintptr(outendPtr) {
|
||||
// length < 2
|
||||
return nil
|
||||
}
|
||||
// Assign output[1]
|
||||
second := (*byte)(incBytePtr(outputPtr, 1))
|
||||
*second = (byte)(nVal & 0xff)
|
||||
// Assign output[0]
|
||||
*output = (byte)(nVal >> 8)
|
||||
return (*byte)(incBytePtr(outputPtr, 2))
|
||||
}
|
||||
|
||||
// amfEncodeInt32 encodes a int32 into data
|
||||
func amfEncodeInt32(output *byte, outend *byte, nVal int32) *byte {
|
||||
outputPtr := unsafe.Pointer(output)
|
||||
outendPtr := unsafe.Pointer(outend)
|
||||
if uintptr(outputPtr)+4 > uintptr(outendPtr) {
|
||||
// length < 4
|
||||
return nil
|
||||
}
|
||||
// Assign output[3]
|
||||
forth := (*byte)(incBytePtr(outputPtr, 3))
|
||||
*forth = (byte)(nVal & 0xff)
|
||||
// Assign output[2]
|
||||
third := (*byte)(incBytePtr(outputPtr, 2))
|
||||
*third = (byte)(nVal >> 8)
|
||||
// Assign output[1]
|
||||
second := (*byte)(incBytePtr(outputPtr, 1))
|
||||
*second = (byte)(nVal >> 16)
|
||||
// Assign output[0]
|
||||
*output = (byte)(nVal >> 24)
|
||||
return (*byte)(incBytePtr(outputPtr, 4))
|
||||
}
|
||||
|
||||
// TODO: write test for this func
|
||||
func memcmp(a, b unsafe.Pointer, size int) int {
|
||||
for i := 0; i < size; i++ {
|
||||
|
|
|
|||
Loading…
Reference in New Issue