similar to: Problems linking against libvorbis.a with GnuWin32

I am a mingw coder and I needed to make the following changes to the CVS source from 9/13/00 to get a build: os_types.h L36C16 reads had to change "unsigned _G_int32_t" to "_G_uint32_t" to resolve the compile error: ..\include\vorbis\os_types.h:36:parse error before 'ogg_uint32_t' ..\include\vorbis\os_types.h:36:warning:data definition has no type or storage class

The following modification is needed in os.h to compile under C++Builder. It has the alloca prototype in malloc.h. #ifndef __GNUC__ #ifdef _WIN32 # ifdef __BORLANDC__ # include <malloc.h> # else # define alloca(x) (_alloca(x)) # endif # define rint(x) (floor((x)+0.5)) #endif #endif Encoding a full range pure tone (500Hz) seems to cause a domain error in sqrt(). Can anyone

Hello Monty, I tried to complile vorbis under win32 (using MS Visual C 5.0) I found some things: 1.) In bitvise.c there must be buffer cleared after malloc: void _oggpack_writeinit(oggpack_buffer *b){ memset(b,0,sizeof(oggpack_buffer)); b->ptr=b->buffer=malloc(BUFFER_INCREMENT); + memset(b->ptr,0,BUFFER_INCREMENT); b->storage=BUFFER_INCREMENT; } void

Hello Monty, I tried to complile vorbis under win32 (using MS Visual C 5.0) I found some things: 1.) In bitvise.c there must be buffer cleared after malloc: void _oggpack_writeinit(oggpack_buffer *b){ memset(b,0,sizeof(oggpack_buffer)); b->ptr=b->buffer=malloc(BUFFER_INCREMENT); + memset(b->ptr,0,BUFFER_INCREMENT); b->storage=BUFFER_INCREMENT; } void

I am coding with vorbis using mingw32 (g++ for win32 without the cygwin.dll dependency). mingw32's math library does not support rint and I can't find a replacement so I have tried the following: Use Cygwin to execute ./configure. Then: (1) "make" with Cygwin - ok. Cygwin supports rint. I encode my Aerosmith's "Get A Grip" .wav from the CD to .ogg with

Hello, I believe llvm.rint description in LangRef is not quite complete. Llvm seems to map math.h:rint() call to llvm.rint intrinsic, and the LangRef says that the result of llvm.rint matches the result of libm rint() call. Next, LangRef states that llvm.rint "returns the operand rounded to the nearest integer." Shouldn't the specification also say that "the actual rounding

Hi Cameron, Thank you for the comments, but I am confused even more now ☺ > llvm.rint won't honor the FPEnv in all cases. It falls under the default FPEnv The default FPEnv section specifies round-to-nearest rounding mode. In this case, how is it correct to map rint() user call to llvm.rint intrinsic call? If this is just a temporary inconsistency, and the long term solution is to map

Why does the source use `int64_t'. Is this suppose to be built with GCC? I have Mumit Kahns gcc, version 2.8.1. Do I need a 2.9.5 version to get the `int64_t' type? I have substituted a typedef of `long long' in os_types.h. This seems to make sense? The rint() macro also seems to be having some problems. I guess there are two meanings to __GNUC__ and _WIN32. One is the OS and

Dear Friends. I found something very puzzling with constOptim(). When I change the parameters for ConstrOptim, the error messages do not seem to be consistent with each other: > constrOptim(c(0.5,0.3,0.5), f=fit.error, gr=fit.error.grr, ui=ui,ci=ci) Error in constrOptim(c(0.5, 0.3, 0.5), f = fit.error, gr = fit.error.grr, : initial value not feasible > constrOptim(c(0.5,0.9,0.5),

Hello, I recently attempted to build theora 1.1.1 with mingw-w64-gcc 7.1 and msys and it fails to build the encoder_example.c example program. There are multiple declarations of the function 'rint'. The source file created its own version of the function that rounds AWAY from zero. MinGW-W64 has its own version of the 'rint' function, which does not round away from zero.

----- Original Message ----- > > On Fri, Jun 21, 2013 at 5:11 PM, Erik Schnetter < > schnetter at cct.lsu.edu > wrote: > > > > > > > On Fri, Jun 21, 2013 at 7:54 AM, David Tweed < david.tweed at arm.com > > wrote: > > > > > > > | LLVM does not currently have special lowering handling for round(), > | and >

On Fri, Jun 21, 2013 at 5:11 PM, Erik Schnetter <schnetter at cct.lsu.edu>wrote: > On Fri, Jun 21, 2013 at 7:54 AM, David Tweed <david.tweed at arm.com> wrote: > >> | LLVM does not currently have special lowering handling for round(), and >> I'll propose a patch to add that, but the larger question is this: should >> fast-math change the tie-breaking

> > The only issue I see is that since we also assume FP operations have no > side effects by default there is no difference between llvm.rint and > llvm.nearbyint. I wouldn’t have a problem with dropping llvm.rint > completely. The forthcoming C standard ( http://www.open-std.org/jtc1/sc22/wg14/www/docs/n2454.pdf, 7.12.9.8) defines new function, `roundeven`, which implements

> > One concern with replacing llvm.rint and llvm.nearbyint with > llvm.roundeven makes it difficult to turn back into a libcall if the > backend doesn't have an instruction for it. You can't just call the > roundeven library function since that wouldn't exist in older libm > implementations. So ideally you would know which function was originally > used in the

On Fri, Jun 21, 2013 at 7:54 AM, David Tweed <david.tweed at arm.com> wrote: > | LLVM does not currently have special lowering handling for round(), and > I'll propose a patch to add that, but the larger question is this: should > fast-math change the tie-breaking behavior of > | rint/nearbyint/round, etc. and, if so, should we make a specific effort > to > have all

Some clarification after getting feedback from Craig Topper…. It’s probably best to say in the documentation that the llvm.nearbyint and llvm.rint functions “assume the default rounding mode, roundToNearest”. This will allow the optimizer to transform them as if they were rounding to nearest without requiring backends to use an encoding that enforces roundToNearest as the rounding mode for these

On Sat, Sep 05, 2020 at 08:40:58PM -0500, Eric Blake wrote: > diff --git a/generator/API.mli b/generator/API.mli > index 712e837..e45b5c0 100644 > --- a/generator/API.mli > +++ b/generator/API.mli > @@ -78,6 +78,8 @@ and ret = > | RString (** return a newly allocated string, > caller frees, NULL for error *) > | RUInt

Hi everyone, According to the current design an intrinsic call that depends on current floating point environment (for example, rounding mode) or change it (for example by raising FP exceptions) is represented by constrained intrinsics. The latter have attached metadata that provide info about current FP environment and have attribute `IntrInaccessibleMemOnly` that helps keeping order of

during the last weeks I was playing around with Windows ACM codecs. These drivers allow the use of audio compression algorithms in Microsoft Windows Apps like Goldwave or the Microsoft Audio Tools (e.g. for streaming). At the moment this code is in a very early stage, only some houskeeping functionality is finished at the moment. But I think it should be possible to implement this thing without

> > I'm not sure why this is an issue. Yes, these two intrinsics depend > on the current rounding mode according to the C standard, and yes, > LLVM in default mode assumes that the current rounding mode is the > default rounding mode. But the same holds true for many other > intrinsics and even the arithmetic IR operations like add. Any other intrinsic, like `floor`,