bool
BufferRealloc(TBuffer * const buf,
xmlrpc_uint32_t const memsize) {
if (buf->staticid)
{
TBuffer b;
if (memsize<=buf->size)
return TRUE;
if (BufferAlloc(&b,memsize))
{
memcpy(b.data,buf->data,buf->size);
BufferFree(buf);
*buf=b;
return TRUE;
}
}
else
{
void *d;
d=realloc(buf->data,memsize);
if (d)
{
buf->data=d;
buf->size=memsize;
return TRUE;
}
}
return FALSE;
}
ps_canvas* PICAPI ps_canvas_create_compatible(const ps_canvas* c, int w, int h)
{
if (!picasso::is_valid_system_device()) {
global_status = STATUS_DEVICE_ERROR;
return NULL;
}
if (!c) {
global_status = STATUS_INVALID_ARGUMENT;
return NULL;
}
if (w <= 0) {
w = c->buffer.width();
}
if (h <= 0) {
h = c->buffer.height();
}
picasso::painter* pa = picasso::get_painter_from_format(c->fmt);
if (!pa) {
return NULL;
}
ps_canvas* p = (ps_canvas*)mem_malloc(sizeof(ps_canvas));
if (p) {
p->refcount = 1;
p->fmt = c->fmt;
p->p = pa;
p->host = NULL;
p->mask = NULL;
new ((void*)&(p->buffer)) picasso::rendering_buffer;
int pitch = picasso::_bytes_per_color(c->fmt) * w;
byte* buf = NULL;
if ((buf = (byte*)BufferAlloc(h * pitch))) {
p->flage = buffer_alloc_surface;
p->buffer.attach(buf, w, h, pitch);
p->p->attach(p->buffer);
global_status = STATUS_SUCCEED;
return p;
} else if ((buf = (byte*)mem_malloc(h * pitch))) {
p->flage = buffer_alloc_malloc;
p->buffer.attach(buf, w, h, pitch);
p->p->attach(p->buffer);
global_status = STATUS_SUCCEED;
return p;
} else {
delete pa;
(&p->buffer)->picasso::rendering_buffer::~rendering_buffer();
mem_free(p);
global_status = STATUS_OUT_OF_MEMORY;
return NULL;
}
} else {
delete pa; //mem_free painter on error
global_status = STATUS_OUT_OF_MEMORY;
return NULL;
}
}
bool
StringAlloc(TString * const stringP) {
bool succeeded;
stringP->size = 0;
succeeded = BufferAlloc(&stringP->buffer, 256);
if (succeeded) {
*(char *)(stringP->buffer.data) = '\0';
return TRUE;
} else
return FALSE;
}
void ParserStream(parser* p, stream* Stream)
{
p->Stream = Stream;
if (Stream)
{
if (!p->Buffer.Data)
{
BufferAlloc(&p->Buffer,4096,1);
BufferStream(&p->Buffer,p->Stream);
}
}
else
BufferClear(&p->Buffer);
}
ps_image* PICAPI ps_image_create_compatible(const ps_canvas* c, int w, int h)
{
if (!picasso::is_valid_system_device()) {
global_status = STATUS_DEVICE_ERROR;
return NULL;
}
if (!c) {
global_status = STATUS_INVALID_ARGUMENT;
return NULL;
}
if (w <= 0) {
w = c->buffer.width();
}
if (h <= 0) {
h = c->buffer.height();
}
ps_image* img = (ps_image*)mem_malloc(sizeof(ps_image));
if (img) {
img->refcount = 1;
img->fmt = c->fmt;
img->host = NULL;
new ((void*)&(img->buffer)) picasso::rendering_buffer;
int pitch = picasso::_bytes_per_color(c->fmt) * w;
byte* buf = NULL;
if ((buf = (byte*)BufferAlloc(h * pitch))) {
img->flage = buffer_alloc_surface;
img->buffer.attach(buf, w, h, pitch);
global_status = STATUS_SUCCEED;
return img;
} else if ((buf = (byte*)mem_malloc(h * pitch))) {
img->flage = buffer_alloc_malloc;
img->buffer.attach(buf, w, h, pitch);
global_status = STATUS_SUCCEED;
return img;
} else {
(&img->buffer)->picasso::rendering_buffer::~rendering_buffer();
mem_free(img);
global_status = STATUS_OUT_OF_MEMORY;
return NULL;
}
} else {
global_status = STATUS_OUT_OF_MEMORY;
return NULL;
}
}
int StringAlloc(TString *s)
{
/* sanity */
if (!s) {
return FALSE;
}
s->size=0;
if (BufferAlloc(&(s->buffer),256))
{
*(char *)(s->buffer.data)='\0';
return TRUE;
}
return FALSE;
}
uint8_t* BufferWrite(buffer* p, const void* Ptr, size_t Length, size_t Align)
{
uint8_t* Write = p->Write + Length;
if (Write > p->End && !BufferAlloc(p,Write-p->Begin,Align))
return 0;
Write = p->Write;
p->Write = Write+Length;
if (Ptr)
memcpy(Write,Ptr,Length);
return Write;
}
ps_image* PICAPI ps_image_create_from_data(ps_byte* data, ps_color_format fmt, int w, int h, int p)
{
if (!picasso::is_valid_system_device()) {
global_status = STATUS_DEVICE_ERROR;
return NULL;
}
if (!data || w <= 0 || h <= 0 || p <= 0) {
global_status = STATUS_INVALID_ARGUMENT;
return NULL;
}
ps_image* img = (ps_image*)mem_malloc(sizeof(ps_image));
if (img) {
img->refcount = 1;
img->fmt = fmt;
img->host = NULL;
new ((void*)&(img->buffer)) picasso::rendering_buffer;
int pitch = picasso::_bytes_per_color(fmt) * w;
byte* buf = NULL;
if ((buf = (byte*)BufferAlloc(h * pitch))) {
for (int i = 0; i < h; i++) {
BufferCopy(buf + (pitch * i), data + (i * p), pitch);
}
img->flage = buffer_alloc_surface;
img->buffer.attach(buf, w, h, pitch);
global_status = STATUS_SUCCEED;
return img;
} else if ((buf = (byte*)mem_malloc(h * pitch))) {
for (int i = 0; i < h; i++) {
mem_copy(buf + (pitch * i), data + (i * p), pitch);
}
img->flage = buffer_alloc_malloc;
img->buffer.attach(buf, w, h, pitch);
global_status = STATUS_SUCCEED;
return img;
} else {
(&img->buffer)->picasso::rendering_buffer::~rendering_buffer();
mem_free(img);
global_status = STATUS_OUT_OF_MEMORY;
return NULL;
}
} else {
global_status = STATUS_OUT_OF_MEMORY;
return NULL;
}
}
format_stream* Format_LoadSubTitle(format_base* p, stream* Input)
{
buffer m = {NULL};
BufferAlloc(&m,4096,1);
BufferStream(&m,Input);
//!SUBTITLE
/*
p->SubTitle = (format_stream*) CAlloc(sizeof(format_stream),1);
if (p->SubTitle)
{
*int* Format = (int*)Format_StreamFormat(p->SubTitle,PACKET_SUBTITLE,sizeof(int));
if (Format)
*Format = STRING_OEM;
p->SubTitle->LastTime = -1;
}
*/
BufferClear(&m);
return NULL;
}
ps_image* PICAPI ps_image_create(ps_color_format fmt, int w, int h)
{
if (!picasso::is_valid_system_device()) {
global_status = STATUS_DEVICE_ERROR;
return 0;
}
if (w <= 0 || h <= 0) {
global_status = STATUS_INVALID_ARGUMENT;
return 0;
}
ps_image *img = (ps_image*)mem_malloc(sizeof(ps_image));
if (img) {
img->refcount = 1;
img->fmt = fmt;
img->host = 0;
new ((void*)&(img->buffer)) picasso::rendering_buffer;
int pitch = picasso::_byte_pre_color(fmt) * w;
byte* buf = 0;
if ((buf = (byte*)BufferAlloc(h * pitch))) {
img->flage = buffer_alloc_surface;
img->buffer.attach(buf, w, h, pitch);
global_status = STATUS_SUCCEED;
return img;
} else if ((buf = (byte*)mem_malloc(h * pitch))) {
img->flage = buffer_alloc_malloc;
img->buffer.attach(buf, w, h, pitch);
global_status = STATUS_SUCCEED;
return img;
} else {
mem_free(img);
global_status = STATUS_OUT_OF_MEMORY;
return 0;
}
} else {
global_status = STATUS_OUT_OF_MEMORY;
return 0;
}
}
bool EdiComposer::Compose(const Document& doc, const wxString& outFilename) {
m_outputFile = new wxFile(outFilename, wxFile::write);
if ( !m_outputFile ) {
LOG_ERROR(wxGetApp().GetLogger(), 0, ADVPCS_COMPOSE_ERROR_OPEN_EDI_FILE + outFilename + "]");
return false;
}
BufferAlloc();
GetTrailer().Reset();
LOG_INFO(wxGetApp().GetLogger(), 0, ADVPCS_COMPOSE_BUILD_HEADER);
bool hr = ComposeHeader(doc);
LOG_INFO(wxGetApp().GetLogger(), 0, ADVPCS_COMPOSE_BUILD_DETAIL);
bool dr = ComposeDetail(doc);
LOG_INFO(wxGetApp().GetLogger(), 0, ADVPCS_COMPOSE_ADDING_TRAILER);
ComposeTrailer(doc);
BufferFree();
LOG_INFO(wxGetApp().GetLogger(), 0, wxString::Format(ADVPCS_COMPOSE_OK, outFilename) );
return hr & dr;
};
int BufferRealloc(TBuffer *buf,uint32 memsize)
{
/* sanity */
if (!buf) {
return FALSE;
}
if (buf->staticid)
{
TBuffer b;
if (memsize<=buf->size)
return TRUE;
if (BufferAlloc(&b,memsize))
{
memcpy(b.data,buf->data,buf->size);
BufferFree(buf);
*buf=b;
return TRUE;
}
}
else
{
void *d;
if( (d = (void*)realloc(buf->data,memsize)) )
{
buf->data=d;
buf->size=memsize;
return TRUE;
}
}
return FALSE;
}
CCBaseBuffer::CCBaseBuffer ( int size )
{ CCBaseBuffer ();
BufferAlloc ( size );
}
static int Process(equalizer* p, const packet* Packet, const flowstate* State)
{
fix_t* s;
int n,DstLength,SrcLength,Channels;
if (!Packet)
return ERR_NEED_MORE_DATA;
Channels = p->Codec.In.Format.Format.Audio.Channels;
SrcLength = Packet->Length;
DstLength = PCMDstLength(p->PCM,SrcLength);
if (DstLength*Channels*2 > p->Buffer.Allocated)
{
uint8_t* Data;
if (!BufferAlloc(&p->Buffer,DstLength*Channels*2,1024))
return ERR_OUT_OF_MEMORY;
Data = p->Buffer.Data;
for (n=0;n<Channels;++n)
{
p->Codec.Packet.Data[n] = Data;
Data += DstLength;
p->Tmp[n] = Data;
Data += DstLength;
}
}
PCMConvert(p->PCM,*(planes*)&p->Codec.Packet.Data,Packet->Data,&DstLength,&SrcLength,SPEED_ONE,256);
p->Codec.Packet.RefTime = Packet->RefTime;
p->Codec.Packet.Length = DstLength;
s = p->State[0];
for (n=0;n<Channels;++n)
{
eqfilter* f;
fix_t* i=(fix_t*)p->Codec.Packet.Data[n];
fix_t* ie=(fix_t*)((uint8_t*)i+DstLength);
fix_t* j=(fix_t*)p->Tmp[n];
fix_t a,b,c,d,e;
e = p->ScaleFinal;
a = s[2];
b = s[1];
c = s[0];
for (ie-=3;i<ie;i+=4,j+=4)
{
d=i[0];
i[0]=fixfast_mul(c,e);
j[0]=ACCFAST_ASHIFT(c-a,ACCFAST_ADJUST);
a=i[1];
i[1]=fixfast_mul(d,e);
j[1]=ACCFAST_ASHIFT(d-b,ACCFAST_ADJUST);
b=i[2];
i[2]=fixfast_mul(a,e);
j[2]=ACCFAST_ASHIFT(a-c,ACCFAST_ADJUST);
c=i[3];
i[3]=fixfast_mul(b,e);
j[3]=ACCFAST_ASHIFT(b-d,ACCFAST_ADJUST);
}
for (ie+=3;i!=ie;++i,++j)
{
j[0]=ACCFAST_ASHIFT(c-a,ACCFAST_ADJUST);
a=b;
b=c;
c=i[0];
i[0]=fixfast_mul(b,e);
}
s[2] = a;
s[1] = b;
s[0] = c;
s += 3;
for (f=p->Filter;f!=p->Filter+MAXFILTER;f+=2,s+=2*2)
if (f[0].alpha!=0 || f[1].alpha!=0)
{
accfast_var(v0);
accfast_var(v1);
i=(fix_t*)p->Codec.Packet.Data[n];
ie=(fix_t*)((uint8_t*)i+DstLength);
j=(fix_t*)p->Tmp[n];
a = s[0];
c = s[1];
b = s[2];
d = s[3];
for (--ie;i<ie;i+=2,j+=2)
{
accfast_mul(v0,a,f[0].beta);
accfast_mul(v1,b,f[1].beta);
accfast_mla(v0,j[0],f[0].alpha);
accfast_mla(v1,j[0],f[1].alpha);
accfast_mla(v0,c,f[0].gamma);
accfast_mla(v1,d,f[1].gamma);
a = accfast_get(v0,ACCFAST_ADJUST);
b = accfast_get(v1,ACCFAST_ADJUST);
i[0] += a+b;
a = ACCFAST_ASHIFT(a,ACCFAST_ADJUST);
b = ACCFAST_ASHIFT(b,ACCFAST_ADJUST);
accfast_mul(v0,c,f[0].beta);
accfast_mul(v1,d,f[1].beta);
accfast_mla(v0,j[1],f[0].alpha);
accfast_mla(v1,j[1],f[1].alpha);
accfast_mla(v0,a,f[0].gamma);
accfast_mla(v1,b,f[1].gamma);
c = accfast_get(v0,ACCFAST_ADJUST);
d = accfast_get(v1,ACCFAST_ADJUST);
i[1] += c+d;
c = ACCFAST_ASHIFT(c,ACCFAST_ADJUST);
d = ACCFAST_ASHIFT(d,ACCFAST_ADJUST);
}
if (i==ie)
{
accfast_mul(v0,a,f[0].beta);
accfast_mul(v1,b,f[1].beta);
accfast_mla(v0,j[0],f[0].alpha);
accfast_mla(v1,j[0],f[1].alpha);
accfast_mla(v0,c,f[0].gamma);
accfast_mla(v1,d,f[1].gamma);
a = c; c = accfast_get(v0,ACCFAST_ADJUST);
b = d; d = accfast_get(v1,ACCFAST_ADJUST);
i[0] += c+d;
c = ACCFAST_ASHIFT(c,ACCFAST_ADJUST);
d = ACCFAST_ASHIFT(d,ACCFAST_ADJUST);
}
s[0] = a;
s[1] = c;
s[2] = b;
s[3] = d;
}
}
if (p->Attenuate)
{
fix_t Max = 0;
for (n=0;n<Channels;++n)
{
fix_t* i=(fix_t*)p->Codec.Packet.Data[n];
fix_t* ie=(fix_t*)((uint8_t*)i+DstLength);
for (;i!=ie;++i)
{
fix_t v = *i;
if (v<0) v=-v;
if (v>Max) Max=v;
}
}
if (Max > FIXC(1.))
{
Max = fix_mul(fix_1div(Max),FIXC(15./16));
Rescale(*(planes*)&p->Codec.Packet.Data,Max,5,DstLength,Channels);
p->Scale = fix_mul(p->Scale,Max);
UpdateScale(p);
}
else
if (Max < FIXC(6./8) && p->Scale < FIXC(1-1./256))
{
Max = FIXC(32./31);
if (fix_mul(p->Scale,Max) > FIXC(1))
Max = fix_1div(p->Scale);
Rescale(*(planes*)&p->Codec.Packet.Data,Max,10,DstLength,Channels);
p->Scale = fix_mul(p->Scale,Max);
UpdateScale(p);
}
}
else
if (p->Scale != FIXC(1.))
UpdateScale(p);
return ERR_NONE;
}
