HRESULT MfMediaStream::Create_(IMFMediaStreamPtr& ptr_stream)
{
ptr_stream_ = ptr_stream;
HRESULT hr = ptr_stream_->QueryInterface(IID_IMFMediaEventGenerator,
reinterpret_cast<void**>(&ptr_event_queue_));
if (FAILED(hr))
{
DBGLOG("ERROR, failed to obtain stream event generator" << HRLOG(hr)
<< " returning E_FAIL.");
return E_FAIL;
}
IMFStreamDescriptorPtr ptr_desc;
hr = ptr_stream->GetStreamDescriptor(&ptr_desc);
if (FAILED(hr))
{
DBGLOG("ERROR, GetStreamDescriptor failed" << HRLOG(hr));
return hr;
}
hr = get_media_type(ptr_desc, &ptr_media_type_);
if (FAILED(hr))
{
DBGLOG("ERROR, get_media_type failed" << HRLOG(hr));
return hr;
}
hr = stream_event_.Create();
if (FAILED(hr))
{
DBGLOG("ERROR, stream event creation failed" << HRLOG(hr));
return hr;
}
return hr;
}
/* test recording (loop test over BtSinkBinRecordFormat */
static void
test_bt_sink_bin_record (BT_TEST_ARGS)
{
BT_TEST_START;
GST_INFO ("-- arrange --");
if (!bt_sink_bin_is_record_format_supported (_i))
return;
// see GST_BUG_733031
if (_i == 3 || _i == 6)
return;
#if !GST_CHECK_VERSION (1,8,0)
if (_i == 5 || _i == 7)
return;
#endif
make_new_song ( /*silence */ 4);
GstElement *sink_bin = get_sink_bin ();
GEnumClass *enum_class =
g_type_class_peek_static (BT_TYPE_SINK_BIN_RECORD_FORMAT);
GEnumValue *enum_value = g_enum_get_value (enum_class, _i);
gchar *filename = make_tmp_song_path ("record", enum_value->value_name);
g_object_set (sink_bin,
"mode", BT_SINK_BIN_MODE_RECORD,
"record-format", _i, "record-file-name", filename, NULL);
GST_INFO ("-- act --");
GST_INFO ("act: == %s ==", filename);
bt_song_play (song);
run_main_loop_until_eos ();
bt_song_stop (song);
g_object_set (sink_bin, "mode", BT_SINK_BIN_MODE_PLAY, NULL);
GST_INFO ("-- assert --");
GST_INFO ("assert: == %s ==", filename);
fail_unless (g_file_test (filename, G_FILE_TEST_IS_REGULAR));
GStatBuf st;
g_stat (filename, &st);
ck_assert_int_gt (st.st_size, 0);
ck_assert_str_eq_and_free (get_media_type (filename), media_types[_i]);
GST_INFO ("-- cleanup --");
g_free (filename);
gst_object_unref (sink_bin);
BT_TEST_END;
}
/*
* Print adapter configuration information
*
* Arguments:
* si pointer to a struct air_cfg_rsp
*
* Returns:
* none
*
*/
void
print_cfg_info(struct air_cfg_rsp *si)
{
const char *adapter, *bus, *media, *vendor;
/*
* Print a header if it hasn't been done yet.
*/
if (!cfg_hdr) {
printf(CFG_HDR);
cfg_hdr = 1;
}
/*
* Format the vendor name and adapter type
*/
vendor = get_vendor(si->acp_vendor);
adapter = get_adapter(si->acp_device);
/*
* Format the communications medium
*/
media = get_media_type(si->acp_media);
bus = get_bus_type(si->acp_bustype);
/*
* Print the ARP server information
*/
printf("%-8s %-8s %-8s %-14s %-4s %ld\n",
si->acp_intf,
vendor,
adapter,
media,
bus,
si->acp_serial);
printf(" MAC address = %s\n",
format_mac_addr(&si->acp_macaddr));
printf(" Hardware version = %s\n", si->acp_hard_vers);
printf(" Firmware version = %s\n", si->acp_firm_vers);
}
/*
* Initialize device for track-at-once mode of writing. All of the data will
* need to be written to the track without interruption.
* This initialized TAO by setting page code 5 and speed.
*/
void
write_init(int mode)
{
(void) printf(gettext("Initializing device"));
if (simulation)
(void) printf(gettext("(Simulation mode)"));
print_n_flush("...");
get_media_type(target->d_fd);
/* DVD- requires DAO mode */
if (device_type == DVD_MINUS) {
write_mode = DAO_MODE;
}
/* DVD+ and DVD- have no support for AUDIO, bail out */
if ((mode == TRACK_MODE_AUDIO) && (device_type != CD_RW)) {
err_msg(gettext("Audio mode is only supported for CD media\n"));
exit(1);
}
if (simulation &&
check_device(target, CHECK_MEDIA_IS_NOT_BLANK) &&
!check_device(target, CHECK_MEDIA_IS_NOT_ERASABLE) &&
device_type != DVD_PLUS_W) {
/*
* If we were in simulation mode, and media wasn't blank,
* but medium was erasable, then cdrw goes to erase the
* contents of the media after the simulation writing in order
* to cleanup the ghost TOC (see write_fini() calls blank()).
* This is bad because it removes existing data if media was
* multi-session. Therefore, we no longer allow simulation
* writing if such condition is met. we don't blank the DVD+RW
* media, so DVD+RWs are fine.
*/
err_msg(gettext(
"Cannot perform simulation for non-blank media\n"));
exit(1);
}
if (!prepare_for_write(target, mode, simulation, keep_disc_open)) {
/* l10n_NOTE : 'failed' as in Initializing device...failed */
(void) printf(gettext("failed.\n"));
err_msg(gettext("Cannot initialize device for write\n"));
exit(1);
}
/* l10n_NOTE : 'done' as in "Initializing device...done" */
(void) printf(gettext("done.\n"));
/* if speed change option was used (-p) then try to set the speed */
if (requested_speed != 0) {
if (verbose)
(void) printf(gettext("Trying to set speed to %dX.\n"),
requested_speed);
if (target->d_speed_ctrl(target, SET_WRITE_SPEED,
requested_speed) == 0) {
err_msg(gettext("Unable to set speed.\n"));
exit(1);
}
if (verbose) {
int speed;
speed = target->d_speed_ctrl(target,
GET_WRITE_SPEED, 0);
if (speed == requested_speed) {
(void) printf(gettext("Speed set to %dX.\n"),
speed);
} else if (speed == 0) {
(void) printf(gettext("Could not obtain "
"current Write Speed.\n"));
} else {
(void) printf(
gettext("Speed set to closest approximation "
"of %dX allowed by device (%dX).\n"),
requested_speed, speed);
}
}
}
}
void
info(void)
{
uchar_t *toc, *p, *conf;
int ret, toc_size;
uint_t bsize;
size_t cap = 0;
char *msg;
struct track_info *ti;
msg = gettext("Cannot read Table of contents\n");
get_media_type(target->d_fd);
(void) printf(gettext("\nDevice : %.8s %.16s\n"),
&target->d_inq[8], &target->d_inq[16]);
(void) printf(gettext("Firmware : Rev. %.4s (%.12s)\n"),
&target->d_inq[32], &target->d_inq[36]);
if (check_device(target, CHECK_DEVICE_NOT_READY)) {
(void) check_device(target, CHECK_NO_MEDIA |
EXIT_IF_CHECK_FAILED);
(void) check_device(target, CHECK_DEVICE_NOT_READY |
EXIT_IF_CHECK_FAILED);
}
if (verbose != 0) {
/*
* Determine the media type by reading the active profile
* from the profile list.
*/
(void) printf(gettext("Media Type : "));
conf = (uchar_t *)my_zalloc(MMC_FTR_HDR_LEN);
if (get_configuration(target->d_fd, MMC_FTR_PRFL_LIST,
MMC_FTR_HDR_LEN, conf))
print_profile_name(read_scsi16(&conf[6]), 0, 1);
else
(void) printf(gettext("UNKNOWN\n"));
free(conf);
/*
* Get the start address of the last possible lead out.
*/
cap = get_last_possible_lba(target);
/*
* The start address of the last possible leadout will only
* be zero if the disc is full or this drive does not support
* this method of determining capacity.
*/
if (cap == 0)
cap = read_format_capacity(target->d_fd, &bsize);
/*
* Since both methods of determining the capacity of the
* media count the correct number of blocks, just multiply
* the capacity by the block size.
*/
cap *= target->d_blksize;
if (device_type == CD_RW) {
(void) printf(gettext("Media Capacity : %.2f MB "),
((double)cap/ONE_MB_BASE2));
} else {
/*
* For DVD's make sure we print out "Formatted Media
* Capacity". Don't do this for CD-RWs as only
* DVDs are formatted.
*/
(void) printf(gettext("Formatted Media Capacity : "
"%.2f GB "), ((double)cap/ONE_GB_BASE10));
}
cap /= target->d_blksize;
(void) printf(gettext("(%u blocks)\n"), (uint_t)cap);
}
if (!check_device(target, CHECK_MEDIA_IS_NOT_BLANK)) {
(void) printf(gettext("Media is blank\n"));
exit(0);
}
/* Find out the number of entries in the toc */
toc = (uchar_t *)my_zalloc(12);
if (!read_toc(target->d_fd, 0, 1, 4, toc)) {
err_msg(msg);
} else {
toc_size = 256*toc[0] + toc[1] + 2;
free(toc);
/* allocate enough space for each track entry */
toc = (uchar_t *)my_zalloc(toc_size);
if (!read_toc(target->d_fd, 0, 1, toc_size, toc)) {
err_msg(msg);
exit(1);
}
(void) printf("\n");
/* l10n_NOTE : Preserve column numbers of '|' character */
(void) printf(gettext("Track No. |Type |Start address\n"));
(void) printf("----------+--------+-------------\n");
/* look at each track and display it's type. */
for (p = &toc[4]; p < (toc + toc_size); p += 8) {
if (p[2] != 0xAA)
(void) printf(" %-3d |", p[2]);
else
(void) printf("Leadout |");
(void) printf("%s |", (p[1] & 4) ? gettext("Data ") :
gettext("Audio"));
(void) printf("%u\n", read_scsi32(&p[4]));
}
}
(void) printf("\n");
ret = read_toc(target->d_fd, 1, 0, 12, toc);
if ((ret == 0) || (toc[1] != 0x0a))
/* For ATAPI drives or old Toshiba drives */
ret = read_toc_as_per_8020(target->d_fd, 1, 0, 12, toc);
if (ret && (toc[1] == 0x0a)) {
(void) printf(gettext("Last session start address: %u\n"),
read_scsi32(&toc[8]));
}
free(toc);
ti = (struct track_info *)my_zalloc(sizeof (struct track_info));
if (build_track_info(target, -1, ti) && (ti->ti_flags & TI_NWA_VALID)) {
(void) printf(gettext("Next writable address: %u\n"),
ti->ti_nwa);
}
free(ti);
exit(0);
}
static gboolean
bind_and_exec (sqlite3 *db,
const gchar *sql,
const gchar *source_id,
const gchar *media_id,
GList *col_names,
GList *keys,
GrlMedia *media)
{
gint r;
const gchar *char_value;
gint int_value;
double double_value;
GList *iter_names, *iter_keys;
guint count;
sqlite3_stmt *stmt;
/* Create statement from sql */
GRL_DEBUG ("%s", sql);
r = sqlite3_prepare_v2 (db, sql, strlen (sql), &stmt, NULL);
if (r != SQLITE_OK) {
GRL_WARNING ("Failed to update metadata for '%s - %s': %s",
source_id, media_id, sqlite3_errmsg (db));
sqlite3_finalize (stmt);
return FALSE;
}
/* Bind media type */
sqlite3_bind_int (stmt, 1, get_media_type (media));
/* Bind column values */
count = 2;
iter_names = col_names;
iter_keys = keys;
while (iter_names) {
if (iter_names->data) {
GrlKeyID key = GRLPOINTER_TO_KEYID (iter_keys->data);
if (key == GRL_METADATA_KEY_RATING) {
double_value = grl_media_get_rating (media);
sqlite3_bind_double (stmt, count, double_value);
} else if (key == GRL_METADATA_KEY_PLAY_COUNT) {
int_value = grl_media_get_play_count (media);
sqlite3_bind_int (stmt, count, int_value);
} else if (key == GRL_METADATA_KEY_LAST_POSITION) {
int_value = grl_media_get_last_position (media);
sqlite3_bind_int (stmt, count, int_value);
} else if (key == GRL_METADATA_KEY_LAST_PLAYED) {
char_value = grl_media_get_last_played (media);
sqlite3_bind_text (stmt, count, char_value, -1, SQLITE_STATIC);
} else if (key == GRL_METADATA_KEY_FAVOURITE) {
int_value = (gint) grl_media_get_favourite (media);
sqlite3_bind_int (stmt, count, int_value);
}
count++;
}
iter_keys = g_list_next (iter_keys);
iter_names = g_list_next (iter_names);
}
sqlite3_bind_text (stmt, count++, source_id, -1, SQLITE_STATIC);
sqlite3_bind_text (stmt, count++, media_id, -1, SQLITE_STATIC);
/* execute query */
while ((r = sqlite3_step (stmt)) == SQLITE_BUSY);
sqlite3_finalize (stmt);
return (r == SQLITE_DONE);
}
static int
get_attrs(disk_t *dp, int fd, nvlist_t *attrs)
{
struct dk_minfo minfo;
struct dk_geom geometry;
if (fd < 0) {
return (ENODEV);
}
bzero(&minfo, sizeof (struct dk_minfo));
/* The first thing to do is read the media */
if (!media_read_info(fd, &minfo)) {
return (ENODEV);
}
if (partition_has_fdisk(dp, fd)) {
if (nvlist_add_boolean(attrs, DM_FDISK) != 0) {
return (ENOMEM);
}
}
if (dp->removable) {
if (nvlist_add_boolean(attrs, DM_REMOVABLE) != 0) {
return (ENOMEM);
}
if (nvlist_add_boolean(attrs, DM_LOADED) != 0) {
return (ENOMEM);
}
}
if (nvlist_add_uint64(attrs, DM_SIZE, minfo.dki_capacity) != 0) {
return (ENOMEM);
}
if (nvlist_add_uint32(attrs, DM_BLOCKSIZE, minfo.dki_lbsize) != 0) {
return (ENOMEM);
}
if (nvlist_add_uint32(attrs, DM_MTYPE,
get_media_type(minfo.dki_media_type)) != 0) {
return (ENOMEM);
}
/* only for disks < 1TB and x86 */
#if defined(i386) || defined(__amd64)
if (ioctl(fd, DKIOCG_PHYGEOM, &geometry) >= 0) {
#else
/* sparc call */
if (ioctl(fd, DKIOCGGEOM, &geometry) >= 0) {
#endif
struct extvtoc vtoc;
if (nvlist_add_uint64(attrs, DM_START, 0) != 0) {
return (ENOMEM);
}
if (nvlist_add_uint64(attrs, DM_NACCESSIBLE,
geometry.dkg_ncyl * geometry.dkg_nhead * geometry.dkg_nsect)
!= 0) {
return (ENOMEM);
}
if (nvlist_add_uint32(attrs, DM_NCYLINDERS, geometry.dkg_ncyl)
!= 0) {
return (ENOMEM);
}
if (nvlist_add_uint32(attrs, DM_NPHYSCYLINDERS,
geometry.dkg_pcyl) != 0) {
return (ENOMEM);
}
if (nvlist_add_uint32(attrs, DM_NALTCYLINDERS,
geometry.dkg_acyl) != 0) {
return (ENOMEM);
}
if (nvlist_add_uint32(attrs, DM_NHEADS,
geometry.dkg_nhead) != 0) {
return (ENOMEM);
}
if (nvlist_add_uint32(attrs, DM_NSECTORS, geometry.dkg_nsect)
!= 0) {
return (ENOMEM);
}
if (nvlist_add_uint32(attrs, DM_NACTUALCYLINDERS,
geometry.dkg_ncyl) != 0) {
return (ENOMEM);
}
if (read_extvtoc(fd, &vtoc) >= 0 && vtoc.v_volume[0] != 0) {
char label[LEN_DKL_VVOL + 1];
(void) snprintf(label, sizeof (label), "%.*s",
LEN_DKL_VVOL, vtoc.v_volume);
if (nvlist_add_string(attrs, DM_LABEL, label) != 0) {
return (ENOMEM);
}
}
} else {
/* check for disks > 1TB for accessible size */
struct dk_gpt *efip;
if (efi_alloc_and_read(fd, &efip) >= 0) {
diskaddr_t p8size = 0;
if (nvlist_add_boolean(attrs, DM_EFI) != 0) {
return (ENOMEM);
}
if (nvlist_add_uint64(attrs, DM_START,
efip->efi_first_u_lba) != 0) {
return (ENOMEM);
}
/* partition 8 is reserved on EFI labels */
if (efip->efi_nparts >= 9) {
p8size = efip->efi_parts[8].p_size;
}
if (nvlist_add_uint64(attrs, DM_NACCESSIBLE,
(efip->efi_last_u_lba - p8size) -
efip->efi_first_u_lba) != 0) {
efi_free(efip);
return (ENOMEM);
}
efi_free(efip);
}
}
return (0);
}
static int
get_media_type(uint_t media_type)
{
switch (media_type) {
case DK_UNKNOWN:
return (DM_MT_UNKNOWN);
case DK_MO_ERASABLE:
return (DM_MT_MO_ERASABLE);
case DK_MO_WRITEONCE:
return (DM_MT_MO_WRITEONCE);
case DK_AS_MO:
return (DM_MT_AS_MO);
case DK_CDROM:
return (DM_MT_CDROM);
case DK_CDR:
return (DM_MT_CDR);
case DK_CDRW:
return (DM_MT_CDRW);
case DK_DVDROM:
return (DM_MT_DVDROM);
case DK_DVDR:
return (DM_MT_DVDR);
case DK_DVDRAM:
return (DM_MT_DVDRAM);
case DK_FIXED_DISK:
return (DM_MT_FIXED);
case DK_FLOPPY:
return (DM_MT_FLOPPY);
case DK_ZIP:
return (DM_MT_ZIP);
case DK_JAZ:
return (DM_MT_JAZ);
default:
return (DM_MT_UNKNOWN);
}
}
/*
* This function handles removable media.
*/
static int
get_rmm_name(disk_t *dp, char *mname, int size)
{
int loaded;
int fd;
loaded = 0;
if ((fd = drive_open_disk(dp, NULL, 0)) >= 0) {
struct dk_minfo minfo;
if ((loaded = media_read_info(fd, &minfo))) {
struct extvtoc vtoc;
if (read_extvtoc(fd, &vtoc) >= 0) {
if (vtoc.v_volume[0] != NULL) {
if (LEN_DKL_VVOL < size) {
(void) strlcpy(mname,
vtoc.v_volume,
LEN_DKL_VVOL);
} else {
(void) strlcpy(mname,
vtoc.v_volume, size);
}
}
}
}
(void) close(fd);
}
return (loaded);
}
