int netmd_set_title(usb_dev_handle* dev, int track, char* buffer, int size)
{
int ret = 1;
char *title_request = NULL;
char title_header[21] = {0x00, 0x18, 0x07, 0x02, 0x20, 0x18, 0x02, 0x00,
0x00, 0x30, 0x00, 0x0a, 0x00, 0x50, 0x00, 0x00,
0x0a, 0x00, 0x00, 0x00, 0x0d};
char reply[255];
title_request = malloc(sizeof(char) * (0x15 + size));
memcpy(title_request, title_header, 0x15);
memcpy((title_request + 0x15), buffer, size);
title_request[8] = track;
title_request[16] = size;
title_request[20] = size;
ret = netmd_exch_message(dev, title_request, (int)(0x15 + size), reply);
if(ret < 0)
{
fprintf(stderr, "bad ret code, returning early\n");
return 0;
}
free(title_request);
return 1;
}
static void send_raw_message(netmd_dev_handle* devh, char *pszRaw)
{
unsigned char cmd[255], rsp[255];
unsigned int data;
char szBuf[4];
size_t cmdlen;
int rsplen;
/* check raw message length */
if ((strlen(pszRaw) % 2) != 0) {
printf("Error: invalid length of raw message!\n");
return;
}
/* convert hex message to bin */
cmdlen = 0;
while (*pszRaw != 0) {
szBuf[0] = *pszRaw++;
szBuf[1] = *pszRaw++;
szBuf[2] = '\0';
if (sscanf(szBuf, "%02X", &data) != 1) {
printf("Error: invalid character at byte %lu ('%s')\n", (unsigned long)cmdlen, szBuf);
return;
}
cmd[cmdlen++] = data & 0xff;
}
/* send it */
rsplen = netmd_exch_message(devh, cmd, cmdlen, rsp);
if (rsplen < 0) {
printf("Error: netmd_exch_message failed with %d\n", rsplen);
return;
}
}
static int request_disc_title(usb_dev_handle* dev, char* buffer, int size)
{
int ret = -1;
int title_size = 0;
char title_request[0x13] = {0x00, 0x18, 0x06, 0x02, 0x20, 0x18, 0x01, 0x00, 0x00, 0x30, 0x00, 0xa, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00};
char title[255];
ret = netmd_exch_message(dev, title_request, 0x13, title);
if(ret < 0)
{
fprintf(stderr, "request_disc_title: bad ret code, returning early\n");
return 0;
}
title_size = ret;
if(title_size == 0 || title_size == 0x13)
return -1; /* bail early somethings wrong */
if(title_size > size)
{
printf("request_disc_title: title too large for buffer\n");
return -1;
}
memset(buffer, 0, size);
strncpy(buffer, (title + 25), title_size - 25);
/* buffer[size + 1] = 0; XXX Huh? This is outside the bounds passed in! */
return title_size - 25;
}
int netmd_request_title(usb_dev_handle* dev, int track, char* buffer, int size)
{
int ret = -1;
int title_size = 0;
char title_request[0x13] = {0x00, 0x18, 0x06, 0x02, 0x20, 0x18, 0x02, 0x00, 0x00, 0x30, 0x00, 0xa, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00};
char title[255];
title_request[8] = track;
ret = netmd_exch_message(dev, title_request, 0x13, title);
if(ret < 0)
{
fprintf(stderr, "bad ret code, returning early\n");
return -1;
}
title_size = ret;
if(title_size == 0 || title_size == 0x13)
return -1; /* bail early somethings wrong or no track */
if(title_size > size)
{
printf("netmd_request_title: title too large for buffer\n");
return -1;
}
memset(buffer, 0, size);
strncpy(buffer, (title + 25), title_size - 25);
buffer[size + 1] = 0;
return title_size - 25;
}
int netmd_set_track( usb_dev_handle* dev, int track)
{
int ret = 0;
char request[] = {0x00, 0x18, 0x50, 0xff, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}; // Change track
int size;
char buf[255];
fprintf(stderr,"Selecting track: %d \n",track);
request[10] = track-1;
ret = netmd_exch_message(dev, request, 11, buf);
if(ret < 0)
{
fprintf(stderr, "bad ret code, returning early\n");
return 0;
}
size = ret;
if (size<1) {
fprintf(stderr, "Invalid size\n");
return -1;
}
return 1;
}
void netmd_get_track_information(netmd_dev_handle *dev, uint16_t track,
uint16_t p1, uint16_t p2,
unsigned char *data, size_t data_length)
{
unsigned char cmd[] = { 0x00, 0x18, 0x06, 0x02, 0x20, 0x10, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0xff, 0x00, 0x00, 0x00, 0x00, 0x00 };
unsigned char rsp[255];
unsigned char *buf;
int length;
uint16_t real_data_length;
size_t size;
buf = cmd + 7;
netmd_copy_word_to_buffer(&buf, track, 0);
netmd_copy_word_to_buffer(&buf, p1, 0);
netmd_copy_word_to_buffer(&buf, p2, 0);
length = netmd_exch_message(dev, cmd, sizeof(cmd), rsp);
if (length > 0) {
uint32_t tmp = (unsigned int)data[19] << 8;
real_data_length = (tmp + data[20]) & 0xffffU;
if (real_data_length > data_length) {
size = data_length;
}
else {
size = real_data_length;
}
memcpy(data, rsp + 21, size);
}
}
int netmd_request_track_flags(netmd_dev_handle*dev, const uint16_t track, unsigned char* data)
{
int ret = 0;
unsigned char request[] = {0x00, 0x18, 0x06, 0x01, 0x20, 0x10,
0x01, 0x00, 0x00, 0xff, 0x00, 0x00,
0x01, 0x00, 0x08};
unsigned char *buf;
unsigned char reply[255];
buf = request + 7;
netmd_copy_word_to_buffer(&buf, track, 0);
ret = netmd_exch_message(dev, request, sizeof(request), reply);
*data = reply[ret - 1];
return ret;
}
int netmd_move_track(usb_dev_handle* dev, int start, int finish)
{
int ret = 0;
char request[] = {0x00, 0x18, 0x43, 0xff, 0x00, 0x00, 0x20, 0x10, 0x01, 0x00, 0x04, 0x20, 0x10, 0x01, 0x00, 0x03};
char reply[255];
request[10] = start;
request[15] = finish;
ret = netmd_exch_message(dev, request, 16, reply);
if(ret < 0)
{
fprintf(stderr, "bad ret code, returning early\n");
return 0;
}
return 1;
}
int netmd_request_track_codec(usb_dev_handle*dev, int track, char* data)
{
int ret = 0;
int size = 0;
char request[] = {0x00, 0x18, 0x06, 0x01, 0x20, 0x10, 0x01, 0x00, 0xDD, 0xff, 0x00, 0x00, 0x01, 0x00, 0x08};
char reply[255];
request[8] = track;
ret = netmd_exch_message(dev, request, 0x13, reply);
if(ret < 0)
{
fprintf(stderr, "bad ret code, returning early\n");
return 0;
}
size = ret;
/* printf("\nCodec Reply:\n"); */
/* print_hex(reply, size); */
*data = reply[size - 1];
return ret;
}
static int netmd_playback_control(usb_dev_handle* dev, unsigned char code)
{
int ret = 0;
unsigned char request[] = {0x00, 0x18, 0xc3, 0xff, 0x75, 0x00, 0x00, 0x00}; // Play
int size;
unsigned char buf[255];
request[4] = code;
ret = netmd_exch_message(dev, request, 8, buf);
size = ret;
if (size<1) {
fprintf(stderr, "Invalid size\n");
return -1;
}
printf( "Reply: " );
print_hex( buf, size );
printf( "\n" );
return 1;
}
int netmd_request_title(netmd_dev_handle* dev, const uint16_t track, char* buffer, const size_t size)
{
int ret = -1;
size_t title_size = 0;
unsigned char title_request[] = {0x00, 0x18, 0x06, 0x02, 0x20, 0x18,
0x02, 0x00, 0x00, 0x30, 0x00, 0xa,
0x00, 0xff, 0x00, 0x00, 0x00, 0x00,
0x00};
unsigned char title[255];
unsigned char *buf;
buf = title_request + 7;
netmd_copy_word_to_buffer(&buf, track, 0);
ret = netmd_exch_message(dev, title_request, 0x13, title);
if(ret < 0)
{
fprintf(stderr, "bad ret code, returning early\n");
return -1;
}
title_size = (size_t)ret;
if(title_size == 0 || title_size == 0x13)
return -1; /* bail early somethings wrong or no track */
if(title_size > size)
{
printf("netmd_request_title: title too large for buffer\n");
return -1;
}
memset(buffer, 0, size);
memcpy(buffer, (title + 25), title_size - 25);
buffer[size] = 0;
return (int)title_size - 25;
}
int netmd_request_track_time(usb_dev_handle* dev, int track, struct netmd_track* buffer)
{
int ret = 0;
int size = 0;
char request[] = {0x00, 0x18, 0x06, 0x02, 0x20, 0x10, 0x01, 0x00, 0x01, 0x30, 0x00, 0x01, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00};
char time_request[255];
request[8] = track;
ret = netmd_exch_message(dev, request, 0x13, time_request);
if(ret < 0)
{
fprintf(stderr, "bad ret code, returning early\n");
return 0;
}
size = ret;
buffer->minute = BCD_TO_PROPER(time_request[28]);
buffer->second = BCD_TO_PROPER(time_request[29]);
buffer->tenth = BCD_TO_PROPER(time_request[30]);
buffer->track = track;
return 1;
}
int netmd_stop(usb_dev_handle* dev)
{
int ret = 0;
char request[] = {0x00, 0x18, 0xc5, 0xff, 0x00, 0x00, 0x00, 0x00}; // Stop
int size;
char buf[255];
fprintf(stderr,"Stopping minidisc \n");
ret = netmd_exch_message(dev, request, 8, buf);
if(ret < 0)
{
fprintf(stderr, "bad ret code, returning early\n");
return 0;
}
size = ret;
if (size<1) {
fprintf(stderr, "Invalid size\n");
return -1;
}
return 1;
}
int netmd_create_group(usb_dev_handle* devh, char* name)
{
int disc_size;
int seperator = 0;
char* disc = malloc(sizeof(char) * 60);
char* new_title = 0;
char* p = 0;
char* request = 0;
char reply[255];
int ret;
char write_req[] = {0x00, 0x18, 0x07, 0x02, 0x20, 0x18, 0x01, 0x00, 0x00, 0x30, 0x00, 0x0a, 0x00, 0x50, 0x00, 0x00};
disc_size = request_disc_title(devh, disc, 60);
if(disc_size > 60)
{
disc = realloc(disc, disc_size);
disc_size = request_disc_title(devh, disc, 60);
}
seperator = strlen(disc);
if(disc[0] != '0')
{
disc_size += 2;
seperator += 2;
}
p = disc + strlen(disc) - 2;
if(strcmp(p, "//") != 0)
disc_size += 2;
/* need a ; // and name added */
disc_size += (strlen(name) + 3);
new_title = malloc(disc_size);
memset(new_title, 0, disc_size);
if(disc[0] != '0')
{
new_title[0] = '0';
new_title[1] = ';';
}
strcat(new_title, disc);
if(strcmp(p, "//") != 0)
{
strcat(new_title, "//");
seperator += 2;
}
new_title[seperator] = ';';
strcat(new_title, name);
strcat(new_title, "//");
printf("%s\n", new_title);
request = malloc(21 + disc_size);
memset(request, 0, 21 + disc_size);
memcpy(request, write_req, 16);
request[16] = disc_size;
request[20] = disc_size;
p = request + 21;
memcpy(p, new_title, disc_size);
ret = netmd_exch_message(devh, request, (int)(0x15 + disc_size), reply);
return ret;
}
int netmd_write_disc_header(usb_dev_handle* devh, minidisc *md)
{
int i;
int dash = 0;
int ret = 1;
int header_size = 0;
int tmp_size = 0;
char* header = 0;
char* tmp = 0;
char* request = 0;
char write_req[] = {0x00, 0x18, 0x07, 0x02, 0x20, 0x18, 0x01, 0x00, 0x00, 0x30, 0x00, 0x0a, 0x00, 0x50, 0x00, 0x00};
char reply[255];
/* calculate header length */
for(i = 0; i < md->group_count; i++)
{
if(md->groups[i].start < 100)
{
if(md->groups[i].start < 10)
header_size += 1;
else
header_size += 2;
}
else
header_size += 3;
if(md->groups[i].finish != 0)
{
if(md->groups[i].start < 100)
{
if(md->groups[i].start < 10)
header_size += 1;
else
header_size += 2;
}
else
header_size += 3;
header_size++; /* room for the - */
}
header_size += 3; /* room for the ; and // tokens */
header_size += strlen(md->groups[i].name);
}
header_size++;
/* printf("New header length - %i (%02x)\n", header_size, header_size); */
header = malloc(sizeof(char) * header_size);
memset(header, 0, header_size);
/* now generate the actual header from each group's info */
for(i = 0; i < md->group_count; i++)
{
dash = 0; /* no dash */
tmp_size = 0;
if(md->groups[i].start < 100)
{
if(md->groups[i].start < 10)
tmp_size += 1;
else
tmp_size += 2;
}
else
header_size += 3;
if(md->groups[i].finish != 0)
{
if(md->groups[i].start < 100)
{
if(md->groups[i].start < 10)
tmp_size += 1;
else
tmp_size += 2;
}
else
tmp_size += 3;
dash = 1;
tmp_size++; /* room for the - */
}
tmp_size += strlen(md->groups[i].name) + 3; /* name length + ; + // + NULL */
tmp = malloc((tmp_size + 2));
memset(tmp, 0, tmp_size);
/* if group starts at 0 and it isn't the disc name group */
if(md->groups[i].start == 0 && i != 0)
snprintf(tmp, tmp_size, ";%s//", md->groups[i].name);
else if(dash)
snprintf(tmp, tmp_size, "%i-%i;%s//", md->groups[i].start, md->groups[i].finish, md->groups[i].name);
else
snprintf(tmp, tmp_size, "%i;%s//", md->groups[i].start, md->groups[i].name);
strcat(header, tmp);
strcat(header, "/");
free(tmp);
}
request = malloc(header_size + 21);
memset(request, 0, header_size + 21);
memcpy(request, write_req, 16);
request[16] = (header_size - 1); /* new size - null */
request[20] = md->header_length; /* old size */
tmp = request + 21;
memcpy(tmp, header, header_size);
ret = netmd_exch_message(devh, request, (header_size + 20), reply);
free(request);
return ret;
}
