Struct ExtendedCue 

pub struct ExtendedCue {
    pub header: Header,
    pub hot_cue: u32,
    pub cue_type: CueType,
    pub time: u32,
    pub loop_time: u32,
    pub color: ColorIndex,
    pub loop_numerator: u16,
    pub loop_denominator: u16,
    pub comment: LenPrefixedWideString,
    pub hot_cue_color_index: u8,
    pub hot_cue_color_rgb: (u8, u8, u8),
    pub trailing: Vec<u8>,
    /* private fields */
}

A memory or hot cue (or loop).

Fields

header: Header

Cue entry header.

hot_cue: u32

Hot cue number.

Value	Hot cue
0	Not a hot cue.
1	A
2	B
…	…

cue_type: CueType

Type of this cue (2 if this cue is a loop).

time: u32

Time in milliseconds after which this cue would occur (at normal playback speed).

loop_time: u32

Time in milliseconds after which this the loop would jump back to time (at normal playback speed).

color: ColorIndex

Color assigned to this cue.

Only used by memory cues, hot cues use a different value (see below).

loop_numerator: u16

Represents the loop size numerator (if this is a quantized loop).

loop_denominator: u16

Represents the loop size denominator (if this is a quantized loop).

comment: LenPrefixedWideString

An UTF-16BE encoded string with a leading u32 length prefix and a trailing NUL (0x0000).

hot_cue_color_index: u8

Rekordbox hotcue color index.

Value	Color
0x00	None (Green on older CDJs).
0x01	#305aff
0x02	#5073ff
0x03	#508cff
0x04	#50a0ff
0x05	#50b4ff
0x06	#50b0f2
0x07	#50aee8
0x08	#45acdb
0x09	#00e0ff
0x0a	#19daf0
0x0b	#32d2e6
0x0c	#21b4b9
0x0d	#20aaa0
0x0e	#1fa392
0x0f	#19a08c
0x10	#14a584
0x11	#14aa7d
0x12	#10b176
0x13	#30d26e
0x14	#37de5a
0x15	#3ceb50
0x16	#28e214
0x17	#7dc13d
0x18	#8cc832
0x19	#9bd723
0x1a	#a5e116
0x1b	#a5dc0a
0x1c	#aad208
0x1d	#b4c805
0x1e	#b4be04
0x1f	#bab404
0x20	#c3af04
0x21	#e1aa00
0x22	#ffa000
0x23	#ff9600
0x24	#ff8c00
0x25	#ff7500
0x26	#e0641b
0x27	#e0461e
0x28	#e0301e
0x29	#e02823
0x2a	#e62828
0x2b	#ff376f
0x2c	#ff2d6f
0x2d	#ff127b
0x2e	#f51e8c
0x2f	#eb2da0
0x30	#e637b4
0x31	#de44cf
0x32	#de448d
0x33	#e630b4
0x34	#e619dc
0x35	#e600ff
0x36	#dc00ff
0x37	#cc00ff
0x38	#b432ff
0x39	#b93cff
0x3a	#c542ff
0x3b	#aa5aff
0x3c	#aa72ff
0x3d	#8272ff
0x3e	#6473ff

hot_cue_color_rgb: (u8, u8, u8)

Rekordbox hot cue color RGB value.

This color is similar but not identical to the color that Rekordbox displays, and possibly used to illuminate the RGB LEDs in a player that has loaded the cue. If not color is associated with this hot cue, the value is (0, 0, 0).

trailing: Vec<u8>

Trailing unknown bytes after unknown10 to the end of the entry.

Per the Kaitai spec, the entry may contain extra data beyond the known fields; any remaining bytes are captured here.

Trait Implementations

impl BinRead for ExtendedCue

type Args<'__binrw_generated_args_lifetime> = ()

The type used for the args parameter of read_args() and read_options().

fn read_options<R: Read + Seek>( __binrw_generated_var_reader: &mut R, __binrw_generated_var_endian: Endian, __binrw_generated_var_arguments: Self::Args<'_>, ) -> BinResult<Self>

Read Self from the reader using the given [Endian] and arguments.

fn read<R>(reader: &mut R) -> Result<Self, Error>

where R: Read + Seek, Self: ReadEndian, Self::Args<'a>: for<'a> Required,

Read Self from the reader using default arguments.

fn read_be<R>(reader: &mut R) -> Result<Self, Error>

where R: Read + Seek, Self::Args<'a>: for<'a> Required,

Read Self from the reader using default arguments and assuming big-endian byte order.

fn read_le<R>(reader: &mut R) -> Result<Self, Error>

where R: Read + Seek, Self::Args<'a>: for<'a> Required,

Read Self from the reader using default arguments and assuming little-endian byte order.

fn read_ne<R>(reader: &mut R) -> Result<Self, Error>

where R: Read + Seek, Self::Args<'a>: for<'a> Required,

Read T from the reader assuming native-endian byte order.

fn read_args<R>(reader: &mut R, args: Self::Args<'_>) -> Result<Self, Error>

where R: Read + Seek, Self: ReadEndian,

Read Self from the reader using the given arguments.

fn read_be_args<R>(reader: &mut R, args: Self::Args<'_>) -> Result<Self, Error>

where R: Read + Seek,

Read Self from the reader, assuming big-endian byte order, using the given arguments.

fn read_le_args<R>(reader: &mut R, args: Self::Args<'_>) -> Result<Self, Error>

where R: Read + Seek,

Read Self from the reader, assuming little-endian byte order, using the given arguments.

fn read_ne_args<R>(reader: &mut R, args: Self::Args<'_>) -> Result<Self, Error>

where R: Read + Seek,

Read T from the reader, assuming native-endian byte order, using the given arguments.

impl BinWrite for ExtendedCue

type Args<'__binrw_generated_args_lifetime> = ()

The type used for the args parameter of write_args() and write_options().

fn write_options<W: Write + Seek>( &self, __binrw_generated_var_writer: &mut W, __binrw_generated_var_endian: Endian, __binrw_generated_var_arguments: Self::Args<'_>, ) -> BinResult<()>

Write Self to the writer using the given [Endian] and arguments.

fn write<W>(&self, writer: &mut W) -> Result<(), Error>

where W: Write + Seek, Self: WriteEndian, Self::Args<'a>: for<'a> Required,

Write Self to the writer using default arguments.

fn write_be<W>(&self, writer: &mut W) -> Result<(), Error>

where W: Write + Seek, Self::Args<'a>: for<'a> Required,

Write Self to the writer assuming big-endian byte order.

fn write_le<W>(&self, writer: &mut W) -> Result<(), Error>

where W: Write + Seek, Self::Args<'a>: for<'a> Required,

Write Self to the writer assuming little-endian byte order.

fn write_ne<W>(&self, writer: &mut W) -> Result<(), Error>

where W: Write + Seek, Self::Args<'a>: for<'a> Required,

Write Self to the writer assuming native-endian byte order.

fn write_args<W>( &self, writer: &mut W, args: Self::Args<'_>, ) -> Result<(), Error>

where W: Write + Seek, Self: WriteEndian,

Write Self to the writer using the given arguments.

fn write_be_args<W>( &self, writer: &mut W, args: Self::Args<'_>, ) -> Result<(), Error>

where W: Write + Seek,

Write Self to the writer, assuming big-endian byte order, using the given arguments.

fn write_le_args<W>( &self, writer: &mut W, args: Self::Args<'_>, ) -> Result<(), Error>

where W: Write + Seek,

Write Self to the writer, assuming little-endian byte order, using the given arguments.

fn write_ne_args<W>( &self, writer: &mut W, args: Self::Args<'_>, ) -> Result<(), Error>

where W: Write + Seek,

Write Self to the writer, assuming native-endian byte order, using the given arguments.

impl Debug for ExtendedCue

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Eq for ExtendedCue

impl PartialEq for ExtendedCue

fn eq(&self, other: &ExtendedCue) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl ReadEndian for ExtendedCue

const ENDIAN: EndianKind

The endianness of the type.

impl Serialize for ExtendedCue

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for ExtendedCue

impl WriteEndian for ExtendedCue

const ENDIAN: EndianKind

The endianness of the type.