devs/foxbox
1
0
Fork 0
forked from len0rd/rockbox
Code Pull requests Activity

Reformat and code police (tabs, trailing whitespace, annoying overuse of parentheses, etc.) in libmpeg2 so I can stomach working on it. Don't call IDCT functions through pointers - I don't feel like extracting that change just for relevance sake.

Browse source 
git-svn-id: svn://svn.rockbox.org/rockbox/trunk@15892 a1c6a512-1295-4272-9138-f99709370657
This commit is contained in:
Michael Sevakis 2007-12-07 13:00:31 +00:00
parent 5886efabf5
commit 2b5f979d75
10 changed files with 1772 additions and 1098 deletions
Download patch file Download diff file Expand all files Collapse all files

194
apps/plugins/mpegplayer/decode.c
View file

@ -33,9 +33,15 @@ extern struct plugin_api* rb;
#define BUFFER_SIZE (1194 * 1024)
#ifdef CPU_COLDFIRE
/* twice as large as on other targets because coldfire uses
* a secondary, transposed buffer for optimisation */
static int16_t static_dct_block[128] IBSS_ATTR ATTR_ALIGN(16);
#endif
const mpeg2_info_t * mpeg2_info (mpeg2dec_t * mpeg2dec)
{
return &(mpeg2dec->info);
return &mpeg2dec->info;
}
static inline int skip_chunk (mpeg2dec_t * mpeg2dec, int bytes)
@ -52,21 +58,28 @@ static inline int skip_chunk (mpeg2dec_t * mpeg2dec, int bytes)
shift = mpeg2dec->shift;
limit = current + bytes;
do {
do
{
byte = *current++;
if (shift == 0x00000100) {
if (shift == 0x00000100)
{
int skipped;
mpeg2dec->shift = 0xffffff00;
skipped = current - mpeg2dec->buf_start;
mpeg2dec->buf_start = current;
return skipped;
}
shift = (shift | byte) << 8;
} while (current < limit);
}
while (current < limit);
mpeg2dec->shift = shift;
mpeg2dec->buf_start = current;
return 0;
}
@ -86,9 +99,12 @@ static inline int copy_chunk (mpeg2dec_t * mpeg2dec, int bytes)
chunk_ptr = mpeg2dec->chunk_ptr;
limit = current + bytes;
do {
do
{
byte = *current++;
if (shift == 0x00000100) {
if (shift == 0x00000100)
{
int copied;
mpeg2dec->shift = 0xffffff00;
@ -97,9 +113,11 @@ static inline int copy_chunk (mpeg2dec_t * mpeg2dec, int bytes)
mpeg2dec->buf_start = current;
return copied;
}
shift = (shift | byte) << 8;
*chunk_ptr++ = byte;
} while (current < limit);
}
while (current < limit);
mpeg2dec->shift = shift;
mpeg2dec->buf_start = current;
@ -123,26 +141,39 @@ static inline mpeg2_state_t seek_chunk (mpeg2dec_t * mpeg2dec)
size = mpeg2dec->buf_end - mpeg2dec->buf_start;
skipped = skip_chunk (mpeg2dec, size);
if (!skipped) {
if (!skipped)
{
mpeg2dec->bytes_since_tag += size;
return STATE_BUFFER;
}
mpeg2dec->bytes_since_tag += skipped;
mpeg2dec->code = mpeg2dec->buf_start[-1];
return (mpeg2_state_t)-1;
}
mpeg2_state_t mpeg2_seek_header (mpeg2dec_t * mpeg2dec)
{
while (mpeg2dec->code != 0xb3 &&
((mpeg2dec->code != 0xb7 && mpeg2dec->code != 0xb8 &&
mpeg2dec->code) || mpeg2dec->sequence.width == (unsigned)-1))
((mpeg2dec->code != 0xb7 &&
mpeg2dec->code != 0xb8 &&
mpeg2dec->code) ||
mpeg2dec->sequence.width == (unsigned)-1))
{
if (seek_chunk (mpeg2dec) == STATE_BUFFER)
return STATE_BUFFER;
mpeg2dec->chunk_start = mpeg2dec->chunk_ptr = mpeg2dec->chunk_buffer;
}
mpeg2dec->chunk_start =
mpeg2dec->chunk_ptr = mpeg2dec->chunk_buffer;
mpeg2dec->user_data_len = 0;
return (mpeg2dec->code ? mpeg2_parse_header (mpeg2dec) :
mpeg2_header_picture_start (mpeg2dec));
return mpeg2dec->code ?
mpeg2_parse_header(mpeg2dec) :
mpeg2_header_picture_start(mpeg2dec);
}
#define RECEIVED(code,state) (((state) << 8) + (code))
@ -151,50 +182,66 @@ mpeg2_state_t mpeg2_parse (mpeg2dec_t * mpeg2dec)
{
int size_buffer, size_chunk, copied;
if (mpeg2dec->action) {
if (mpeg2dec->action)
{
mpeg2_state_t state;
state = mpeg2dec->action (mpeg2dec);
if ((int)state >= 0)
return state;
}
while (1) {
while (1)
{
while ((unsigned) (mpeg2dec->code - mpeg2dec->first_decode_slice) <
mpeg2dec->nb_decode_slices) {
mpeg2dec->nb_decode_slices)
{
size_buffer = mpeg2dec->buf_end - mpeg2dec->buf_start;
size_chunk = (mpeg2dec->chunk_buffer + BUFFER_SIZE -
mpeg2dec->chunk_ptr);
if (size_buffer <= size_chunk) {
size_chunk = mpeg2dec->chunk_buffer + BUFFER_SIZE -
mpeg2dec->chunk_ptr;
if (size_buffer <= size_chunk)
{
copied = copy_chunk (mpeg2dec, size_buffer);
if (!copied) {
if (!copied)
{
mpeg2dec->bytes_since_tag += size_buffer;
mpeg2dec->chunk_ptr += size_buffer;
return STATE_BUFFER;
}
} else {
}
else
{
copied = copy_chunk (mpeg2dec, size_chunk);
if (!copied) {
if (!copied)
{
/* filled the chunk buffer without finding a start code */
mpeg2dec->bytes_since_tag += size_chunk;
mpeg2dec->action = seek_chunk;
return STATE_INVALID;
}
}
mpeg2dec->bytes_since_tag += copied;
mpeg2_slice (&(mpeg2dec->decoder), mpeg2dec->code,
mpeg2_slice (&mpeg2dec->decoder, mpeg2dec->code,
mpeg2dec->chunk_start);
mpeg2dec->code = mpeg2dec->buf_start[-1];
mpeg2dec->chunk_ptr = mpeg2dec->chunk_start;
}
if ((unsigned) (mpeg2dec->code - 1) >= 0xb0 - 1)
break;
if (seek_chunk (mpeg2dec) == STATE_BUFFER)
return STATE_BUFFER;
}
switch (mpeg2dec->code) {
switch (mpeg2dec->code)
{
case 0x00:
mpeg2dec->action = mpeg2_header_picture_start;
return mpeg2dec->state;
@ -209,33 +256,54 @@ mpeg2_state_t mpeg2_parse (mpeg2dec_t * mpeg2dec)
mpeg2dec->action = seek_chunk;
return STATE_INVALID;
}
return (mpeg2dec->state == STATE_SLICE) ? STATE_SLICE : STATE_INVALID;
}
mpeg2_state_t mpeg2_parse_header (mpeg2dec_t * mpeg2dec)
{
static int (* process_header[]) (mpeg2dec_t * mpeg2dec) = {
mpeg2_header_picture, mpeg2_header_extension, mpeg2_header_user_data,
mpeg2_header_sequence, NULL, NULL, NULL, NULL, mpeg2_header_gop
static int (* const process_header[9]) (mpeg2dec_t *) =
{
mpeg2_header_picture,
mpeg2_header_extension,
mpeg2_header_user_data,
mpeg2_header_sequence,
NULL,
NULL,
NULL,
NULL,
mpeg2_header_gop
};
int size_buffer, size_chunk, copied;
mpeg2dec->action = mpeg2_parse_header;
mpeg2dec->info.user_data = NULL; mpeg2dec->info.user_data_len = 0;
while (1) {
mpeg2dec->info.user_data = NULL;
mpeg2dec->info.user_data_len = 0;
while (1)
{
size_buffer = mpeg2dec->buf_end - mpeg2dec->buf_start;
size_chunk = (mpeg2dec->chunk_buffer + BUFFER_SIZE -
mpeg2dec->chunk_ptr);
if (size_buffer <= size_chunk) {
size_chunk = mpeg2dec->chunk_buffer + BUFFER_SIZE -
mpeg2dec->chunk_ptr;
if (size_buffer <= size_chunk)
{
copied = copy_chunk (mpeg2dec, size_buffer);
if (!copied) {
if (!copied)
{
mpeg2dec->bytes_since_tag += size_buffer;
mpeg2dec->chunk_ptr += size_buffer;
return STATE_BUFFER;
}
} else {
}
else
{
copied = copy_chunk (mpeg2dec, size_chunk);
if (!copied) {
if (!copied)
{
/* filled the chunk buffer without finding a start code */
mpeg2dec->bytes_since_tag += size_chunk;
mpeg2dec->code = 0xb4;
@ -243,17 +311,20 @@ mpeg2_state_t mpeg2_parse_header (mpeg2dec_t * mpeg2dec)
return STATE_INVALID;
}
}
mpeg2dec->bytes_since_tag += copied;
if (process_header[mpeg2dec->code & 0x0b] (mpeg2dec)) {
if (process_header[mpeg2dec->code & 0x0b] (mpeg2dec))
{
mpeg2dec->code = mpeg2dec->buf_start[-1];
mpeg2dec->action = mpeg2_seek_header;
return STATE_INVALID;
}
mpeg2dec->code = mpeg2dec->buf_start[-1];
switch (RECEIVED (mpeg2dec->code, mpeg2dec->state)) {
switch (RECEIVED (mpeg2dec->code, mpeg2dec->state))
{
/* state transition after a sequence header */
case RECEIVED (0x00, STATE_SEQUENCE):
mpeg2dec->action = mpeg2_header_picture_start;
@ -290,6 +361,7 @@ mpeg2_state_t mpeg2_parse_header (mpeg2dec_t * mpeg2dec)
mpeg2dec->chunk_start = mpeg2dec->chunk_ptr = mpeg2dec->chunk_buffer;
mpeg2dec->user_data_len = 0;
return mpeg2dec->state;
}
}
@ -299,33 +371,42 @@ int mpeg2_convert (mpeg2dec_t * mpeg2dec, mpeg2_convert_t convert, void * arg)
mpeg2_convert_init_t convert_init;
int error;
error = convert (MPEG2_CONVERT_SET, NULL, &(mpeg2dec->sequence), 0,
error = convert (MPEG2_CONVERT_SET, NULL, &mpeg2dec->sequence, 0,
arg, &convert_init);
if (!error) {
if (!error)
{
mpeg2dec->convert = convert;
mpeg2dec->convert_arg = arg;
mpeg2dec->convert_id_size = convert_init.id_size;
mpeg2dec->convert_stride = 0;
}
return error;
}
int mpeg2_stride (mpeg2dec_t * mpeg2dec, int stride)
{
if (!mpeg2dec->convert) {
if (!mpeg2dec->convert)
{
if (stride < (int) mpeg2dec->sequence.width)
stride = mpeg2dec->sequence.width;
mpeg2dec->decoder.stride_frame = stride;
} else {
}
else
{
mpeg2_convert_init_t convert_init;
stride = mpeg2dec->convert(MPEG2_CONVERT_STRIDE, NULL,
&(mpeg2dec->sequence), stride,
&mpeg2dec->sequence, stride,
mpeg2dec->convert_arg,
&convert_init);
mpeg2dec->convert_id_size = convert_init.id_size;
mpeg2dec->convert_stride = stride;
}
return stride;
}
@ -333,21 +414,29 @@ void mpeg2_set_buf (mpeg2dec_t * mpeg2dec, uint8_t * buf[3], void * id)
{
mpeg2_fbuf_t * fbuf;
if (mpeg2dec->custom_fbuf) {
if (mpeg2dec->state == STATE_SEQUENCE) {
if (mpeg2dec->custom_fbuf)
{
if (mpeg2dec->state == STATE_SEQUENCE)
{
mpeg2dec->fbuf[2] = mpeg2dec->fbuf[1];
mpeg2dec->fbuf[1] = mpeg2dec->fbuf[0];
}
mpeg2_set_fbuf (mpeg2dec, (mpeg2dec->decoder.coding_type ==
PIC_FLAG_CODING_TYPE_B));
fbuf = mpeg2dec->fbuf[0];
} else {
fbuf = &(mpeg2dec->fbuf_alloc[mpeg2dec->alloc_index].fbuf);
}
else
{
fbuf = &mpeg2dec->fbuf_alloc[mpeg2dec->alloc_index].fbuf;
mpeg2dec->alloc_index_user = ++mpeg2dec->alloc_index;
}
fbuf->buf[0] = buf[0];
fbuf->buf[1] = buf[1];
fbuf->buf[2] = buf[2];
fbuf->id = id;
}
@ -390,23 +479,18 @@ void mpeg2_reset (mpeg2dec_t * mpeg2dec, int full_reset)
mpeg2dec->state = STATE_INVALID;
mpeg2dec->first = 1;
mpeg2_reset_info(&(mpeg2dec->info));
mpeg2_reset_info(&mpeg2dec->info);
mpeg2dec->info.gop = NULL;
mpeg2dec->info.user_data = NULL;
mpeg2dec->info.user_data_len = 0;
if (full_reset) {
if (full_reset)
{
mpeg2dec->info.sequence = NULL;
mpeg2_header_state_init (mpeg2dec);
}
}
#ifdef CPU_COLDFIRE
/* twice as large as on other targets because coldfire uses
* a secondary, transposed buffer for optimisation */
static int16_t static_dct_block[128] IBSS_ATTR ATTR_ALIGN(16);
#endif
mpeg2dec_t * mpeg2_init (void)
{
mpeg2dec_t * mpeg2dec;

536
apps/plugins/mpegplayer/header.c
View file

File diff suppressed because it is too large Load diff

103
apps/plugins/mpegplayer/idct.c
View file

@ -29,26 +29,11 @@
#include "attributes.h"
#include "mpeg2_internal.h"
/* idct main entry point */
void (* mpeg2_idct_copy) (int16_t * block, uint8_t * dest, int stride);
void (* mpeg2_idct_add) (int last, int16_t * block,
uint8_t * dest, int stride);
#if defined(CPU_COLDFIRE) || defined (CPU_ARM)
#define IDCT_ASM
#endif
#ifdef CPU_COLDFIRE
/* assembler functions */
extern void mpeg2_idct_copy_coldfire(int16_t * block, uint8_t * dest,
const int stride);
extern void mpeg2_idct_add_coldfire(const int last, int16_t * block,
uint8_t * dest, const int stride);
#elif defined CPU_ARM
/* assembler functions */
extern void mpeg2_idct_copy_arm(int16_t * block, uint8_t * dest,
const int stride);
extern void mpeg2_idct_add_arm(const int last, int16_t * block,
uint8_t * dest, const int stride);
#else /* !CPU_COLDFIRE, !CPU_ARM */
#ifndef IDCT_ASM
#define W1 2841 /* 2048 * sqrt (2) * cos (1 * pi / 16) */
#define W2 2676 /* 2048 * sqrt (2) * cos (2 * pi / 16) */
@ -63,8 +48,11 @@ extern void mpeg2_idct_add_arm(const int last, int16_t * block,
* to +-3826 - this is the worst case for a column IDCT where the
* column inputs are 16-bit values.
*/
uint8_t mpeg2_clip[3840 * 2 + 256] IBSS_ATTR;
#define CLIP(i) ((mpeg2_clip + 3840)[i])
#define CLIP(i) \
({ typeof (i) _i = (i); \
if ((_i & 0xff) != _i) \
_i = ~(_i >> (8*sizeof(_i) - 1)); \
_i; })
#if 0
#define BUTTERFLY(t0,t1,W0,W1,d0,d1) \
@ -89,7 +77,8 @@ static inline void idct_row (int16_t * const block)
/* shortcut */
if (likely (!(block[1] | ((int32_t *)block)[1] | ((int32_t *)block)[2] |
((int32_t *)block)[3]))) {
((int32_t *)block)[3])))
{
uint32_t tmp = (uint16_t) (block[0] >> 1);
tmp |= tmp << 16;
((int32_t *)block)[0] = tmp;
@ -175,16 +164,19 @@ static inline void idct_col (int16_t * const block)
block[8*7] = (a0 - b0) >> 17;
}
static void mpeg2_idct_copy_c (int16_t * block, uint8_t * dest,
void mpeg2_idct_copy (int16_t * block, uint8_t * dest,
const int stride)
{
int i;
for (i = 0; i < 8; i++)
idct_row (block + 8 * i);
for (i = 0; i < 8; i++)
idct_col (block + i);
do {
do
{
dest[0] = CLIP (block[0]);
dest[1] = CLIP (block[1]);
dest[2] = CLIP (block[2]);
@ -194,25 +186,32 @@ static void mpeg2_idct_copy_c (int16_t * block, uint8_t * dest,
dest[6] = CLIP (block[6]);
dest[7] = CLIP (block[7]);
((int32_t *)block)[0] = 0; ((int32_t *)block)[1] = 0;
((int32_t *)block)[2] = 0; ((int32_t *)block)[3] = 0;
((int32_t *)block)[0] = 0;
((int32_t *)block)[1] = 0;
((int32_t *)block)[2] = 0;
((int32_t *)block)[3] = 0;
dest += stride;
block += 8;
} while (--i);
}
while (--i);
}
static void mpeg2_idct_add_c (const int last, int16_t * block,
void mpeg2_idct_add (const int last, int16_t * block,
uint8_t * dest, const int stride)
{
int i;
if (last != 129 || (block[0] & (7 << 4)) == (4 << 4)) {
if (last != 129 || (block[0] & (7 << 4)) == (4 << 4))
{
for (i = 0; i < 8; i++)
idct_row (block + 8 * i);
for (i = 0; i < 8; i++)
idct_col (block + i);
do {
do
{
dest[0] = CLIP (block[0] + dest[0]);
dest[1] = CLIP (block[1] + dest[1]);
dest[2] = CLIP (block[2] + dest[2]);
@ -222,19 +221,24 @@ static void mpeg2_idct_add_c (const int last, int16_t * block,
dest[6] = CLIP (block[6] + dest[6]);
dest[7] = CLIP (block[7] + dest[7]);
((int32_t *)block)[0] = 0; ((int32_t *)block)[1] = 0;
((int32_t *)block)[2] = 0; ((int32_t *)block)[3] = 0;
((int32_t *)block)[0] = 0;
((int32_t *)block)[1] = 0;
((int32_t *)block)[2] = 0;
((int32_t *)block)[3] = 0;
dest += stride;
block += 8;
} while (--i);
} else {
int DC;
DC = (block[0] + 64) >> 7;
}
while (--i);
}
else
{
int DC = (block[0] + 64) >> 7;
block[0] = block[63] = 0;
i = 8;
do {
do
{
dest[0] = CLIP (DC + dest[0]);
dest[1] = CLIP (DC + dest[1]);
dest[2] = CLIP (DC + dest[2]);
@ -244,34 +248,17 @@ static void mpeg2_idct_add_c (const int last, int16_t * block,
dest[6] = CLIP (DC + dest[6]);
dest[7] = CLIP (DC + dest[7]);
dest += stride;
} while (--i);
}
while (--i);
}
}
#endif /* CPU selection */
#endif /* IDCT_ASM */
void mpeg2_idct_init (void)
{
extern uint8_t default_mpeg2_scan_norm[64];
extern uint8_t default_mpeg2_scan_alt[64];
extern uint8_t mpeg2_scan_norm[64];
extern uint8_t mpeg2_scan_alt[64];
int i, j;
#ifdef CPU_COLDFIRE
mpeg2_idct_copy = mpeg2_idct_copy_coldfire;
mpeg2_idct_add = mpeg2_idct_add_coldfire;
#elif defined CPU_ARM
mpeg2_idct_copy = mpeg2_idct_copy_arm;
mpeg2_idct_add = mpeg2_idct_add_arm;
#else
mpeg2_idct_copy = mpeg2_idct_copy_c;
mpeg2_idct_add = mpeg2_idct_add_c;
for (i = -3840; i < 3840 + 256; i++)
CLIP(i) = (i < 0) ? 0 : ((i > 255) ? 255 : i);
#endif
for (i = 0; i < 64; i++)
{
j = default_mpeg2_scan_norm[i];

12
apps/plugins/mpegplayer/idct_arm.S
View file

@ -17,10 +17,10 @@
*
****************************************************************************/
.global mpeg2_idct_copy_arm
.type mpeg2_idct_copy_arm, %function
.global mpeg2_idct_add_arm
.type mpeg2_idct_add_arm, %function
.global mpeg2_idct_copy
.type mpeg2_idct_copy, %function
.global mpeg2_idct_add
.type mpeg2_idct_add, %function
/* Custom calling convention:
@ -265,7 +265,7 @@
sub r0, r0, #16
bx lr
mpeg2_idct_copy_arm:
mpeg2_idct_copy:
stmfd sp!, { r1-r2, r4-r12, lr }
bl .idct
ldmfd sp!, { r1-r2 }
@ -313,7 +313,7 @@ mpeg2_idct_copy_arm:
blo 1b
ldmfd sp!, { r4-r12, pc }
mpeg2_idct_add_arm:
mpeg2_idct_add:
cmp r0, #129
mov r0, r1
ldreqsh r1, [r0, #0]

12
apps/plugins/mpegplayer/idct_coldfire.S
View file

@ -18,10 +18,10 @@
*
****************************************************************************/
.global mpeg2_idct_copy_coldfire
.type mpeg2_idct_copy_coldfire, @function
.global mpeg2_idct_add_coldfire
.type mpeg2_idct_add_coldfire, @function
.global mpeg2_idct_copy
.type mpeg2_idct_copy, @function
.global mpeg2_idct_add
.type mpeg2_idct_add, @function
/* The IDCT itself.
* Input: %a0: block pointer
@ -240,7 +240,7 @@
.align 2
mpeg2_idct_copy_coldfire:
mpeg2_idct_copy:
lea.l (-11*4,%sp), %sp
movem.l %d2-%d7/%a2-%a6, (%sp) | save some registers
move.l (11*4+4,%sp), %a0 | %a0 - block pointer for idct
@ -339,7 +339,7 @@ mpeg2_idct_copy_coldfire:
.align 2
mpeg2_idct_add_coldfire:
mpeg2_idct_add:
lea.l (-11*4,%sp), %sp
movem.l %d2-%d7/%a2-%a6, (%sp)
movem.l (11*4+4,%sp), %d0/%a0-%a2 | %d0 - last value

4
apps/plugins/mpegplayer/motion_comp.c
View file

@ -19,6 +19,8 @@
* 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
*
* $Id$
*/
#include "plugin.h"
@ -48,7 +50,7 @@ extern mpeg2_mc_fct MC_avg_y_8;
extern mpeg2_mc_fct MC_avg_xy_16;
extern mpeg2_mc_fct MC_avg_xy_8;
mpeg2_mc_t mpeg2_mc =
const mpeg2_mc_t mpeg2_mc =
{
{
MC_put_o_16, MC_put_x_16, MC_put_y_16, MC_put_xy_16,

34
apps/plugins/mpegplayer/mpeg2.h
View file

@ -34,14 +34,15 @@
#define SEQ_FLAG_COLOUR_DESCRIPTION 16
#define SEQ_MASK_VIDEO_FORMAT 0xe0
#define SEQ_VIDEO_FORMAT_COMPONENT 0
#define SEQ_VIDEO_FORMAT_COMPONENT 0x00
#define SEQ_VIDEO_FORMAT_PAL 0x20
#define SEQ_VIDEO_FORMAT_NTSC 0x40
#define SEQ_VIDEO_FORMAT_SECAM 0x60
#define SEQ_VIDEO_FORMAT_MAC 0x80
#define SEQ_VIDEO_FORMAT_UNSPECIFIED 0xa0
typedef struct mpeg2_sequence_s {
typedef struct mpeg2_sequence_s
{
unsigned int width, height;
unsigned int chroma_width, chroma_height;
unsigned int byte_rate;
@ -63,7 +64,8 @@ typedef struct mpeg2_sequence_s {
#define GOP_FLAG_BROKEN_LINK 2
#define GOP_FLAG_CLOSED_GOP 4
typedef struct mpeg2_gop_s {
typedef struct mpeg2_gop_s
{
uint8_t hours;
uint8_t minutes;
uint8_t seconds;
@ -84,22 +86,26 @@ typedef struct mpeg2_gop_s {
#define PIC_FLAG_TAGS 128
#define PIC_MASK_COMPOSITE_DISPLAY 0xfffff000
typedef struct mpeg2_picture_s {
typedef struct mpeg2_picture_s
{
unsigned int temporal_reference;
unsigned int nb_fields;
uint32_t tag, tag2;
uint32_t flags;
struct {
struct
{
int x, y;
} display_offset[3];
} mpeg2_picture_t;
typedef struct mpeg2_fbuf_s {
typedef struct mpeg2_fbuf_s
{
uint8_t * buf[3];
void * id;
} mpeg2_fbuf_t;
typedef struct mpeg2_info_s {
typedef struct mpeg2_info_s
{
const mpeg2_sequence_t * sequence;
const mpeg2_gop_t * gop;
const mpeg2_picture_t * current_picture;
@ -116,7 +122,8 @@ typedef struct mpeg2_info_s {
typedef struct mpeg2dec_s mpeg2dec_t;
typedef struct mpeg2_decoder_s mpeg2_decoder_t;
typedef enum {
typedef enum
{
STATE_BUFFER = 0,
STATE_SEQUENCE = 1,
STATE_SEQUENCE_REPEATED = 2,
@ -130,18 +137,22 @@ typedef enum {
STATE_INVALID_END = 10
} mpeg2_state_t;
typedef struct mpeg2_convert_init_s {
typedef struct mpeg2_convert_init_s
{
unsigned int id_size;
unsigned int buf_size[3];
void (* start)(void * id, const mpeg2_fbuf_t * fbuf,
const mpeg2_picture_t * picture, const mpeg2_gop_t * gop);
void (* copy)(void * id, uint8_t * const * src, unsigned int v_offset);
} mpeg2_convert_init_t;
typedef enum {
typedef enum
{
MPEG2_CONVERT_SET = 0,
MPEG2_CONVERT_STRIDE = 1,
MPEG2_CONVERT_START = 2
} mpeg2_convert_stage_t;
typedef int mpeg2_convert_t (int stage, void * id,
const mpeg2_sequence_t * sequence, int stride,
void * arg, mpeg2_convert_init_t * result);
@ -168,7 +179,8 @@ void mpeg2_init_fbuf (mpeg2_decoder_t * decoder, uint8_t * current_fbuf[3],
uint8_t * forward_fbuf[3], uint8_t * backward_fbuf[3]);
void mpeg2_slice (mpeg2_decoder_t * decoder, int code, const uint8_t * buffer);
typedef enum {
typedef enum
{
MPEG2_ALLOC_MPEG2DEC = 0,
MPEG2_ALLOC_CHUNK = 1,
MPEG2_ALLOC_YUV = 2,

44
apps/plugins/mpegplayer/mpeg2_internal.h
View file

@ -20,6 +20,8 @@
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
#ifndef MPEG2_INTERNAL_H
#define MPEG2_INTERNAL_H
#include "config.h" /* for Rockbox CPU_ #defines */
@ -50,7 +52,8 @@
typedef void mpeg2_mc_fct (uint8_t *, const uint8_t *, int, int);
typedef struct {
typedef struct
{
uint8_t * ref[2][3];
uint8_t ** ref2[2];
int pmv[2][2];
@ -61,7 +64,8 @@ typedef void motion_parser_t (mpeg2_decoder_t * decoder,
motion_t * motion,
mpeg2_mc_fct * const * table);
struct mpeg2_decoder_s {
struct mpeg2_decoder_s
{
/* first, state that carries information from one macroblock to the */
/* next inside a slice, and is never used outside of mpeg2_slice() */
@ -152,11 +156,13 @@ struct mpeg2_decoder_s {
int mpeg1;
};
typedef struct {
typedef struct
{
mpeg2_fbuf_t fbuf;
} fbuf_alloc_t;
struct mpeg2dec_s {
struct mpeg2dec_s
{
mpeg2_decoder_t decoder;
mpeg2_info_t info;
@ -222,19 +228,6 @@ struct mpeg2dec_s {
uint8_t new_quantizer_matrix[4][64];
};
typedef struct {
#ifdef ARCH_PPC
uint8_t regv[12*16];
#endif
int dummy;
} cpu_state_t;
/* cpu_accel.c */
uint32_t mpeg2_detect_accel (void);
/* cpu_state.c */
void mpeg2_cpu_state_init (uint32_t accel);
/* decode.c */
mpeg2_state_t mpeg2_seek_header (mpeg2dec_t * mpeg2dec);
mpeg2_state_t mpeg2_parse_header (mpeg2dec_t * mpeg2dec);
@ -257,11 +250,26 @@ void mpeg2_set_fbuf (mpeg2dec_t * mpeg2dec, int b_type);
/* idct.c */
void mpeg2_idct_init (void);
void mpeg2_idct_copy(int16_t * block, uint8_t * dest,
const int stride);
void mpeg2_idct_add(const int last, int16_t * block,
uint8_t * dest, const int stride);
extern const uint8_t default_mpeg2_scan_norm[64];
extern const uint8_t default_mpeg2_scan_alt[64];
extern uint8_t mpeg2_scan_norm[64];
extern uint8_t mpeg2_scan_alt[64];
/* motion_comp.c */
void mpeg2_mc_init (void);
typedef struct {
typedef struct
{
mpeg2_mc_fct * put [8];
mpeg2_mc_fct * avg [8];
} mpeg2_mc_t;
extern const mpeg2_mc_t mpeg2_mc;
#endif /* MPEG2_INTERNAL_H */

721
apps/plugins/mpegplayer/slice.c
View file

File diff suppressed because it is too large Load diff