This is the interface to nesvideos-piece. It includes functions and global variables that are to be accessed by the emulator.

#ifndef NESVPIECEhh
#define NESVPIECEhh

#define NESVIDEOS_LOGGING 1

#ifdef __cplusplus
extern "C" {
#endif

/* Is video logging enabled? 0=no, 1=yes, 2=active. Default value: 0 */ 
extern int LoggingEnabled; 

/* Get and set the video recording command (shell command) */ 
extern const char* NESVideoGetVideoCmd(void); 
extern void NESVideoSetVideoCmd(const char *cmd);

/* Save 1 frame of video. (Assumed to be 16-bit RGB) */ 
/* FPS is scaled by 24 bits (*0x1000000) */
/* Does not do anything if LoggingEnabled<2. */ 
extern void NESVideoLoggingVideo
    (const void*data, unsigned width, unsigned height,
     unsigned fps_scaled,
     unsigned bpp); 

/* Save N bytes of audio. bytes_per_second is required on the first call. */ 
/* Does not do anything if LoggingEnabled<2. */ 
/* The interval of calling this function is not important, as long as all the audio
 * data is eventually written without too big delay (5 seconds is too big)
 * This function may be called multiple times per video frame, or once per a few video
 * frames, or anything in between. Just that all audio data must be written exactly once,
 * and in order. */ 
extern void NESVideoLoggingAudio
    (const void*data,
     unsigned rate, unsigned bits, unsigned chans,
     unsigned nsamples);
/* nsamples*chans*(bits/8) = bytes in *data. */

/* Requests current AVI to be closed and new be started */
/* Use when encoding parameters have changed */
extern void NESVideoNextAVI();

#ifdef __cplusplus
}
#endif

#endif

This is the source code of the functionality behind nesvideos-piece.

#define THREAD_SAFETY

#include <cmath>
#include <string>
#include <vector>
#include <deque>
#include <list>
#include <map>

#include <unistd.h>   // mknod, unlink, write
#include <stdio.h>
#include <sys/stat.h> // S_IFIFO
#include <fcntl.h>    // fcntl
#include <sys/poll.h> // poll
#include <stdlib.h>   // setenv
#include <string.h>   // strrchr
#include <errno.h>
#include <glob.h>

#include <gd.h>

#ifdef THREAD_SAFETY
# include <pthread.h>
#endif

/* Note: This module assumes everyone uses BGR16 as display depth */

//#define LOGO_LENGTH_HEADER  (1.2)
//#define LOGO_LENGTH_OVERLAP (10.0-LOGO_LENGTH_HEADER)
//#define LOGO_LENGTH_HEADER  (1.1)
//#define LOGO_LENGTH_OVERLAP (6.3-LOGO_LENGTH_HEADER)
//#define LOGO_LENGTH_HEADER  (1.4)
#define LOGO_LENGTH_OVERLAP (0)
#define LOGO_LENGTH_HEADER (0)

static std::string VIDEO_CMD = "";
/*
-rawvideo on:fps=60:format=0x42475220:w=256:h=224:size=$[1024*224]
-audiofile "+AUDIO_FN+"
*/
static std::string AUDIO_FN = "s.log";

static bool Terminate=false;
static unsigned videonumber = 0;

#ifdef THREAD_SAFETY
static pthread_mutex_t APIlock = PTHREAD_MUTEX_INITIALIZER;
#endif

static unsigned NonblockWrite(FILE* fp, const unsigned char*buf, unsigned length)
{
  Retry:
    int result = write(fileno(fp), buf, length);
    if(result == -1 && errno==EAGAIN)
    {
        return 0;
    }
    if(result == -1 && errno==EINTR) goto Retry;
    if(result == -1)
    {
        perror("write");
        Terminate=true;
        return 0;
    }
    return result;
}
static int WaitUntilOneIsWritable(FILE*f1, FILE*f2)
{
    struct pollfd po[2] = { {fileno(f1),POLLOUT,0}, {fileno(f2),POLLOUT,0} };
    poll(po, 2, -1);
    return ((po[0].revents & POLLOUT) ? 1 : 0)
         | ((po[1].revents & POLLOUT) ? 2 : 0);
}

#define BGR32 0x42475220  // BGR32 fourcc
#define BGR24 0x42475218  // BGR24 fourcc
#define BGR16 0x42475210  // BGR16 fourcc
#define BGR15 0x4247520F  // BGR15 fourcc
#define I420  0x30323449  // I420 fourcc
#define YUY2  0x32595559  // YUY2 fourcc

static unsigned USE_FOURCC = BGR16;
static unsigned INPUT_BPP  = 16;

#define u32(n) (n)&255,((n)>>8)&255,((n)>>16)&255,((n)>>24)&255
#define u16(n) (n)&255,((n)>>8)&255
#define s4(s) s[0],s[1],s[2],s[3]

static const unsigned FPS_SCALE = 0x1000000;

static struct Construct
{
    Construct()
    {
        char Buf[4096];
        getcwd(Buf,sizeof(Buf));
        Buf[sizeof(Buf)-1]=0;
        AUDIO_FN = Buf + std::string("/") + AUDIO_FN;
    }
} Construct;

class AVI
{
    FILE* vidfp;
    FILE* audfp;
    
    bool KnowVideo;
    unsigned vid_width;
    unsigned vid_height;
    unsigned vid_fps_scaled;
    std::list<std::vector<unsigned char> > VideoBuffer;
    unsigned VidBufSize;
    
    bool KnowAudio;
    unsigned aud_rate;
    unsigned aud_chans;
    unsigned aud_bits;
    std::list<std::vector<unsigned char> > AudioBuffer;
    unsigned AudBufSize;
    
public:
    AVI() :
        vidfp(NULL),
        audfp(NULL),
        KnowVideo(false), VidBufSize(0),
        KnowAudio(false), AudBufSize(0)
    {
    }
    ~AVI()
    {
        while(VidBufSize && AudBufSize)
        {
            CheckFlushing();
        }
        if(audfp) fclose(audfp);
        if(vidfp) pclose(vidfp);
        unlink(AUDIO_FN.c_str());
    }
    
    void Audio(unsigned r,unsigned b,unsigned c,
               const unsigned char*d, unsigned nsamples)
    {
        if(Terminate) return;
        if(!KnowAudio)
        {
            aud_rate = r;
            aud_chans = c;
            aud_bits = b;
            KnowAudio = true;
        }
        CheckFlushing();
        
        unsigned bytes = nsamples * aud_chans * (aud_bits / 8);
        
        unsigned wrote = 0;
        if(KnowVideo && AudioBuffer.empty())
        {
            //fprintf(stderr, "Writing %u of %s from %p to %p\t", bytes, "aud", (void*)d, (void*)audfp);
            wrote = NonblockWrite(audfp, d, bytes);
            //fprintf(stderr, "Wrote %u\n", wrote);
        }
        if(wrote < bytes)
        {
            unsigned remain = bytes-wrote;
            //fprintf(stderr, "Buffering %u of %s (%p..%p)\n", remain, "aud", d+wrote, d+bytes);
            AudioBuffer.push_back(std::vector<unsigned char>(d+wrote, d+bytes));
            AudBufSize += remain;
        }
        CheckFlushing();
    }
    void Video(unsigned w,unsigned h,unsigned f, const unsigned char*d)
    {
        if(Terminate) return;
        if(!KnowVideo)
        {
            vid_width      = w;
            vid_height     = h;
            vid_fps_scaled = f;
            KnowVideo = true;
        }
        CheckFlushing();
        
        unsigned bpp   = INPUT_BPP; if(bpp == 15 || bpp == 17) bpp = 16;
        unsigned bytes = vid_width * vid_height * bpp / 8;
        
        //std::vector<unsigned char> tmp(bytes, 'k');
        //d = &tmp[0];
        
        unsigned wrote = 0;
        if(KnowAudio && VideoBuffer.empty())
        {
            CheckBegin();
            //fprintf(stderr, "Writing %u of %s from %p to %p\t", bytes, "vid", (void*)d, (void*)vidfp);
            wrote = NonblockWrite(vidfp, d, bytes);
            //fprintf(stderr, "Wrote %u\n", wrote);
        }
        
        if(wrote < bytes)
        {
            unsigned remain = bytes-wrote;
            //fprintf(stderr, "Buffering %u of %s (%p..%p)\n", remain, "vid", d+wrote, d+bytes);

            VideoBuffer.push_back(std::vector<unsigned char>(d+wrote, d+bytes));
            VidBufSize += remain;
        }
        CheckFlushing();
    }

private:
    /* fp is passed as a reference because it may be NULL
     * prior to calling, and this function changes it. */
    template<typename BufType>
    void FlushBufferSome(BufType& List, unsigned& Size, FILE*& fp, const char* what)
    {
        what=what;
        
    Retry:
        if(List.empty() || Terminate) return;
        
        typename BufType::iterator i = List.begin();
        std::vector<unsigned char>& buf = *i;
        
        if(buf.empty())
        {
            List.erase(i);
            goto Retry;
        }
        
        unsigned bytes = buf.size();
        
        CheckBegin();
        //fprintf(stderr, "Writing %u of %s from %p to %p\t", bytes, what, (void*)&buf[0], (void*)fp);
        
        unsigned ate = NonblockWrite(fp, &buf[0], bytes);

        //fprintf(stderr, "Wrote %u\n", ate);
        
        buf.erase(buf.begin(), buf.begin()+ate);
        
        Size -= ate;
        
        if(buf.empty())
        {
            List.erase(i);
        }
    }

    void CheckFlushing()
    {
        //AudioBuffer.clear();
        //VideoBuffer.clear();
        
        if(KnowAudio && KnowVideo && !Terminate)
        {
            if(!AudioBuffer.empty() && !VideoBuffer.empty())
            {
                do {
                    /* vidfp = &1, audfp = &2 */
                    int attempt = WaitUntilOneIsWritable(vidfp, audfp);
                    
                    if(attempt <= 0) break; /* Some kind of error can cause this */

                    // Flush Video
                    if(attempt&1) FlushBufferSome(VideoBuffer, VidBufSize, vidfp, "vid");
                    
                    // Flush Audio
                    if(attempt&2) FlushBufferSome(AudioBuffer, AudBufSize, audfp, "aud");
                } while (!AudioBuffer.empty() && !VideoBuffer.empty());
            }
            else
            {
                FlushBufferSome(VideoBuffer, VidBufSize, vidfp, "vid");
                FlushBufferSome(AudioBuffer, AudBufSize, audfp, "aud");
            }
            /*
            fprintf(stderr, "Buffer Sizes: Audio %u(%u) video %u(%u)\n",
                (unsigned)AudioBuffer.size(), AudBufSize,
                (unsigned)VideoBuffer.size(), VidBufSize);
            */
        }
    }
    std::string GetMEncoderRawvideoParam() const
    {
        char Buf[512];
        unsigned bpp   = INPUT_BPP; if(bpp == 15 || bpp == 17) bpp = 16;
        sprintf(Buf, "fps=%g:format=0x%04X:w=%u:h=%u:size=%u",
            vid_fps_scaled / (double)FPS_SCALE,
            USE_FOURCC,
            vid_width,
            vid_height,
            vid_width*vid_height * bpp/8);
        return Buf;
    }
    std::string GetMEncoderRawaudioParam() const
    {
        char Buf[512];
        sprintf(Buf, "channels=%u:rate=%u:samplesize=%u:bitrate=%u",
            aud_chans,
            aud_rate,
            aud_bits/8,
            aud_rate*aud_chans*(aud_bits/8) );
        return Buf;
    }
    std::string GetMEncoderCommand() const
    {
        std::string mandatory = "-audiofile " + AUDIO_FN
                              + " -audio-demuxer rawaudio"
                              + " -demuxer rawvideo"
                              + " -rawvideo " + GetMEncoderRawvideoParam()
                              + " -rawaudio " + GetMEncoderRawaudioParam()
                              ;
        std::string cmd = VIDEO_CMD;

        std::string::size_type p = cmd.find("NESV""SETTINGS");
        if(p != cmd.npos)
            cmd = cmd.replace(p, 4+8, mandatory);
        else
            fprintf(stderr, "Warning: NESVSETTINGS not found in videocmd\n");
        
        char videonumstr[64];
        sprintf(videonumstr, "%u", videonumber);
        
        for(;;)
        {
            p = cmd.find("VIDEO""NUMBER");
            if(p == cmd.npos) break;
            cmd = cmd.replace(p, 5+6, videonumstr);
        }
        
        fprintf(stderr, "Launch: %s\n", cmd.c_str()); fflush(stderr);
        
        return cmd;
    }

    void CheckBegin()
    {
        if(!audfp)
        {
            unlink(AUDIO_FN.c_str());
            mknod(AUDIO_FN.c_str(), S_IFIFO|0666, 0);
        }
        
        if(!vidfp)
        {
            /* Note: popen does not accept b/t in mode param */
            setenv("LD_PRELOAD", "", 1);
            vidfp = popen(GetMEncoderCommand().c_str(), "w");
            if(!vidfp)
            {
                perror("Launch failed");
            }
            else
            {
                fcntl(fileno(vidfp), F_SETFL, O_WRONLY | O_NONBLOCK);
            }
        }
        
        if(!audfp)
        {
        Retry:
            audfp = fopen(AUDIO_FN.c_str(), "wb");
            
            if(!audfp)
            {
                perror(AUDIO_FN.c_str());
                if(errno == ESTALE) goto Retry;
            }
            else
            {
                fcntl(fileno(audfp), F_SETFL, O_WRONLY | O_NONBLOCK);
            }
        }
    }
};

static AVI* AVI = 0;

namespace LogoInfo
{
    unsigned width;
    unsigned height;
}

#include "quantize.hh"
#include "rgbtorgb.hh"

extern "C"
{
    int LoggingEnabled = 0; /* 0=no, 1=yes, 2=recording! */

    const char* NESVideoGetVideoCmd()
    {
        return VIDEO_CMD.c_str();
    }
    void NESVideoSetVideoCmd(const char *cmd)
    {
#ifdef THREAD_SAFETY
        struct ScopedLock
        { ScopedLock() { 
                         pthread_mutex_lock(&APIlock);
                         //fprintf(stderr, "audio start\n"); fflush(stderr);
                       }
          ~ScopedLock() {
                         //fprintf(stderr, "audio end\n"); fflush(stderr);
                         pthread_mutex_unlock(&APIlock); }
        } ScopedLock;
#endif

        VIDEO_CMD = cmd;
    }
    
    static class AVI& GetAVIptr()
    {
        if(!AVI)
        {
            fprintf(stderr, "Starting new AVI (num %u)\n", videonumber);
            AVI = new class AVI;
        }
        return *AVI;
    }
    
    void NESVideoNextAVI()
    {
#ifdef THREAD_SAFETY
        struct ScopedLock
        { ScopedLock() { 
                         pthread_mutex_lock(&APIlock);
                         //fprintf(stderr, "audio start\n"); fflush(stderr);
                       }
          ~ScopedLock() {
                         //fprintf(stderr, "audio end\n"); fflush(stderr);
                         pthread_mutex_unlock(&APIlock); }
        } ScopedLock;
#endif

        if(AVI)
        {
            fprintf(stderr, "Closing AVI (next will be started)\n");
            delete AVI;
            AVI = 0;
            ++videonumber;
        }
    }

    static void Overlay32With32(unsigned char* target, const unsigned char* source, int alpha)
    {
        target[0] += ((int)(source[0] - target[0])) * alpha / 255;
        target[1] += ((int)(source[1] - target[1])) * alpha / 255;
        target[2] += ((int)(source[2] - target[2])) * alpha / 255;
    }
    
    static void OverlayLogoFrom(const char* fn, std::vector<unsigned char>& data)
    {
        FILE*fp = fopen(fn, "rb");
        if(!fp) perror(fn);
        if(!fp) return; /* Silently ignore missing frames */
        
        gdImagePtr im = gdImageCreateFromPng(fp);
        if(!gdImageTrueColor(im))
        {
          fprintf(stderr, "'%s': Only true color images are supported\n", fn);
          goto CloseIm;
        }
        {/*scope begin*/
        
        unsigned new_width = gdImageSX(im);
        unsigned new_height= gdImageSY(im);
        
        if(new_width != LogoInfo::width
        || new_height != LogoInfo::height)
        {
            if(new_height < LogoInfo::height || new_height > LogoInfo::height+20)
            fprintf(stderr, "'%s': ERROR, expected %dx%d, got %dx%d\n", fn,
                LogoInfo::width, LogoInfo::height,
                new_width, new_height);
        }

        for(unsigned y=0; y<LogoInfo::height; ++y)
        {
            unsigned char pixbuf[4] = {0,0,0,0};
            for(unsigned x = 0; x < LogoInfo::width; ++x)
            {
                int color = gdImageTrueColorPixel(im, x,y);
                int alpha = 255-gdTrueColorGetAlpha(color)*256/128;
                pixbuf[2] = gdTrueColorGetRed(color);
                pixbuf[1] = gdTrueColorGetGreen(color);
                pixbuf[0] = gdTrueColorGetBlue(color);
                Overlay32With32(&data[(y*LogoInfo::width+x)*3], pixbuf, alpha);
            }
        }
        }/* close scope */
    CloseIm:
        gdImageDestroy(im);
        fclose(fp);
    }
    
    static const std::string GetLogoFileName(unsigned frameno)
    {
        std::string avdir = "/home/bisqwit/povray/nesvlogov5/";
        //std::string avdir = "/home/bisqwit/povray/nesvlogov6/cv2/";
        //std::string avdir = "/home/bisqwit/povray/nesvlogov6/kuros/";
        
        char AvName[512];
        sprintf(AvName, "logo_%d_%d_f%03u.png",
            LogoInfo::width,
            LogoInfo::height,
            frameno);
        
        std::string want = avdir + AvName;
        int ac = access(want.c_str(), R_OK);
        if(ac != 0)
        {
            /* No correct avatar file? Check if there's an approximate match. */
            static std::map<int, std::vector<std::string> > files;
            if(files.empty()) /* Cache the list of logo files. */
            {
                static const char GlobPat[] = "logo_*_*_f*.png";
                glob_t globdata;
                globdata.gl_offs = 0;
                fprintf(stderr, "Loading list of usable logo animation files in %s...\n", avdir.c_str());
                int globres = glob( (avdir + GlobPat).c_str(), GLOB_NOSORT, NULL, &globdata);
                if(globres == 0)
                {
                    for(size_t n=0; n<globdata.gl_pathc; ++n)
                    {
                        const char* fn = globdata.gl_pathv[n];
                        const char* slash = strrchr(fn, '/');
                        if(slash) fn = slash+1;
                        
                        int gotw=0, goth=0, gotf=0;
                        sscanf(fn, "logo_%d_%d_f%d", &gotw,&goth,&gotf);
                        files[gotf].push_back(fn);
                    }
                }
                globfree(&globdata);
            }
            
            std::map<int, std::vector<std::string> >::const_iterator
                i = files.find(frameno);
            if(i != files.end())
            {
                std::string best;
                int bestdist = -1;
                
                const std::vector<std::string>& fnames = i->second;
                for(size_t b=fnames.size(), a=0; a<b; ++a)
                {
                    unsigned gotw=0, goth=0;
                    sscanf(fnames[a].c_str(), "logo_%u_%u", &gotw,&goth);
                    if(gotw < LogoInfo::width || goth < LogoInfo::height) continue;
                    
                    int dist = std::max(gotw - LogoInfo::width,
                                        goth - LogoInfo::height);
                    
                    if(bestdist == -1 || dist < bestdist)
                        { bestdist = dist; best = fnames[a]; }
                }
                
                if(bestdist >= 0) want = avdir + best;
            }
        }
        return want;
    }
    
    static const std::vector<unsigned char> NVConvert24To16Frame
        (const std::vector<unsigned char>& logodata)
    {
        std::vector<unsigned char> result(LogoInfo::width * LogoInfo::height * 2);
        Convert24To16Frame(&logodata[0], &result[0], LogoInfo::width * LogoInfo::height, LogoInfo::width);
        return result;
    }
    static const std::vector<unsigned char> NVConvert24To15Frame
        (const std::vector<unsigned char>& logodata)
    {
        std::vector<unsigned char> result(LogoInfo::width * LogoInfo::height * 2);
        Convert24To15Frame(&logodata[0], &result[0], LogoInfo::width * LogoInfo::height, LogoInfo::width);
        return result;
    }
    
    static const std::vector<unsigned char> NVConvert24To_I420Frame
        (const std::vector<unsigned char>& logodata)
    {
        std::vector<unsigned char> result(LogoInfo::width * LogoInfo::height * 3 / 2);
        Convert24To_I420Frame(&logodata[0], &result[0], LogoInfo::width * LogoInfo::height, LogoInfo::width);
        return result;
    }
    
    static const std::vector<unsigned char> NVConvert24To_YUY2Frame
        (const std::vector<unsigned char>& logodata)
    {
        std::vector<unsigned char> result(LogoInfo::width * LogoInfo::height * 3 / 2);
        Convert24To_YUY2Frame(&logodata[0], &result[0], LogoInfo::width * LogoInfo::height, LogoInfo::width);
        return result;
    }
    
    static const std::vector<unsigned char> NVConvert16To24Frame
        (const void* data, unsigned npixels)
    {
        std::vector<unsigned char> logodata(npixels*3); /* filled with black. */
        Convert16To24Frame(data, &logodata[0], npixels);
        return logodata;
    }
    
    static const std::vector<unsigned char> NVConvert15To24Frame
        (const void* data, unsigned npixels)
    {
        std::vector<unsigned char> logodata(npixels*3); /* filled with black. */
        Convert15To24Frame(data, &logodata[0], npixels);
        return logodata;
    }
    
    static const std::vector<unsigned char> NVConvert_I420To24Frame
        (const void* data, unsigned npixels)
    {
        std::vector<unsigned char> logodata(npixels*3); /* filled with black. */
        Convert_I420To24Frame(data, &logodata[0], npixels, LogoInfo::width);
        return logodata;
    }
    
    static const std::vector<unsigned char> NVConvert_YUY2To24Frame
        (const void* data, unsigned npixels)
    {
        std::vector<unsigned char> logodata(npixels*3); /* filled with black. */
        Convert_YUY2To24Frame(data, &logodata[0], npixels, LogoInfo::width);
        return logodata;
    }
    
    static void SubstituteWithBlackIfNeeded(const void*& data)
    {
        /* If the first frames of the animation consist of a
         * single color (such as gray for NES), replace them
         * with black to avoid ugly backgrounds on logo animations
         */
    
        static bool Deviate = false;
        static short* Replacement = 0;
        static unsigned wid=0, hei=0;
        if(Deviate)
        {
            if(Replacement) { delete[] Replacement; Replacement=0; }
            return;
        }
        
        unsigned dim = LogoInfo::width * LogoInfo::height;
        const short* p = (const short*)data;
        for(unsigned a=0; a<dim; ++a)
            if(p[a] != p[0])
            {
                Deviate = true;
                return;
            }
        
        if(Replacement && (wid != LogoInfo::width || hei != LogoInfo::height))
        {
            delete[] Replacement;
            Replacement = 0;
        }
        
        wid = LogoInfo::width;
        hei = LogoInfo::height;
        
        if(!Replacement)
        {
            Replacement = new short[dim];
            for(unsigned a=0; a<dim; ++a) Replacement[a]=0x0000;
        }
        data = (void*)Replacement;
    }

    void NESVideoLoggingVideo
        (const void*data, unsigned width,unsigned height,
         unsigned fps_scaled,
         unsigned bpp
        )
    {
        if(LoggingEnabled < 2) return;
        
#ifdef THREAD_SAFETY
        struct ScopedLock
        { ScopedLock() { 
                         pthread_mutex_lock(&APIlock);
                         //fprintf(stderr, "video start\n"); fflush(stderr);
                       }
          ~ScopedLock() {
                         //fprintf(stderr, "video end\n"); fflush(stderr);
                         pthread_mutex_unlock(&APIlock); }
        } ScopedLock;
#endif

        if(bpp == 32) /* Convert 32 to 24 */
        {
            bpp = 24;
            
            static std::vector<unsigned char> VideoBuf;
            VideoBuf.resize(width*height * 3);
            
            Convert32To24Frame(data, &VideoBuf[0], width*height);
            data = (void*)&VideoBuf[0];
        }
        
        if(bpp) INPUT_BPP = bpp;
        
        switch(INPUT_BPP)
        {
            case 32: USE_FOURCC = BGR32; break;
            case 24: USE_FOURCC = BGR24; break;
            case 16: USE_FOURCC = BGR16; break;
            case 15: USE_FOURCC = BGR15; break;
            case 12: USE_FOURCC = I420; break;
            case 17: USE_FOURCC = YUY2; break;
        }
        //USE_FOURCC = BGR24; // FIXME TEMPORARY
        
        const int LogoFramesHeader  = (int)( (LOGO_LENGTH_HEADER  * fps_scaled) / (1 << 24) );
        const int LogoFramesOverlap = (int)( (LOGO_LENGTH_OVERLAP * fps_scaled) / (1 << 24) );
        
        LogoInfo::width  = width;
        LogoInfo::height = height;
        
        if(INPUT_BPP == 16 || INPUT_BPP == 15)
        {
            SubstituteWithBlackIfNeeded(data);
        }
        else if(INPUT_BPP != 24 && INPUT_BPP != 12 && INPUT_BPP != 17)
        {
            fprintf(stderr, "NESVIDEOS_PIECE only supports 16 and 24 bpp, you gave %u bpp\n",
                bpp);
            return;
        }

        static bool LogoHeaderPartSent = false;
        if(!LogoHeaderPartSent)
        {
            /* Send animation frames that do not involve source video? */
            LogoHeaderPartSent=true;

            if(LogoFramesHeader > 0)
            {
                for(int frame = 0; frame < LogoFramesHeader; ++frame)
                {
                    std::vector<unsigned char> logodata(width*height*3); /* filled with black. */
                    
                    std::string fn = GetLogoFileName(frame);
                    /*fprintf(stderr, "wid=%d(%d), hei=%d(%d),fn=%s\n",
                        width, LogoInfo::width,
                        height, LogoInfo::height,
                        fn.c_str());*/
                    OverlayLogoFrom(fn.c_str(), logodata);
                    
                    //INPUT_BPP = 24; USE_FOURCC = BGR24; // FIXME TEMPORARY
                    
                    if(INPUT_BPP == 16)
                    {
                        std::vector<unsigned char> result = NVConvert24To16Frame(logodata);
                        GetAVIptr().Video(width,height,fps_scaled, &result[0]);
                    }
                    else if(INPUT_BPP == 15)
                    {
                        std::vector<unsigned char> result = NVConvert24To15Frame(logodata);
                        GetAVIptr().Video(width,height,fps_scaled, &result[0]);
                    }
                    else if(INPUT_BPP == 12)
                    {
                        std::vector<unsigned char> result = NVConvert24To_I420Frame(logodata);
                        GetAVIptr().Video(width,height,fps_scaled, &result[0]);
                    }
                    else if(INPUT_BPP == 17)
                    {
                        std::vector<unsigned char> result = NVConvert24To_YUY2Frame(logodata);
                        GetAVIptr().Video(width,height,fps_scaled, &result[0]);
                    }
                    else
                    {
                        GetAVIptr().Video(width,height,fps_scaled, &logodata[0]);
                    }
                }
            }
        }
        
        static int LogoOverlapSent = 0;
        if(LogoOverlapSent < LogoFramesOverlap)
        {
            /* Send animation frames that mix source and animation? */

            std::string fn = GetLogoFileName(LogoOverlapSent + LogoFramesHeader);
            /*
            fprintf(stderr, "wid=%d(%d), hei=%d(%d),fn=%s\n",
                width, LogoInfo::width,
                height, LogoInfo::height,
                fn.c_str());*/

            std::vector<unsigned char> logodata;
            if(INPUT_BPP == 16)
            {
                logodata = NVConvert16To24Frame(data, width*height);
            }
            else if(INPUT_BPP == 15)
            {
                logodata = NVConvert15To24Frame(data, width*height);
            }
            else if(INPUT_BPP == 17)
            {
                logodata = NVConvert_YUY2To24Frame(data, width*height);
            }
            else if(INPUT_BPP == 12)
            {
                logodata = NVConvert_I420To24Frame(data, width*height);
            }
            else
            {
                logodata.resize(width*height*3); /* filled with black. */
                memcpy(&logodata[0], data, width*height*3);
            }

            OverlayLogoFrom(fn.c_str(), logodata);
            
//            INPUT_BPP = 24; USE_FOURCC = BGR24; // FIXME TEMPORARY

            if(INPUT_BPP == 16)
            {
                std::vector<unsigned char> result = NVConvert24To16Frame(logodata);
                GetAVIptr().Video(width,height,fps_scaled, &result[0]);
            }
            else if(INPUT_BPP == 15)
            {
                std::vector<unsigned char> result = NVConvert24To15Frame(logodata);
                GetAVIptr().Video(width,height,fps_scaled, &result[0]);
            }
            else if(INPUT_BPP == 12)
            {
                std::vector<unsigned char> result = NVConvert24To_I420Frame(logodata);
                GetAVIptr().Video(width,height,fps_scaled, &result[0]);
            }
            else if(INPUT_BPP == 17)
            {
                std::vector<unsigned char> result = NVConvert24To_YUY2Frame(logodata);
                GetAVIptr().Video(width,height,fps_scaled, &result[0]);
            }
            else
            {
                GetAVIptr().Video(width,height,fps_scaled, &logodata[0]);
            }

            ++LogoOverlapSent;
            return;
        }
        
        GetAVIptr().Video(width,height,fps_scaled,  (const unsigned char*) data);
    }

    void NESVideoLoggingAudio
        (const void*data,
         unsigned rate, unsigned bits, unsigned chans,
         unsigned nsamples)
    {
        if(LoggingEnabled < 2) return;
        
#ifdef THREAD_SAFETY
        struct ScopedLock
        { ScopedLock() { 
                         pthread_mutex_lock(&APIlock);
                         //fprintf(stderr, "audio start\n"); fflush(stderr);
                       }
          ~ScopedLock() {
                         //fprintf(stderr, "audio end\n"); fflush(stderr);
                         pthread_mutex_unlock(&APIlock); }
        } ScopedLock;
#endif

        static bool LogoHeaderPartSent = false;
        if(!LogoHeaderPartSent && LOGO_LENGTH_HEADER > 0)
        {
            LogoHeaderPartSent=true;
            
            double HdrLength = LOGO_LENGTH_HEADER; // N64 workaround
            
            const long n = (long)(rate * HdrLength)/*
                - (rate * 0.11)*/;
            
            if(n > 0) {
            unsigned bytes = n*chans*(bits/8);
            unsigned char* buf = (unsigned char*)malloc(bytes);
            if(buf)
            {
                memset(buf,0,bytes);
                GetAVIptr().Audio(rate,bits,chans, buf, n);
                free(buf);
            } }
        }
        
        /*
        fprintf(stderr, "Writing %u samples (%u bits, %u chans, %u rate)\n",
            nsamples, bits, chans, rate);*/
        
        /*
        static FILE*fp = fopen("audiodump.wav", "wb");
        fwrite(data, 1, nsamples*(bits/8)*chans, fp);
        fflush(fp);*/
        
        GetAVIptr().Audio(rate,bits,chans, (const unsigned char*) data, nsamples);
    }
} /* extern "C" */

This include file provides functions for a single R/G/B value from some bit depth to a lesser bit depth, such as RGB32 to RGB15, with ordered dithering.

/*
 Ordered dithering methods provided for:
   8x8 (Quantize8x8)
   4x4 (Quantize4x4)
   3x3 (Quantize3x3)
   4x2 (Quantize4x2)
   3x2 (Quantize3x2)
   2x2 (Quantize2x2)
 The functions are:
 
   template<int m, int in_max>
   int QuantizeFunc(size_t quant_pos, double value)
   
      - Quantizes value, assumed to be in range 0..in_max, to range 0..m
      - quant_pos tells the coordinate into the dithering matrix

   template<int m, int in_max>
   int QuantizeFunc(size_t quant_pos, unsigned value)

      - Quantizes value, assumed to be in range 0..in_max, to range 0..m
      - quant_pos tells the coordinate into the dithering matrix

 Copyright (C) 1992,2008 Joel Yliluoma (http://iki.fi/bisqwit/)
*/

#define OrderedDitherDecl(n) \
    static const double flts[n]; \
    static const int ints[n]; \
    enum { mul = n+1, \
           maxin = in_max, \
           even = !(maxin % mul), \
           intmul = even ? 1 : mul };

/* macroes for initializing dither tables */
#define d(n) (n)/double(mul) - 0.5
#define i(n) even ? (n*in_max/mul - (int)in_max/2) \
                  : (n*in_max - (int)mul*in_max/2)

template<int m, int in_max = 255>
struct QuantizeNoDither
{
    int res;
    template<typename IntType>
    QuantizeNoDither(IntType v) : res(v * m / in_max) { }
    operator int() const { return res; }
};

template<int m, typename Base>
struct QuantizeFuncBase: private Base
{
    int res;
    
    QuantizeFuncBase(size_t quant_pos, double v) : res(0)
    {
        if(v > 0.0)
        {
            const double dither_threshold = Base::flts[quant_pos];
            res = (int)(v * (m / double(Base::maxin)) + dither_threshold);
            if(res > m) res = m;
        }
    }
    
    QuantizeFuncBase(size_t quant_pos, unsigned char v) : res(v)
    {
        if(m == Base::maxin) return;
        if(m < Base::maxin)
        {
            // With dithering
            const int dither_threshold = Base::ints[quant_pos];
            const int intmul = Base::intmul;
            res = (res * (m * intmul) + dither_threshold) / (Base::maxin * intmul);
        }
        else
        {
            // Without dithering
            res = QuantizeNoDither<m, Base::maxin> (res);
        }
    }
};

#define QuantizeFuncDecl(name, base) \
  template<int m, int in_max=255> \
  struct name: private QuantizeFuncBase<m, base<in_max> > \
  { \
      typedef QuantizeFuncBase<m, base<in_max> > Base; \
      template<typename A, typename B> name(A a, B b) : Base(a, b) { } \
      operator int() const { return Base::res; } \
  }

/******* Quantizing with 8x8 ordered dithering ********/
template<int in_max> struct OrderedDither_8x8 { OrderedDitherDecl(8*8) };
    template<int in_max>
    const double OrderedDither_8x8<in_max>::flts[] /* A table for 8x8 ordered dithering */
    = { d(1 ), d(49), d(13), d(61), d( 4), d(52), d(16), d(64),
        d(33), d(17), d(45), d(29), d(36), d(20), d(48), d(32),
        d(9 ), d(57), d( 5), d(53), d(12), d(60), d( 8), d(56),
        d(41), d(25), d(37), d(21), d(44), d(28), d(40), d(24),
        d(3 ), d(51), d(15), d(63), d( 2), d(50), d(14), d(62),
        d(35), d(19), d(47), d(31), d(34), d(18), d(46), d(30),
        d(11), d(59), d( 7), d(55), d(10), d(58), d( 6), d(54),
        d(43), d(27), d(39), d(23), d(42), d(26), d(38), d(22) };
    template<int in_max>
    const int OrderedDither_8x8<in_max>::ints[]
    = { i(1 ), i(49), i(13), i(61), i( 4), i(52), i(16), i(64),
        i(33), i(17), i(45), i(29), i(36), i(20), i(48), i(32),
        i(9 ), i(57), i( 5), i(53), i(12), i(60), i( 8), i(56),
        i(41), i(25), i(37), i(21), i(44), i(28), i(40), i(24),
        i(3 ), i(51), i(15), i(63), i( 2), i(50), i(14), i(62),
        i(35), i(19), i(47), i(31), i(34), i(18), i(46), i(30),
        i(11), i(59), i( 7), i(55), i(10), i(58), i( 6), i(54),
        i(43), i(27), i(39), i(23), i(42), i(26), i(38), i(22) };
QuantizeFuncDecl(Quantize8x8, OrderedDither_8x8);


/******* Quantizing with 4x4 ordered dithering ********/
template<int in_max> struct OrderedDither_4x4 { OrderedDitherDecl(4*4) };
    template<int in_max>
    const double OrderedDither_4x4<in_max>::flts[] /* A table for 4x4 ordered dithering */
    = { d( 1), d( 9), d( 3), d(11),
        d(13), d( 5), d(15), d( 7),
        d( 4), d(12), d( 2), d(10),  
        d(16), d( 8), d(14), d( 6) };
    template<int in_max>
    const int OrderedDither_4x4<in_max>::ints[]
    = { i( 1), i( 9), i( 3), i(11),
        i(13), i( 5), i(15), i( 7),
        i( 4), i(12), i( 2), i(10),
        i(16), i( 8), i(14), i( 6) };
QuantizeFuncDecl(Quantize4x4, OrderedDither_4x4);

/******* Quantizing with 3x3 ordered dithering ********/
template<int in_max> struct OrderedDither_3x3 { OrderedDitherDecl(3*3) };
    template<int in_max>
    const double OrderedDither_3x3<in_max>::flts[] /* A table for 3x3 ordered dithering */
    = { d(1), d(7), d(3),
        d(6), d(4), d(9),
        d(8), d(2), d(5) };
    template<int in_max>
    const int OrderedDither_3x3<in_max>::ints[]
    = { i(1), i(7), i(3),
        i(6), i(4), i(9),  
        i(8), i(2), i(5) };
QuantizeFuncDecl(Quantize3x3, OrderedDither_3x3);

/******* Quantizing with 4x2 ordered dithering ********/
template<int in_max> struct OrderedDither_4x2 { OrderedDitherDecl(4*2) };
    template<int in_max>
    const double OrderedDither_4x2<in_max>::flts[] /* A table for 4x2 ordered dithering */
    = { d(1), d(5), d(2), d(6),
        d(7), d(3), d(8), d(4) };
    template<int in_max>
    const int OrderedDither_4x2<in_max>::ints[]
    = { i(1), i(5), i(2), i(6),
        i(7), i(3), i(8), i(4) };
QuantizeFuncDecl(Quantize4x2, OrderedDither_4x2);

/******* Quantizing with 3x2 ordered dithering ********/
template<int in_max> struct OrderedDither_3x2 { OrderedDitherDecl(3*2) };
    template<int in_max>
    const double OrderedDither_3x2<in_max>::flts[] /* A table for 3x2 ordered dithering */
    = { d(1), d(5), d(3),
        d(4), d(2), d(6) };
    template<int in_max>
    const int OrderedDither_3x2<in_max>::ints[]
    = { i(1), i(5), i(3),
        i(4), i(2), i(6) };
QuantizeFuncDecl(Quantize3x2, OrderedDither_3x2);

/******* Quantizing with 2x2 ordered dithering ********/
template<int in_max> struct OrderedDither_2x2 { OrderedDitherDecl(2*2) };
    template<int in_max>
    const double OrderedDither_2x2<in_max>::flts[] /* A table for 2x2 ordered dithering */
    = { d(1), d(4),
        d(3), d(2) };
    template<int in_max>
    const int OrderedDither_2x2<in_max>::ints[]
    = { i(1), i(4),
        i(3), i(2) };
QuantizeFuncDecl(Quantize2x2, OrderedDither_2x2);


#undef OrderedDitherDecl
#undef QuantizeFuncDecl
#undef i
#undef d

#if defined(__MMX__) && !defined(__x86_64)
#define USE_MMX
#endif
#if defined(__SSE__)
#define USE_SSE
#endif

/* SIMD interface (MMX) written by Bisqwit
 * Copyright (C) 1992,2008 Joel Yliluoma (http://iki.fi/bisqwit/)
 */

#ifdef __3dNOW__
# include <mm3dnow.h> /* Note: not available on ICC */ 
#elif defined(__MMX__)
# include <mmintrin.h>
#endif
#ifdef __SSE__
#include <xmmintrin.h>
 #ifdef __ICC
 typedef __m128 __v4sf;
 #endif
#endif

struct c64_common
{
    static signed char clamp_s8(int_fast64_t v)
        { return v<-128 ? -128 : (v > 127 ? 127 : v); }
    static unsigned char clamp_u8(int_fast64_t v)
        { return v<0 ? 0 : (v > 255 ? 255 : v); }
    static short clamp_s16(int_fast64_t v)
        { return v<-32768 ? -32768 : (v > 32767 ? 32767 : v); }

    static inline uint_fast64_t expand32_8(uint_fast32_t a)
    {
        // 0000abcd -> 0a0b0c0d
        typedef uint_fast64_t v;
        return (a&0xFFU)
            | ((a&0xFF00U)<<8)    // base: 8+8 = 16
            | ((v)(a&0xFF0000U)<<16) // base: 16+16 = 32
            | ((v)(a&0xFF000000UL)<<24); // base: 24+24 = 48
    }
    static inline uint_fast64_t expand32_16(uint_fast32_t a)
    {
        // 0000abcd -> 00ab00cd
        typedef uint_fast64_t v;
        return (a&0xFFFFU)
         | ((v)(a&0xFFFF0000UL)<<16);   // base: 16+16 = 32
    }
};

#ifdef __MMX__
/* 64-bit integers that use MMX / 3Dnow operations where relevant */
struct c64_MMX: public c64_common
{
    typedef c64_MMX c64;

    __m64 value;
    
    inline c64_MMX() { }
    inline c64_MMX(__m64 v) : value(v) { }
    inline c64_MMX(const uint64_t& v) : value( *(const __m64*)& v) { }

    inline c64 operator<< (int b) const { if(b < 0) return *this >> -b; return shl64(b); }
    inline c64 operator>> (int b) const { if(b < 0) return *this << -b; return shr64(b); }
    c64& operator<<= (int n) { return *this = shl64(n); }
    c64& operator>>= (int n) { return *this = shr64(n); }

    c64 conv_s16_u8() const { return conv_s16_u8(*this); }
    c64 conv_s16_s8() const { return conv_s16_s8(*this); }

    void Get(const unsigned char* p)      { value = *(const __m64*)p; }
    void Put(      unsigned char* p)const { *(__m64*)p =  value; }
    
    void Init16(short a,short b,short c, short d)
        { value = _mm_setr_pi16(a,b,c,d); }
    void Init16(short a)
        { value = _mm_set1_pi16(a); }

    void GetD(const unsigned char* p)      { value = *(const __m64*)p; }
    
    template<int n>
    short Extract16() const { return ((const short*)&value)[n]; }
    template<int n>
    int Extract32() const { return ((const int*)&value)[n]; }
    
    short Extract88_from_1616lo() const
    {
        const unsigned char* data = (const unsigned char*)&value;
        // bytes:  76543210
        // shorts: 33221100
        // take:        H L
        return data[0] | *(short*)(data+1);
        //return data[0] | ((*(const unsigned int*)data) >> 8);
    }
    short Extract88_from_1616hi() const
    {
        const unsigned char* data = 4+(const unsigned char*)&value;
        // bytes:  76543210
        // shorts: 33221100
        // take:    H L
        return data[0] | *(short*)(data+1);
        //return data[0] | ((*(const unsigned int*)data) >> 8);
    }
    

    c64& operator&= (const c64& b) { value=_mm_and_si64(value,b.value); return *this; }
    c64& operator|= (const c64& b) { value=_mm_or_si64(value,b.value); return *this; }
    c64& operator^= (const c64& b) { value=_mm_xor_si64(value,b.value); return *this; }
    c64& operator+= (const c64& b) { return *this = *this + b; }
    c64& operator-= (const c64& b) { return *this = *this - b; }
    
            /* psllqi: p = packed
                       s = shift
                       r = right, l = left
                       l = shift in zero, a = shift in sign bit
                       q = 64-bit, d = 32-bit, w = 16-bit
                      [i = immed amount]
             */
    c64 operator& (const c64& b) const { return c64(_mm_and_si64(value,b.value)); }
    c64 operator| (const c64& b) const { return c64(_mm_or_si64(value,b.value)); }
    c64 operator^ (const c64& b) const { return c64(_mm_xor_si64(value,b.value)); }
    
    c64 operator- (const c64& b) const
    {
        #ifdef __SSE2__
        return _mm_sub_si64(value, b.value);
        #else
        return (const uint64_t&)value - (const uint64_t&)b.value;
        #endif
    }
    c64 operator+ (const c64& b) const
    {
        #ifdef __SSE2__
        return _mm_add_si64(value, b.value);
        #else
        return (const uint64_t&)value + (const uint64_t&)b.value;
        #endif
    }
    

    c64 shl64(int b) const { return _mm_slli_si64(value, b); }
    c64 shr64(int b) const { return _mm_srli_si64(value, b); }
    c64 shl16(int b) const { return _mm_slli_pi16(value, b); }
    c64 shr16(int b) const { return _mm_srli_pi16(value, b); }
    c64 sar32(int b) const { return _mm_srai_pi32(value, b); }
    c64 sar16(int b) const { return _mm_srai_pi16(value, b); }
    c64 add32(const c64& b) const { return _mm_add_pi32(value, b.value); }
    c64 add16(const c64& b) const { return _mm_add_pi16(value, b.value); }
    c64 sub32(const c64& b) const { return _mm_sub_pi32(value, b.value); }
    c64 sub16(const c64& b) const { return _mm_sub_pi16(value, b.value); }
    c64 mul16(const c64& b) const   { return _mm_mullo_pi16(value, b.value); }
    c64 mul16hi(const c64& b) const { return _mm_mulhi_pi16(value, b.value); }
    //c64 mul32(const c64& b) const { return _mm_mullo_pi32(value, b.value); }
    c64 add8(const c64& b) const { return _mm_add_pi8(value, b.value); }
    c64 sub8(const c64& b) const { return _mm_sub_pi8(value, b.value); }
    
    c64 unpacklbw(const c64& b) const { return _mm_unpacklo_pi8(b.value,value); }
    c64 unpacklwd(const c64& b) const { return _mm_unpacklo_pi16(b.value,value); }
    c64 unpackhbw(const c64& b) const { return _mm_unpackhi_pi8(b.value,value); }
    c64 unpackhwd(const c64& b) const { return _mm_unpackhi_pi16(b.value,value); }
    c64 unpackldq(const c64& b) const { return _mm_unpacklo_pi32(b.value,value); }
    c64 unpackldq() const { return _mm_unpacklo_pi32(value,value); }

    c64 operator& (const uint64_t& v) { return c64(_mm_and_si64(value, *(const __m64*)& v)); }
    
    c64 conv_s32_s16(const c64& b) const { return _mm_packs_pi32(value, b.value); }
    c64 conv_s16_u8(const c64& b) const { return _mm_packs_pu16(value, b.value); }
    c64 conv_s16_s8(const c64& b) const { return _mm_packs_pi16(value, b.value); }
};
#endif

struct c64_nonMMX: public c64_common
{
    typedef c64_nonMMX c64;
    
    uint_least64_t value;
    
    inline c64_nonMMX() { }
    inline c64_nonMMX(uint64_t v) : value(v) { }

    c64 operator<< (int b) const { if(b < 0) return *this >> -b; return shl64(b); }
    c64 operator>> (int b) const { if(b < 0) return *this << -b; return shr64(b); }
    c64& operator<<= (int n) { return *this = shl64(n); }
    c64& operator>>= (int n) { return *this = shr64(n); }

    c64 conv_s16_u8() const { return conv_s16_u8(*this); }
    c64 conv_s16_s8() const { return conv_s16_s8(*this); }

    void Init16(short a,short b,short c, short d)
        { uint_fast64_t aa = (unsigned short)a,
                        bb = (unsigned short)b,
                        cc = (unsigned short)c,
                        dd = (unsigned short)d;
          value = aa | (bb << 16) | (cc << 32) | (dd << 48); }
    void Init16(short a)
        { Init16(a,a,a,a); }
    void Init8(unsigned char a,unsigned char b,unsigned char c,unsigned char d,
               unsigned char e,unsigned char f,unsigned char g,unsigned char h)
    {
        value = ((uint_fast64_t)(a | (b << 8) | (c << 16) | (d << 24)))
              | (((uint_fast64_t)e) << 32)
              | (((uint_fast64_t)f) << 40)
              | (((uint_fast64_t)g) << 48)
              | (((uint_fast64_t)h) << 56);
    }

    void Get(const unsigned char* p)      { value = *(const uint_least64_t*)p; }
    void Put(      unsigned char* p)const { *(uint_least64_t*)p =  value; }
    
    c64& operator&= (const c64& b) { value&=b.value; return *this; }
    c64& operator|= (const c64& b) { value|=b.value; return *this; }
    c64& operator^= (const c64& b) { value^=b.value; return *this; }
    c64& operator+= (const c64& b) { value+=b.value; return *this; }
    c64& operator-= (const c64& b) { value-=b.value; return *this; }
    c64 operator& (const c64& b) const { return value & b.value; }
    c64 operator| (const c64& b) const { return value | b.value; }
    c64 operator^ (const c64& b) const { return value ^ b.value; }
    c64 operator- (const c64& b) const { return value - b.value; }
    c64 operator+ (const c64& b) const { return value + b.value; }

    c64 operator& (uint_fast64_t b) const { return value & b; }
    
    #define usimdsim(type, count, op) \
        type* p = (type*)&res.value; \
        for(int n=0; n<count; ++n) p[n] = (p[n] op b)

    #define simdsim(type, count, op) \
        type* p = (type*)&res.value; \
        const type* o = (const type*)&b.value; \
        for(int n=0; n<count; ++n) p[n] = (p[n] op o[n])
    
    c64 shl64(int b) const { return value << b; }
    c64 shr64(int b) const { return value >> b; }
    c64 shl16(int b) const { c64 res = *this; usimdsim(short, 2, <<); return res; }
    c64 shr16(int b) const { c64 res = *this; usimdsim(unsigned short, 2, >>); return res; }
    c64 sar32(int b) const { c64 res = *this; usimdsim(int, 2, >>); return res; }
    c64 sar16(int b) const { c64 res = *this; usimdsim(short, 2, >>); return res; }

    c64 add16(const c64& b) const { c64 res = *this; simdsim(short, 4, +); return res; }
    c64 sub16(const c64& b) const { c64 res = *this; simdsim(short, 4, -); return res; }
    c64 add32(const c64& b) const { c64 res = *this; simdsim(int,   2, +); return res; }
    c64 sub32(const c64& b) const { c64 res = *this; simdsim(int,   2, -); return res; }
    c64 mul16(const c64& b) const { c64 res = *this; simdsim(short, 4, *); return res; }
    c64 mul16hi(const c64& b) const { c64 res = *this; simdsim(short, 4, *) >> 16; return res; }
    c64 add8(const c64& b) const { c64 res = *this; simdsim(unsigned char, 8, +); return res; }
    c64 sub8(const c64& b) const { c64 res = *this; simdsim(unsigned char, 8, -); return res; }
    
    #undef simdsim
    #undef usimdsim
    
    c64 conv_s32_s16(const c64& b) const
    {
        c64 res; res.
        Init16(clamp_s16(value & 0xFFFFFFFFU),
               clamp_s16(value >> 32),
               clamp_s16(b.value & 0xFFFFFFFFU),
               clamp_s16(b.value >> 32));
        return res;
    }
    c64 conv_s16_u8(const c64& b) const
    {
        c64 res; res.
        Init8(clamp_u8(value & 0xFFFF),
              clamp_u8((value >> 16) & 0xFFFF),
              clamp_u8((value >> 32) & 0xFFFF),
              clamp_u8((value >> 48) & 0xFFFF),
              clamp_u8(b.value & 0xFFFF),
              clamp_u8((b.value >> 16) & 0xFFFF),
              clamp_u8((b.value >> 32) & 0xFFFF),
              clamp_u8((b.value >> 48) & 0xFFFF));
        return res;
    }
    c64 conv_s16_s8(const c64& b) const
    {
        c64 res; res.
        Init8(clamp_s8(value & 0xFFFF),
              clamp_s8((value >> 16) & 0xFFFF),
              clamp_s8((value >> 32) & 0xFFFF),
              clamp_s8((value >> 48) & 0xFFFF),
              clamp_s8(b.value & 0xFFFF),
              clamp_s8((b.value >> 16) & 0xFFFF),
              clamp_s8((b.value >> 32) & 0xFFFF),
              clamp_s8((b.value >> 48) & 0xFFFF));
        return res;
    }

    /* TODO: Verify that these are correct (though they should never be used anyway) */
    c64 unpacklbw(const c64& p) const
    {
    #if defined(__MMX__) && !defined(__ICC)
        /* ICC says [error: type of cast must be integral or enum]
         * on the return value cast,
         * so we cannot use this code on ICC. Fine for GCC. */
        return (uint_least64_t)_m_punpcklbw(*(__m64*)&p.value, *(__m64*)&value);
    #else
        uint_fast64_t a=value, b=p.value;
        return expand32_8(a) | (expand32_8(b) << 8);
    #endif
    }
    c64 unpackhbw(const c64& p) const
    {
    #if defined(__MMX__) && !defined(__ICC)
        return (uint_least64_t)_m_punpckhbw(*(__m64*)&p.value, *(__m64*)&value);
    #else
        uint_fast64_t a=value, b=p.value;
        return expand32_8(a>>32) | (expand32_8(b>>32) << 8);
    #endif
    }
    c64 unpacklwd(const c64& p) const
    {
    #if defined(__MMX__) && !defined(__ICC)
        return (uint_least64_t)_m_punpcklwd(*(__m64*)&p.value, *(__m64*)&value);
    #else
        uint_fast64_t a=value, b=p.value;
        return expand32_16(a) | (expand32_16(b) << 16);
    #endif
    }
    c64 unpackhwd(const c64& p) const
    {
    #if defined(__MMX__) && !defined(__ICC)
        return (uint_least64_t)_m_punpckhwd(*(__m64*)&p.value, *(__m64*)&value);
    #else
        uint_fast64_t a=value, b=p.value;
        return expand32_16(a>>32) | (expand32_16(b>>32) << 16);
    #endif
    }
    c64 unpackldq() const { return unpackldq(*this); }
    c64 unpackldq(const c64& p) const
    {
    #if defined(__MMX__) && !defined(__ICC)
        return (uint_least64_t)_m_punpckldq(*(__m64*)&p.value, *(__m64*)&value);
    #else
        return value | (p.value << 32);
    #endif
    }
};

#ifdef USE_MMX
typedef c64_MMX c64;
#else
typedef c64_nonMMX c64;
#endif

static inline void MMX_clear()
{
    #ifdef __3dNOW__
    _m_femms(); /* Note: not available on ICC */
    #elif defined(__MMX__)
    _mm_empty();
    #endif
}