Attachment #305117 for bug #386909

View | Details | Raw Unified | Return to bug 386909 | Differences between

and this patch




            }
            else
            {
                xprintf("FIXME: unhandled predicition type: %i\n", prediction_type);
                /* i think the only other prediction type (or perhaps this is just a
                 * boolean?) runs adaptive fir twice.. like:
                 * predictor_decompress_fir_adapt(predictor_error, tempout, ...)

        }
        case 20:
        case 32:
            xprintf("FIXME: unimplemented sample size %i\n", alac->setinfo_sample_size);
            break;
        default:
            break;

            }
            else
            { /* see mono case */
                xprintf("FIXME: unhandled predicition type: %i\n", prediction_type_a);
            }

            /* channel 2 */

            }
            else
            {
                xprintf("FIXME: unhandled predicition type: %i\n", prediction_type_b);
            }
        }
        else

        }
        case 20:
        case 32:
            xprintf("FIXME: unimplemented sample size %i\n", alac->setinfo_sample_size);
            break;
        default:
            break;




pthread_cond_t ab_buffer_ready;

static void die(char *why) {
    xprintf("FATAL: %s\n", why);
    //exit(1);
}

static int hex2bin(unsigned char *buf, char *hex) {

            continue;
        }
        if (!strcmp(line, "exit\n")) {
            ;//exit(0);
        }
        if (!strcmp(line, "flush\n")) {
            hairtunes_flush();
        }
    }
    xprintf("bye!\n");
    fflush(stderr);
#endif


{
  assert(f<=0);
  if (debug)
      xprintf("VOL: %lf\n", f);
  volume = pow(10.0,0.05*f);
  fix_volume = 65536.0 * volume;
}

  ab_resync();
  pthread_mutex_unlock(&ab_mutex);
  if (debug)
      xprintf("FLUSH\n");
}

#ifdef HAIRTUNES_STANDALONE

    } else if (seq_order(ab_read, seqno)) {     // late but not yet played
        abuf = audio_buffer + BUFIDX(seqno);
    } else {    // too late.
        xprintf("\nlate packet %04X (%04X:%04X)\n", seqno, ab_read, ab_write);
    }
    buf_fill = ab_write - ab_read;
    pthread_mutex_unlock(&ab_mutex);

    if (seq_order(last, first))
        return;

    xprintf("requesting resend on %d packets (port %d)\n", last-first+1, controlport);

    char req[8];    // *not* a standard RTCP NACK
    req[0] = 0x80;

        port += 3;
    }

    xprintf("port: %d\n", port); // let our handler know where we end up listening
    xprintf("cport: %d\n", port+1);

    rtp_sockets[0] = sock;
    rtp_sockets[1] = csock;

    bf_est_drift = biquad_filt(&bf_drift_lpf, CONTROL_B*(bf_est_err*CONTROL_A + err_deriv) + bf_est_drift);

    if (debug)
        xprintf("bf %d err %f drift %f desiring %f ed %f estd %f\r", fill, bf_est_err, bf_est_drift, desired_fill, err_deriv, err_deriv + CONTROL_A*bf_est_err);
    bf_playback_rate = 1.0 + CONTROL_A*bf_est_err + bf_est_drift;

    bf_last_err = bf_est_err;

    buf_fill = ab_write - ab_read;
    if (buf_fill < 1 || !ab_synced || ab_buffering) {    // init or underrun. stop and wait
        if (ab_synced)
          xprintf("\nunderrun\n");

        ab_buffering = 1;
        pthread_cond_wait(&ab_buffer_ready, &ab_mutex);

        return 0;
    }
    if (buf_fill >= BUFFER_FRAMES) {   // overrunning! uh-oh. restart at a sane distance
        xprintf("\noverrun.\n");
        ab_read = ab_write - START_FILL;
    }
    read = ab_read;


    volatile abuf_t *curframe = audio_buffer + BUFIDX(read);
    if (!curframe->ready) {
        xprintf("\nmissing frame.\n");
        memset(curframe->data, 0, FRAME_BYTES);
    }
    curframe->ready = 0;

    if (stuff) {
        if (stuff==1) {
            if (debug)
                xprintf("+++++++++\n");
            // interpolate one sample
            *outptr++ = dithered_vol(((long)inptr[-2] + (long)inptr[0]) >> 1);
            *outptr++ = dithered_vol(((long)inptr[-1] + (long)inptr[1]) >> 1);
        } else if (stuff==-1) {
            if (debug)
                xprintf("---------\n");
            inptr++;
            inptr++;
        }




#include "shairport.h"
#include "hairtunes.h"

static struct printfPtr g_printf={NULL};

int xprintf(const char *format, ...)
{
  char dbg[2048];
  va_list args;
  va_start(args, format);
  vsnprintf(dbg, sizeof(dbg), format, args);
  va_end(args);
  if(g_printf.extprintf)
  {
    g_printf.extprintf(dbg, sizeof(dbg));
  }
  else 
  {
    printf(dbg);
  }

  return 1;
}

#ifndef TRUE
#define TRUE (-1)
#endif

{
 g_ao=*ao;
}

void shairport_set_printf(struct printfPtr *funcPtr)
{
  g_printf = *funcPtr;
}
#endif

#ifndef XBMC

int shairport_main(int argc, char **argv)
#endif
{
  xprintf("initializing shairport\n",NULL);
  char tHWID_Hex[HWID_SIZE * 2 + 1];
  char tKnownHwid[32];


    }    
    else if(!strcmp(arg, "-h") || !strcmp(arg, "--help"))
    {
      xprintf("ShairPort version 0.05 C port - Airport Express emulator\n");
      xprintf("Usage:\nshairport [OPTION...]\n\nOptions:\n");
      xprintf("  -a, --apname=AirPort    Sets Airport name\n");
      xprintf("  -p, --password=secret   Sets Password (not working)\n");
      xprintf("  -o, --server_port=5000  Sets Port for Avahi/dns-sd\n");
      xprintf("  -b, --buffer=282        Sets Number of frames to buffer before beginning playback\n");
      xprintf("  -d                      Daemon mode\n");
      xprintf("  -q, --quiet             Supresses all output.\n");
      xprintf("  -v,-v2,-v3,-vv          Various debugging levels\n");
      xprintf("\n");
      return 0;
    }    
  }

  if ( buffer_start_fill < 30 || buffer_start_fill > BUFFER_FRAMES ) { 
     xprintf("buffer value must be > 30 and < %d\n", BUFFER_FRAMES);
     return(0);
  }


    int tPid = fork();
    if(tPid < 0)
    {
      //exit(1); // Error on fork
    }
    else if(tPid > 0)
    {
      //exit(0);
    }
    else
    {

    sscanf(tHWID_Hex, "%02X%02X%02X%02X%02X%02X", &tHWID[0], &tHWID[1], &tHWID[2], &tHWID[3], &tHWID[4], &tHWID[5]);
  }

  xprintf("LogLevel: %d\n", kCurrentLogLevel);
  xprintf("AirName: %s\n", tServerName);
  xprintf("HWID: %.*s\n", HWID_SIZE, tHWID+1);
  xprintf("HWID_Hex(%d): %s\n", strlen(tHWID_Hex), tHWID_Hex);

  if(tSimLevel >= 1)
  {

#ifndef XBMC
    startAvahi(tHWID_Hex, tServerName, tPort);
#endif
    xprintf("Starting connection server: specified server port: %d\n", tPort);
    tServerSock = setupListenServer(&tAddrInfo, tPort);
    if(tServerSock < 0)
    {
      freeaddrinfo(tAddrInfo);
      xprintf("Error setting up server socket on port %d, try specifying a different port\n", tPort);
      return 0;
    }



    int readsock;

    xprintf("Waiting for clients to connect\n");

    while(m_running)
    {

        {
          freeaddrinfo(tAddrInfo);
          tAddrInfo = NULL;
          xprintf("...Accepted Client Connection..\n");
          close(tServerSock);
          handleClient(tClientSock, tPassword, tHWID);
          //close(tClientSock);

        }
        else
        {
          xprintf("Child now busy handling new client\n");
          close(tClientSock);
        }
#else
      xprintf("...Accepted Client Connection..\n");
      handleClient(tClientSock, tPassword, tHWID);
#endif
      }

      }
  }

  xprintf("Finished\n");
  if(tAddrInfo != NULL)
  {
    freeaddrinfo(tAddrInfo);


void handleClient(int pSock, char *pPassword, char *pHWADDR)
{
  xprintf("In Handle Client\n");
  fflush(stdout);

  socklen_t len;


  // deal with both IPv4 and IPv6:
  if (addr.ss_family == AF_INET) {
      xprintf("Constructing ipv4 address\n");
      struct sockaddr_in *s = (struct sockaddr_in *)&addr;
      port = ntohs(s->sin_port);
      inet_ntop(AF_INET, &s->sin_addr, ipstr, sizeof ipstr);

      if(memcmp(&addr.bin[0], "\x00\x00\x00\x00" "\x00\x00\x00\x00" "\x00\x00\xff\xff", 12) == 0)
      {
        // its ipv4...
        xprintf("Constructing ipv4 from ipv6 address\n");
        memcpy(ipbin, &addr.bin[12], 4);
        ipbinlen = 4;
      }
      else
      {
        xprintf("Constructing ipv6 address\n");
        memcpy(ipbin, &s->sin6_addr, 16);
        ipbinlen = 16;
      }
  }

  xprintf("Peer IP address: %s\n", ipstr);
  xprintf("Peer port      : %d\n", port);

  int tMoreDataNeeded = 1;
  struct keyring     tKeys;

      tError = readDataFromClient(pSock, &(tConn.recv));
      if(!tError && strlen(tConn.recv.data) > 0)
      {
        xprintf("Finished Reading some data from client\n");
        // parse client request
        tMoreDataNeeded = parseMessage(&tConn, ipbin, ipbinlen, pHWADDR);
        if(1 == tMoreDataNeeded)
        {
          xprintf("\n\nNeed to read more data\n");
        }
        else if(-1 == tMoreDataNeeded) // Forked process down below ended.
        {
          xprintf("Forked Process ended...cleaning up\n");
          cleanup(&tConn);
          // pSock was already closed
          return;

      }
      else
      {
        xprintf("Error reading from socket, closing client\n");
        // Error reading data....quit.
        cleanup(&tConn);
        return;
      }
    }
    xprintf("Writing: %d chars to socket\n", tConn.resp.current);
    //tConn->resp.data[tConn->resp.current-1] = '\0';
    writeDataToClient(pSock, &(tConn.resp));
   // Finished reading one message...


void writeDataToClient(int pSock, struct shairbuffer *pResponse)
{
  xprintf("\n----Beg Send Response Header----\n%.*s\n", pResponse->current, pResponse->data);
  send(pSock, pResponse->data, pResponse->current,0);
  xprintf("----Send Response Header----\n");
}

int readDataFromClient(int pSock, struct shairbuffer *pClientBuffer)

  while(tRetval > 0 && tEnd < 0)
  {
     // Read from socket until \n\n, \r\n\r\n, or \r\r is found
      xprintf("Waiting To Read...\n");
      fflush(stdout);
      tRetval = read(pSock, tReadBuf, MAX_SIZE);
      // if new buffer contains the end of request string, only copy partial buffer?

        {
          pClientBuffer->marker = tEnd+1; // Marks start of content
        }
        xprintf("Found end of http request at: %d\n", tEnd);
        fflush(stdout);        
      }
      else
      {
        tEnd = MAX_SIZE;
        xprintf("Read %d of data so far\n%s\n", tRetval, tReadBuf);
        fflush(stdout);
      }
      if(tRetval > 0)
      {
        // Copy read data into tReceive;
        xprintf("Read %d data, using %d of it\n", tRetval, tEnd);
        addNToShairBuffer(pClientBuffer, tReadBuf, tRetval);
        xprintf("Finished copying data\n");
      }
      else
      {
        xprintf("Error reading data from socket, got: %d bytes", tRetval);
        return tRetval;
      }
  }
  if(tEnd + 1 != tRetval)
  {
    xprintf("Read more data after end of http request. %d instead of %d\n", tRetval, tEnd+1);
  }
  xprintf("Finished Reading Data:\n%s\nEndOfData\n", pClientBuffer->data);
  fflush(stdout);
  return 0;
}

char *getFromBuffer(char *pBufferPtr, const char *pField, int pLenAfterField, int *pReturnSize, char *pDelims)
{
  xprintf("GettingFromBuffer: %s\n", pField);
  char* tFound = strstr(pBufferPtr, pField);
  int tSize = 0;
  if(tFound != NULL)

    }
    
    tSize = (int) (tShortest - tFound);
    xprintf("Found %.*s  length: %d\n", tSize, tFound, tSize);
    if(pReturnSize != NULL)
    {
      *pReturnSize = tSize;

  }
  else
  {
    xprintf("Not Found\n");
  }
  return tFound;
}

  {
    char tTrim[tFoundSize + 2];
    getTrimmed(tFound, tFoundSize, TRUE, TRUE, tTrim);
    xprintf("HeaderChallenge:  [%s] len: %d  sizeFound: %d\n", tTrim, strlen(tTrim), tFoundSize);
    int tChallengeDecodeSize = 16;
    char *tChallenge = decode_base64((unsigned char *)tTrim, tFoundSize, &tChallengeDecodeSize);
    xprintf("Challenge Decode size: %d  expected 16\n", tChallengeDecodeSize);

    int tCurSize = 0;
    unsigned char tChalResp[38];

    }

    char *tTmp = encode_base64((unsigned char *)tChalResp, tCurSize);
    xprintf("Full sig: %s\n", tTmp);
    free(tTmp);

    // RSA Encrypt

    {
      if(isLogEnabledFor(HEADER_LOG_LEVEL))
      {
        xprintf("Content-Length: %s value -> %d\n", tContent, tContentSize);
        if(pConn->recv.marker != 0)
        {
          xprintf("ContentPtr has %d, but needs %d\n", 
                  strlen(pConn->recv.data+pConn->recv.marker), tContentSize);
        }
      }

  }
  else
  {
    xprintf("No content, header only\n");
  }

  // "Creates" a new Response Header for our response message

    {
      tLen = 20;
    }
    xprintf("********** RECV %.*s **********\n", tLen, pConn->recv.data);
  }

  if(pConn->password != NULL)


  if(buildAppleResponse(pConn, pIpBin, pIpBinLen, pHWID)) // need to free sig
  {
    xprintf("Added AppleResponse to Apple-Challenge request\n");
  }

  // Find option, then based on option, do different actions.

      int tKeySize = 0;
      char tEncodedAesIV[tSize + 2];
      getTrimmed(tHeaderVal, tSize, TRUE, TRUE, tEncodedAesIV);
      xprintf("AESIV: [%.*s] Size: %d  Strlen: %d\n", tSize, tEncodedAesIV, tSize, strlen(tEncodedAesIV));
      char *tDecodedIV =  decode_base64((unsigned char*) tEncodedAesIV, tSize, &tSize);

      // grab the key, copy it out of the receive buffer
      tHeaderVal = getFromContent(tContent, "a=rsaaeskey", &tKeySize);
      char tEncodedAesKey[tKeySize + 2]; // +1 for nl, +1 for \0
      getTrimmed(tHeaderVal, tKeySize, TRUE, TRUE, tEncodedAesKey);
      xprintf("AES KEY: [%s] Size: %d  Strlen: %d\n", tEncodedAesKey, tKeySize, strlen(tEncodedAesKey));
      // remove base64 coding from key
      char *tDecodedAesKey = decode_base64((unsigned char*) tEncodedAesKey,
                              tKeySize, &tKeySize);  // Need to free DecodedAesKey

      int tFmtpSize = 0;
      char *tFmtp = getFromContent(tContent, "a=fmtp", &tFmtpSize);  // Don't need to free
      tFmtp = getTrimmedMalloc(tFmtp, tFmtpSize, TRUE, FALSE); // will need to free
      xprintf("Format: %s\n", tFmtp);

      RSA *rsa = loadKey();
      // Decrypt the binary aes key

      if(RSA_private_decrypt(tKeySize, (unsigned char *)tDecodedAesKey, 
      (unsigned char*) tDecryptedKey, rsa, RSA_PKCS1_OAEP_PADDING) >= 0)
      {
        xprintf("Decrypted AES key from RSA Successfully\n");
      }
      else
      {
        xprintf("Error Decrypting AES key from RSA\n");
      }
      free(tDecodedAesKey);
      RSA_free(rsa);

//    struct comms *tComms = pConn->hairtunes;
//   if (! (pipe(tComms->in) == 0 && pipe(tComms->out) == 0))
//    {
//      xprintf("Error setting up hairtunes communications...some things probably wont work very well.\n");
//    }
    
    // Setup fork
    char tPort[8] = "6000";  // get this from dup()'d stdout of child pid

    xprintf("******** SETUP!!!!!\n",NULL);
#ifndef XBMC
    int tPid = fork();
    if(tPid == 0)

      tFound = getFromSetup(pConn->recv.data, "timing_port", &tSize);
      getTrimmed(tFound, tSize, 1, 0, tTPortStr);

      xprintf("converting %s and %s from str->int\n", tCPortStr, tTPortStr);
      int tControlport = atoi(tCPortStr);
      int tTimingport = atoi(tTPortStr);

      xprintf("Got %d for CPort and %d for TPort\n", tControlport, tTimingport);
      char *tRtp = NULL;
      char *tPipe = NULL;
      char *tAoDriver = NULL;

                      tDataport, tRtp, tPipe, tAoDriver, tAoDeviceName, tAoDeviceId);
#ifndef XBMC
      // Quit when finished.
      xprintf("Returned from hairtunes init....returning -1, should close out this whole side of the fork\n");
      return -1;
    }
    else if(tPid >0)

      int tRead = read(tComms->out[0], tFromHairtunes, 80);
      if(tRead <= 0)
      {
        xprintf("Error reading port from hairtunes function, assuming default port: %d\n", tPort);
      }
      else
      {

        }
        else
        {
          xprintf("Read %d bytes, Error translating %s into a port\n", tRead, tFromHairtunes);
        }
      }


    }
    else
    {
      xprintf("Error forking process....dere' be errors round here.\n");
      return -1;
    }
#endif

    propogateCSeq(pConn);
#ifndef XBMC
    close(pConn->hairtunes->in[1]);
    xprintf("Tearing down connection, closing pipes\n");
#else
    hairtunes_cleanup();
#endif

    propogateCSeq(pConn);
    int tSize = 0;
    char *tVol = getFromHeader(pConn->recv.data, "volume", &tSize);
    xprintf("About to write [vol: %.*s] data to hairtunes\n", tSize, tVol);
    // TBD VOLUME
#ifndef XBMC
    write(pConn->hairtunes->in[1], "vol: ", 5);

#else
    hairtunes_setvolume(atof(tVol));
#endif
    xprintf("Finished writing data write data to hairtunes\n");
  }
  else
  {
    xprintf("\n\nUn-Handled recv: %s\n", pConn->recv.data);
    propogateCSeq(pConn);
  }
  addToShairBuffer(&(pConn->resp), "\r\n");

    char tName[100 + HWID_SIZE + 3];
    if(strlen(pServerName) > tMaxServerName)
    {
      xprintf("Hey dog, we see you like long server names, "
              "so we put a strncat in our command so we don't buffer overflow, while you listen to your flow.\n"
              "We just used the first %d characters.  Pick something shorter if you want\n", tMaxServerName);
    }

    strcat(tName, pHWStr);
    strcat(tName, "@");
    strncat(tName, pServerName, tMaxServerName);
    xprintf("Avahi/DNS-SD Name: %s\n", tName);
    
    execlp("avahi-publish-service", "avahi-publish-service", tName,
         "_raop._tcp", tPort, "tp=UDP","sm=false","sv=false","ek=1","et=0,1",

            perror("error");
    }

    xprintf("Bad error... couldn't find or failed to run: avahi-publish-service OR dns-sd\n");
    //exit(1);
  }
  else
  {
    xprintf("Avahi/DNS-SD started on PID: %d\n", tPid);
  }
  return tPid;
}


void printBufferInfo(struct shairbuffer *pBuf, int pLevel)
{
  xprintf("Buffer: [%s]  size: %d  maxchars:%d\n", pBuf->data, pBuf->current, pBuf->maxsize/sizeof(char));
}

int getAvailChars(struct shairbuffer *pBuf)

  {
    va_list argp;
    va_start(argp, pFormat);
    xprintf(pFormat, argp);
    //vprintf(pFormat, argp);
    va_end(argp);
  }
  //#endif

{
  if(pBuf->data != NULL)
  {
    xprintf("Hrm, buffer wasn't cleaned up....trying to free\n");
    free(pBuf->data);
    xprintf("Free didn't seem to seg fault....huzzah\n");
  }
  pBuf->current = 0;
  pBuf->marker = 0;

  BIO *tBio = BIO_new_mem_buf(AIRPORT_PRIVATE_KEY, -1);
  RSA *rsa = PEM_read_bio_RSAPrivateKey(tBio, NULL, NULL, NULL); //NULL, NULL, NULL);
  BIO_free(tBio);
  xprintf("RSA Key: %d\n", RSA_check_key(rsa));
  return rsa;
}




{
#endif /* __cplusplus */

struct printfPtr
{
  int (*extprintf)(const char* msg, size_t msgSize);
};

int shairport_main(int argc, char **argv);
void shairport_exit(void);
int shairport_loop(void);
int shairport_is_running(void);
void shairport_set_ao(struct AudioOutput *ao);
void shairport_set_printf(struct printfPtr *funcPtr);

#ifdef __cplusplus
}




      delay(RETRY_DELAY, &tRes);
    }
  }
  xprintf("%d Retry attempts exceeded\n", RETRY_COUNT);
  return ERROR;
}


  tError = getaddrinfo(pHostname, pService, &hints, pAddrInfo);
  if(tError != 0)
  {
    xprintf("Error getting address info\n");
  }
  return tError;
}

  else
  {
    // Invalid encoded data, no other cases are possible.
    xprintf("Unrecoverable error....base64 values are incorrectly encoded\n");
    return pSize;
  }
}

    memset(input, 0, length);
    memcpy(input, pInput, pLength);
    memset(input+pLength, '=', length-pLength);
    xprintf("Fixed value: [%.*s]\n", length, input);
  }
  char *buffer = (char *)malloc(length);
  memset(buffer, 0, length);

Return to bug 386909

Lines 804-810 Link Here

(-)src/alac.c (-5 / +5 lines)
804	}	804	}
805	else	805	else
806	{	806	{
807	fprintf(stderr, "FIXME: unhandled predicition type: %i\n", prediction_type);	807	xprintf("FIXME: unhandled predicition type: %i\n", prediction_type);
808	/* i think the only other prediction type (or perhaps this is just a	808	/* i think the only other prediction type (or perhaps this is just a
809	* boolean?) runs adaptive fir twice.. like:	809	* boolean?) runs adaptive fir twice.. like:
810	* predictor_decompress_fir_adapt(predictor_error, tempout, ...)	810	* predictor_decompress_fir_adapt(predictor_error, tempout, ...)
Lines 885-891 Link Here
885	}	885	}
886	case 20:	886	case 20:
887	case 32:	887	case 32:
888	fprintf(stderr, "FIXME: unimplemented sample size %i\n", alac->setinfo_sample_size);	888	xprintf("FIXME: unimplemented sample size %i\n", alac->setinfo_sample_size);
889	break;	889	break;
890	default:	890	default:
891	break;	891	break;
Lines 1004-1010 Link Here
1004	}	1004	}
1005	else	1005	else
1006	{ /* see mono case */	1006	{ /* see mono case */
1007	fprintf(stderr, "FIXME: unhandled predicition type: %i\n", prediction_type_a);	1007	xprintf("FIXME: unhandled predicition type: %i\n", prediction_type_a);
1008	}	1008	}
1009		1009
1010	/* channel 2 */	1010	/* channel 2 */
Lines 1029-1035 Link Here
1029	}	1029	}
1030	else	1030	else
1031	{	1031	{
1032	fprintf(stderr, "FIXME: unhandled predicition type: %i\n", prediction_type_b);	1032	xprintf("FIXME: unhandled predicition type: %i\n", prediction_type_b);
1033	}	1033	}
1034	}	1034	}
1035	else	1035	else
Lines 1106-1112 Link Here
1106	}	1106	}
1107	case 20:	1107	case 20:
1108	case 32:	1108	case 32:
1109	fprintf(stderr, "FIXME: unimplemented sample size %i\n", alac->setinfo_sample_size);	1109	xprintf("FIXME: unimplemented sample size %i\n", alac->setinfo_sample_size);
1110	break;	1110	break;
1111	default:	1111	default:
1112	break;	1112	break;

Lines 121-128 Link Here

(-)src/hairtunes.c (-16 / +16 lines)
121	pthread_cond_t ab_buffer_ready;	121	pthread_cond_t ab_buffer_ready;
122		122
123	static void die(char *why) {	123	static void die(char *why) {
124	fprintf(stderr, "FATAL: %s\n", why);	124	xprintf("FATAL: %s\n", why);
125	exit(1);	125	//exit(1);
126	}	126	}
127		127
128	static int hex2bin(unsigned char buf, char hex) {	128	static int hex2bin(unsigned char buf, char hex) {
Lines 245-257 Link Here
245	continue;	245	continue;
246	}	246	}
247	if (!strcmp(line, "exit\n")) {	247	if (!strcmp(line, "exit\n")) {
248	exit(0);	248	;//exit(0);
249	}	249	}
250	if (!strcmp(line, "flush\n")) {	250	if (!strcmp(line, "flush\n")) {
251	hairtunes_flush();	251	hairtunes_flush();
252	}	252	}
253	}	253	}
254	fprintf(stderr, "bye!\n");	254	xprintf("bye!\n");
255	fflush(stderr);	255	fflush(stderr);
256	#endif	256	#endif
257		257
Lines 262-268 Link Here
262	{	262	{
263	assert(f<=0);	263	assert(f<=0);
264	if (debug)	264	if (debug)
265	fprintf(stderr, "VOL: %lf\n", f);	265	xprintf("VOL: %lf\n", f);
266	volume = pow(10.0,0.05*f);	266	volume = pow(10.0,0.05*f);
267	fix_volume = 65536.0 * volume;	267	fix_volume = 65536.0 * volume;
268	}	268	}
Lines 273-279 Link Here
273	ab_resync();	273	ab_resync();
274	pthread_mutex_unlock(&ab_mutex);	274	pthread_mutex_unlock(&ab_mutex);
275	if (debug)	275	if (debug)
276	fprintf(stderr, "FLUSH\n");	276	xprintf("FLUSH\n");
277	}	277	}
278		278
279	#ifdef HAIRTUNES_STANDALONE	279	#ifdef HAIRTUNES_STANDALONE
Lines 423-429 Link Here
423	} else if (seq_order(ab_read, seqno)) { // late but not yet played	423	} else if (seq_order(ab_read, seqno)) { // late but not yet played
424	abuf = audio_buffer + BUFIDX(seqno);	424	abuf = audio_buffer + BUFIDX(seqno);
425	} else { // too late.	425	} else { // too late.
426	fprintf(stderr, "\nlate packet %04X (%04X:%04X)\n", seqno, ab_read, ab_write);	426	xprintf("\nlate packet %04X (%04X:%04X)\n", seqno, ab_read, ab_write);
427	}	427	}
428	buf_fill = ab_write - ab_read;	428	buf_fill = ab_write - ab_read;
429	pthread_mutex_unlock(&ab_mutex);	429	pthread_mutex_unlock(&ab_mutex);
Lines 520-526 Link Here
520	if (seq_order(last, first))	520	if (seq_order(last, first))
521	return;	521	return;
522		522
523	fprintf(stderr, "requesting resend on %d packets (port %d)\n", last-first+1, controlport);	523	xprintf("requesting resend on %d packets (port %d)\n", last-first+1, controlport);
524		524
525	char req[8]; // not a standard RTCP NACK	525	char req[8]; // not a standard RTCP NACK
526	req[0] = 0x80;	526	req[0] = 0x80;
Lines 604-611 Link Here
604	port += 3;	604	port += 3;
605	}	605	}
606		606
607	printf("port: %d\n", port); // let our handler know where we end up listening	607	xprintf("port: %d\n", port); // let our handler know where we end up listening
608	printf("cport: %d\n", port+1);	608	xprintf("cport: %d\n", port+1);
609		609
610	rtp_sockets[0] = sock;	610	rtp_sockets[0] = sock;
611	rtp_sockets[1] = csock;	611	rtp_sockets[1] = csock;
Lines 708-714 Link Here
708	bf_est_drift = biquad_filt(&bf_drift_lpf, CONTROL_B(bf_est_errCONTROL_A + err_deriv) + bf_est_drift);	708	bf_est_drift = biquad_filt(&bf_drift_lpf, CONTROL_B(bf_est_errCONTROL_A + err_deriv) + bf_est_drift);
709		709
710	if (debug)	710	if (debug)
711	fprintf(stderr, "bf %d err %f drift %f desiring %f ed %f estd %f\r", fill, bf_est_err, bf_est_drift, desired_fill, err_deriv, err_deriv + CONTROL_A*bf_est_err);	711	xprintf("bf %d err %f drift %f desiring %f ed %f estd %f\r", fill, bf_est_err, bf_est_drift, desired_fill, err_deriv, err_deriv + CONTROL_A*bf_est_err);
712	bf_playback_rate = 1.0 + CONTROL_A*bf_est_err + bf_est_drift;	712	bf_playback_rate = 1.0 + CONTROL_A*bf_est_err + bf_est_drift;
713		713
714	bf_last_err = bf_est_err;	714	bf_last_err = bf_est_err;
Lines 724-730 Link Here
724	buf_fill = ab_write - ab_read;	724	buf_fill = ab_write - ab_read;
725	if (buf_fill < 1 \|\| !ab_synced \|\| ab_buffering) { // init or underrun. stop and wait	725	if (buf_fill < 1 \|\| !ab_synced \|\| ab_buffering) { // init or underrun. stop and wait
726	if (ab_synced)	726	if (ab_synced)
727	fprintf(stderr, "\nunderrun\n");	727	xprintf("\nunderrun\n");
728		728
729	ab_buffering = 1;	729	ab_buffering = 1;
730	pthread_cond_wait(&ab_buffer_ready, &ab_mutex);	730	pthread_cond_wait(&ab_buffer_ready, &ab_mutex);
Lines 736-742 Link Here
736	return 0;	736	return 0;
737	}	737	}
738	if (buf_fill >= BUFFER_FRAMES) { // overrunning! uh-oh. restart at a sane distance	738	if (buf_fill >= BUFFER_FRAMES) { // overrunning! uh-oh. restart at a sane distance
739	fprintf(stderr, "\noverrun.\n");	739	xprintf("\noverrun.\n");
740	ab_read = ab_write - START_FILL;	740	ab_read = ab_write - START_FILL;
741	}	741	}
742	read = ab_read;	742	read = ab_read;
Lines 748-754 Link Here
748		748
749	volatile abuf_t *curframe = audio_buffer + BUFIDX(read);	749	volatile abuf_t *curframe = audio_buffer + BUFIDX(read);
750	if (!curframe->ready) {	750	if (!curframe->ready) {
751	fprintf(stderr, "\nmissing frame.\n");	751	xprintf("\nmissing frame.\n");
752	memset(curframe->data, 0, FRAME_BYTES);	752	memset(curframe->data, 0, FRAME_BYTES);
753	}	753	}
754	curframe->ready = 0;	754	curframe->ready = 0;
Lines 775-787 Link Here
775	if (stuff) {	775	if (stuff) {
776	if (stuff==1) {	776	if (stuff==1) {
777	if (debug)	777	if (debug)
778	fprintf(stderr, "+++++++++\n");	778	xprintf("+++++++++\n");
779	// interpolate one sample	779	// interpolate one sample
780	*outptr++ = dithered_vol(((long)inptr[-2] + (long)inptr[0]) >> 1);	780	*outptr++ = dithered_vol(((long)inptr[-2] + (long)inptr[0]) >> 1);
781	*outptr++ = dithered_vol(((long)inptr[-1] + (long)inptr[1]) >> 1);	781	*outptr++ = dithered_vol(((long)inptr[-1] + (long)inptr[1]) >> 1);
782	} else if (stuff==-1) {	782	} else if (stuff==-1) {
783	if (debug)	783	if (debug)
784	fprintf(stderr, "---------\n");	784	xprintf("---------\n");
785	inptr++;	785	inptr++;
786	inptr++;	786	inptr++;
787	}	787	}

Lines 82-88 Link Here

(-)src/socketlib.c (-4 / +4 lines)
82	delay(RETRY_DELAY, &tRes);	82	delay(RETRY_DELAY, &tRes);
83	}	83	}
84	}	84	}
85	printf("%d Retry attempts exceeded\n", RETRY_COUNT);	85	xprintf("%d Retry attempts exceeded\n", RETRY_COUNT);
86	return ERROR;	86	return ERROR;
87	}	87	}
88		88
Lines 102-108 Link Here
102	tError = getaddrinfo(pHostname, pService, &hints, pAddrInfo);	102	tError = getaddrinfo(pHostname, pService, &hints, pAddrInfo);
103	if(tError != 0)	103	if(tError != 0)
104	{	104	{
105	printf("Error getting address info\n");	105	xprintf("Error getting address info\n");
106	}	106	}
107	return tError;	107	return tError;
108	}	108	}
Lines 200-206 Link Here
200	else	200	else
201	{	201	{
202	// Invalid encoded data, no other cases are possible.	202	// Invalid encoded data, no other cases are possible.
203	printf("Unrecoverable error....base64 values are incorrectly encoded\n");	203	xprintf("Unrecoverable error....base64 values are incorrectly encoded\n");
204	return pSize;	204	return pSize;
205	}	205	}
206	}	206	}
Lines 226-232 Link Here
226	memset(input, 0, length);	226	memset(input, 0, length);
227	memcpy(input, pInput, pLength);	227	memcpy(input, pInput, pLength);
228	memset(input+pLength, '=', length-pLength);	228	memset(input+pLength, '=', length-pLength);
229	printf("Fixed value: [%.*s]\n", length, input);	229	xprintf("Fixed value: [%.*s]\n", length, input);
230	}	230	}
231	char buffer = (char )malloc(length);	231	char buffer = (char )malloc(length);
232	memset(buffer, 0, length);	232	memset(buffer, 0, length);

Lines 59-69 Link Here

(-)src/shairport.h (+6 lines)
59	{	59	{
60	#endif /* __cplusplus */	60	#endif /* __cplusplus */
61		61
		62	struct printfPtr
		63	{
		64	int (extprintf)(const char msg, size_t msgSize);
		65	};
		66
62	int shairport_main(int argc, char **argv);	67	int shairport_main(int argc, char **argv);
63	void shairport_exit(void);	68	void shairport_exit(void);
64	int shairport_loop(void);	69	int shairport_loop(void);
65	int shairport_is_running(void);	70	int shairport_is_running(void);
66	void shairport_set_ao(struct AudioOutput *ao);	71	void shairport_set_ao(struct AudioOutput *ao);
		72	void shairport_set_printf(struct printfPtr *funcPtr);
67		73
68	#ifdef __cplusplus	74	#ifdef __cplusplus
69	}	75	}