hvirtual/quicktime/wmx1.c

Go to the documentation of this file.

#include "quicktime.h"
#include "jpeglib.h"

#define ABS(x) ((x) < 0 ? -(x) : (x)) 

int quicktime_init_codec_wmx1(quicktime_video_map_t *vtrack)
{
        int i;
        quicktime_wmx1_codec_t *codec = &(vtrack->codecs.wmx1_codec);

        quicktime_init_yuv(&(codec->yuv_tables));
        codec->bytes_per_line = vtrack->track->tkhd.track_width * 3;
        if((float)codec->bytes_per_line / 6 > (int)(codec->bytes_per_line / 6))
                codec->bytes_per_line += 3;

        codec->rows = vtrack->track->tkhd.track_height / 2;
        if((float)vtrack->track->tkhd.track_height / 2 > (int)(vtrack->track->tkhd.track_height / 2))
                codec->rows++;

        for(i = 0; i < WMX_CHUNK_FRAMES; i++)
                codec->frame_cache[i] = 0;

        codec->key_frame = 0;
        codec->keyframe_position = 0;
        codec->quality = 100;
        codec->use_float = 0;
        codec->frames_per_chunk = 0;
        codec->threshold = 5;
        return 0;
}

int quicktime_delete_codec_wmx1(quicktime_video_map_t *vtrack)
{
        int i;
        quicktime_wmx1_codec_t *codec = &(vtrack->codecs.wmx1_codec);

        quicktime_delete_yuv(&(codec->yuv_tables));
        for(i = 0; i < WMX_CHUNK_FRAMES; i++)
                if(codec->frame_cache[i]) free(codec->frame_cache[i]);

        if(codec->key_frame) free(codec->key_frame);
        return 0;
}

int wmx1_write_cache(quicktime_t *file, int track)
{
        long offset = quicktime_position(file);
        quicktime_video_map_t *vtrack = &(file->vtracks[track]);
        quicktime_wmx1_codec_t *codec = &(vtrack->codecs.wmx1_codec);
        int width = codec->bytes_per_line;
        int height = codec->rows;
        int result = 0;
        int frame, channel, i, j, k;
        long bytes_per_row = codec->bytes_per_line;
        int step = codec->frames_per_chunk * bytes_per_row;
        long bytes = height * bytes_per_row * codec->frames_per_chunk;
        long output_bytes;
        unsigned char *input_row, *input_end, *output_row, *input_frame, *output_frame;

/*printf("wmx1_write_cache 1 %d %d %d\n", bytes_per_row, bytes_per_channel, bytes); */
        if(!codec->key_frame)
        {
                codec->key_frame = malloc(bytes);
                if(!codec->key_frame) result = 1;
        }
/*printf("wmx1_write_cache 2\n"); */

/* Interlace rows */
        for(frame = 0; frame < codec->frames_per_chunk; frame++)
        {
                input_frame = codec->frame_cache[frame];
                output_frame = codec->key_frame + frame * bytes_per_row;
                input_row = input_frame;
                output_row = output_frame;

                for(i = 0; i < height; i++)
                {
                        for(j = 0; j < width; j++)
                        {
                                output_row[j] = input_row[j];
                        }
                        output_row += step;
                        input_row += bytes_per_row;
                }
        }

/* Write as a jpeg */
/*      { */
/*              struct jpeg_compress_struct jpeg_compress; */
/*              struct jpeg_error_mgr jpeg_error; */
/*              JSAMPROW row_pointer[1]; */
/*              jpeg_compress.err = jpeg_std_error(&jpeg_error); */
/*              jpeg_create_compress(&jpeg_compress); */
/*              jpeg_stdio_dest(&jpeg_compress, quicktime_get_fd(file)); */
/*              jpeg_compress.image_width = bytes_per_row; */
/*              jpeg_compress.image_height = height * codec->frames_per_chunk; */
/*              jpeg_compress.input_components = 1; */
/*              jpeg_compress.in_color_space = JCS_GRAYSCALE; */
/*              jpeg_set_defaults(&jpeg_compress); */
/*              jpeg_set_quality(&jpeg_compress, codec->quality, 0); */
/*              jpeg_start_compress(&jpeg_compress, TRUE); */
/*              while(jpeg_compress.next_scanline < jpeg_compress.image_height && !result) */
/*              { */
/*                      row_pointer[0] = codec->key_frame + jpeg_compress.next_scanline * bytes_per_row; */
/*                      result = jpeg_write_scanlines(&jpeg_compress, row_pointer, 1); */
/*                      result = !result; */
/*              } */
/*              jpeg_finish_compress(&jpeg_compress); */
/*              jpeg_destroy((j_common_ptr)&jpeg_compress); */
/*      } */

/* Write as raw */
        result = quicktime_write_data(file, codec->key_frame, bytes);
        result = !result;
/*printf("wmx1_write_cache 4\n"); */

        output_bytes = quicktime_position(file) - offset;
        quicktime_update_tables(file,
                                                vtrack->track,
                                                offset,
                                                vtrack->current_chunk,
                                                vtrack->current_position,
                                                codec->frames_per_chunk,
                                                output_bytes);
/*printf("wmx1_write_cache 5\n"); */

        codec->frames_per_chunk = 0;
        vtrack->current_chunk++;
        return result;
}

/* Perform YUV transform and store in cache */
int wmx1_store_in_cache(quicktime_t *file, unsigned char *cache, unsigned char **row_pointers, int track)
{
        long offset = quicktime_position(file);
        quicktime_video_map_t *vtrack = &(file->vtracks[track]);
        quicktime_wmx1_codec_t *codec = &(vtrack->codecs.wmx1_codec);
        quicktime_yuv_t *yuv_tables = &(codec->yuv_tables);
        int result = 0;
        int width = vtrack->track->tkhd.track_width;
        int height = vtrack->track->tkhd.track_height;
        long bytes = codec->rows * codec->bytes_per_line;
        unsigned char *buffer = cache;
        unsigned char *output_row;    /* Pointer to output row */
        unsigned char *row_pointer1, *row_pointer2;  /* Pointers to input rows */
        int x1, x2, in_y, out_y;
        int y1, y2, y3, y4, u, v;
        int r, g, b;
        int endpoint = width * 3;
        int denominator;

        for(in_y = 0, out_y = 0; in_y < height; out_y++)
        {
                output_row = buffer + out_y * codec->bytes_per_line;
                row_pointer1 = row_pointers[in_y];
                in_y++;

                if(in_y < height)
                        row_pointer2 = row_pointers[in_y];
                else
                        row_pointer2 = row_pointer1;

                in_y++;

                for(x1 = 0, x2 = 0; x1 < endpoint; )
                {
/* Top left pixel */
                        r = row_pointer1[x1++];
                        g = row_pointer1[x1++];
                        b = row_pointer1[x1++];

                        y1 = (yuv_tables->rtoy_tab[r] + yuv_tables->gtoy_tab[g] + yuv_tables->btoy_tab[b]);
                        u = (yuv_tables->rtou_tab[r] + yuv_tables->gtou_tab[g] + yuv_tables->btou_tab[b]);
                        v = (yuv_tables->rtov_tab[r] + yuv_tables->gtov_tab[g] + yuv_tables->btov_tab[b]);

/* Top right pixel */
                        if(x1 < endpoint)
                        {
                                r = row_pointer1[x1++];
                                g = row_pointer1[x1++];
                                b = row_pointer1[x1++];
                        }

                        y2 = (yuv_tables->rtoy_tab[r] + yuv_tables->gtoy_tab[g] + yuv_tables->btoy_tab[b]);
                        u += (yuv_tables->rtou_tab[r] + yuv_tables->gtou_tab[g] + yuv_tables->btou_tab[b]);
                        v += (yuv_tables->rtov_tab[r] + yuv_tables->gtov_tab[g] + yuv_tables->btov_tab[b]);

/* Bottom left pixel */
                        r = row_pointer2[x2++];
                        g = row_pointer2[x2++];
                        b = row_pointer2[x2++];

                        y3 = (yuv_tables->rtoy_tab[r] + yuv_tables->gtoy_tab[g] + yuv_tables->btoy_tab[b]);
                        u += (yuv_tables->rtou_tab[r] + yuv_tables->gtou_tab[g] + yuv_tables->btou_tab[b]);
                        v += (yuv_tables->rtov_tab[r] + yuv_tables->gtov_tab[g] + yuv_tables->btov_tab[b]);

/* Bottom right pixel */
                        if(x2 < endpoint)
                        {
                                r = row_pointer2[x2++];
                                g = row_pointer2[x2++];
                                b = row_pointer2[x2++];
                        }

                        y4 = (yuv_tables->rtoy_tab[r] + yuv_tables->gtoy_tab[g] + yuv_tables->btoy_tab[b]);
                        u += (yuv_tables->rtou_tab[r] + yuv_tables->gtou_tab[g] + yuv_tables->btou_tab[b]);
                        v += (yuv_tables->rtov_tab[r] + yuv_tables->gtov_tab[g] + yuv_tables->btov_tab[b]);

                        y1 /= 0x10000;
                        y2 /= 0x10000;
                        y3 /= 0x10000;
                        y4 /= 0x10000;
                        u /= 0x40000;
                        v /= 0x40000;
                        if(y1 > 255) y1 = 255;
                        if(y2 > 255) y2 = 255;
                        if(y3 > 255) y3 = 255;
                        if(y4 > 255) y4 = 255;
                        if(u > 127) u = 127;
                        if(v > 127) v = 127;
                        if(y1 < 0) y1 = 0;
                        if(y2 < 0) y2 = 0;
                        if(y3 < 0) y3 = 0;
                        if(y4 < 0) y4 = 0;
                        if(u < -128) u = -128;
                        if(v < -128) v = -128;

                        *output_row++ = u;
                        *output_row++ = v;
                        *output_row++ = y1;
                        *output_row++ = y2;
                        *output_row++ = y3;
                        *output_row++ = y4;
                }
        }
        return 0;
}

int quicktime_encode_wmx1(quicktime_t *file, unsigned char **row_pointers, int track)
{
        int result = 0;
        int written_cache = 0;
        quicktime_video_map_t *vtrack = &(file->vtracks[track]);
        quicktime_wmx1_codec_t *codec = &(vtrack->codecs.wmx1_codec);
        int width = vtrack->track->tkhd.track_width;
        int height = vtrack->track->tkhd.track_height;
        int bytes = codec->rows * codec->bytes_per_line;
        long frame_difference = 0;
        int i;

/* Arm cache */
        if(codec->frames_per_chunk < WMX_CHUNK_FRAMES)
        {
                unsigned char *frame_cache;
                unsigned char *row_pointer1, *row_pointer2, *endpoint;
                if(!codec->frame_cache[codec->frames_per_chunk])
                        codec->frame_cache[codec->frames_per_chunk] = malloc(bytes);
                frame_cache = codec->frame_cache[codec->frames_per_chunk];

/* Copy to cache */
                wmx1_store_in_cache(file, frame_cache, row_pointers, track);
                codec->frames_per_chunk++;
        }
        else
        {
/* Write cache and start new cache. */
                unsigned char *frame_cache;

                result = wmx1_write_cache(file, track);
                written_cache = 1;

/* Copy next frame to cache */
                if(!codec->frame_cache[codec->frames_per_chunk])
                        codec->frame_cache[codec->frames_per_chunk] = malloc(bytes);
                frame_cache = codec->frame_cache[codec->frames_per_chunk];
                wmx1_store_in_cache(file, codec->frame_cache[codec->frames_per_chunk], row_pointers, track);
                codec->frames_per_chunk++;
        }
/*printf("quicktime_encode_wmx1 3\n"); */

/*      if(!written_cache) */
/*              quicktime_update_tables(file, */
/*                                              vtrack->track, */
/*                                              offset, */
/*                                              vtrack->current_chunk, */
/*                                              vtrack->current_position, */
/*                                              codec->frames_per_chunk, */
/*                                              output_bytes); */
/*  */
        return result;
}

int quicktime_decode_wmx1(quicktime_t *file, unsigned char **row_pointers, int track)
{
        int result = 0;
        return result;
}

---