| /* |
| * QuickTime Data Handler |
| * |
| * Copyright 2011 Aric Stewart for CodeWeavers |
| * |
| * This library is free software; you can redistribute it and/or |
| * modify it under the terms of the GNU Lesser General Public |
| * License as published by the Free Software Foundation; either |
| * version 2.1 of the License, or (at your option) any later version. |
| * |
| * This library is distributed in the hope that it will be useful, |
| * but WITHOUT ANY WARRANTY; without even the implied warranty of |
| * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
| * Lesser General Public License for more details. |
| * |
| * You should have received a copy of the GNU Lesser General Public |
| * License along with this library; if not, write to the Free Software |
| * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA |
| */ |
| |
| #include "config.h" |
| |
| #define ULONG CoreFoundation_ULONG |
| #define HRESULT CoreFoundation_HRESULT |
| |
| #define LoadResource __carbon_LoadResource |
| #define CompareString __carbon_CompareString |
| #define GetCurrentThread __carbon_GetCurrentThread |
| #define GetCurrentProcess __carbon_GetCurrentProcess |
| #define AnimatePalette __carbon_AnimatePalette |
| #define EqualRgn __carbon_EqualRgn |
| #define FillRgn __carbon_FillRgn |
| #define FrameRgn __carbon_FrameRgn |
| #define GetPixel __carbon_GetPixel |
| #define InvertRgn __carbon_InvertRgn |
| #define LineTo __carbon_LineTo |
| #define OffsetRgn __carbon_OffsetRgn |
| #define PaintRgn __carbon_PaintRgn |
| #define Polygon __carbon_Polygon |
| #define ResizePalette __carbon_ResizePalette |
| #define SetRectRgn __carbon_SetRectRgn |
| |
| #define CheckMenuItem __carbon_CheckMenuItem |
| #define DeleteMenu __carbon_DeleteMenu |
| #define DrawMenuBar __carbon_DrawMenuBar |
| #define EnableMenuItem __carbon_EnableMenuItem |
| #define EqualRect __carbon_EqualRect |
| #define FillRect __carbon_FillRect |
| #define FrameRect __carbon_FrameRect |
| #define GetCursor __carbon_GetCursor |
| #define GetMenu __carbon_GetMenu |
| #define InvertRect __carbon_InvertRect |
| #define IsWindowVisible __carbon_IsWindowVisible |
| #define MoveWindow __carbon_MoveWindow |
| #define OffsetRect __carbon_OffsetRect |
| #define PtInRect __carbon_PtInRect |
| #define SetCursor __carbon_SetCursor |
| #define SetRect __carbon_SetRect |
| #define ShowCursor __carbon_ShowCursor |
| #define ShowWindow __carbon_ShowWindow |
| #define UnionRect __carbon_UnionRect |
| |
| #include <QuickTime/QuickTimeComponents.h> |
| |
| #undef LoadResource |
| #undef CompareString |
| #undef GetCurrentThread |
| #undef _CDECL |
| #undef DPRINTF |
| #undef GetCurrentProcess |
| #undef AnimatePalette |
| #undef EqualRgn |
| #undef FillRgn |
| #undef FrameRgn |
| #undef GetPixel |
| #undef InvertRgn |
| #undef LineTo |
| #undef OffsetRgn |
| #undef PaintRgn |
| #undef Polygon |
| #undef ResizePalette |
| #undef SetRectRgn |
| #undef CheckMenuItem |
| #undef DeleteMenu |
| #undef DrawMenuBar |
| #undef EnableMenuItem |
| #undef EqualRect |
| #undef FillRect |
| #undef FrameRect |
| #undef GetCursor |
| #undef GetMenu |
| #undef InvertRect |
| #undef IsWindowVisible |
| #undef MoveWindow |
| #undef OffsetRect |
| #undef PtInRect |
| #undef SetCursor |
| #undef SetRect |
| #undef ShowCursor |
| #undef ShowWindow |
| #undef UnionRect |
| |
| #undef ULONG |
| #undef HRESULT |
| #undef DPRINTF |
| #undef STDMETHODCALLTYPE |
| |
| #include <assert.h> |
| #include <stdio.h> |
| #include <stdarg.h> |
| |
| #define NONAMELESSSTRUCT |
| #define NONAMELESSUNION |
| #define COBJMACROS |
| |
| #include "windef.h" |
| #include "winbase.h" |
| #include "wtypes.h" |
| #include "winuser.h" |
| #include "dshow.h" |
| |
| #include "wine/unicode.h" |
| #include "wine/debug.h" |
| |
| #include "qtprivate.h" |
| |
| WINE_DEFAULT_DEBUG_CHANNEL(qtdatahandler); |
| |
| static ComponentDescription myType = |
| { |
| 'dhlr', |
| 'WINE', |
| 'WINE', |
| 0, |
| 0 |
| }; |
| |
| typedef struct DHData |
| { |
| WineDataRefRecord dataRef; |
| |
| Ptr AsyncPtr; |
| long AsyncRefCon; |
| DataHCompletionUPP AsyncCompletionRtn; |
| } DHData; |
| |
| static pascal ComponentResult myComponentRoutineProc ( ComponentParameters * |
| cp, Handle componentStorage); |
| |
| void RegisterWineDataHandler( void ) |
| { |
| ComponentRoutineUPP MyComponentRoutineUPP; |
| |
| MyComponentRoutineUPP = NewComponentRoutineUPP(&myComponentRoutineProc); |
| RegisterComponent( &myType , MyComponentRoutineUPP, 0, NULL, NULL, NULL); |
| } |
| |
| static pascal ComponentResult myDataHCanUseDataRef ( DataHandler dh, |
| Handle dataRef, |
| long *useFlags |
| ) |
| { |
| WineDataRefRecord *record = (WineDataRefRecord*)(*dataRef); |
| TRACE("%p %p %p\n",dh,dataRef,useFlags); |
| if (record->pReader == NULL) |
| return badComponentSelector; |
| *useFlags = kDataHCanRead; |
| return noErr; |
| } |
| |
| static pascal ComponentResult myDataHSetDataRef ( DataHandler dh, Handle dataRef) |
| { |
| Handle storage = GetComponentInstanceStorage(dh); |
| DHData *data = (DHData*)*storage; |
| WineDataRefRecord* newRef = (WineDataRefRecord*)(*dataRef); |
| TRACE("\n"); |
| if (newRef->pReader != data->dataRef.pReader) |
| IAsyncReader_AddRef(newRef->pReader); |
| data->dataRef = *newRef; |
| return noErr; |
| } |
| |
| static pascal ComponentResult myDataHGetAvailableFileSize ( DataHandler dh, |
| long *fileSize) |
| { |
| Handle storage = GetComponentInstanceStorage(dh); |
| DHData *data = (DHData*)*storage; |
| LONGLONG total; |
| LONGLONG available; |
| |
| TRACE("%p\n",dh); |
| |
| IAsyncReader_Length(data->dataRef.pReader,&total,&available); |
| *fileSize = available; |
| return noErr; |
| } |
| |
| static pascal ComponentResult myDataHGetFileSize ( DataHandler dh, long *fileSize) |
| { |
| Handle storage = GetComponentInstanceStorage(dh); |
| DHData *data = (DHData*)*storage; |
| LONGLONG total; |
| LONGLONG available; |
| |
| TRACE("%p\n",dh); |
| |
| IAsyncReader_Length(data->dataRef.pReader,&total,&available); |
| *fileSize = total; |
| return noErr; |
| } |
| |
| static pascal ComponentResult myDataHScheduleData ( DataHandler dh, |
| Ptr PlaceToPutDataPtr, |
| long FileOffset, |
| long DataSize, |
| long RefCon, |
| DataHSchedulePtr scheduleRec, |
| DataHCompletionUPP CompletionRtn) |
| { |
| Handle storage = GetComponentInstanceStorage(dh); |
| DHData *data = (DHData*)*storage; |
| HRESULT hr; |
| LONGLONG offset = FileOffset; |
| BYTE* buffer = (BYTE*)PlaceToPutDataPtr; |
| |
| TRACE("%p %p %li %li %li %p %p\n",dh, PlaceToPutDataPtr, FileOffset, DataSize, RefCon, scheduleRec, CompletionRtn); |
| |
| hr = IAsyncReader_SyncRead(data->dataRef.pReader, offset, DataSize, buffer); |
| TRACE("result %x\n",hr); |
| if (CompletionRtn) |
| { |
| if (data->AsyncCompletionRtn) |
| InvokeDataHCompletionUPP(data->AsyncPtr, data->AsyncRefCon, noErr, data->AsyncCompletionRtn); |
| |
| data->AsyncPtr = PlaceToPutDataPtr; |
| data->AsyncRefCon = RefCon; |
| data->AsyncCompletionRtn = CompletionRtn; |
| } |
| |
| return noErr; |
| } |
| |
| static pascal ComponentResult myDataHFinishData (DataHandler dh, Ptr PlaceToPutDataPtr, Boolean Cancel) |
| { |
| Handle storage = GetComponentInstanceStorage(dh); |
| DHData *data = (DHData*)*storage; |
| if (!data->AsyncCompletionRtn) |
| return noErr; |
| if (!PlaceToPutDataPtr || PlaceToPutDataPtr == data->AsyncPtr) |
| { |
| if (!Cancel) |
| InvokeDataHCompletionUPP(data->AsyncPtr, data->AsyncRefCon, noErr, data->AsyncCompletionRtn); |
| data->AsyncPtr = NULL; |
| data->AsyncRefCon = 0; |
| data->AsyncCompletionRtn = NULL; |
| } |
| return noErr; |
| } |
| |
| static pascal ComponentResult myDataHGetData ( DataHandler dh, |
| Handle h, |
| long hOffset, |
| long offset, |
| long size) |
| { |
| Handle storage = GetComponentInstanceStorage(dh); |
| DHData *data = (DHData*)*storage; |
| BYTE *target = (BYTE*)*h; |
| LONGLONG off = offset; |
| HRESULT hr; |
| |
| TRACE("%p %p %li %li %li\n",dh, h, hOffset, offset, size); |
| hr = IAsyncReader_SyncRead(data->dataRef.pReader, off, size, target+hOffset); |
| TRACE("result %x\n",hr); |
| |
| return noErr; |
| } |
| |
| static pascal ComponentResult myDataHCompareDataRef ( DataHandler dh, |
| Handle dataRef, Boolean *equal) |
| { |
| WineDataRefRecord *ptr1; |
| Handle storage = GetComponentInstanceStorage(dh); |
| DHData *data = (DHData*)*storage; |
| TRACE("\n"); |
| |
| ptr1 = (WineDataRefRecord*)dataRef; |
| |
| *equal = (ptr1->pReader == data->dataRef.pReader); |
| return noErr; |
| } |
| |
| static pascal ComponentResult myDataHGetDataRef ( DataHandler dh, Handle *dataRef) |
| { |
| Handle storage = GetComponentInstanceStorage(dh); |
| TRACE("\n"); |
| *dataRef = storage; |
| HandToHand(dataRef); |
| return noErr; |
| } |
| |
| static pascal ComponentResult myDataHGetScheduleAheadTime ( DataHandler dh, |
| long *millisecs) |
| { |
| TRACE("\n"); |
| *millisecs = 1000; |
| return noErr; |
| } |
| |
| static pascal ComponentResult myDataHGetInfoFlags ( DataHandler dh, UInt32 *flags) |
| { |
| TRACE("\n"); |
| *flags = 0; |
| return noErr; |
| } |
| |
| static pascal ComponentResult myDataHGetFileTypeOrdering ( DataHandler dh, |
| DataHFileTypeOrderingHandle *orderingListHandle) |
| { |
| OSType orderlist[1] = {kDataHFileTypeExtension}; |
| TRACE("\n"); |
| PtrToHand( &orderlist, (Handle*)orderingListHandle, sizeof(OSType)); |
| return noErr; |
| } |
| |
| typedef struct { |
| const char *const fname; |
| const int sig_length; |
| const BYTE sig[10]; |
| } signature; |
| |
| static const signature stream_sigs[] = { |
| {"video.asf",4,{0x30,0x26,0xb2,0x75}}, |
| {"video.mov",8,{0x00,0x00,0x00,0x14,0x66,0x74,0x79,0x70}}, |
| {"video.mp4",8,{0x00,0x00,0x00,0x18,0x66,0x74,0x79,0x70}}, |
| {"video.m4v",8,{0x00,0x00,0x00,0x1c,0x66,0x74,0x79,0x70}}, |
| {"video.flv",4,{0x46,0x4C,0x56,0x01}}, |
| {"video.mpg",3,{0x00,0x00,0x01}}, |
| {"avideo.rm",4,{0x2E,0x52,0x4D,0x46}} |
| }; |
| |
| static pascal ComponentResult myDataHGetFileName ( DataHandler dh, Str255 str) |
| { |
| Handle storage = GetComponentInstanceStorage(dh); |
| DHData *data = (DHData*)*storage; |
| TRACE("%p %s\n",str,debugstr_guid(&data->dataRef.streamSubtype)); |
| |
| /* Todo Expand this list */ |
| if (IsEqualIID(&data->dataRef.streamSubtype, &MEDIASUBTYPE_MPEG1Video) || |
| IsEqualIID(&data->dataRef.streamSubtype, &MEDIASUBTYPE_MPEG1System)) |
| CFStringGetPascalString(CFSTR("video.mpg"),str,256,kCFStringEncodingMacRoman); |
| else if(IsEqualIID(&data->dataRef.streamSubtype, &MEDIASUBTYPE_Asf)) |
| CFStringGetPascalString(CFSTR("video.asf"),str,256,kCFStringEncodingMacRoman); |
| else if(IsEqualIID(&data->dataRef.streamSubtype, &MEDIASUBTYPE_Avi)) |
| CFStringGetPascalString(CFSTR("video.avi"),str,256,kCFStringEncodingMacRoman); |
| else if(IsEqualIID(&data->dataRef.streamSubtype, &MEDIASUBTYPE_QTMovie)) |
| CFStringGetPascalString(CFSTR("video.mov"),str,256,kCFStringEncodingMacRoman); |
| else |
| { |
| BYTE header[10] = {0,0,0,0,0,0,0,0,0,0}; |
| int i; |
| IAsyncReader_SyncRead(data->dataRef.pReader, 0, 8, header); |
| |
| for (i=0; i < sizeof(stream_sigs)/sizeof(signature); i++) |
| if (memcmp(header, stream_sigs[i].sig, stream_sigs[i].sig_length)==0) |
| { |
| str[0] = strlen(stream_sigs[i].fname); |
| memcpy(str + 1, stream_sigs[i].fname, str[0]); |
| return noErr; |
| } |
| |
| return badComponentSelector; |
| } |
| |
| return noErr; |
| } |
| |
| static pascal ComponentResult myDataHOpenForRead(DataHandler dh) |
| { |
| TRACE("\n"); |
| return noErr; |
| } |
| |
| static pascal ComponentResult myDataHTask(DataHandler dh) |
| { |
| Handle storage = GetComponentInstanceStorage(dh); |
| DHData *data = (DHData*)*storage; |
| |
| if (data->AsyncCompletionRtn) |
| { |
| TRACE("Sending Completion\n"); |
| InvokeDataHCompletionUPP(data->AsyncPtr, data->AsyncRefCon, noErr, data->AsyncCompletionRtn); |
| data->AsyncPtr = NULL; |
| data->AsyncRefCon = 0; |
| data->AsyncCompletionRtn = NULL; |
| } |
| return noErr; |
| } |
| |
| static pascal ComponentResult myDataHPlaybackHints(DataHandler dh, long flags, |
| unsigned long minFileOffset, unsigned long maxFileOffset, |
| long bytesPerSecond) |
| { |
| TRACE("%lu %lu %li\n",minFileOffset, maxFileOffset, bytesPerSecond); |
| return noErr; |
| } |
| |
| static pascal ComponentResult myDataHPlaybackHints64(DataHandler dh, long flags, |
| wide *minFileOffset, wide *maxFileOffset, |
| long bytesPerSecond) |
| { |
| if (TRACE_ON(qtdatahandler)) |
| { |
| SInt64 minFileOffset64 = WideToSInt64(*minFileOffset); |
| LONGLONG minFileOffsetLL = minFileOffset64; |
| SInt64 maxFileOffset64 = WideToSInt64(*maxFileOffset); |
| LONGLONG maxFileOffsetLL = maxFileOffset64; |
| |
| TRACE("%s %s %li\n",wine_dbgstr_longlong(minFileOffsetLL), wine_dbgstr_longlong(maxFileOffsetLL), bytesPerSecond); |
| } |
| return noErr; |
| } |
| |
| static pascal ComponentResult myDataHGetFileSize64(DataHandler dh, wide * fileSize) |
| { |
| Handle storage = GetComponentInstanceStorage(dh); |
| DHData *data = (DHData*)*storage; |
| LONGLONG total; |
| LONGLONG available; |
| SInt64 total64; |
| |
| TRACE("%p\n",dh); |
| |
| IAsyncReader_Length(data->dataRef.pReader,&total,&available); |
| total64 = total; |
| *fileSize = SInt64ToWide(total64); |
| return noErr; |
| } |
| |
| static pascal ComponentResult myDataHGetFileSizeAsync ( DataHandler dh, wide *fileSize, DataHCompletionUPP CompletionRtn, long RefCon ) |
| { |
| Handle storage = GetComponentInstanceStorage(dh); |
| DHData *data = (DHData*)*storage; |
| LONGLONG total; |
| LONGLONG available; |
| SInt64 total64; |
| |
| TRACE("%p\n",dh); |
| |
| IAsyncReader_Length(data->dataRef.pReader,&total,&available); |
| total64 = total; |
| *fileSize = SInt64ToWide(total64); |
| |
| if (CompletionRtn) |
| { |
| if (data->AsyncCompletionRtn) |
| InvokeDataHCompletionUPP(data->AsyncPtr, data->AsyncRefCon, noErr, data->AsyncCompletionRtn); |
| |
| data->AsyncPtr = (Ptr)fileSize; |
| data->AsyncRefCon = RefCon; |
| data->AsyncCompletionRtn = CompletionRtn; |
| } |
| |
| return noErr; |
| } |
| |
| static pascal ComponentResult myDataHGetAvailableFileSize64(DataHandler dh, wide * fileSize) |
| { |
| Handle storage = GetComponentInstanceStorage(dh); |
| DHData *data = (DHData*)*storage; |
| LONGLONG total; |
| LONGLONG available; |
| SInt64 total64; |
| |
| TRACE("%p\n",dh); |
| |
| IAsyncReader_Length(data->dataRef.pReader,&total,&available); |
| total64 = available; |
| *fileSize = SInt64ToWide(total64); |
| return noErr; |
| } |
| |
| static pascal ComponentResult myDataHScheduleData64( DataHandler dh, |
| Ptr PlaceToPutDataPtr, |
| const wide * FileOffset, |
| long DataSize, |
| long RefCon, |
| DataHSchedulePtr scheduleRec, |
| DataHCompletionUPP CompletionRtn) |
| { |
| Handle storage = GetComponentInstanceStorage(dh); |
| DHData *data = (DHData*)*storage; |
| HRESULT hr; |
| SInt64 fileOffset64 = WideToSInt64(*FileOffset); |
| LONGLONG offset = fileOffset64; |
| BYTE* buffer = (BYTE*)PlaceToPutDataPtr; |
| |
| TRACE("%p %p %s %li %li %p %p\n",dh, PlaceToPutDataPtr, wine_dbgstr_longlong(offset), DataSize, RefCon, scheduleRec, CompletionRtn); |
| |
| hr = IAsyncReader_SyncRead(data->dataRef.pReader, offset, DataSize, buffer); |
| TRACE("result %x\n",hr); |
| if (CompletionRtn) |
| { |
| if (data->AsyncCompletionRtn) |
| InvokeDataHCompletionUPP(data->AsyncPtr, data->AsyncRefCon, noErr, data->AsyncCompletionRtn); |
| |
| data->AsyncPtr = PlaceToPutDataPtr; |
| data->AsyncRefCon = RefCon; |
| data->AsyncCompletionRtn = CompletionRtn; |
| } |
| |
| return noErr; |
| } |
| |
| static const struct { LPVOID proc; ProcInfoType type;} componentFunctions[] = |
| { |
| {NULL, 0}, /* 0 */ |
| {NULL, 0}, /* 1 */ |
| {myDataHGetData, kPascalStackBased |
| | RESULT_SIZE(SIZE_CODE(sizeof(ComponentResult))) |
| | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(DataHandler))) |
| | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(Handle))) |
| | STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(long))) |
| | STACK_ROUTINE_PARAMETER(4, SIZE_CODE(sizeof(long))) |
| | STACK_ROUTINE_PARAMETER(5, SIZE_CODE(sizeof(long))) |
| }, /* kDataHGetDataSelect */ |
| {NULL, 0}, /* kDataHPutDataSelect */ |
| {NULL, 0}, /* kDataHFlushDataSelect */ |
| {NULL, 0}, /* kDataHOpenForWriteSelect */ |
| {NULL, 0}, /* kDataHCloseForWriteSelect */ |
| {NULL, 0}, /* 7 */ |
| {myDataHOpenForRead, kPascalStackBased |
| | RESULT_SIZE(SIZE_CODE(sizeof(ComponentResult))) |
| | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(DataHandler))) |
| }, /* kDataHOpenForReadSelect |
| */ |
| {NULL, 0}, /* kDataHCloseForReadSelect */ |
| {myDataHSetDataRef, kPascalStackBased |
| | RESULT_SIZE(SIZE_CODE(sizeof(ComponentResult))) |
| | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(DataHandler))) |
| | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(Handle))) |
| }, /* kDataHSetDataRefSelect */ |
| {myDataHGetDataRef, kPascalStackBased |
| | RESULT_SIZE(SIZE_CODE(sizeof(ComponentResult))) |
| | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(DataHandler))) |
| | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(Handle))) |
| }, /* kDataHGetDataRefSelect */ |
| {myDataHCompareDataRef, kPascalStackBased |
| | RESULT_SIZE(SIZE_CODE(sizeof(ComponentResult))) |
| | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(DataHandler))) |
| | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(Handle))) |
| | STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(Boolean*))) |
| }, /* kDataHCompareDataRefSelect */ |
| {myDataHTask, kPascalStackBased |
| | RESULT_SIZE(SIZE_CODE(sizeof(ComponentResult))) |
| | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(DataHandler))) |
| }, /* kDataHTaskSelect */ |
| {myDataHScheduleData, kPascalStackBased |
| | RESULT_SIZE(SIZE_CODE(sizeof(ComponentResult))) |
| | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(DataHandler))) |
| | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(Ptr))) |
| | STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(long))) |
| | STACK_ROUTINE_PARAMETER(4, SIZE_CODE(sizeof(long))) |
| | STACK_ROUTINE_PARAMETER(5, SIZE_CODE(sizeof(long))) |
| | STACK_ROUTINE_PARAMETER(6, SIZE_CODE(sizeof(DataHSchedulePtr))) |
| | STACK_ROUTINE_PARAMETER(7, SIZE_CODE(sizeof(DataHCompletionUPP))) |
| }, /* kDataHScheduleDataSelect */ |
| {myDataHFinishData, kPascalStackBased |
| | RESULT_SIZE(SIZE_CODE(sizeof(ComponentResult))) |
| | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(DataHandler))) |
| | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(Ptr))) |
| | STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(Boolean))) |
| }, /* kDataHFinishDataSelect */ |
| {NULL, 0}, /* kDataHFlushCacheSelect 0x10 */ |
| {NULL, 0}, /* kDataHResolveDataRefSelect */ |
| {myDataHGetFileSize, kPascalStackBased |
| | RESULT_SIZE(SIZE_CODE(sizeof(ComponentResult))) |
| | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(DataHandler))) |
| | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(long*))) |
| }, /* kDataHGetFileSizeSelect */ |
| {myDataHCanUseDataRef, kPascalStackBased |
| | RESULT_SIZE(SIZE_CODE(sizeof(ComponentResult))) |
| | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(DataHandler))) |
| | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(Handle))) |
| | STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(long*))) |
| }, /* kDataHCanUseDataRefSelect */ |
| {NULL, 0}, /* kDataHGetVolumeListSelect */ |
| {NULL, 0}, /* kDataHWriteSelect */ |
| {NULL, 0}, /* kDataHPreextendSelect */ |
| {NULL, 0}, /* kDataHSetFileSizeSelect */ |
| {NULL, 0}, /* kDataHGetFreeSpaceSelect */ |
| {NULL, 0}, /* kDataHCreateFileSelect */ |
| {NULL, 0}, /* kDataHGetPreferredBlockSizeSelect */ |
| {NULL, 0}, /* kDataHGetDeviceIndexSelect */ |
| {NULL, 0}, /* kDataHIsStreamingDataHandlerSelect */ |
| {NULL, 0}, /* kDataHGetDataInBufferSelect */ |
| {myDataHGetScheduleAheadTime, kPascalStackBased |
| | RESULT_SIZE(SIZE_CODE(sizeof(ComponentResult))) |
| | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(DataHandler))) |
| | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(long*))) |
| }, /* kDataHGetScheduleAheadTimeSelect */ |
| /* End of Required List */ |
| {NULL, 0}, /* kDataHSetCacheSizeLimitSelect */ |
| {NULL, 0}, /* kDataHGetCacheSizeLimitSelect 0x20 */ |
| {NULL, 0}, /* kDataHGetMovieSelect */ |
| {NULL, 0}, /* kDataHAddMovieSelect */ |
| {NULL, 0}, /* kDataHUpdateMovieSelect */ |
| {NULL, 0}, /* kDataHDoesBufferSelect */ |
| {myDataHGetFileName, kPascalStackBased |
| | RESULT_SIZE(SIZE_CODE(sizeof(ComponentResult))) |
| | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(DataHandler))) |
| | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(Str255*))) |
| }, /* kDataHGetFileNameSelect */ |
| {myDataHGetAvailableFileSize, kPascalStackBased |
| | RESULT_SIZE(SIZE_CODE(sizeof(ComponentResult))) |
| | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(DataHandler))) |
| | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(long*))) |
| }, /* kDataHGetAvailableFileSizeSelect */ |
| {NULL, 0}, /* kDataHGetMacOSFileTypeSelect */ |
| {NULL, 0}, /* kDataHGetMIMETypeSelect */ |
| {NULL, 0}, /* kDataHSetDataRefWithAnchorSelect */ |
| {NULL, 0}, /* kDataHGetDataRefWithAnchorSelect */ |
| {NULL, 0}, /* kDataHSetMacOSFileTypeSelect */ |
| {NULL, 0}, /* kDataHSetTimeBaseSelect */ |
| {myDataHGetInfoFlags, kPascalStackBased |
| | RESULT_SIZE(SIZE_CODE(sizeof(ComponentResult))) |
| | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(DataHandler))) |
| | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(UInt32*))) |
| }, /* kDataHGetInfoFlagsSelect */ |
| {myDataHScheduleData64, kPascalStackBased |
| | RESULT_SIZE(SIZE_CODE(sizeof(ComponentResult))) |
| | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(DataHandler))) |
| | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(Ptr))) |
| | STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(wide*))) |
| | STACK_ROUTINE_PARAMETER(4, SIZE_CODE(sizeof(long))) |
| | STACK_ROUTINE_PARAMETER(5, SIZE_CODE(sizeof(long))) |
| | STACK_ROUTINE_PARAMETER(6, SIZE_CODE(sizeof(DataHSchedulePtr))) |
| | STACK_ROUTINE_PARAMETER(7, SIZE_CODE(sizeof(DataHCompletionUPP))) |
| }, /* kDataHScheduleData64Select */ |
| {NULL, 0}, /* kDataHWrite64Select */ |
| {myDataHGetFileSize64, kPascalStackBased |
| | RESULT_SIZE(SIZE_CODE(sizeof(ComponentResult))) |
| | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(DataHandler))) |
| | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(wide*))) |
| }, /* kDataHGetFileSize64Select 0x30 */ |
| {NULL, 0}, /* kDataHPreextend64Select */ |
| {NULL, 0}, /* kDataHSetFileSize64Select */ |
| {NULL, 0}, /* kDataHGetFreeSpace64Select */ |
| {NULL, 0}, /* kDataHAppend64Select */ |
| {NULL, 0}, /* kDataHReadAsyncSelect */ |
| {NULL, 0}, /* kDataHPollReadSelect */ |
| {NULL, 0}, /* kDataHGetDataAvailabilitySelect */ |
| {NULL, 0}, /* 0x0038 */ |
| {NULL, 0}, /* 0x0039 */ |
| {myDataHGetFileSizeAsync, kPascalStackBased |
| | RESULT_SIZE(SIZE_CODE(sizeof(ComponentResult))) |
| | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(DataHandler))) |
| | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(wide*))) |
| | STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(DataHCompletionUPP))) |
| | STACK_ROUTINE_PARAMETER(4, SIZE_CODE(sizeof(long))) |
| }, /* kDataHGetFileSizeAsyncSelect */ |
| {NULL, 0}, /* kDataHGetDataRefAsTypeSelect */ |
| {NULL, 0}, /* kDataHSetDataRefExtensionSelect */ |
| {NULL, 0}, /* kDataHGetDataRefExtensionSelect */ |
| {NULL, 0}, /* kDataHGetMovieWithFlagsSelect */ |
| {NULL, 0}, /* 0x3F */ |
| {myDataHGetFileTypeOrdering, kPascalStackBased |
| | RESULT_SIZE(SIZE_CODE(sizeof(ComponentResult))) |
| | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(DataHandler))) |
| | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(DataHFileTypeOrderingHandle*))) |
| }, /* kDataHGetFileTypeOrderingSelect 0x40 */ |
| {NULL, 0}, /* kDataHCreateFileWithFlagsSelect */ |
| {NULL, 0}, /* kDataHGetMIMETypeAsyncSelect */ |
| {NULL, 0}, /* kDataHGetInfoSelect */ |
| {NULL, 0}, /* kDataHSetIdleManagerSelect */ |
| {NULL, 0}, /* kDataHDeleteFileSelect */ |
| {NULL, 0}, /* kDataHSetMovieUsageFlagsSelect */ |
| {NULL, 0}, /* kDataHUseTemporaryDataRefSelect */ |
| {NULL, 0}, /* kDataHGetTemporaryDataRefCapabilitiesSelect */ |
| {NULL, 0}, /* kDataHRenameFileSelect */ |
| {NULL, 0}, /* 0x4A */ |
| {NULL, 0}, /* 0x4B */ |
| {NULL, 0}, /* 0x4C */ |
| {NULL, 0}, /* 0x4D */ |
| {myDataHGetAvailableFileSize64, kPascalStackBased |
| | RESULT_SIZE(SIZE_CODE(sizeof(ComponentResult))) |
| | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(DataHandler))) |
| | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(wide*))) |
| }, /* kDataHGetAvailableFileSize64Select */ |
| {NULL, 0}, /* kDataHGetDataAvailability64Select */ |
| }; |
| |
| static const struct { LPVOID proc; ProcInfoType type;} componentFunctions_2[] = |
| { |
| {myDataHPlaybackHints, kPascalStackBased |
| | RESULT_SIZE(SIZE_CODE(sizeof(ComponentResult))) |
| | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(DataHandler))) |
| | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(long))) |
| | STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(unsigned long))) |
| | STACK_ROUTINE_PARAMETER(4, SIZE_CODE(sizeof(unsigned long))) |
| | STACK_ROUTINE_PARAMETER(5, SIZE_CODE(sizeof(long))) |
| }, /* kDataHPlaybackHintsSelect 0x103 */ |
| {myDataHPlaybackHints64, kPascalStackBased |
| | RESULT_SIZE(SIZE_CODE(sizeof(ComponentResult))) |
| | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(DataHandler))) |
| | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(long))) |
| | STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(wide*))) |
| | STACK_ROUTINE_PARAMETER(4, SIZE_CODE(sizeof(wide*))) |
| | STACK_ROUTINE_PARAMETER(5, SIZE_CODE(sizeof(long))) |
| }, /* kDataHPlaybackHints64Select 0x10E */ |
| {NULL, 0}, /* kDataHGetDataRateSelect 0x110 */ |
| {NULL, 0}, /* kDataHSetTimeHintsSelect 0x111 */ |
| }; |
| |
| /* Component Functions */ |
| |
| static pascal ComponentResult myComponentOpen(ComponentInstance ci, ComponentInstance self) |
| { |
| DHData myData; |
| Handle storage; |
| |
| ZeroMemory(&myData,sizeof(DHData)); |
| PtrToHand( &myData, &storage, sizeof(DHData)); |
| SetComponentInstanceStorage(self,storage); |
| |
| return noErr; |
| } |
| |
| static pascal ComponentResult myComponentClose(ComponentInstance ci, ComponentInstance self) |
| { |
| Handle storage = GetComponentInstanceStorage(self); |
| DHData *data; |
| if (storage) |
| { |
| data = (DHData*)*storage; |
| if (data && data->dataRef.pReader != NULL) |
| IAsyncReader_Release(data->dataRef.pReader); |
| DisposeHandle(storage); |
| SetComponentInstanceStorage(self,NULL); |
| } |
| return noErr; |
| } |
| |
| static pascal ComponentResult myComponentCanDo(ComponentInstance ci, SInt16 ftnNumber) |
| { |
| TRACE("test 0x%x\n",ftnNumber); |
| if (ftnNumber <= kComponentOpenSelect && ftnNumber >= kComponentCanDoSelect) |
| return TRUE; |
| if (ftnNumber == kDataHPlaybackHintsSelect) |
| return TRUE; |
| if (ftnNumber == kDataHPlaybackHints64Select) |
| return TRUE; |
| if (ftnNumber > kDataHGetDataAvailability64Select) |
| return FALSE; |
| TRACE("impl? %i\n",(componentFunctions[ftnNumber].proc != NULL)); |
| return (componentFunctions[ftnNumber].proc != NULL); |
| } |
| |
| /* Main Proc */ |
| |
| static ComponentResult callOurFunction(LPVOID proc, ProcInfoType type, ComponentParameters * cp) |
| { |
| ComponentRoutineUPP myUUP; |
| ComponentResult result; |
| |
| myUUP = NewComponentFunctionUPP(proc, type); |
| result = CallComponentFunction(cp, myUUP); |
| DisposeComponentFunctionUPP(myUUP); |
| return result; |
| } |
| |
| static pascal ComponentResult myComponentRoutineProc ( ComponentParameters * cp, |
| Handle componentStorage) |
| { |
| switch (cp->what) |
| { |
| case kComponentOpenSelect: |
| return callOurFunction(myComponentOpen, uppCallComponentOpenProcInfo, cp); |
| case kComponentCloseSelect: |
| return callOurFunction(myComponentClose, uppCallComponentOpenProcInfo, cp); |
| case kComponentCanDoSelect: |
| return callOurFunction(myComponentCanDo, uppCallComponentCanDoProcInfo, cp); |
| case kDataHPlaybackHintsSelect: |
| return callOurFunction(componentFunctions_2[0].proc, componentFunctions_2[0].type, cp); |
| case kDataHPlaybackHints64Select: |
| return callOurFunction(componentFunctions_2[1].proc, componentFunctions_2[1].type, cp); |
| } |
| |
| if (cp->what > 0 && cp->what <=kDataHGetDataAvailability64Select && componentFunctions[cp->what].proc) |
| return callOurFunction(componentFunctions[cp->what].proc, componentFunctions[cp->what].type, cp); |
| |
| FIXME("unhandled select 0x%x\n",cp->what); |
| return badComponentSelector; |
| } |
