diff options
| -rw-r--r-- | AUTHORS | 5 | ||||
| -rw-r--r-- | ChangeLog | 1 | ||||
| -rw-r--r-- | src/libxinevdec/Makefile.am | 6 | ||||
| -rw-r--r-- | src/libxinevdec/qtsmc.c | 708 |
4 files changed, 717 insertions, 3 deletions
@@ -234,8 +234,9 @@ Contributions Mike Melanson <melanson@pcisys.net> QT, FILM, RoQ, WAV, FLI, SMJPEG, Id CIN, WC3 movie, VOC, VQA, AIFF, - and SND/AU file demuxers, RoQ audio decoder, various ADPCM audio - decoders, raw RGB & YUV support, FLI & MS RLE video decoders + and SND/AU file demuxers; RoQ audio decoder; various ADPCM audio + decoders; raw RGB & YUV support; FLI, MS RLE, and QT SMC video + decoders Tim Ferguson <timf@mail.csse.monash.edu.au> CYUV, RoQ, and Id CIN video decoders @@ -9,6 +9,7 @@ xine-lib (next version) [someone fill in stability and urgency] * AIFF file demuxer * Sun/NeXT SND/AU file demuxer * Id CIN video decoder + * QT SMC video decoder * time-based seeking in ogg-streams * improved support for ogg-streams containing video (so-called ogm streams) * spu encoding for full overlay support with dxr3 diff --git a/src/libxinevdec/Makefile.am b/src/libxinevdec/Makefile.am index 04df1b283..75ef4718e 100644 --- a/src/libxinevdec/Makefile.am +++ b/src/libxinevdec/Makefile.am @@ -11,7 +11,8 @@ lib_LTLIBRARIES = xineplug_decode_cinepak.la xineplug_decode_cyuv.la \ xineplug_decode_msvc.la xineplug_decode_roqvideo.la \ xineplug_decode_svq1.la xineplug_decode_fli.la \ xineplug_decode_rgb.la xineplug_decode_yuv.la \ - xineplug_decode_msrle.la xineplug_decode_idcinvideo.la + xineplug_decode_msrle.la xineplug_decode_idcinvideo.la \ + xineplug_decode_qtsmc.la xineplug_decode_cinepak_la_SOURCES = cinepak.c xineplug_decode_cinepak_la_LDFLAGS = -avoid-version -module @@ -43,6 +44,9 @@ xineplug_decode_msrle_la_LDFLAGS = -avoid-version -module xineplug_decode_idcinvideo_la_SOURCES = idcinvideo.c xineplug_decode_idcinvideo_la_LDFLAGS = -avoid-version -module +xineplug_decode_qtsmc_la_SOURCES = qtsmc.c +xineplug_decode_qtsmc_la_LDFLAGS = -avoid-version -module + noinst_HEADERS = svq1_codebooks.h debug: diff --git a/src/libxinevdec/qtsmc.c b/src/libxinevdec/qtsmc.c new file mode 100644 index 000000000..ff9518191 --- /dev/null +++ b/src/libxinevdec/qtsmc.c @@ -0,0 +1,708 @@ +/* + * Copyright (C) 2000-2002 the xine project + * + * This file is part of xine, a free video player. + * + * xine is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * xine is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA + * + * Apple Graphics (SMC) Decoder by Mike Melanson (melanson@pcisys.net) + * Special thanks to Roberto Togni <rtogni@bresciaonline.it> for tracking + * down the final, nagging bugs. + * For more information on the SMC format, visit: + * http://www.pcisys.net/~melanson/codecs/ + * + * $Id: qtsmc.c,v 1.1 2002/08/29 06:09:06 tmmm Exp $ + */ + +#include <stdio.h> +#include <stdlib.h> +#include <string.h> +#include <sys/types.h> +#include <unistd.h> + +#include "video_out.h" +#include "buffer.h" +#include "xine_internal.h" +#include "xineutils.h" +#include "bswap.h" + +#define VIDEOBUFSIZE 128*1024 + +#define BE_16(x) (be2me_16(*(unsigned short *)(x))) +#define BE_32(x) (be2me_32(*(unsigned int *)(x))) + +#define COLORS_PER_TABLE 256 +#define BYTES_PER_COLOR 4 + +#define CPAIR 2 +#define CQUAD 4 +#define COCTET 8 + +typedef struct qtsmc_decoder_s { + video_decoder_t video_decoder; /* parent video decoder structure */ + + /* these are traditional variables in a video decoder object */ + vo_instance_t *video_out; /* object that will receive frames */ + uint64_t video_step; /* frame duration in pts units */ + int decoder_ok; /* current decoder status */ + int skipframes; + + unsigned char *buf; /* the accumulated buffer data */ + int bufsize; /* the maximum size of buf */ + int size; /* the current size of buf */ + + int width; /* the width of a video frame */ + int height; /* the height of a video frame */ + + /* SMC color tables */ + unsigned char color_pairs[COLORS_PER_TABLE * BYTES_PER_COLOR * CPAIR]; + unsigned char color_quads[COLORS_PER_TABLE * BYTES_PER_COLOR * CQUAD]; + unsigned char color_octets[COLORS_PER_TABLE * BYTES_PER_COLOR * COCTET]; + + unsigned char yuv_palette[256 * 4]; + yuv_planes_t yuv_planes; + +} qtsmc_decoder_t; + +/************************************************************************** + * SMC specific decode functions + *************************************************************************/ + +#define GET_BLOCK_COUNT \ + (opcode & 0x10) ? (1 + this->buf[stream_ptr++]) : 1 + (opcode & 0x0F); +#define ADVANCE_BLOCK() \ +{ \ + pixel_ptr += 4; \ + if (pixel_ptr >= this->width) \ + { \ + pixel_ptr = 0; \ + row_ptr += this->width * 4; \ + } \ + total_blocks--; \ + if (total_blocks < 0) \ + { \ + printf(_("warning: block counter just went negative (this should not happen)\n")); \ + return; \ + } \ +} + +void decode_qtsmc(qtsmc_decoder_t *this) { + + int i; + int stream_ptr = 0; + int chunk_size; + unsigned char opcode; + int n_blocks; + unsigned int color_flags; + unsigned int color_flags_a; + unsigned int color_flags_b; + unsigned int flag_mask; + + yuv_planes_t *yuv = &this->yuv_planes; + + int image_size = this->height * this->width; + int row_ptr = 0; + int pixel_ptr = 0; + int pixel_x, pixel_y; + int row_inc = this->width - 4; + int block_ptr; + int prev_block_ptr; + int prev_block_ptr1, prev_block_ptr2; + int prev_block_flag; + int total_blocks; + int color_table_index; /* indexes to color pair, quad, or octet tables */ + int color_index; /* indexes into palette map */ + + int color_pair_index = 0; + int color_quad_index = 0; + int color_octet_index = 0; + + chunk_size = BE_32(&this->buf[stream_ptr]) & 0x00FFFFFF; + stream_ptr += 4; + if (chunk_size != this->size) + printf(_("warning: MOV chunk size != encoded chunk size (%d != %d); using MOV chunk size\n"), + chunk_size, this->size); + + chunk_size = this->size; + total_blocks = (this->width * this->height) / (4 * 4); + + /* traverse through the blocks */ + while (total_blocks) { + /* sanity checks */ + /* make sure stream ptr hasn't gone out of bounds */ + if (stream_ptr > chunk_size) { + printf(_( + "SMC decoder just went out of bounds (stream ptr = %d, chunk size = %d)\n"), + stream_ptr, chunk_size); + return; + } + /* make sure the row pointer hasn't gone wild */ + if (row_ptr >= image_size) { + printf(_( + "SMC decoder just went out of bounds (row ptr = %d, height = %d)\n"), + row_ptr, image_size); + return; + } + + opcode = this->buf[stream_ptr++]; + switch (opcode & 0xF0) { + /* skip n blocks */ + case 0x00: + case 0x10: + n_blocks = GET_BLOCK_COUNT; + while (n_blocks--) + ADVANCE_BLOCK(); + break; + + /* repeat last block n times */ + case 0x20: + case 0x30: + n_blocks = GET_BLOCK_COUNT; + + /* sanity check */ + if ((row_ptr == 0) && (pixel_ptr == 0)) { + printf(_( + "encountered repeat block opcode (%02X) but no blocks rendered yet\n"), + opcode & 0xF0); + break; + } + + /* figure out where the previous block started */ + if (pixel_ptr == 0) + prev_block_ptr1 = (row_ptr - this->width * 4) + this->width - 4; + else + prev_block_ptr1 = row_ptr + pixel_ptr - 4; + + while (n_blocks--) { + block_ptr = row_ptr + pixel_ptr; + prev_block_ptr = prev_block_ptr1; + for (pixel_y = 0; pixel_y < 4; pixel_y++) { + for (pixel_x = 0; pixel_x < 4; pixel_x++) { + yuv->y[block_ptr] = yuv->y[prev_block_ptr]; + yuv->u[block_ptr] = yuv->u[prev_block_ptr]; + yuv->v[block_ptr] = yuv->v[prev_block_ptr]; + block_ptr++; + prev_block_ptr++; + } + block_ptr += row_inc; + prev_block_ptr += row_inc; + } + ADVANCE_BLOCK(); + } + break; + + /* repeat previous pair of blocks n times */ + case 0x40: + case 0x50: + n_blocks = GET_BLOCK_COUNT; + n_blocks *= 2; + + /* sanity check */ + if ((row_ptr == 0) && (pixel_ptr < 2 * 4)) { + printf(_( + "encountered repeat block opcode (%02X) but not enough blocks rendered yet\n"), + opcode & 0xF0); + break; + } + + /* figure out where the previous 2 blocks started */ + if (pixel_ptr == 0) + prev_block_ptr1 = (row_ptr - this->width * 4) + + this->width - 4 * 2; + else if (pixel_ptr == 4) + prev_block_ptr1 = (row_ptr - this->width * 4) + row_inc; + else + prev_block_ptr1 = row_ptr + pixel_ptr - 4 * 2; + + if (pixel_ptr == 0) + prev_block_ptr2 = (row_ptr - this->width * 4) + row_inc; + else + prev_block_ptr2 = row_ptr + pixel_ptr - 4; + + prev_block_flag = 0; + while (n_blocks--) { + block_ptr = row_ptr + pixel_ptr; + if (prev_block_flag) + prev_block_ptr = prev_block_ptr2; + else + prev_block_ptr = prev_block_ptr1; + prev_block_flag = !prev_block_flag; + + for (pixel_y = 0; pixel_y < 4; pixel_y++) { + for (pixel_x = 0; pixel_x < 4; pixel_x++) { + yuv->y[block_ptr] = yuv->y[prev_block_ptr]; + yuv->u[block_ptr] = yuv->u[prev_block_ptr]; + yuv->v[block_ptr] = yuv->v[prev_block_ptr]; + block_ptr++; + prev_block_ptr++; + } + block_ptr += row_inc; + prev_block_ptr += row_inc; + } + ADVANCE_BLOCK(); + } + break; + + /* 1-color block encoding */ + case 0x60: + case 0x70: + n_blocks = GET_BLOCK_COUNT; + color_index = this->buf[stream_ptr++] * 4; + + while (n_blocks--) { + block_ptr = row_ptr + pixel_ptr; + for (pixel_y = 0; pixel_y < 4; pixel_y++) { + for (pixel_x = 0; pixel_x < 4; pixel_x++) { + yuv->y[block_ptr] = this->yuv_palette[color_index + 0]; + yuv->u[block_ptr] = this->yuv_palette[color_index + 1]; + yuv->v[block_ptr] = this->yuv_palette[color_index + 2]; + block_ptr++; + } + block_ptr += row_inc; + } + ADVANCE_BLOCK(); + } + break; + + /* 2-color block encoding */ + case 0x80: + case 0x90: + n_blocks = (opcode & 0x0F) + 1; + + /* figure out which color pair to use to paint the 2-color block */ + if ((opcode & 0xF0) == 0x80) { + /* fetch the next 2 colors from bytestream and store in next + * available entry in the color pair table */ + for (i = 0; i < CPAIR; i++) { + color_index = this->buf[stream_ptr++] * BYTES_PER_COLOR; + color_table_index = CPAIR * BYTES_PER_COLOR * color_pair_index + + (i * BYTES_PER_COLOR); + this->color_pairs[color_table_index + 0] = + this->yuv_palette[color_index + 0]; + this->color_pairs[color_table_index + 1] = + this->yuv_palette[color_index + 1]; + this->color_pairs[color_table_index + 2] = + this->yuv_palette[color_index + 2]; + } + /* this is the base index to use for this block */ + color_table_index = CPAIR * BYTES_PER_COLOR * color_pair_index; + color_pair_index++; + /* wraparound */ + if (color_pair_index == COLORS_PER_TABLE) + color_pair_index = 0; + } + else + color_table_index = CPAIR * BYTES_PER_COLOR * this->buf[stream_ptr++]; + + while (n_blocks--) { + color_flags = BE_16(&this->buf[stream_ptr]); + stream_ptr += 2; + flag_mask = 0x8000; + block_ptr = row_ptr + pixel_ptr; + for (pixel_y = 0; pixel_y < 4; pixel_y++) { + for (pixel_x = 0; pixel_x < 4; pixel_x++) { + if (color_flags & flag_mask) + color_index = color_table_index + BYTES_PER_COLOR; + else + color_index = color_table_index; + flag_mask >>= 1; + + yuv->y[block_ptr] = this->color_pairs[color_index + 0]; + yuv->u[block_ptr] = this->color_pairs[color_index + 1]; + yuv->v[block_ptr] = this->color_pairs[color_index + 2]; + block_ptr++; + } + block_ptr += row_inc; + } + ADVANCE_BLOCK(); + } + break; + + /* 4-color block encoding */ + case 0xA0: + case 0xB0: + n_blocks = (opcode & 0x0F) + 1; + + /* figure out which color quad to use to paint the 4-color block */ + if ((opcode & 0xF0) == 0xA0) { + /* fetch the next 4 colors from bytestream and store in next + * available entry in the color quad table */ + for (i = 0; i < CQUAD; i++) { + color_index = this->buf[stream_ptr++] * BYTES_PER_COLOR; + color_table_index = CQUAD * BYTES_PER_COLOR * color_quad_index + + (i * BYTES_PER_COLOR); + this->color_quads[color_table_index + 0] = + this->yuv_palette[color_index + 0]; + this->color_quads[color_table_index + 1] = + this->yuv_palette[color_index + 1]; + this->color_quads[color_table_index + 2] = + this->yuv_palette[color_index + 2]; + } + /* this is the base index to use for this block */ + color_table_index = CQUAD * BYTES_PER_COLOR * color_quad_index; + color_quad_index++; + /* wraparound */ + if (color_quad_index == COLORS_PER_TABLE) + color_quad_index = 0; + } + else + color_table_index = CQUAD * BYTES_PER_COLOR * this->buf[stream_ptr++]; + + while (n_blocks--) { + color_flags = BE_32(&this->buf[stream_ptr]); + stream_ptr += 4; + /* flag mask actually acts as a bit shift count here */ + flag_mask = 30; + block_ptr = row_ptr + pixel_ptr; + for (pixel_y = 0; pixel_y < 4; pixel_y++) { + for (pixel_x = 0; pixel_x < 4; pixel_x++) { + color_index = color_table_index + (BYTES_PER_COLOR * + ((color_flags >> flag_mask) & 0x03)); + flag_mask -= 2; + + yuv->y[block_ptr] = this->color_quads[color_index + 0]; + yuv->u[block_ptr] = this->color_quads[color_index + 1]; + yuv->v[block_ptr] = this->color_quads[color_index + 2]; + block_ptr++; + } + block_ptr += row_inc; + } + ADVANCE_BLOCK(); + } + break; + + /* 8-color block encoding */ + case 0xC0: + case 0xD0: + n_blocks = (opcode & 0x0F) + 1; + + /* figure out which color octet to use to paint the 8-color block */ + if ((opcode & 0xF0) == 0xC0) { + /* fetch the next 8 colors from bytestream and store in next + * available entry in the color octet table */ + for (i = 0; i < COCTET; i++) { + color_index = this->buf[stream_ptr++] * BYTES_PER_COLOR; + color_table_index = COCTET * BYTES_PER_COLOR * color_octet_index + + (i * BYTES_PER_COLOR); + this->color_octets[color_table_index + 0] = + this->yuv_palette[color_index + 0]; + this->color_octets[color_table_index + 1] = + this->yuv_palette[color_index + 1]; + this->color_octets[color_table_index + 2] = + this->yuv_palette[color_index + 2]; + } + /* this is the base index to use for this block */ + color_table_index = COCTET * BYTES_PER_COLOR * color_octet_index; + color_octet_index++; + /* wraparound */ + if (color_octet_index == COLORS_PER_TABLE) + color_octet_index = 0; + } + else + color_table_index = COCTET * BYTES_PER_COLOR * this->buf[stream_ptr++]; + + while (n_blocks--) { + /* + For this input of 6 hex bytes: + 01 23 45 67 89 AB + Mangle it to this output: + flags_a = xx012456, flags_b = xx89A37B + */ + /* build the color flags */ + color_flags_a = color_flags_b = 0; + color_flags_a = + (this->buf[stream_ptr + 0] << 16) | + ((this->buf[stream_ptr + 1] & 0xF0) << 8) | + ((this->buf[stream_ptr + 2] & 0xF0) << 4) | + ((this->buf[stream_ptr + 2] & 0x0F) << 4) | + ((this->buf[stream_ptr + 3] & 0xF0) >> 4); + color_flags_b = + (this->buf[stream_ptr + 4] << 16) | + ((this->buf[stream_ptr + 5] & 0xF0) << 8) | + ((this->buf[stream_ptr + 1] & 0x0F) << 8) | + ((this->buf[stream_ptr + 3] & 0x0F) << 4) | + (this->buf[stream_ptr + 5] & 0x0F); + stream_ptr += 6; + + color_flags = color_flags_a; + /* flag mask actually acts as a bit shift count here */ + flag_mask = 21; + block_ptr = row_ptr + pixel_ptr; + for (pixel_y = 0; pixel_y < 4; pixel_y++) { + /* reload flags at third row (iteration pixel_y == 2) */ + if (pixel_y == 2) { + color_flags = color_flags_b; + flag_mask = 21; + } + for (pixel_x = 0; pixel_x < 4; pixel_x++) { + color_index = color_table_index + (BYTES_PER_COLOR * + ((color_flags >> flag_mask) & 0x07)); + flag_mask -= 3; + + yuv->y[block_ptr] = this->color_octets[color_index + 0]; + yuv->u[block_ptr] = this->color_octets[color_index + 1]; + yuv->v[block_ptr] = this->color_octets[color_index + 2]; + block_ptr++; + } + block_ptr += row_inc; + } + ADVANCE_BLOCK(); + } + break; + + /* 16-color block encoding (every pixel is a different color) */ + case 0xE0: + n_blocks = (opcode & 0x0F) + 1; + + while (n_blocks--) { + block_ptr = row_ptr + pixel_ptr; + for (pixel_y = 0; pixel_y < 4; pixel_y++) { + for (pixel_x = 0; pixel_x < 4; pixel_x++) { + color_index = this->buf[stream_ptr++] * BYTES_PER_COLOR; + yuv->y[block_ptr] = this->yuv_palette[color_index + 0]; + yuv->u[block_ptr] = this->yuv_palette[color_index + 1]; + yuv->v[block_ptr] = this->yuv_palette[color_index + 2]; + block_ptr++; + } + block_ptr += row_inc; + } + ADVANCE_BLOCK(); + } + break; + + case 0xF0: + printf(_("0xF0 opcode seen in SMC chunk (xine developers would like to know)\n")); + break; + } + } +} + + +/************************************************************************** + * xine video plugin functions + *************************************************************************/ + +/* + * This function is called by xine to determine which buffer types this + * decoder knows how to handle. + * Parameters: + * this_gen: A video decoder object + * buf_type: The number of the buffer type that xine is querying for; + * these buffer constants are defined in src/xine-engine/buffer.h. + * Return: + * 1 if the decoder is capable of handling buf_type + * 0 if the decoder is not capable of handling buf_type + */ +static int qtsmc_can_handle (video_decoder_t *this_gen, int buf_type) { + + return (buf_type == BUF_VIDEO_SMC); +} + +/* + * This function is responsible is called to initialize the video decoder + * for use. Initialization usually involves setting up the fields in your + * private video decoder object. + */ +static void qtsmc_init (video_decoder_t *this_gen, + vo_instance_t *video_out) { + qtsmc_decoder_t *this = (qtsmc_decoder_t *) this_gen; + + /* set our own video_out object to the one that xine gives us */ + this->video_out = video_out; + + /* indicate that the decoder is not quite ready yet */ + this->decoder_ok = 0; +} + +/* + * This function receives a buffer of data from the demuxer layer and + * figures out how to handle it based on its header flags. + */ +static void qtsmc_decode_data (video_decoder_t *this_gen, + buf_element_t *buf) { + + qtsmc_decoder_t *this = (qtsmc_decoder_t *) this_gen; + xine_bmiheader *bih; + palette_entry_t *palette; + int i; + + vo_frame_t *img; /* video out frame */ + + /* a video decoder does not care about this flag (?) */ + if (buf->decoder_flags & BUF_FLAG_PREVIEW) + return; + + if ((buf->decoder_flags & BUF_FLAG_SPECIAL) && + (buf->decoder_info[1] == BUF_SPECIAL_PALETTE)) { + palette = (palette_entry_t *)buf->decoder_info[3]; + for (i = 0; i < buf->decoder_info[2]; i++) { + this->yuv_palette[i * 4 + 0] = + COMPUTE_Y(palette[i].r, palette[i].g, palette[i].b); + this->yuv_palette[i * 4 + 1] = + COMPUTE_U(palette[i].r, palette[i].g, palette[i].b); + this->yuv_palette[i * 4 + 2] = + COMPUTE_V(palette[i].r, palette[i].g, palette[i].b); + } + } + + if (buf->decoder_flags & BUF_FLAG_HEADER) { /* need to initialize */ + this->video_out->open (this->video_out); + + if(this->buf) + free(this->buf); + + bih = (xine_bmiheader *) buf->content; + this->width = (bih->biWidth + 3) & ~0x03; + this->height = (bih->biHeight + 3) & ~0x03; + this->video_step = buf->decoder_info[1]; + + if (this->buf) + free (this->buf); + this->bufsize = VIDEOBUFSIZE; + this->buf = malloc(this->bufsize); + this->size = 0; + + this->video_out->open (this->video_out); + this->decoder_ok = 1; + + init_yuv_planes(&this->yuv_planes, this->width, this->height); + + return; + } else if (this->decoder_ok) { + + if (this->size + buf->size > this->bufsize) { + this->bufsize = this->size + 2 * buf->size; + this->buf = realloc (this->buf, this->bufsize); + } + + xine_fast_memcpy (&this->buf[this->size], buf->content, buf->size); + + this->size += buf->size; + + if (buf->decoder_flags & BUF_FLAG_FRAMERATE) + this->video_step = buf->decoder_info[0]; + + if (buf->decoder_flags & BUF_FLAG_FRAME_END) { + + img = this->video_out->get_frame (this->video_out, + this->width, this->height, + 42, IMGFMT_YUY2, VO_BOTH_FIELDS); + + img->duration = this->video_step; + img->pts = buf->pts; + img->bad_frame = 0; + + decode_qtsmc(this); + yuv444_to_yuy2(&this->yuv_planes, img->base[0], img->pitches[0]); + + if (img->copy) { + int height = img->height; + uint8_t *src[3]; + + src[0] = img->base[0]; + + while ((height -= 16) >= 0) { + img->copy(img, src); + src[0] += 16 * img->pitches[0]; + } + } + + img->draw(img); + img->free(img); + + this->size = 0; + } + } +} + +/* + * This function is called when xine needs to flush the system. Not + * sure when or if this is used or even if it needs to do anything. + */ +static void qtsmc_flush (video_decoder_t *this_gen) { +} + +/* + * This function resets the video decoder. + */ +static void qtsmc_reset (video_decoder_t *this_gen) { + qtsmc_decoder_t *this = (qtsmc_decoder_t *) this_gen; + + this->size = 0; +} + +/* + * This function is called when xine shuts down the decoder. It should + * free any memory and release any other resources allocated during the + * execution of the decoder. + */ +static void qtsmc_close (video_decoder_t *this_gen) { + qtsmc_decoder_t *this = (qtsmc_decoder_t *) this_gen; + + if (this->buf) { + free (this->buf); + this->buf = NULL; + } + + if (this->decoder_ok) { + this->decoder_ok = 0; + this->video_out->close(this->video_out); + } +} + +/* + * This function returns the human-readable ID string to identify + * this decoder. + */ +static char *qtsmc_get_id(void) { + return "QT SMC"; +} + +/* + * This function frees the video decoder instance allocated to the decoder. + */ +static void qtsmc_dispose (video_decoder_t *this_gen) { + free (this_gen); +} + +video_decoder_t *init_video_decoder_plugin (int iface_version, xine_t *xine) { + + qtsmc_decoder_t *this ; + + if (iface_version != 10) { + printf( "qtsmc: plugin doesn't support plugin API version %d.\n" + "qtsmc: this means there's a version mismatch between xine and this " + "qtsmc: decoder plugin.\nInstalling current plugins should help.\n", + iface_version); + return NULL; + } + + this = (qtsmc_decoder_t *) malloc (sizeof (qtsmc_decoder_t)); + memset(this, 0, sizeof (qtsmc_decoder_t)); + + this->video_decoder.interface_version = iface_version; + this->video_decoder.can_handle = qtsmc_can_handle; + this->video_decoder.init = qtsmc_init; + this->video_decoder.decode_data = qtsmc_decode_data; + this->video_decoder.flush = qtsmc_flush; + this->video_decoder.reset = qtsmc_reset; + this->video_decoder.close = qtsmc_close; + this->video_decoder.get_identifier = qtsmc_get_id; + this->video_decoder.dispose = qtsmc_dispose; + this->video_decoder.priority = 9; + + return (video_decoder_t *) this; +} + |