mirror of
https://github.com/mpv-player/mpv
synced 2025-02-28 19:30:44 +00:00
Add spudec_new_scaled and spudec_draw_scaled for vobsub support.
Change what is passed to spudec_new for vobsub support. Suppress conditional on USE_DVDREAD. Correct a bug where some subtitles with no Stop display control code would not display long enough. Be more strict with bogus packets. Transform everything that should into unsigned. git-svn-id: svn://svn.mplayerhq.hu/mplayer/trunk@4079 b3059339-0415-0410-9bf9-f77b7e298cf2
This commit is contained in:
kmkaplan
parent
0b9a69e3f5
commit
278211c851
349
spudec.c
349
spudec.c
@ -1,3 +1,4 @@
|
||||
#undef WITH_NO_ANTIALIASING
|
||||
/* SPUdec.c
|
||||
Skeleton of function spudec_process_controll() is from xine sources.
|
||||
Further works:
|
||||
@ -14,35 +15,46 @@
|
||||
#include "config.h"
|
||||
#include "mp_msg.h"
|
||||
|
||||
#ifdef USE_DVDREAD
|
||||
|
||||
#include <errno.h>
|
||||
#include <limits.h>
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <unistd.h>
|
||||
#ifndef WITH_NO_ANTIALIASING
|
||||
#include <math.h>
|
||||
#endif
|
||||
#include "spudec.h"
|
||||
|
||||
#define MIN(a, b) ((a)<(b)?(a):(b))
|
||||
|
||||
typedef struct {
|
||||
dvd_priv_t *dvd_info; /* Info from libmpdemux */
|
||||
unsigned int global_palette[16];
|
||||
unsigned int orig_frame_width, orig_frame_height;
|
||||
unsigned char* packet;
|
||||
size_t packet_reserve; /* size of the memory pointed to by packet */
|
||||
int packet_offset; /* end of the currently assembled fragment */
|
||||
int packet_size; /* size of the packet once all fragments are assembled */
|
||||
int control_start; /* index of start of control data */
|
||||
int palette[4];
|
||||
int alpha[4];
|
||||
int now_pts;
|
||||
int start_pts, end_pts;
|
||||
int start_col, end_col;
|
||||
int start_row, end_row;
|
||||
int width, height, stride;
|
||||
int current_nibble[2]; /* next data nibble (4 bits) to be
|
||||
processed (for RLE decoding) for
|
||||
even and odd lines */
|
||||
unsigned int packet_offset; /* end of the currently assembled fragment */
|
||||
unsigned int packet_size; /* size of the packet once all fragments are assembled */
|
||||
unsigned int control_start; /* index of start of control data */
|
||||
unsigned int palette[4];
|
||||
unsigned int alpha[4];
|
||||
unsigned int now_pts;
|
||||
unsigned int start_pts, end_pts;
|
||||
unsigned int start_col, end_col;
|
||||
unsigned int start_row, end_row;
|
||||
unsigned int width, height, stride;
|
||||
unsigned int current_nibble[2]; /* next data nibble (4 bits) to be
|
||||
processed (for RLE decoding) for
|
||||
even and odd lines */
|
||||
int deinterlace_oddness; /* 0 or 1, index into current_nibble */
|
||||
size_t image_size; /* Size of the image buffer */
|
||||
unsigned char *image; /* Grayscale value */
|
||||
unsigned char *aimage; /* Alpha value */
|
||||
int scaled; /* flag if the image has already been scaled */
|
||||
unsigned int scaled_start_col, scaled_start_row;
|
||||
unsigned int scaled_width, scaled_height, scaled_stride;
|
||||
size_t scaled_image_size;
|
||||
unsigned char *scaled_image;
|
||||
unsigned char *scaled_aimage;
|
||||
} spudec_handle_t;
|
||||
|
||||
static inline unsigned int get_be16(const unsigned char *p)
|
||||
@ -65,7 +77,7 @@ static void next_line(spudec_handle_t *this)
|
||||
static inline unsigned char get_nibble(spudec_handle_t *this)
|
||||
{
|
||||
unsigned char nib;
|
||||
int *nibblep = this->current_nibble + this->deinterlace_oddness;
|
||||
unsigned int *nibblep = this->current_nibble + this->deinterlace_oddness;
|
||||
if (*nibblep / 2 >= this->control_start) {
|
||||
mp_msg(MSGT_SPUDEC,MSGL_WARN, "SPUdec: ERROR: get_nibble past end of packet\n");
|
||||
return 0;
|
||||
@ -95,15 +107,16 @@ static inline int mkalpha(int i)
|
||||
|
||||
static void spudec_process_data(spudec_handle_t *this)
|
||||
{
|
||||
int cmap[4], alpha[4];
|
||||
int i, x, y;
|
||||
unsigned int cmap[4], alpha[4];
|
||||
unsigned int i, x, y;
|
||||
|
||||
this->scaled = 0;
|
||||
for (i = 0; i < 4; ++i) {
|
||||
alpha[i] = mkalpha(this->alpha[i]);
|
||||
if (alpha[i] == 0)
|
||||
cmap[i] = 0;
|
||||
else {
|
||||
cmap[i] = ((this->dvd_info->cur_pgc->palette[this->palette[i]] >> 16) & 0xff) - alpha[i];
|
||||
cmap[i] = ((this->global_palette[this->palette[i]] >> 16) & 0xff) - alpha[i];
|
||||
if (cmap[i] < 0)
|
||||
cmap[i] = 0;
|
||||
}
|
||||
@ -134,7 +147,7 @@ static void spudec_process_data(spudec_handle_t *this)
|
||||
while (this->current_nibble[0] < i
|
||||
&& this->current_nibble[1] / 2 < this->control_start
|
||||
&& y < this->height) {
|
||||
int len, color;
|
||||
unsigned int len, color;
|
||||
unsigned int rle = 0;
|
||||
rle = get_nibble(this);
|
||||
if (rle < 0x04) {
|
||||
@ -164,13 +177,13 @@ static void spudec_process_data(spudec_handle_t *this)
|
||||
}
|
||||
}
|
||||
|
||||
static void spudec_process_control(spudec_handle_t *this, int pts100)
|
||||
static void spudec_process_control(spudec_handle_t *this, unsigned int pts100)
|
||||
{
|
||||
int a,b; /* Temporary vars */
|
||||
int date, type;
|
||||
int off;
|
||||
int start_off = 0;
|
||||
int next_off;
|
||||
unsigned int date, type;
|
||||
unsigned int off;
|
||||
unsigned int start_off = 0;
|
||||
unsigned int next_off;
|
||||
|
||||
this->control_start = get_be16(this->packet + 2);
|
||||
next_off = this->control_start;
|
||||
@ -191,6 +204,7 @@ static void spudec_process_control(spudec_handle_t *this, int pts100)
|
||||
/* Start display */
|
||||
mp_msg(MSGT_SPUDEC,MSGL_DBG2,"Start display!\n");
|
||||
this->start_pts = pts100 + date;
|
||||
this->end_pts = UINT_MAX;
|
||||
break;
|
||||
case 0x02:
|
||||
/* Stop display */
|
||||
@ -223,11 +237,11 @@ static void spudec_process_control(spudec_handle_t *this, int pts100)
|
||||
b = get_be24(this->packet + off + 3);
|
||||
this->start_col = a >> 12;
|
||||
this->end_col = a & 0xfff;
|
||||
this->width = this->end_col - this->start_col + 1;
|
||||
this->width = (this->end_col < this->start_col) ? 0 : this->end_col - this->start_col + 1;
|
||||
this->stride = (this->width + 7) & ~7; /* Kludge: draw_alpha needs width multiple of 8 */
|
||||
this->start_row = b >> 12;
|
||||
this->end_row = b & 0xfff;
|
||||
this->height = this->end_row - this->start_row /* + 1 */;
|
||||
this->height = (this->end_row < this->start_row) ? 0 : this->end_row - this->start_row /* + 1 */;
|
||||
mp_msg(MSGT_SPUDEC,MSGL_DBG2,"Coords col: %d - %d row: %d - %d (%dx%d)\n",
|
||||
this->start_col, this->end_col, this->start_row, this->end_row,
|
||||
this->width, this->height);
|
||||
@ -257,17 +271,21 @@ static void spudec_process_control(spudec_handle_t *this, int pts100)
|
||||
}
|
||||
}
|
||||
|
||||
static void spudec_decode(spudec_handle_t *this,int pts100)
|
||||
static void spudec_decode(spudec_handle_t *this, unsigned int pts100)
|
||||
{
|
||||
spudec_process_control(this, pts100);
|
||||
spudec_process_data(this);
|
||||
}
|
||||
|
||||
|
||||
void spudec_assemble(void *this, unsigned char *packet, int len, int pts100)
|
||||
void spudec_assemble(void *this, unsigned char *packet, unsigned int len, unsigned int pts100)
|
||||
{
|
||||
spudec_handle_t *spu = (spudec_handle_t*)this;
|
||||
// spudec_heartbeat(this, pts100);
|
||||
if (len < 2) {
|
||||
mp_msg(MSGT_SPUDEC,MSGL_WARN,"SPUasm: packet too short\n");
|
||||
return;
|
||||
}
|
||||
if (spu->packet_offset == 0) {
|
||||
unsigned int len2 = get_be16(packet);
|
||||
// Start new fragment
|
||||
@ -280,6 +298,10 @@ void spudec_assemble(void *this, unsigned char *packet, int len, int pts100)
|
||||
if (spu->packet != NULL) {
|
||||
spu->deinterlace_oddness = 0;
|
||||
spu->packet_size = len2;
|
||||
if (len > len2) {
|
||||
mp_msg(MSGT_SPUDEC,MSGL_WARN,"SPUasm: invalid frag len / len2: %d / %d \n", len, len2);
|
||||
return;
|
||||
}
|
||||
memcpy(spu->packet, packet, len);
|
||||
spu->packet_offset = len;
|
||||
}
|
||||
@ -297,8 +319,8 @@ void spudec_assemble(void *this, unsigned char *packet, int len, int pts100)
|
||||
// check if we have a complete packet (unfortunatelly packet_size is bad
|
||||
// for some disks)
|
||||
// if (spu->packet_offset == spu->packet_size)
|
||||
{ int x=0,y;
|
||||
while(x>=0 && x+4<=spu->packet_offset){
|
||||
{ unsigned int x=0,y;
|
||||
while(x+4<=spu->packet_offset){
|
||||
y=get_be16(spu->packet+x+2); // next control pointer
|
||||
mp_msg(MSGT_SPUDEC,MSGL_DBG2,"SPUtest: x=%d y=%d off=%d size=%d\n",x,y,spu->packet_offset,spu->packet_size);
|
||||
if(x>=4 && x==y){ // if it points to self - we're done!
|
||||
@ -327,11 +349,11 @@ void spudec_assemble(void *this, unsigned char *packet, int len, int pts100)
|
||||
void spudec_reset(void *this) // called after seek
|
||||
{
|
||||
spudec_handle_t *spu = (spudec_handle_t*)this;
|
||||
spu->now_pts = -1;
|
||||
spu->now_pts = 0;
|
||||
spu->packet_size = spu->packet_offset = 0;
|
||||
}
|
||||
|
||||
void spudec_heartbeat(void *this, int pts100)
|
||||
void spudec_heartbeat(void *this, unsigned int pts100)
|
||||
{
|
||||
((spudec_handle_t *)this)->now_pts = pts100;
|
||||
}
|
||||
@ -344,28 +366,277 @@ void spudec_draw(void *this, void (*draw_alpha)(int x0,int y0, int w,int h, unsi
|
||||
spu->image, spu->aimage, spu->stride);
|
||||
}
|
||||
|
||||
void *spudec_new(dvd_priv_t *dvd_info)
|
||||
/* transform mplayer's alpha value into an opacity value that is linear */
|
||||
static inline int canon_alpha(int alpha)
|
||||
{
|
||||
return alpha ? 256 - alpha : 0;
|
||||
}
|
||||
|
||||
void spudec_draw_scaled(void *me, unsigned int dxs, unsigned int dys, void (*draw_alpha)(int x0,int y0, int w,int h, unsigned char* src, unsigned char *srca, int stride))
|
||||
{
|
||||
spudec_handle_t *spu = (spudec_handle_t *)me;
|
||||
if (spu->start_pts <= spu->now_pts && spu->now_pts < spu->end_pts) {
|
||||
if (spu->orig_frame_width == 0 || spu->orig_frame_height == 0
|
||||
|| (spu->orig_frame_width == dxs && spu->orig_frame_height == dys)) {
|
||||
if (spu->image)
|
||||
draw_alpha(spu->start_col, spu->start_row, spu->width, spu->height,
|
||||
spu->image, spu->aimage, spu->stride);
|
||||
}
|
||||
else {
|
||||
if (!spu->scaled) { /* Resizing is needed */
|
||||
/* scaled_x = scalex * x / 0x100
|
||||
scaled_y = scaley * y / 0x100
|
||||
order of operations is important because of rounding. */
|
||||
unsigned int scalex = 0x100 * dxs / spu->orig_frame_width;
|
||||
unsigned int scaley = 0x100 * dys / spu->orig_frame_height;
|
||||
spu->scaled_start_col = spu->start_col * scalex / 0x100;
|
||||
spu->scaled_start_row = spu->start_row * scaley / 0x100;
|
||||
spu->scaled_width = spu->width * scalex / 0x100;
|
||||
spu->scaled_height = spu->height * scaley / 0x100;
|
||||
/* Kludge: draw_alpha needs width multiple of 8 */
|
||||
spu->scaled_stride = (spu->scaled_width + 7) & ~7;
|
||||
if (spu->scaled_image_size < spu->scaled_stride * spu->scaled_height) {
|
||||
if (spu->scaled_image) {
|
||||
free(spu->scaled_image);
|
||||
spu->scaled_image_size = 0;
|
||||
}
|
||||
spu->scaled_image = malloc(2 * spu->scaled_stride * spu->scaled_height);
|
||||
if (spu->scaled_image) {
|
||||
spu->scaled_image_size = spu->scaled_stride * spu->scaled_height;
|
||||
spu->scaled_aimage = spu->scaled_image + spu->scaled_image_size;
|
||||
}
|
||||
}
|
||||
if (spu->scaled_image) {
|
||||
unsigned int x, y;
|
||||
/* Kludge: draw_alpha needs width multiple of 8. */
|
||||
if (spu->scaled_width < spu->scaled_stride)
|
||||
for (y = 0; y < spu->scaled_height; ++y) {
|
||||
memset(spu->scaled_aimage + y * spu->scaled_stride + spu->scaled_width, 0,
|
||||
spu->scaled_stride - spu->scaled_width);
|
||||
/* FIXME: Why is this one needed? */
|
||||
memset(spu->scaled_image + y * spu->scaled_stride + spu->scaled_width, 0,
|
||||
spu->scaled_stride - spu->scaled_width);
|
||||
}
|
||||
#ifdef WITH_NO_ANTIALIASING
|
||||
for (y = 0; y < spu->scaled_height; ++y) {
|
||||
int unscaled_y = y * 0x100 / scaley;
|
||||
int strides = spu->stride * unscaled_y;
|
||||
int scaled_strides = spu->scaled_stride * y;
|
||||
for (x = 0; x < spu->scaled_width; ++x) {
|
||||
int unscaled_x = x * 0x100 / scalex;
|
||||
spu->scaled_image[scaled_strides + x] = spu->image[strides + unscaled_x];
|
||||
spu->scaled_aimage[scaled_strides + x] = spu->aimage[strides + unscaled_x];
|
||||
}
|
||||
}
|
||||
#else
|
||||
{
|
||||
/* Any pixel (x, y) represents pixels from the original
|
||||
rectangular region comprised between the columns
|
||||
unscaled_y and unscaled_y + 0x100 / scaley and the rows
|
||||
unscaled_x and unscaled_x + 0x100 / scalex
|
||||
|
||||
The original rectangular region that the scaled pixel
|
||||
represents is cut in 9 rectangular areas like this:
|
||||
|
||||
+---+-----------------+---+
|
||||
| 1 | 2 | 3 |
|
||||
+---+-----------------+---+
|
||||
| | | |
|
||||
| 4 | 5 | 6 |
|
||||
| | | |
|
||||
+---+-----------------+---+
|
||||
| 7 | 8 | 9 |
|
||||
+---+-----------------+---+
|
||||
|
||||
The width of the left column is at most one pixel and
|
||||
it is never null and its right column is at a pixel
|
||||
boundary. The height of the top row is at most one
|
||||
pixel it is never null and its bottom row is at a
|
||||
pixel boundary. The width and height of region 5 are
|
||||
integral values. The width of the right column is
|
||||
what remains and is less than one pixel. The height
|
||||
of the bottom row is what remains and is less than
|
||||
one pixel.
|
||||
|
||||
The row above 1, 2, 3 is unscaled_y. The row between
|
||||
1, 2, 3 and 4, 5, 6 is top_low_row. The row between 4,
|
||||
5, 6 and 7, 8, 9 is (unsigned int)unscaled_y_bottom.
|
||||
The row beneath 7, 8, 9 is unscaled_y_bottom.
|
||||
|
||||
The column left of 1, 4, 7 is unscaled_x. The column
|
||||
between 1, 4, 7 and 2, 5, 8 is left_right_column. The
|
||||
column between 2, 5, 8 and 3, 6, 9 is (unsigned
|
||||
int)unscaled_x_right. The column right of 3, 6, 9 is
|
||||
unscaled_x_right. */
|
||||
const double inv_scalex = (double) 0x100 / scalex;
|
||||
const double inv_scaley = (double) 0x100 / scaley;
|
||||
for (y = 0; y < spu->scaled_height; ++y) {
|
||||
const double unscaled_y = y * inv_scaley;
|
||||
const double unscaled_y_bottom = unscaled_y + inv_scaley;
|
||||
const unsigned int top_low_row = MIN(unscaled_y_bottom, unscaled_y + 1.0);
|
||||
const double top = top_low_row - unscaled_y;
|
||||
const unsigned int height = unscaled_y_bottom > top_low_row
|
||||
? (unsigned int) unscaled_y_bottom - top_low_row
|
||||
: 0;
|
||||
const double bottom = unscaled_y_bottom > top_low_row
|
||||
? unscaled_y_bottom - floor(unscaled_y_bottom)
|
||||
: 0.0;
|
||||
for (x = 0; x < spu->scaled_width; ++x) {
|
||||
const double unscaled_x = x * inv_scalex;
|
||||
const double unscaled_x_right = unscaled_x + inv_scalex;
|
||||
const unsigned int left_right_column = MIN(unscaled_x_right, unscaled_x + 1.0);
|
||||
const double left = left_right_column - unscaled_x;
|
||||
const unsigned int width = unscaled_x_right > left_right_column
|
||||
? (unsigned int) unscaled_x_right - left_right_column
|
||||
: 0;
|
||||
const double right = unscaled_x_right > left_right_column
|
||||
? unscaled_x_right - floor(unscaled_x_right)
|
||||
: 0.0;
|
||||
double color = 0.0;
|
||||
double alpha = 0.0;
|
||||
double tmp;
|
||||
unsigned int base;
|
||||
/* Now use these informations to compute a good alpha,
|
||||
and lightness. The sum is on each of the 9
|
||||
region's surface and alpha and lightness.
|
||||
|
||||
transformed alpha = sum(surface * alpha) / sum(surface)
|
||||
transformed color = sum(surface * alpha * color) / sum(surface * alpha)
|
||||
*/
|
||||
/* 1: top left part */
|
||||
base = spu->stride * (unsigned int) unscaled_y;
|
||||
tmp = left * top * canon_alpha(spu->aimage[base + (unsigned int) unscaled_x]);
|
||||
alpha += tmp;
|
||||
color += tmp * spu->image[base + (unsigned int) unscaled_x];
|
||||
/* 2: top center part */
|
||||
if (width > 0) {
|
||||
unsigned int walkx;
|
||||
for (walkx = left_right_column; walkx < (unsigned int) unscaled_x_right; ++walkx) {
|
||||
base = spu->stride * (unsigned int) unscaled_y + walkx;
|
||||
tmp = /* 1.0 * */ top * canon_alpha(spu->aimage[base]);
|
||||
alpha += tmp;
|
||||
color += tmp * spu->image[base];
|
||||
}
|
||||
}
|
||||
/* 3: top right part */
|
||||
if (right > 0.0) {
|
||||
base = spu->stride * (unsigned int) unscaled_y + (unsigned int) unscaled_x_right;
|
||||
tmp = right * top * canon_alpha(spu->aimage[base]);
|
||||
alpha += tmp;
|
||||
color += tmp * spu->image[base];
|
||||
}
|
||||
/* 4: center left part */
|
||||
if (height > 0) {
|
||||
unsigned int walky;
|
||||
for (walky = top_low_row; walky < (unsigned int) unscaled_y_bottom; ++walky) {
|
||||
base = spu->stride * walky + (unsigned int) unscaled_x;
|
||||
tmp = left /* * 1.0 */ * canon_alpha(spu->aimage[base]);
|
||||
alpha += tmp;
|
||||
color += tmp * spu->image[base];
|
||||
}
|
||||
}
|
||||
/* 5: center part */
|
||||
if (width > 0 && height > 0) {
|
||||
unsigned int walky;
|
||||
for (walky = top_low_row; walky < (unsigned int) unscaled_y_bottom; ++walky) {
|
||||
unsigned int walkx;
|
||||
base = spu->stride * walky;
|
||||
for (walkx = left_right_column; walkx < (unsigned int) unscaled_x_right; ++walkx) {
|
||||
tmp = /* 1.0 * 1.0 * */ canon_alpha(spu->aimage[base + walkx]);
|
||||
alpha += tmp;
|
||||
color += tmp * spu->image[base + walkx];
|
||||
}
|
||||
}
|
||||
}
|
||||
/* 6: center right part */
|
||||
if (right > 0.0 && height > 0) {
|
||||
unsigned int walky;
|
||||
for (walky = top_low_row; walky < (unsigned int) unscaled_y_bottom; ++walky) {
|
||||
base = spu->stride * walky + (unsigned int) unscaled_x_right;
|
||||
tmp = right /* * 1.0 */ * canon_alpha(spu->aimage[base]);
|
||||
alpha += tmp;
|
||||
color += tmp * spu->image[base];
|
||||
}
|
||||
}
|
||||
/* 7: bottom left part */
|
||||
if (bottom > 0.0) {
|
||||
base = spu->stride * (unsigned int) unscaled_y_bottom + (unsigned int) unscaled_x;
|
||||
tmp = left * bottom * canon_alpha(spu->aimage[base]);
|
||||
alpha += tmp;
|
||||
color += tmp * spu->image[base];
|
||||
}
|
||||
/* 8: bottom center part */
|
||||
if (width > 0 && bottom > 0.0) {
|
||||
unsigned int walkx;
|
||||
base = spu->stride * (unsigned int) unscaled_y_bottom;
|
||||
for (walkx = left_right_column; walkx < (unsigned int) unscaled_x_right; ++walkx) {
|
||||
tmp = /* 1.0 * */ bottom * canon_alpha(spu->aimage[base + walkx]);
|
||||
alpha += tmp;
|
||||
color += tmp * spu->image[base + walkx];
|
||||
}
|
||||
}
|
||||
/* 9: bottom right part */
|
||||
if (right > 0.0 && bottom > 0.0) {
|
||||
base = spu->stride * (unsigned int) unscaled_y_bottom + (unsigned int) unscaled_x_right;
|
||||
tmp = right * bottom * canon_alpha(spu->aimage[base]);
|
||||
alpha += tmp;
|
||||
color += tmp * spu->image[base];
|
||||
}
|
||||
/* Finally mix these transparency and brightness information suitably */
|
||||
base = spu->scaled_stride * y + x;
|
||||
spu->scaled_image[base] = color / alpha;
|
||||
spu->scaled_aimage[base] = alpha * scalex * scaley / 0x10000;
|
||||
if (spu->scaled_aimage[base]) {
|
||||
spu->scaled_aimage[base] = 256 - spu->scaled_aimage[base];
|
||||
if (spu->scaled_aimage[base] + spu->scaled_image[base] > 255)
|
||||
spu->scaled_image[base] = 256 - spu->scaled_aimage[base];
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
#endif
|
||||
spu->scaled = 1;
|
||||
}
|
||||
}
|
||||
if (spu->scaled_image)
|
||||
draw_alpha(spu->scaled_start_col, spu->scaled_start_row, spu->scaled_width, spu->scaled_height,
|
||||
spu->scaled_image, spu->scaled_aimage, spu->scaled_stride);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void *spudec_new_scaled(unsigned int *palette, unsigned int frame_width, unsigned int frame_height)
|
||||
{
|
||||
spudec_handle_t *this = calloc(1, sizeof(spudec_handle_t));
|
||||
if (this) {
|
||||
this->dvd_info = dvd_info;
|
||||
if (palette)
|
||||
memcpy(this->global_palette, palette, sizeof(this->global_palette));
|
||||
this->packet = NULL;
|
||||
this->image = NULL;
|
||||
this->scaled_image = NULL;
|
||||
this->orig_frame_width = frame_width;
|
||||
this->orig_frame_height = frame_height;
|
||||
}
|
||||
else
|
||||
perror("FATAL: spudec_init: calloc");
|
||||
return this;
|
||||
}
|
||||
|
||||
void *spudec_new(unsigned int *palette)
|
||||
{
|
||||
return spudec_new_scaled(palette, 0, 0);
|
||||
}
|
||||
|
||||
void spudec_free(void *this)
|
||||
{
|
||||
spudec_handle_t *spu = (spudec_handle_t*)this;
|
||||
if (spu) {
|
||||
if (spu->packet)
|
||||
free(spu->packet);
|
||||
if (spu->scaled_image)
|
||||
free(spu->scaled_image);
|
||||
if (spu->image)
|
||||
free(spu->image);
|
||||
free(spu);
|
||||
}
|
||||
}
|
||||
|
||||
#endif /* USE_DVDREAD */
|
||||
|
||||
|
||||
Loading…
Reference in New Issue
Block a user