void drag_keys_command_t::drag_curve( anim::track_t *t)
{
ui::can_drag_keys_visitor v0( offset_);
boost::apply_visitor( v0, t->curve().get());
// if keys can be dragged
if( v0.result)
{
add_track( t);
iterator it = curves_.find( t);
RAMEN_ASSERT( it != curves_.end());
// restore the original curve
anim::copy( it->second, t->curve().get());
// and drag it.
ui::drag_keys_visitor v1( offset_, snap_frames_);
boost::apply_visitor( v1, t->curve().get());
}
}
int main(int argc, char *argv[])
{
enum user_action action;
int c;
cs_error_t err;
cmap_handle_t handle;
int i;
size_t value_len;
cmap_value_types_t type;
int track_prefix;
int no_retries;
char * settings_file = NULL;
action = ACTION_PRINT_PREFIX;
track_prefix = 1;
while ((c = getopt(argc, argv, "hgsdDtTbp:")) != -1) {
switch (c) {
case 'h':
return print_help();
break;
case 'b':
show_binary++;
break;
case 'g':
action = ACTION_GET;
break;
case 's':
action = ACTION_SET;
break;
case 'd':
action = ACTION_DELETE;
break;
case 'D':
action = ACTION_DELETE_PREFIX;
break;
case 'p':
settings_file = optarg;
action = ACTION_LOAD;
break;
case 't':
action = ACTION_TRACK;
track_prefix = 0;
break;
case 'T':
action = ACTION_TRACK;
break;
case '?':
return (EXIT_FAILURE);
break;
default:
action = ACTION_PRINT_PREFIX;
break;
}
}
if (argc == 1 || (argc == 2 && show_binary)) {
action = ACTION_PRINT_ALL;
}
argc -= optind;
argv += optind;
if (argc == 0 &&
action != ACTION_LOAD &&
action != ACTION_PRINT_ALL) {
fprintf(stderr, "Expected key after options\n");
return (EXIT_FAILURE);
}
no_retries = 0;
while ((err = cmap_initialize(&handle)) == CS_ERR_TRY_AGAIN && no_retries++ < MAX_TRY_AGAIN) {
sleep(1);
}
if (err != CS_OK) {
fprintf (stderr, "Failed to initialize the cmap API. Error %s\n", cs_strerror(err));
exit (EXIT_FAILURE);
}
switch (action) {
case ACTION_PRINT_ALL:
print_iter(handle, NULL);
break;
case ACTION_PRINT_PREFIX:
for (i = 0; i < argc; i++) {
print_iter(handle, argv[i]);
}
break;
case ACTION_GET:
for (i = 0; i < argc; i++) {
err = cmap_get(handle, argv[i], NULL, &value_len, &type);
if (err == CS_OK) {
print_key(handle, argv[i], value_len, NULL, type);
} else {
fprintf(stderr, "Can't get key %s. Error %s\n", argv[i], cs_strerror(err));
}
}
break;
case ACTION_DELETE:
for (i = 0; i < argc; i++) {
err = cmap_delete(handle, argv[i]);
if (err != CS_OK) {
fprintf(stderr, "Can't delete key %s. Error %s\n", argv[i], cs_strerror(err));
}
}
break;
case ACTION_DELETE_PREFIX:
for (i = 0; i < argc; i++) {
delete_with_prefix(handle, argv[i]);
}
break;
case ACTION_LOAD:
read_in_config_file(handle, settings_file);
break;
case ACTION_TRACK:
for (i = 0; i < argc; i++) {
add_track(handle, argv[i], track_prefix);
}
track_changes(handle);
break;
case ACTION_SET:
if (argc < 3) {
fprintf(stderr, "At least 3 parameters are expected for set\n");
return (EXIT_FAILURE);
}
set_key(handle, argv[0], argv[1], argv[2]);
break;
}
err = cmap_finalize(handle);
if (err != CS_OK) {
fprintf (stderr, "Failed to finalize the cmap API. Error %s\n", cs_strerror(err));
exit (EXIT_FAILURE);
}
return (0);
}
static gboolean
xmms_cue_browse (xmms_xform_t *xform,
const gchar *url,
xmms_error_t *error)
{
gchar line[XMMS_XFORM_MAX_LINE_SIZE];
cue_track track;
gchar *p;
g_return_val_if_fail (xform, FALSE);
memset (&track, 0, sizeof (cue_track));
if (!xmms_xform_read_line (xform, line, error)) {
xmms_error_set (error, XMMS_ERROR_INVAL, "error reading cue-file!");
return FALSE;
}
do {
p = skip_white_space (line);
if (g_ascii_strncasecmp (p, "FILE", 4) == 0) {
if (track.file[0]) {
add_track (xform, &track);
}
p = skip_to_char (p, '"');
p ++;
save_to_char (p, '"', track.file);
} else if (g_ascii_strncasecmp (p, "TRACK", 5) == 0) {
p = skip_to_char (p, ' ');
p = skip_white_space (p);
p = skip_to_char (p, ' ');
p = skip_white_space (p);
if (g_ascii_strncasecmp (p, "AUDIO", 5) == 0) {
cue_track *t = g_new0 (cue_track, 1);
track.tracks = g_list_prepend (track.tracks, t);
}
} else if (g_ascii_strncasecmp (p, "INDEX", 5) == 0) {
cue_track *t = g_list_nth_data (track.tracks, 0);
if (!t) {
continue;
}
p = skip_to_char (p, ' ');
p = skip_white_space (p);
p = skip_to_char (p, ' ');
p = skip_white_space (p);
add_index (t, p);
} else if (g_ascii_strncasecmp (p, "TITLE", 5) == 0) {
cue_track *t = g_list_nth_data (track.tracks, 0);
p = skip_to_char (p, '"');
p ++;
if (!t) {
save_to_char (p, '"', track.album);
} else {
save_to_char (p, '"', t->title);
}
} else if (g_ascii_strncasecmp (p, "PERFORMER", 9) == 0) {
cue_track *t = g_list_nth_data (track.tracks, 0);
p = skip_to_char (p, '"');
p ++;
if (!t) {
save_to_char (p, '"', track.artist);
} else {
save_to_char (p, '"', t->artist);
}
}
} while (xmms_xform_read_line (xform, line, error));
if (track.file[0]) {
add_track (xform, &track);
}
xmms_error_reset (error);
return TRUE;
}
int
main(int argc, char **argv)
{
int arg, addr, ch, fd;
int dao = 0, eject = 0, fixate = 0, list = 0, multi = 0, preemp = 0;
int nogap = 0, speed = 4 * 177, test_write = 0, force = 0;
int block_size = 0, block_type = 0, cdopen = 0, dvdrw = 0;
const char *dev, *env_speed;
if (feature_present("ata_cam")) {
errx(1, "\nATA_CAM option is enabled in kernel.\n"
"Install the sysutils/cdrtools port and use cdrecord instead.\n\n"
"Please refer to:\n"
"http://www.freebsd.org/doc/handbook/creating-cds.html#CDRECORD");
}
if ((dev = getenv("CDROM")) == NULL)
dev = "/dev/acd0";
env_speed = getenv("BURNCD_SPEED");
while ((ch = getopt(argc, argv, "def:Flmnpqs:tv")) != -1) {
switch (ch) {
case 'd':
dao = 1;
break;
case 'e':
eject = 1;
break;
case 'f':
dev = optarg;
break;
case 'F':
force = 1;
break;
case 'l':
list = 1;
break;
case 'm':
multi = 1;
break;
case 'n':
nogap = 1;
break;
case 'p':
preemp = 1;
break;
case 'q':
quiet = 1;
break;
case 's':
env_speed = optarg;
break;
case 't':
test_write = 1;
break;
case 'v':
verbose = 1;
break;
default:
usage();
}
}
argc -= optind;
argv += optind;
if (env_speed == NULL)
;
else if (strcasecmp("max", env_speed) == 0)
speed = CDR_MAX_SPEED;
else
speed = atoi(env_speed) * 177;
if (speed <= 0)
errx(EX_USAGE, "Invalid speed: %s", env_speed);
if (argc == 0)
usage();
if ((fd = open(dev, O_RDWR, 0)) < 0)
err(EX_NOINPUT, "open(%s)", dev);
if (ioctl(fd, CDRIOCGETBLOCKSIZE, &saved_block_size) < 0)
err(EX_IOERR, "ioctl(CDRIOCGETBLOCKSIZE)");
if (ioctl(fd, CDRIOCWRITESPEED, &speed) < 0)
err(EX_IOERR, "ioctl(CDRIOCWRITESPEED)");
global_fd_for_cleanup = fd;
err_set_exit(cleanup);
signal(SIGHUP, cleanup_signal);
signal(SIGINT, cleanup_signal);
signal(SIGTERM, cleanup_signal);
for (arg = 0; arg < argc; arg++) {
if (!strcasecmp(argv[arg], "fixate")) {
fixate = 1;
continue;
}
if (!strcasecmp(argv[arg], "eject")) {
eject = 1;
break;
}
if (!strcasecmp(argv[arg], "msinfo")) {
struct ioc_read_toc_single_entry entry;
struct ioc_toc_header header;
if (ioctl(fd, CDIOREADTOCHEADER, &header) < 0)
err(EX_IOERR, "ioctl(CDIOREADTOCHEADER)");
bzero(&entry, sizeof(struct ioc_read_toc_single_entry));
entry.address_format = CD_LBA_FORMAT;
entry.track = header.ending_track;
if (ioctl(fd, CDIOREADTOCENTRY, &entry) < 0)
err(EX_IOERR, "ioctl(CDIOREADTOCENTRY)");
if (ioctl(fd, CDRIOCNEXTWRITEABLEADDR, &addr) < 0)
err(EX_IOERR, "ioctl(CDRIOCNEXTWRITEABLEADDR)");
fprintf(stdout, "%d,%d\n",
ntohl(entry.entry.addr.lba), addr);
break;
}
if ((!strcasecmp(argv[arg], "erase") ||
!strcasecmp(argv[arg], "blank")) && !test_write) {
int blank, pct, last = 0;
if (!strcasecmp(argv[arg], "erase"))
blank = CDR_B_ALL;
else
blank = CDR_B_MIN;
if (!quiet)
fprintf(stderr, "%sing CD, please wait..\r",
blank == CDR_B_ALL ? "eras" : "blank");
if (ioctl(fd, CDRIOCBLANK, &blank) < 0)
err(EX_IOERR, "ioctl(CDRIOCBLANK)");
while (1) {
sleep(1);
if (ioctl(fd, CDRIOCGETPROGRESS, &pct) == -1)
err(EX_IOERR,"ioctl(CDRIOGETPROGRESS)");
if (pct > 0 && !quiet)
fprintf(stderr,
"%sing CD - %d %% done \r",
blank == CDR_B_ALL ?
"eras" : "blank", pct);
if (pct == 100 || (pct == 0 && last > 90))
break;
last = pct;
}
if (!quiet)
printf("\n");
continue;
}
if (!strcasecmp(argv[arg], "format") && !test_write) {
if (arg + 1 < argc &&
(!strcasecmp(argv[arg + 1], "dvd+rw") ||
!strcasecmp(argv[arg + 1], "dvd-rw")))
do_format(fd, force, argv[arg + 1]);
else
errx(EX_NOINPUT, "format media type invalid");
arg++;
continue;
}
if (!strcasecmp(argv[arg], "audio") || !strcasecmp(argv[arg], "raw")) {
block_type = CDR_DB_RAW;
block_size = 2352;
continue;
}
if (!strcasecmp(argv[arg], "data") || !strcasecmp(argv[arg], "mode1")) {
block_type = CDR_DB_ROM_MODE1;
block_size = 2048;
continue;
}
if (!strcasecmp(argv[arg], "mode2")) {
block_type = CDR_DB_ROM_MODE2;
block_size = 2336;
continue;
}
if (!strcasecmp(argv[arg], "xamode1")) {
block_type = CDR_DB_XA_MODE1;
block_size = 2048;
continue;
}
if (!strcasecmp(argv[arg], "xamode2")) {
block_type = CDR_DB_XA_MODE2_F2;
block_size = 2324;
continue;
}
if (!strcasecmp(argv[arg], "vcd")) {
block_type = CDR_DB_XA_MODE2_F2;
block_size = 2352;
dao = 1;
nogap = 1;
continue;
}
if (!strcasecmp(argv[arg], "dvdrw")) {
block_type = CDR_DB_ROM_MODE1;
block_size = 2048;
dvdrw = 1;
continue;
}
if (!block_size)
errx(EX_NOINPUT, "no data format selected");
if (list) {
char file_buf[MAXPATHLEN + 1], *eol;
FILE *fp;
if ((fp = fopen(argv[arg], "r")) == NULL)
err(EX_NOINPUT, "fopen(%s)", argv[arg]);
while (fgets(file_buf, sizeof(file_buf), fp) != NULL) {
if (*file_buf == '#' || *file_buf == '\n')
continue;
if ((eol = strchr(file_buf, '\n')))
*eol = '\0';
add_track(file_buf, block_size, block_type, nogap);
}
if (feof(fp))
fclose(fp);
else
err(EX_IOERR, "fgets(%s)", file_buf);
}
else
add_track(argv[arg], block_size, block_type, nogap);
}
if (notracks) {
if (dvdrw && notracks > 1)
errx(EX_USAGE, "DVD's only have 1 track");
if (ioctl(fd, CDIOCSTART, 0) < 0)
err(EX_IOERR, "ioctl(CDIOCSTART)");
if (!cdopen) {
if (ioctl(fd, CDRIOCINITWRITER, &test_write) < 0)
err(EX_IOERR, "ioctl(CDRIOCINITWRITER)");
cdopen = 1;
}
if (dao)
do_DAO(fd, test_write, multi);
else
do_TAO(fd, test_write, preemp, dvdrw);
}
if (!test_write && fixate && !dao && !dvdrw) {
if (!quiet)
fprintf(stderr, "fixating CD, please wait..\n");
if (ioctl(fd, CDRIOCFIXATE, &multi) < 0)
err(EX_IOERR, "ioctl(CDRIOCFIXATE)");
}
if (ioctl(fd, CDRIOCSETBLOCKSIZE, &saved_block_size) < 0) {
err_set_exit(NULL);
err(EX_IOERR, "ioctl(CDRIOCSETBLOCKSIZE)");
}
if (eject)
if (ioctl(fd, CDIOCEJECT) < 0)
err(EX_IOERR, "ioctl(CDIOCEJECT)");
signal(SIGHUP, SIG_DFL);
signal(SIGINT, SIG_DFL);
signal(SIGTERM, SIG_DFL);
close(fd);
exit(EX_OK);
}
static int process_metadata(MXFReader *reader, MXFPartition *partition)
{
MXFFile *mxfFile = reader->mxfFile;
EssenceReader *essenceReader = reader->essenceReader;
EssenceReaderData *data = essenceReader->data;
mxfKey key;
uint8_t llen;
uint64_t len;
MXFMetadataSet *essContainerDataSet;
MXFMetadataSet *sourcePackageSet;
MXFMetadataSet *sourcePackageTrackSet;
MXFMetadataSet *materialPackageSet;
MXFMetadataSet *materialPackageTrackSet;
MXFMetadataSet *descriptorSet;
MXFArrayItemIterator arrayIter;
mxfUL dataDefUL;
MXFTrack *track;
EssenceTrack *essenceTrack;
MXFList wrappedTracks;
MXFList sortedWrappedTracks;
WrappedTrack *newWrappedTrack = NULL;
WrappedTrack *wrappedTrack;
WrappedTrack *sortedWrappedTrack;
WrappedTrack *prevSortedWrappedTrack;
WrappedTrack *firstSortedWrappedTrack;
MXFListIterator listIter;
MXFListIterator sortedListIter;
int wasInserted;
int haveZeroTrackNumber;
uint32_t trackID;
mxf_initialise_list(&wrappedTracks, free);
mxf_initialise_list(&sortedWrappedTracks, NULL);
/* create and read the header metadata */
CHK_OFAIL(mxf_read_next_nonfiller_kl(mxfFile, &key, &llen, &len));
CHK_OFAIL(mxf_is_header_metadata(&key));
CHK_OFAIL(mxf_create_header_metadata(&data->headerMetadata, reader->dataModel));
CHK_OFAIL(mxf_read_header_metadata(mxfFile, data->headerMetadata,
partition->headerByteCount, &key, llen, len));
/* check for metadata only files */
if (!mxf_find_singular_set_by_key(data->headerMetadata, &MXF_SET_K(EssenceContainerData), &essContainerDataSet))
{
reader->isMetadataOnly = 1;
return 1;
}
/* get the body and index SID from the (single essence container; external essence not supported) */
CHK_OFAIL(mxf_get_uint32_item(essContainerDataSet, &MXF_ITEM_K(EssenceContainerData, BodySID), &data->bodySID));
if (mxf_have_item(essContainerDataSet, &MXF_ITEM_K(EssenceContainerData, IndexSID)))
{
CHK_OFAIL(mxf_get_uint32_item(essContainerDataSet, &MXF_ITEM_K(EssenceContainerData, IndexSID), &data->indexSID));
}
else
{
data->indexSID = 0;
}
/* get the clip duration */
CHK_OFAIL(get_clip_duration(data->headerMetadata, &reader->clip, 0));
/* get the tracks from the (single) material package */
haveZeroTrackNumber = 0;
CHK_OFAIL(mxf_find_singular_set_by_key(data->headerMetadata, &MXF_SET_K(MaterialPackage), &materialPackageSet));
CHK_OFAIL(mxf_uu_get_package_tracks(materialPackageSet, &arrayIter));
while (mxf_uu_next_track(data->headerMetadata, &arrayIter, &materialPackageTrackSet))
{
/* CHK_OFAIL(mxf_uu_get_track_datadef(materialPackageTrackSet, &dataDefUL)); */
/* NOTE: not failing because files from Omneon were found to have a missing DataDefinition item
in the Sequence and DMSourceClip referenced by a static DM Track */
if (!mxf_uu_get_track_datadef(materialPackageTrackSet, &dataDefUL))
{
continue;
}
if (mxf_is_picture(&dataDefUL) || mxf_is_sound(&dataDefUL))
{
CHK_MALLOC_OFAIL(newWrappedTrack, WrappedTrack);
memset(newWrappedTrack, 0, sizeof(WrappedTrack));
CHK_OFAIL(mxf_append_list_element(&wrappedTracks, newWrappedTrack));
wrappedTrack = newWrappedTrack;
newWrappedTrack = NULL; /* assigned to list so set to NULL so not free'ed in fail */
CHK_OFAIL(add_track(reader, &track));
wrappedTrack->track = track;
if (mxf_have_item(materialPackageTrackSet, &MXF_ITEM_K(GenericTrack, TrackNumber)))
{
CHK_OFAIL(mxf_get_uint32_item(materialPackageTrackSet, &MXF_ITEM_K(GenericTrack, TrackNumber), &wrappedTrack->trackNumber));
}
else
{
wrappedTrack->trackNumber = 0;
}
CHK_OFAIL(mxf_get_uint32_item(materialPackageTrackSet, &MXF_ITEM_K(GenericTrack, TrackID), &wrappedTrack->trackID));
CHK_OFAIL(mxf_get_rational_item(materialPackageTrackSet, &MXF_ITEM_K(Track, EditRate), &wrappedTrack->editRate));
CHK_OFAIL(mxf_uu_get_track_duration(materialPackageTrackSet, &wrappedTrack->duration));
CHK_OFAIL(mxf_uu_get_track_reference(materialPackageTrackSet, &wrappedTrack->sourcePackageUID, &wrappedTrack->sourceTrackID));
wrappedTrack->isVideo = mxf_is_picture(&dataDefUL);
track->isVideo = wrappedTrack->isVideo;
track->materialTrackID = wrappedTrack->trackID;
track->materialTrackNumber = wrappedTrack->trackNumber;
if (wrappedTrack->isVideo)
{
track->video.frameRate = wrappedTrack->editRate;
}
if (wrappedTrack->trackNumber == 0)
{
haveZeroTrackNumber = 1;
}
}
}
/* sort the tracks; use trackNumber if != 0 else use the trackID; video track is always first */
mxf_initialise_list_iter(&listIter, &wrappedTracks);
while (mxf_next_list_iter_element(&listIter))
{
wrappedTrack = (WrappedTrack*)mxf_get_iter_element(&listIter);
wasInserted = 0;
mxf_initialise_list_iter(&sortedListIter, &sortedWrappedTracks);
while (mxf_next_list_iter_element(&sortedListIter))
{
sortedWrappedTrack = (WrappedTrack*)mxf_get_iter_element(&sortedListIter);
if ((wrappedTrack->track->isVideo && !sortedWrappedTrack->track->isVideo) ||
(wrappedTrack->track->isVideo == sortedWrappedTrack->track->isVideo &&
((!haveZeroTrackNumber && wrappedTrack->trackNumber < sortedWrappedTrack->trackNumber) ||
(haveZeroTrackNumber && wrappedTrack->trackID < sortedWrappedTrack->trackID))))
{
CHK_OFAIL(mxf_insert_list_element(&sortedWrappedTracks, mxf_get_list_iter_index(&sortedListIter),
1, wrappedTrack));
wasInserted = 1;
break;
}
}
if (!wasInserted)
{
CHK_OFAIL(mxf_append_list_element(&sortedWrappedTracks, wrappedTrack));
}
}
/* set the MXFTracks to the same order */
prevSortedWrappedTrack = NULL;
firstSortedWrappedTrack = NULL;
mxf_initialise_list_iter(&sortedListIter, &sortedWrappedTracks);
while (mxf_next_list_iter_element(&sortedListIter))
{
sortedWrappedTrack = (WrappedTrack*)mxf_get_iter_element(&sortedListIter);
if (firstSortedWrappedTrack == NULL)
{
firstSortedWrappedTrack = sortedWrappedTrack;
}
if (prevSortedWrappedTrack != NULL)
{
prevSortedWrappedTrack->track->next = sortedWrappedTrack->track;
}
prevSortedWrappedTrack = sortedWrappedTrack;
}
if (prevSortedWrappedTrack != NULL)
{
prevSortedWrappedTrack->track->next = NULL;
}
if (firstSortedWrappedTrack != NULL)
{
reader->clip.tracks = firstSortedWrappedTrack->track;
}
/* process source package tracks and linked descriptors */
mxf_initialise_list_iter(&sortedListIter, &sortedWrappedTracks);
while (mxf_next_list_iter_element(&sortedListIter))
{
sortedWrappedTrack = (WrappedTrack*)mxf_get_iter_element(&sortedListIter);
CHK_OFAIL(mxf_uu_get_referenced_track(data->headerMetadata, &sortedWrappedTrack->sourcePackageUID,
sortedWrappedTrack->sourceTrackID, &sourcePackageTrackSet));
CHK_OFAIL(add_essence_track(essenceReader, &essenceTrack));
essenceTrack->isVideo = sortedWrappedTrack->isVideo;
if (mxf_have_item(sourcePackageTrackSet, &MXF_ITEM_K(GenericTrack, TrackNumber)))
{
CHK_OFAIL(mxf_get_uint32_item(sourcePackageTrackSet, &MXF_ITEM_K(GenericTrack, TrackNumber), &essenceTrack->trackNumber));
}
else
{
essenceTrack->trackNumber = 0;
}
CHK_OFAIL(mxf_get_uint32_item(sourcePackageTrackSet, &MXF_ITEM_K(GenericTrack, TrackID), &trackID));
essenceTrack->frameRate = reader->clip.frameRate;
essenceTrack->playoutDuration = reader->clip.duration;
essenceTrack->indexSID = data->indexSID;
essenceTrack->bodySID = data->bodySID;
/* process the descriptor */
CHK_OFAIL(mxf_uu_get_referenced_package(data->headerMetadata, &sortedWrappedTrack->sourcePackageUID,
&sourcePackageSet));
CHK_OFAIL(mxf_uu_get_track_descriptor(sourcePackageSet, trackID, &descriptorSet));
if (mxf_is_subclass_of(data->headerMetadata->dataModel, &descriptorSet->key, &MXF_SET_K(CDCIEssenceDescriptor)))
{
CHK_OFAIL(process_cdci_descriptor(descriptorSet, sortedWrappedTrack->track, essenceTrack));
}
else if (mxf_is_subclass_of(data->headerMetadata->dataModel, &descriptorSet->key, &MXF_SET_K(WaveAudioDescriptor)))
{
CHK_OFAIL(process_wav_descriptor(descriptorSet, sortedWrappedTrack->track, essenceTrack));
}
else if (mxf_is_subclass_of(data->headerMetadata->dataModel, &descriptorSet->key, &MXF_SET_K(GenericSoundEssenceDescriptor)))
{
CHK_OFAIL(process_sound_descriptor(descriptorSet, track, essenceTrack));
}
else
{
mxf_log_error("Unsupported file descriptor" LOG_LOC_FORMAT, LOG_LOC_PARAMS);
return 0;
}
}
/* initialise the playout timecode */
if (!initialise_playout_timecode(reader, materialPackageSet))
{
CHK_ORET(initialise_default_playout_timecode(reader));
}
/* initialise the source timecodes */
initialise_source_timecodes(reader, sourcePackageSet);
mxf_clear_list(&wrappedTracks);
mxf_clear_list(&sortedWrappedTracks);
return 1;
fail:
SAFE_FREE(newWrappedTrack);
mxf_clear_list(&wrappedTracks);
mxf_clear_list(&sortedWrappedTracks);
return 0;
}
void import_flac_file(const std::string& filename)
{
//std::cerr << "import_flac_file " << filename << std::endl;
TagLib::FLAC::File file(filename.c_str());
auto tag = file.tag();
auto artist_name = tag->artist().to8Bit(true);
auto album_title = tag->album().to8Bit(true);
auto track_title = tag->title().to8Bit(true);
auto artist = dm::artist::find_by_name(artist_name);
if ( artist.is_null() )
{
// Create artist.
artist.name(artist_name);
artist.save();
}
auto album = artist.find_album_by_title(album_title);
if ( album.is_null() )
{
// Create album.
album.title(album_title);
album.member("artist", json::object{ { "id", artist.id() }, { "name", artist.name() } });
album.save();
// Add album to artist albums.
artist.add_album(album);
artist.save();
}
auto track = album.find_track_by_title_and_number(track_title, tag->track());
// Set/update track attributes.
track.title(track_title);
track.track_number(tag->track());
track.disc_number(1);
// Create track source object.
json::object source{ { "name", "local" }, { "uri", filename } };
TagLib::FLAC::Properties* properties = file.audioProperties();
if ( properties )
{
track.duration(properties->length());
}
TagLib::Ogg::XiphComment* xiph_comment = file.xiphComment();
if ( xiph_comment )
{
auto field_map = xiph_comment->fieldListMap();
json::object replaygain;
for ( auto& field : field_map )
{
if ( field.first == "TRACK NUMBER" || field.first == "TRACKNUMBER" )
{
if ( field.second.size() > 0 ) {
track.track_number(std::stoi(field.second[0].to8Bit()));
}
else {
std::cerr << "field='" << field.first << "' string list size=" << field.second.size() << std::endl;
}
}
else if ( field.first == "DISC NUMBER" || field.first == "DISCNUMBER" )
{
if ( field.second.size() > 0 ) {
track.disc_number(std::stoi(field.second[0].to8Bit()));
}
else {
std::cerr << "field='" << field.first << "' string list size=" << field.second.size() << std::endl;
}
}
else if ( field.first == "REPLAYGAIN_REFERENCE_LOUDNESS" )
{
auto ref_loudness = std::stod(field.second[0].to8Bit());
replaygain["reference_loudness"] = ref_loudness;
}
else if ( field.first == "REPLAYGAIN_TRACK_GAIN" )
{
auto gain = std::stod(field.second[0].to8Bit());
replaygain["track_gain"] = gain;
}
}
if ( !replaygain.empty() ) {
source["replaygain"] = replaygain;
}
}
const TagLib::List<TagLib::FLAC::Picture*>& images = file.pictureList();
if ( images.size() > 0 )
{
TagLib::FLAC::Picture* image = images[0];
if ( image->mimeType() == "image/jpeg" )
{
auto cover = dm::album_cover::find_by_album_id(album.id());
if ( cover.is_null() )
{
cover.format("jpg");
cover.data(reinterpret_cast<const char*>(image->data().data()), image->data().size());
cover.save();
}
}
else
{
std::cerr << "unhandled image mime type - " << filename << " images=" << images.size() << ", mime type " << image->mimeType() << std::endl;
}
}
track.artist(artist);
track.album(album);
track.source(std::move(source));
if ( track.id_is_null() )
{
// Create track id.
track.save();
// Add new track to album.
album.add_track(track);
album.save();
}
else
{
track.save();
}
}
