Linux BlueZ PCM 音频播放器

http://blog.linuxpk.com/25219/viewspace-7836.html

自己写的简单的实验代码，贴上来看看，有兴趣的话，大家可以交流
/******************************************************************************/
/**                                                                                                                           **/
/**                         MODULES USED                                                                  **/
/**                                                                                                                            **/
/******************************************************************************/
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include "msgqueue.h"
/******************************************************************************/
/**                                                                                                                           **/
/**                         DEFINITIONS AND MACROS                                              **/
/**                                                                                                                           **/
/******************************************************************************/
#define DONGLE_ADDR  "00:11:67:58:D1:0F"     /*ISSC*/
#define HEAD_SET_ADDR "83:82:5B:00:A5:A3"     /*NK-808 channel 1*/
#define HEAD_SET_CHAN   1

//#define PCM_DATA_PATH   "/tmp/sco.dat"
//#define PCM_DATA_PATH   "/mnt/heart.pcm"
#define PCM_DATA_PATH   "/mnt/tianhou.pcm"

#define RECV_BUFFER     64
#define SEND_BUFFER     64

typedef pthread_t thread_T;
typedef void *(*pthread_startroutine_t) (void *);
typedef void *pthread_addr_t;
typedef void threadArg_T;
typedef void (*threadFunc_T)(void *);

/*debugging micro*/
#ifdef ENABLE_DEBUG
int DebugEnabled = 0;
#else
#define DebugEnabled    1
#endif
#define DDBG(fmts)  if(DebugEnabled)printf(fmts)
#define DBG(fmts,args) if(DebugEnabled)printf(fmts,args)
#define DBG2(fmts,arg1,arg2) if(DebugEnabled)printf(fmts,arg1,arg2)
/******************************************************************************/
/**                                                                                                                           **/
/**                            TYPEDEF AND STRUCTURE                                          **/
/**                                                                                                                            **/
/******************************************************************************/
struct _dongle_priv {
    int hci_sock;
    int sco_sock;
    int device_channel;
    char ag_addr[20];  /* adddress of adapter */
    char hs_addr[20];
    unsigned char isServiceConnected;
    char isScoConnected;
    char isRunning;
    char callSetup;
    char callAccept; 

};
typedef struct _dongle_priv bt_data;
/******************************************************************************/
/**                                                                                                                           **/
/**                            GLOBAL VARIABLES                                                         **/
/**                                                                                                                            **/
/******************************************************************************/
bt_data * BTd;
static sem_t   Sem;
/******************************************************************************/
/**                                                                                                                           **/
/**                         LOCAL FUNCTIONS                                                             **/
/**                                                                                                                            **/
/******************************************************************************/
thread_T thread_create(int priority, threadFunc_T startFunc, threadArg_T *arg)
{
    thread_T             thread;
    pthread_attr_t       thread_attr;
    struct sched_param   param;

    pthread_attr_init(&thread_attr);
    /* pthread_attr_setinheritsched(PTHREAD_EXPLICT_SCHED); */
    pthread_attr_setdetachstate(&thread_attr, PTHREAD_CREATE_DETACHED);

    param.sched_priority = priority;
    pthread_attr_setschedparam(&thread_attr, ¶m);

    pthread_create(&thread, &thread_attr, (pthread_startroutine_t)startFunc,
                   (pthread_addr_t)arg);
    return(thread);
}

void set_bit(int offset)
{
    BTd->isServiceConnected |= (0x01<}

static int rfcomm_connect(bdaddr_t * src, bdaddr_t * dst, uint8_t channel)
{
 struct sockaddr_rc addr;
 int s;

 if ((s = socket(PF_BLUETOOTH, SOCK_STREAM, BTPROTO_RFCOMM)) < 0) {
  return -1;
 }

 memset(&addr, 0, sizeof(addr));
 addr.rc_family = AF_BLUETOOTH;
 bacpy(&addr.rc_bdaddr, src);
 addr.rc_channel = 0;
 if (bind(s, (struct sockaddr *)&addr, sizeof(addr)) < 0) {
  printf("rfcomm bind error\n");
  close(s);
  return -1;
 }

 memset(&addr, 0, sizeof(addr));
 addr.rc_family = AF_BLUETOOTH;
 bacpy(&addr.rc_bdaddr, dst);
 addr.rc_channel = channel;
 if (connect(s, (struct sockaddr *)&addr, sizeof(addr)) < 0) {
  printf("rfcomm connect error\n");
  close(s);
  return -1;
 } else{
  printf("connecting successfully sock %d\n",s);
 }

 return s;
}

static int sco_connect(bdaddr_t *src, bdaddr_t *dst)
{

 struct sockaddr_sco addr;
 //struct sco_conninfo conn;
 //struct sco_options opts;
 int s;

 if ((s = socket(PF_BLUETOOTH, SOCK_SEQPACKET, BTPROTO_SCO)) < 0) {
  return -1;
  }
 memset(&addr, 0, sizeof(addr));
 addr.sco_family = AF_BLUETOOTH;
 bacpy(&addr.sco_bdaddr, src);
 if (bind(s, (struct sockaddr *)&addr, sizeof(addr)) < 0) {
  close(s);
  return -1;
  }
 memset(&addr, 0, sizeof(addr));
 addr.sco_family = AF_BLUETOOTH;
 bacpy(&addr.sco_bdaddr, dst);
 if (connect(s, (struct sockaddr *)&addr, sizeof(addr)) < 0 ){
  close(s);
  printf("sco connecting failed\n");
  return -1;
  }

 return s;
}

static int start_rfcomm_link(char *dst , char *src , int channel)
{
    bdaddr_t usb_dongle_addr,head_set_addr; 
    int fd;
   
    if (!dst||!src){
        return -1;
    }

    str2ba(src,&usb_dongle_addr);
 str2ba(dst,&head_set_addr);
 
    fd = rfcomm_connect(&usb_dongle_addr,&head_set_addr,channel);

    return fd;

}

static int start_sco_link(char *dst , char *src)
{
    bdaddr_t usb_dongle_addr,head_set_addr; 
    int fd;

    //uint16_t sco_handle, sco_mtu;

   
    if (!dst||!src){
        return -1;
    }

    str2ba(src,&usb_dongle_addr);
 str2ba(dst,&head_set_addr);
 
    fd = sco_connect(&usb_dongle_addr,&head_set_addr);

    return fd;

}

static int cind_cmd_str(char *cmd)
{
    if (!cmd){
        return -1;
    }

    memset(cmd,0,sizeof(cmd));
    strcpy(cmd,"\r\n+CIND:(\"service\",(0,1)),(\"call\",(0,1)),(\"callsetup\",(0,3)),(\"signal\",(0-5)),(\"roam\",(0-1))\r\n");
    return 0;
          
}

static int at_rx(int fd_at, char *receive)
{
    int retval,ret;
    fd_set rfds;
 struct timeval tv;

 FD_ZERO(&rfds);
 FD_SET(fd_at, &rfds);
 tv.tv_sec = 0;
 tv.tv_usec = 5000;
   

    if (!receive){
        return -1;
    }

    memset(receive,0,sizeof(receive));

 if ((retval = select(fd_at+1, &rfds, NULL, NULL, &tv)) > 0){ 
     memset(receive,0,RECV_BUFFER);
  ret = read(fd_at,receive,RECV_BUFFER);
        if (ret > 0){
            DBG("recving from headset %s\n",receive);
           
        } else if (-1 == ret){
            close(fd_at);
            BTd->isRunning = 0;
        }
 } else if (!retval){
     //DDBG("time out\n");
 }
    
 return 0;   
   
}

static int at_tx(int fd_at,char* send)
{ 

 if (strlen(send)){
     DBG("AG Sending %s\n",send);
     write(fd_at,send,strlen(send));
 }

    
 return 0;
}

static int at_txrx(int fd_at,char* send, char *receive)
{ 
 int ret = 0;
 fd_set rfds;
 struct timeval tv;
 int retval;
   
 FD_ZERO(&rfds);
 FD_SET(fd_at, &rfds);
 tv.tv_sec = 3;
 tv.tv_usec = 0;

 memset(receive,0,sizeof(receive));

 if (strlen(send)){
     DBG("AG Sending %s\n",send);
     write(fd_at,send,strlen(send));
 }

 if ((retval = select(fd_at+1, &rfds, NULL, NULL, &tv)) > 0){ 
     memset(receive,0,RECV_BUFFER);
  ret = read(fd_at,receive,RECV_BUFFER);
        if (ret){
            DBG("[at_rxtx]recving from headset %s\n",receive);
        }
 } else if (!retval){
     //DDBG("time out\n");
 }
    
 return 0;
}

static void monitor_headset(int fd_rfcomm)
{
    char recv_buf[RECV_BUFFER] = {0};
    char send_buf[SEND_BUFFER] = {0};

   
    while (1 == BTd->isRunning){
        at_rx(fd_rfcomm, recv_buf);

        if (strstr(recv_buf,"AT+BRSF")){
            at_tx(fd_rfcomm,"\r\n+BRSF:49\r");
            at_tx(fd_rfcomm,"\r\nOK\r\n");
            set_bit(0);
            continue;
        }

        if (strstr(recv_buf,"AT+CIND=?")){
            cind_cmd_str(send_buf);
            at_tx(fd_rfcomm,send_buf);
            at_tx(fd_rfcomm,"\r\nOK\r\n");
            set_bit(1);
            continue;
        }

        if (strstr(recv_buf,"AT+CIND")){
            at_tx(fd_rfcomm,"\r\n+CIND:1,0,0,2,0\r\n");
            at_tx(fd_rfcomm,"\r\nOK\r\n");   
            set_bit(2);
            continue;
        }

        if (strstr(recv_buf,"AT+CMER")){
            at_tx(fd_rfcomm,"\r\nOK\r\n");   
            set_bit(3);
            continue;
        }
        //Standard call hold and multiparty handling AT command
        if (strstr(recv_buf,"AT+CHLD")){
            at_tx(fd_rfcomm,"\r\n+CHLD:0\r\n");           
            at_tx(fd_rfcomm,"\r\nOK\r\n");
            set_bit(4);
            continue;
        }
        //Standard “Call Waiting notification” AT command
        if (strstr(recv_buf,"AT+CCWA")){
            at_tx(fd_rfcomm,"\r\nOK\r\n");   
            set_bit(5);
            continue;
        }
        //volume setting
        if (strstr(recv_buf,"AT+VGS")){      
            at_tx(fd_rfcomm,"\r\nOK\r\n");   
            set_bit(6);
            continue;           
        }
        //volume setting
        if (strstr(recv_buf,"AT+VGM")){        
            at_tx(fd_rfcomm,"\r\nOK\r\n");  
            set_bit(7);
            continue;           
        }

        if (strstr(recv_buf,"ATA")){
            //CallingAccept = 1;
            BTd->callAccept = 1;
            DDBG("ATA is received\n");
            at_tx(fd_rfcomm,"\r\nOK\r\n"); 
            at_tx(fd_rfcomm,"\r\n+CIEV=2,1\r\n");   
            continue;

        }
       
    }  
}

static void audio_loop(int fd_sco)
{   
    char recv_buf[RECV_BUFFER] = {0};
    int retval,ret;
    fd_set rfds;
 struct timeval tv;

 FD_ZERO(&rfds);
 FD_SET(fd_sco, &rfds);
 tv.tv_sec = 3;
 tv.tv_usec = 0;
 memset(recv_buf,0,RECV_BUFFER);
 if ((retval = select(fd_sco+1, &rfds, NULL, NULL, &tv)) > 0){ 
  ret = read(fd_sco,recv_buf,1023);
        if (ret){
            //DBG("recving from headset %s\n",receive);
            //DBG("recv_length %d\n",ret);
            //DBG("%x\n",recv_buf);           
        }
        write(fd_sco,recv_buf,ret);
 } else if (!retval){
     //DDBG("time out\n");
 }
}

static int get_file_size(char *file_path)
{
    FILE * fd;
    int start,end,fileLen;

    fd = fopen(file_path,"r");

    if (fd){   
        fseek(fd, 0, SEEK_SET);
     start = ftell(fd);
     fseek(fd, 0, SEEK_END);
     end = ftell(fd);
     fileLen = end - start + 1;
     /*move to the head*/
        fseek(fd, 0, SEEK_SET);
     DBG("audio fileLength %d\n",fileLen);
     fclose(fd);
     return fileLen;
 } else{
     return -1;
 }

}

static unsigned char * fill_pcm_buffer(char * pcm_file_path,int *length)
{
    int size = 0;
    FILE *fd;
    unsigned char * pcmDataPtr;

    if (!pcm_file_path){
        return NULL;
    }

    size = get_file_size(pcm_file_path);
   
    if (size > 0){
        *length = size;
        pcmDataPtr = (unsigned char *)malloc(size);
        if (!pcmDataPtr){
            DDBG("can't allocate memory\n");
            return NULL;
        }
        memset(pcmDataPtr,0,size);
        fd = fopen(pcm_file_path,"r");
        if (!fd){
            return NULL;
        }

        fread(pcmDataPtr,1,size,fd);
        fclose(fd);
        return pcmDataPtr;
    } else{
        return NULL;
    }
   
}

static bt_data * init_bt_para()
{
    bt_data * btd;
    btd = (bt_data *)malloc(sizeof(bt_data));
    if (!btd){
        printf("opps can't allocate resource!\n");
        exit(-1);
    }

    memset(btd,0,sizeof(*btd));

    strcpy(btd->ag_addr,DONGLE_ADDR);
    strcpy(btd->hs_addr,HEAD_SET_ADDR);

    btd->device_channel = HEAD_SET_CHAN;

    btd->callSetup = 0;
    btd->callAccept = 0;
    btd->isRunning = 0;
    btd->isServiceConnected = 0;
    btd->isScoConnected = 0;
   
    btd->hci_sock = -1;
    btd->sco_sock = -1;

    return btd;           
   
}

static int ring_headset(int fd_rfcomm)
{
    char recv_buf[RECV_BUFFER] = {0};

    sem_wait(&Sem);

    at_txrx(fd_rfcomm,"\r\nRING\r\n",recv_buf);
    while (!strstr(recv_buf,"ATA")&&!BTd->callAccept){
        at_txrx(fd_rfcomm,"\r\nRING\r\n",recv_buf);           
    }
    at_tx(fd_rfcomm,"\r\nOK\r\n");           

    at_tx(fd_rfcomm,"\r\n+CIEV:2,1\r\n");  
    sem_destroy(&Sem);

    return 0;  
   
}

static void play_pcm_audio(int fd_sco,unsigned char * pcm_buffer,int max_length,int times)
{
#define OFFSET  48
    int i;
    int cur = 0;
    int retval;
    unsigned char *pdata;
    unsigned char buffer[64];
    fd_set rfds,wfds;   
 struct timeval tv;
    unsigned int sector = 300*1024;

 if (!pcm_buffer){
     return -1;
 }

    FD_ZERO(&rfds);
 FD_SET(fd_sco, &rfds);
 FD_ZERO(&wfds);
 FD_SET(fd_sco, &wfds);

 tv.tv_sec = 0;
 tv.tv_usec =8000;

    pdata = pcm_buffer;
    
    for (i = 0 ; i < times ; i++){
        while (cur < max_length){
         if ((retval = select(fd_sco+1, NULL, &wfds, NULL, &tv)) > 0){         
                //fread(receive,1,OFFSET,fd_music);
                //memset(buffer,0,sizeof(buffer));
                //memcpy(buffer,pdata,OFFSET);
                printf("twins\r\n");
                //printf("twins\r\n");
                //usleep(1);
                //printf("\r\n");
                write(fd_sco,pdata,48);
                cur += OFFSET;
                pdata += OFFSET;     
                if (cur > sector){
                    sleep(5);
                    sector += 300*1024;
                }
            }
        }
        printf("music data is finished\n");
        sleep(2);
       
        pdata = pcm_buffer;
        cur = 0;
        sector = 300*1024;
   }
        //close(fd_sco);
    free(pcm_buffer);
    printf("audio transfer over\n");
    return;

}

void init_hcid_conf()
{
    system("hcid -f /etc/bluetooth/hcid.conf");
}

int main()
{
    int fd_rfcomm,fd_sco;
    unsigned char * pcm_buffer;
    int max_length;

    bt_data *btd;
    init_hcid_conf();

    btd = init_bt_para();
    BTd = btd;

    fd_rfcomm = start_rfcomm_link(btd->hs_addr, btd->ag_addr, btd->device_channel);
   
    if (fd_rfcomm < 0){           
        exit(-1);
    }
    btd->isRunning = 1;

    btd->hci_sock = fd_rfcomm;
    thread_create(50, (threadFunc_T)monitor_headset, (threadArg_T *)btd->hci_sock);
    thread_create(50, (threadFunc_T)ring_headset, (threadArg_T *)btd->hci_sock);
    pcm_buffer = fill_pcm_buffer(PCM_DATA_PATH, &max_length);

    while (1){
        if (btd->isServiceConnected == 0xff&&!btd->callSetup){
            //printf("service level connection finished\n");
            //ready to make/accept a call
            at_tx(fd_rfcomm,"\r\n+CIEV=3,1\r\n");   
            sem_post(&Sem);
            //CallSetup = 1;
            btd->callSetup = 1;
        }   

        if (0 == btd->isScoConnected){
            fd_sco = start_sco_link(btd->hs_addr,btd->ag_addr);
        }

        if (fd_sco > 0){
            //printf("sco link successfully!\n");
            btd->sco_sock = fd_sco;
            btd->isScoConnected = 1;
        }
   
        if (btd->callAccept == 1){

            play_pcm_audio(btd->sco_sock, pcm_buffer, max_length,1);
            break;
        }
    }
    //sleep(80);
    close(btd->sco_sock);
    close(btd->hci_sock);
}