Skip to content
Permalink
master
Switch branches/tags

Name already in use

A tag already exists with the provided branch name. Many Git commands accept both tag and branch names, so creating this branch may cause unexpected behavior. Are you sure you want to create this branch?
Go to file
 
 
Cannot retrieve contributors at this time
/*****************************************************************************
*
* Avi Import Component dataref interface for libavformat
*
* Copyright(C) 2006 Christoph Naegeli <chn1@mac.com>
*
* 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 Street, Fifth Floor, Boston, MA 02110-1301 USA
*
****************************************************************************/
#include <QuickTime/QuickTime.h>
#include <libavformat/avformat.h>
#include <libavformat/avio_internal.h>
struct _dataref_private {
Handle dataRef;
OSType dataRefType;
DataHandler dh;
int64_t pos;
int64_t size;
unsigned char supportsWideOffsets;
};
typedef struct _dataref_private dataref_private;
/* DataRef Wrapper for QuickTime */
static int dataref_update_filesize(dataref_private *private)
{
wide fsize;
ComponentResult result = DataHGetFileSize64(private->dh, &fsize);
if(result == noErr) {
private->size = (int64_t)fsize.lo;
private->size += (int64_t)fsize.hi << 32;
// Our data handler supports wide offsets. Remember for later use.
private->supportsWideOffsets = 1;
} else {
long size32;
result = DataHGetFileSize(private->dh, &size32);
require_noerr(result, bail);
private->size = size32;
}
bail:
return result;
}
/* !!! THIS FUNCTION ASSUMES h->priv_data IS VALID in contrary to the other open functions
* found in ffmpeg */
static int dataref_open(URLContext *h, const char *filename, int flags)
{
ComponentResult result;
dataref_private *private;
long access = 0;
if((flags & URL_RDWR) == URL_RDWR) {
access = kDataHCanRead | kDataHCanWrite;
} else if(flags & URL_WRONLY) {
access = kDataHCanWrite;
} else {
access = kDataHCanRead;
}
private = h->priv_data;
result = OpenAComponent(GetDataHandler(private->dataRef, private->dataRefType, access), &private->dh);
require_noerr(result,bail);
result = DataHSetDataRef(private->dh, private->dataRef);
require_noerr(result,bail);
if(access & kDataHCanRead) {
result = DataHOpenForRead(private->dh);
require_noerr(result,bail);
}
if(access & kDataHCanWrite) {
result = DataHOpenForWrite(private->dh);
require_noerr(result,bail);
}
private->pos = 0ll;
private->size = 0ll;
result = dataref_update_filesize(private);
require_noerr(result,bail);
bail:
return result;
} /* dataref_open() */
static int dataref_read(URLContext *h, unsigned char *buf, int size)
{
int result;
dataref_private *p = (dataref_private*)h->priv_data;
int read;
if (p->pos + size > p->size) {
// it tried to read past the end
// but since we cache the size, it might be wrong
// try to update the size before clipping the request
dataref_update_filesize(p);
}
if (p->pos >= p->size)
return 0; // can't read past the end
else
read = FFMIN(size, p->size - p->pos);
if(p->supportsWideOffsets) {
wide offset;
offset.hi = p->pos >> 32;
offset.lo = (UInt32)p->pos;
result = DataHScheduleData64(p->dh, (Ptr)buf, &offset, (long)read, 0, NULL, NULL);
if (result == badComponentSelector && offset.hi == 0) {
result = DataHScheduleData(p->dh, (Ptr)buf, offset.lo, (long)read, 0, NULL, NULL);
}
} else {
result = DataHScheduleData(p->dh, (Ptr)buf, (long)p->pos, (long)read, 0, NULL, NULL);
}
if(result != noErr) {
read = -1;
goto bail;
}
p->pos += read;
bail:
return (int)read;
} /* dataref_read() */
static int dataref_write(URLContext *h, const unsigned char *buf, int size)
{
int result;
int written = size;
dataref_private *p = (dataref_private*)h->priv_data;
if(p->supportsWideOffsets) {
wide offset;
offset.hi = p->pos >> 32;
offset.lo = (UInt32)p->pos;
result = DataHWrite64(p->dh, (Ptr)buf, &offset, size, NULL, 0);
} else {
result = DataHWrite(p->dh, (Ptr)buf, (long)p->pos, size, NULL, 0);
}
if(result != noErr) {
written = -1;
goto bail;
}
p->pos += written;
bail:
return written;
} /* dataref_write() */
static int64_t dataref_seek(URLContext *h, int64_t pos, int whence)
{
dataref_private *p = (dataref_private*)h->priv_data;
switch(whence) {
case SEEK_SET:
p->pos = pos;
break;
case SEEK_CUR:
p->pos += pos;
break;
case SEEK_END:
dataref_update_filesize(p);
p->pos = p->size + pos;
break;
case AVSEEK_SIZE:
dataref_update_filesize(p);
return p->size;
default:
return -1;
}
return p->pos;
} /* dataref_seek() */
static int dataref_close(URLContext *h)
{
dataref_private *p = (dataref_private*)h->priv_data;
CloseComponent(p->dh);
p->dh = 0;
p->pos = 0;
p->size = 0;
av_free(p);
h->priv_data = NULL;
return 0;
} /* dataref_close() */
URLProtocol dataref_protocol = {
"Data Ref",
dataref_open,
dataref_read,
dataref_write,
dataref_seek,
dataref_close,
};
/* This is the public function to open bytecontext withs datarefs */
OSStatus url_open_dataref(AVIOContext **pb, Handle dataRef, OSType dataRefType, DataHandler *dataHandler, Boolean *wideSupport, int64_t *dataSize)
{
URLContext *uc;
URLProtocol *up;
OSStatus err;
dataref_private *private;
private = av_mallocz(sizeof(dataref_private));
private->dataRef = dataRef;
private->dataRefType = dataRefType;
up = &dataref_protocol;
//FIXME use url_alloc() with better fake protocol, and avoid using avio_internal
uc = av_mallocz(sizeof(URLContext));
if(!uc) {
err = -ENOMEM;
return err;
}
uc->filename = NULL;
uc->prot = up;
uc->flags = URL_RDONLY; // we're just using the read access...
uc->is_streamed = 0; // not streamed...
uc->max_packet_size = 0; // stream file
uc->priv_data = private;
uc->is_connected = 1;
err = up->url_open(uc, uc->filename, URL_RDONLY);
if(err < 0) {
av_free(uc);
return err;
}
err = ffio_fdopen(pb, uc);
if(err < 0) {
ffurl_close(uc);
return err;
}
if(dataHandler)
*dataHandler = private->dh;
if(wideSupport)
*wideSupport = private->supportsWideOffsets;
if(dataSize)
*dataSize = private->size;
return noErr;
} /* url_open_dataref() */