Attachment #213768 for bug #297910

View | Details | Raw Unified | Return to bug 297910
Collapse All | Expand All




++ cynthiune.app-0.9.5/Bundles/Musepack/CNSFileHandle.h

#ifndef CNSFILEHANDLE_H
#define CNSFILEHANDLE_H

#import <mpc/reader.h>

#ifdef __cplusplus
extern "C" {
#endif /* __cplusplus */

int CNSFileHandleRead (mpc_reader *fileHandle, void *ptr, int size);
int CNSFileHandleTell (mpc_reader *fileHandle);
mpc_bool_t CNSFileHandleCanSeek (mpc_reader *fileHandle);
mpc_bool_t CNSFileHandleSeek (mpc_reader *fileHandle, int offset);
int CNSFileHandleGetSize (mpc_reader *fileHandle);
mpc_bool_t CNSFileHandleCanSeek (void *fileHandle);
mpc_bool_t CNSFileHandleSeek (void *fileHandle, int offset);
int CNSFileHandleGetSize (void *fileHandle);

#ifdef __cplusplus
}
++ cynthiune.app-0.9.5/Bundles/Musepack/CNSFileHandle.m


#import "CNSFileHandle.h"

void
CNSFileHandleRetain (void *fileHandle)
{
  [(NSFileHandle *) fileHandle retain];
}

void
CNSFileHandleRelease (void *fileHandle)
{
  [(NSFileHandle *) fileHandle release];
}

int
CNSFileHandleRead (mpc_reader *fileHandle, void *ptr, int size)
{
  NSData *data;

  data = [(NSFileHandle *) fileHandle->data readDataOfLength: size];
  [data getBytes: ptr];

  return [data length];
}

int
CNSFileHandleTell (mpc_reader *fileHandle)
{
  return [(NSFileHandle *) fileHandle->data offsetInFile];
}

mpc_bool_t
CNSFileHandleCanSeek (mpc_reader *fileHandle)
{
  return YES;
}

mpc_bool_t
CNSFileHandleSeek (mpc_reader *fileHandle, int offset)
{
  [(NSFileHandle *) fileHandle->data seekToFileOffset: (long long) offset];

  return YES;
}

int
CNSFileHandleGetSize (mpc_reader *fileHandle)
{
  int size, where;

  where = [(NSFileHandle *) fileHandle->data offsetInFile];
  size = [(NSFileHandle *) fileHandle->data seekToEndOfFile];
  [(NSFileHandle *) fileHandle->data seekToFileOffset: (long long) where];

  return size;
}
++ cynthiune.app-0.9.5/Bundles/Musepack/Musepack.h


  mpc_reader *mpcReader;
  mpc_streaminfo *mpcStreamInfo;
  mpc_demux *mpcDecoder;

  MPC_SAMPLE_FORMAT sampleBuffer[maxSamples];
  unsigned char frameBuffer[maxSamples * 4];
++ cynthiune.app-0.9.5/Bundles/Musepack/Musepack.m

#import <Cynthiune/Format.h>
#import <Cynthiune/utils.h>

#import <mpc/mpcdec.h>

#import "Musepack.h"
#import "CNSFileHandle.h"

MPCReaderDelete (mpc_reader *reader)
{
  [(NSFileHandle *) reader->data release];
  mpc_reader_exit_stdio (reader);
}

static mpc_streaminfo *

  mpc_streaminfo *streamInfo;

  streamInfo = malloc (sizeof (mpc_streaminfo));
  mpc_streaminfo_init (streamInfo);

  return streamInfo;
}

static mpc_decoder *
MPCDecoderNew (mpc_reader *reader, mpc_streaminfo *streamInfo)
{
  mpc_decoder *decoder;

  decoder = malloc (sizeof (mpc_decoder));
  mpc_decoder_setup (decoder, reader);
  mpc_decoder_initialize (decoder, streamInfo);

  return decoder;
}

static inline void
CopyBuffer (const MPC_SAMPLE_FORMAT *buffer, unsigned char *destBuffer,
            unsigned int length)

    {
      [fileHandle retain];
      mpcReader = MPCReaderNew (fileHandle);
      if (!mpcReader)
      	return MPC_FALSE;
      mpcStreamInfo = MPCStreamInfoNew ();
      mpcDecoder = mpc_demux_init (mpcReader);
      if (!mpcDecoder)
 	return MPC_FALSE;
      mpc_demux_get_info (mpcDecoder, mpcStreamInfo);

      result = YES;
    }

  NSFileHandle *testFileHandle;
  mpc_reader *testReader;
  mpc_streaminfo *testStreamInfo;
  mpc_demux *testDecoder;
  BOOL result;

  testFileHandle = [NSFileHandle fileHandleForReadingAtPath: fileName];

    {
      testReader = MPCReaderNew (testFileHandle);
      testStreamInfo = MPCStreamInfoNew ();
      testDecoder = mpc_demux_init (testReader);
      if (testDecoder)
	{
	  result = YES;
	  mpc_demux_exit (testDecoder);
	}
      if (testReader)
	MPCReaderDelete (testReader);
    }
  else
    result = NO;

	     withSize: (unsigned int) bufferSize
{
  int bytes, status;
  mpc_frame_info frame;
  mpc_status err;
  unsigned long frames, samples;

  status = 1;
  frame.buffer = sampleBuffer;

  while (!remaining)
    {
      err = mpc_demux_decode (mpcDecoder, &frame);
      if (err != MPC_STATUS_OK)
	{
	  status = -1;
	  break;
	}
      else if (frame.bits == -1)
	{
	  status = 0;
	  break;
	}
      else
        {
	   samples = frame.samples;
          frames = samples * mpcStreamInfo->channels;
          CopyBuffer (sampleBuffer, frameBuffer, frames);
          remaining = frames * 2;


- (unsigned int) readDuration
{
  return (unsigned int) mpc_streaminfo_get_length (mpcStreamInfo);
}

- (void) streamClose

      [fileHandle closeFile];
      [fileHandle release];
    }
  if (mpcDecoder)
    mpc_demux_exit (mpcDecoder);
  if (mpcReader)
    MPCReaderDelete (mpcReader);
  if (mpcStreamInfo)
    free (mpcStreamInfo);
  if (mpcDecoder)
    free (mpcDecoder);

  [self _resetIVars];
}

// Player Protocol
+ (NSArray *) acceptedFileExtensions
{
  return [NSArray arrayWithObjects: @"mpc", @"mp+", @"mpp", nil];
}

- (BOOL) isSeekable


- (void) seek: (unsigned int) aPos
{
  mpc_demux_seek_second (mpcDecoder, (double) aPos);
}

@end

Return to bug 297910

Line Link Here

(-)file_not_specified_in_diff (-73 / +60 lines)
0	-- cynthiune.app-0.9.5.orig/Bundles/Musepack/CNSFileHandle.h	0	++ cynthiune.app-0.9.5/Bundles/Musepack/CNSFileHandle.h
Lines 23-42 Link Here
23	#ifndef CNSFILEHANDLE_H	23	#ifndef CNSFILEHANDLE_H
24	#define CNSFILEHANDLE_H	24	#define CNSFILEHANDLE_H
25		25
26	#include <mpcdec/config_types.h>	26	#import <mpc/reader.h>
27		27
28	#ifdef __cplusplus	28	#ifdef __cplusplus
29	extern "C" {	29	extern "C" {
30	#endif /* __cplusplus */	30	#endif /* __cplusplus */
31		31
32	void CNSFileHandleRetain (void *fileHandle);	32	int CNSFileHandleRead (mpc_reader fileHandle, void ptr, int size);
33	void CNSFileHandleRelease (void *fileHandle);	33	int CNSFileHandleTell (mpc_reader *fileHandle);
34		34	mpc_bool_t CNSFileHandleCanSeek (mpc_reader *fileHandle);
35	int CNSFileHandleRead (void fileHandle, void ptr, int size);	35	mpc_bool_t CNSFileHandleSeek (mpc_reader *fileHandle, int offset);
36	int CNSFileHandleTell (void *fileHandle);	36	int CNSFileHandleGetSize (mpc_reader *fileHandle);
37	mpc_bool_t CNSFileHandleCanSeek (void *fileHandle);
38	mpc_bool_t CNSFileHandleSeek (void *fileHandle, int offset);
39	int CNSFileHandleGetSize (void *fileHandle);
40		37
41	#ifdef __cplusplus	38	#ifdef __cplusplus
42	}	39	}
43	-- cynthiune.app-0.9.5.orig/Bundles/Musepack/CNSFileHandle.m	40	++ cynthiune.app-0.9.5/Bundles/Musepack/CNSFileHandle.m
Lines 26-82 Link Here
26		26
27	#import "CNSFileHandle.h"	27	#import "CNSFileHandle.h"
28		28
29	void
30	CNSFileHandleRetain (void *fileHandle)
31	{
32	[(NSFileHandle *) fileHandle retain];
33	}
34
35	void
36	CNSFileHandleRelease (void *fileHandle)
37	{
38	[(NSFileHandle *) fileHandle release];
39	}
40
41	int	29	int
42	CNSFileHandleRead (void fileHandle, void ptr, int size)	30	CNSFileHandleRead (mpc_reader fileHandle, void ptr, int size)
43	{	31	{
44	NSData *data;	32	NSData *data;
45		33
46	data = [(NSFileHandle *) fileHandle readDataOfLength: size];	34	data = [(NSFileHandle *) fileHandle->data readDataOfLength: size];
47	[data getBytes: ptr];	35	[data getBytes: ptr];
48		36
49	return [data length];	37	return [data length];
50	}	38	}
51		39
52	int	40	int
53	CNSFileHandleTell (void *fileHandle)	41	CNSFileHandleTell (mpc_reader *fileHandle)
54	{	42	{
55	return [(NSFileHandle *) fileHandle offsetInFile];	43	return [(NSFileHandle *) fileHandle->data offsetInFile];
56	}	44	}
57		45
58	mpc_bool_t	46	mpc_bool_t
59	CNSFileHandleCanSeek (void *fileHandle)	47	CNSFileHandleCanSeek (mpc_reader *fileHandle)
60	{	48	{
61	return YES;	49	return YES;
62	}	50	}
63		51
64	mpc_bool_t	52	mpc_bool_t
65	CNSFileHandleSeek (void *fileHandle, int offset)	53	CNSFileHandleSeek (mpc_reader *fileHandle, int offset)
66	{	54	{
67	[(NSFileHandle *) fileHandle seekToFileOffset: (long long) offset];	55	[(NSFileHandle *) fileHandle->data seekToFileOffset: (long long) offset];
68		56
69	return YES;	57	return YES;
70	}	58	}
71		59
72	int	60	int
73	CNSFileHandleGetSize (void *fileHandle)	61	CNSFileHandleGetSize (mpc_reader *fileHandle)
74	{	62	{
75	int size, where;	63	int size, where;
76		64
77	where = [(NSFileHandle *) fileHandle offsetInFile];	65	where = [(NSFileHandle *) fileHandle->data offsetInFile];
78	size = [(NSFileHandle *) fileHandle seekToEndOfFile];	66	size = [(NSFileHandle *) fileHandle->data seekToEndOfFile];
79	[(NSFileHandle *) fileHandle seekToFileOffset: (long long) where];	67	[(NSFileHandle *) fileHandle->data seekToFileOffset: (long long) where];
80		68
81	return size;	69	return size;
82	}	70	}
83	-- cynthiune.app-0.9.5.orig/Bundles/Musepack/Musepack.h	71	++ cynthiune.app-0.9.5/Bundles/Musepack/Musepack.h
Lines 31-37 Link Here
31		31
32	mpc_reader *mpcReader;	32	mpc_reader *mpcReader;
33	mpc_streaminfo *mpcStreamInfo;	33	mpc_streaminfo *mpcStreamInfo;
34	mpc_decoder *mpcDecoder;	34	mpc_demux *mpcDecoder;
35		35
36	MPC_SAMPLE_FORMAT sampleBuffer[maxSamples];	36	MPC_SAMPLE_FORMAT sampleBuffer[maxSamples];
37	unsigned char frameBuffer[maxSamples * 4];	37	unsigned char frameBuffer[maxSamples * 4];
38	-- cynthiune.app-0.9.5.orig/Bundles/Musepack/Musepack.m	38	++ cynthiune.app-0.9.5/Bundles/Musepack/Musepack.m
Lines 30-36 Link Here
30	#import <Cynthiune/Format.h>	30	#import <Cynthiune/Format.h>
31	#import <Cynthiune/utils.h>	31	#import <Cynthiune/utils.h>
32		32
33	#import <mpcdec/mpcdec.h>	33	#import <mpc/mpcdec.h>
34		34
35	#import "Musepack.h"	35	#import "Musepack.h"
36	#import "CNSFileHandle.h"	36	#import "CNSFileHandle.h"
Lines 75-81 Link Here
75	MPCReaderDelete (mpc_reader *reader)	75	MPCReaderDelete (mpc_reader *reader)
76	{	76	{
77	[(NSFileHandle *) reader->data release];	77	[(NSFileHandle *) reader->data release];
78	free (reader);	78	mpc_reader_exit_stdio (reader);
79	}	79	}
80		80
81	static mpc_streaminfo *	81	static mpc_streaminfo *
Lines 84-106 Link Here
84	mpc_streaminfo *streamInfo;	84	mpc_streaminfo *streamInfo;
85		85
86	streamInfo = malloc (sizeof (mpc_streaminfo));	86	streamInfo = malloc (sizeof (mpc_streaminfo));
87	mpc_streaminfo_init (streamInfo);
88		87
89	return streamInfo;	88	return streamInfo;
90	}	89	}
91		90
92	static mpc_decoder *
93	MPCDecoderNew (mpc_reader reader, mpc_streaminfo streamInfo)
94	{
95	mpc_decoder *decoder;
96
97	decoder = malloc (sizeof (mpc_decoder));
98	mpc_decoder_setup (decoder, reader);
99	mpc_decoder_initialize (decoder, streamInfo);
100
101	return decoder;
102	}
103
104	static inline void	91	static inline void
105	CopyBuffer (const MPC_SAMPLE_FORMAT buffer, unsigned char destBuffer,	92	CopyBuffer (const MPC_SAMPLE_FORMAT buffer, unsigned char destBuffer,
106	unsigned int length)	93	unsigned int length)
Lines 173-182 Link Here
173	{	160	{
174	[fileHandle retain];	161	[fileHandle retain];
175	mpcReader = MPCReaderNew (fileHandle);	162	mpcReader = MPCReaderNew (fileHandle);
		163	if (!mpcReader)
		164	return MPC_FALSE;
176	mpcStreamInfo = MPCStreamInfoNew ();	165	mpcStreamInfo = MPCStreamInfoNew ();
177	mpc_streaminfo_read (mpcStreamInfo, mpcReader);	166	mpcDecoder = mpc_demux_init (mpcReader);
178		167	if (!mpcDecoder)
179	mpcDecoder = MPCDecoderNew (mpcReader, mpcStreamInfo);	168	return MPC_FALSE;
		169	mpc_demux_get_info (mpcDecoder, mpcStreamInfo);
180		170
181	result = YES;	171	result = YES;
182	}	172	}
Lines 196-201 Link Here
196	NSFileHandle *testFileHandle;	186	NSFileHandle *testFileHandle;
197	mpc_reader *testReader;	187	mpc_reader *testReader;
198	mpc_streaminfo *testStreamInfo;	188	mpc_streaminfo *testStreamInfo;
		189	mpc_demux *testDecoder;
199	BOOL result;	190	BOOL result;
200		191
201	testFileHandle = [NSFileHandle fileHandleForReadingAtPath: fileName];	192	testFileHandle = [NSFileHandle fileHandleForReadingAtPath: fileName];
Lines 203-211 Link Here
203	{	194	{
204	testReader = MPCReaderNew (testFileHandle);	195	testReader = MPCReaderNew (testFileHandle);
205	testStreamInfo = MPCStreamInfoNew ();	196	testStreamInfo = MPCStreamInfoNew ();
206	result = !mpc_streaminfo_read (testStreamInfo, testReader);	197	testDecoder = mpc_demux_init (testReader);
207	free (testStreamInfo);	198	if (testDecoder)
208	MPCReaderDelete (testReader);	199	{
		200	result = YES;
		201	mpc_demux_exit (testDecoder);
		202	}
		203	if (testReader)
		204	MPCReaderDelete (testReader);
209	}	205	}
210	else	206	else
211	result = NO;	207	result = NO;
Lines 222-242 Link Here
222	withSize: (unsigned int) bufferSize	218	withSize: (unsigned int) bufferSize
223	{	219	{
224	int bytes, status;	220	int bytes, status;
225	unsigned int vbrAcc, vbrBits;	221	mpc_frame_info frame;
		222	mpc_status err;
226	unsigned long frames, samples;	223	unsigned long frames, samples;
227		224
228	status = 1;	225	status = 1;
		226	frame.buffer = sampleBuffer;
229		227
230	if (!remaining)	228	while (!remaining)
231	{	229	{
232	samples = mpc_decoder_decode (mpcDecoder, sampleBuffer,	230	err = mpc_demux_decode (mpcDecoder, &frame);
233	&vbrAcc, &vbrBits);	231	if (err != MPC_STATUS_OK)
234	if (!samples)	232	{
235	status = 0;	233	status = -1;
236	else if (samples == (unsigned long) -1)	234	break;
237	status = -1;	235	}
		236	else if (frame.bits == -1)
		237	{
		238	status = 0;
		239	break;
		240	}
238	else	241	else
239	{	242	{
		243	samples = frame.samples;
240	frames = samples * mpcStreamInfo->channels;	244	frames = samples * mpcStreamInfo->channels;
241	CopyBuffer (sampleBuffer, frameBuffer, frames);	245	CopyBuffer (sampleBuffer, frameBuffer, frames);
242	remaining = frames * 2;	246	remaining = frames * 2;
Lines 277-283 Link Here
277		281
278	- (unsigned int) readDuration	282	- (unsigned int) readDuration
279	{	283	{
280	return mpcStreamInfo->pcm_samples / mpcStreamInfo->sample_freq;	284	return (unsigned int) mpc_streaminfo_get_length (mpcStreamInfo);
281	}	285	}
282		286
283	- (void) streamClose	287	- (void) streamClose
Lines 287-298 Link Here
287	[fileHandle closeFile];	291	[fileHandle closeFile];
288	[fileHandle release];	292	[fileHandle release];
289	}	293	}
		294	if (mpcDecoder)
		295	mpc_demux_exit (mpcDecoder);
290	if (mpcReader)	296	if (mpcReader)
291	MPCReaderDelete (mpcReader);	297	MPCReaderDelete (mpcReader);
292	if (mpcStreamInfo)
293	free (mpcStreamInfo);
294	if (mpcDecoder)
295	free (mpcDecoder);
296		298
297	[self _resetIVars];	299	[self _resetIVars];
298	}	300	}
Lines 300-306 Link Here
300	// Player Protocol	302	// Player Protocol
301	+ (NSArray *) acceptedFileExtensions	303	+ (NSArray *) acceptedFileExtensions
302	{	304	{
303	return [NSArray arrayWithObjects: @"mpc", @"mp+", nil];	305	return [NSArray arrayWithObjects: @"mpc", @"mp+", @"mpp", nil];
304	}	306	}
305		307
306	- (BOOL) isSeekable	308	- (BOOL) isSeekable
Lines 310-316 Link Here
310		312
311	- (void) seek: (unsigned int) aPos	313	- (void) seek: (unsigned int) aPos
312	{	314	{
313	mpc_decoder_seek_seconds (mpcDecoder, (double) aPos);	315	mpc_demux_seek_second (mpcDecoder, (double) aPos);
314	}	316	}
315		317
316	@end	318	@end