/*
NAME
  rtmp.go

DESCRIPTION
  See Readme.md

AUTHORS
  Saxon Nelson-Milton <saxon@ausocean.org>
  Dan Kortschak <dan@ausocean.org>
  Alan Noble <alan@ausocean.org>

LICENSE
  rtmp.go is Copyright (C) 2017-2019 the Australian Ocean Lab (AusOcean)

  It is free software: you can redistribute it and/or modify them
  under the terms of the GNU General Public License as published by the
  Free Software Foundation, either version 3 of the License, or (at your
  option) any later version.

  It is distributed in the hope that it will be useful, but WITHOUT
  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
  for more details.

  You should have received a copy of the GNU General Public License
  along with revid in gpl.txt. If not, see http://www.gnu.org/licenses.

  Derived from librtmp under the GNU Lesser General Public License 2.1
  Copyright (C) 2005-2008 Team XBMC http://www.xbmc.org
  Copyright (C) 2008-2009 Andrej Stepanchuk
  Copyright (C) 2009-2010 Howard Chu
*/

package rtmp

import (
	"bytes"
	"encoding/binary"
	"errors"
	"fmt"
	"io"
	"log"
	"math/rand"
	"net"
	"strconv"
	"time"
)

const (
	minDataSize = 11
	debugMode   = true
	length      = 512
)

const (
	// av_setDataFrame is a static const global in rtmp.c
	setDataFrame = "@setDataFrame"

	av__checkbw                         = "_checkbw"
	av__onbwcheck                       = "_onbwcheck"
	av__onbwdone                        = "_onbwdone"
	av__result                          = "_result"
	av_app                              = "app"
	av_audioCodecs                      = "audioCodecs"
	av_capabilities                     = "capabilities"
	av_close                            = "close"
	av_code                             = "code"
	av_connect                          = "connect"
	av_createStream                     = "createStream"
	av_deleteStream                     = "deleteStream"
	av_FCPublish                        = "FCPublish"
	av_FCUnpublish                      = "FCUnpublish"
	av_flashVer                         = "flashVer"
	av_fpad                             = "fpad"
	av_level                            = "level"
	av_live                             = "live"
	av_NetConnection_Connect_InvalidApp = "NetConnection.Connect.InvalidApp"
	av_NetStream_Failed                 = "NetStream.Failed"
	av_NetStream_Pause_Notify           = "NetStream.Pause.Notify"
	av_NetStream_Play_Complete          = "NetStream.Play.Complete"
	av_NetStream_Play_Failed            = "NetStream.Play.Failed"
	av_NetStream_Play_PublishNotify     = "NetStream.Play.PublishNotify"
	av_NetStream_Play_Start             = "NetStream.Play.Start"
	av_NetStream_Play_Stop              = "NetStream.Play.Stop"
	av_NetStream_Play_StreamNotFound    = "NetStream.Play.StreamNotFound"
	av_NetStream_Play_UnpublishNotify   = "NetStream.Play.UnpublishNotify"
	av_NetStream_Publish_Start          = "NetStream.Publish.Start"
	av_NetStream_Seek_Notify            = "NetStream.Seek.Notify"
	av_nonprivate                       = "nonprivate"
	av_objectEncoding                   = "objectEncoding"
	av_onBWDone                         = "onBWDone"
	av_onFCSubscribe                    = "onFCSubscribe"
	av_onFCUnsubscribe                  = "onFCUnsubscribe"
	av_onStatus                         = "onStatus"
	av_pageUrl                          = "pageUrl"
	av_ping                             = "ping"
	av_play                             = "play"
	av_playlist_ready                   = "playlist_ready"
	av_publish                          = "publish"
	av_releaseStream                    = "releaseStream"
	av_secureToken                      = "secureToken"
	av_set_playlist                     = "set_playlist"
	av_swfUrl                           = "swfUrl"
	av_tcUrl                            = "tcUrl"
	av_type                             = "type"
	av_videoCodecs                      = "videoCodecs"
	av_videoFunction                    = "videoFunction"
)

var RTMPT_cmds = []string{
	"open",
	"send",
	"idle",
	"close",
}

var (
	packetSize               = [...]int{12, 8, 4, 1}
	RTMPProtocolStringsLower = [...]string{
		"rtmp",
		"rtmpt",
		"rtmpe",
		"rtmpte",
		"rtmps",
		"rtmpts",
		"",
		"",
		"rtmfp",
	}
)

var (
	errUnknownScheme = errors.New("rtmp: unknown scheme")
	errHandshake     = errors.New("rtmp: handshake failed")
	errConnSend      = errors.New("rtmp: connection send error")
	errConnStream    = errors.New("rtmp: connection stream error")
	errInvalidHeader = errors.New("rtmp: invalid header")
	errInvalidBody   = errors.New("rtmp: invalid body")
	errTinyPacket    = errors.New("rtmp: packet too small")
	errEncoding      = errors.New("rtmp: encoding error")
	errDecoding      = errors.New("rtmp: decoding error")
	errCopying       = errors.New("rtmp: copying error")
)

// RTMPPacket_IsReady(a)
// rtmp.h +142
func C_RTMPPacket_IsReady(pkt *packet) bool {
	return pkt.bytesRead == pkt.bodySize
}

// uint32_t RTMP_GetTime();
// rtmp.c +156
func C_RTMP_GetTime() int32 {
	return int32(time.Now().UnixNano() / 1000000)
}

// void RTMP_EnableWrite(RTMP *r);
// rtmp.c +351
func C_RTMP_EnableWrite(s *Session) {
	s.link.protocol |= RTMP_FEATURE_WRITE
}

// void RTMP_SetBufferMS(RTMP *r, int size);
// rtmp.c +381
// DELETED

// void SocksSetup(RTMP *r, C_AVal* sockshost);
// rtmp.c +410
// DELETED

// int RTMP_SetupURL(RTMP *r, char* url);
// rtmp.c +757
// NOTE: code dealing with rtmp over http has been disregarded
func C_RTMP_SetupURL(s *Session, addr string) (err error) {
	s.link.protocol, s.link.host, s.link.port, s.link.app, s.link.playpath, err = C_RTMP_ParseURL(addr)
	if err != nil {
		return err
	}

	if s.link.tcUrl == "" {
		if s.link.app != "" {
			s.link.tcUrl = fmt.Sprintf("%v://%v:%v/%v",
				RTMPProtocolStringsLower[s.link.protocol], s.link.host, s.link.port, s.link.app)
			s.link.lFlags |= RTMP_LF_FTCU
		} else {
			s.link.tcUrl = addr
		}
	}

	if s.link.port == 0 {
		switch {
		case (s.link.protocol & RTMP_FEATURE_SSL) != 0:
			s.link.port = 433
		case (s.link.protocol & RTMP_FEATURE_HTTP) != 0:
			s.link.port = 80
		default:
			s.link.port = 1935
		}
	}
	return nil
}

// int RTMP_Connect(RTMP *r, RTMPPacket* cp);
// rtmp.c +1032
func C_RTMP_Connect(s *Session, cp *packet) error {
	addr, err := net.ResolveTCPAddr("tcp4", s.link.host+":"+strconv.Itoa(int(s.link.port)))
	if err != nil {
		return err
	}
	s.link.conn, err = net.DialTCP("tcp4", nil, addr)
	if err != nil {
		return err
	}
	if debugMode {
		log.Println("... connected, handshaking...")
	}
	err = C_HandShake(s, 1)
	if err != nil {
		log.Println("C_RTMP_Connect1: handshake failed!")
		return errHandshake
	}
	if debugMode {
		log.Println("... handshaked...")
	}
	err = C_SendConnectPacket(s, cp)
	if err != nil {
		log.Println("RTMP connect failed!")
		return errConnSend
	}
	return nil
}

// int RTMP_Connect1(RTMP* r, RTMPPacket* cp);
// rtmp.c +978
// DELETED - subsumed by RTMP_Connect

// int RTMP_ConnectStream(RTMP* r, int seekTime);
// rtmp.c +1099
// Side effects: s.isPlaying is set true upon successful connection
func C_RTMP_ConnectStream(s *Session, seekTime int32) error {
	var pkt packet

	if seekTime > 0 {
		s.link.seekTime = seekTime
	}

	for !s.isPlaying && s.isConnected() {
		err := C_RTMP_ReadPacket(s, &pkt)
		if err != nil {
			break
		}
		// TODO: port is ready
		if C_RTMPPacket_IsReady(&pkt) {
			if pkt.bodySize == 0 {
				continue
			}

			if pkt.packetType == RTMP_PACKET_TYPE_AUDIO ||
				pkt.packetType == RTMP_PACKET_TYPE_VIDEO ||
				pkt.packetType == RTMP_PACKET_TYPE_INFO {
				log.Println("C_RTMP_ConnectStream: got packet before play()! Ignoring.")
				pkt.body = nil
				continue
			}

			C_RTMP_ClientPacket(s, &pkt)
			pkt.body = nil
		}
	}

	if !s.isPlaying {
		return errConnStream
	}
	return nil
}

// int RTMP_ClientPacket()
// rtmp.c +1226
// NOTE cases have been commented out that are not currently used by AusOcean
func C_RTMP_ClientPacket(s *Session, pkt *packet) int32 {
	var hasMediaPacket int32
	switch pkt.packetType {

	case RTMP_PACKET_TYPE_CHUNK_SIZE:
		// TODO: port this
		C_HandleChangeChunkSize(s, pkt)

	case RTMP_PACKET_TYPE_BYTES_READ_REPORT:
		// TODO: usue new logger here
		//RTMP_Log(RTMP_LOGDEBUG, "%s, received: bytes read report", __FUNCTION__);

	case RTMP_PACKET_TYPE_CONTROL:
		panic("Unsupported packet type RTMP_PACKET_TYPE_CONTROL")
		/*
			log.Println("RTMP_PACKET_TYPE_CONTROL")
			// TODO: port this
			C.HandleCtrl(s, pkt)
		*/
	case RTMP_PACKET_TYPE_SERVER_BW:
		// TODO: port this
		C_HandlServerBW(s, pkt)

	case RTMP_PACKET_TYPE_CLIENT_BW:
		// TODO: port this
		C_HandleClientBW(s, pkt)

	case RTMP_PACKET_TYPE_AUDIO:
		panic("Unsupported packet type RTMP_PACKET_TYPE_AUDIO")

	case RTMP_PACKET_TYPE_VIDEO:
		panic("Unsupported packet type RTMP_PACKET_TYPE_VIDEO")

	case RTMP_PACKET_TYPE_FLEX_MESSAGE:
		panic("Unsupported packet type RTMP_PACKET_TYPE_FLEX_MESSAGE")

	case RTMP_PACKET_TYPE_INFO:
		panic("Unsupported packet type RTMP_PACKET_TYPE_INFO")

	case RTMP_PACKET_TYPE_INVOKE:
		log.Println("RTMP_PACKET_TYPE_INVOKE:")
		// TODO use new logger here
		//RTMP_Log(RTMP_LOGDEBUG, "%s, received: invoke %u bytes", __FUNCTION__,pkt.bodySize);

		err := C_HandleInvoke(s, pkt.body[:pkt.bodySize])
		if err != nil {
			// This will never happen with the methods we implement.
			log.Println("HasMediaPacket")
			hasMediaPacket = 2
		}

	case RTMP_PACKET_TYPE_FLASH_VIDEO:
		panic("Unsupported packet type RTMP_PACKET_TYPE_FLASH_VIDEO")

	default:
		// TODO use new logger here
		// RTMP_Log(RTMP_LOGDEBUG, "%s, unknown packet type received: 0x%02x", __FUNCTION__,pkt.packetType);
	}
	return hasMediaPacket
}

// int ReadN(RTMP* r, char* buffer, int n);
// rtmp.c +1390
func C_ReadN(s *Session, buf []byte) error {
	err := s.link.conn.SetReadDeadline(time.Now().Add(time.Second * time.Duration(s.link.timeout)))
	if err != nil {
		return err
	}
	n, err := io.ReadFull(s.link.conn, buf)
	if err != nil {
		if debugMode {
			log.Printf("C_ReadN error: %v\n", err)
		}
		s.close()
		return err
	}
	s.nBytesIn += int32(n)
	if s.nBytesIn > (s.nBytesInSent + s.clientBW/10) {
		err := C_SendBytesReceived(s)
		if err != nil {
			return err
		}
	}
	return nil
}

// int WriteN(RTMP* r, const char* buffer, int n);
// rtmp.c +1502
func C_WriteN(s *Session, buf []byte) error {
	//ToDo: consider using a different timeout for writes than for reads
	err := s.link.conn.SetWriteDeadline(time.Now().Add(time.Second * time.Duration(s.link.timeout)))
	if err != nil {
		return err
	}
	_, err = s.link.conn.Write(buf)
	if err != nil {
		if debugMode {
			log.Printf("C_WriteN, RTMP send error: %v\n", err)
		}
		s.close()
		return err
	}
	return nil
}

// int SendConnectPacket(RTMP* r, RTMPPacket* cp);
// rtmp.c +1579
func C_SendConnectPacket(s *Session, cp *packet) error {
	if cp != nil {
		return C_RTMP_SendPacket(s, cp, 1)
	}

	var pbuf [4096]byte
	pkt := packet{
		channel:         0x03,
		headerType:      RTMP_PACKET_SIZE_LARGE,
		packetType:      RTMP_PACKET_TYPE_INVOKE,
		timestamp:       0,
		info:            0,
		hasAbsTimestamp: false,
		header:          pbuf[:],
		body:            pbuf[RTMP_MAX_HEADER_SIZE:],
	}
	enc := pkt.body

	enc = C_AMF_EncodeString(enc, av_connect)
	if enc == nil {
		return errEncoding
	}
	s.numInvokes += 1
	enc = C_AMF_EncodeNumber(enc, float64(s.numInvokes))
	if enc == nil {
		return errEncoding
	}
	enc[0] = AMF_OBJECT
	enc = enc[1:]

	enc = C_AMF_EncodeNamedString(enc, av_app, s.link.app)
	if enc == nil {
		return errEncoding
	}
	if s.link.protocol&RTMP_FEATURE_WRITE != 0 {
		enc = C_AMF_EncodeNamedString(enc, av_type, av_nonprivate)
		if enc == nil {
			return errEncoding
		}
	}

	if s.link.flashVer != "" {
		enc = C_AMF_EncodeNamedString(enc, av_flashVer, s.link.flashVer)
		if enc == nil {
			return errEncoding
		}
	}
	if s.link.swfUrl != "" {
		enc = C_AMF_EncodeNamedString(enc, av_swfUrl, s.link.swfUrl)
		if enc == nil {
			return errEncoding
		}
	}

	if s.link.tcUrl != "" {
		enc = C_AMF_EncodeNamedString(enc, av_tcUrl, s.link.tcUrl)
		if enc == nil {
			return errEncoding
		}
	}

	if s.link.protocol&RTMP_FEATURE_WRITE == 0 {
		enc = C_AMF_EncodeNamedBoolean(enc, av_fpad, false)
		if enc == nil {
			return errEncoding
		}
		enc = C_AMF_EncodeNamedNumber(enc, av_capabilities, 15)
		if enc == nil {
			return errEncoding
		}
		enc = C_AMF_EncodeNamedNumber(enc, av_audioCodecs, s.audioCodecs)
		if enc == nil {
			return errEncoding
		}
		enc = C_AMF_EncodeNamedNumber(enc, av_videoCodecs, s.videoCodecs)
		if enc == nil {
			return errEncoding
		}
		enc = C_AMF_EncodeNamedNumber(enc, av_videoFunction, 1)
		if enc == nil {
			return errEncoding
		}
		if s.link.pageUrl != "" {
			enc = C_AMF_EncodeNamedString(enc, av_pageUrl, s.link.pageUrl)
			if enc == nil {
				return errEncoding
			}
		}
	}

	if s.encoding != 0.0 || s.sendEncoding {
		enc = C_AMF_EncodeNamedNumber(enc, av_objectEncoding, s.encoding)
		if enc == nil {
			return errEncoding
		}
	}

	if copy(enc, []byte{0, 0, AMF_OBJECT_END}) != 3 {
		return errCopying // TODO: is this even possible?
	}
	enc = enc[3:]

	/* add auth string */
	if s.link.auth != "" {
		enc = C_AMF_EncodeBoolean(enc, s.link.lFlags&RTMP_LF_AUTH != 0)
		if enc == nil {
			return errEncoding
		}
		enc = C_AMF_EncodeString(enc, s.link.auth)
		if enc == nil {
			return errEncoding
		}
	}

	for i := range s.link.extras.o_props {
		enc = C_AMF_PropEncode(&s.link.extras.o_props[i], enc)
		if enc == nil {
			return errEncoding
		}
	}

	pkt.bodySize = uint32((len(pbuf) - RTMP_MAX_HEADER_SIZE) - len(enc))

	return C_RTMP_SendPacket(s, &pkt, 1)
}

// int RTMP_SendCreateStream(RTMP* r);
// rtmp.c +1725
func C_RTMP_SendCreateStream(s *Session) error {
	var pbuf [256]byte
	pkt := packet{
		channel:         0x03, /* control channel (invoke) */
		headerType:      RTMP_PACKET_SIZE_MEDIUM,
		packetType:      RTMP_PACKET_TYPE_INVOKE,
		timestamp:       0,
		info:            0,
		hasAbsTimestamp: false,
		header:          pbuf[:],
		body:            pbuf[RTMP_MAX_HEADER_SIZE:],
	}
	enc := pkt.body

	enc = C_AMF_EncodeString(enc, av_createStream)
	if enc == nil {
		return errEncoding
	}
	s.numInvokes++
	enc = C_AMF_EncodeNumber(enc, float64(s.numInvokes))
	if enc == nil {
		return errEncoding
	}
	enc[0] = AMF_NULL
	enc = enc[1:]

	pkt.bodySize = uint32((len(pbuf) - RTMP_MAX_HEADER_SIZE) - len(enc))

	return C_RTMP_SendPacket(s, &pkt, 1)
}

// int SendReleaseStream(RTMP* r);
// rtmp.c +1816
func C_SendReleaseStream(s *Session) error {
	var pbuf [1024]byte
	pkt := packet{
		channel:         0x03, /* control channel (invoke) */
		headerType:      RTMP_PACKET_SIZE_MEDIUM,
		packetType:      RTMP_PACKET_TYPE_INVOKE,
		timestamp:       0,
		info:            0,
		hasAbsTimestamp: false,
		header:          pbuf[:],
		body:            pbuf[RTMP_MAX_HEADER_SIZE:],
	}
	enc := pkt.body

	enc = C_AMF_EncodeString(enc, av_releaseStream)
	if enc == nil {
		return errEncoding
	}
	s.numInvokes++
	enc = C_AMF_EncodeNumber(enc, float64(s.numInvokes))
	if enc == nil {
		return errEncoding
	}
	enc[0] = AMF_NULL
	enc = enc[1:]
	enc = C_AMF_EncodeString(enc, s.link.playpath)
	if enc == nil {
		return errEncoding
	}
	pkt.bodySize = uint32((len(pbuf) - RTMP_MAX_HEADER_SIZE) - len(enc))

	return C_RTMP_SendPacket(s, &pkt, 0)
}

// int SendFCPublish(RTMP* r);
// rtmp.c +1846
func C_SendFCPublish(s *Session) error {
	var pbuf [1024]byte
	pkt := packet{
		channel:         0x03, /* control channel (invoke) */
		headerType:      RTMP_PACKET_SIZE_MEDIUM,
		packetType:      RTMP_PACKET_TYPE_INVOKE,
		timestamp:       0,
		info:            0,
		hasAbsTimestamp: false,
		header:          pbuf[:],
		body:            pbuf[RTMP_MAX_HEADER_SIZE:],
	}
	enc := pkt.body

	enc = C_AMF_EncodeString(enc, av_FCPublish)
	if enc == nil {
		return errEncoding
	}
	s.numInvokes++
	enc = C_AMF_EncodeNumber(enc, float64(s.numInvokes))
	if enc == nil {
		return errEncoding
	}
	enc[0] = AMF_NULL
	enc = enc[1:]
	enc = C_AMF_EncodeString(enc, s.link.playpath)
	if enc == nil {
		return errEncoding
	}

	pkt.bodySize = uint32((len(pbuf) - RTMP_MAX_HEADER_SIZE) - len(enc))

	return C_RTMP_SendPacket(s, &pkt, 0)
}

// int SendFCUnpublish(RTMP *r);
// rtmp.c +1875
func C_SendFCUnpublish(s *Session) error {
	var pbuf [1024]byte
	pkt := packet{
		channel:         0x03, /* control channel (invoke) */
		headerType:      RTMP_PACKET_SIZE_MEDIUM,
		packetType:      RTMP_PACKET_TYPE_INVOKE,
		timestamp:       0,
		info:            0,
		hasAbsTimestamp: false,
		header:          pbuf[:],
		body:            pbuf[RTMP_MAX_HEADER_SIZE:],
	}
	enc := pkt.body

	enc = C_AMF_EncodeString(enc, av_FCUnpublish)
	if enc == nil {
		return errEncoding
	}
	s.numInvokes++
	enc = C_AMF_EncodeNumber(enc, float64(s.numInvokes))
	if enc == nil {
		return errEncoding
	}
	enc[0] = AMF_NULL
	enc = enc[1:]
	enc = C_AMF_EncodeString(enc, s.link.playpath)
	if enc == nil {
		return errEncoding
	}

	pkt.bodySize = uint32((len(pbuf) - RTMP_MAX_HEADER_SIZE) - len(enc))

	return C_RTMP_SendPacket(s, &pkt, 0)
}

// int SendPublish(RTMP* r);
// rtmp.c +1908
func C_SendPublish(s *Session) error {
	var pbuf [1024]byte
	pkt := packet{
		channel:         0x04, /* source channel (invoke) */
		headerType:      RTMP_PACKET_SIZE_LARGE,
		packetType:      RTMP_PACKET_TYPE_INVOKE,
		timestamp:       0,
		info:            s.streamID,
		hasAbsTimestamp: false,
		header:          pbuf[:],
		body:            pbuf[RTMP_MAX_HEADER_SIZE:],
	}
	enc := pkt.body

	enc = C_AMF_EncodeString(enc, av_publish)
	if enc == nil {
		return errEncoding
	}
	s.numInvokes++
	enc = C_AMF_EncodeNumber(enc, float64(s.numInvokes))
	if enc == nil {
		return errEncoding
	}
	enc[0] = AMF_NULL
	enc = enc[1:]
	enc = C_AMF_EncodeString(enc, s.link.playpath)
	if enc == nil {
		return errEncoding
	}
	enc = C_AMF_EncodeString(enc, av_live)
	if enc == nil {
		return errEncoding
	}

	pkt.bodySize = uint32((len(pbuf) - RTMP_MAX_HEADER_SIZE) - len(enc))

	return C_RTMP_SendPacket(s, &pkt, 1)
}

// int
// SendDeleteStream(RTMP *r, double dStreamId)
// rtmp.c +1942
func C_SendDeleteStream(s *Session, dStreamId float64) error {
	var pbuf [256]byte
	pkt := packet{
		channel:         0x03, /* control channel (invoke) */
		headerType:      RTMP_PACKET_SIZE_MEDIUM,
		packetType:      RTMP_PACKET_TYPE_INVOKE,
		timestamp:       0,
		info:            0,
		hasAbsTimestamp: false,
		header:          pbuf[:],
		body:            pbuf[RTMP_MAX_HEADER_SIZE:],
	}
	enc := pkt.body

	enc = C_AMF_EncodeString(enc, av_deleteStream)
	if enc == nil {
		return errEncoding
	}
	s.numInvokes++
	enc = C_AMF_EncodeNumber(enc, float64(s.numInvokes))
	if enc == nil {
		return errEncoding
	}
	enc[0] = AMF_NULL
	enc = enc[1:]
	enc = C_AMF_EncodeNumber(enc, dStreamId)
	if enc == nil {
		return errEncoding
	}
	pkt.bodySize = uint32((len(pbuf) - RTMP_MAX_HEADER_SIZE) - len(enc))

	/* no response expected */
	return C_RTMP_SendPacket(s, &pkt, 0)
}

// int SendBytesReceived(RTMP* r);
// rtmp.c +2080
func C_SendBytesReceived(s *Session) error {
	var pbuf [256]byte
	pkt := packet{
		channel:         0x02, /* control channel (invoke) */
		headerType:      RTMP_PACKET_SIZE_MEDIUM,
		packetType:      RTMP_PACKET_TYPE_BYTES_READ_REPORT,
		timestamp:       0,
		info:            0,
		hasAbsTimestamp: false,
		header:          pbuf[:],
		body:            pbuf[RTMP_MAX_HEADER_SIZE:],
	}
	enc := pkt.body

	s.nBytesInSent = s.nBytesIn
	enc = C_AMF_EncodeInt32(enc, s.nBytesIn)
	if enc == nil {
		return errEncoding
	}
	pkt.bodySize = 4

	return C_RTMP_SendPacket(s, &pkt, 0)
}

// int SendCheckBW(RTMP* r);
// rtmp.c +2105
func C_SendCheckBW(s *Session) error {
	var pbuf [256]byte
	pkt := packet{
		channel:         0x03, /* control channel (invoke) */
		headerType:      RTMP_PACKET_SIZE_LARGE,
		packetType:      RTMP_PACKET_TYPE_INVOKE,
		timestamp:       0,
		info:            0,
		hasAbsTimestamp: false,
		header:          pbuf[:],
		body:            pbuf[RTMP_MAX_HEADER_SIZE:],
	}
	enc := pkt.body

	enc = C_AMF_EncodeString(enc, av__checkbw)
	if enc == nil {
		return errEncoding
	}
	s.numInvokes++
	enc = C_AMF_EncodeNumber(enc, float64(s.numInvokes))
	if enc == nil {
		return errEncoding
	}
	enc[0] = AMF_NULL
	enc = enc[1:]

	pkt.bodySize = uint32((len(pbuf) - RTMP_MAX_HEADER_SIZE) - len(enc))

	return C_RTMP_SendPacket(s, &pkt, 0)
}

// void AV_erase(method* vals, int* num, int i, int freeit);
// rtmp.c +2393
func C_AV_erase(m []method, i int) []method {
	copy(m[i:], m[i+1:])
	m[len(m)-1] = method{}
	return m[:len(m)-1]
}

// int HandleInvoke(RTMP* r, const char* body, unsigned int bodySize);
// rtmp.c +2912
// Side effects: s.isPlaying set to true upon av_NetStream_Publish_Start
func C_HandleInvoke(s *Session, body []byte) error {
	if body[0] != 0x02 {
		return errInvalidBody
	}
	var obj C_AMFObject
	nRes := C_AMF_Decode(&obj, body, 0)
	if nRes < 0 {
		return errDecoding
	}

	// NOTE we don't really need this ?? still functions without it
	//C.AMF_Dump(&obj)
	//C.AMFProp_GetString(C_AMF_GetProp(&obj, nil, 0), &method)
	meth := C_AMFProp_GetString(C_AMF_GetProp(&obj, "", 0))
	txn := C_AMFProp_GetNumber(C_AMF_GetProp(&obj, "", 1))
	// TODO use new logger here
	// RTMP_Log(RTMP_LOGDEBUG, "%s, server invoking <%s>", __FUNCTION__, method.av_val);

	switch meth {
	case av__result:
		var methodInvoked string
		for i, m := range s.methodCalls {
			if float64(m.num) == txn {
				methodInvoked = m.name
				s.methodCalls = C_AV_erase(s.methodCalls, i)
				break
			}
		}
		if methodInvoked == "" {
			// TODO use new logger here
			//RTMP_Log(RTMP_LOGDEBUG, "%s, received result id %f without matching request",
			//__FUNCTION__, txn);
			goto leave
		}
		// TODO use new logger here
		//RTMP_Log(RTMP_LOGDEBUG, "%s, received result for method call <%s>", __FUNCTION__,
		//methodInvoked.av_val);
		switch methodInvoked {
		case av_connect:
			if s.link.token != "" {
				panic("No support for link token")

			}
			if (s.link.protocol & RTMP_FEATURE_WRITE) != 0 {
				C_SendReleaseStream(s)
				C_SendFCPublish(s)
			} else {
				panic("Link protocol has no RTMP_FEATURE_WRITE")
			}

			C_RTMP_SendCreateStream(s)
			if (s.link.protocol & RTMP_FEATURE_WRITE) == 0 {
				panic("Link protocol has no RTMP_FEATURE_WRITE")
			}

		case av_createStream:
			s.streamID = int32(C_AMFProp_GetNumber(C_AMF_GetProp(&obj, "", 3)))

			if s.link.protocol&RTMP_FEATURE_WRITE != 0 {
				C_SendPublish(s)
			} else {
				panic("Link protocol has no RTMP_FEATURE_WRITE")
			}

		case av_play, av_publish:
			panic("Unsupported method av_play/av_publish")
		}
		//C.free(unsafe.Pointer(methodInvoked.av_val))

	case av_onBWDone:
		if s.bwCheckCounter == 0 {
			C_SendCheckBW(s)
		}

	case av_onFCUnsubscribe, av_onFCSubscribe:
		panic("Unsupported method av_onFCUnsubscribe/av_onFCSubscribe")

	case av_ping:
		panic("Unsupported method av_ping")

	case av__onbwcheck:
		panic("Unsupported method av_onbwcheck")

	case av__onbwdone:
		panic("Unsupported method av_onbwdone")

	case av_close:
		panic("Unsupported method av_close")

	case av_onStatus:
		var obj2 C_AMFObject
		C_AMFProp_GetObject(C_AMF_GetProp(&obj, "", 3), &obj2)
		code := C_AMFProp_GetString(C_AMF_GetProp(&obj2, av_code, -1))

		level := C_AMFProp_GetString(C_AMF_GetProp(&obj2, av_level, -1)) // Not used.
		_ = level

		// TODO use new logger
		// RTMP_Log(RTMP_LOGDEBUG, "%s, onStatus: %s", __FUNCTION__, code.av_val);

		switch code {
		case av_NetStream_Failed, av_NetStream_Play_Failed,
			av_NetStream_Play_StreamNotFound, av_NetConnection_Connect_InvalidApp:
			panic("Unsupported method av_NetStream/av_NetStream_Play_Failed/av_netSTream_Play_StreamNotFound/av_netConnection_Connect_invalidApp")

		case av_NetStream_Play_Start, av_NetStream_Play_PublishNotify:
			panic("Unsupported method av_NetStream_Play_Start/av_NetStream_Play_PublishNotify")

		case av_NetStream_Publish_Start:
			s.isPlaying = true
			for i, m := range s.methodCalls {
				if m.name == av_publish {
					s.methodCalls = C_AV_erase(s.methodCalls, i)
					break
				}
			}

		case av_NetStream_Play_Complete, av_NetStream_Play_Stop, av_NetStream_Play_UnpublishNotify:
			panic("Unsupported method av_NetStream_Play_Complete/av_NetStream_Play_Stop/av_NetStream_Play_UnpublishNotify")

		case av_NetStream_Seek_Notify:
			panic("Unsupported method av_netStream_Seek_Notify")

		case av_NetStream_Pause_Notify:
			panic("Unsupported method av_NetStream_Pause_Notify")
		}

	case av_playlist_ready:
		panic("Unsupported method av_playlist_ready")

	default:
		panic(fmt.Sprintf("unknown method: %q", meth))
	}
leave:
	C_AMF_Reset(&obj)
	// None of the methods we implement will result in a true return.
	return nil
}

// void HandleChangeChunkSize(RTMP* r, const RTMPPacket* packet);
// rtmp.c +3345
func C_HandleChangeChunkSize(s *Session, pkt *packet) {
	if pkt.bodySize >= 4 {
		s.inChunkSize = int32(C_AMF_DecodeInt32(pkt.body[:4]))
		// TODO use new logger here
		// RTMP_Log(RTMP_LOGDEBUG, "%s, received: chunk size change to %d", __FUNCTION__, s.inChunkSize);
	}
}

// void HandleServerBW(RTMP* r, const RTMPPacket* packet);
// rtmp.c +3508
func C_HandlServerBW(s *Session, pkt *packet) {
	s.serverBW = int32(C_AMF_DecodeInt32(pkt.body[:4]))
	// TODO use new logger here
	// RTMP_Log(RTMP_LOGDEBUG, "%s: server BW = %d", __FUNCTION__, s.serverBW);
}

// void HandleClientBW(RTMP* r, const RTMPPacket* packet);
// rtmp.c +3515
func C_HandleClientBW(s *Session, pkt *packet) {
	s.clientBW = int32(C_AMF_DecodeInt32(pkt.body[:4]))
	//s.clientBW = int32(C.AMF_DecodeInt32((*byte)(unsafe.Pointer(pkt.body))))

	if pkt.bodySize > 4 {
		s.clientBW2 = pkt.body[4]
	} else {
		s.clientBW2 = 0xff
	}
	// TODO use new logger here
	// RTMP_Log(RTMP_LOGDEBUG, "%s: client BW = %d %d", __FUNCTION__, s.clientBW,
	//s.clientBW2);
}

// static int DecodeInt32LE(const char* data);
// rtmp.c +3527
func C_DecodeInt32LE(data []byte) int32 {
	return int32(data[3])<<24 | int32(data[2])<<16 | int32(data[1])<<8 | int32(data[0])
}

// int EncodeInt32LE(char* output, int nVal);
// rtmp.c +3537
func C_EncodeInt32LE(dst []byte, v int32) int32 {
	binary.LittleEndian.PutUint32(dst, uint32(v))
	return 4
}

// int RTMP_ReadPacket(RTMP* r, RTMPPacket* packet);
// rtmp.c +3550
func C_RTMP_ReadPacket(s *Session, pkt *packet) error {
	var hbuf [RTMP_MAX_HEADER_SIZE]byte
	header := hbuf[:]

	err := C_ReadN(s, header[:1])
	if err != nil {
		log.Println("C_RTMP_ReadPacket: failed to read RTMP packet header!")
		return err
	}
	pkt.headerType = (header[0] & 0xc0) >> 6
	pkt.channel = int32(header[0] & 0x3f)
	header = header[1:]

	switch {
	case pkt.channel == 0:
		err = C_ReadN(s, header[:1])
		if err != nil {
			log.Println("C_RTMP_ReadPacket: failed to read rtmp packet header 2nd byte.")
			return err
		}
		header = header[1:]
		pkt.channel = int32(header[0]) + 64

	case pkt.channel == 1:
		err = C_ReadN(s, header[:2])
		if err != nil {
			log.Println("C_RTMP_ReadPacket: failed to read RTMP packet 3rd byte")
			return err
		}
		header = header[2:]
		pkt.channel = int32(binary.BigEndian.Uint16(header[:2])) + 64

	}

	if pkt.channel >= s.channelsAllocatedIn {
		n := pkt.channel + 10
		timestamp := append(s.channelTimestamp, make([]int32, 10)...)

		var pkts []*packet
		if s.vecChannelsIn == nil {
			pkts = make([]*packet, n)
		} else {
			pkts = append(s.vecChannelsIn[:pkt.channel:pkt.channel], make([]*packet, 10)...)
		}

		s.channelTimestamp = timestamp
		s.vecChannelsIn = pkts

		for i := int(s.channelsAllocatedIn); i < len(s.channelTimestamp); i++ {
			s.channelTimestamp[i] = 0
		}
		for i := int(s.channelsAllocatedIn); i < int(n); i++ {
			s.vecChannelsIn[i] = nil
		}
		s.channelsAllocatedIn = n
	}

	size := packetSize[pkt.headerType]
	switch {
	case size == RTMP_LARGE_HEADER_SIZE:
		pkt.hasAbsTimestamp = true
	case size < RTMP_LARGE_HEADER_SIZE:
		if s.vecChannelsIn[pkt.channel] != nil {
			*pkt = *(s.vecChannelsIn[pkt.channel])
		}
	}

	size--

	if size > 0 {
		err = C_ReadN(s, header[:size])
		if err != nil {
			log.Println("C_RTMP_ReadPacket: failed to read rtmp packet heades.")
			return err
		}
	}

	hSize := len(hbuf) - len(header) + size

	if size >= 3 {
		pkt.timestamp = C_AMF_DecodeInt24(header[:3])

		if size >= 6 {
			pkt.bodySize = C_AMF_DecodeInt24(header[3:6])
			pkt.bytesRead = 0

			if size > 6 {
				pkt.packetType = header[6]

				if size == 11 {
					pkt.info = C_DecodeInt32LE(header[7:11])
				}
			}
		}
	}

	extendedTimestamp := pkt.timestamp == 0xffffff
	if extendedTimestamp {
		err = C_ReadN(s, header[size:size+4])
		if err != nil {
			log.Println("RTMPRead_Packet: Failed to read extended timestamp")
			return err
		}
		// TODO: port this
		pkt.timestamp = C_AMF_DecodeInt32(header[size : size+4])
		hSize += 4
	}

	if pkt.bodySize > 0 && pkt.body == nil {
		resizePacket(pkt, pkt.bodySize, (hbuf[0]&0xc0)>>6)
	}

	toRead := int32(pkt.bodySize - pkt.bytesRead)
	chunkSize := s.inChunkSize

	if toRead < chunkSize {
		chunkSize = toRead
	}

	if pkt.chunk != nil {
		pkt.chunk.headerSize = int32(hSize)
		copy(pkt.chunk.header[:], hbuf[:hSize])
		pkt.chunk.data = pkt.body[pkt.bytesRead : pkt.bytesRead+uint32(chunkSize)]
	}

	err = C_ReadN(s, pkt.body[pkt.bytesRead:][:chunkSize])
	if err != nil {
		log.Println("C_RTMP_ReadPacket: failed to read RTMP packet body")
		return err
	}

	pkt.bytesRead += uint32(chunkSize)

	// keep the packet as ref for other packets on this channel
	if s.vecChannelsIn[pkt.channel] == nil {
		s.vecChannelsIn[pkt.channel] = &packet{}
	}
	*(s.vecChannelsIn[pkt.channel]) = *pkt

	if extendedTimestamp {
		s.vecChannelsIn[pkt.channel].timestamp = 0xffffff
	}

	// TODO: port this
	if C_RTMPPacket_IsReady(pkt) {
		if !pkt.hasAbsTimestamp {
			// timestamps seem to always be relative
			pkt.timestamp += uint32(s.channelTimestamp[pkt.channel])
		}
		s.channelTimestamp[pkt.channel] = int32(pkt.timestamp)

		s.vecChannelsIn[pkt.channel].body = nil
		s.vecChannelsIn[pkt.channel].bytesRead = 0
		s.vecChannelsIn[pkt.channel].hasAbsTimestamp = false
	} else {
		pkt.body = nil /* so it won't be erased on free */
	}
	return nil
}

// resizePacket adjust the packet's storage to accommodate a body of the given size.
func resizePacket(pkt *packet, size uint32, ht uint8) {
	buf := make([]byte, RTMP_MAX_HEADER_SIZE+size)
	pkt.headerType = ht
	pkt.header = buf
	pkt.body = buf[RTMP_MAX_HEADER_SIZE:]
}

// int HandShake(RTMP* r, int FP9HandShake);
// rtmp.c +3744
func C_HandShake(s *Session, FP9HandShake int32) error {
	var clientbuf [RTMP_SIG_SIZE + 1]byte
	clientsig := clientbuf[1:]

	var serversig [RTMP_SIG_SIZE]byte

	clientbuf[0] = 0x03 // not encrypted

	binary.BigEndian.PutUint32(clientsig, uint32(C_RTMP_GetTime()))
	copy(clientsig[4:8], []byte{0, 0, 0, 0})

	for i := 8; i < RTMP_SIG_SIZE; i++ {
		clientsig[i] = byte(rand.Intn(256))
	}

	err := C_WriteN(s, clientbuf[:])
	if err != nil {
		return err
	}

	var typ [1]byte
	err = C_ReadN(s, typ[:])
	if err != nil {
		return err
	}

	if debugMode {
		log.Printf("C_HandShake: Type answer: %v\n", typ[0])
	}
	if typ[0] != clientbuf[0] {
		log.Printf("C_HandShake: type mismatch: client sent %v, server sent: %v\n",
			clientbuf[0], typ)
	}
	err = C_ReadN(s, serversig[:])
	if err != nil {
		return err
	}

	// decode server response
	suptime := binary.BigEndian.Uint32(serversig[:4])
	_ = suptime
	// RTMP_Log(RTMP_LOGDEBUG, "%s: Server Uptime : %d", __FUNCTION__, suptime)
	// RTMP_Log(RTMP_LOGDEBUG, "%s: FMS Version   : %d.%d.%d.%d", __FUNCTION__,
	// 	serversig[4], serversig[5], serversig[6], serversig[7])

	// 2nd part of handshake
	err = C_WriteN(s, serversig[:])
	if err != nil {
		return err
	}

	err = C_ReadN(s, serversig[:])
	if err != nil {
		return err
	}

	if !bytes.Equal(serversig[:RTMP_SIG_SIZE], clientbuf[1:RTMP_SIG_SIZE+1]) {
		log.Printf("Client signature does not match: %q != %q",
			serversig[:RTMP_SIG_SIZE], clientbuf[1:RTMP_SIG_SIZE+1])
	}
	return nil
}

// int RTMP_SendPacket(RTMP* r, RTMPPacket* packet, int queue);
// rtmp.c +3896
func C_RTMP_SendPacket(s *Session, pkt *packet, queue int) error {
	var prevPkt *packet
	var last int

	if pkt.channel >= s.channelsAllocatedOut {
		n := int(pkt.channel + 10)

		var pkts []*packet
		if s.vecChannelsOut == nil {
			pkts = make([]*packet, n)
		} else {
			pkts = append(s.vecChannelsOut[:pkt.channel:pkt.channel], make([]*packet, 10)...)
		}
		s.vecChannelsOut = pkts

		for i := int(s.channelsAllocatedOut); i < n; i++ {
			s.vecChannelsOut[i] = nil
		}

		s.channelsAllocatedOut = int32(n)
	}
	prevPkt = s.vecChannelsOut[pkt.channel]

	if prevPkt != nil && pkt.headerType != RTMP_PACKET_SIZE_LARGE {
		// compress a bit by using the prev packet's attributes
		if prevPkt.bodySize == pkt.bodySize && prevPkt.packetType == pkt.packetType && pkt.headerType == RTMP_PACKET_SIZE_MEDIUM {
			pkt.headerType = RTMP_PACKET_SIZE_SMALL
		}

		if prevPkt.timestamp == pkt.timestamp && pkt.headerType == RTMP_PACKET_SIZE_SMALL {
			pkt.headerType = RTMP_PACKET_SIZE_MINIMUM
		}

		last = int(prevPkt.timestamp)
	}

	if pkt.headerType > 3 {
		log.Printf("Sanity failed! trying to send header of type: 0x%02x.",
			pkt.headerType)
		return errInvalidHeader
	}

	var headBytes []byte
	var origIdx int
	if pkt.body != nil {
		// Span from -packetsize for the type to the start of the body.
		headBytes = pkt.header
		origIdx = RTMP_MAX_HEADER_SIZE - packetSize[pkt.headerType]
	} else {
		// Allocate a new header and allow 6 bytes of movement backward.
		var hbuf [RTMP_MAX_HEADER_SIZE]byte
		headBytes = hbuf[:]
		origIdx = 6
	}

	var cSize int
	switch {
	case pkt.channel > 319:
		cSize = 2
	case pkt.channel > 63:
		cSize = 1
	}

	hSize := packetSize[pkt.headerType]
	if cSize != 0 {
		origIdx -= cSize
		hSize += cSize
	}

	var ts uint32
	if prevPkt != nil {
		ts = uint32(int(pkt.timestamp) - last)
	}
	if ts >= 0xffffff {
		origIdx -= 4
		hSize += 4
		log.Printf("Larger timestamp than 24-bit: 0x%v", ts)
	}

	headerIdx := origIdx

	c := pkt.headerType << 6
	switch cSize {
	case 0:
		c |= byte(pkt.channel)
	case 1:
		// Do nothing.
	case 2:
		c |= 1
	}
	headBytes[headerIdx] = c
	headerIdx++

	if cSize != 0 {
		tmp := pkt.channel - 64
		headBytes[headerIdx] = byte(tmp & 0xff)
		headerIdx++

		if cSize == 2 {
			headBytes[headerIdx] = byte(tmp >> 8)
			headerIdx++
		}
	}

	if packetSize[pkt.headerType] > 1 {
		res := ts
		if ts > 0xffffff {
			res = 0xffffff
		}
		C_AMF_EncodeInt24(headBytes[headerIdx:], int32(res))
		headerIdx += 3 // 24bits
	}

	if packetSize[pkt.headerType] > 4 {
		C_AMF_EncodeInt24(headBytes[headerIdx:], int32(pkt.bodySize))
		headerIdx += 3 // 24bits
		headBytes[headerIdx] = pkt.packetType
		headerIdx++
	}

	if packetSize[pkt.headerType] > 8 {
		n := int(C_EncodeInt32LE(headBytes[headerIdx:headerIdx+4], pkt.info))
		headerIdx += n
	}

	if ts >= 0xffffff {
		C_AMF_EncodeInt32(headBytes[headerIdx:], int32(ts))
		headerIdx += 4 // 32bits
	}

	size := int(pkt.bodySize)
	chunkSize := int(s.outChunkSize)

	if debugMode {
		log.Printf("C_RTMP_SendPacket: %v->%v, size=%v", s.link.conn.LocalAddr(), s.link.conn.RemoteAddr(), size)
	}

	// Send the previously deferred packet if combining it with the next packet would exceed the chunk size.
	if s.defered != nil && len(s.defered)+size+hSize > chunkSize {
		err := C_WriteN(s, s.defered)
		if err != nil {
			return err
		}
		s.defered = nil
	}

	// TODO(kortschak): Rewrite this horrific peice of premature optimisation.
	// NB: RTMP wants packets in chunks which are 128 bytes by default, but the server may request a different size.
	for size+hSize != 0 {
		if s.defered == nil && pkt.packetType == RTMP_PACKET_TYPE_AUDIO && size < chunkSize {
			s.defered = headBytes[origIdx:][:size+hSize]
			break
		}
		if chunkSize > size {
			chunkSize = size
		}
		bytes := headBytes[origIdx:][:chunkSize+hSize]
		if s.defered != nil {
			// Prepend the previously deferred packet and write it with the current one.
			bytes = append(s.defered, bytes...)
		}
		err := C_WriteN(s, bytes)
		if err != nil {
			return err
		}
		s.defered = nil

		size -= chunkSize
		origIdx += chunkSize + hSize
		hSize = 0

		if size > 0 {
			origIdx -= 1 + cSize
			hSize = 1 + cSize

			if ts >= 0xffffff {
				origIdx -= 4
				hSize += 4
			}

			headBytes[origIdx] = 0xc0 | c

			if cSize != 0 {
				tmp := int(pkt.channel) - 64
				headBytes[origIdx+1] = byte(tmp)

				if cSize == 2 {
					headBytes[origIdx+2] = byte(tmp >> 8)
				}
			}
			if ts >= 0xffffff {
				extendedTimestamp := headBytes[origIdx+1+cSize:]
				C_AMF_EncodeInt32(extendedTimestamp[:4], int32(ts))
			}
		}
	}

	// We invoked a remote method
	// TODO: port the const
	if pkt.packetType == RTMP_PACKET_TYPE_INVOKE {
		buf := pkt.body[1:]
		meth := C_AMF_DecodeString(buf)

		if debugMode {
			log.Printf("invoking %v", meth)
		}
		// keep it in call queue till result arrives
		if queue != 0 {
			buf = buf[3+len(meth):]
			txn := int32(C_AMF_DecodeNumber(buf[:8]))
			s.methodCalls = append(s.methodCalls, method{name: meth, num: txn})
		}
	}

	if s.vecChannelsOut[pkt.channel] == nil {
		s.vecChannelsOut[pkt.channel] = &packet{}
	}
	*(s.vecChannelsOut[pkt.channel]) = *pkt

	return nil
}

/// int RTMP_Write(RTMP* r, const char* buf, int size);
// rtmp.c +5136
func C_RTMP_Write(s *Session, buf []byte) error {
	var pkt = &s.write
	var enc []byte
	size := len(buf)
	var num int

	pkt.channel = 0x04
	pkt.info = s.streamID
	for len(buf) != 0 {
		if pkt.bytesRead == 0 {
			if size < minDataSize {
				return errTinyPacket
			}

			if buf[0] == 'F' && buf[1] == 'L' && buf[2] == 'V' {
				buf = buf[13:]
			}

			pkt.packetType = buf[0]
			buf = buf[1:]
			pkt.bodySize = C_AMF_DecodeInt24(buf[:3])
			buf = buf[3:]
			pkt.timestamp = C_AMF_DecodeInt24(buf[:3])
			buf = buf[3:]
			pkt.timestamp |= uint32(buf[0]) << 24
			buf = buf[4:]

			headerType := uint8(RTMP_PACKET_SIZE_MEDIUM)
			switch pkt.packetType {
			case RTMP_PACKET_TYPE_VIDEO, RTMP_PACKET_TYPE_AUDIO:
				if pkt.timestamp == 0 {
					headerType = RTMP_PACKET_SIZE_LARGE
				}
			case RTMP_PACKET_TYPE_INFO:
				headerType = RTMP_PACKET_SIZE_LARGE
				pkt.bodySize += 16
			}

			resizePacket(pkt, pkt.bodySize, headerType)

			enc = pkt.body[:pkt.bodySize]
			if pkt.packetType == RTMP_PACKET_TYPE_INFO {
				enc = C_AMF_EncodeString(enc, setDataFrame)
				if enc == nil {
					return errEncoding
				}
				pkt.bytesRead = uint32(len(pkt.body) - len(enc))
			}

		} else {
			enc = pkt.body[:pkt.bodySize][pkt.bytesRead:]
		}
		num = int(pkt.bodySize - pkt.bytesRead)
		if num > len(buf) {
			num = len(buf)
		}

		copy(enc[:num], buf[:num])
		pkt.bytesRead += uint32(num)
		buf = buf[num:]
		if pkt.bytesRead == pkt.bodySize {
			err := C_RTMP_SendPacket(s, pkt, 0)
			pkt.body = nil
			pkt.bytesRead = 0
			if err != nil {
				return err
			}
			if len(buf) < 4 {
				return nil
			}
			buf = buf[4:]
		}
	}
	return nil
}

var rtmpErrs = [...]string{
	1: "rtmp: not connected",
	2: "rtmp: write error",
	3: "rtmp: not started",
}

type Err uint

func (e Err) Error() string {
	if 0 <= int(e) && int(e) < len(rtmpErrs) {
		s := rtmpErrs[e]
		if s != "" {
			return s
		}
	}
	return "rtmp: " + strconv.Itoa(int(e))
}