Subversion Repositories planix.SVN

/*
 * readV210.c - read single uncompressed Quicktime YUV image.
 * http://developer.apple.com/quicktime/icefloe/dispatch019.html#v210
 * Steve Simon, 2009
 */
#include <u.h>
#include <libc.h>
#include <bio.h>
#include <draw.h>
#include <ctype.h>
#include "imagefile.h"

enum {
        Pixels = 720,
        R601pal = 576,
        R601ntsc = 486,
        Shift = 13
};

static int
looksize(char *file, vlong size, int *pixels, int *lines, int *chunk)
{
        Biobuf *bp;
        uvlong l, p, c;
        char *s, *a[12];

        /*
         * This may not always work, there could be an alias between file
         * sizes of different standards stored in 8bits and 10 bits.
         */
        if((bp = Bopen(file, OREAD)) == nil)
                return -1;
        while((s = Brdstr(bp, '\n', 1)) != nil){
                if(tokenize(s, a, nelem(a)) < 3)
                        continue;
                if(a[0][0] == '#')
                        continue;
                p = atoll(a[3]);
                l = atoll(a[5]);
                l += atoll(a[7]);
                c = 128 * ceil(p/48);
                if(l*c == size){
                        *pixels = p;
                        *lines = l;
                        *chunk = c;
                        break;
                }
        }
        Bterm(bp);
        if(s == nil)
                return -1;
        return 0;
}

static int
clip(int x)
{
        x >>= Shift + 2;        /* +2 as we assume all input images are 10 bit */
        if(x > 255)
                return 0xff;
        if(x <= 0)
                return 0;
        return x;
}

Rawimage**
BreadV210(Biobuf *bp, int colourspace)
{
        Dir *d;
        uvlong sz;
        Rawimage *a, **array;
        ushort *mux, *end, *frm, *wr;
        uchar *buf, *r, *g, *b;
        uint i, t;
        int y1, y2, cb, cr, c, l, rd;
        int chunk, lines, pixels;
        int F1, F2, F3, F4;

        buf = nil;
        if(colourspace != CYCbCr){
                werrstr("BreadV210: unknown colour space %d", colourspace);
                return nil;
        }

        if((d = dirfstat(Bfildes(bp))) != nil){
                sz = d->length;
                free(d);
        }
        else {
                fprint(2, "cannot stat input, assuming pixelsx576x10bit\n");
                sz = Pixels * R601pal * 2L + (pixels * R601pal / 2L);
        }

        if(looksize("/lib/video.specs", sz, &pixels, &lines, &chunk) == -1){
                werrstr("file spec not in /lib/video.specs\n");
                return nil;
        }

        if((a = calloc(sizeof(Rawimage), 1)) == nil)
                sysfatal("no memory");

        if((array = calloc(sizeof(Rawimage * ), 2)) == nil)
                sysfatal("no memory");
        array[0] = a;
        array[1] = nil;

        a->nchans = 3;
        a->chandesc = CRGB;
        a->chanlen = pixels * lines;
        a->r = Rect(0, 0, pixels, lines);

        if((frm = malloc(pixels*2*lines*sizeof(ushort))) == nil)
                goto Error;

        for(c = 0; c  < 3; c++)
                if((a->chans[c] = malloc(pixels*lines)) == nil)
                        goto Error;

        if((buf = malloc(chunk)) == nil)
                goto Error;

        for(l = 0; l < lines; l++){
                if(Bread(bp, buf, chunk) == -1)
                        goto Error;

                rd = 0;
                wr = &frm[l*pixels*2];
                end = &frm[(l+1)*pixels*2];
                while(wr < end){
                        t = 0;
                        for(i = 0; i < 4; i++)
                                t += buf[rd+i] << 8*i;
                        *wr++ = t & 0x3ff;
                        *wr++ = t>>10 & 0x3ff;
                        *wr++ = t>>20 & 0x3ff;
                        rd += 4;
                }
        }

        mux = frm;
        end = frm + pixels * lines * 2;
        r = a->chans[0];
        g = a->chans[1];
        b = a->chans[2];

        if(pixels == Pixels && lines != R601pal){       // 625
                F1 = floor(1.402 * (1 << Shift));
                F2 = floor(0.34414 * (1 << Shift));
                F3 = floor(0.71414 * (1 << Shift));
                F4 = floor(1.772 * (1 << Shift));
        }
        else{                                           // 525 and HD
                F1 = floor(1.5748 * (1 << Shift));
                F2 = floor(0.1874 * (1 << Shift));
                F3 = floor(0.4681 * (1 << Shift));
                F4 = floor(1.8560 * (1 << Shift));
        }

        /*
         * Fixme: fixed colourspace conversion at present
         */
        while(mux < end){

                cb = *mux++ - 512;
                y1 = (int)*mux++ << Shift;
                cr = *mux++ - 512;
                y2 = (int)*mux++ << Shift;

                *r++ = clip(y1 + F1*cr);
                *g++ = clip(y1 - F2*cb - F3*cr);
                *b++ = clip((y1 + F4*cb));

                *r++ = clip(y2 + F1*cr);
                *g++ = clip(y2 - F2*cb - F3*cr);
                *b++ = clip((y2 + F4*cb));
        }
        free(frm);
        free(buf);
        return array;

Error:
        for(c = 0; c < 3; c++)
                free(a->chans[c]);
        free(a->cmap);
        free(array[0]);
        free(array);
        free(frm);
        free(buf);
        return nil;
}

Rawimage**
readV210(int fd, int colorspace)
{
        Rawimage * *a;
        Biobuf b;

        if(Binit(&b, fd, OREAD) < 0)
                return nil;
        a = BreadV210(&b, colorspace);
        Bterm(&b);
        return a;
}