← Back to branch summary

~ubuntu-branches/debian/wheezy/libnjb/wheezy

« back to all changes in this revision

Viewing changes to src/protocol.c

  • Committer: Bazaar Package Importer
  • Author(s): Shaun Jackman
  • Date: 2004-12-26 15:21:09 UTC
  • mfrom: (1.1.1 upstream)
  • Revision ID: james.westby@ubuntu.com-20041226152109-1jp8ujo260tfmybi
Tags: 1.2-2
http://bugs.debian.org/287290
Synopses were incorrect (closes: #287290). 

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/protocol.c
1
 
#include "../config.h"
2
1
#include <stdio.h>
3
2
#include <stdlib.h>
4
3
#include <unistd.h>
5
4
#include <fcntl.h>
6
 
#include <sys/ioctl.h>
7
5
#include <string.h>
8
6
#include <errno.h>
9
7
#include "libnjb.h"
15
13
#include "ioutil.h"
16
14
#include "defs.h"
17
15
#include "base.h"
 
16
#include "eax.h"
18
17
 
19
18
extern int __sub_depth;
20
19
 
 
20
 
 
21
/**
 
22
 * Initializes the basic state of the njb->protocol_state for the
 
23
 * NJB1-device.
 
24
 */
 
25
int njb_init_state (njb_t *njb) {
 
26
  __dsub= "njb_init_state";
 
27
 
 
28
  njb_state_t *state;
 
29
 
 
30
  __enter;
 
31
 
 
32
  state = malloc(sizeof(njb_state_t));
 
33
  if (state == NULL) {
 
34
    __leave;
 
35
    return -1;
 
36
  }
 
37
 
 
38
  state->session_updated = 0;
 
39
  state->libcount = 0;
 
40
  state->first_eax = NULL;
 
41
  state->next_eax = NULL;
 
42
  state->reset_get_track_tag = 0;
 
43
  state->reset_get_playlist = 0;
 
44
  state->reset_get_datafile_tag = 0;
 
45
  njb->protocol_state = (unsigned char *) state;
 
46
 
 
47
  __leave;
 
48
  return 0;
 
49
}
 
50
 
21
51
/*
22
52
 * Beginning with firmware 2.93, very strange things started happening.
23
53
 * For certian functions, a non-zero status code does not automatically
37
67
        memset(data, 0, 8);
38
68
        from_64bit_to_njb1_bytes(count, &data[0]);
39
69
 
40
 
        if ( usb_setup(&njb->ctl, UT_WRITE_VENDOR_OTHER,
 
70
        if ( usb_setup(njb, UT_WRITE_VENDOR_OTHER,
41
71
                NJB_CMD_SET_LIBRARY_COUNTER, 0, 0, 8, data) == -1 ) {
42
72
 
43
73
                NJB_ERROR(EO_USBCTL);
62
92
        memset(lcount, 0, sizeof(njblibctr_t));
63
93
        memset(data, 0, 25);
64
94
        
65
 
        if ( usb_setup(&njb->ctl, UT_READ_VENDOR_OTHER,
 
95
        if ( usb_setup(njb, UT_READ_VENDOR_OTHER,
66
96
                NJB_CMD_GET_LIBRARY_COUNTER, 0, 0, 25, data) == -1 ) {
67
97
                NJB_ERROR(EO_USBCTL);
68
98
                __leave;
99
129
        
100
130
        memset(data, 0, 58);
101
131
 
102
 
        if ( usb_setup(&njb->ctl, UT_WRITE_VENDOR_OTHER,
 
132
        if ( usb_setup(njb, UT_WRITE_VENDOR_OTHER,
103
133
                NJB_CMD_PING, 0, 0, 0, NULL) == -1 ) {
104
134
                NJB_ERROR(EO_USBCTL);
105
135
                __leave;
150
180
 
151
181
        __enter;
152
182
 
153
 
        if ( usb_setup(&njb->ctl, UT_READ_VENDOR_OTHER,
 
183
        if ( usb_setup(njb, UT_READ_VENDOR_OTHER,
154
184
                NJB_CMD_VERIFY_LAST_CMD, 0, 0, 1, &data) == -1 ) {
155
185
 
156
186
                NJB_ERROR(EO_USBCTL);
178
208
 
179
209
        __enter;
180
210
 
181
 
        if ( usb_setup(&njb->ctl, UT_READ_VENDOR_OTHER,
 
211
        if ( usb_setup(njb, UT_READ_VENDOR_OTHER,
182
212
                mode, 0, 0, 1, &data) == -1 ) {
183
213
 
184
214
                NJB_ERROR(EO_USBCTL);
205
235
 
206
236
        memset(data, 0, 9);
207
237
        
208
 
        if ( usb_setup(&njb->ctl, UT_READ_VENDOR_OTHER, cmd, 0, 0, 9, data)
 
238
        if ( usb_setup(njb, UT_READ_VENDOR_OTHER, cmd, 0, 0, 9, data)
209
239
                 == -1 ) {
210
240
 
211
241
                NJB_ERROR(EO_USBCTL);
252
282
        lsw= get_lsw(tagh->trackid);
253
283
        msw= get_msw(tagh->trackid);
254
284
 
255
 
        if ( usb_setup(&njb->ctl, UT_WRITE_VENDOR_OTHER,
 
285
        if ( usb_setup(njb, UT_WRITE_VENDOR_OTHER,
256
286
                NJB_CMD_GET_TRACK_TAG, msw, lsw, 0, NULL) == -1 ) {
257
287
                NJB_ERROR(EO_USBCTL);
258
288
                free(data);
287
317
 
288
318
        memset(data, 0, 9);
289
319
        
290
 
        if ( usb_setup(&njb->ctl, UT_READ_VENDOR_OTHER, cmd, 0, 0, 9, data)
 
320
        if ( usb_setup(njb, UT_READ_VENDOR_OTHER, cmd, 0, 0, 9, data)
291
321
                 == -1 ) {
292
322
 
293
323
                NJB_ERROR(EO_USBCTL);
338
368
        lsw= get_lsw(plh->plid);
339
369
        msw= get_msw(plh->plid);
340
370
 
341
 
        if ( usb_setup(&njb->ctl, UT_WRITE_VENDOR_OTHER,
 
371
        if ( usb_setup(njb, UT_WRITE_VENDOR_OTHER,
342
372
                NJB_CMD_GET_PLAYLIST, msw, lsw, 0, NULL) == -1 ) {
343
373
 
344
374
                NJB_ERROR(EO_USBCTL);
378
408
 
379
409
        memset(data, 0, 17);
380
410
        
381
 
        if ( usb_setup(&njb->ctl, UT_READ_VENDOR_OTHER,
 
411
        if ( usb_setup(njb, UT_READ_VENDOR_OTHER,
382
412
                NJB_CMD_GET_DISK_USAGE, 0, 0, 17, data) == -1 ) {
383
413
 
384
414
                NJB_ERROR(EO_USBCTL);
412
442
        __enter;
413
443
 
414
444
        memset(data,0,OWNER_STRING_LENGTH+1);
415
 
        if ( usb_setup(&njb->ctl, UT_WRITE_VENDOR_OTHER,
 
445
        if ( usb_setup(njb, UT_WRITE_VENDOR_OTHER,
416
446
                NJB_CMD_GET_OWNER_STRING, 0, 0, 0, NULL) == -1 ) {
417
447
 
418
448
                NJB_ERROR(EO_USBCTL);
451
481
 
452
482
        __enter;
453
483
 
454
 
        if ( usb_setup(&njb->ctl, UT_WRITE_VENDOR_OTHER,
 
484
        if ( usb_setup(njb, UT_WRITE_VENDOR_OTHER,
455
485
                NJB_CMD_SET_OWNER_STRING, 0, 0, 0, NULL) == -1 ) {
456
486
 
457
487
                NJB_ERROR(EO_USBCTL);
485
515
 
486
516
        memset(data, 0, 9);
487
517
        
488
 
        if ( usb_setup(&njb->ctl, UT_READ_VENDOR_OTHER, cmd, 0, 0, 9, data)
 
518
        if ( usb_setup(njb, UT_READ_VENDOR_OTHER, cmd, 0, 0, 9, data)
489
519
                 == -1 ) {
490
520
 
491
521
                NJB_ERROR(EO_USBCTL);
532
562
        lsw= get_lsw(dfh->dfid);
533
563
        msw= get_msw(dfh->dfid);
534
564
 
535
 
        if ( usb_setup(&njb->ctl, UT_WRITE_VENDOR_OTHER,
 
565
        if ( usb_setup(njb, UT_WRITE_VENDOR_OTHER,
536
566
                NJB_CMD_GET_DATAFILE_TAG, msw, lsw, 0, NULL) == -1 ) {
537
567
 
538
568
                NJB_ERROR(EO_USBCTL);
563
593
        return df;
564
594
}
565
595
 
566
 
/*
 
596
/**
567
597
 * offset    is the offset into the file, starting at 0.
568
598
 * bsize     indicates the recieved buffer max size.
569
599
 * bp        points to the recieve buffer
570
 
 *           (atleast MAX_XFER_BLOCK_SIZE + XFER_BLOCK_HEADER_SIZE)
 
600
 *           (atleast NJB_XFER_BLOCK_SIZE + NJB_XFER_BLOCK_HEADER_SIZE)
571
601
 * lastsort  indicates if last transfer was short (ended before
572
602
 *           requested number of bytes were recieved).
573
603
 *
587
617
        __enter;
588
618
 
589
619
        /* Too large transfer requested */
590
 
        if ( bsize > MAX_XFER_BLOCK_SIZE ) {
 
620
        if ( bsize > NJB_XFER_BLOCK_SIZE ) {
591
621
                NJB_ERROR(EO_TOOBIG);
592
622
                __leave;
593
623
                return -1;
601
631
        from_32bit_to_njb1_bytes(offset, &filedata[0]);
602
632
        from_32bit_to_njb1_bytes(bsize, &filedata[4]);
603
633
 
604
 
        if ( usb_setup(&njb->ctl, UT_WRITE_VENDOR_OTHER,
 
634
        if ( usb_setup(njb, UT_WRITE_VENDOR_OTHER,
605
635
                       NJB_CMD_RECEIVE_FILE_BLOCK, 0, 0, 8, filedata) == -1 ) {
606
636
          
607
637
          NJB_ERROR(EO_USBCTL);
610
640
        }
611
641
 
612
642
        /* Read the status and block header first */
613
 
        if ( (bread = usb_pipe_read(njb, bp, bsize + XFER_BLOCK_HEADER_SIZE)) == -1 ) {
 
643
        if ( (bread = usb_pipe_read(njb, bp, bsize + NJB_XFER_BLOCK_HEADER_SIZE)) == -1 ) {
614
644
          NJB_ERROR(EO_USBBLK);
615
645
          __leave;
616
646
          return -1;
617
 
        } else if ( bread < bsize + XFER_BLOCK_HEADER_SIZE ) {
 
647
        } else if ( bread < bsize + NJB_XFER_BLOCK_HEADER_SIZE ) {
618
648
          /* This was a short transfer, OK... */
619
649
          /* printf("Short transfer on pipe.\n"); */
620
650
        }
641
671
        memset(data, 0, 4);
642
672
        from_32bit_to_njb1_bytes(fileid, &data[0]);
643
673
 
644
 
        if ( usb_setup(&njb->ctl, UT_WRITE_VENDOR_OTHER,
 
674
        if ( usb_setup(njb, UT_WRITE_VENDOR_OTHER,
645
675
                NJB_CMD_REQUEST_TRACK, 1, 0, 4, data) == -1 ) {
646
676
                NJB_ERROR(EO_USBCTL);
647
677
                __leave;
659
689
 
660
690
        __enter;
661
691
 
662
 
        if ( usb_setup(&njb->ctl, UT_READ_VENDOR_OTHER,
 
692
        if ( usb_setup(njb, UT_READ_VENDOR_OTHER,
663
693
                NJB_CMD_TRANSFER_COMPLETE, 0, 0, 1, &data) == -1 ) {
664
694
 
665
695
                NJB_ERROR(EO_USBCTL);
691
721
        
692
722
        from_32bit_to_njb1_bytes(tagh->size, &utagsz[0]);
693
723
 
694
 
        if ( usb_setup(&njb->ctl, UT_WRITE_VENDOR_OTHER,
 
724
        if ( usb_setup(njb, UT_WRITE_VENDOR_OTHER,
695
725
                NJB_CMD_SEND_TRACK_TAG, 0, 0, 4, utagsz) == -1 ) {
696
726
 
697
727
                NJB_ERROR(EO_USBCTL);
746
776
        memset(utagsz, 0, 4);
747
777
        memset(data, 0, 5);
748
778
 
749
 
        from_32bit_to_njb1_bytes(dfh->size, &utagsz[0]);
 
779
        /* Add five here for the header overhead */
 
780
        from_32bit_to_njb1_bytes(dfh->size+5, &utagsz[0]);
750
781
 
751
 
        if ( usb_setup(&njb->ctl, UT_WRITE_VENDOR_OTHER,
 
782
        if ( usb_setup(njb, UT_WRITE_VENDOR_OTHER,
752
783
                NJB_CMD_SEND_DATAFILE_TAG, 0, 0, 4, utagsz) == -1 ) {
753
784
 
754
785
                NJB_ERROR(EO_USBCTL);
788
819
 
789
820
        /* Read back datafile ID */
790
821
 
791
 
        bread= usb_pipe_read(njb, data, 5);
 
822
        bread = usb_pipe_read(njb, data, 5);
792
823
        if ( bread == -1 ) {
793
824
                NJB_ERROR(EO_USBBLK);
794
825
                __leave;
812
843
}
813
844
 
814
845
/*
815
 
 * This function transfers a block of <= MAX_XFER_BLOCK_SIZE to the
 
846
 * This function transfers a block of <= NJB_XFER_BLOCK_SIZE to the
816
847
 * jukebox and returns the number of bytes actually sent. Short transfers
817
848
 * are OK but must be accounted for.
818
849
 */
829
860
 
830
861
        __enter;
831
862
 
832
 
        if ( blocksize > MAX_XFER_BLOCK_SIZE ) {
 
863
        if ( blocksize > NJB_XFER_BLOCK_SIZE ) {
833
864
                NJB_ERROR(EO_TOOBIG);
834
865
                __leave;
835
866
                return -1;
844
875
          /* Only if something fails, retry */
845
876
          retry = 0;
846
877
 
847
 
          if ( usb_setup(&njb->ctl, UT_READ_VENDOR_OTHER,
 
878
          if ( usb_setup(njb, UT_READ_VENDOR_OTHER,
848
879
                         NJB_CMD_SEND_FILE_BLOCK, lsw, msw, 1, &status)
849
880
               == -1 ) {
850
881
            
896
927
 
897
928
        __enter;
898
929
 
899
 
        if ( usb_setup(&njb->ctl, UT_READ_VENDOR_OTHER,
 
930
        if ( usb_setup(njb, UT_READ_VENDOR_OTHER,
900
931
                NJB_CMD_STOP_PLAY, 0, 0, 1, &data) == -1 ) {
901
932
 
902
933
                NJB_ERROR(EO_USBCTL);
923
954
 
924
955
        memset(data, 0, 5);
925
956
        
926
 
        if ( usb_setup(&njb->ctl, UT_READ_VENDOR_OTHER,
 
957
        if ( usb_setup(njb, UT_READ_VENDOR_OTHER,
927
958
                NJB_CMD_GET_EAX_SIZE, 0, 0, 5, data) == -1 ) {
928
959
 
929
960
                NJB_ERROR(EO_USBCTL);
943
974
        return 0;
944
975
}
945
976
 
 
977
/* This is an old, deprecated routine */
946
978
eax_t *njb_get_eax (njb_t *njb, u_int32_t size)
947
979
{
948
980
        __dsub= "njb_get_eax";
965
997
        
966
998
        from_32bit_to_njb1_bytes(size, &usize[0]);
967
999
 
968
 
        if ( usb_setup(&njb->ctl, UT_WRITE_VENDOR_OTHER, NJB_CMD_GET_EAX,
 
1000
        if ( usb_setup(njb, UT_WRITE_VENDOR_OTHER, NJB_CMD_GET_EAX,
969
1001
                0, 0, 4, usize) == -1 ) {
970
1002
 
971
1003
                NJB_ERROR(EO_USBCTL);
1006
1038
        return eax;
1007
1039
}
1008
1040
 
 
1041
/* This is the new EAX API */
 
1042
void njb_read_eaxtypes (njb_t *njb, u_int32_t size)
 
1043
{
 
1044
  __dsub= "njb_read_eaxtypes";
 
1045
 
 
1046
  njb_state_t *state = (njb_state_t *) njb->protocol_state;
 
1047
  unsigned char *data;
 
1048
  ssize_t bread;
 
1049
  u_int32_t actsize;
 
1050
  unsigned char usize[4];
 
1051
 
 
1052
  __enter;
 
1053
 
 
1054
  data = (unsigned char *) malloc(size);
 
1055
  if ( data == NULL ) {
 
1056
    NJB_ERROR(EO_NOMEM);
 
1057
    __leave;
 
1058
    return;
 
1059
  }
 
1060
  memset(data, 0, size);
 
1061
  memset(usize, 0, 4);
 
1062
        
 
1063
  from_32bit_to_njb1_bytes(size, &usize[0]);
 
1064
 
 
1065
  if ( usb_setup(njb, UT_WRITE_VENDOR_OTHER, NJB_CMD_GET_EAX,
 
1066
                 0, 0, 4, usize) == -1 ) {
 
1067
    
 
1068
    NJB_ERROR(EO_USBCTL);
 
1069
    free(data);
 
1070
    __leave;
 
1071
    return;
 
1072
  }
 
1073
 
 
1074
  bread = usb_pipe_read(njb, data, size+5);
 
1075
  if ( bread == -1 ) {
 
1076
    NJB_ERROR(EO_USBBLK);
 
1077
    free(data);
 
1078
    __leave;
 
1079
    return;
 
1080
  } else if ( bread < size ) {
 
1081
    NJB_ERROR(EO_RDSHORT);
 
1082
    free(data);
 
1083
    __leave;
 
1084
    return;
 
1085
  }
 
1086
 
 
1087
  if ( data[0] ) {
 
1088
    NJB_STATUS((int) data[0]);
 
1089
    free(data);
 
1090
    __leave;
 
1091
    return;
 
1092
  }
 
1093
 
 
1094
  actsize = njb1_bytes_to_32bit(&data[1]);
 
1095
 
 
1096
  /* Unpack the EAX structure */
 
1097
  eax_unpack_new_api(&data[5], actsize, state);
 
1098
 
 
1099
  free(data);
 
1100
 
 
1101
  __leave;
 
1102
  return;
 
1103
}
 
1104
 
 
1105
njb_eax_t *njb_get_nexteax(njb_t *njb)
 
1106
{
 
1107
  njb_state_t *state = (njb_state_t *) njb->protocol_state;
 
1108
  njb_eax_t *ret;
 
1109
 
 
1110
  ret = state->next_eax;
 
1111
  if (ret != NULL) {
 
1112
    state->next_eax = ret->next;
 
1113
  }
 
1114
  return ret;
 
1115
}
 
1116
 
 
1117
/* This routine is dangerous. Do not call it... */
1009
1118
int njb_refresh_eax(njb_t *njb, eax_t *eax)
1010
1119
{
1011
1120
        __dsub= "njb_refresh_eax";
1023
1132
        }
1024
1133
        memset(data, 0, 4);
1025
1134
        
1026
 
        if ( usb_setup(&njb->ctl, UT_WRITE_VENDOR_OTHER,
 
1135
        if ( usb_setup(njb, UT_WRITE_VENDOR_OTHER,
1027
1136
                        NJB_CMD_GET_EAX, 1, 0, 4, data) == -1 ) {
1028
1137
                NJB_ERROR(EO_USBCTL);
1029
1138
                free(data);
1091
1200
        }
1092
1201
        memset(data, 0, 17);
1093
1202
        
1094
 
        if ( usb_setup(&njb->ctl, UT_READ_VENDOR_OTHER,
 
1203
        if ( usb_setup(njb, UT_READ_VENDOR_OTHER,
1095
1204
                        NJB_CMD_GET_TIME, 0, 0, 17, data) == -1 ) {
1096
1205
                NJB_ERROR(EO_USBCTL);
1097
1206
                free(data);
1124
1233
                return -1;
1125
1234
        }
1126
1235
 
1127
 
        if ( usb_setup(&njb->ctl, UT_WRITE_VENDOR_OTHER,
 
1236
        if ( usb_setup(njb, UT_WRITE_VENDOR_OTHER,
1128
1237
                NJB_CMD_SET_TIME, 0, 0, 16, data) == -1 ) {
1129
1238
 
1130
1239
                NJB_ERROR(EO_USBCTL);
1159
1268
        msw= get_msw( (u_int32_t) size );
1160
1269
        lsw= get_lsw( (u_int32_t) size );
1161
1270
 
1162
 
        if ( usb_setup(&njb->ctl, UT_WRITE_VENDOR_OTHER,
 
1271
        if ( usb_setup(njb, UT_WRITE_VENDOR_OTHER,
1163
1272
                NJB_CMD_CREATE_PLAYLIST, lsw, msw, 0, NULL) == -1 ) {
1164
1273
                NJB_ERROR(EO_USBCTL);
1165
1274
                __leave;
1211
1320
        msw= get_msw(plid);
1212
1321
        lsw= get_lsw(plid);
1213
1322
 
1214
 
        if ( usb_setup(&njb->ctl, UT_READ_VENDOR_OTHER,
 
1323
        if ( usb_setup(njb, UT_READ_VENDOR_OTHER,
1215
1324
                NJB_CMD_DELETE_PLAYLIST, msw, lsw, 1, &data) == -1 ) {
1216
1325
 
1217
1326
                NJB_ERROR(EO_USBCTL);
1250
1359
        from_32bit_to_njb1_bytes(plid, &data[0]);
1251
1360
        from_32bit_to_njb1_bytes(size, &data[4]);
1252
1361
 
1253
 
        if ( usb_setup(&njb->ctl, UT_WRITE_VENDOR_OTHER,
 
1362
        if ( usb_setup(njb, UT_WRITE_VENDOR_OTHER,
1254
1363
                NJB_CMD_RENAME_PLAYLIST, 0, 0, 8, data) == -1 ) {
1255
1364
 
1256
1365
                NJB_ERROR(EO_USBCTL);
1284
1393
        from_32bit_to_njb1_bytes(trid, &data[2]);
1285
1394
        from_32bit_to_njb1_bytes(plid, &data[6]);
1286
1395
 
1287
 
        if ( usb_setup(&njb->ctl, UT_WRITE_VENDOR_OTHER,
 
1396
        if ( usb_setup(njb, UT_WRITE_VENDOR_OTHER,
1288
1397
                NJB_CMD_ADD_TRACK_TO_PLAYLIST, 0, 0, 10, data) == -1 ) {
1289
1398
 
1290
1399
                NJB_ERROR(EO_USBCTL);
1329
1438
        from_32bit_to_njb1_bytes(plid, &data[0]);
1330
1439
        from_16bit_to_njb1_bytes(ntracks, &data[4]);
1331
1440
 
1332
 
        if ( usb_setup(&njb->ctl, UT_WRITE_VENDOR_OTHER,
 
1441
        if ( usb_setup(njb, UT_WRITE_VENDOR_OTHER,
1333
1442
                NJB_CMD_ADD_MULTIPLE_TRACKS_TO_PLAYLIST, 0, 0, 6, data) 
1334
1443
                == -1 ) {
1335
1444
 
1369
1478
        msw= get_msw(trackid);
1370
1479
        lsw= get_lsw(trackid);
1371
1480
 
1372
 
        if ( usb_setup(&njb->ctl, UT_READ_VENDOR_OTHER,
 
1481
        if ( usb_setup(njb, UT_READ_VENDOR_OTHER,
1373
1482
                NJB_CMD_DELETE_TRACK, msw, lsw, 1, &data) == -1 ) {
1374
1483
                NJB_ERROR(EO_USBCTL);
1375
1484
                __leave;
1397
1506
        msw= get_msw(fileid);
1398
1507
        lsw= get_lsw(fileid);
1399
1508
 
1400
 
        if ( usb_setup(&njb->ctl, UT_READ_VENDOR_OTHER,
 
1509
        if ( usb_setup(njb, UT_READ_VENDOR_OTHER,
1401
1510
                NJB_CMD_DELETE_DATAFILE, msw, lsw, 1, &data) == -1 ) {
1402
1511
                NJB_ERROR(EO_USBCTL);
1403
1512
                __leave;
1425
1534
        
1426
1535
        from_32bit_to_njb1_bytes(trackid, &data[0]);
1427
1536
 
1428
 
        if ( usb_setup(&njb->ctl, UT_WRITE_VENDOR_OTHER, cmd, 0, 0, 4, data)
 
1537
        if ( usb_setup(njb, UT_WRITE_VENDOR_OTHER, cmd, 0, 0, 4, data)
1429
1538
                 == -1 ) {
1430
1539
 
1431
1540
                NJB_ERROR(EO_USBCTL);
1446
1555
 
1447
1556
        memset(data, 0, 3);
1448
1557
        
1449
 
        if ( usb_setup(&njb->ctl, UT_READ_VENDOR_OTHER,
 
1558
        if ( usb_setup(njb, UT_READ_VENDOR_OTHER,
1450
1559
                NJB_CMD_ELAPSED_TIME, 0, 0, 3, data) == -1 ) {
1451
1560
                NJB_ERROR(EO_USBCTL);
1452
1561
                __leave;
1492
1601
        from_32bit_to_njb1_bytes(tagh->trackid, &data[0]);
1493
1602
        memcpy(&data[4], tag, tagh->size);
1494
1603
 
1495
 
        if ( usb_setup(&njb->ctl, UT_WRITE_VENDOR_OTHER,
 
1604
        if ( usb_setup(njb, UT_WRITE_VENDOR_OTHER,
1496
1605
                NJB_CMD_REPLACE_TRACK_TAG, lsw, msw, 0, NULL) == -1 ) {
1497
1606
 
1498
1607
                NJB_ERROR(EO_USBCTL);
1519
1628
        return 0;
1520
1629
}
1521
1630
 
1522
 
int njb_adjust_sound(njb_t *njb, u_int8_t effect, u_int16_t value)
 
1631
int njb_adjust_sound(njb_t *njb, u_int8_t effect, int16_t value)
1523
1632
{
1524
1633
        __dsub= "njb_adjust_sound";
1525
1634
        unsigned char data[3];
 
1635
        u_int16_t sendvalue = ((u_int16_t) value) & 0xff;
1526
1636
 
1527
1637
        __enter;
1528
1638
 
1529
1639
        memset(data, 0, 3);
1530
 
 
1531
1640
        data[0] = effect;
1532
 
        from_16bit_to_njb1_bytes(value, &data[1]);
1533
 
 
1534
 
        if ( usb_setup(&njb->ctl, UT_WRITE_VENDOR_OTHER,
 
1641
 
 
1642
        printf("Effect %d, sending value %d (%04X)\n", effect, sendvalue, sendvalue);
 
1643
 
 
1644
        from_16bit_to_njb1_bytes(sendvalue, &data[1]);
 
1645
 
 
1646
        if ( usb_setup(njb, UT_WRITE_VENDOR_OTHER,
1535
1647
                NJB_CMD_ADJUST_SOUND, 0, 0, 3, data) == -1 ) {
1536
1648
                NJB_ERROR(EO_USBCTL);
1537
1649
                __leave;