iOS音乐播放器实现代码完整版

本文实例为大家分享了iOS实现音乐播放器的具体代码，供大家参考，具体内容如下

audio_queue.cpp

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

215

216

217

218

219

220

221

222

223

224

225

226

227

228

229

230

231

232

233

234

235

236

237

238

239

240

241

242

243

244

245

246

247

248

249

250

251

252

253

254

255

256

257

258

259

260

261

262

263

264

265

266

267

268

269

270

271

272

273

274

275

276

277

278

279

280

281

282

283

284

285

286

287

288

289

290

291

292

293

294

295

296

297

298

299

300

301

302

303

304

305

306

307

308

309

310

311

312

313

314

315

316

317

318

319

320

321

322

323

324

325

326

327

328

329

330

331

332

333

334

335

336

337

338

339

340

341

342

343

344

345

346

347

348

349

350

351

352

353

354

355

356

357

358

359

360

361

362

363

364

365

366

367

368

369

370

371

372

373

374

375

376

377

378

379

380

381

382

383

384

385

386

387

388

389

390

391

392

393

394

395

/*

* This file is part of the FreeStreamer project,

* See the file ''LICENSE'' for using the code.

*

* Part of the code in this file has been rewritten from

* the AudioFileStreamExample / afsclient.cpp

*

* The threadless playback has been adapted from

* Alex Crichton's AudioStreamer.

*/

#include "audio_queue.h"

#include <cassert>

//#define AQ_DEBUG 1

#if !defined (AQ_DEBUG)

#define AQ_TRACE(...) do {} while (0)

#else

#define AQ_TRACE(...) printf(__VA_ARGS__)

#endif

namespace astreamer {

typedef struct queued_packet {

AudioStreamPacketDescription desc;

struct queued_packet *next;

char data[];

} queued_packet_t;

/* public */

Audio_Queue::Audio_Queue()

: m_delegate(0),

m_state(IDLE),

m_outAQ(0),

m_fillBufferIndex(0),

m_bytesFilled(0),

m_packetsFilled(0),

m_buffersUsed(0),

m_processedPacketsSizeTotal(0),

m_processedPacketsCount(0),

m_audioQueueStarted(false),

m_waitingOnBuffer(false),

m_queuedHead(0),

m_queuedTail(0),

m_lastError(noErr)

{

for (size_t i=0; i < AQ_BUFFERS; i++) {

m_bufferInUse[i] = false;

}

Audio_Queue::~Audio_Queue()

{

stop(true);

cleanup();

}

bool Audio_Queue::initialized()

{

return (m_outAQ != 0);

}

void Audio_Queue::start()

{

// start the queue if it has not been started already

if (m_audioQueueStarted) {

return;

}

OSStatus err = AudioQueueStart(m_outAQ, NULL);

if (!err) {

m_audioQueueStarted = true;

m_lastError = noErr;

} else {

AQ_TRACE("%s: AudioQueueStart failed!\\n", __PRETTY_FUNCTION__);

m_lastError = err;

}

void Audio_Queue::pause()

{

if (m_state == RUNNING) {

if (AudioQueuePause(m_outAQ) != 0) {

AQ_TRACE("%s: AudioQueuePause failed!\\n", __PRETTY_FUNCTION__);

}

setState(PAUSED);

} else if (m_state == PAUSED) {

AudioQueueStart(m_outAQ, NULL);

setState(RUNNING);

}

void Audio_Queue::stop()

{

stop(true);

}

void Audio_Queue::stop(bool stopImmediately)

{

if (!m_audioQueueStarted) {

AQ_TRACE("%s: audio queue already stopped, return!\\n", __PRETTY_FUNCTION__);

return;

}

m_audioQueueStarted = false;

AQ_TRACE("%s: enter\\n", __PRETTY_FUNCTION__);

if (AudioQueueFlush(m_outAQ) != 0) {

AQ_TRACE("%s: AudioQueueFlush failed!\\n", __PRETTY_FUNCTION__);

}

if (stopImmediately) {

AudioQueueRemovePropertyListener(m_outAQ,

kAudioQueueProperty_IsRunning,

audioQueueIsRunningCallback,

this);

}

if (AudioQueueStop(m_outAQ, stopImmediately) != 0) {

AQ_TRACE("%s: AudioQueueStop failed!\\n", __PRETTY_FUNCTION__);

}

if (stopImmediately) {

setState(IDLE);

}

AQ_TRACE("%s: leave\\n", __PRETTY_FUNCTION__);

}

double Audio_Queue::packetDuration()

{

return m_streamDesc.mFramesPerPacket / m_streamDesc.mSampleRate;

}

unsigned Audio_Queue::timePlayedInSeconds()

{

unsigned timePlayed = 0;

AudioTimeStamp queueTime;

Boolean discontinuity;

OSStatus err = AudioQueueGetCurrentTime(m_outAQ, NULL, &queueTime, &discontinuity);

if (err) {

goto out;

}

timePlayed = queueTime.mSampleTime / m_streamDesc.mSampleRate;

out:

return timePlayed;

}

unsigned Audio_Queue::bitrate()

{

unsigned bitrate = 0;

double packetDuration = this->packetDuration();

if (packetDuration > 0 && m_processedPacketsCount > 50) {

double averagePacketByteSize = m_processedPacketsSizeTotal / m_processedPacketsCount;

bitrate = 8 * averagePacketByteSize / packetDuration;

}

return bitrate;

}

void

Audio_Queue::handlePropertyChange(AudioFileStreamID inAudioFileStream, AudioFileStreamPropertyID inPropertyID, UInt32 *ioFlags)

{

OSStatus err = noErr;

AQ_TRACE("found property '%lu%lu%lu%lu'\\n", (inPropertyID>>24)&255, (inPropertyID>>16)&255, (inPropertyID>>8)&255, inPropertyID&255);

switch (inPropertyID) {

case kAudioFileStreamProperty_ReadyToProducePackets:

{

cleanup();

// the file stream parser is now ready to produce audio packets.

// get the stream format.

memset(&m_streamDesc, 0, sizeof(m_streamDesc));

UInt32 asbdSize = sizeof(m_streamDesc);

err = AudioFileStreamGetProperty(inAudioFileStream, kAudioFileStreamProperty_DataFormat, &asbdSize, &m_streamDesc);

if (err) {

AQ_TRACE("%s: error in kAudioFileStreamProperty_DataFormat\\n", __PRETTY_FUNCTION__);

m_lastError = err;

break;

}

// create the audio queue

err = AudioQueueNewOutput(&m_streamDesc, audioQueueOutputCallback, this, CFRunLoopGetCurrent(), NULL, 0, &m_outAQ);

if (err) {

AQ_TRACE("%s: error in AudioQueueNewOutput\\n", __PRETTY_FUNCTION__);

if (m_delegate) {

m_delegate->audioQueueInitializationFailed();

}

m_lastError = err;

break;

}

// allocate audio queue buffers

for (unsigned int i = 0; i < AQ_BUFFERS; ++i) {

err = AudioQueueAllocateBuffer(m_outAQ, AQ_BUFSIZ, &m_audioQueueBuffer[i]);

if (err) {

/* If allocating the buffers failed, everything else will fail, too.

* Dispose the queue so that we can later on detect that this

* queue in fact has not been initialized.

*/

AQ_TRACE("%s: error in AudioQueueAllocateBuffer\\n", __PRETTY_FUNCTION__);

(void)AudioQueueDispose(m_outAQ, true);

m_outAQ = 0;

if (m_delegate) {

m_delegate->audioQueueInitializationFailed();

}

m_lastError = err;

break;

}

setCookiesForStream(inAudioFileStream);

// listen for kAudioQueueProperty_IsRunning

err = AudioQueueAddPropertyListener(m_outAQ, kAudioQueueProperty_IsRunning, audioQueueIsRunningCallback, this);

if (err) {

AQ_TRACE("%s: error in AudioQueueAddPropertyListener\\n", __PRETTY_FUNCTION__);

m_lastError = err;

break;

}

break;

}

void Audio_Queue::handleAudioPackets(UInt32 inNumberBytes, UInt32 inNumberPackets, const void *inInputData, AudioStreamPacketDescription *inPacketDescriptions)

{

if (!initialized()) {

AQ_TRACE("%s: warning: attempt to handle audio packets with uninitialized audio queue. return.\\n", __PRETTY_FUNCTION__);

return;

}

// this is called by audio file stream when it finds packets of audio

AQ_TRACE("got data. bytes: %lu packets: %lu\\n", inNumberBytes, inNumberPackets);

/* Place each packet into a buffer and then send each buffer into the audio

queue */

UInt32 i;

if (!inPacketDescriptions) {

AQ_TRACE("%s: notice: supplying the packet descriptions for a supposed CBR data.\\n", __PRETTY_FUNCTION__);

// If no packet descriptions are supplied, assume we are dealing with CBR data

UInt32 base = inNumberBytes / inNumberPackets;

AudioStreamPacketDescription *descriptions = new AudioStreamPacketDescription[inNumberPackets];

for (i = 0; i < inNumberPackets; i++) {

descriptions[i].mStartOffset = (base * i);

descriptions[i].mDataByteSize = base;

descriptions[i].mVariableFramesInPacket = 0;

}

inPacketDescriptions = descriptions;

m_cbrPacketDescriptions.push_back(descriptions);

}

for (i = 0; i < inNumberPackets && !m_waitingOnBuffer && m_queuedHead == NULL; i++) {

AudioStreamPacketDescription *desc = &inPacketDescriptions[i];

int ret = handlePacket((const char*)inInputData + desc->mStartOffset, desc);

if (!ret) break;

}

if (i == inNumberPackets) {

return;

}

for (; i < inNumberPackets; i++) {

/* Allocate the packet */

UInt32 size = inPacketDescriptions[i].mDataByteSize;

queued_packet_t *packet = (queued_packet_t *)malloc(sizeof(queued_packet_t) + size);

/* Prepare the packet */

packet->next = NULL;

packet->desc = inPacketDescriptions[i];

packet->desc.mStartOffset = 0;

memcpy(packet->data, (const char *)inInputData + inPacketDescriptions[i].mStartOffset,

size);

if (m_queuedHead == NULL) {

m_queuedHead = m_queuedTail = packet;

} else {

m_queuedTail->next = packet;

m_queuedTail = packet;

}

int Audio_Queue::handlePacket(const void *data, AudioStreamPacketDescription *desc)

{

if (!initialized()) {

AQ_TRACE("%s: warning: attempt to handle audio packets with uninitialized audio queue. return.\\n", __PRETTY_FUNCTION__);

return -1;

}

AQ_TRACE("%s: enter\\n", __PRETTY_FUNCTION__);

UInt32 packetSize = desc->mDataByteSize;

/* This shouldn't happen because most of the time we read the packet buffer

size from the file stream, but if we restored to guessing it we could

come up too small here */

if (packetSize > AQ_BUFSIZ) {

AQ_TRACE("%s: packetSize %lli > AQ_BUFSIZ %li\\n", __PRETTY_FUNCTION__, packetSize, AQ_BUFSIZ);

return -1;

}

// if the space remaining in the buffer is not enough for this packet, then

// enqueue the buffer and wait for another to become available.

if (AQ_BUFSIZ - m_bytesFilled < packetSize) {

int hasFreeBuffer = enqueueBuffer();

if (hasFreeBuffer <= 0) {

return hasFreeBuffer;

}

} else {

AQ_TRACE("%s: skipped enqueueBuffer AQ_BUFSIZ - m_bytesFilled %lu, packetSize %lli\\n", __PRETTY_FUNCTION__, (AQ_BUFSIZ - m_bytesFilled), packetSize);

}

m_processedPacketsSizeTotal += packetSize;

m_processedPacketsCount++;

// copy data to the audio queue buffer

AudioQueueBufferRef buf = m_audioQueueBuffer[m_fillBufferIndex];

memcpy((char*)buf->mAudioData + m_bytesFilled, data, packetSize);

// fill out packet description to pass to enqueue() later on

m_packetDescs[m_packetsFilled] = *desc;

// Make sure the offset is relative to the start of the audio buffer

m_packetDescs[m_packetsFilled].mStartOffset = m_bytesFilled;

// keep track of bytes filled and packets filled

m_bytesFilled += packetSize;

m_packetsFilled++;

/* Maximum number of packets which can be contained in one buffer */

#define kAQMaxPacketDescs 512

/* If filled our buffer with packets, then commit it to the system */

if (m_packetsFilled >= kAQMaxPacketDescs) {

return enqueueBuffer();

}

return 1;

}

/* private */

void Audio_Queue::cleanup()

{

if (!initialized()) {

AQ_TRACE("%s: warning: attempt to cleanup an uninitialized audio queue. return.\\n", __PRETTY_FUNCTION__);

return;

}

if (AudioQueueDispose(m_outAQ, true) != 0) {

AQ_TRACE("%s: AudioQueueDispose failed!\\n", __PRETTY_FUNCTION__);

}

m_outAQ = 0;

m_fillBufferIndex = m_bytesFilled = m_packetsFilled = m_buffersUsed = m_processedPacketsSizeTotal = m_processedPacketsCount = 0;

for (size_t i=0; i < AQ_BUFFERS; i++) {

m_bufferInUse[i] = false;

}

queued_packet_t *cur = m_queuedHead;

while (cur) {

queued_packet_t *tmp = cur->next;

free(cur);

cur = tmp;

}

m_queuedHead = m_queuedHead = 0;

for (size_t i=0; i < m_cbrPacketDescriptions.size(); i++) {

delete[] m_cbrPacketDescriptions[i];

}

audio_stream.h

100

101

102

103

104

105

106

107

108

109

110

111

/*

* This file is part of the FreeStreamer project,

* See the file ''LICENSE'' for using the code.

*/

#ifndef ASTREAMER_AUDIO_STREAM_H

#define ASTREAMER_AUDIO_STREAM_H

#import "http_stream.h"

#include "audio_queue.h"

#include <AudioToolbox/AudioToolbox.h>

#include <string>

namespace astreamer {

enum Audio_Stream_Error {

AS_ERR_OPEN = 1, // Cannot open the audio stream

AS_ERR_STREAM_PARSE = 2, // Parse error

AS_ERR_NETWORK = 3 // Network error

};

class Audio_Stream_Delegate;

class Audio_Stream : public HTTP_Stream_Delegate, public Audio_Queue_Delegate {

public:

Audio_Stream_Delegate *m_delegate;

enum State {

STOPPED,

BUFFERING,

PLAYING,

SEEKING,

FAILED,

END_OF_FILE

};

Audio_Stream();

virtual ~Audio_Stream();

void open();

void close();

void pause();

unsigned timePlayedInSeconds();

unsigned durationInSeconds();

void seekToTime(unsigned newSeekTime);

void setUrl(CFURLRef url);

void setStrictContentTypeChecking(bool strictChecking);

void setDefaultContentType(std::string& defaultContentType);

State state();

/* Audio_Queue_Delegate */

void audioQueueStateChanged(Audio_Queue::State state);

void audioQueueBuffersEmpty();

void audioQueueOverflow();

void audioQueueUnderflow();

void audioQueueInitializationFailed();

/* HTTP_Stream_Delegate */

void streamIsReadyRead();

void streamHasBytesAvailable(UInt8 *data, UInt32 numBytes);

void streamEndEncountered();

void streamErrorOccurred();

void streamMetaDataAvailable(std::map<CFStringRef,CFStringRef> metaData);

private:

Audio_Stream(const Audio_Stream&);

Audio_Stream& operator=(const Audio_Stream&);

bool m_httpStreamRunning;

bool m_audioStreamParserRunning;

size_t m_contentLength;

State m_state;

HTTP_Stream *m_httpStream;

Audio_Queue *m_audioQueue;

AudioFileStreamID m_audioFileStream; // the audio file stream parser

SInt64 m_dataOffset;

unsigned m_seekTime;

bool m_strictContentTypeChecking;

std::string m_defaultContentType;

size_t contentLength();

void closeAndSignalError(int error);

void setState(State state);

static void propertyValueCallback(void *inClientData, AudioFileStreamID inAudioFileStream, AudioFileStreamPropertyID inPropertyID, UInt32 *ioFlags);

static void streamDataCallback(void *inClientData, UInt32 inNumberBytes, UInt32 inNumberPackets, const void *inInputData, AudioStreamPacketDescription *inPacketDescriptions);

AudioFileTypeID audioStreamTypeFromContentType(std::string contentType);

};

class Audio_Stream_Delegate {

public:

virtual void audioStreamStateChanged(Audio_Stream::State state) = 0;

virtual void audioStreamErrorOccurred(int errorCode) = 0;

virtual void audioStreamMetaDataAvailable(std::map<CFStringRef,CFStringRef> metaData) = 0;

};

} // namespace astreamer

#endif // ASTREAMER_AUDIO_STREAM_H

更多源码请点击下载：iOS音乐播放器实现代码

以上就是本文的全部内容，希望对大家的学习有所帮助，也希望大家多多支持快网idc。