pl_mpeg.go

// Code generated by go generate; DO NOT EDIT.

// PL_MPEG Copywrite Dominic Szablewski
//
// Permission is hereby granted, free of charge, to any person obtaining a copy of
// this software and associated documentation files(the "Software"), to deal in
// the Software without restriction, including without limitation the rights to
// use, copy, modify, merge, publish, distribute, sublicense, and / or sell copies
// of the Software, and to permit persons to whom the Software is furnished to do
// so, subject to the following conditions :
// The above copyright notice and this permission notice shall be included in all
// copies or substantial portions of the Software.
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
// SOFTWARE.

package mpg

import (
	"github.com/gotranspile/cxgo/runtime/cmath"
	"github.com/gotranspile/cxgo/runtime/libc"
	"github.com/gotranspile/cxgo/runtime/stdio"
	"math"
	"unsafe"
)

const plm_packet_invalid_ts1 = -1
const plm_audio_samples_per_frame = 1152
const plm_buffer_default_size = 0x20000
const _true = 1
const _false = 0

type plm_t struct {
	Demux                           *plm_demux_t
	Time                            float64
	Has_ended                       int64
	Loop                            int64
	Has_decoders                    int64
	Video_enabled                   int64
	Video_packet_type               int64
	Video_buffer                    *plm_buffer_t
	Video_decoder                   *plm_video_t
	Audio_enabled                   int64
	Audio_stream_index              int64
	Audio_packet_type               int64
	Audio_lead_time                 float64
	Audio_buffer                    *plm_buffer_t
	Audio_decoder                   *plm_audio_t
	Video_decode_callback           plm_video_decode_callback
	Video_decode_callback_user_data unsafe.Pointer
	Audio_decode_callback           plm_audio_decode_callback
	Audio_decode_callback_user_data unsafe.Pointer
}
type plm_buffer_t struct {
	Bit_index               uint64
	Capacity                uint64
	Length                  uint64
	Total_size              uint64
	Discard_read_bytes      int64
	Has_ended               int64
	Free_when_done          int64
	Close_when_done         int64
	Fh                      *stdio.File
	Load_callback           plm_buffer_load_callback
	Load_callback_user_data unsafe.Pointer
	Bytes                   *uint8
	Mode                    plm_buffer_mode
}
type plm_demux_t struct {
	Buffer                   *plm_buffer_t
	Destroy_buffer_when_done int64
	System_clock_ref         float64
	Last_file_size           uint64
	Last_decoded_pts         float64
	Start_time               float64
	Duration                 float64
	Start_code               int64
	Has_pack_header          int64
	Has_system_header        int64
	Has_headers              int64
	Num_audio_streams        int64
	Num_video_streams        int64
	Current_packet           plm_packet_t
	Next_packet              plm_packet_t
}
type plm_video_t struct {
	Framerate                float64
	Time                     float64
	Frames_decoded           int64
	Width                    int64
	Height                   int64
	Mb_width                 int64
	Mb_height                int64
	Mb_size                  int64
	Luma_width               int64
	Luma_height              int64
	Chroma_width             int64
	Chroma_height            int64
	Start_code               int64
	Picture_type             int64
	Motion_forward           plm_video_motion_t
	Motion_backward          plm_video_motion_t
	Has_sequence_header      int64
	Quantizer_scale          int64
	Slice_begin              int64
	Macroblock_address       int64
	Mb_row                   int64
	Mb_col                   int64
	Macroblock_type          int64
	Macroblock_intra         int64
	Dc_predictor             [3]int64
	Buffer                   *plm_buffer_t
	Destroy_buffer_when_done int64
	Frame_current            plm_frame_t
	Frame_forward            plm_frame_t
	Frame_backward           plm_frame_t
	Frames_data              *uint8
	Block_data               [64]int64
	Intra_quant_matrix       [64]uint8
	Non_intra_quant_matrix   [64]uint8
	Has_reference_frame      int64
	Assume_no_b_frames       int64
}
type plm_audio_t struct {
	Time                     float64
	Samples_decoded          int64
	Samplerate_index         int64
	Bitrate_index            int64
	Version                  int64
	Layer                    int64
	Mode                     int64
	Bound                    int64
	V_pos                    int64
	Next_frame_data_size     int64
	Has_header               int64
	Buffer                   *plm_buffer_t
	Destroy_buffer_when_done int64
	Allocation               [2][32]*plm_quantizer_spec_t
	Scale_factor_info        [2][32]uint8
	Scale_factor             [2][32][3]int64
	Sample                   [2][32][3]int64
	Samples                  plm_samples_t
	D                        [1024]float32
	V                        [2][1024]float32
	U                        [32]float32
}
type plm_packet_t struct {
	Type   int64
	Pts    float64
	Length uint64
	Data   *uint8
}
type plm_plane_t struct {
	Width  uint64
	Height uint64
	Data   *uint8
}
type plm_frame_t struct {
	Time   float64
	Width  uint64
	Height uint64
	Y      plm_plane_t
	Cr     plm_plane_t
	Cb     plm_plane_t
}
type plm_video_decode_callback func(self *plm_t, frame *plm_frame_t, user unsafe.Pointer)
type plm_samples_t struct {
	Time        float64
	Count       uint64
	Interleaved [2304]float32
}
type plm_audio_decode_callback func(self *plm_t, samples *plm_samples_t, user unsafe.Pointer)
type plm_buffer_load_callback func(self *plm_buffer_t, user unsafe.Pointer)

var plm_demux_packet_private int64 = 189
var plm_demux_packet_audio_1 int64 = 192
var plm_demux_packet_audio_2 int64 = 193
var plm_demux_packet_audio_3 int64 = 194
var plm_demux_packet_audio_4 int64 = 194
var plm_demux_packet_video_1 int64 = 224

func plm_create_with_filename(filename *byte) *plm_t {
	var buffer *plm_buffer_t = plm_buffer_create_with_filename(filename)
	if buffer == nil {
		return nil
	}
	return plm_create_with_buffer(buffer, _true)
}
func plm_create_with_file(fh *stdio.File, close_when_done int64) *plm_t {
	var buffer *plm_buffer_t = plm_buffer_create_with_file(fh, close_when_done)
	return plm_create_with_buffer(buffer, _true)
}
func plm_create_with_memory(bytes *uint8, length uint64, free_when_done int64) *plm_t {
	var buffer *plm_buffer_t = plm_buffer_create_with_memory(bytes, length, free_when_done)
	return plm_create_with_buffer(buffer, _true)
}
func plm_create_with_buffer(buffer *plm_buffer_t, destroy_when_done int64) *plm_t {
	var self *plm_t = new(plm_t)
	*self = plm_t{}
	self.Demux = plm_demux_create(buffer, destroy_when_done)
	self.Video_enabled = _true
	self.Audio_enabled = _true
	plm_init_decoders(self)
	return self
}
func plm_init_decoders(self *plm_t) int64 {
	if self.Has_decoders != 0 {
		return _true
	}
	if plm_demux_has_headers(self.Demux) == 0 {
		return _false
	}
	if plm_demux_get_num_video_streams(self.Demux) > 0 {
		if self.Video_enabled != 0 {
			self.Video_packet_type = plm_demux_packet_video_1
		}
		self.Video_buffer = plm_buffer_create_with_capacity(128 * 1024)
		plm_buffer_set_load_callback(self.Video_buffer, func(self *plm_buffer_t, user unsafe.Pointer) {
			plm_read_video_packet(self, user)
		}, unsafe.Pointer(self))
	}
	if plm_demux_get_num_audio_streams(self.Demux) > 0 {
		if self.Audio_enabled != 0 {
			self.Audio_packet_type = plm_demux_packet_audio_1 + self.Audio_stream_index
		}
		self.Audio_buffer = plm_buffer_create_with_capacity(128 * 1024)
		plm_buffer_set_load_callback(self.Audio_buffer, func(self *plm_buffer_t, user unsafe.Pointer) {
			plm_read_audio_packet(self, user)
		}, unsafe.Pointer(self))
	}
	if self.Video_buffer != nil {
		self.Video_decoder = plm_video_create_with_buffer(self.Video_buffer, _true)
	}
	if self.Audio_buffer != nil {
		self.Audio_decoder = plm_audio_create_with_buffer(self.Audio_buffer, _true)
	}
	self.Has_decoders = _true
	return _true
}
func plm_destroy(self *plm_t) {
	if self.Video_decoder != nil {
		plm_video_destroy(self.Video_decoder)
	}
	if self.Audio_decoder != nil {
		plm_audio_destroy(self.Audio_decoder)
	}
	plm_demux_destroy(self.Demux)
	libc.Free(unsafe.Pointer(self))
}
func plm_get_audio_enabled(self *plm_t) int64 {
	return self.Audio_enabled
}
func plm_has_headers(self *plm_t) int64 {
	if plm_demux_has_headers(self.Demux) == 0 {
		return _false
	}
	if plm_init_decoders(self) == 0 {
		return _false
	}
	if self.Video_decoder != nil && plm_video_has_header(self.Video_decoder) == 0 || self.Audio_decoder != nil && plm_audio_has_header(self.Audio_decoder) == 0 {
		return _false
	}
	return _true
}
func plm_set_audio_enabled(self *plm_t, enabled int64) {
	self.Audio_enabled = enabled
	if enabled == 0 {
		self.Audio_packet_type = 0
		return
	}
	if plm_init_decoders(self) != 0 && self.Audio_decoder != nil {
		self.Audio_packet_type = plm_demux_packet_audio_1 + self.Audio_stream_index
	} else {
		self.Audio_packet_type = 0
	}
}
func plm_set_audio_stream(self *plm_t, stream_index int64) {
	if stream_index < 0 || stream_index > 3 {
		return
	}
	self.Audio_stream_index = stream_index
	plm_set_audio_enabled(self, self.Audio_enabled)
}
func plm_get_video_enabled(self *plm_t) int64 {
	return self.Video_enabled
}
func plm_set_video_enabled(self *plm_t, enabled int64) {
	self.Video_enabled = enabled
	if enabled == 0 {
		self.Video_packet_type = 0
		return
	}
	if plm_init_decoders(self) != 0 && self.Video_decoder != nil {
		self.Video_packet_type = plm_demux_packet_video_1
	} else {
		self.Video_packet_type = 0
	}
}
func plm_get_num_video_streams(self *plm_t) int64 {
	return plm_demux_get_num_video_streams(self.Demux)
}
func plm_get_width(self *plm_t) int64 {
	if plm_init_decoders(self) != 0 && self.Video_decoder != nil {
		return plm_video_get_width(self.Video_decoder)
	}
	return 0
}
func plm_get_height(self *plm_t) int64 {
	if plm_init_decoders(self) != 0 && self.Video_decoder != nil {
		return plm_video_get_height(self.Video_decoder)
	}
	return 0
}
func plm_get_framerate(self *plm_t) float64 {
	if plm_init_decoders(self) != 0 && self.Video_decoder != nil {
		return plm_video_get_framerate(self.Video_decoder)
	}
	return 0
}
func plm_get_num_audio_streams(self *plm_t) int64 {
	return plm_demux_get_num_audio_streams(self.Demux)
}
func plm_get_samplerate(self *plm_t) int64 {
	if plm_init_decoders(self) != 0 && self.Audio_decoder != nil {
		return plm_audio_get_samplerate(self.Audio_decoder)
	}
	return 0
}
func plm_get_audio_lead_time(self *plm_t) float64 {
	return self.Audio_lead_time
}
func plm_set_audio_lead_time(self *plm_t, lead_time float64) {
	self.Audio_lead_time = lead_time
}
func plm_get_time(self *plm_t) float64 {
	return self.Time
}
func plm_get_duration(self *plm_t) float64 {
	return plm_demux_get_duration(self.Demux, plm_demux_packet_video_1)
}
func plm_rewind(self *plm_t) {
	if self.Video_decoder != nil {
		plm_video_rewind(self.Video_decoder)
	}
	if self.Audio_decoder != nil {
		plm_audio_rewind(self.Audio_decoder)
	}
	plm_demux_rewind(self.Demux)
	self.Time = 0
}
func plm_get_loop(self *plm_t) int64 {
	return self.Loop
}
func plm_set_loop(self *plm_t, loop int64) {
	self.Loop = loop
}
func plm_has_ended(self *plm_t) int64 {
	return self.Has_ended
}
func plm_set_video_decode_callback(self *plm_t, fp plm_video_decode_callback, user unsafe.Pointer) {
	self.Video_decode_callback = fp
	self.Video_decode_callback_user_data = user
}
func plm_set_audio_decode_callback(self *plm_t, fp plm_audio_decode_callback, user unsafe.Pointer) {
	self.Audio_decode_callback = fp
	self.Audio_decode_callback_user_data = user
}
func plm_decode(self *plm_t, tick float64) {
	if plm_init_decoders(self) == 0 {
		return
	}
	var decode_video int64 = int64(libc.BoolToInt(self.Video_decode_callback != nil && self.Video_packet_type != 0))
	var decode_audio int64 = int64(libc.BoolToInt(self.Audio_decode_callback != nil && self.Audio_packet_type != 0))
	if decode_video == 0 && decode_audio == 0 {
		return
	}
	var did_decode int64 = _false
	var decode_video_failed int64 = _false
	var decode_audio_failed int64 = _false
	var video_target_time float64 = self.Time + tick
	var audio_target_time float64 = self.Time + tick + self.Audio_lead_time
	for {
		did_decode = _false
		if decode_video != 0 && plm_video_get_time(self.Video_decoder) < video_target_time {
			var frame *plm_frame_t = plm_video_decode(self.Video_decoder)
			if frame != nil {
				self.Video_decode_callback(self, frame, self.Video_decode_callback_user_data)
				did_decode = _true
			} else {
				decode_video_failed = _true
			}
		}
		if decode_audio != 0 && plm_audio_get_time(self.Audio_decoder) < audio_target_time {
			var samples *plm_samples_t = plm_audio_decode(self.Audio_decoder)
			if samples != nil {
				self.Audio_decode_callback(self, samples, self.Audio_decode_callback_user_data)
				did_decode = _true
			} else {
				decode_audio_failed = _true
			}
		}
		if did_decode == 0 {
			break
		}
	}
	if (decode_video == 0 || decode_video_failed != 0) && (decode_audio == 0 || decode_audio_failed != 0) && plm_demux_has_ended(self.Demux) != 0 {
		plm_handle_end(self)
		return
	}
	self.Time += tick
}
func plm_decode_video(self *plm_t) *plm_frame_t {
	if plm_init_decoders(self) == 0 {
		return nil
	}
	if self.Video_packet_type == 0 {
		return nil
	}
	var frame *plm_frame_t = plm_video_decode(self.Video_decoder)
	if frame != nil {
		self.Time = frame.Time
	} else if plm_demux_has_ended(self.Demux) != 0 {
		plm_handle_end(self)
	}
	return frame
}
func plm_decode_audio(self *plm_t) *plm_samples_t {
	if plm_init_decoders(self) == 0 {
		return nil
	}
	if self.Audio_packet_type == 0 {
		return nil
	}
	var samples *plm_samples_t = plm_audio_decode(self.Audio_decoder)
	if samples != nil {
		self.Time = samples.Time
	} else if plm_demux_has_ended(self.Demux) != 0 {
		plm_handle_end(self)
	}
	return samples
}
func plm_handle_end(self *plm_t) {
	if self.Loop != 0 {
		plm_rewind(self)
	} else {
		self.Has_ended = _true
	}
}
func plm_read_video_packet(buffer *plm_buffer_t, user unsafe.Pointer) {
	_ = buffer
	var self *plm_t = (*plm_t)(user)
	plm_read_packets(self, self.Video_packet_type)
}
func plm_read_audio_packet(buffer *plm_buffer_t, user unsafe.Pointer) {
	_ = buffer
	var self *plm_t = (*plm_t)(user)
	plm_read_packets(self, self.Audio_packet_type)
}
func plm_read_packets(self *plm_t, requested_type int64) {
	var packet *plm_packet_t
	for (func() *plm_packet_t {
		packet = plm_demux_decode(self.Demux)
		return packet
	}()) != nil {
		if packet.Type == self.Video_packet_type {
			plm_buffer_write(self.Video_buffer, packet.Data, packet.Length)
		} else if packet.Type == self.Audio_packet_type {
			plm_buffer_write(self.Audio_buffer, packet.Data, packet.Length)
		}
		if packet.Type == requested_type {
			return
		}
	}
	if plm_demux_has_ended(self.Demux) != 0 {
		if self.Video_buffer != nil {
			plm_buffer_signal_end(self.Video_buffer)
		}
		if self.Audio_buffer != nil {
			plm_buffer_signal_end(self.Audio_buffer)
		}
	}
}
func plm_seek_frame(self *plm_t, time float64, seek_exact int64) *plm_frame_t {
	if plm_init_decoders(self) == 0 {
		return nil
	}
	if self.Video_packet_type == 0 {
		return nil
	}
	var type_ int64 = self.Video_packet_type
	var start_time float64 = plm_demux_get_start_time(self.Demux, type_)
	var duration float64 = plm_demux_get_duration(self.Demux, type_)
	if time < 0 {
		time = 0
	} else if time > duration {
		time = duration
	}
	var packet *plm_packet_t = plm_demux_seek(self.Demux, time, type_, _true)
	if packet == nil {
		return nil
	}
	var previous_audio_packet_type int64 = self.Audio_packet_type
	self.Audio_packet_type = 0
	plm_video_rewind(self.Video_decoder)
	plm_video_set_time(self.Video_decoder, packet.Pts-start_time)
	plm_buffer_write(self.Video_buffer, packet.Data, packet.Length)
	var frame *plm_frame_t = plm_video_decode(self.Video_decoder)
	if seek_exact != 0 {
		for frame != nil && frame.Time < time {
			frame = plm_video_decode(self.Video_decoder)
		}
	}
	self.Audio_packet_type = previous_audio_packet_type
	if frame != nil {
		self.Time = frame.Time
	}
	self.Has_ended = _false
	return frame
}
func plm_seek(self *plm_t, time float64, seek_exact int64) int64 {
	var frame *plm_frame_t = plm_seek_frame(self, time, seek_exact)
	if frame == nil {
		return _false
	}
	if self.Video_decode_callback != nil {
		self.Video_decode_callback(self, frame, self.Video_decode_callback_user_data)
	}
	if self.Audio_packet_type == 0 {
		return _true
	}
	var start_time float64 = plm_demux_get_start_time(self.Demux, self.Video_packet_type)
	plm_audio_rewind(self.Audio_decoder)
	var packet *plm_packet_t = nil
	for (func() *plm_packet_t {
		packet = plm_demux_decode(self.Demux)
		return packet
	}()) != nil {
		if packet.Type == self.Video_packet_type {
			plm_buffer_write(self.Video_buffer, packet.Data, packet.Length)
		} else if packet.Type == self.Audio_packet_type && packet.Pts-start_time > self.Time {
			plm_audio_set_time(self.Audio_decoder, packet.Pts-start_time)
			plm_buffer_write(self.Audio_buffer, packet.Data, packet.Length)
			plm_decode(self, 0)
			break
		}
	}
	return _true
}

type plm_buffer_mode int64

const (
	plm_buffer_mode_file = plm_buffer_mode(iota)
	plm_buffer_mode_fixed_mem
	plm_buffer_mode_ring
	plm_buffer_mode_append
)

type plm_vlc_t struct {
	Index int16
	Value int16
}
type plm_vlc_uint_t struct {
	Index int16
	Value uint16
}

func plm_buffer_create_with_filename(filename *byte) *plm_buffer_t {
	var fh *stdio.File = stdio.FOpen(libc.GoString(filename), "rb")
	if fh == nil {
		return nil
	}
	return plm_buffer_create_with_file(fh, _true)
}
func plm_buffer_create_with_file(fh *stdio.File, close_when_done int64) *plm_buffer_t {
	var self *plm_buffer_t = plm_buffer_create_with_capacity(128 * 1024)
	self.Fh = fh
	self.Close_when_done = close_when_done
	self.Mode = plm_buffer_mode(plm_buffer_mode_file)
	self.Discard_read_bytes = _true
	self.Fh.Seek(0, stdio.SEEK_END)
	self.Total_size = uint64(self.Fh.Tell())
	self.Fh.Seek(0, stdio.SEEK_SET)
	plm_buffer_set_load_callback(self, func(self *plm_buffer_t, user unsafe.Pointer) {
		plm_buffer_load_file_callback(self, user)
	}, nil)
	return self
}
func plm_buffer_create_with_memory(bytes *uint8, length uint64, free_when_done int64) *plm_buffer_t {
	var self *plm_buffer_t = new(plm_buffer_t)
	*self = plm_buffer_t{}
	self.Capacity = length
	self.Length = length
	self.Total_size = length
	self.Free_when_done = free_when_done
	self.Bytes = bytes
	self.Mode = plm_buffer_mode(plm_buffer_mode_fixed_mem)
	self.Discard_read_bytes = _false
	return self
}
func plm_buffer_create_with_capacity(capacity uint64) *plm_buffer_t {
	var self *plm_buffer_t = new(plm_buffer_t)
	*self = plm_buffer_t{}
	self.Capacity = capacity
	self.Free_when_done = _true
	self.Bytes = (*uint8)(libc.Malloc(int(capacity)))
	self.Mode = plm_buffer_mode(plm_buffer_mode_ring)
	self.Discard_read_bytes = _true
	return self
}
func plm_buffer_create_for_appending(initial_capacity uint64) *plm_buffer_t {
	var self *plm_buffer_t = plm_buffer_create_with_capacity(initial_capacity)
	self.Mode = plm_buffer_mode(plm_buffer_mode_append)
	self.Discard_read_bytes = _false
	return self
}
func plm_buffer_destroy(self *plm_buffer_t) {
	if self.Fh != nil && self.Close_when_done != 0 {
		self.Fh.Close()
	}
	if self.Free_when_done != 0 {
		libc.Free(unsafe.Pointer(self.Bytes))
	}
	libc.Free(unsafe.Pointer(self))
}
func plm_buffer_get_size(self *plm_buffer_t) uint64 {
	if self.Mode == plm_buffer_mode(plm_buffer_mode_file) {
		return self.Total_size
	}
	return self.Length
}
func plm_buffer_get_remaining(self *plm_buffer_t) uint64 {
	return self.Length - (self.Bit_index >> 3)
}
func plm_buffer_write(self *plm_buffer_t, bytes *uint8, length uint64) uint64 {
	if self.Mode == plm_buffer_mode(plm_buffer_mode_fixed_mem) {
		return 0
	}
	if self.Discard_read_bytes != 0 {
		plm_buffer_discard_read_bytes(self)
		if self.Mode == plm_buffer_mode(plm_buffer_mode_ring) {
			self.Total_size = 0
		}
	}
	var bytes_available uint64 = self.Capacity - self.Length
	if bytes_available < length {
		var new_size uint64 = self.Capacity
		for {
			new_size *= 2
			if new_size-self.Length >= length {
				break
			}
		}
		self.Bytes = (*uint8)(libc.Realloc(unsafe.Pointer(self.Bytes), int(new_size)))
		self.Capacity = new_size
	}
	libc.MemCpy(unsafe.Add(unsafe.Pointer(self.Bytes), self.Length), unsafe.Pointer(bytes), int(length))
	self.Length += length
	self.Has_ended = _false
	return length
}
func plm_buffer_signal_end(self *plm_buffer_t) {
	self.Total_size = self.Length
}
func plm_buffer_set_load_callback(self *plm_buffer_t, fp plm_buffer_load_callback, user unsafe.Pointer) {
	self.Load_callback = fp
	self.Load_callback_user_data = user
}
func plm_buffer_rewind(self *plm_buffer_t) {
	plm_buffer_seek(self, 0)
}
func plm_buffer_seek(self *plm_buffer_t, pos uint64) {
	self.Has_ended = _false
	if self.Mode == plm_buffer_mode(plm_buffer_mode_file) {
		self.Fh.Seek(int64(pos), stdio.SEEK_SET)
		self.Bit_index = 0
		self.Length = 0
	} else if self.Mode == plm_buffer_mode(plm_buffer_mode_ring) {
		if pos != 0 {
			return
		}
		self.Bit_index = 0
		self.Length = 0
		self.Total_size = 0
	} else if pos < self.Length {
		self.Bit_index = pos << 3
	}
}
func plm_buffer_tell(self *plm_buffer_t) uint64 {
	if self.Mode == plm_buffer_mode(plm_buffer_mode_file) {
		return uint64(self.Fh.Tell()) + (self.Bit_index >> 3) - self.Length
	}
	return self.Bit_index >> 3
}
func plm_buffer_discard_read_bytes(self *plm_buffer_t) {
	var byte_pos uint64 = self.Bit_index >> 3
	if byte_pos == self.Length {
		self.Bit_index = 0
		self.Length = 0
	} else if byte_pos > 0 {
		libc.MemMove(unsafe.Pointer(self.Bytes), unsafe.Add(unsafe.Pointer(self.Bytes), byte_pos), int(self.Length-byte_pos))
		self.Bit_index -= byte_pos << 3
		self.Length -= byte_pos
	}
}
func plm_buffer_load_file_callback(self *plm_buffer_t, user unsafe.Pointer) {
	_ = user
	if self.Discard_read_bytes != 0 {
		plm_buffer_discard_read_bytes(self)
	}
	var bytes_available uint64 = self.Capacity - self.Length
	var bytes_read uint64 = uint64(self.Fh.ReadN((*byte)(unsafe.Add(unsafe.Pointer(self.Bytes), self.Length)), 1, int(bytes_available)))
	self.Length += bytes_read
	if bytes_read == 0 {
		self.Has_ended = _true
	}
}
func plm_buffer_has_ended(self *plm_buffer_t) int64 {
	return self.Has_ended
}
func plm_buffer_has(self *plm_buffer_t, count uint64) int64 {
	if ((self.Length << 3) - self.Bit_index) >= count {
		return _true
	}
	if self.Load_callback != nil {
		self.Load_callback(self, self.Load_callback_user_data)
		if ((self.Length << 3) - self.Bit_index) >= count {
			return _true
		}
	}
	if self.Total_size != 0 && self.Length == self.Total_size {
		self.Has_ended = _true
	}
	return _false
}
func plm_buffer_read(self *plm_buffer_t, count int64) int64 {
	if plm_buffer_has(self, uint64(count)) == 0 {
		return 0
	}
	var value int64 = 0
	for count != 0 {
		var (
			current_byte int64 = int64(*(*uint8)(unsafe.Add(unsafe.Pointer(self.Bytes), self.Bit_index>>3)))
			remaining    int64 = int64(8 - (self.Bit_index & 7))
			read         int64
		)
		if remaining < count {
			read = remaining
		} else {
			read = count
		}
		var shift int64 = remaining - read
		var mask int64 = (math.MaxUint8 >> (8 - read))
		value = (value << read) | (current_byte&(mask<<shift))>>shift
		self.Bit_index += uint64(read)
		count -= read
	}
	return value
}
func plm_buffer_align(self *plm_buffer_t) {
	self.Bit_index = ((self.Bit_index + 7) >> 3) << 3
}
func plm_buffer_skip(self *plm_buffer_t, count uint64) {
	if plm_buffer_has(self, count) != 0 {
		self.Bit_index += count
	}
}
func plm_buffer_skip_bytes(self *plm_buffer_t, v uint8) int64 {
	plm_buffer_align(self)
	var skipped int64 = 0
	for plm_buffer_has(self, 8) != 0 && int64(*(*uint8)(unsafe.Add(unsafe.Pointer(self.Bytes), self.Bit_index>>3))) == int64(v) {
		self.Bit_index += 8
		skipped++
	}
	return skipped
}
func plm_buffer_next_start_code(self *plm_buffer_t) int64 {
	plm_buffer_align(self)
	for plm_buffer_has(self, 5<<3) != 0 {
		var byte_index uint64 = self.Bit_index >> 3
		if int64(*(*uint8)(unsafe.Add(unsafe.Pointer(self.Bytes), byte_index))) == 0 && int64(*(*uint8)(unsafe.Add(unsafe.Pointer(self.Bytes), byte_index+1))) == 0 && int64(*(*uint8)(unsafe.Add(unsafe.Pointer(self.Bytes), byte_index+2))) == 1 {
			self.Bit_index = (byte_index + 4) << 3
			return int64(*(*uint8)(unsafe.Add(unsafe.Pointer(self.Bytes), byte_index+3)))
		}
		self.Bit_index += 8
	}
	return -1
}
func plm_buffer_find_start_code(self *plm_buffer_t, code int64) int64 {
	var current int64 = 0
	for _true != 0 {
		current = plm_buffer_next_start_code(self)
		if current == code || current == -1 {
			return current
		}
	}
	return -1
}
func plm_buffer_has_start_code(self *plm_buffer_t, code int64) int64 {
	var (
		previous_bit_index          uint64 = self.Bit_index
		previous_discard_read_bytes int64  = self.Discard_read_bytes
	)
	self.Discard_read_bytes = _false
	var current int64 = plm_buffer_find_start_code(self, code)
	self.Bit_index = previous_bit_index
	self.Discard_read_bytes = previous_discard_read_bytes
	return current
}
func plm_buffer_peek_non_zero(self *plm_buffer_t, bit_count int64) int64 {
	if plm_buffer_has(self, uint64(bit_count)) == 0 {
		return _false
	}
	var val int64 = plm_buffer_read(self, bit_count)
	self.Bit_index -= uint64(bit_count)
	return int64(libc.BoolToInt(val != 0))
}
func plm_buffer_read_vlc(self *plm_buffer_t, table *plm_vlc_t) int16 {
	var state plm_vlc_t = plm_vlc_t{}
	for {
		state = *(*plm_vlc_t)(unsafe.Add(unsafe.Pointer(table), unsafe.Sizeof(plm_vlc_t{})*uintptr(int64(state.Index)+plm_buffer_read(self, 1))))
		if int64(state.Index) <= 0 {
			break
		}
	}
	return state.Value
}
func plm_buffer_read_vlc_uint(self *plm_buffer_t, table *plm_vlc_uint_t) uint16 {
	return uint16(plm_buffer_read_vlc(self, (*plm_vlc_t)(unsafe.Pointer(table))))
}

var plm_start_pack int64 = 186
var plm_start_end int64 = 185
var plm_start_system int64 = 187

func plm_demux_create(buffer *plm_buffer_t, destroy_when_done int64) *plm_demux_t {
	var self *plm_demux_t = new(plm_demux_t)
	*self = plm_demux_t{}
	self.Buffer = buffer
	self.Destroy_buffer_when_done = destroy_when_done
	self.Start_time = float64(-1)
	self.Duration = float64(-1)
	self.Start_code = -1
	plm_demux_has_headers(self)
	return self
}
func plm_demux_destroy(self *plm_demux_t) {
	if self.Destroy_buffer_when_done != 0 {
		plm_buffer_destroy(self.Buffer)
	}
	libc.Free(unsafe.Pointer(self))
}
func plm_demux_has_headers(self *plm_demux_t) int64 {
	if self.Has_headers != 0 {
		return _true
	}
	if self.Has_pack_header == 0 {
		if self.Start_code != plm_start_pack && plm_buffer_find_start_code(self.Buffer, plm_start_pack) == -1 {
			return _false
		}
		self.Start_code = plm_start_pack
		if plm_buffer_has(self.Buffer, 64) == 0 {
			return _false
		}
		self.Start_code = -1
		if plm_buffer_read(self.Buffer, 4) != 2 {
			return _false
		}
		self.System_clock_ref = plm_demux_decode_time(self)
		plm_buffer_skip(self.Buffer, 1)
		plm_buffer_skip(self.Buffer, 22)
		plm_buffer_skip(self.Buffer, 1)
		self.Has_pack_header = _true
	}
	if self.Has_system_header == 0 {
		if self.Start_code != plm_start_system && plm_buffer_find_start_code(self.Buffer, plm_start_system) == -1 {
			return _false
		}
		self.Start_code = plm_start_system
		if plm_buffer_has(self.Buffer, 56) == 0 {
			return _false
		}
		self.Start_code = -1
		plm_buffer_skip(self.Buffer, 16)
		plm_buffer_skip(self.Buffer, 24)
		self.Num_audio_streams = plm_buffer_read(self.Buffer, 6)
		plm_buffer_skip(self.Buffer, 5)
		self.Num_video_streams = plm_buffer_read(self.Buffer, 5)
		self.Has_system_header = _true
	}
	self.Has_headers = _true
	return _true
}
func plm_demux_get_num_video_streams(self *plm_demux_t) int64 {
	if plm_demux_has_headers(self) != 0 {
		return self.Num_video_streams
	}
	return 0
}
func plm_demux_get_num_audio_streams(self *plm_demux_t) int64 {
	if plm_demux_has_headers(self) != 0 {
		return self.Num_audio_streams
	}
	return 0
}
func plm_demux_rewind(self *plm_demux_t) {
	plm_buffer_rewind(self.Buffer)
	self.Current_packet.Length = 0
	self.Next_packet.Length = 0
	self.Start_code = -1
}
func plm_demux_has_ended(self *plm_demux_t) int64 {
	return plm_buffer_has_ended(self.Buffer)
}
func plm_demux_buffer_seek(self *plm_demux_t, pos uint64) {
	plm_buffer_seek(self.Buffer, pos)
	self.Current_packet.Length = 0
	self.Next_packet.Length = 0
	self.Start_code = -1
}
func plm_demux_get_start_time(self *plm_demux_t, type_ int64) float64 {
	if self.Start_time != float64(-1) {
		return self.Start_time
	}
	var previous_pos int64 = int64(plm_buffer_tell(self.Buffer))
	var previous_start_code int64 = self.Start_code
	plm_demux_rewind(self)
	for {
		{
			var packet *plm_packet_t = plm_demux_decode(self)
			if packet == nil {
				break
			}
			if packet.Type == type_ {
				self.Start_time = packet.Pts
			}
		}
		if self.Start_time != float64(-1) {
			break
		}
	}
	plm_demux_buffer_seek(self, uint64(previous_pos))
	self.Start_code = previous_start_code
	return self.Start_time
}
func plm_demux_get_duration(self *plm_demux_t, type_ int64) float64 {
	var file_size uint64 = plm_buffer_get_size(self.Buffer)
	if self.Duration != float64(-1) && self.Last_file_size == file_size {
		return self.Duration
	}
	var previous_pos uint64 = plm_buffer_tell(self.Buffer)
	var previous_start_code int64 = self.Start_code
	var start_range int64 = 64 * 1024
	var max_range int64 = 4096 * 1024
	for range_ := int64(start_range); range_ <= max_range; range_ *= 2 {
		var seek_pos int64 = int64(file_size - uint64(range_))
		if seek_pos < 0 {
			seek_pos = 0
			range_ = max_range
		}
		plm_demux_buffer_seek(self, uint64(seek_pos))
		self.Current_packet.Length = 0
		var last_pts float64 = float64(-1)
		var packet *plm_packet_t = nil
		for (func() *plm_packet_t {
			packet = plm_demux_decode(self)
			return packet
		}()) != nil {
			if packet.Pts != float64(-1) && packet.Type == type_ {
				last_pts = packet.Pts
			}
		}
		if last_pts != float64(-1) {
			self.Duration = last_pts - plm_demux_get_start_time(self, type_)
			break
		}
	}
	plm_demux_buffer_seek(self, previous_pos)
	self.Start_code = previous_start_code
	self.Last_file_size = file_size
	return self.Duration
}
func plm_demux_seek(self *plm_demux_t, seek_time float64, type_ int64, force_intra int64) *plm_packet_t {
	if plm_demux_has_headers(self) == 0 {
		return nil
	}
	var duration float64 = plm_demux_get_duration(self, type_)
	var file_size int64 = int64(plm_buffer_get_size(self.Buffer))
	var byterate int64 = int64(float64(file_size) / duration)
	var cur_time float64 = self.Last_decoded_pts
	var scan_span float64 = 1
	if seek_time > duration {
		seek_time = duration
	} else if seek_time < 0 {
		seek_time = 0
	}
	seek_time += self.Start_time
	for retry := int64(0); retry < 32; retry++ {
		var (
			found_packet_with_pts   int64   = _false
			found_packet_in_range   int64   = _false
			last_valid_packet_start int64   = -1
			first_packet_time       float64 = float64(-1)
			cur_pos                 int64   = int64(plm_buffer_tell(self.Buffer))
			offset                  int64   = int64((seek_time - cur_time - scan_span) * float64(byterate))
			seek_pos                int64   = cur_pos + offset
		)
		if seek_pos < 0 {
			seek_pos = 0
		} else if seek_pos > file_size-256 {
			seek_pos = file_size - 256
		}
		plm_demux_buffer_seek(self, uint64(seek_pos))
		for plm_buffer_find_start_code(self.Buffer, type_) != -1 {
			var (
				packet_start int64         = int64(plm_buffer_tell(self.Buffer))
				packet       *plm_packet_t = plm_demux_decode_packet(self, type_)
			)
			if packet == nil || packet.Pts == float64(-1) {
				continue
			}
			if packet.Pts > seek_time || packet.Pts < seek_time-scan_span {
				found_packet_with_pts = _true
				byterate = int64(float64(seek_pos-cur_pos) / (packet.Pts - cur_time))
				cur_time = packet.Pts
				break
			}
			if found_packet_in_range == 0 {
				found_packet_in_range = _true
				first_packet_time = packet.Pts
			}
			if force_intra != 0 {
				for i := uint64(0); i < packet.Length-6; i++ {
					if int64(*(*uint8)(unsafe.Add(unsafe.Pointer(packet.Data), i))) == 0 && int64(*(*uint8)(unsafe.Add(unsafe.Pointer(packet.Data), i+1))) == 0 && int64(*(*uint8)(unsafe.Add(unsafe.Pointer(packet.Data), i+2))) == 1 && int64(*(*uint8)(unsafe.Add(unsafe.Pointer(packet.Data), i+3))) == 0 {
						if (int64(*(*uint8)(unsafe.Add(unsafe.Pointer(packet.Data), i+5))) & 56) == 8 {
							last_valid_packet_start = packet_start
						}
						break
					}
				}
			} else {
				last_valid_packet_start = packet_start
			}
		}
		if last_valid_packet_start != -1 {
			plm_demux_buffer_seek(self, uint64(last_valid_packet_start))
			return plm_demux_decode_packet(self, type_)
		} else if found_packet_in_range != 0 {
			scan_span *= 2
			seek_time = first_packet_time
		} else if found_packet_with_pts == 0 {
			byterate = int64(float64(seek_pos-cur_pos) / (duration - cur_time))
			cur_time = duration
		}
	}
	return nil
}
func plm_demux_decode(self *plm_demux_t) *plm_packet_t {
	if plm_demux_has_headers(self) == 0 {
		return nil
	}
	if self.Current_packet.Length != 0 {
		var bits_till_next_packet uint64 = self.Current_packet.Length << 3
		if plm_buffer_has(self.Buffer, bits_till_next_packet) == 0 {
			return nil
		}
		plm_buffer_skip(self.Buffer, bits_till_next_packet)
		self.Current_packet.Length = 0
	}
	if self.Next_packet.Length != 0 {
		return plm_demux_get_packet(self)
	}
	if self.Start_code != -1 {
		return plm_demux_decode_packet(self, self.Start_code)
	}
	for {
		self.Start_code = plm_buffer_next_start_code(self.Buffer)
		if self.Start_code == plm_demux_packet_video_1 || self.Start_code == plm_demux_packet_private || self.Start_code >= plm_demux_packet_audio_1 && self.Start_code <= plm_demux_packet_audio_4 {
			return plm_demux_decode_packet(self, self.Start_code)
		}
		if self.Start_code == -1 {
			break
		}
	}
	return nil
}
func plm_demux_decode_time(self *plm_demux_t) float64 {
	var clock int64 = plm_buffer_read(self.Buffer, 3) << 30
	plm_buffer_skip(self.Buffer, 1)
	clock |= plm_buffer_read(self.Buffer, 15) << 15
	plm_buffer_skip(self.Buffer, 1)
	clock |= plm_buffer_read(self.Buffer, 15)
	plm_buffer_skip(self.Buffer, 1)
	return float64(clock) / 90000.0
}
func plm_demux_decode_packet(self *plm_demux_t, type_ int64) *plm_packet_t {
	if plm_buffer_has(self.Buffer, 16<<3) == 0 {
		return nil
	}
	self.Start_code = -1
	self.Next_packet.Type = type_
	self.Next_packet.Length = uint64(plm_buffer_read(self.Buffer, 16))
	self.Next_packet.Length -= uint64(plm_buffer_skip_bytes(self.Buffer, math.MaxUint8))
	if plm_buffer_read(self.Buffer, 2) == 1 {
		plm_buffer_skip(self.Buffer, 16)
		self.Next_packet.Length -= 2
	}
	var pts_dts_marker int64 = plm_buffer_read(self.Buffer, 2)
	if pts_dts_marker == 3 {
		self.Next_packet.Pts = plm_demux_decode_time(self)
		self.Last_decoded_pts = self.Next_packet.Pts
		plm_buffer_skip(self.Buffer, 40)
		self.Next_packet.Length -= 10
	} else if pts_dts_marker == 2 {
		self.Next_packet.Pts = plm_demux_decode_time(self)
		self.Last_decoded_pts = self.Next_packet.Pts
		self.Next_packet.Length -= 5
	} else if pts_dts_marker == 0 {
		self.Next_packet.Pts = float64(-1)
		plm_buffer_skip(self.Buffer, 4)
		self.Next_packet.Length -= 1
	} else {
		return nil
	}
	return plm_demux_get_packet(self)
}
func plm_demux_get_packet(self *plm_demux_t) *plm_packet_t {
	if plm_buffer_has(self.Buffer, self.Next_packet.Length<<3) == 0 {
		return nil
	}
	self.Current_packet.Data = (*uint8)(unsafe.Add(unsafe.Pointer(self.Buffer.Bytes), self.Buffer.Bit_index>>3))
	self.Current_packet.Length = self.Next_packet.Length
	self.Current_packet.Type = self.Next_packet.Type
	self.Current_packet.Pts = self.Next_packet.Pts
	self.Next_packet.Length = 0
	return &self.Current_packet
}

var plm_video_picture_type_intra int64 = 1
var plm_video_picture_type_predictive int64 = 2
var plm_video_picture_type_b int64 = 3
var plm_start_sequence int64 = 179
var plm_start_slice_first int64 = 1
var plm_start_slice_last int64 = 175
var plm_start_picture int64 = 0
var plm_start_extension int64 = 181
var plm_start_user_data int64 = 178
var plm_video_picture_rate [16]float64 = [16]float64{0.0, 23.976, 24.0, 25.0, 29.97, 30.0, 50.0, 59.94, 60.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0}
var plm_video_zig_zag [64]uint8 = [64]uint8{0, 1, 8, 16, 9, 2, 3, 10, 17, 24, 32, 25, 18, 11, 4, 5, 12, 19, 26, 33, 40, 48, 41, 34, 27, 20, 13, 6, 7, 14, 21, 28, 35, 42, 49, 56, 57, 50, 43, 36, 29, 22, 15, 23, 30, 37, 44, 51, 58, 59, 52, 45, 38, 31, 39, 46, 53, 60, 61, 54, 47, 55, 62, 63}
var plm_video_intra_quant_matrix [64]uint8 = [64]uint8{8, 16, 19, 22, 26, 27, 29, 34, 16, 16, 22, 24, 27, 29, 34, 37, 19, 22, 26, 27, 29, 34, 34, 38, 22, 22, 26, 27, 29, 34, 37, 40, 22, 26, 27, 29, 32, 35, 40, 48, 26, 27, 29, 32, 35, 40, 48, 58, 26, 27, 29, 34, 38, 46, 56, 69, 27, 29, 35, 38, 46, 56, 69, 83}
var plm_video_non_intra_quant_matrix [64]uint8 = [64]uint8{16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16}
var plm_video_premultiplier_matrix [64]uint8 = [64]uint8{32, 44, 42, 38, 32, 25, 17, 9, 44, 62, 58, 52, 44, 35, 24, 12, 42, 58, 55, 49, 42, 33, 23, 12, 38, 52, 49, 44, 38, 30, 20, 10, 32, 44, 42, 38, 32, 25, 17, 9, 25, 35, 33, 30, 25, 20, 14, 7, 17, 24, 23, 20, 17, 14, 9, 5, 9, 12, 12, 10, 9, 7, 5, 2}
var plm_video_macroblock_address_increment [80]plm_vlc_t = [80]plm_vlc_t{{Index: 1 << 1, Value: 0}, {Index: 0, Value: 1}, {Index: 2 << 1, Value: 0}, {Index: 3 << 1, Value: 0}, {Index: 4 << 1, Value: 0}, {Index: 5 << 1, Value: 0}, {Index: 0, Value: 3}, {Index: 0, Value: 2}, {Index: 6 << 1, Value: 0}, {Index: 7 << 1, Value: 0}, {Index: 0, Value: 5}, {Index: 0, Value: 4}, {Index: 8 << 1, Value: 0}, {Index: 9 << 1, Value: 0}, {Index: 0, Value: 7}, {Index: 0, Value: 6}, {Index: 10 << 1, Value: 0}, {Index: 11 << 1, Value: 0}, {Index: 12 << 1, Value: 0}, {Index: 13 << 1, Value: 0}, {Index: 14 << 1, Value: 0}, {Index: 15 << 1, Value: 0}, {Index: 16 << 1, Value: 0}, {Index: 17 << 1, Value: 0}, {Index: 18 << 1, Value: 0}, {Index: 19 << 1, Value: 0}, {Index: 0, Value: 9}, {Index: 0, Value: 8}, {Index: -1, Value: 0}, {Index: 20 << 1, Value: 0}, {Index: -1, Value: 0}, {Index: 21 << 1, Value: 0}, {Index: 22 << 1, Value: 0}, {Index: 23 << 1, Value: 0}, {Index: 0, Value: 15}, {Index: 0, Value: 14}, {Index: 0, Value: 13}, {Index: 0, Value: 12}, {Index: 0, Value: 11}, {Index: 0, Value: 10}, {Index: 24 << 1, Value: 0}, {Index: 25 << 1, Value: 0}, {Index: 26 << 1, Value: 0}, {Index: 27 << 1, Value: 0}, {Index: 28 << 1, Value: 0}, {Index: 29 << 1, Value: 0}, {Index: 30 << 1, Value: 0}, {Index: 31 << 1, Value: 0}, {Index: 32 << 1, Value: 0}, {Index: -1, Value: 0}, {Index: -1, Value: 0}, {Index: 33 << 1, Value: 0}, {Index: 34 << 1, Value: 0}, {Index: 35 << 1, Value: 0}, {Index: 36 << 1, Value: 0}, {Index: 37 << 1, Value: 0}, {Index: 38 << 1, Value: 0}, {Index: 39 << 1, Value: 0}, {Index: 0, Value: 21}, {Index: 0, Value: 20}, {Index: 0, Value: 19}, {Index: 0, Value: 18}, {Index: 0, Value: 17}, {Index: 0, Value: 16}, {Index: 0, Value: 35}, {Index: -1, Value: 0}, {Index: -1, Value: 0}, {Index: 0, Value: 34}, {Index: 0, Value: 33}, {Index: 0, Value: 32}, {Index: 0, Value: 31}, {Index: 0, Value: 30}, {Index: 0, Value: 29}, {Index: 0, Value: 28}, {Index: 0, Value: 27}, {Index: 0, Value: 26}, {Index: 0, Value: 25}, {Index: 0, Value: 24}, {Index: 0, Value: 23}, {Index: 0, Value: 22}}
var plm_video_macroblock_type_intra [4]plm_vlc_t = [4]plm_vlc_t{{Index: 1 << 1, Value: 0}, {Index: 0, Value: 1}, {Index: -1, Value: 0}, {Index: 0, Value: 17}}
var plm_video_macroblock_type_predictive [14]plm_vlc_t = [14]plm_vlc_t{{Index: 1 << 1, Value: 0}, {Index: 0, Value: 10}, {Index: 2 << 1, Value: 0}, {Index: 0, Value: 2}, {Index: 3 << 1, Value: 0}, {Index: 0, Value: 8}, {Index: 4 << 1, Value: 0}, {Index: 5 << 1, Value: 0}, {Index: 6 << 1, Value: 0}, {Index: 0, Value: 18}, {Index: 0, Value: 26}, {Index: 0, Value: 1}, {Index: -1, Value: 0}, {Index: 0, Value: 17}}
var plm_video_macroblock_type_b [22]plm_vlc_t = [22]plm_vlc_t{{Index: 1 << 1, Value: 0}, {Index: 2 << 1, Value: 0}, {Index: 3 << 1, Value: 0}, {Index: 4 << 1, Value: 0}, {Index: 0, Value: 12}, {Index: 0, Value: 14}, {Index: 5 << 1, Value: 0}, {Index: 6 << 1, Value: 0}, {Index: 0, Value: 4}, {Index: 0, Value: 6}, {Index: 7 << 1, Value: 0}, {Index: 8 << 1, Value: 0}, {Index: 0, Value: 8}, {Index: 0, Value: 10}, {Index: 9 << 1, Value: 0}, {Index: 10 << 1, Value: 0}, {Index: 0, Value: 30}, {Index: 0, Value: 1}, {Index: -1, Value: 0}, {Index: 0, Value: 17}, {Index: 0, Value: 22}, {Index: 0, Value: 26}}
var plm_video_macroblock_type [4]*plm_vlc_t = [4]*plm_vlc_t{nil, &plm_video_macroblock_type_intra[0], &plm_video_macroblock_type_predictive[0], &plm_video_macroblock_type_b[0]}
var plm_video_code_block_pattern [126]plm_vlc_t = [126]plm_vlc_t{{Index: 1 << 1, Value: 0}, {Index: 2 << 1, Value: 0}, {Index: 3 << 1, Value: 0}, {Index: 4 << 1, Value: 0}, {Index: 5 << 1, Value: 0}, {Index: 6 << 1, Value: 0}, {Index: 7 << 1, Value: 0}, {Index: 8 << 1, Value: 0}, {Index: 9 << 1, Value: 0}, {Index: 10 << 1, Value: 0}, {Index: 11 << 1, Value: 0}, {Index: 12 << 1, Value: 0}, {Index: 13 << 1, Value: 0}, {Index: 0, Value: 60}, {Index: 14 << 1, Value: 0}, {Index: 15 << 1, Value: 0}, {Index: 16 << 1, Value: 0}, {Index: 17 << 1, Value: 0}, {Index: 18 << 1, Value: 0}, {Index: 19 << 1, Value: 0}, {Index: 20 << 1, Value: 0}, {Index: 21 << 1, Value: 0}, {Index: 22 << 1, Value: 0}, {Index: 23 << 1, Value: 0}, {Index: 0, Value: 32}, {Index: 0, Value: 16}, {Index: 0, Value: 8}, {Index: 0, Value: 4}, {Index: 24 << 1, Value: 0}, {Index: 25 << 1, Value: 0}, {Index: 26 << 1, Value: 0}, {Index: 27 << 1, Value: 0}, {Index: 28 << 1, Value: 0}, {Index: 29 << 1, Value: 0}, {Index: 30 << 1, Value: 0}, {Index: 31 << 1, Value: 0}, {Index: 0, Value: 62}, {Index: 0, Value: 2}, {Index: 0, Value: 61}, {Index: 0, Value: 1}, {Index: 0, Value: 56}, {Index: 0, Value: 52}, {Index: 0, Value: 44}, {Index: 0, Value: 28}, {Index: 0, Value: 40}, {Index: 0, Value: 20}, {Index: 0, Value: 48}, {Index: 0, Value: 12}, {Index: 32 << 1, Value: 0}, {Index: 33 << 1, Value: 0}, {Index: 34 << 1, Value: 0}, {Index: 35 << 1, Value: 0}, {Index: 36 << 1, Value: 0}, {Index: 37 << 1, Value: 0}, {Index: 38 << 1, Value: 0}, {Index: 39 << 1, Value: 0}, {Index: 40 << 1, Value: 0}, {Index: 41 << 1, Value: 0}, {Index: 42 << 1, Value: 0}, {Index: 43 << 1, Value: 0}, {Index: 0, Value: 63}, {Index: 0, Value: 3}, {Index: 0, Value: 36}, {Index: 0, Value: 24}, {Index: 44 << 1, Value: 0}, {Index: 45 << 1, Value: 0}, {Index: 46 << 1, Value: 0}, {Index: 47 << 1, Value: 0}, {Index: 48 << 1, Value: 0}, {Index: 49 << 1, Value: 0}, {Index: 50 << 1, Value: 0}, {Index: 51 << 1, Value: 0}, {Index: 52 << 1, Value: 0}, {Index: 53 << 1, Value: 0}, {Index: 54 << 1, Value: 0}, {Index: 55 << 1, Value: 0}, {Index: 56 << 1, Value: 0}, {Index: 57 << 1, Value: 0}, {Index: 58 << 1, Value: 0}, {Index: 59 << 1, Value: 0}, {Index: 0, Value: 34}, {Index: 0, Value: 18}, {Index: 0, Value: 10}, {Index: 0, Value: 6}, {Index: 0, Value: 33}, {Index: 0, Value: 17}, {Index: 0, Value: 9}, {Index: 0, Value: 5}, {Index: -1, Value: 0}, {Index: 60 << 1, Value: 0}, {Index: 61 << 1, Value: 0}, {Index: 62 << 1, Value: 0}, {Index: 0, Value: 58}, {Index: 0, Value: 54}, {Index: 0, Value: 46}, {Index: 0, Value: 30}, {Index: 0, Value: 57}, {Index: 0, Value: 53}, {Index: 0, Value: 45}, {Index: 0, Value: 29}, {Index: 0, Value: 38}, {Index: 0, Value: 26}, {Index: 0, Value: 37}, {Index: 0, Value: 25}, {Index: 0, Value: 43}, {Index: 0, Value: 23}, {Index: 0, Value: 51}, {Index: 0, Value: 15}, {Index: 0, Value: 42}, {Index: 0, Value: 22}, {Index: 0, Value: 50}, {Index: 0, Value: 14}, {Index: 0, Value: 41}, {Index: 0, Value: 21}, {Index: 0, Value: 49}, {Index: 0, Value: 13}, {Index: 0, Value: 35}, {Index: 0, Value: 19}, {Index: 0, Value: 11}, {Index: 0, Value: 7}, {Index: 0, Value: 39}, {Index: 0, Value: 27}, {Index: 0, Value: 59}, {Index: 0, Value: 55}, {Index: 0, Value: 47}, {Index: 0, Value: 31}}
var plm_video_motion [68]plm_vlc_t = [68]plm_vlc_t{{Index: 1 << 1, Value: 0}, {}, {Index: 2 << 1, Value: 0}, {Index: 3 << 1, Value: 0}, {Index: 4 << 1, Value: 0}, {Index: 5 << 1, Value: 0}, {Index: 0, Value: 1}, {Index: 0, Value: -1}, {Index: 6 << 1, Value: 0}, {Index: 7 << 1, Value: 0}, {Index: 0, Value: 2}, {Index: 0, Value: -2}, {Index: 8 << 1, Value: 0}, {Index: 9 << 1, Value: 0}, {Index: 0, Value: 3}, {Index: 0, Value: -3}, {Index: 10 << 1, Value: 0}, {Index: 11 << 1, Value: 0}, {Index: 12 << 1, Value: 0}, {Index: 13 << 1, Value: 0}, {Index: -1, Value: 0}, {Index: 14 << 1, Value: 0}, {Index: 15 << 1, Value: 0}, {Index: 16 << 1, Value: 0}, {Index: 17 << 1, Value: 0}, {Index: 18 << 1, Value: 0}, {Index: 0, Value: 4}, {Index: 0, Value: -4}, {Index: -1, Value: 0}, {Index: 19 << 1, Value: 0}, {Index: 20 << 1, Value: 0}, {Index: 21 << 1, Value: 0}, {Index: 0, Value: 7}, {Index: 0, Value: -7}, {Index: 0, Value: 6}, {Index: 0, Value: -6}, {Index: 0, Value: 5}, {Index: 0, Value: -5}, {Index: 22 << 1, Value: 0}, {Index: 23 << 1, Value: 0}, {Index: 24 << 1, Value: 0}, {Index: 25 << 1, Value: 0}, {Index: 26 << 1, Value: 0}, {Index: 27 << 1, Value: 0}, {Index: 28 << 1, Value: 0}, {Index: 29 << 1, Value: 0}, {Index: 30 << 1, Value: 0}, {Index: 31 << 1, Value: 0}, {Index: 32 << 1, Value: 0}, {Index: 33 << 1, Value: 0}, {Index: 0, Value: 10}, {Index: 0, Value: -10}, {Index: 0, Value: 9}, {Index: 0, Value: -9}, {Index: 0, Value: 8}, {Index: 0, Value: -8}, {Index: 0, Value: 16}, {Index: 0, Value: -16}, {Index: 0, Value: 15}, {Index: 0, Value: -15}, {Index: 0, Value: 14}, {Index: 0, Value: -14}, {Index: 0, Value: 13}, {Index: 0, Value: -13}, {Index: 0, Value: 12}, {Index: 0, Value: -12}, {Index: 0, Value: 11}, {Index: 0, Value: -11}}
var plm_video_dct_size_luminance [18]plm_vlc_t = [18]plm_vlc_t{{Index: 1 << 1, Value: 0}, {Index: 2 << 1, Value: 0}, {Index: 0, Value: 1}, {Index: 0, Value: 2}, {Index: 3 << 1, Value: 0}, {Index: 4 << 1, Value: 0}, {}, {Index: 0, Value: 3}, {Index: 0, Value: 4}, {Index: 5 << 1, Value: 0}, {Index: 0, Value: 5}, {Index: 6 << 1, Value: 0}, {Index: 0, Value: 6}, {Index: 7 << 1, Value: 0}, {Index: 0, Value: 7}, {Index: 8 << 1, Value: 0}, {Index: 0, Value: 8}, {Index: -1, Value: 0}}
var plm_video_dct_size_chrominance [18]plm_vlc_t = [18]plm_vlc_t{{Index: 1 << 1, Value: 0}, {Index: 2 << 1, Value: 0}, {}, {Index: 0, Value: 1}, {Index: 0, Value: 2}, {Index: 3 << 1, Value: 0}, {Index: 0, Value: 3}, {Index: 4 << 1, Value: 0}, {Index: 0, Value: 4}, {Index: 5 << 1, Value: 0}, {Index: 0, Value: 5}, {Index: 6 << 1, Value: 0}, {Index: 0, Value: 6}, {Index: 7 << 1, Value: 0}, {Index: 0, Value: 7}, {Index: 8 << 1, Value: 0}, {Index: 0, Value: 8}, {Index: -1, Value: 0}}
var plm_video_dct_size [3]*plm_vlc_t = [3]*plm_vlc_t{&plm_video_dct_size_luminance[0], &plm_video_dct_size_chrominance[0], &plm_video_dct_size_chrominance[0]}
var plm_video_dct_coeff [224]plm_vlc_uint_t = [224]plm_vlc_uint_t{{Index: 1 << 1, Value: 0}, {Index: 0, Value: 1}, {Index: 2 << 1, Value: 0}, {Index: 3 << 1, Value: 0}, {Index: 4 << 1, Value: 0}, {Index: 5 << 1, Value: 0}, {Index: 6 << 1, Value: 0}, {Index: 0, Value: 257}, {Index: 7 << 1, Value: 0}, {Index: 8 << 1, Value: 0}, {Index: 9 << 1, Value: 0}, {Index: 10 << 1, Value: 0}, {Index: 0, Value: 2}, {Index: 0, Value: 513}, {Index: 11 << 1, Value: 0}, {Index: 12 << 1, Value: 0}, {Index: 13 << 1, Value: 0}, {Index: 14 << 1, Value: 0}, {Index: 15 << 1, Value: 0}, {Index: 0, Value: 3}, {Index: 0, Value: 1025}, {Index: 0, Value: 769}, {Index: 16 << 1, Value: 0}, {Index: 0, Value: math.MaxUint16}, {Index: 17 << 1, Value: 0}, {Index: 18 << 1, Value: 0}, {Index: 0, Value: 1793}, {Index: 0, Value: 1537}, {Index: 0, Value: 258}, {Index: 0, Value: 1281}, {Index: 19 << 1, Value: 0}, {Index: 20 << 1, Value: 0}, {Index: 21 << 1, Value: 0}, {Index: 22 << 1, Value: 0}, {Index: 0, Value: 514}, {Index: 0, Value: 2305}, {Index: 0, Value: 4}, {Index: 0, Value: 2049}, {Index: 23 << 1, Value: 0}, {Index: 24 << 1, Value: 0}, {Index: 25 << 1, Value: 0}, {Index: 26 << 1, Value: 0}, {Index: 27 << 1, Value: 0}, {Index: 28 << 1, Value: 0}, {Index: 29 << 1, Value: 0}, {Index: 30 << 1, Value: 0}, {Index: 0, Value: 3329}, {Index: 0, Value: 6}, {Index: 0, Value: 3073}, {Index: 0, Value: 2817}, {Index: 0, Value: 770}, {Index: 0, Value: 259}, {Index: 0, Value: 5}, {Index: 0, Value: 2561}, {Index: 31 << 1, Value: 0}, {Index: 32 << 1, Value: 0}, {Index: 33 << 1, Value: 0}, {Index: 34 << 1, Value: 0}, {Index: 35 << 1, Value: 0}, {Index: 36 << 1, Value: 0}, {Index: 37 << 1, Value: 0}, {Index: 38 << 1, Value: 0}, {Index: 39 << 1, Value: 0}, {Index: 40 << 1, Value: 0}, {Index: 41 << 1, Value: 0}, {Index: 42 << 1, Value: 0}, {Index: 43 << 1, Value: 0}, {Index: 44 << 1, Value: 0}, {Index: 45 << 1, Value: 0}, {Index: 46 << 1, Value: 0}, {Index: 0, Value: 4097}, {Index: 0, Value: 1282}, {Index: 0, Value: 7}, {Index: 0, Value: 515}, {Index: 0, Value: 260}, {Index: 0, Value: 3841}, {Index: 0, Value: 3585}, {Index: 0, Value: 1026}, {Index: 47 << 1, Value: 0}, {Index: 48 << 1, Value: 0}, {Index: 49 << 1, Value: 0}, {Index: 50 << 1, Value: 0}, {Index: 51 << 1, Value: 0}, {Index: 52 << 1, Value: 0}, {Index: 53 << 1, Value: 0}, {Index: 54 << 1, Value: 0}, {Index: 55 << 1, Value: 0}, {Index: 56 << 1, Value: 0}, {Index: 57 << 1, Value: 0}, {Index: 58 << 1, Value: 0}, {Index: 59 << 1, Value: 0}, {Index: 60 << 1, Value: 0}, {Index: 61 << 1, Value: 0}, {Index: 62 << 1, Value: 0}, {Index: -1, Value: 0}, {Index: 63 << 1, Value: 0}, {Index: 64 << 1, Value: 0}, {Index: 65 << 1, Value: 0}, {Index: 66 << 1, Value: 0}, {Index: 67 << 1, Value: 0}, {Index: 68 << 1, Value: 0}, {Index: 69 << 1, Value: 0}, {Index: 70 << 1, Value: 0}, {Index: 71 << 1, Value: 0}, {Index: 72 << 1, Value: 0}, {Index: 73 << 1, Value: 0}, {Index: 74 << 1, Value: 0}, {Index: 75 << 1, Value: 0}, {Index: 76 << 1, Value: 0}, {Index: 77 << 1, Value: 0}, {Index: 0, Value: 11}, {Index: 0, Value: 2050}, {Index: 0, Value: 1027}, {Index: 0, Value: 10}, {Index: 0, Value: 516}, {Index: 0, Value: 1794}, {Index: 0, Value: 5377}, {Index: 0, Value: 5121}, {Index: 0, Value: 9}, {Index: 0, Value: 4865}, {Index: 0, Value: 4609}, {Index: 0, Value: 261}, {Index: 0, Value: 771}, {Index: 0, Value: 8}, {Index: 0, Value: 1538}, {Index: 0, Value: 4353}, {Index: 78 << 1, Value: 0}, {Index: 79 << 1, Value: 0}, {Index: 80 << 1, Value: 0}, {Index: 81 << 1, Value: 0}, {Index: 82 << 1, Value: 0}, {Index: 83 << 1, Value: 0}, {Index: 84 << 1, Value: 0}, {Index: 85 << 1, Value: 0}, {Index: 86 << 1, Value: 0}, {Index: 87 << 1, Value: 0}, {Index: 88 << 1, Value: 0}, {Index: 89 << 1, Value: 0}, {Index: 90 << 1, Value: 0}, {Index: 91 << 1, Value: 0}, {Index: 0, Value: 2562}, {Index: 0, Value: 2306}, {Index: 0, Value: 1283}, {Index: 0, Value: 772}, {Index: 0, Value: 517}, {Index: 0, Value: 263}, {Index: 0, Value: 262}, {Index: 0, Value: 15}, {Index: 0, Value: 14}, {Index: 0, Value: 13}, {Index: 0, Value: 12}, {Index: 0, Value: 6657}, {Index: 0, Value: 6401}, {Index: 0, Value: 6145}, {Index: 0, Value: 5889}, {Index: 0, Value: 5633}, {Index: 92 << 1, Value: 0}, {Index: 93 << 1, Value: 0}, {Index: 94 << 1, Value: 0}, {Index: 95 << 1, Value: 0}, {Index: 96 << 1, Value: 0}, {Index: 97 << 1, Value: 0}, {Index: 98 << 1, Value: 0}, {Index: 99 << 1, Value: 0}, {Index: 100 << 1, Value: 0}, {Index: 101 << 1, Value: 0}, {Index: 102 << 1, Value: 0}, {Index: 103 << 1, Value: 0}, {Index: 0, Value: 31}, {Index: 0, Value: 30}, {Index: 0, Value: 29}, {Index: 0, Value: 28}, {Index: 0, Value: 27}, {Index: 0, Value: 26}, {Index: 0, Value: 25}, {Index: 0, Value: 24}, {Index: 0, Value: 23}, {Index: 0, Value: 22}, {Index: 0, Value: 21}, {Index: 0, Value: 20}, {Index: 0, Value: 19}, {Index: 0, Value: 18}, {Index: 0, Value: 17}, {Index: 0, Value: 16}, {Index: 104 << 1, Value: 0}, {Index: 105 << 1, Value: 0}, {Index: 106 << 1, Value: 0}, {Index: 107 << 1, Value: 0}, {Index: 108 << 1, Value: 0}, {Index: 109 << 1, Value: 0}, {Index: 110 << 1, Value: 0}, {Index: 111 << 1, Value: 0}, {Index: 0, Value: 40}, {Index: 0, Value: 39}, {Index: 0, Value: 38}, {Index: 0, Value: 37}, {Index: 0, Value: 36}, {Index: 0, Value: 35}, {Index: 0, Value: 34}, {Index: 0, Value: 33}, {Index: 0, Value: 32}, {Index: 0, Value: 270}, {Index: 0, Value: 269}, {Index: 0, Value: 268}, {Index: 0, Value: 267}, {Index: 0, Value: 266}, {Index: 0, Value: 265}, {Index: 0, Value: 264}, {Index: 0, Value: 274}, {Index: 0, Value: 273}, {Index: 0, Value: 272}, {Index: 0, Value: 271}, {Index: 0, Value: 1539}, {Index: 0, Value: 4098}, {Index: 0, Value: 3842}, {Index: 0, Value: 3586}, {Index: 0, Value: 3330}, {Index: 0, Value: 3074}, {Index: 0, Value: 2818}, {Index: 0, Value: 7937}, {Index: 0, Value: 7681}, {Index: 0, Value: 7425}, {Index: 0, Value: 7169}, {Index: 0, Value: 6913}}

type plm_video_motion_t struct {
	Full_px int64
	Is_set  int64
	R_size  int64
	H       int64
	V       int64
}

func plm_clamp(n int64) uint8 {
	if n > math.MaxUint8 {
		n = math.MaxUint8
	} else if n < 0 {
		n = 0
	}
	return uint8(int8(n))
}
func plm_video_create_with_buffer(buffer *plm_buffer_t, destroy_when_done int64) *plm_video_t {
	var self *plm_video_t = new(plm_video_t)
	*self = plm_video_t{}
	self.Buffer = buffer
	self.Destroy_buffer_when_done = destroy_when_done
	self.Start_code = plm_buffer_find_start_code(self.Buffer, plm_start_sequence)
	if self.Start_code != -1 {
		plm_video_decode_sequence_header(self)
	}
	return self
}
func plm_video_destroy(self *plm_video_t) {
	if self.Destroy_buffer_when_done != 0 {
		plm_buffer_destroy(self.Buffer)
	}
	if self.Has_sequence_header != 0 {
		libc.Free(unsafe.Pointer(self.Frames_data))
	}
	libc.Free(unsafe.Pointer(self))
}
func plm_video_get_framerate(self *plm_video_t) float64 {
	if plm_video_has_header(self) != 0 {
		return self.Framerate
	}
	return 0
}
func plm_video_get_width(self *plm_video_t) int64 {
	if plm_video_has_header(self) != 0 {
		return self.Width
	}
	return 0
}
func plm_video_get_height(self *plm_video_t) int64 {
	if plm_video_has_header(self) != 0 {
		return self.Height
	}
	return 0
}
func plm_video_set_no_delay(self *plm_video_t, no_delay int64) {
	self.Assume_no_b_frames = no_delay
}
func plm_video_get_time(self *plm_video_t) float64 {
	return self.Time
}
func plm_video_set_time(self *plm_video_t, time float64) {
	self.Frames_decoded = int64(self.Framerate * time)
	self.Time = time
}
func plm_video_rewind(self *plm_video_t) {
	plm_buffer_rewind(self.Buffer)
	self.Time = 0
	self.Frames_decoded = 0
	self.Has_reference_frame = _false
	self.Start_code = -1
}
func plm_video_has_ended(self *plm_video_t) int64 {
	return plm_buffer_has_ended(self.Buffer)
}
func plm_video_decode(self *plm_video_t) *plm_frame_t {
	if plm_video_has_header(self) == 0 {
		return nil
	}
	var frame *plm_frame_t = nil
	for {
		if self.Start_code != plm_start_picture {
			self.Start_code = plm_buffer_find_start_code(self.Buffer, plm_start_picture)
			if self.Start_code == -1 {
				if self.Has_reference_frame != 0 && self.Assume_no_b_frames == 0 && plm_buffer_has_ended(self.Buffer) != 0 && (self.Picture_type == plm_video_picture_type_intra || self.Picture_type == plm_video_picture_type_predictive) {
					self.Has_reference_frame = _false
					frame = &self.Frame_backward
					break
				}
				return nil
			}
		}
		if plm_buffer_has_start_code(self.Buffer, plm_start_picture) == -1 && plm_buffer_has_ended(self.Buffer) == 0 {
			return nil
		}
		plm_buffer_discard_read_bytes(self.Buffer)
		plm_video_decode_picture(self)
		if self.Assume_no_b_frames != 0 {
			frame = &self.Frame_backward
		} else if self.Picture_type == plm_video_picture_type_b {
			frame = &self.Frame_current
		} else if self.Has_reference_frame != 0 {
			frame = &self.Frame_forward
		} else {
			self.Has_reference_frame = _true
		}
		if frame != nil {
			break
		}
	}
	frame.Time = self.Time
	self.Frames_decoded++
	self.Time = float64(self.Frames_decoded) / self.Framerate
	return frame
}
func plm_video_has_header(self *plm_video_t) int64 {
	if self.Has_sequence_header != 0 {
		return _true
	}
	if self.Start_code != plm_start_sequence {
		self.Start_code = plm_buffer_find_start_code(self.Buffer, plm_start_sequence)
	}
	if self.Start_code == -1 {
		return _false
	}
	if plm_video_decode_sequence_header(self) == 0 {
		return _false
	}
	return _true
}
func plm_video_decode_sequence_header(self *plm_video_t) int64 {
	var max_header_size int64 = 64 + 2*64*8
	if plm_buffer_has(self.Buffer, uint64(max_header_size)) == 0 {
		return _false
	}
	self.Width = plm_buffer_read(self.Buffer, 12)
	self.Height = plm_buffer_read(self.Buffer, 12)
	if self.Width <= 0 || self.Height <= 0 {
		return _false
	}
	plm_buffer_skip(self.Buffer, 4)
	self.Framerate = plm_video_picture_rate[plm_buffer_read(self.Buffer, 4)]
	plm_buffer_skip(self.Buffer, 18+1+10+1)
	if plm_buffer_read(self.Buffer, 1) != 0 {
		for i := int64(0); i < 64; i++ {
			var idx int64 = int64(plm_video_zig_zag[i])
			self.Intra_quant_matrix[idx] = uint8(int8(plm_buffer_read(self.Buffer, 8)))
		}
	} else {
		libc.MemCpy(unsafe.Pointer(&self.Intra_quant_matrix[0]), unsafe.Pointer(&plm_video_intra_quant_matrix[0]), 64)
	}
	if plm_buffer_read(self.Buffer, 1) != 0 {
		for i := int64(0); i < 64; i++ {
			var idx int64 = int64(plm_video_zig_zag[i])
			self.Non_intra_quant_matrix[idx] = uint8(int8(plm_buffer_read(self.Buffer, 8)))
		}
	} else {
		libc.MemCpy(unsafe.Pointer(&self.Non_intra_quant_matrix[0]), unsafe.Pointer(&plm_video_non_intra_quant_matrix[0]), 64)
	}
	self.Mb_width = (self.Width + 15) >> 4
	self.Mb_height = (self.Height + 15) >> 4
	self.Mb_size = self.Mb_width * self.Mb_height
	self.Luma_width = self.Mb_width << 4
	self.Luma_height = self.Mb_height << 4
	self.Chroma_width = self.Mb_width << 3
	self.Chroma_height = self.Mb_height << 3
	var luma_plane_size uint64 = uint64(self.Luma_width * self.Luma_height)
	var chroma_plane_size uint64 = uint64(self.Chroma_width * self.Chroma_height)
	var frame_data_size uint64 = (luma_plane_size + chroma_plane_size*2)
	self.Frames_data = (*uint8)(libc.Malloc(int(frame_data_size * 3)))
	plm_video_init_frame(self, &self.Frame_current, (*uint8)(unsafe.Add(unsafe.Pointer(self.Frames_data), frame_data_size*0)))
	plm_video_init_frame(self, &self.Frame_forward, (*uint8)(unsafe.Add(unsafe.Pointer(self.Frames_data), frame_data_size*1)))
	plm_video_init_frame(self, &self.Frame_backward, (*uint8)(unsafe.Add(unsafe.Pointer(self.Frames_data), frame_data_size*2)))
	self.Has_sequence_header = _true
	return _true
}
func plm_video_init_frame(self *plm_video_t, frame *plm_frame_t, base *uint8) {
	var (
		luma_plane_size   uint64 = uint64(self.Luma_width * self.Luma_height)
		chroma_plane_size uint64 = uint64(self.Chroma_width * self.Chroma_height)
	)
	frame.Width = uint64(self.Width)
	frame.Height = uint64(self.Height)
	frame.Y.Width = uint64(self.Luma_width)
	frame.Y.Height = uint64(self.Luma_height)
	frame.Y.Data = base
	frame.Cr.Width = uint64(self.Chroma_width)
	frame.Cr.Height = uint64(self.Chroma_height)
	frame.Cr.Data = (*uint8)(unsafe.Add(unsafe.Pointer(base), luma_plane_size))
	frame.Cb.Width = uint64(self.Chroma_width)
	frame.Cb.Height = uint64(self.Chroma_height)
	frame.Cb.Data = (*uint8)(unsafe.Add(unsafe.Pointer((*uint8)(unsafe.Add(unsafe.Pointer(base), luma_plane_size))), chroma_plane_size))
}
func plm_video_decode_picture(self *plm_video_t) {
	plm_buffer_skip(self.Buffer, 10)
	self.Picture_type = plm_buffer_read(self.Buffer, 3)
	plm_buffer_skip(self.Buffer, 16)
	if self.Picture_type <= 0 || self.Picture_type > plm_video_picture_type_b {
		return
	}
	if self.Picture_type == plm_video_picture_type_predictive || self.Picture_type == plm_video_picture_type_b {
		self.Motion_forward.Full_px = plm_buffer_read(self.Buffer, 1)
		var f_code int64 = plm_buffer_read(self.Buffer, 3)
		if f_code == 0 {
			return
		}
		self.Motion_forward.R_size = f_code - 1
	}
	if self.Picture_type == plm_video_picture_type_b {
		self.Motion_backward.Full_px = plm_buffer_read(self.Buffer, 1)
		var f_code int64 = plm_buffer_read(self.Buffer, 3)
		if f_code == 0 {
			return
		}
		self.Motion_backward.R_size = f_code - 1
	}
	var frame_temp plm_frame_t = self.Frame_forward
	if self.Picture_type == plm_video_picture_type_intra || self.Picture_type == plm_video_picture_type_predictive {
		self.Frame_forward = self.Frame_backward
	}
	for {
		self.Start_code = plm_buffer_next_start_code(self.Buffer)
		if !(self.Start_code == plm_start_extension || self.Start_code == plm_start_user_data) {
			break
		}
	}
	for self.Start_code >= plm_start_slice_first && self.Start_code <= plm_start_slice_last {
		plm_video_decode_slice(self, self.Start_code&math.MaxUint8)
		if self.Macroblock_address >= self.Mb_size-2 {
			break
		}
		self.Start_code = plm_buffer_next_start_code(self.Buffer)
	}
	if self.Picture_type == plm_video_picture_type_intra || self.Picture_type == plm_video_picture_type_predictive {
		self.Frame_backward = self.Frame_current
		self.Frame_current = frame_temp
	}
}
func plm_video_decode_slice(self *plm_video_t, slice int64) {
	self.Slice_begin = _true
	self.Macroblock_address = (slice-1)*self.Mb_width - 1
	self.Motion_backward.H = func() int64 {
		p := &self.Motion_forward.H
		self.Motion_forward.H = 0
		return *p
	}()
	self.Motion_backward.V = func() int64 {
		p := &self.Motion_forward.V
		self.Motion_forward.V = 0
		return *p
	}()
	self.Dc_predictor[0] = 128
	self.Dc_predictor[1] = 128
	self.Dc_predictor[2] = 128
	self.Quantizer_scale = plm_buffer_read(self.Buffer, 5)
	for plm_buffer_read(self.Buffer, 1) != 0 {
		plm_buffer_skip(self.Buffer, 8)
	}
	for {
		plm_video_decode_macroblock(self)
		if !(self.Macroblock_address < self.Mb_size-1 && plm_buffer_peek_non_zero(self.Buffer, 23) != 0) {
			break
		}
	}
}
func plm_video_decode_macroblock(self *plm_video_t) {
	var (
		increment int64 = 0
		t         int64 = int64(plm_buffer_read_vlc(self.Buffer, &plm_video_macroblock_address_increment[0]))
	)
	for t == 34 {
		t = int64(plm_buffer_read_vlc(self.Buffer, &plm_video_macroblock_address_increment[0]))
	}
	for t == 35 {
		increment += 33
		t = int64(plm_buffer_read_vlc(self.Buffer, &plm_video_macroblock_address_increment[0]))
	}
	increment += t
	if self.Slice_begin != 0 {
		self.Slice_begin = _false
		self.Macroblock_address += increment
	} else {
		if self.Macroblock_address+increment >= self.Mb_size {
			return
		}
		if increment > 1 {
			self.Dc_predictor[0] = 128
			self.Dc_predictor[1] = 128
			self.Dc_predictor[2] = 128
			if self.Picture_type == plm_video_picture_type_predictive {
				self.Motion_forward.H = 0
				self.Motion_forward.V = 0
			}
		}
		for increment > 1 {
			self.Macroblock_address++
			self.Mb_row = self.Macroblock_address / self.Mb_width
			self.Mb_col = self.Macroblock_address % self.Mb_width
			plm_video_predict_macroblock(self)
			increment--
		}
		self.Macroblock_address++
	}
	self.Mb_row = self.Macroblock_address / self.Mb_width
	self.Mb_col = self.Macroblock_address % self.Mb_width
	if self.Mb_col >= self.Mb_width || self.Mb_row >= self.Mb_height {
		return
	}
	var table *plm_vlc_t = plm_video_macroblock_type[self.Picture_type]
	self.Macroblock_type = int64(plm_buffer_read_vlc(self.Buffer, table))
	self.Macroblock_intra = self.Macroblock_type & 1
	self.Motion_forward.Is_set = self.Macroblock_type & 8
	self.Motion_backward.Is_set = self.Macroblock_type & 4
	if (self.Macroblock_type & 16) != 0 {
		self.Quantizer_scale = plm_buffer_read(self.Buffer, 5)
	}
	if self.Macroblock_intra != 0 {
		self.Motion_backward.H = func() int64 {
			p := &self.Motion_forward.H
			self.Motion_forward.H = 0
			return *p
		}()
		self.Motion_backward.V = func() int64 {
			p := &self.Motion_forward.V
			self.Motion_forward.V = 0
			return *p
		}()
	} else {
		self.Dc_predictor[0] = 128
		self.Dc_predictor[1] = 128
		self.Dc_predictor[2] = 128
		plm_video_decode_motion_vectors(self)
		plm_video_predict_macroblock(self)
	}
	var cbp int64
	if (self.Macroblock_type & 2) != 0 {
		cbp = int64(plm_buffer_read_vlc(self.Buffer, &plm_video_code_block_pattern[0]))
	} else if self.Macroblock_intra != 0 {
		cbp = 63
	} else {
		cbp = 0
	}
	for block, mask := int64(0), int64(32); block < 6; block++ {
		if (cbp & mask) != 0 {
			plm_video_decode_block(self, block)
		}
		mask >>= 1
	}
}
func plm_video_decode_motion_vectors(self *plm_video_t) {
	if self.Motion_forward.Is_set != 0 {
		var r_size int64 = self.Motion_forward.R_size
		self.Motion_forward.H = plm_video_decode_motion_vector(self, r_size, self.Motion_forward.H)
		self.Motion_forward.V = plm_video_decode_motion_vector(self, r_size, self.Motion_forward.V)
	} else if self.Picture_type == plm_video_picture_type_predictive {
		self.Motion_forward.H = 0
		self.Motion_forward.V = 0
	}
	if self.Motion_backward.Is_set != 0 {
		var r_size int64 = self.Motion_backward.R_size
		self.Motion_backward.H = plm_video_decode_motion_vector(self, r_size, self.Motion_backward.H)
		self.Motion_backward.V = plm_video_decode_motion_vector(self, r_size, self.Motion_backward.V)
	}
}
func plm_video_decode_motion_vector(self *plm_video_t, r_size int64, motion int64) int64 {
	var (
		fscale int64 = 1 << r_size
		m_code int64 = int64(plm_buffer_read_vlc(self.Buffer, &plm_video_motion[0]))
		r      int64 = 0
		d      int64
	)
	if m_code != 0 && fscale != 1 {
		r = plm_buffer_read(self.Buffer, r_size)
		d = ((cmath.Abs(m_code) - 1) << r_size) + r + 1
		if m_code < 0 {
			d = -d
		}
	} else {
		d = m_code
	}
	motion += d
	if motion > (fscale<<4)-1 {
		motion -= fscale << 5
	} else if motion < ((-fscale) << 4) {
		motion += fscale << 5
	}
	return motion
}
func plm_video_predict_macroblock(self *plm_video_t) {
	var (
		fw_h int64 = self.Motion_forward.H
		fw_v int64 = self.Motion_forward.V
	)
	if self.Motion_forward.Full_px != 0 {
		fw_h <<= 1
		fw_v <<= 1
	}
	if self.Picture_type == plm_video_picture_type_b {
		var (
			bw_h int64 = self.Motion_backward.H
			bw_v int64 = self.Motion_backward.V
		)
		if self.Motion_backward.Full_px != 0 {
			bw_h <<= 1
			bw_v <<= 1
		}
		if self.Motion_forward.Is_set != 0 {
			plm_video_copy_macroblock(self, &self.Frame_forward, fw_h, fw_v)
			if self.Motion_backward.Is_set != 0 {
				plm_video_interpolate_macroblock(self, &self.Frame_backward, bw_h, bw_v)
			}
		} else {
			plm_video_copy_macroblock(self, &self.Frame_backward, bw_h, bw_v)
		}
	} else {
		plm_video_copy_macroblock(self, &self.Frame_forward, fw_h, fw_v)
	}
}
func plm_video_copy_macroblock(self *plm_video_t, s *plm_frame_t, motion_h int64, motion_v int64) {
	var d *plm_frame_t = &self.Frame_current
	plm_video_process_macroblock(self, s.Y.Data, d.Y.Data, motion_h, motion_v, 16, _false)
	plm_video_process_macroblock(self, s.Cr.Data, d.Cr.Data, motion_h/2, motion_v/2, 8, _false)
	plm_video_process_macroblock(self, s.Cb.Data, d.Cb.Data, motion_h/2, motion_v/2, 8, _false)
}
func plm_video_interpolate_macroblock(self *plm_video_t, s *plm_frame_t, motion_h int64, motion_v int64) {
	var d *plm_frame_t = &self.Frame_current
	plm_video_process_macroblock(self, s.Y.Data, d.Y.Data, motion_h, motion_v, 16, _true)
	plm_video_process_macroblock(self, s.Cr.Data, d.Cr.Data, motion_h/2, motion_v/2, 8, _true)
	plm_video_process_macroblock(self, s.Cb.Data, d.Cb.Data, motion_h/2, motion_v/2, 8, _true)
}
func plm_video_process_macroblock(self *plm_video_t, s *uint8, d *uint8, motion_h int64, motion_v int64, block_size int64, interpolate int64) {
	var (
		dw          int64  = self.Mb_width * block_size
		hp          int64  = motion_h >> 1
		vp          int64  = motion_v >> 1
		odd_h       int64  = int64(libc.BoolToInt((motion_h & 1) == 1))
		odd_v       int64  = int64(libc.BoolToInt((motion_v & 1) == 1))
		si          uint64 = uint64(((self.Mb_row*block_size)+vp)*dw + self.Mb_col*block_size + hp)
		di          uint64 = uint64((self.Mb_row*dw + self.Mb_col) * block_size)
		max_address uint64 = uint64(dw*(self.Mb_height*block_size-block_size+1) - block_size)
	)
	if si > max_address || di > max_address {
		return
	}
	switch (interpolate << 2) | odd_h<<1 | odd_v {
	case ((0 << 2) | 0<<1 | 0):
		for {
			{
				var (
					dest_scan   int64 = dw - block_size
					source_scan int64 = dw - block_size
				)
				for y := int64(0); y < block_size; y++ {
					for x := int64(0); x < block_size; x++ {
						*(*uint8)(unsafe.Add(unsafe.Pointer(d), di)) = *(*uint8)(unsafe.Add(unsafe.Pointer(s), si))
						si++
						di++
					}
					si += uint64(source_scan)
					di += uint64(dest_scan)
				}
			}
			if _false == 0 {
				break
			}
		}
	case ((0 << 2) | 0<<1 | 1):
		for {
			{
				var (
					dest_scan   int64 = dw - block_size
					source_scan int64 = dw - block_size
				)
				for y := int64(0); y < block_size; y++ {
					for x := int64(0); x < block_size; x++ {
						*(*uint8)(unsafe.Add(unsafe.Pointer(d), di)) = uint8(int8((int64(*(*uint8)(unsafe.Add(unsafe.Pointer(s), si))) + int64(*(*uint8)(unsafe.Add(unsafe.Pointer(s), si+uint64(dw)))) + 1) >> 1))
						si++
						di++
					}
					si += uint64(source_scan)
					di += uint64(dest_scan)
				}
			}
			if _false == 0 {
				break
			}
		}
	case ((0 << 2) | 1<<1 | 0):
		for {
			{
				var (
					dest_scan   int64 = dw - block_size
					source_scan int64 = dw - block_size
				)
				for y := int64(0); y < block_size; y++ {
					for x := int64(0); x < block_size; x++ {
						*(*uint8)(unsafe.Add(unsafe.Pointer(d), di)) = uint8(int8((int64(*(*uint8)(unsafe.Add(unsafe.Pointer(s), si))) + int64(*(*uint8)(unsafe.Add(unsafe.Pointer(s), si+1))) + 1) >> 1))
						si++
						di++
					}
					si += uint64(source_scan)
					di += uint64(dest_scan)
				}
			}
			if _false == 0 {
				break
			}
		}
	case ((0 << 2) | 1<<1 | 1):
		for {
			{
				var (
					dest_scan   int64 = dw - block_size
					source_scan int64 = dw - block_size
				)
				for y := int64(0); y < block_size; y++ {
					for x := int64(0); x < block_size; x++ {
						*(*uint8)(unsafe.Add(unsafe.Pointer(d), di)) = uint8(int8((int64(*(*uint8)(unsafe.Add(unsafe.Pointer(s), si))) + int64(*(*uint8)(unsafe.Add(unsafe.Pointer(s), si+1))) + int64(*(*uint8)(unsafe.Add(unsafe.Pointer(s), si+uint64(dw)))) + int64(*(*uint8)(unsafe.Add(unsafe.Pointer(s), si+uint64(dw)+1))) + 2) >> 2))
						si++
						di++
					}
					si += uint64(source_scan)
					di += uint64(dest_scan)
				}
			}
			if _false == 0 {
				break
			}
		}
	case ((1 << 2) | 0<<1 | 0):
		for {
			{
				var (
					dest_scan   int64 = dw - block_size
					source_scan int64 = dw - block_size
				)
				for y := int64(0); y < block_size; y++ {
					for x := int64(0); x < block_size; x++ {
						*(*uint8)(unsafe.Add(unsafe.Pointer(d), di)) = uint8(int8((int64(*(*uint8)(unsafe.Add(unsafe.Pointer(d), di))) + int64(*(*uint8)(unsafe.Add(unsafe.Pointer(s), si))) + 1) >> 1))
						si++
						di++
					}
					si += uint64(source_scan)
					di += uint64(dest_scan)
				}
			}
			if _false == 0 {
				break
			}
		}
	case ((1 << 2) | 0<<1 | 1):
		for {
			{
				var (
					dest_scan   int64 = dw - block_size
					source_scan int64 = dw - block_size
				)
				for y := int64(0); y < block_size; y++ {
					for x := int64(0); x < block_size; x++ {
						*(*uint8)(unsafe.Add(unsafe.Pointer(d), di)) = uint8(int8((int64(*(*uint8)(unsafe.Add(unsafe.Pointer(d), di))) + ((int64(*(*uint8)(unsafe.Add(unsafe.Pointer(s), si))) + int64(*(*uint8)(unsafe.Add(unsafe.Pointer(s), si+uint64(dw)))) + 1) >> 1) + 1) >> 1))
						si++
						di++
					}
					si += uint64(source_scan)
					di += uint64(dest_scan)
				}
			}
			if _false == 0 {
				break
			}
		}
	case ((1 << 2) | 1<<1 | 0):
		for {
			{
				var (
					dest_scan   int64 = dw - block_size
					source_scan int64 = dw - block_size
				)
				for y := int64(0); y < block_size; y++ {
					for x := int64(0); x < block_size; x++ {
						*(*uint8)(unsafe.Add(unsafe.Pointer(d), di)) = uint8(int8((int64(*(*uint8)(unsafe.Add(unsafe.Pointer(d), di))) + ((int64(*(*uint8)(unsafe.Add(unsafe.Pointer(s), si))) + int64(*(*uint8)(unsafe.Add(unsafe.Pointer(s), si+1))) + 1) >> 1) + 1) >> 1))
						si++
						di++
					}
					si += uint64(source_scan)
					di += uint64(dest_scan)
				}
			}
			if _false == 0 {
				break
			}
		}
	case ((1 << 2) | 1<<1 | 1):
		for {
			{
				var (
					dest_scan   int64 = dw - block_size
					source_scan int64 = dw - block_size
				)
				for y := int64(0); y < block_size; y++ {
					for x := int64(0); x < block_size; x++ {
						*(*uint8)(unsafe.Add(unsafe.Pointer(d), di)) = uint8(int8((int64(*(*uint8)(unsafe.Add(unsafe.Pointer(d), di))) + ((int64(*(*uint8)(unsafe.Add(unsafe.Pointer(s), si))) + int64(*(*uint8)(unsafe.Add(unsafe.Pointer(s), si+1))) + int64(*(*uint8)(unsafe.Add(unsafe.Pointer(s), si+uint64(dw)))) + int64(*(*uint8)(unsafe.Add(unsafe.Pointer(s), si+uint64(dw)+1))) + 2) >> 2) + 1) >> 1))
						si++
						di++
					}
					si += uint64(source_scan)
					di += uint64(dest_scan)
				}
			}
			if _false == 0 {
				break
			}
		}
	}
}
func plm_video_decode_block(self *plm_video_t, block int64) {
	var (
		n            int64 = 0
		quant_matrix *uint8
	)
	if self.Macroblock_intra != 0 {
		var (
			predictor   int64
			dct_size    int64
			plane_index int64
		)
		if block > 3 {
			plane_index = block - 3
		} else {
			plane_index = 0
		}
		predictor = self.Dc_predictor[plane_index]
		dct_size = int64(plm_buffer_read_vlc(self.Buffer, plm_video_dct_size[plane_index]))
		if dct_size > 0 {
			var differential int64 = plm_buffer_read(self.Buffer, dct_size)
			if (differential & (1 << (dct_size - 1))) != 0 {
				self.Block_data[0] = predictor + differential
			} else {
				self.Block_data[0] = predictor + (-(1 << dct_size) | (differential + 1))
			}
		} else {
			self.Block_data[0] = predictor
		}
		self.Dc_predictor[plane_index] = self.Block_data[0]
		self.Block_data[0] <<= 3 + 5
		quant_matrix = &self.Intra_quant_matrix[0]
		n = 1
	} else {
		quant_matrix = &self.Non_intra_quant_matrix[0]
	}
	var level int64 = 0
	for _true != 0 {
		var (
			run   int64  = 0
			coeff uint16 = plm_buffer_read_vlc_uint(self.Buffer, &plm_video_dct_coeff[0])
		)
		if int64(coeff) == 1 && n > 0 && plm_buffer_read(self.Buffer, 1) == 0 {
			break
		}
		if int64(coeff) == math.MaxUint16 {
			run = plm_buffer_read(self.Buffer, 6)
			level = plm_buffer_read(self.Buffer, 8)
			if level == 0 {
				level = plm_buffer_read(self.Buffer, 8)
			} else if level == 128 {
				level = plm_buffer_read(self.Buffer, 8) - 256
			} else if level > 128 {
				level = level - 256
			}
		} else {
			run = int64(coeff) >> 8
			level = int64(coeff) & math.MaxUint8
			if plm_buffer_read(self.Buffer, 1) != 0 {
				level = -level
			}
		}
		n += run
		if n < 0 || n >= 64 {
			return
		}
		var de_zig_zagged int64 = int64(plm_video_zig_zag[n])
		n++
		level <<= 1
		if self.Macroblock_intra == 0 {
			if level < 0 {
				level += -1
			} else {
				level += 1
			}
		}
		level = (level * self.Quantizer_scale * int64(*(*uint8)(unsafe.Add(unsafe.Pointer(quant_matrix), de_zig_zagged)))) >> 4
		if (level & 1) == 0 {
			if level > 0 {
				level -= 1
			} else {
				level -= -1
			}
		}
		if level > 2047 {
			level = 2047
		} else if level < -2048 {
			level = -2048
		}
		self.Block_data[de_zig_zagged] = level * int64(plm_video_premultiplier_matrix[de_zig_zagged])
	}
	var d *uint8
	var dw int64
	var di int64
	if block < 4 {
		d = self.Frame_current.Y.Data
		dw = self.Luma_width
		di = (self.Mb_row*self.Luma_width + self.Mb_col) << 4
		if (block & 1) != 0 {
			di += 8
		}
		if (block & 2) != 0 {
			di += self.Luma_width << 3
		}
	} else {
		if block == 4 {
			d = self.Frame_current.Cb.Data
		} else {
			d = self.Frame_current.Cr.Data
		}
		dw = self.Chroma_width
		di = ((self.Mb_row * self.Luma_width) << 2) + (self.Mb_col << 3)
	}
	var s *int64 = &self.Block_data[0]
	var si int64 = 0
	if self.Macroblock_intra != 0 {
		if n == 1 {
			var clamped int64 = int64(plm_clamp((*(*int64)(unsafe.Add(unsafe.Pointer(s), unsafe.Sizeof(int64(0))*0)) + 128) >> 8))
			for {
				{
					var (
						dest_scan   int64 = dw - 8
						source_scan int64 = 8 - 8
					)
					for y := int64(0); y < 8; y++ {
						for x := int64(0); x < 8; x++ {
							*(*uint8)(unsafe.Add(unsafe.Pointer(d), di)) = uint8(int8(clamped))
							si++
							di++
						}
						si += source_scan
						di += dest_scan
					}
				}
				if _false == 0 {
					break
				}
			}
			*(*int64)(unsafe.Add(unsafe.Pointer(s), unsafe.Sizeof(int64(0))*0)) = 0
		} else {
			plm_video_idct(s)
			for {
				{
					var (
						dest_scan   int64 = dw - 8
						source_scan int64 = 8 - 8
					)
					for y := int64(0); y < 8; y++ {
						for x := int64(0); x < 8; x++ {
							*(*uint8)(unsafe.Add(unsafe.Pointer(d), di)) = plm_clamp(*(*int64)(unsafe.Add(unsafe.Pointer(s), unsafe.Sizeof(int64(0))*uintptr(si))))
							si++
							di++
						}
						si += source_scan
						di += dest_scan
					}
				}
				if _false == 0 {
					break
				}
			}
			*(*[64]int64)(unsafe.Pointer(&self.Block_data[0])) = [64]int64{}
		}
	} else {
		if n == 1 {
			var value int64 = (*(*int64)(unsafe.Add(unsafe.Pointer(s), unsafe.Sizeof(int64(0))*0)) + 128) >> 8
			for {
				{
					var (
						dest_scan   int64 = dw - 8
						source_scan int64 = 8 - 8
					)
					for y := int64(0); y < 8; y++ {
						for x := int64(0); x < 8; x++ {
							*(*uint8)(unsafe.Add(unsafe.Pointer(d), di)) = plm_clamp(int64(*(*uint8)(unsafe.Add(unsafe.Pointer(d), di))) + value)
							si++
							di++
						}
						si += source_scan
						di += dest_scan
					}
				}
				if _false == 0 {
					break
				}
			}
			*(*int64)(unsafe.Add(unsafe.Pointer(s), unsafe.Sizeof(int64(0))*0)) = 0
		} else {
			plm_video_idct(s)
			for {
				{
					var (
						dest_scan   int64 = dw - 8
						source_scan int64 = 8 - 8
					)
					for y := int64(0); y < 8; y++ {
						for x := int64(0); x < 8; x++ {
							*(*uint8)(unsafe.Add(unsafe.Pointer(d), di)) = plm_clamp(int64(*(*uint8)(unsafe.Add(unsafe.Pointer(d), di))) + *(*int64)(unsafe.Add(unsafe.Pointer(s), unsafe.Sizeof(int64(0))*uintptr(si))))
							si++
							di++
						}
						si += source_scan
						di += dest_scan
					}
				}
				if _false == 0 {
					break
				}
			}
			*(*[64]int64)(unsafe.Pointer(&self.Block_data[0])) = [64]int64{}
		}
	}
}
func plm_video_idct(block *int64) {
	var (
		b1   int64
		b3   int64
		b4   int64
		b6   int64
		b7   int64
		tmp1 int64
		tmp2 int64
		m0   int64
		x0   int64
		x1   int64
		x2   int64
		x3   int64
		x4   int64
		y3   int64
		y4   int64
		y5   int64
		y6   int64
		y7   int64
	)
	for i := int64(0); i < 8; i++ {
		b1 = *(*int64)(unsafe.Add(unsafe.Pointer(block), unsafe.Sizeof(int64(0))*uintptr(i+4*8)))
		b3 = *(*int64)(unsafe.Add(unsafe.Pointer(block), unsafe.Sizeof(int64(0))*uintptr(i+2*8))) + *(*int64)(unsafe.Add(unsafe.Pointer(block), unsafe.Sizeof(int64(0))*uintptr(i+6*8)))
		b4 = *(*int64)(unsafe.Add(unsafe.Pointer(block), unsafe.Sizeof(int64(0))*uintptr(i+5*8))) - *(*int64)(unsafe.Add(unsafe.Pointer(block), unsafe.Sizeof(int64(0))*uintptr(i+3*8)))
		tmp1 = *(*int64)(unsafe.Add(unsafe.Pointer(block), unsafe.Sizeof(int64(0))*uintptr(i+1*8))) + *(*int64)(unsafe.Add(unsafe.Pointer(block), unsafe.Sizeof(int64(0))*uintptr(i+7*8)))
		tmp2 = *(*int64)(unsafe.Add(unsafe.Pointer(block), unsafe.Sizeof(int64(0))*uintptr(i+3*8))) + *(*int64)(unsafe.Add(unsafe.Pointer(block), unsafe.Sizeof(int64(0))*uintptr(i+5*8)))
		b6 = *(*int64)(unsafe.Add(unsafe.Pointer(block), unsafe.Sizeof(int64(0))*uintptr(i+1*8))) - *(*int64)(unsafe.Add(unsafe.Pointer(block), unsafe.Sizeof(int64(0))*uintptr(i+7*8)))
		b7 = tmp1 + tmp2
		m0 = *(*int64)(unsafe.Add(unsafe.Pointer(block), unsafe.Sizeof(int64(0))*uintptr(i+0*8)))
		x4 = ((b6*473 - b4*196 + 128) >> 8) - b7
		x0 = x4 - (((tmp1-tmp2)*362 + 128) >> 8)
		x1 = m0 - b1
		x2 = (((*(*int64)(unsafe.Add(unsafe.Pointer(block), unsafe.Sizeof(int64(0))*uintptr(i+2*8)))-*(*int64)(unsafe.Add(unsafe.Pointer(block), unsafe.Sizeof(int64(0))*uintptr(i+6*8))))*362 + 128) >> 8) - b3
		x3 = m0 + b1
		y3 = x1 + x2
		y4 = x3 + b3
		y5 = x1 - x2
		y6 = x3 - b3
		y7 = -x0 - ((b4*473 + b6*196 + 128) >> 8)
		*(*int64)(unsafe.Add(unsafe.Pointer(block), unsafe.Sizeof(int64(0))*uintptr(i+0*8))) = b7 + y4
		*(*int64)(unsafe.Add(unsafe.Pointer(block), unsafe.Sizeof(int64(0))*uintptr(i+1*8))) = x4 + y3
		*(*int64)(unsafe.Add(unsafe.Pointer(block), unsafe.Sizeof(int64(0))*uintptr(i+2*8))) = y5 - x0
		*(*int64)(unsafe.Add(unsafe.Pointer(block), unsafe.Sizeof(int64(0))*uintptr(i+3*8))) = y6 - y7
		*(*int64)(unsafe.Add(unsafe.Pointer(block), unsafe.Sizeof(int64(0))*uintptr(i+4*8))) = y6 + y7
		*(*int64)(unsafe.Add(unsafe.Pointer(block), unsafe.Sizeof(int64(0))*uintptr(i+5*8))) = x0 + y5
		*(*int64)(unsafe.Add(unsafe.Pointer(block), unsafe.Sizeof(int64(0))*uintptr(i+6*8))) = y3 - x4
		*(*int64)(unsafe.Add(unsafe.Pointer(block), unsafe.Sizeof(int64(0))*uintptr(i+7*8))) = y4 - b7
	}
	for i := int64(0); i < 64; i += 8 {
		b1 = *(*int64)(unsafe.Add(unsafe.Pointer(block), unsafe.Sizeof(int64(0))*uintptr(i+4)))
		b3 = *(*int64)(unsafe.Add(unsafe.Pointer(block), unsafe.Sizeof(int64(0))*uintptr(i+2))) + *(*int64)(unsafe.Add(unsafe.Pointer(block), unsafe.Sizeof(int64(0))*uintptr(i+6)))
		b4 = *(*int64)(unsafe.Add(unsafe.Pointer(block), unsafe.Sizeof(int64(0))*uintptr(i+5))) - *(*int64)(unsafe.Add(unsafe.Pointer(block), unsafe.Sizeof(int64(0))*uintptr(i+3)))
		tmp1 = *(*int64)(unsafe.Add(unsafe.Pointer(block), unsafe.Sizeof(int64(0))*uintptr(i+1))) + *(*int64)(unsafe.Add(unsafe.Pointer(block), unsafe.Sizeof(int64(0))*uintptr(i+7)))
		tmp2 = *(*int64)(unsafe.Add(unsafe.Pointer(block), unsafe.Sizeof(int64(0))*uintptr(i+3))) + *(*int64)(unsafe.Add(unsafe.Pointer(block), unsafe.Sizeof(int64(0))*uintptr(i+5)))
		b6 = *(*int64)(unsafe.Add(unsafe.Pointer(block), unsafe.Sizeof(int64(0))*uintptr(i+1))) - *(*int64)(unsafe.Add(unsafe.Pointer(block), unsafe.Sizeof(int64(0))*uintptr(i+7)))
		b7 = tmp1 + tmp2
		m0 = *(*int64)(unsafe.Add(unsafe.Pointer(block), unsafe.Sizeof(int64(0))*uintptr(i+0)))
		x4 = ((b6*473 - b4*196 + 128) >> 8) - b7
		x0 = x4 - (((tmp1-tmp2)*362 + 128) >> 8)
		x1 = m0 - b1
		x2 = (((*(*int64)(unsafe.Add(unsafe.Pointer(block), unsafe.Sizeof(int64(0))*uintptr(i+2)))-*(*int64)(unsafe.Add(unsafe.Pointer(block), unsafe.Sizeof(int64(0))*uintptr(i+6))))*362 + 128) >> 8) - b3
		x3 = m0 + b1
		y3 = x1 + x2
		y4 = x3 + b3
		y5 = x1 - x2
		y6 = x3 - b3
		y7 = -x0 - ((b4*473 + b6*196 + 128) >> 8)
		*(*int64)(unsafe.Add(unsafe.Pointer(block), unsafe.Sizeof(int64(0))*uintptr(i+0))) = (b7 + y4 + 128) >> 8
		*(*int64)(unsafe.Add(unsafe.Pointer(block), unsafe.Sizeof(int64(0))*uintptr(i+1))) = (x4 + y3 + 128) >> 8
		*(*int64)(unsafe.Add(unsafe.Pointer(block), unsafe.Sizeof(int64(0))*uintptr(i+2))) = (y5 - x0 + 128) >> 8
		*(*int64)(unsafe.Add(unsafe.Pointer(block), unsafe.Sizeof(int64(0))*uintptr(i+3))) = (y6 - y7 + 128) >> 8
		*(*int64)(unsafe.Add(unsafe.Pointer(block), unsafe.Sizeof(int64(0))*uintptr(i+4))) = (y6 + y7 + 128) >> 8
		*(*int64)(unsafe.Add(unsafe.Pointer(block), unsafe.Sizeof(int64(0))*uintptr(i+5))) = (x0 + y5 + 128) >> 8
		*(*int64)(unsafe.Add(unsafe.Pointer(block), unsafe.Sizeof(int64(0))*uintptr(i+6))) = (y3 - x4 + 128) >> 8
		*(*int64)(unsafe.Add(unsafe.Pointer(block), unsafe.Sizeof(int64(0))*uintptr(i+7))) = (y4 - b7 + 128) >> 8
	}
}
func plm_frame_to_rgb(frame *plm_frame_t, dest *uint8, stride int64) {
	var (
		cols int64 = int64(frame.Width >> 1)
		rows int64 = int64(frame.Height >> 1)
		yw   int64 = int64(frame.Y.Width)
		cw   int64 = int64(frame.Cb.Width)
	)
	for row := int64(0); row < rows; row++ {
		var (
			c_index int64 = row * cw
			y_index int64 = row * 2 * yw
			d_index int64 = row * 2 * stride
		)
		for col := int64(0); col < cols; col++ {
			var (
				y  int64
				cr int64 = int64(*(*uint8)(unsafe.Add(unsafe.Pointer(frame.Cr.Data), c_index))) - 128
				cb int64 = int64(*(*uint8)(unsafe.Add(unsafe.Pointer(frame.Cb.Data), c_index))) - 128
				r  int64 = (cr * 0x19895) >> 16
				g  int64 = (cb*0x644A + cr*0xD01E) >> 16
				b  int64 = (cb * 0x20469) >> 16
			)
			y = ((int64(*(*uint8)(unsafe.Add(unsafe.Pointer(frame.Y.Data), y_index+0))) - 16) * 76309) >> 16
			*(*uint8)(unsafe.Add(unsafe.Pointer(dest), d_index+0+0)) = plm_clamp(y + r)
			*(*uint8)(unsafe.Add(unsafe.Pointer(dest), d_index+0+1)) = plm_clamp(y - g)
			*(*uint8)(unsafe.Add(unsafe.Pointer(dest), d_index+0+2)) = plm_clamp(y + b)
			y = ((int64(*(*uint8)(unsafe.Add(unsafe.Pointer(frame.Y.Data), y_index+1))) - 16) * 76309) >> 16
			*(*uint8)(unsafe.Add(unsafe.Pointer(dest), d_index+3+0)) = plm_clamp(y + r)
			*(*uint8)(unsafe.Add(unsafe.Pointer(dest), d_index+3+1)) = plm_clamp(y - g)
			*(*uint8)(unsafe.Add(unsafe.Pointer(dest), d_index+3+2)) = plm_clamp(y + b)
			y = ((int64(*(*uint8)(unsafe.Add(unsafe.Pointer(frame.Y.Data), y_index+yw))) - 16) * 76309) >> 16
			*(*uint8)(unsafe.Add(unsafe.Pointer(dest), d_index+stride+0)) = plm_clamp(y + r)
			*(*uint8)(unsafe.Add(unsafe.Pointer(dest), d_index+stride+1)) = plm_clamp(y - g)
			*(*uint8)(unsafe.Add(unsafe.Pointer(dest), d_index+stride+2)) = plm_clamp(y + b)
			y = ((int64(*(*uint8)(unsafe.Add(unsafe.Pointer(frame.Y.Data), y_index+yw+1))) - 16) * 76309) >> 16
			*(*uint8)(unsafe.Add(unsafe.Pointer(dest), d_index+stride+3+0)) = plm_clamp(y + r)
			*(*uint8)(unsafe.Add(unsafe.Pointer(dest), d_index+stride+3+1)) = plm_clamp(y - g)
			*(*uint8)(unsafe.Add(unsafe.Pointer(dest), d_index+stride+3+2)) = plm_clamp(y + b)
			c_index += 1
			y_index += 2
			d_index += 2 * 3
		}
	}
}
func plm_frame_to_bgr(frame *plm_frame_t, dest *uint8, stride int64) {
	var (
		cols int64 = int64(frame.Width >> 1)
		rows int64 = int64(frame.Height >> 1)
		yw   int64 = int64(frame.Y.Width)
		cw   int64 = int64(frame.Cb.Width)
	)
	for row := int64(0); row < rows; row++ {
		var (
			c_index int64 = row * cw
			y_index int64 = row * 2 * yw
			d_index int64 = row * 2 * stride
		)
		for col := int64(0); col < cols; col++ {
			var (
				y  int64
				cr int64 = int64(*(*uint8)(unsafe.Add(unsafe.Pointer(frame.Cr.Data), c_index))) - 128
				cb int64 = int64(*(*uint8)(unsafe.Add(unsafe.Pointer(frame.Cb.Data), c_index))) - 128
				r  int64 = (cr * 0x19895) >> 16
				g  int64 = (cb*0x644A + cr*0xD01E) >> 16
				b  int64 = (cb * 0x20469) >> 16
			)
			y = ((int64(*(*uint8)(unsafe.Add(unsafe.Pointer(frame.Y.Data), y_index+0))) - 16) * 76309) >> 16
			*(*uint8)(unsafe.Add(unsafe.Pointer(dest), d_index+0+2)) = plm_clamp(y + r)
			*(*uint8)(unsafe.Add(unsafe.Pointer(dest), d_index+0+1)) = plm_clamp(y - g)
			*(*uint8)(unsafe.Add(unsafe.Pointer(dest), d_index+0+0)) = plm_clamp(y + b)
			y = ((int64(*(*uint8)(unsafe.Add(unsafe.Pointer(frame.Y.Data), y_index+1))) - 16) * 76309) >> 16
			*(*uint8)(unsafe.Add(unsafe.Pointer(dest), d_index+3+2)) = plm_clamp(y + r)
			*(*uint8)(unsafe.Add(unsafe.Pointer(dest), d_index+3+1)) = plm_clamp(y - g)
			*(*uint8)(unsafe.Add(unsafe.Pointer(dest), d_index+3+0)) = plm_clamp(y + b)
			y = ((int64(*(*uint8)(unsafe.Add(unsafe.Pointer(frame.Y.Data), y_index+yw))) - 16) * 76309) >> 16
			*(*uint8)(unsafe.Add(unsafe.Pointer(dest), d_index+stride+2)) = plm_clamp(y + r)
			*(*uint8)(unsafe.Add(unsafe.Pointer(dest), d_index+stride+1)) = plm_clamp(y - g)
			*(*uint8)(unsafe.Add(unsafe.Pointer(dest), d_index+stride+0)) = plm_clamp(y + b)
			y = ((int64(*(*uint8)(unsafe.Add(unsafe.Pointer(frame.Y.Data), y_index+yw+1))) - 16) * 76309) >> 16
			*(*uint8)(unsafe.Add(unsafe.Pointer(dest), d_index+stride+3+2)) = plm_clamp(y + r)
			*(*uint8)(unsafe.Add(unsafe.Pointer(dest), d_index+stride+3+1)) = plm_clamp(y - g)
			*(*uint8)(unsafe.Add(unsafe.Pointer(dest), d_index+stride+3+0)) = plm_clamp(y + b)
			c_index += 1
			y_index += 2
			d_index += 2 * 3
		}
	}
}
func plm_frame_to_rgba(frame *plm_frame_t, dest *uint8, stride int64) {
	var (
		cols int64 = int64(frame.Width >> 1)
		rows int64 = int64(frame.Height >> 1)
		yw   int64 = int64(frame.Y.Width)
		cw   int64 = int64(frame.Cb.Width)
	)
	for row := int64(0); row < rows; row++ {
		var (
			c_index int64 = row * cw
			y_index int64 = row * 2 * yw
			d_index int64 = row * 2 * stride
		)
		for col := int64(0); col < cols; col++ {
			var (
				y  int64
				cr int64 = int64(*(*uint8)(unsafe.Add(unsafe.Pointer(frame.Cr.Data), c_index))) - 128
				cb int64 = int64(*(*uint8)(unsafe.Add(unsafe.Pointer(frame.Cb.Data), c_index))) - 128
				r  int64 = (cr * 0x19895) >> 16
				g  int64 = (cb*0x644A + cr*0xD01E) >> 16
				b  int64 = (cb * 0x20469) >> 16
			)
			y = ((int64(*(*uint8)(unsafe.Add(unsafe.Pointer(frame.Y.Data), y_index+0))) - 16) * 76309) >> 16
			*(*uint8)(unsafe.Add(unsafe.Pointer(dest), d_index+0+0)) = plm_clamp(y + r)
			*(*uint8)(unsafe.Add(unsafe.Pointer(dest), d_index+0+1)) = plm_clamp(y - g)
			*(*uint8)(unsafe.Add(unsafe.Pointer(dest), d_index+0+2)) = plm_clamp(y + b)
			y = ((int64(*(*uint8)(unsafe.Add(unsafe.Pointer(frame.Y.Data), y_index+1))) - 16) * 76309) >> 16
			*(*uint8)(unsafe.Add(unsafe.Pointer(dest), d_index+4+0)) = plm_clamp(y + r)
			*(*uint8)(unsafe.Add(unsafe.Pointer(dest), d_index+4+1)) = plm_clamp(y - g)
			*(*uint8)(unsafe.Add(unsafe.Pointer(dest), d_index+4+2)) = plm_clamp(y + b)
			y = ((int64(*(*uint8)(unsafe.Add(unsafe.Pointer(frame.Y.Data), y_index+yw))) - 16) * 76309) >> 16
			*(*uint8)(unsafe.Add(unsafe.Pointer(dest), d_index+stride+0)) = plm_clamp(y + r)
			*(*uint8)(unsafe.Add(unsafe.Pointer(dest), d_index+stride+1)) = plm_clamp(y - g)
			*(*uint8)(unsafe.Add(unsafe.Pointer(dest), d_index+stride+2)) = plm_clamp(y + b)
			y = ((int64(*(*uint8)(unsafe.Add(unsafe.Pointer(frame.Y.Data), y_index+yw+1))) - 16) * 76309) >> 16
			*(*uint8)(unsafe.Add(unsafe.Pointer(dest), d_index+stride+4+0)) = plm_clamp(y + r)
			*(*uint8)(unsafe.Add(unsafe.Pointer(dest), d_index+stride+4+1)) = plm_clamp(y - g)
			*(*uint8)(unsafe.Add(unsafe.Pointer(dest), d_index+stride+4+2)) = plm_clamp(y + b)
			c_index += 1
			y_index += 2
			d_index += 2 * 4
		}
	}
}
func plm_frame_to_bgra(frame *plm_frame_t, dest *uint8, stride int64) {
	var (
		cols int64 = int64(frame.Width >> 1)
		rows int64 = int64(frame.Height >> 1)
		yw   int64 = int64(frame.Y.Width)
		cw   int64 = int64(frame.Cb.Width)
	)
	for row := int64(0); row < rows; row++ {
		var (
			c_index int64 = row * cw
			y_index int64 = row * 2 * yw
			d_index int64 = row * 2 * stride
		)
		for col := int64(0); col < cols; col++ {
			var (
				y  int64
				cr int64 = int64(*(*uint8)(unsafe.Add(unsafe.Pointer(frame.Cr.Data), c_index))) - 128
				cb int64 = int64(*(*uint8)(unsafe.Add(unsafe.Pointer(frame.Cb.Data), c_index))) - 128
				r  int64 = (cr * 0x19895) >> 16
				g  int64 = (cb*0x644A + cr*0xD01E) >> 16
				b  int64 = (cb * 0x20469) >> 16
			)
			y = ((int64(*(*uint8)(unsafe.Add(unsafe.Pointer(frame.Y.Data), y_index+0))) - 16) * 76309) >> 16
			*(*uint8)(unsafe.Add(unsafe.Pointer(dest), d_index+0+2)) = plm_clamp(y + r)
			*(*uint8)(unsafe.Add(unsafe.Pointer(dest), d_index+0+1)) = plm_clamp(y - g)
			*(*uint8)(unsafe.Add(unsafe.Pointer(dest), d_index+0+0)) = plm_clamp(y + b)
			y = ((int64(*(*uint8)(unsafe.Add(unsafe.Pointer(frame.Y.Data), y_index+1))) - 16) * 76309) >> 16
			*(*uint8)(unsafe.Add(unsafe.Pointer(dest), d_index+4+2)) = plm_clamp(y + r)
			*(*uint8)(unsafe.Add(unsafe.Pointer(dest), d_index+4+1)) = plm_clamp(y - g)
			*(*uint8)(unsafe.Add(unsafe.Pointer(dest), d_index+4+0)) = plm_clamp(y + b)
			y = ((int64(*(*uint8)(unsafe.Add(unsafe.Pointer(frame.Y.Data), y_index+yw))) - 16) * 76309) >> 16
			*(*uint8)(unsafe.Add(unsafe.Pointer(dest), d_index+stride+2)) = plm_clamp(y + r)
			*(*uint8)(unsafe.Add(unsafe.Pointer(dest), d_index+stride+1)) = plm_clamp(y - g)
			*(*uint8)(unsafe.Add(unsafe.Pointer(dest), d_index+stride+0)) = plm_clamp(y + b)
			y = ((int64(*(*uint8)(unsafe.Add(unsafe.Pointer(frame.Y.Data), y_index+yw+1))) - 16) * 76309) >> 16
			*(*uint8)(unsafe.Add(unsafe.Pointer(dest), d_index+stride+4+2)) = plm_clamp(y + r)
			*(*uint8)(unsafe.Add(unsafe.Pointer(dest), d_index+stride+4+1)) = plm_clamp(y - g)
			*(*uint8)(unsafe.Add(unsafe.Pointer(dest), d_index+stride+4+0)) = plm_clamp(y + b)
			c_index += 1
			y_index += 2
			d_index += 2 * 4
		}
	}
}
func plm_frame_to_argb(frame *plm_frame_t, dest *uint8, stride int64) {
	var (
		cols int64 = int64(frame.Width >> 1)
		rows int64 = int64(frame.Height >> 1)
		yw   int64 = int64(frame.Y.Width)
		cw   int64 = int64(frame.Cb.Width)
	)
	for row := int64(0); row < rows; row++ {
		var (
			c_index int64 = row * cw
			y_index int64 = row * 2 * yw
			d_index int64 = row * 2 * stride
		)
		for col := int64(0); col < cols; col++ {
			var (
				y  int64
				cr int64 = int64(*(*uint8)(unsafe.Add(unsafe.Pointer(frame.Cr.Data), c_index))) - 128
				cb int64 = int64(*(*uint8)(unsafe.Add(unsafe.Pointer(frame.Cb.Data), c_index))) - 128
				r  int64 = (cr * 0x19895) >> 16
				g  int64 = (cb*0x644A + cr*0xD01E) >> 16
				b  int64 = (cb * 0x20469) >> 16
			)
			y = ((int64(*(*uint8)(unsafe.Add(unsafe.Pointer(frame.Y.Data), y_index+0))) - 16) * 76309) >> 16
			*(*uint8)(unsafe.Add(unsafe.Pointer(dest), d_index+0+1)) = plm_clamp(y + r)
			*(*uint8)(unsafe.Add(unsafe.Pointer(dest), d_index+0+2)) = plm_clamp(y - g)
			*(*uint8)(unsafe.Add(unsafe.Pointer(dest), d_index+0+3)) = plm_clamp(y + b)
			y = ((int64(*(*uint8)(unsafe.Add(unsafe.Pointer(frame.Y.Data), y_index+1))) - 16) * 76309) >> 16
			*(*uint8)(unsafe.Add(unsafe.Pointer(dest), d_index+4+1)) = plm_clamp(y + r)
			*(*uint8)(unsafe.Add(unsafe.Pointer(dest), d_index+4+2)) = plm_clamp(y - g)
			*(*uint8)(unsafe.Add(unsafe.Pointer(dest), d_index+4+3)) = plm_clamp(y + b)
			y = ((int64(*(*uint8)(unsafe.Add(unsafe.Pointer(frame.Y.Data), y_index+yw))) - 16) * 76309) >> 16
			*(*uint8)(unsafe.Add(unsafe.Pointer(dest), d_index+stride+1)) = plm_clamp(y + r)
			*(*uint8)(unsafe.Add(unsafe.Pointer(dest), d_index+stride+2)) = plm_clamp(y - g)
			*(*uint8)(unsafe.Add(unsafe.Pointer(dest), d_index+stride+3)) = plm_clamp(y + b)
			y = ((int64(*(*uint8)(unsafe.Add(unsafe.Pointer(frame.Y.Data), y_index+yw+1))) - 16) * 76309) >> 16
			*(*uint8)(unsafe.Add(unsafe.Pointer(dest), d_index+stride+4+1)) = plm_clamp(y + r)
			*(*uint8)(unsafe.Add(unsafe.Pointer(dest), d_index+stride+4+2)) = plm_clamp(y - g)
			*(*uint8)(unsafe.Add(unsafe.Pointer(dest), d_index+stride+4+3)) = plm_clamp(y + b)
			c_index += 1
			y_index += 2
			d_index += 2 * 4
		}
	}
}
func plm_frame_to_abgr(frame *plm_frame_t, dest *uint8, stride int64) {
	var (
		cols int64 = int64(frame.Width >> 1)
		rows int64 = int64(frame.Height >> 1)
		yw   int64 = int64(frame.Y.Width)
		cw   int64 = int64(frame.Cb.Width)
	)
	for row := int64(0); row < rows; row++ {
		var (
			c_index int64 = row * cw
			y_index int64 = row * 2 * yw
			d_index int64 = row * 2 * stride
		)
		for col := int64(0); col < cols; col++ {
			var (
				y  int64
				cr int64 = int64(*(*uint8)(unsafe.Add(unsafe.Pointer(frame.Cr.Data), c_index))) - 128
				cb int64 = int64(*(*uint8)(unsafe.Add(unsafe.Pointer(frame.Cb.Data), c_index))) - 128
				r  int64 = (cr * 0x19895) >> 16
				g  int64 = (cb*0x644A + cr*0xD01E) >> 16
				b  int64 = (cb * 0x20469) >> 16
			)
			y = ((int64(*(*uint8)(unsafe.Add(unsafe.Pointer(frame.Y.Data), y_index+0))) - 16) * 76309) >> 16
			*(*uint8)(unsafe.Add(unsafe.Pointer(dest), d_index+0+3)) = plm_clamp(y + r)
			*(*uint8)(unsafe.Add(unsafe.Pointer(dest), d_index+0+2)) = plm_clamp(y - g)
			*(*uint8)(unsafe.Add(unsafe.Pointer(dest), d_index+0+1)) = plm_clamp(y + b)
			y = ((int64(*(*uint8)(unsafe.Add(unsafe.Pointer(frame.Y.Data), y_index+1))) - 16) * 76309) >> 16
			*(*uint8)(unsafe.Add(unsafe.Pointer(dest), d_index+4+3)) = plm_clamp(y + r)
			*(*uint8)(unsafe.Add(unsafe.Pointer(dest), d_index+4+2)) = plm_clamp(y - g)
			*(*uint8)(unsafe.Add(unsafe.Pointer(dest), d_index+4+1)) = plm_clamp(y + b)
			y = ((int64(*(*uint8)(unsafe.Add(unsafe.Pointer(frame.Y.Data), y_index+yw))) - 16) * 76309) >> 16
			*(*uint8)(unsafe.Add(unsafe.Pointer(dest), d_index+stride+3)) = plm_clamp(y + r)
			*(*uint8)(unsafe.Add(unsafe.Pointer(dest), d_index+stride+2)) = plm_clamp(y - g)
			*(*uint8)(unsafe.Add(unsafe.Pointer(dest), d_index+stride+1)) = plm_clamp(y + b)
			y = ((int64(*(*uint8)(unsafe.Add(unsafe.Pointer(frame.Y.Data), y_index+yw+1))) - 16) * 76309) >> 16
			*(*uint8)(unsafe.Add(unsafe.Pointer(dest), d_index+stride+4+3)) = plm_clamp(y + r)
			*(*uint8)(unsafe.Add(unsafe.Pointer(dest), d_index+stride+4+2)) = plm_clamp(y - g)
			*(*uint8)(unsafe.Add(unsafe.Pointer(dest), d_index+stride+4+1)) = plm_clamp(y + b)
			c_index += 1
			y_index += 2
			d_index += 2 * 4
		}
	}
}

var plm_audio_frame_sync int64 = 2047
var plm_audio_mpeg_2_5 int64 = 0
var plm_audio_mpeg_2 int64 = 2
var plm_audio_mpeg_1 int64 = 3
var plm_audio_layer_iii int64 = 1
var plm_audio_layer_ii int64 = 2
var plm_audio_layer_i int64 = 3
var plm_audio_mode_stereo int64 = 0
var plm_audio_mode_joint_stereo int64 = 1
var plm_audio_mode_dual_channel int64 = 2
var plm_audio_mode_mono int64 = 3
var plm_audio_sample_rate [8]uint16 = [8]uint16{44100, 48000, 32000, 0, 22050, 24000, 16000, 0}
var plm_audio_bit_rate [28]int16 = [28]int16{32, 48, 56, 64, 80, 96, 112, 128, 160, 192, 224, 256, 320, 384, 8, 16, 24, 32, 40, 48, 56, 64, 80, 96, 112, 128, 144, 160}
var plm_audio_scalefactor_base [3]int64 = [3]int64{0x2000000, 26632170, 0x1428A30}
var plm_audio_synthesis_window [512]float32 = [512]float32{0.0, -0.5, -0.5, -0.5, -0.5, -0.5, -0.5, -1.0, -1.0, -1.0, -1.0, -1.5, -1.5, -2.0, -2.0, -2.5, -2.5, -3.0, -3.5, -3.5, -4.0, -4.5, -5.0, -5.5, -6.5, -7.0, -8.0, -8.5, -9.5, -10.5, -12.0, -13.0, -14.5, -15.5, -17.5, -19.0, -20.5, -22.5, -24.5, -26.5, -29.0, -31.5, -34.0, -36.5, -39.5, -42.5, -45.5, -48.5, -52.0, -55.5, -58.5, -62.5, -66.0, -69.5, -73.5, -77.0, -80.5, -84.5, -88.0, -91.5, -95.0, -98.0, -101.0, -104.0, 106.5, 109.0, 111.0, 112.5, 113.5, 114.0, 114.0, 113.5, 112.0, 110.5, 107.5, 104.0, 100.0, 94.5, 88.5, 81.5, 73.0, 63.5, 53.0, 41.5, 28.5, 14.5, -1.0, -18.0, -36.0, -55.5, -76.5, -98.5, -122.0, -147.0, -173.5, -200.5, -229.5, -259.5, -290.5, -322.5, -355.5, -389.5, -424.0, -459.5, -495.5, -532.0, -568.5, -605.0, -641.5, -678.0, -714.0, -749.0, -783.5, -817.0, -849.0, -879.5, -908.5, -935.0, -959.5, -981.0, -1000.5, -1016.0, -1028.5, -1037.5, -1042.5, -1043.5, -1040.0, -1031.5, 1018.5, 1000.0, 976.0, 946.5, 911.0, 869.5, 822.0, 767.5, 707.0, 640.0, 565.5, 485.0, 397.0, 302.5, 201.0, 92.5, -22.5, -144.0, -272.5, -407.0, -547.5, -694.0, -846.0, -1003.0, -1165.0, -1331.5, -1502.0, -1675.5, -1852.5, -2031.5, -2212.5, -2394.0, -2576.5, -2758.5, -2939.5, -3118.5, -3294.5, -3467.5, -3635.5, -3798.5, -3955.0, -4104.5, -4245.5, -4377.5, -4499.0, -4609.5, -4708.0, -4792.5, -4863.5, -4919.0, -4958.0, -4979.5, -4983.0, -4967.5, -4931.5, -4875.0, -4796.0, -4694.5, -4569.5, -4420.0, -4246.0, -4046.0, -3820.0, -3567.0, 3287.0, 2979.5, 2644.0, 2280.5, 1888.0, 1467.5, 1018.5, 541.0, 35.0, -499.0, -1061.0, -1650.0, -2266.5, -2909.0, -3577.0, -4270.0, -4987.5, -5727.5, -6490.0, -7274.0, -8077.5, -8899.5, -9739.0, -10594.5, -11464.5, -12347.0, -13241.0, -14144.5, -15056.0, -15973.5, -16895.5, -17820.0, -18744.5, -19668.0, -20588.0, -21503.0, -22410.5, -23308.5, -24195.0, -25068.5, -25926.5, -26767.0, -27589.0, -28389.0, -29166.5, -29919.0, -30644.5, -31342.0, -32009.5, -32645.0, -33247.0, -33814.5, -34346.0, -34839.5, -35295.0, -35710.0, -36084.5, -36417.5, -36707.5, -36954.0, -37156.5, -37315.0, -37428.0, -37496.0, 37519.0, 37496.0, 37428.0, 37315.0, 37156.5, 36954.0, 36707.5, 36417.5, 36084.5, 35710.0, 35295.0, 34839.5, 34346.0, 33814.5, 33247.0, 32645.0, 32009.5, 31342.0, 30644.5, 29919.0, 29166.5, 28389.0, 27589.0, 26767.0, 25926.5, 25068.5, 24195.0, 23308.5, 22410.5, 21503.0, 20588.0, 19668.0, 18744.5, 17820.0, 16895.5, 15973.5, 15056.0, 14144.5, 13241.0, 12347.0, 11464.5, 10594.5, 9739.0, 8899.5, 8077.5, 7274.0, 6490.0, 5727.5, 4987.5, 4270.0, 3577.0, 2909.0, 2266.5, 1650.0, 1061.0, 499.0, -35.0, -541.0, -1018.5, -1467.5, -1888.0, -2280.5, -2644.0, -2979.5, 3287.0, 3567.0, 3820.0, 4046.0, 4246.0, 4420.0, 4569.5, 4694.5, 4796.0, 4875.0, 4931.5, 4967.5, 4983.0, 4979.5, 4958.0, 4919.0, 4863.5, 4792.5, 4708.0, 4609.5, 4499.0, 4377.5, 4245.5, 4104.5, 3955.0, 3798.5, 3635.5, 3467.5, 3294.5, 3118.5, 2939.5, 2758.5, 2576.5, 2394.0, 2212.5, 2031.5, 1852.5, 1675.5, 1502.0, 1331.5, 1165.0, 1003.0, 846.0, 694.0, 547.5, 407.0, 272.5, 144.0, 22.5, -92.5, -201.0, -302.5, -397.0, -485.0, -565.5, -640.0, -707.0, -767.5, -822.0, -869.5, -911.0, -946.5, -976.0, -1000.0, 1018.5, 1031.5, 1040.0, 1043.5, 1042.5, 1037.5, 1028.5, 1016.0, 1000.5, 981.0, 959.5, 935.0, 908.5, 879.5, 849.0, 817.0, 783.5, 749.0, 714.0, 678.0, 641.5, 605.0, 568.5, 532.0, 495.5, 459.5, 424.0, 389.5, 355.5, 322.5, 290.5, 259.5, 229.5, 200.5, 173.5, 147.0, 122.0, 98.5, 76.5, 55.5, 36.0, 18.0, 1.0, -14.5, -28.5, -41.5, -53.0, -63.5, -73.0, -81.5, -88.5, -94.5, -100.0, -104.0, -107.5, -110.5, -112.0, -113.5, -114.0, -114.0, -113.5, -112.5, -111.0, -109.0, 106.5, 104.0, 101.0, 98.0, 95.0, 91.5, 88.0, 84.5, 80.5, 77.0, 73.5, 69.5, 66.0, 62.5, 58.5, 55.5, 52.0, 48.5, 45.5, 42.5, 39.5, 36.5, 34.0, 31.5, 29.0, 26.5, 24.5, 22.5, 20.5, 19.0, 17.5, 15.5, 14.5, 13.0, 12.0, 10.5, 9.5, 8.5, 8.0, 7.0, 6.5, 5.5, 5.0, 4.5, 4.0, 3.5, 3.5, 3.0, 2.5, 2.5, 2.0, 2.0, 1.5, 1.5, 1.0, 1.0, 1.0, 1.0, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5}
var plm_audio_quant_lut_step_1 [2][16]uint8 = [2][16]uint8{{0: 0, 1: 0, 2: 1, 3: 1, 4: 1, 5: 2, 6: 2, 7: 2, 8: 2, 9: 2, 10: 2, 11: 2, 12: 2, 13: 2}, {0: 0, 1: 0, 2: 0, 3: 0, 4: 0, 5: 0, 6: 1, 7: 1, 8: 1, 9: 2, 10: 2, 11: 2, 12: 2, 13: 2}}
var plm_audio_quant_tab_A uint8 = (27 | 64)
var plm_audio_quant_tab_B uint8 = (30 | 64)
var plm_audio_quant_tab_C uint8 = 8
var plm_audio_quant_tab_D uint8 = 12
var quant_lut_step_2 [3][3]uint8 = [3][3]uint8{{plm_audio_quant_tab_C, plm_audio_quant_tab_C, plm_audio_quant_tab_D}, {plm_audio_quant_tab_A, plm_audio_quant_tab_A, plm_audio_quant_tab_A}, {plm_audio_quant_tab_B, plm_audio_quant_tab_A, plm_audio_quant_tab_B}}
var plm_audio_quant_lut_step_3 [3][32]uint8 = [3][32]uint8{{0: 68, 1: 68, 2: 52, 3: 52, 4: 52, 5: 52, 6: 52, 7: 52, 8: 52, 9: 52, 10: 52, 11: 52}, {0: 67, 1: 67, 2: 67, 3: 66, 4: 66, 5: 66, 6: 66, 7: 66, 8: 66, 9: 66, 10: 66, 11: 49, 12: 49, 13: 49, 14: 49, 15: 49, 16: 49, 17: 49, 18: 49, 19: 49, 20: 49, 21: 49, 22: 49, 23: 32, 24: 32, 25: 32, 26: 32, 27: 32, 28: 32, 29: 32}, {0: 69, 1: 69, 2: 69, 3: 69, 4: 52, 5: 52, 6: 52, 7: 52, 8: 52, 9: 52, 10: 52, 11: 36, 12: 36, 13: 36, 14: 36, 15: 36, 16: 36, 17: 36, 18: 36, 19: 36, 20: 36, 21: 36, 22: 36, 23: 36, 24: 36, 25: 36, 26: 36, 27: 36, 28: 36, 29: 36}}
var plm_audio_quant_lut_step_4 [6][16]uint8 = [6][16]uint8{{0: 0, 1: 1, 2: 2, 3: 17}, {0: 0, 1: 1, 2: 2, 3: 3, 4: 4, 5: 5, 6: 6, 7: 17}, {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 17}, {0, 1, 3, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17}, {0, 1, 2, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 17}, {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15}}

type plm_quantizer_spec_t struct {
	Levels uint16
	Group  uint8
	Bits   uint8
}

var plm_audio_quant_tab [17]plm_quantizer_spec_t = [17]plm_quantizer_spec_t{{Levels: 3, Group: 1, Bits: 5}, {Levels: 5, Group: 1, Bits: 7}, {Levels: 7, Group: 0, Bits: 3}, {Levels: 9, Group: 1, Bits: 10}, {Levels: 15, Group: 0, Bits: 4}, {Levels: 31, Group: 0, Bits: 5}, {Levels: 63, Group: 0, Bits: 6}, {Levels: math.MaxInt8, Group: 0, Bits: 7}, {Levels: math.MaxUint8, Group: 0, Bits: 8}, {Levels: 511, Group: 0, Bits: 9}, {Levels: 1023, Group: 0, Bits: 10}, {Levels: 2047, Group: 0, Bits: 11}, {Levels: 4095, Group: 0, Bits: 12}, {Levels: 8191, Group: 0, Bits: 13}, {Levels: 0x3FFF, Group: 0, Bits: 14}, {Levels: math.MaxInt16, Group: 0, Bits: 15}, {Levels: math.MaxUint16, Group: 0, Bits: 16}}

func plm_audio_create_with_buffer(buffer *plm_buffer_t, destroy_when_done int64) *plm_audio_t {
	var self *plm_audio_t = new(plm_audio_t)
	*self = plm_audio_t{}
	self.Samples.Count = plm_audio_samples_per_frame
	self.Buffer = buffer
	self.Destroy_buffer_when_done = destroy_when_done
	self.Samplerate_index = 3
	libc.MemCpy(unsafe.Pointer(&self.D[0]), unsafe.Pointer(&plm_audio_synthesis_window[0]), int(512*unsafe.Sizeof(float32(0))))
	libc.MemCpy(unsafe.Pointer(&self.D[512]), unsafe.Pointer(&plm_audio_synthesis_window[0]), int(512*unsafe.Sizeof(float32(0))))
	self.Next_frame_data_size = plm_audio_decode_header(self)
	return self
}
func plm_audio_destroy(self *plm_audio_t) {
	if self.Destroy_buffer_when_done != 0 {
		plm_buffer_destroy(self.Buffer)
	}
	libc.Free(unsafe.Pointer(self))
}
func plm_audio_has_header(self *plm_audio_t) int64 {
	if self.Has_header != 0 {
		return _true
	}
	self.Next_frame_data_size = plm_audio_decode_header(self)
	return self.Has_header
}
func plm_audio_get_samplerate(self *plm_audio_t) int64 {
	if plm_audio_has_header(self) != 0 {
		return int64(plm_audio_sample_rate[self.Samplerate_index])
	}
	return 0
}
func plm_audio_get_time(self *plm_audio_t) float64 {
	return self.Time
}
func plm_audio_set_time(self *plm_audio_t, time float64) {
	self.Samples_decoded = int64(time * float64(plm_audio_sample_rate[self.Samplerate_index]))
	self.Time = time
}
func plm_audio_rewind(self *plm_audio_t) {
	plm_buffer_rewind(self.Buffer)
	self.Time = 0
	self.Samples_decoded = 0
	self.Next_frame_data_size = 0
}
func plm_audio_has_ended(self *plm_audio_t) int64 {
	return plm_buffer_has_ended(self.Buffer)
}
func plm_audio_decode(self *plm_audio_t) *plm_samples_t {
	if self.Next_frame_data_size == 0 {
		if plm_buffer_has(self.Buffer, 48) == 0 {
			return nil
		}
		self.Next_frame_data_size = plm_audio_decode_header(self)
	}
	if self.Next_frame_data_size == 0 || plm_buffer_has(self.Buffer, uint64(self.Next_frame_data_size<<3)) == 0 {
		return nil
	}
	plm_audio_decode_frame(self)
	self.Next_frame_data_size = 0
	self.Samples.Time = self.Time
	self.Samples_decoded += plm_audio_samples_per_frame
	self.Time = float64(self.Samples_decoded) / float64(plm_audio_sample_rate[self.Samplerate_index])
	return &self.Samples
}
func plm_audio_find_frame_sync(self *plm_audio_t) int64 {
	var i uint64
	for i = self.Buffer.Bit_index >> 3; i < self.Buffer.Length-1; i++ {
		if int64(*(*uint8)(unsafe.Add(unsafe.Pointer(self.Buffer.Bytes), i))) == math.MaxUint8 && (int64(*(*uint8)(unsafe.Add(unsafe.Pointer(self.Buffer.Bytes), i+1)))&254) == 252 {
			self.Buffer.Bit_index = ((i + 1) << 3) + 3
			return _true
		}
	}
	self.Buffer.Bit_index = (i + 1) << 3
	return _false
}
func plm_audio_decode_header(self *plm_audio_t) int64 {
	if plm_buffer_has(self.Buffer, 48) == 0 {
		return 0
	}
	plm_buffer_skip_bytes(self.Buffer, 0)
	var sync int64 = plm_buffer_read(self.Buffer, 11)
	if sync != plm_audio_frame_sync && plm_audio_find_frame_sync(self) == 0 {
		return 0
	}
	self.Version = plm_buffer_read(self.Buffer, 2)
	self.Layer = plm_buffer_read(self.Buffer, 2)
	var hasCRC int64 = int64(libc.BoolToInt(plm_buffer_read(self.Buffer, 1) == 0))
	if self.Version != plm_audio_mpeg_1 || self.Layer != plm_audio_layer_ii {
		return 0
	}
	var bitrate_index int64 = plm_buffer_read(self.Buffer, 4) - 1
	if bitrate_index > 13 {
		return 0
	}
	var samplerate_index int64 = plm_buffer_read(self.Buffer, 2)
	if samplerate_index == 3 {
		return 0
	}
	var padding int64 = plm_buffer_read(self.Buffer, 1)
	plm_buffer_skip(self.Buffer, 1)
	var mode int64 = plm_buffer_read(self.Buffer, 2)
	if self.Has_header != 0 && (self.Bitrate_index != bitrate_index || self.Samplerate_index != samplerate_index || self.Mode != mode) {
		return 0
	}
	self.Bitrate_index = bitrate_index
	self.Samplerate_index = samplerate_index
	self.Mode = mode
	self.Has_header = _true
	if mode == plm_audio_mode_joint_stereo {
		self.Bound = (plm_buffer_read(self.Buffer, 2) + 1) << 2
	} else {
		plm_buffer_skip(self.Buffer, 2)
		if mode == plm_audio_mode_mono {
			self.Bound = 0
		} else {
			self.Bound = 32
		}
	}
	plm_buffer_skip(self.Buffer, 4)
	if hasCRC != 0 {
		plm_buffer_skip(self.Buffer, 16)
	}
	var bitrate int64 = int64(plm_audio_bit_rate[self.Bitrate_index])
	var samplerate int64 = int64(plm_audio_sample_rate[self.Samplerate_index])
	var frame_size int64 = (bitrate * 144000 / samplerate) + padding
	return frame_size - (func() int64 {
		if hasCRC != 0 {
			return 6
		}
		return 4
	}())
}
func plm_audio_decode_frame(self *plm_audio_t) {
	var (
		tab3    int64 = 0
		sblimit int64 = 0
		tab1    int64
	)
	if self.Mode == plm_audio_mode_mono {
		tab1 = 0
	} else {
		tab1 = 1
	}
	var tab2 int64 = int64(plm_audio_quant_lut_step_1[tab1][self.Bitrate_index])
	tab3 = int64(quant_lut_step_2[tab2][self.Samplerate_index])
	sblimit = tab3 & 63
	tab3 >>= 6
	if self.Bound > sblimit {
		self.Bound = sblimit
	}
	for sb := int64(0); sb < self.Bound; sb++ {
		self.Allocation[0][sb] = plm_audio_read_allocation(self, sb, tab3)
		self.Allocation[1][sb] = plm_audio_read_allocation(self, sb, tab3)
	}
	for sb := int64(self.Bound); sb < sblimit; sb++ {
		self.Allocation[0][sb] = func() *plm_quantizer_spec_t {
			p := &self.Allocation[1][sb]
			self.Allocation[1][sb] = plm_audio_read_allocation(self, sb, tab3)
			return *p
		}()
	}
	var channels int64
	if self.Mode == plm_audio_mode_mono {
		channels = 1
	} else {
		channels = 2
	}
	for sb := int64(0); sb < sblimit; sb++ {
		for ch := int64(0); ch < channels; ch++ {
			if self.Allocation[ch][sb] != nil {
				self.Scale_factor_info[ch][sb] = uint8(int8(plm_buffer_read(self.Buffer, 2)))
			}
		}
		if self.Mode == plm_audio_mode_mono {
			self.Scale_factor_info[1][sb] = self.Scale_factor_info[0][sb]
		}
	}
	for sb := int64(0); sb < sblimit; sb++ {
		for ch := int64(0); ch < channels; ch++ {
			if self.Allocation[ch][sb] != nil {
				var sf *int64 = &self.Scale_factor[ch][sb][0]
				switch self.Scale_factor_info[ch][sb] {
				case 0:
					*(*int64)(unsafe.Add(unsafe.Pointer(sf), unsafe.Sizeof(int64(0))*0)) = plm_buffer_read(self.Buffer, 6)
					*(*int64)(unsafe.Add(unsafe.Pointer(sf), unsafe.Sizeof(int64(0))*1)) = plm_buffer_read(self.Buffer, 6)
					*(*int64)(unsafe.Add(unsafe.Pointer(sf), unsafe.Sizeof(int64(0))*2)) = plm_buffer_read(self.Buffer, 6)
				case 1:
					*(*int64)(unsafe.Add(unsafe.Pointer(sf), unsafe.Sizeof(int64(0))*0)) = func() int64 {
						p := (*int64)(unsafe.Add(unsafe.Pointer(sf), unsafe.Sizeof(int64(0))*1))
						*(*int64)(unsafe.Add(unsafe.Pointer(sf), unsafe.Sizeof(int64(0))*1)) = plm_buffer_read(self.Buffer, 6)
						return *p
					}()
					*(*int64)(unsafe.Add(unsafe.Pointer(sf), unsafe.Sizeof(int64(0))*2)) = plm_buffer_read(self.Buffer, 6)
				case 2:
					*(*int64)(unsafe.Add(unsafe.Pointer(sf), unsafe.Sizeof(int64(0))*0)) = func() int64 {
						p := (*int64)(unsafe.Add(unsafe.Pointer(sf), unsafe.Sizeof(int64(0))*1))
						*(*int64)(unsafe.Add(unsafe.Pointer(sf), unsafe.Sizeof(int64(0))*1)) = func() int64 {
							p := (*int64)(unsafe.Add(unsafe.Pointer(sf), unsafe.Sizeof(int64(0))*2))
							*(*int64)(unsafe.Add(unsafe.Pointer(sf), unsafe.Sizeof(int64(0))*2)) = plm_buffer_read(self.Buffer, 6)
							return *p
						}()
						return *p
					}()
				case 3:
					*(*int64)(unsafe.Add(unsafe.Pointer(sf), unsafe.Sizeof(int64(0))*0)) = plm_buffer_read(self.Buffer, 6)
					*(*int64)(unsafe.Add(unsafe.Pointer(sf), unsafe.Sizeof(int64(0))*1)) = func() int64 {
						p := (*int64)(unsafe.Add(unsafe.Pointer(sf), unsafe.Sizeof(int64(0))*2))
						*(*int64)(unsafe.Add(unsafe.Pointer(sf), unsafe.Sizeof(int64(0))*2)) = plm_buffer_read(self.Buffer, 6)
						return *p
					}()
				}
			}
		}
		if self.Mode == plm_audio_mode_mono {
			self.Scale_factor[1][sb][0] = self.Scale_factor[0][sb][0]
			self.Scale_factor[1][sb][1] = self.Scale_factor[0][sb][1]
			self.Scale_factor[1][sb][2] = self.Scale_factor[0][sb][2]
		}
	}
	var out_pos int64 = 0
	for part := int64(0); part < 3; part++ {
		for granule := int64(0); granule < 4; granule++ {
			for sb := int64(0); sb < self.Bound; sb++ {
				plm_audio_read_samples(self, 0, sb, part)
				plm_audio_read_samples(self, 1, sb, part)
			}
			for sb := int64(self.Bound); sb < sblimit; sb++ {
				plm_audio_read_samples(self, 0, sb, part)
				self.Sample[1][sb][0] = self.Sample[0][sb][0]
				self.Sample[1][sb][1] = self.Sample[0][sb][1]
				self.Sample[1][sb][2] = self.Sample[0][sb][2]
			}
			for sb := int64(sblimit); sb < 32; sb++ {
				self.Sample[0][sb][0] = 0
				self.Sample[0][sb][1] = 0
				self.Sample[0][sb][2] = 0
				self.Sample[1][sb][0] = 0
				self.Sample[1][sb][1] = 0
				self.Sample[1][sb][2] = 0
			}
			for p := int64(0); p < 3; p++ {
				self.V_pos = (self.V_pos - 64) & 1023
				for ch := int64(0); ch < 2; ch++ {
					plm_audio_idct36(self.Sample[ch], p, &self.V[ch][0], self.V_pos)
					*(*[32]float32)(unsafe.Pointer(&self.U[0])) = [32]float32{}
					var d_index int64 = 512 - (self.V_pos >> 1)
					var v_index int64 = (self.V_pos % 128) >> 1
					for v_index < 1024 {
						for i := int64(0); i < 32; i++ {
							self.U[i] += self.D[func() int64 {
								p := &d_index
								x := *p
								*p++
								return x
							}()] * self.V[ch][func() int64 {
								p := &v_index
								x := *p
								*p++
								return x
							}()]
						}
						v_index += 128 - 32
						d_index += 64 - 32
					}
					d_index -= 512 - 32
					v_index = (128 - 32 + 1024) - v_index
					for v_index < 1024 {
						for i := int64(0); i < 32; i++ {
							self.U[i] += self.D[func() int64 {
								p := &d_index
								x := *p
								*p++
								return x
							}()] * self.V[ch][func() int64 {
								p := &v_index
								x := *p
								*p++
								return x
							}()]
						}
						v_index += 128 - 32
						d_index += 64 - 32
					}
					for j := int64(0); j < 32; j++ {
						self.Samples.Interleaved[((out_pos+j)<<1)+ch] = float32(float64(self.U[j]) / 2.147418112e+09)
					}
				}
				out_pos += 32
			}
		}
	}
	plm_buffer_align(self.Buffer)
}
func plm_audio_read_allocation(self *plm_audio_t, sb int64, tab3 int64) *plm_quantizer_spec_t {
	var (
		tab4 int64 = int64(plm_audio_quant_lut_step_3[tab3][sb])
		qtab int64 = int64(plm_audio_quant_lut_step_4[tab4&15][plm_buffer_read(self.Buffer, tab4>>4)])
	)
	if qtab != 0 {
		return &plm_audio_quant_tab[qtab-1]
	}
	return nil
}
func plm_audio_read_samples(self *plm_audio_t, ch int64, sb int64, part int64) {
	var (
		q      *plm_quantizer_spec_t = self.Allocation[ch][sb]
		sf     int64                 = self.Scale_factor[ch][sb][part]
		sample *int64                = &self.Sample[ch][sb][0]
		val    int64                 = 0
	)
	if q == nil {
		*(*int64)(unsafe.Add(unsafe.Pointer(sample), unsafe.Sizeof(int64(0))*0)) = func() int64 {
			p := (*int64)(unsafe.Add(unsafe.Pointer(sample), unsafe.Sizeof(int64(0))*1))
			*(*int64)(unsafe.Add(unsafe.Pointer(sample), unsafe.Sizeof(int64(0))*1)) = func() int64 {
				p := (*int64)(unsafe.Add(unsafe.Pointer(sample), unsafe.Sizeof(int64(0))*2))
				*(*int64)(unsafe.Add(unsafe.Pointer(sample), unsafe.Sizeof(int64(0))*2)) = 0
				return *p
			}()
			return *p
		}()
		return
	}
	if sf == 63 {
		sf = 0
	} else {
		var shift int64 = (sf / 3) | 0
		sf = (plm_audio_scalefactor_base[sf%3] + ((1 << shift) >> 1)) >> shift
	}
	var adj int64 = int64(q.Levels)
	if int64(q.Group) != 0 {
		val = plm_buffer_read(self.Buffer, int64(q.Bits))
		*(*int64)(unsafe.Add(unsafe.Pointer(sample), unsafe.Sizeof(int64(0))*0)) = val % adj
		val /= adj
		*(*int64)(unsafe.Add(unsafe.Pointer(sample), unsafe.Sizeof(int64(0))*1)) = val % adj
		*(*int64)(unsafe.Add(unsafe.Pointer(sample), unsafe.Sizeof(int64(0))*2)) = val / adj
	} else {
		*(*int64)(unsafe.Add(unsafe.Pointer(sample), unsafe.Sizeof(int64(0))*0)) = plm_buffer_read(self.Buffer, int64(q.Bits))
		*(*int64)(unsafe.Add(unsafe.Pointer(sample), unsafe.Sizeof(int64(0))*1)) = plm_buffer_read(self.Buffer, int64(q.Bits))
		*(*int64)(unsafe.Add(unsafe.Pointer(sample), unsafe.Sizeof(int64(0))*2)) = plm_buffer_read(self.Buffer, int64(q.Bits))
	}
	var scale int64 = 0x10000 / (adj + 1)
	adj = ((adj + 1) >> 1) - 1
	val = (adj - *(*int64)(unsafe.Add(unsafe.Pointer(sample), unsafe.Sizeof(int64(0))*0))) * scale
	*(*int64)(unsafe.Add(unsafe.Pointer(sample), unsafe.Sizeof(int64(0))*0)) = (val*(sf>>12) + ((val*(sf&4095) + 2048) >> 12)) >> 12
	val = (adj - *(*int64)(unsafe.Add(unsafe.Pointer(sample), unsafe.Sizeof(int64(0))*1))) * scale
	*(*int64)(unsafe.Add(unsafe.Pointer(sample), unsafe.Sizeof(int64(0))*1)) = (val*(sf>>12) + ((val*(sf&4095) + 2048) >> 12)) >> 12
	val = (adj - *(*int64)(unsafe.Add(unsafe.Pointer(sample), unsafe.Sizeof(int64(0))*2))) * scale
	*(*int64)(unsafe.Add(unsafe.Pointer(sample), unsafe.Sizeof(int64(0))*2)) = (val*(sf>>12) + ((val*(sf&4095) + 2048) >> 12)) >> 12
}
func plm_audio_idct36(s [32][3]int64, ss int64, d *float32, dp int64) {
	var (
		t01 float32
		t02 float32
		t03 float32
		t04 float32
		t05 float32
		t06 float32
		t07 float32
		t08 float32
		t09 float32
		t10 float32
		t11 float32
		t12 float32
		t13 float32
		t14 float32
		t15 float32
		t16 float32
		t17 float32
		t18 float32
		t19 float32
		t20 float32
		t21 float32
		t22 float32
		t23 float32
		t24 float32
		t25 float32
		t26 float32
		t27 float32
		t28 float32
		t29 float32
		t30 float32
		t31 float32
		t32 float32
		t33 float32
	)
	t01 = float32(s[0][ss] + s[31][ss])
	t02 = float32(float64(float32(s[0][ss]-s[31][ss])) * 0.500602998235)
	t03 = float32(s[1][ss] + s[30][ss])
	t04 = float32(float64(float32(s[1][ss]-s[30][ss])) * 0.505470959898)
	t05 = float32(s[2][ss] + s[29][ss])
	t06 = float32(float64(float32(s[2][ss]-s[29][ss])) * 0.515447309923)
	t07 = float32(s[3][ss] + s[28][ss])
	t08 = float32(float64(float32(s[3][ss]-s[28][ss])) * 0.53104259109)
	t09 = float32(s[4][ss] + s[27][ss])
	t10 = float32(float64(float32(s[4][ss]-s[27][ss])) * 0.553103896034)
	t11 = float32(s[5][ss] + s[26][ss])
	t12 = float32(float64(float32(s[5][ss]-s[26][ss])) * 0.582934968206)
	t13 = float32(s[6][ss] + s[25][ss])
	t14 = float32(float64(float32(s[6][ss]-s[25][ss])) * 0.622504123036)
	t15 = float32(s[7][ss] + s[24][ss])
	t16 = float32(float64(float32(s[7][ss]-s[24][ss])) * 0.674808341455)
	t17 = float32(s[8][ss] + s[23][ss])
	t18 = float32(float64(float32(s[8][ss]-s[23][ss])) * 0.744536271002)
	t19 = float32(s[9][ss] + s[22][ss])
	t20 = float32(float64(float32(s[9][ss]-s[22][ss])) * 0.839349645416)
	t21 = float32(s[10][ss] + s[21][ss])
	t22 = float32(float64(float32(s[10][ss]-s[21][ss])) * 0.972568237862)
	t23 = float32(s[11][ss] + s[20][ss])
	t24 = float32(float64(float32(s[11][ss]-s[20][ss])) * 1.16943993343)
	t25 = float32(s[12][ss] + s[19][ss])
	t26 = float32(float64(float32(s[12][ss]-s[19][ss])) * 1.48416461631)
	t27 = float32(s[13][ss] + s[18][ss])
	t28 = float32(float64(float32(s[13][ss]-s[18][ss])) * 2.05778100995)
	t29 = float32(s[14][ss] + s[17][ss])
	t30 = float32(float64(float32(s[14][ss]-s[17][ss])) * 3.40760841847)
	t31 = float32(s[15][ss] + s[16][ss])
	t32 = float32(float64(float32(s[15][ss]-s[16][ss])) * 10.1900081235)
	t33 = t01 + t31
	t31 = float32(float64(t01-t31) * 0.502419286188)
	t01 = t03 + t29
	t29 = float32(float64(t03-t29) * 0.52249861494)
	t03 = t05 + t27
	t27 = float32(float64(t05-t27) * 0.566944034816)
	t05 = t07 + t25
	t25 = float32(float64(t07-t25) * 0.64682178336)
	t07 = t09 + t23
	t23 = float32(float64(t09-t23) * 0.788154623451)
	t09 = t11 + t21
	t21 = float32(float64(t11-t21) * 1.06067768599)
	t11 = t13 + t19
	t19 = float32(float64(t13-t19) * 1.72244709824)
	t13 = t15 + t17
	t17 = float32(float64(t15-t17) * 5.10114861869)
	t15 = t33 + t13
	t13 = float32(float64(t33-t13) * 0.509795579104)
	t33 = t01 + t11
	t01 = float32(float64(t01-t11) * 0.601344886935)
	t11 = t03 + t09
	t09 = float32(float64(t03-t09) * 0.899976223136)
	t03 = t05 + t07
	t07 = float32(float64(t05-t07) * 2.56291544774)
	t05 = t15 + t03
	t15 = float32(float64(t15-t03) * 0.541196100146)
	t03 = t33 + t11
	t11 = float32(float64(t33-t11) * 1.30656296488)
	t33 = t05 + t03
	t05 = float32(float64(t05-t03) * 0.707106781187)
	t03 = t15 + t11
	t15 = float32(float64(t15-t11) * 0.707106781187)
	t03 += t15
	t11 = t13 + t07
	t13 = float32(float64(t13-t07) * 0.541196100146)
	t07 = t01 + t09
	t09 = float32(float64(t01-t09) * 1.30656296488)
	t01 = t11 + t07
	t07 = float32(float64(t11-t07) * 0.707106781187)
	t11 = t13 + t09
	t13 = float32(float64(t13-t09) * 0.707106781187)
	t11 += t13
	t01 += t11
	t11 += t07
	t07 += t13
	t09 = t31 + t17
	t31 = float32(float64(t31-t17) * 0.509795579104)
	t17 = t29 + t19
	t29 = float32(float64(t29-t19) * 0.601344886935)
	t19 = t27 + t21
	t21 = float32(float64(t27-t21) * 0.899976223136)
	t27 = t25 + t23
	t23 = float32(float64(t25-t23) * 2.56291544774)
	t25 = t09 + t27
	t09 = float32(float64(t09-t27) * 0.541196100146)
	t27 = t17 + t19
	t19 = float32(float64(t17-t19) * 1.30656296488)
	t17 = t25 + t27
	t27 = float32(float64(t25-t27) * 0.707106781187)
	t25 = t09 + t19
	t19 = float32(float64(t09-t19) * 0.707106781187)
	t25 += t19
	t09 = t31 + t23
	t31 = float32(float64(t31-t23) * 0.541196100146)
	t23 = t29 + t21
	t21 = float32(float64(t29-t21) * 1.30656296488)
	t29 = t09 + t23
	t23 = float32(float64(t09-t23) * 0.707106781187)
	t09 = t31 + t21
	t31 = float32(float64(t31-t21) * 0.707106781187)
	t09 += t31
	t29 += t09
	t09 += t23
	t23 += t31
	t17 += t29
	t29 += t25
	t25 += t09
	t09 += t27
	t27 += t23
	t23 += t19
	t19 += t31
	t21 = t02 + t32
	t02 = float32(float64(t02-t32) * 0.502419286188)
	t32 = t04 + t30
	t04 = float32(float64(t04-t30) * 0.52249861494)
	t30 = t06 + t28
	t28 = float32(float64(t06-t28) * 0.566944034816)
	t06 = t08 + t26
	t08 = float32(float64(t08-t26) * 0.64682178336)
	t26 = t10 + t24
	t10 = float32(float64(t10-t24) * 0.788154623451)
	t24 = t12 + t22
	t22 = float32(float64(t12-t22) * 1.06067768599)
	t12 = t14 + t20
	t20 = float32(float64(t14-t20) * 1.72244709824)
	t14 = t16 + t18
	t16 = float32(float64(t16-t18) * 5.10114861869)
	t18 = t21 + t14
	t14 = float32(float64(t21-t14) * 0.509795579104)
	t21 = t32 + t12
	t32 = float32(float64(t32-t12) * 0.601344886935)
	t12 = t30 + t24
	t24 = float32(float64(t30-t24) * 0.899976223136)
	t30 = t06 + t26
	t26 = float32(float64(t06-t26) * 2.56291544774)
	t06 = t18 + t30
	t18 = float32(float64(t18-t30) * 0.541196100146)
	t30 = t21 + t12
	t12 = float32(float64(t21-t12) * 1.30656296488)
	t21 = t06 + t30
	t30 = float32(float64(t06-t30) * 0.707106781187)
	t06 = t18 + t12
	t12 = float32(float64(t18-t12) * 0.707106781187)
	t06 += t12
	t18 = t14 + t26
	t26 = float32(float64(t14-t26) * 0.541196100146)
	t14 = t32 + t24
	t24 = float32(float64(t32-t24) * 1.30656296488)
	t32 = t18 + t14
	t14 = float32(float64(t18-t14) * 0.707106781187)
	t18 = t26 + t24
	t24 = float32(float64(t26-t24) * 0.707106781187)
	t18 += t24
	t32 += t18
	t18 += t14
	t26 = t14 + t24
	t14 = t02 + t16
	t02 = float32(float64(t02-t16) * 0.509795579104)
	t16 = t04 + t20
	t04 = float32(float64(t04-t20) * 0.601344886935)
	t20 = t28 + t22
	t22 = float32(float64(t28-t22) * 0.899976223136)
	t28 = t08 + t10
	t10 = float32(float64(t08-t10) * 2.56291544774)
	t08 = t14 + t28
	t14 = float32(float64(t14-t28) * 0.541196100146)
	t28 = t16 + t20
	t20 = float32(float64(t16-t20) * 1.30656296488)
	t16 = t08 + t28
	t28 = float32(float64(t08-t28) * 0.707106781187)
	t08 = t14 + t20
	t20 = float32(float64(t14-t20) * 0.707106781187)
	t08 += t20
	t14 = t02 + t10
	t02 = float32(float64(t02-t10) * 0.541196100146)
	t10 = t04 + t22
	t22 = float32(float64(t04-t22) * 1.30656296488)
	t04 = t14 + t10
	t10 = float32(float64(t14-t10) * 0.707106781187)
	t14 = t02 + t22
	t02 = float32(float64(t02-t22) * 0.707106781187)
	t14 += t02
	t04 += t14
	t14 += t10
	t10 += t02
	t16 += t04
	t04 += t08
	t08 += t14
	t14 += t28
	t28 += t10
	t10 += t20
	t20 += t02
	t21 += t16
	t16 += t32
	t32 += t04
	t04 += t06
	t06 += t08
	t08 += t18
	t18 += t14
	t14 += t30
	t30 += t28
	t28 += t26
	t26 += t10
	t10 += t12
	t12 += t20
	t20 += t24
	t24 += t02
	*(*float32)(unsafe.Add(unsafe.Pointer(d), unsafe.Sizeof(float32(0))*uintptr(dp+48))) = -t33
	*(*float32)(unsafe.Add(unsafe.Pointer(d), unsafe.Sizeof(float32(0))*uintptr(dp+49))) = func() float32 {
		p := (*float32)(unsafe.Add(unsafe.Pointer(d), unsafe.Sizeof(float32(0))*uintptr(dp+47)))
		*(*float32)(unsafe.Add(unsafe.Pointer(d), unsafe.Sizeof(float32(0))*uintptr(dp+47))) = -t21
		return *p
	}()
	*(*float32)(unsafe.Add(unsafe.Pointer(d), unsafe.Sizeof(float32(0))*uintptr(dp+50))) = func() float32 {
		p := (*float32)(unsafe.Add(unsafe.Pointer(d), unsafe.Sizeof(float32(0))*uintptr(dp+46)))
		*(*float32)(unsafe.Add(unsafe.Pointer(d), unsafe.Sizeof(float32(0))*uintptr(dp+46))) = -t17
		return *p
	}()
	*(*float32)(unsafe.Add(unsafe.Pointer(d), unsafe.Sizeof(float32(0))*uintptr(dp+51))) = func() float32 {
		p := (*float32)(unsafe.Add(unsafe.Pointer(d), unsafe.Sizeof(float32(0))*uintptr(dp+45)))
		*(*float32)(unsafe.Add(unsafe.Pointer(d), unsafe.Sizeof(float32(0))*uintptr(dp+45))) = -t16
		return *p
	}()
	*(*float32)(unsafe.Add(unsafe.Pointer(d), unsafe.Sizeof(float32(0))*uintptr(dp+52))) = func() float32 {
		p := (*float32)(unsafe.Add(unsafe.Pointer(d), unsafe.Sizeof(float32(0))*uintptr(dp+44)))
		*(*float32)(unsafe.Add(unsafe.Pointer(d), unsafe.Sizeof(float32(0))*uintptr(dp+44))) = -t01
		return *p
	}()
	*(*float32)(unsafe.Add(unsafe.Pointer(d), unsafe.Sizeof(float32(0))*uintptr(dp+53))) = func() float32 {
		p := (*float32)(unsafe.Add(unsafe.Pointer(d), unsafe.Sizeof(float32(0))*uintptr(dp+43)))
		*(*float32)(unsafe.Add(unsafe.Pointer(d), unsafe.Sizeof(float32(0))*uintptr(dp+43))) = -t32
		return *p
	}()
	*(*float32)(unsafe.Add(unsafe.Pointer(d), unsafe.Sizeof(float32(0))*uintptr(dp+54))) = func() float32 {
		p := (*float32)(unsafe.Add(unsafe.Pointer(d), unsafe.Sizeof(float32(0))*uintptr(dp+42)))
		*(*float32)(unsafe.Add(unsafe.Pointer(d), unsafe.Sizeof(float32(0))*uintptr(dp+42))) = -t29
		return *p
	}()
	*(*float32)(unsafe.Add(unsafe.Pointer(d), unsafe.Sizeof(float32(0))*uintptr(dp+55))) = func() float32 {
		p := (*float32)(unsafe.Add(unsafe.Pointer(d), unsafe.Sizeof(float32(0))*uintptr(dp+41)))
		*(*float32)(unsafe.Add(unsafe.Pointer(d), unsafe.Sizeof(float32(0))*uintptr(dp+41))) = -t04
		return *p
	}()
	*(*float32)(unsafe.Add(unsafe.Pointer(d), unsafe.Sizeof(float32(0))*uintptr(dp+56))) = func() float32 {
		p := (*float32)(unsafe.Add(unsafe.Pointer(d), unsafe.Sizeof(float32(0))*uintptr(dp+40)))
		*(*float32)(unsafe.Add(unsafe.Pointer(d), unsafe.Sizeof(float32(0))*uintptr(dp+40))) = -t03
		return *p
	}()
	*(*float32)(unsafe.Add(unsafe.Pointer(d), unsafe.Sizeof(float32(0))*uintptr(dp+57))) = func() float32 {
		p := (*float32)(unsafe.Add(unsafe.Pointer(d), unsafe.Sizeof(float32(0))*uintptr(dp+39)))
		*(*float32)(unsafe.Add(unsafe.Pointer(d), unsafe.Sizeof(float32(0))*uintptr(dp+39))) = -t06
		return *p
	}()
	*(*float32)(unsafe.Add(unsafe.Pointer(d), unsafe.Sizeof(float32(0))*uintptr(dp+58))) = func() float32 {
		p := (*float32)(unsafe.Add(unsafe.Pointer(d), unsafe.Sizeof(float32(0))*uintptr(dp+38)))
		*(*float32)(unsafe.Add(unsafe.Pointer(d), unsafe.Sizeof(float32(0))*uintptr(dp+38))) = -t25
		return *p
	}()
	*(*float32)(unsafe.Add(unsafe.Pointer(d), unsafe.Sizeof(float32(0))*uintptr(dp+59))) = func() float32 {
		p := (*float32)(unsafe.Add(unsafe.Pointer(d), unsafe.Sizeof(float32(0))*uintptr(dp+37)))
		*(*float32)(unsafe.Add(unsafe.Pointer(d), unsafe.Sizeof(float32(0))*uintptr(dp+37))) = -t08
		return *p
	}()
	*(*float32)(unsafe.Add(unsafe.Pointer(d), unsafe.Sizeof(float32(0))*uintptr(dp+60))) = func() float32 {
		p := (*float32)(unsafe.Add(unsafe.Pointer(d), unsafe.Sizeof(float32(0))*uintptr(dp+36)))
		*(*float32)(unsafe.Add(unsafe.Pointer(d), unsafe.Sizeof(float32(0))*uintptr(dp+36))) = -t11
		return *p
	}()
	*(*float32)(unsafe.Add(unsafe.Pointer(d), unsafe.Sizeof(float32(0))*uintptr(dp+61))) = func() float32 {
		p := (*float32)(unsafe.Add(unsafe.Pointer(d), unsafe.Sizeof(float32(0))*uintptr(dp+35)))
		*(*float32)(unsafe.Add(unsafe.Pointer(d), unsafe.Sizeof(float32(0))*uintptr(dp+35))) = -t18
		return *p
	}()
	*(*float32)(unsafe.Add(unsafe.Pointer(d), unsafe.Sizeof(float32(0))*uintptr(dp+62))) = func() float32 {
		p := (*float32)(unsafe.Add(unsafe.Pointer(d), unsafe.Sizeof(float32(0))*uintptr(dp+34)))
		*(*float32)(unsafe.Add(unsafe.Pointer(d), unsafe.Sizeof(float32(0))*uintptr(dp+34))) = -t09
		return *p
	}()
	*(*float32)(unsafe.Add(unsafe.Pointer(d), unsafe.Sizeof(float32(0))*uintptr(dp+63))) = func() float32 {
		p := (*float32)(unsafe.Add(unsafe.Pointer(d), unsafe.Sizeof(float32(0))*uintptr(dp+33)))
		*(*float32)(unsafe.Add(unsafe.Pointer(d), unsafe.Sizeof(float32(0))*uintptr(dp+33))) = -t14
		return *p
	}()
	*(*float32)(unsafe.Add(unsafe.Pointer(d), unsafe.Sizeof(float32(0))*uintptr(dp+32))) = -t05
	*(*float32)(unsafe.Add(unsafe.Pointer(d), unsafe.Sizeof(float32(0))*uintptr(dp+0))) = t05
	*(*float32)(unsafe.Add(unsafe.Pointer(d), unsafe.Sizeof(float32(0))*uintptr(dp+31))) = -t30
	*(*float32)(unsafe.Add(unsafe.Pointer(d), unsafe.Sizeof(float32(0))*uintptr(dp+1))) = t30
	*(*float32)(unsafe.Add(unsafe.Pointer(d), unsafe.Sizeof(float32(0))*uintptr(dp+30))) = -t27
	*(*float32)(unsafe.Add(unsafe.Pointer(d), unsafe.Sizeof(float32(0))*uintptr(dp+2))) = t27
	*(*float32)(unsafe.Add(unsafe.Pointer(d), unsafe.Sizeof(float32(0))*uintptr(dp+29))) = -t28
	*(*float32)(unsafe.Add(unsafe.Pointer(d), unsafe.Sizeof(float32(0))*uintptr(dp+3))) = t28
	*(*float32)(unsafe.Add(unsafe.Pointer(d), unsafe.Sizeof(float32(0))*uintptr(dp+28))) = -t07
	*(*float32)(unsafe.Add(unsafe.Pointer(d), unsafe.Sizeof(float32(0))*uintptr(dp+4))) = t07
	*(*float32)(unsafe.Add(unsafe.Pointer(d), unsafe.Sizeof(float32(0))*uintptr(dp+27))) = -t26
	*(*float32)(unsafe.Add(unsafe.Pointer(d), unsafe.Sizeof(float32(0))*uintptr(dp+5))) = t26
	*(*float32)(unsafe.Add(unsafe.Pointer(d), unsafe.Sizeof(float32(0))*uintptr(dp+26))) = -t23
	*(*float32)(unsafe.Add(unsafe.Pointer(d), unsafe.Sizeof(float32(0))*uintptr(dp+6))) = t23
	*(*float32)(unsafe.Add(unsafe.Pointer(d), unsafe.Sizeof(float32(0))*uintptr(dp+25))) = -t10
	*(*float32)(unsafe.Add(unsafe.Pointer(d), unsafe.Sizeof(float32(0))*uintptr(dp+7))) = t10
	*(*float32)(unsafe.Add(unsafe.Pointer(d), unsafe.Sizeof(float32(0))*uintptr(dp+24))) = -t15
	*(*float32)(unsafe.Add(unsafe.Pointer(d), unsafe.Sizeof(float32(0))*uintptr(dp+8))) = t15
	*(*float32)(unsafe.Add(unsafe.Pointer(d), unsafe.Sizeof(float32(0))*uintptr(dp+23))) = -t12
	*(*float32)(unsafe.Add(unsafe.Pointer(d), unsafe.Sizeof(float32(0))*uintptr(dp+9))) = t12
	*(*float32)(unsafe.Add(unsafe.Pointer(d), unsafe.Sizeof(float32(0))*uintptr(dp+22))) = -t19
	*(*float32)(unsafe.Add(unsafe.Pointer(d), unsafe.Sizeof(float32(0))*uintptr(dp+10))) = t19
	*(*float32)(unsafe.Add(unsafe.Pointer(d), unsafe.Sizeof(float32(0))*uintptr(dp+21))) = -t20
	*(*float32)(unsafe.Add(unsafe.Pointer(d), unsafe.Sizeof(float32(0))*uintptr(dp+11))) = t20
	*(*float32)(unsafe.Add(unsafe.Pointer(d), unsafe.Sizeof(float32(0))*uintptr(dp+20))) = -t13
	*(*float32)(unsafe.Add(unsafe.Pointer(d), unsafe.Sizeof(float32(0))*uintptr(dp+12))) = t13
	*(*float32)(unsafe.Add(unsafe.Pointer(d), unsafe.Sizeof(float32(0))*uintptr(dp+19))) = -t24
	*(*float32)(unsafe.Add(unsafe.Pointer(d), unsafe.Sizeof(float32(0))*uintptr(dp+13))) = t24
	*(*float32)(unsafe.Add(unsafe.Pointer(d), unsafe.Sizeof(float32(0))*uintptr(dp+18))) = -t31
	*(*float32)(unsafe.Add(unsafe.Pointer(d), unsafe.Sizeof(float32(0))*uintptr(dp+14))) = t31
	*(*float32)(unsafe.Add(unsafe.Pointer(d), unsafe.Sizeof(float32(0))*uintptr(dp+17))) = -t02
	*(*float32)(unsafe.Add(unsafe.Pointer(d), unsafe.Sizeof(float32(0))*uintptr(dp+15))) = t02
	*(*float32)(unsafe.Add(unsafe.Pointer(d), unsafe.Sizeof(float32(0))*uintptr(dp+16))) = 0.0
}