Разработка кроссплатформенного порта D-Series

timeline_update_event_state_by_seqnum(t.sequence_number(), TSTATE::PROGRESSING, requests);

TSTATE::STATUS status;

requests.unlock();

if (!check_codec_is_active__ ()

&& (t.type () == TEVENT::PLAYOUT)

&& !check_preset_is_set__ ()) {

// The timeline is active, but the Preset slot on the device is empty.

// In this case it is assumed that the device is not active (e.g. just after restoring of communication)

// The clip should be cued on the preset slot instead of preview.

logger.printf(LOGGER::filter_info, "(Active timeline) The codec is inactive, cueing timeline event to preset");

status = set_preset__ (&t);

} else {

status = set_preview__(&t);

}

requests.lock();

timeline_update_event_state_by_seqnum(t.sequence_number(), status, requests);

}

}

}

size_t n_to_deactivate = timeline_deactivated_length();

if (n_to_deactivate) {

logger.printf(LOGGER::filter_verbose, "(Active timeline) There are %d clips to deactivate", n_to_deactivate);

for (unsigned int i_pos = 0; i_pos < n_to_deactivate; ++i_pos) {

logger.printf(LOGGER::filter_verbose, "Deactivate clip %d, state %d", i_pos, timeline_deactivated_event_state(i_pos));

timeline_update_deactivated_event_state(i_pos, TSTATE::COMPLETE, requests);

}

}

}

if ((timeline_length() > 0)

&& (timeline_event_stage(0) == TSTATE::PREROLL)

&& (timeline_event_state(0) == TSTATE::PENDING))

{

const TEVENT t = timeline_event(0);

logger.printf(LOGGER::filter_verbose, "Start-at request");

timeline_update_event_state_by_seqnum(t.sequence_number(), TSTATE::PROGRESSING, requests);

STATE new_state;

TSTATE::STATUS status = TSTATE::FAILURE;

requests.unlock();

if (issue_timestamped_control__(t.type() == TEVENT::RECORD))

{

status = TSTATE::COMPLETE;

}

requests.lock();

timeline_update_event_state_by_seqnum(t.sequence_number(), status, requests);

}

}

if (manual_set_speed_control_request_is_pending()) {

SPEED_FACTOR speed_factor = next_manual_set_speed_control_request();

if (sense_state().speed() == speed_factor) {

logger.printf(LOGGER::filter_debug, "shuttle request ignored - speed is already %d", speed_factor);

} else {

if (speed_factor == 0) {

protocol__->stop();

} else if (speed_factor == 1000) {

protocol__->play();

} else {

requests.unlock();

// convert speed factor back to Odetics protocol

bool f_fwd = speed_factor > 0;

if (!f_fwd)

speed_factor = -speed_factor;

if (f_fwd)

protocol__->shuttle_forward(speed_factor);

else

protocol__->shuttle_reverse(speed_factor);

requests.lock();

}

start_fast_poll();

}

}

if (manual_advance_clip_control_request_is_pending()) {

TIMECODE_INTERVAL jog = next_manual_advance_clip_control_request();

int32_t frames = jog.frames() + ((jog.seconds() * 60 + jog.minutes()) * 60 + jog.hours()) * jog.nominal_framerate();

requests.unlock();

jog.is_negative() ? protocol__->jump_backward(2*frames) : protocol__->jump_forward(2*frames);

requests.lock();

start_fast_poll();

}

if (manual_timecode_control_request_is_pending()) {

SONYVTR_TIMECODE timecode = next_manual_timecode_control_request();

logger.printf(LOGGER::filter_debug, "go to timecode request %02d:%02d:%02d:%02d", timecode.hours(), timecode.minutes(), timecode.seconds(), timecode.frames());

requests.unlock();

protocol__->set_in_preset(timecode);

requests.lock();

}

}

logger.printf(LOGGER::filter_debug_verbose, "done handling channel %s", sense_name().c_str());

}

bool NEXIO::CODEC__::record__()

{

if (protocol_configuration__.f_start_at)

{

// Start-at functionality is enabled

return check_timestamped_control_done__(true);

}

else

{

// Start-at is disable, just send play request

return issue_record__();

}

}

bool NEXIO::CODEC__::issue_record__()

{

if (protocol__->record ())

{

preset_is_onair__ = true;

return true;

}

return false;

}

void NEXIO::CODEC__::issue_stop__()

{

preroll_requested__ = false;

reset_preset__ = false;

if (protocol__->eject())

preset_is_onair__ = false;

if (!check_stop_req_status__()) {

/* Ignored with a warning */}

}

void NEXIO::CODEC__::new_operation_pending()

{

kick_thread();

}

bool NEXIO::CODEC__::play__()

{

if (protocol_configuration__.f_start_at)

{

// Start-at functionality is enabled

return check_timestamped_control_done__(false);

}

else

{

// Start-at is disable, just send play request

if (!protocol__->play_next_cue())

return false;

return check_play_req_status__();

}

}

bool NEXIO::CODEC__::check_codec_is_active__()

{

DEVICE_STATUS_1 ds;

if (!protocol__->channel_status_sense (1, 1, reinterpret_cast<uint8_t *>(&ds)))

return false;

return (ds.v_rec || ds.v_play);

}

bool NEXIO::CODEC__::check_stop_req_status__()

{

size_t num_waits = 0;

do {

DEVICE_STATUS_1 ds;

// Recognize Eject complete by clearing of play and record state

if (!protocol__->channel_status_sense(1, 1, reinterpret_cast<uint8_t *>(&ds)))

return false;

if (ds.v_stop)

break;

sleep(WAIT_FOR_STOP_COMPLETE);

if (++num_waits > MAX_STOP_WAITS) {

logger.printf(LOGGER::filter_error, "Timed out waiting for stop request to complete");

return false;

}

} while (true);

return true;

}

bool NEXIO::CODEC__::check_timestamped_control_done__(bool issue_record)

{

if (preroll_requested__)

{

preroll_requested__ = false;

if (reset_preset__)

{

reset_preset__ = false;

// Incorrect material cued into PST.

// Switch to PVW (unset PST OUT and Play Next Cue)

logger.printf(LOGGER::filter_verbose, "Last seconds change: issuing switching to preview slot");

if (!protocol__->set_out_preset(SONYVTR_TIMECODE(0,0,0,0)))

{

logger.printf(LOGGER::filter_error, "Last seconds change: unable to switch to preview slot");

return false;

}

}

else if (!issue_record)

{

// Preroll is sent. Additional controls is not needed.

// Status of play request should be checked.

return check_play_req_status__();

}

else

{

// Preroll is sent. Additional controls is not needed.

return true;

}

}

return (issue_record ? issue_record__() : protocol__->play_next_cue());

}

void NEXIO::CODEC__::poll__()

{

uint8_t const POLL_FIRST_CHANNEL_STATUS_BYTE = 1;

uint8_t const POLL_NUM_CHANNEL_STATUS_BYTES = 3;

uint8_t ofs = POLL_FIRST_CHANNEL_STATUS_BYTE;

uint8_t status[POLL_NUM_CHANNEL_STATUS_BYTES];

typedef uint8_t __attribute__((__may_alias__)) uint8_t_a;

uint8_t_a *status_a = static_cast<uint8_t_a *>(status); // avoiding strict aliasing warning (see ds1 below)

uint8_t size = sizeof(status);

if (!protocol__->channel_status_sense(ofs, size, status))

return;

DEVICE_STATUS_1 ds1 = *reinterpret_cast<DEVICE_STATUS_1 *>(status_a+1-POLL_FIRST_CHANNEL_STATUS_BYTE);

DEVICE_STATUS_2 ds2 = *reinterpret_cast<DEVICE_STATUS_2 *>(status_a+2-POLL_FIRST_CHANNEL_STATUS_BYTE);

DEVICE_STATUS_3 ds3 = *reinterpret_cast<DEVICE_STATUS_3 *>(status_a+3-POLL_FIRST_CHANNEL_STATUS_BYTE);

STATE old_state = sense_state();

STATE new_state = old_state;

if (ds1.v_stop || ds2.v_still || !ds3.v_in_preset) {

new_state.action(STATE::IDLE);

new_state.speed(0);

} else if (ds1.v_rec) {

new_state.action(STATE::ENCODING);

new_state.speed(STATE::SPEED_FACTOR_DIVISOR);

}

else if (ds1.v_play) {

new_state.action(STATE::DECODING);

new_state.speed(STATE::SPEED_FACTOR_DIVISOR);

}

// I tried to find criteria which would allow the current timecode to be retrieved periodically,

// but things are too complicated by jog/shuttle - there is no way to tell that we are jogging.

SONYVTR_TIMECODE s_tc;

if (protocol__->get_current_time_sense(ODETICS_PROTOCOL::TC_LTC, &s_tc)) {

TIMECODE_POSITION tc(framerate__, s_tc.hours(), s_tc.minutes(), s_tc.seconds(), s_tc.frames());

new_state.timecode_position(tc);

}

if (ds2.v_jog || ds2.v_var || ds2.v_shuttle) {

SPEED_FACTOR speed_factor;

if (protocol__->get_speed_factor(&speed_factor))

new_state.speed(speed_factor);

}

bool f_update = new_state != old_state;

if (new_state.action() == STATE::IDLE || !f_update)

start_slow_poll();

if (f_update)

update_state(new_state);

}

/// \brief Prepare to record the given material ID starting at the given timecode to the given duration

/// \note Recording shares the preset out point with playout.

TRANSPORT::TSTATE::STATUS NEXIO::CODEC__::prepare_recording__(TEVENT const *event)

{

const CLIP &c = event->clip();

ODETICS_PROTOCOL_NAME id_handle;

if (protocol__->get_id_handle_from_extended_id(c.id(), &id_handle)) {

if (is_record_override_enabled()) {

// item exists; delete if not protected

NEXIO_PROTOCOL::TIDATTRIBUTES attr;

if (!protocol__->get_special_id_attributes(id_handle, &attr)) {

return TSTATE::FAILURE;

}

if (attr & NEXIO_PROTOCOL::ID_ATTRIBUTES_DELETE_PROTECTED) {

logger.printf(LOGGER::filter_info, "%ls exists (ID handle %s) and delete protected, can't record", c.id().c_str(), id_handle.get());

return TSTATE::FAILURE;

}

logger.printf(LOGGER::filter_info, "%ls exists (ID handle %s): delete before recording", c.id().c_str(), id_handle.get());

NEXIO_PROTOCOL::TID tid;

if (!protocol__->erase_id_with_transaction(id_handle, &tid)) {

// This might mean the clip was deleted between the time we got its handle and tried to erase it.

logger.printf(LOGGER::filter_error, "Could not delete before recording: operation failed");

}

else {

NEXIO_PROTOCOL::TSTATUS tstatus = get_transaction_status(tid, GET_TSTATUS_WAIT, MAX_STATUS_WAITS);

if (tstatus != NEXIO_PROTOCOL::TSTATUS_SUCCESS) {

// Delete failed. Can't record.

logger.printf(LOGGER::filter_error, "Could not delete before recording: transaction status %d", tstatus);

return TSTATE::FAILURE;

}

logger.printf(LOGGER::filter_verbose, "Delete before recording succeeded: transaction status %d", tstatus);

}

} else {

// item exists; fail cue

return TSTATE::FAILURE;

}

}

NEXIO_PROTOCOL::TID tid;

if (!protocol__->create_empty_media_with_extended_id(c.id(), &tid)) {

logger.printf(LOGGER::filter_error, "Could not create empty media: operation failed");

return TSTATE::FAILURE;

}

NEXIO_PROTOCOL::TSTATUS tstatus = get_transaction_status(tid, GET_TSTATUS_WAIT, MAX_STATUS_WAITS);

if (tstatus != NEXIO_PROTOCOL::TSTATUS_SUCCESS) {

logger.printf(LOGGER::filter_error, "Could not create empty media for %ls: transaction status %d", c.id().c_str(), tstatus);

return TSTATE::FAILURE;

}

if (!protocol__->get_transaction_id_handle(tid, &id_handle)) {

logger.printf(LOGGER::filter_error, "Could not retrieve transaction ID for transaction %d", tid);

return TSTATE::FAILURE;

}

const TIMECODE &som = c.som();

if (som.is_null()) {

if (!protocol__->cue_up_to_record(id_handle))

return TSTATE::FAILURE;

} else {

if (!protocol__->cue_up_to_record(SONYVTR_TIMECODE(som), id_handle))

return TSTATE::FAILURE;

}

const TIMECODE_INTERVAL &dur = c.duration();

if (!dur.is_null() && !som.is_null()) {

if (!protocol__->set_out_preset(SONYVTR_TIMECODE(som+dur)))

return TSTATE::FAILURE;

} else if (!protocol__->reset_out_preset()) {

return TSTATE::FAILURE;

}

return TSTATE::COMPLETE;

}

NEXIO_UTIL::NEXIO_PROTOCOL &NEXIO::CODEC__::protocol() const

{

return *protocol__;

}

bool NEXIO::CODEC__::check_preset_is_set__ ()

{

DEVICE_STATUS_2 ds;

return (protocol__->channel_status_sense(2, 1, reinterpret_cast<uint8_t *>(&ds)) && ds.v_cue_up_complete);

}

Размещено на Allbest.ru