object_data_segment.go

package dvb

import (
	"encoding/binary"
	"errors"
	"fmt"
)

const (
	ObjectCodingMethodCodingOfPixels            = uint8(0x0)
	ObjectCodingMethodCharacters                = uint8(0x1)
	ObjectCodingMethodProgressiveCodingOfPixels = uint8(0x2)
	// 0x3 - reserved
)

// object data segment; the object data segment carries information on a specific subtitle object. Objects that
// occur more than once within a region need only be transmitted once, and then positioned multiple times within
// the region. Objects used in more than one subtitle service need only be transmitted once. There are three types
// of object:
// -A graphical object in interlaced format that contains run-length encoded bitmap colours.
// -A graphical object in progressive format, whose sequence of filtered scanlines is compressed using
// zlib [14], which in turn applies DEFLATE compression [15], as defined in the PNG [16] graphics format.
// -A text object that carries a string of character codes. Usage of the text object is not defined in the present
// document.
type ObjectDataSegment struct {
	// This field shall contain the value '0000 1111'.
	SyncByte uint8

	// This field shall contain the value 0x13, as listed in table 7.
	SegmentType uint8

	// The page_id identifies the subtitle service of the data contained in this subtitling_segment. Segments with a
	// page_id value signalled in the subtitling descriptor as the composition page id, carry subtitling data specific for one
	// subtitle service. Accordingly, segments with the page_id signalled in the subtitling descriptor as the ancillary page id,
	// carry data that may be shared by multiple subtitle services.
	PageID uint16 // LE

	// This field shall indicate the number of bytes contained in the segment following the segment_length
	// field.
	SegmentLength uint16 // BE

	// Uniquely identifies within the page the object for which data is contained in this object_data_segment field
	ObjectID uint16

	// ndicates the version of this segment data. When any of the contents of this segment change,
	// this version number is incremented
	ObjectVersionNumber uint8 // 4 bits

	// Specifies the method used to code the object, as defined in table 18
	ObjectCodingMethod uint8 // 2 bits

	// If set to '1' this indicates that the CLUT entry value '1' is a non modifying colour. When
	// the non modifying colour is assigned to an object pixel, then the pixel of the underlying region background or object
	// shall not be modified. This can be used to create "transparent holes" in objects.
	NonModifyingColourFlag bool // 1 bit

	// Reserved uint8 // 1 bit

	Pixels ObjectDataSegmentPixels

	CharacterCodes ObjectDataSegmentCharacterCodes

	ProgressivePixels ObjectDataSegmentProgressivePixelBlock
}

type ObjectDataSegmentPixels struct {
	// Specifies the number of bytes contained in the pixel-data_sub-blocks for the top field
	TopFieldDataBlockLength uint16 // BE

	// Specifies the number of bytes contained in the data_sub-block for the bottom field
	ButtomFieldDataBlockLength uint16 // BE

	PixelDataSubBlocks []PixelDataSubBlock
}

func (p ObjectDataSegmentPixels) Marshal() ([]byte, error) {
	return nil, ErrNotImplemented
}

func (p *ObjectDataSegmentPixels) Unmarshal(buf []byte) error {
	return ErrNotImplemented
}

func (s ObjectDataSegment) Marshal() ([]byte, error) {
	if s.SyncByte != segmentSyncByte {
		return nil, ErrIncorrectSyncByte
	}

	if s.SegmentType != SegmentTypeObjectData {
		return nil, ErrIncorrectSegmentType
	}

	if s.SegmentLength < 3 {
		return nil, ErrIncorrectSegmentLength
	}

	buf := make([]uint8, segmentHeaderSize+3)
	buf[0] = s.SyncByte
	buf[1] = s.SegmentType
	binary.LittleEndian.PutUint16(buf[2:4], s.PageID)
	binary.BigEndian.PutUint16(buf[4:6], s.SegmentLength)
	binary.LittleEndian.PutUint16(buf[6:8], s.ObjectID)
	buf[8] = s.ObjectVersionNumber<<4 | s.ObjectCodingMethod<<2 | bool2byte(s.NonModifyingColourFlag)<<1

	switch s.ObjectCodingMethod {
	case ObjectCodingMethodCodingOfPixels:
		return buf, ErrNotImplemented

	case ObjectCodingMethodCharacters:
		ccBuf, err := s.CharacterCodes.Marshal()
		if err != nil {
			return buf, err
		}
		// nolint makezero
		return append(buf, ccBuf...), nil

	case ObjectCodingMethodProgressiveCodingOfPixels:
		ppBuf, err := s.ProgressivePixels.Marshal()
		if err != nil {
			return buf, err
		}
		// nolint makezero
		return append(buf, ppBuf...), nil

	default:
		return buf, fmt.Errorf("unknown object coding method")
	}
}

// Unmarshal bytes to ObjectDataSegment
// TODO handle errors; check segmentLength
func (s *ObjectDataSegment) Unmarshal(buf []byte) error {
	if buf == nil {
		return ErrNilBuffer
	}

	if len(buf) < 9 {
		return ErrShortBuffer
	}

	s.SyncByte = buf[0]
	s.SegmentType = buf[1]
	s.PageID = binary.LittleEndian.Uint16(buf[2:4])
	s.SegmentLength = binary.BigEndian.Uint16(buf[4:6])

	if s.SyncByte != segmentSyncByte {
		return ErrIncorrectSyncByte
	}

	if s.SegmentType != SegmentTypeObjectData {
		return ErrIncorrectSegmentType
	}

	if s.SegmentLength < 3 {
		return ErrIncorrectSegmentLength
	}

	s.ObjectID = binary.LittleEndian.Uint16(buf[6:8])
	s.ObjectVersionNumber = (buf[8] & 0b1111_0000) >> 4
	s.ObjectCodingMethod = (buf[8] & 0b0000_1100) >> 2
	s.NonModifyingColourFlag = byte2bool((buf[8] & 0b0000_0010) >> 1)

	switch s.ObjectCodingMethod {
	case ObjectCodingMethodCodingOfPixels:
		return ErrNotImplemented

	case ObjectCodingMethodCharacters:
		if len(buf) < 10 {
			return fmt.Errorf("failed to parse object data segment with character codes: %w", ErrShortBuffer)
		}
		cc := ObjectDataSegmentCharacterCodes{}
		if err := cc.Unmarshal(buf[9:]); err != nil {
			return err
		}
		s.CharacterCodes = cc
		return nil

	case ObjectCodingMethodProgressiveCodingOfPixels:
		ppBlock := ObjectDataSegmentProgressivePixelBlock{}
		if err := ppBlock.Unmarshal(buf[9:]); err != nil {
			return fmt.Errorf("failed to parse progressive pixel block: %w", err)
		}
		s.ProgressivePixels = ppBlock
		return nil

	default:
		return errors.New("unknown object coding method")
	}
}

const (
	// table 22
	PixelDataSubBlockDataType2BitsPerPixelCodeString = 0x10
	PixelDataSubBlockDataType4BitsPerPixelCodeString = 0x11
	PixelDataSubBlockDataType8BitsPerPixelCodeString = 0x12

	// Specifies how to map the 2-bit/pixel codes on a 4-bit/entry CLUT by listing the 4 entry
	// numbers of 4-bits each; entry number 0 first, entry number 3 last
	PixelDataSubBlockDataType2To4BitMapTableData = 0x20
	PixelDataSubBlockDataType2To8BitMapTableData = 0x21
	PixelDataSubBlockDataType4To8BitMapTableData = 0x22
	PixelDataSubBlockDataTypeEndOfObjectLineCode = 0xF0

	// all other values are reserved
)

type PixelDataSubBlock struct {
	// Identifies the type of information contained in the pixel-data_sub-block according to table 21.
	DataType uint8
	Data     []byte
}

// Size returns size in bytes
func (b PixelDataSubBlock) Size() int {
	return 1 + len(b.Data)
}

// TODO:
func (b PixelDataSubBlock) Marshal() ([]byte, error) {
	return []byte{}, ErrNotImplemented
}

// TODO:
func (b *PixelDataSubBlock) Unmarshal(buf []byte) error {
	iterator := newBytesIterator(buf)
	if iterator.Len() == 0 {
		return ErrShortBuffer
	}
	dataType, err := iterator.NextByte()
	if err != nil {
		return err
	}
	switch dataType {
	case PixelDataSubBlockDataType2BitsPerPixelCodeString:
	case PixelDataSubBlockDataType4BitsPerPixelCodeString:
	case PixelDataSubBlockDataType8BitsPerPixelCodeString:
	case PixelDataSubBlockDataType2To4BitMapTableData:
	case PixelDataSubBlockDataType2To8BitMapTableData:
	case PixelDataSubBlockDataType4To8BitMapTableData:
	case PixelDataSubBlockDataTypeEndOfObjectLineCode:
	default:
		return fmt.Errorf("unknown data_type of pixel data sub block %x", dataType)
	}
	return nil
}

// CharacterCodes is a slice of UTF-16 symbols
type CharacterCodes []uint16

// NumberOfCodes returns symbols count
func (cc CharacterCodes) NumberOfCodes() int { return len(cc) }

// Size returns size in bytes of character codes
func (cc CharacterCodes) Size() int { return len(cc) * 2 }

// String returns printable string
func (cc CharacterCodes) String() string { return string(sliceU16toU8LE(cc)) }

// Bytes returns CharacterCodes as a slice of bytes
func (cc CharacterCodes) Bytes() []byte { return sliceU16toU8LE(cc) }

type ObjectDataSegmentCharacterCodes struct {
	// Specifies the number of character codes in the string
	NumberOfCodes uint8

	// Specifies a character through its index number in a character table, the definition of which is not
	// included in the present document. The specification and provision of such a character code table is part of the local
	// agreement between the subtitle service provider and IRD manufacturer that is needed to put this mode of subtitles into
	// operation
	CharacterCodes CharacterCodes
}

func (c ObjectDataSegmentCharacterCodes) Marshal() ([]byte, error) {
	sz := 1 + int(c.NumberOfCodes)*2
	buf := make([]byte, sz)
	buf[0] = c.NumberOfCodes
	copy(buf[1:sz-1], sliceU16toU8LE(c.CharacterCodes))
	return buf, nil
}

func (c *ObjectDataSegmentCharacterCodes) Unmarshal(buf []byte) error {
	if buf == nil {
		return ErrNilBuffer
	}
	if len(buf) < 1 {
		return ErrShortBuffer
	}
	c.NumberOfCodes = buf[0]
	if len(buf) < 1+int(c.NumberOfCodes)*2 {
		return fmt.Errorf("failed to parse object data segment character codes: %w", ErrShortBuffer)
	}
	c.CharacterCodes = sliceU8toU16LE(buf[1 : 1+int(c.NumberOfCodes)*2])
	return nil
}

type ObjectDataSegmentProgressivePixelBlock struct {
	// This field shall indicate the width of the subtitle bitmap image in pixels
	BitmapWidth uint16 // BE

	// This field shall indicate the height of the subtitle bitmap image in pixels
	BitmapHeight uint16 // BE

	// This field shall indicate the number of compressed_bitmap_data_byte following this
	// field.
	CompressedDataBlockLength uint16 // BE

	// This field is formed of the sequence of bytes of the subtitle bitmap image in
	// compressed form, which is according to the zlib container format [14], in the same way as is specified for the Portable
	// Network Graphics (PNG) format [16]. This format applies the DEFLATE compression algorithm [15]. The compressed
	// bitmap data shall consist of the raw zlib datastream and shall not contain any PNG format overhead such as chunk
	// headers or chunk CRC values.
	CompressedBitmapDataByte []uint8
}

func (p ObjectDataSegmentProgressivePixelBlock) Marshal() ([]byte, error) {
	if len(p.CompressedBitmapDataByte) != int(p.CompressedDataBlockLength) {
		return nil, fmt.Errorf("compressed bitmap data length %d does not match declared length %d", len(p.CompressedBitmapDataByte), p.CompressedDataBlockLength)
	}
	buf := make([]byte, 6)
	binary.BigEndian.PutUint16(buf[0:2], p.BitmapWidth)
	binary.BigEndian.PutUint16(buf[2:4], p.BitmapHeight)
	binary.BigEndian.PutUint16(buf[4:6], p.CompressedDataBlockLength)
	// nolint makezero
	return append(buf, p.CompressedBitmapDataByte...), nil
}

func (p *ObjectDataSegmentProgressivePixelBlock) Unmarshal(buf []byte) error {
	if buf == nil {
		return ErrNilBuffer
	}
	if len(buf) < 6 {
		return ErrShortBuffer
	}
	p.BitmapWidth = binary.BigEndian.Uint16(buf[0:2])
	p.BitmapHeight = binary.BigEndian.Uint16(buf[2:4])
	p.CompressedDataBlockLength = binary.BigEndian.Uint16(buf[4:6])
	if len(buf) < 6+int(p.CompressedDataBlockLength) {
		return fmt.Errorf("failed to parse object data segment progressive pixel block: %w", ErrShortBuffer)
	}
	p.CompressedBitmapDataByte = buf[6 : 6+int(p.CompressedDataBlockLength)]
	if len(p.CompressedBitmapDataByte) != int(p.CompressedDataBlockLength) {
		return fmt.Errorf("compressed bitmap data length %d does not match declared length %d", len(p.CompressedBitmapDataByte), p.CompressedDataBlockLength)
	}
	return nil
}