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

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

@ -33,9 +33,15 @@ extern struct plugin_api* rb;
#define BUFFER_SIZE (1194 * 1024) #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) 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) static inline int skip_chunk (mpeg2dec_t * mpeg2dec, int bytes)
@ -46,27 +52,34 @@ static inline int skip_chunk (mpeg2dec_t * mpeg2dec, int bytes)
uint8_t byte; uint8_t byte;
if (!bytes) if (!bytes)
return 0; return 0;
current = mpeg2dec->buf_start; current = mpeg2dec->buf_start;
shift = mpeg2dec->shift; shift = mpeg2dec->shift;
limit = current + bytes; limit = current + bytes;
do { do
byte = *current++; {
if (shift == 0x00000100) { byte = *current++;
int skipped;
mpeg2dec->shift = 0xffffff00; if (shift == 0x00000100)
skipped = current - mpeg2dec->buf_start; {
mpeg2dec->buf_start = current; int skipped;
return skipped;
} mpeg2dec->shift = 0xffffff00;
shift = (shift | byte) << 8; skipped = current - mpeg2dec->buf_start;
} while (current < limit); mpeg2dec->buf_start = current;
return skipped;
}
shift = (shift | byte) << 8;
}
while (current < limit);
mpeg2dec->shift = shift; mpeg2dec->shift = shift;
mpeg2dec->buf_start = current; mpeg2dec->buf_start = current;
return 0; return 0;
} }
@ -79,27 +92,32 @@ static inline int copy_chunk (mpeg2dec_t * mpeg2dec, int bytes)
uint8_t byte; uint8_t byte;
if (!bytes) if (!bytes)
return 0; return 0;
current = mpeg2dec->buf_start; current = mpeg2dec->buf_start;
shift = mpeg2dec->shift; shift = mpeg2dec->shift;
chunk_ptr = mpeg2dec->chunk_ptr; chunk_ptr = mpeg2dec->chunk_ptr;
limit = current + bytes; limit = current + bytes;
do { do
byte = *current++; {
if (shift == 0x00000100) { byte = *current++;
int copied;
mpeg2dec->shift = 0xffffff00; if (shift == 0x00000100)
mpeg2dec->chunk_ptr = chunk_ptr + 1; {
copied = current - mpeg2dec->buf_start; int copied;
mpeg2dec->buf_start = current;
return copied; mpeg2dec->shift = 0xffffff00;
} mpeg2dec->chunk_ptr = chunk_ptr + 1;
shift = (shift | byte) << 8; copied = current - mpeg2dec->buf_start;
*chunk_ptr++ = byte; mpeg2dec->buf_start = current;
} while (current < limit); return copied;
}
shift = (shift | byte) << 8;
*chunk_ptr++ = byte;
}
while (current < limit);
mpeg2dec->shift = shift; mpeg2dec->shift = shift;
mpeg2dec->buf_start = current; 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; size = mpeg2dec->buf_end - mpeg2dec->buf_start;
skipped = skip_chunk (mpeg2dec, size); skipped = skip_chunk (mpeg2dec, size);
if (!skipped) {
mpeg2dec->bytes_since_tag += size; if (!skipped)
return STATE_BUFFER; {
mpeg2dec->bytes_since_tag += size;
return STATE_BUFFER;
} }
mpeg2dec->bytes_since_tag += skipped; mpeg2dec->bytes_since_tag += skipped;
mpeg2dec->code = mpeg2dec->buf_start[-1]; mpeg2dec->code = mpeg2dec->buf_start[-1];
return (mpeg2_state_t)-1; return (mpeg2_state_t)-1;
} }
mpeg2_state_t mpeg2_seek_header (mpeg2dec_t * mpeg2dec) mpeg2_state_t mpeg2_seek_header (mpeg2dec_t * mpeg2dec)
{ {
while (mpeg2dec->code != 0xb3 && while (mpeg2dec->code != 0xb3 &&
((mpeg2dec->code != 0xb7 && mpeg2dec->code != 0xb8 && ((mpeg2dec->code != 0xb7 &&
mpeg2dec->code) || mpeg2dec->sequence.width == (unsigned)-1)) mpeg2dec->code != 0xb8 &&
if (seek_chunk (mpeg2dec) == STATE_BUFFER) mpeg2dec->code) ||
return STATE_BUFFER; mpeg2dec->sequence.width == (unsigned)-1))
mpeg2dec->chunk_start = mpeg2dec->chunk_ptr = mpeg2dec->chunk_buffer; {
if (seek_chunk (mpeg2dec) == STATE_BUFFER)
return STATE_BUFFER;
}
mpeg2dec->chunk_start =
mpeg2dec->chunk_ptr = mpeg2dec->chunk_buffer;
mpeg2dec->user_data_len = 0; 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)) #define RECEIVED(code,state) (((state) << 8) + (code))
@ -151,146 +182,187 @@ mpeg2_state_t mpeg2_parse (mpeg2dec_t * mpeg2dec)
{ {
int size_buffer, size_chunk, copied; int size_buffer, size_chunk, copied;
if (mpeg2dec->action) { if (mpeg2dec->action)
mpeg2_state_t state; {
mpeg2_state_t state;
state = mpeg2dec->action (mpeg2dec); state = mpeg2dec->action (mpeg2dec);
if ((int)state >= 0)
return state; if ((int)state >= 0)
return state;
} }
while (1) { while (1)
while ((unsigned) (mpeg2dec->code - mpeg2dec->first_decode_slice) < {
mpeg2dec->nb_decode_slices) { while ((unsigned) (mpeg2dec->code - mpeg2dec->first_decode_slice) <
size_buffer = mpeg2dec->buf_end - mpeg2dec->buf_start; mpeg2dec->nb_decode_slices)
size_chunk = (mpeg2dec->chunk_buffer + BUFFER_SIZE - {
mpeg2dec->chunk_ptr); size_buffer = mpeg2dec->buf_end - mpeg2dec->buf_start;
if (size_buffer <= size_chunk) { size_chunk = mpeg2dec->chunk_buffer + BUFFER_SIZE -
copied = copy_chunk (mpeg2dec, size_buffer); mpeg2dec->chunk_ptr;
if (!copied) {
mpeg2dec->bytes_since_tag += size_buffer; if (size_buffer <= size_chunk)
mpeg2dec->chunk_ptr += size_buffer; {
return STATE_BUFFER; copied = copy_chunk (mpeg2dec, size_buffer);
}
} else { if (!copied)
copied = copy_chunk (mpeg2dec, size_chunk); {
if (!copied) { mpeg2dec->bytes_since_tag += size_buffer;
/* filled the chunk buffer without finding a start code */ mpeg2dec->chunk_ptr += size_buffer;
mpeg2dec->bytes_since_tag += size_chunk; return STATE_BUFFER;
mpeg2dec->action = seek_chunk; }
return STATE_INVALID; }
} else
{
copied = copy_chunk (mpeg2dec, size_chunk);
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,
mpeg2dec->chunk_start);
mpeg2dec->code = mpeg2dec->buf_start[-1];
mpeg2dec->chunk_ptr = mpeg2dec->chunk_start;
} }
mpeg2dec->bytes_since_tag += copied;
mpeg2_slice (&(mpeg2dec->decoder), mpeg2dec->code, if ((unsigned) (mpeg2dec->code - 1) >= 0xb0 - 1)
mpeg2dec->chunk_start); break;
mpeg2dec->code = mpeg2dec->buf_start[-1];
mpeg2dec->chunk_ptr = mpeg2dec->chunk_start; if (seek_chunk (mpeg2dec) == STATE_BUFFER)
} return STATE_BUFFER;
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: case 0x00:
mpeg2dec->action = mpeg2_header_picture_start; mpeg2dec->action = mpeg2_header_picture_start;
return mpeg2dec->state; return mpeg2dec->state;
case 0xb7: case 0xb7:
mpeg2dec->action = mpeg2_header_end; mpeg2dec->action = mpeg2_header_end;
break; break;
case 0xb3: case 0xb3:
case 0xb8: case 0xb8:
mpeg2dec->action = mpeg2_parse_header; mpeg2dec->action = mpeg2_parse_header;
break; break;
default: default:
mpeg2dec->action = seek_chunk; mpeg2dec->action = seek_chunk;
return STATE_INVALID; return STATE_INVALID;
} }
return (mpeg2dec->state == STATE_SLICE) ? STATE_SLICE : STATE_INVALID; return (mpeg2dec->state == STATE_SLICE) ? STATE_SLICE : STATE_INVALID;
} }
mpeg2_state_t mpeg2_parse_header (mpeg2dec_t * mpeg2dec) mpeg2_state_t mpeg2_parse_header (mpeg2dec_t * mpeg2dec)
{ {
static int (* process_header[]) (mpeg2dec_t * mpeg2dec) = { 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 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; int size_buffer, size_chunk, copied;
mpeg2dec->action = mpeg2_parse_header; mpeg2dec->action = mpeg2_parse_header;
mpeg2dec->info.user_data = NULL; mpeg2dec->info.user_data_len = 0; mpeg2dec->info.user_data = NULL;
while (1) { mpeg2dec->info.user_data_len = 0;
size_buffer = mpeg2dec->buf_end - mpeg2dec->buf_start;
size_chunk = (mpeg2dec->chunk_buffer + BUFFER_SIZE -
mpeg2dec->chunk_ptr);
if (size_buffer <= size_chunk) {
copied = copy_chunk (mpeg2dec, size_buffer);
if (!copied) {
mpeg2dec->bytes_since_tag += size_buffer;
mpeg2dec->chunk_ptr += size_buffer;
return STATE_BUFFER;
}
} else {
copied = copy_chunk (mpeg2dec, size_chunk);
if (!copied) {
/* filled the chunk buffer without finding a start code */
mpeg2dec->bytes_since_tag += size_chunk;
mpeg2dec->code = 0xb4;
mpeg2dec->action = mpeg2_seek_header;
return STATE_INVALID;
}
}
mpeg2dec->bytes_since_tag += copied;
if (process_header[mpeg2dec->code & 0x0b] (mpeg2dec)) { while (1)
mpeg2dec->code = mpeg2dec->buf_start[-1]; {
mpeg2dec->action = mpeg2_seek_header; size_buffer = mpeg2dec->buf_end - mpeg2dec->buf_start;
return STATE_INVALID; size_chunk = mpeg2dec->chunk_buffer + BUFFER_SIZE -
} mpeg2dec->chunk_ptr;
mpeg2dec->code = mpeg2dec->buf_start[-1]; if (size_buffer <= size_chunk)
switch (RECEIVED (mpeg2dec->code, mpeg2dec->state)) { {
copied = copy_chunk (mpeg2dec, size_buffer);
/* state transition after a sequence header */ if (!copied)
case RECEIVED (0x00, STATE_SEQUENCE): {
mpeg2dec->action = mpeg2_header_picture_start; mpeg2dec->bytes_since_tag += size_buffer;
case RECEIVED (0xb8, STATE_SEQUENCE): mpeg2dec->chunk_ptr += size_buffer;
mpeg2_header_sequence_finalize (mpeg2dec); return STATE_BUFFER;
break; }
}
else
{
copied = copy_chunk (mpeg2dec, size_chunk);
/* other legal state transitions */ if (!copied)
case RECEIVED (0x00, STATE_GOP): {
mpeg2_header_gop_finalize (mpeg2dec); /* filled the chunk buffer without finding a start code */
mpeg2dec->action = mpeg2_header_picture_start; mpeg2dec->bytes_since_tag += size_chunk;
break; mpeg2dec->code = 0xb4;
case RECEIVED (0x01, STATE_PICTURE): mpeg2dec->action = mpeg2_seek_header;
case RECEIVED (0x01, STATE_PICTURE_2ND): return STATE_INVALID;
mpeg2_header_picture_finalize (mpeg2dec); }
mpeg2dec->action = mpeg2_header_slice_start; }
break;
/* legal headers within a given state */ mpeg2dec->bytes_since_tag += copied;
case RECEIVED (0xb2, STATE_SEQUENCE):
case RECEIVED (0xb2, STATE_GOP):
case RECEIVED (0xb2, STATE_PICTURE):
case RECEIVED (0xb2, STATE_PICTURE_2ND):
case RECEIVED (0xb5, STATE_SEQUENCE):
case RECEIVED (0xb5, STATE_PICTURE):
case RECEIVED (0xb5, STATE_PICTURE_2ND):
mpeg2dec->chunk_ptr = mpeg2dec->chunk_start;
continue;
default: if (process_header[mpeg2dec->code & 0x0b] (mpeg2dec))
mpeg2dec->action = mpeg2_seek_header; {
return STATE_INVALID; mpeg2dec->code = mpeg2dec->buf_start[-1];
} mpeg2dec->action = mpeg2_seek_header;
return STATE_INVALID;
}
mpeg2dec->chunk_start = mpeg2dec->chunk_ptr = mpeg2dec->chunk_buffer; mpeg2dec->code = mpeg2dec->buf_start[-1];
mpeg2dec->user_data_len = 0;
return 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;
case RECEIVED (0xb8, STATE_SEQUENCE):
mpeg2_header_sequence_finalize (mpeg2dec);
break;
/* other legal state transitions */
case RECEIVED (0x00, STATE_GOP):
mpeg2_header_gop_finalize (mpeg2dec);
mpeg2dec->action = mpeg2_header_picture_start;
break;
case RECEIVED (0x01, STATE_PICTURE):
case RECEIVED (0x01, STATE_PICTURE_2ND):
mpeg2_header_picture_finalize (mpeg2dec);
mpeg2dec->action = mpeg2_header_slice_start;
break;
/* legal headers within a given state */
case RECEIVED (0xb2, STATE_SEQUENCE):
case RECEIVED (0xb2, STATE_GOP):
case RECEIVED (0xb2, STATE_PICTURE):
case RECEIVED (0xb2, STATE_PICTURE_2ND):
case RECEIVED (0xb5, STATE_SEQUENCE):
case RECEIVED (0xb5, STATE_PICTURE):
case RECEIVED (0xb5, STATE_PICTURE_2ND):
mpeg2dec->chunk_ptr = mpeg2dec->chunk_start;
continue;
default:
mpeg2dec->action = mpeg2_seek_header;
return STATE_INVALID;
}
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; mpeg2_convert_init_t convert_init;
int error; int error;
error = convert (MPEG2_CONVERT_SET, NULL, &(mpeg2dec->sequence), 0, error = convert (MPEG2_CONVERT_SET, NULL, &mpeg2dec->sequence, 0,
arg, &convert_init); arg, &convert_init);
if (!error) {
mpeg2dec->convert = convert; if (!error)
mpeg2dec->convert_arg = arg; {
mpeg2dec->convert_id_size = convert_init.id_size; mpeg2dec->convert = convert;
mpeg2dec->convert_stride = 0; mpeg2dec->convert_arg = arg;
mpeg2dec->convert_id_size = convert_init.id_size;
mpeg2dec->convert_stride = 0;
} }
return error; return error;
} }
int mpeg2_stride (mpeg2dec_t * mpeg2dec, int stride) int mpeg2_stride (mpeg2dec_t * mpeg2dec, int stride)
{ {
if (!mpeg2dec->convert) { if (!mpeg2dec->convert)
if (stride < (int) mpeg2dec->sequence.width) {
stride = mpeg2dec->sequence.width; if (stride < (int) mpeg2dec->sequence.width)
mpeg2dec->decoder.stride_frame = stride; stride = mpeg2dec->sequence.width;
} else {
mpeg2_convert_init_t convert_init;
stride = mpeg2dec->convert (MPEG2_CONVERT_STRIDE, NULL, mpeg2dec->decoder.stride_frame = stride;
&(mpeg2dec->sequence), stride,
mpeg2dec->convert_arg,
&convert_init);
mpeg2dec->convert_id_size = convert_init.id_size;
mpeg2dec->convert_stride = stride;
} }
else
{
mpeg2_convert_init_t convert_init;
stride = mpeg2dec->convert(MPEG2_CONVERT_STRIDE, NULL,
&mpeg2dec->sequence, stride,
mpeg2dec->convert_arg,
&convert_init);
mpeg2dec->convert_id_size = convert_init.id_size;
mpeg2dec->convert_stride = stride;
}
return stride; return stride;
} }
@ -333,21 +414,29 @@ void mpeg2_set_buf (mpeg2dec_t * mpeg2dec, uint8_t * buf[3], void * id)
{ {
mpeg2_fbuf_t * fbuf; mpeg2_fbuf_t * fbuf;
if (mpeg2dec->custom_fbuf) { if (mpeg2dec->custom_fbuf)
if (mpeg2dec->state == STATE_SEQUENCE) { {
mpeg2dec->fbuf[2] = mpeg2dec->fbuf[1]; if (mpeg2dec->state == STATE_SEQUENCE)
mpeg2dec->fbuf[1] = mpeg2dec->fbuf[0]; {
} mpeg2dec->fbuf[2] = mpeg2dec->fbuf[1];
mpeg2_set_fbuf (mpeg2dec, (mpeg2dec->decoder.coding_type == mpeg2dec->fbuf[1] = mpeg2dec->fbuf[0];
PIC_FLAG_CODING_TYPE_B)); }
fbuf = mpeg2dec->fbuf[0];
} else { mpeg2_set_fbuf (mpeg2dec, (mpeg2dec->decoder.coding_type ==
fbuf = &(mpeg2dec->fbuf_alloc[mpeg2dec->alloc_index].fbuf); PIC_FLAG_CODING_TYPE_B));
mpeg2dec->alloc_index_user = ++mpeg2dec->alloc_index;
fbuf = mpeg2dec->fbuf[0];
} }
else
{
fbuf = &mpeg2dec->fbuf_alloc[mpeg2dec->alloc_index].fbuf;
mpeg2dec->alloc_index_user = ++mpeg2dec->alloc_index;
}
fbuf->buf[0] = buf[0]; fbuf->buf[0] = buf[0];
fbuf->buf[1] = buf[1]; fbuf->buf[1] = buf[1];
fbuf->buf[2] = buf[2]; fbuf->buf[2] = buf[2];
fbuf->id = id; fbuf->id = id;
} }
@ -390,31 +479,26 @@ void mpeg2_reset (mpeg2dec_t * mpeg2dec, int full_reset)
mpeg2dec->state = STATE_INVALID; mpeg2dec->state = STATE_INVALID;
mpeg2dec->first = 1; mpeg2dec->first = 1;
mpeg2_reset_info(&(mpeg2dec->info)); mpeg2_reset_info(&mpeg2dec->info);
mpeg2dec->info.gop = NULL; mpeg2dec->info.gop = NULL;
mpeg2dec->info.user_data = NULL; mpeg2dec->info.user_data = NULL;
mpeg2dec->info.user_data_len = 0; mpeg2dec->info.user_data_len = 0;
if (full_reset) {
mpeg2dec->info.sequence = NULL; if (full_reset)
mpeg2_header_state_init (mpeg2dec); {
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 * mpeg2_init (void)
{ {
mpeg2dec_t * mpeg2dec; mpeg2dec_t * mpeg2dec;
mpeg2_idct_init (); mpeg2_idct_init ();
mpeg2dec = (mpeg2dec_t *) mpeg2_malloc (sizeof (mpeg2dec_t), mpeg2dec = (mpeg2dec_t *)mpeg2_malloc(sizeof (mpeg2dec_t),
MPEG2_ALLOC_MPEG2DEC); MPEG2_ALLOC_MPEG2DEC);
if (mpeg2dec == NULL) if (mpeg2dec == NULL)
return NULL; return NULL;
@ -425,8 +509,8 @@ mpeg2dec_t * mpeg2_init (void)
rb->memset (mpeg2dec->decoder.DCTblock, 0, 64 * sizeof (int16_t)); rb->memset (mpeg2dec->decoder.DCTblock, 0, 64 * sizeof (int16_t));
rb->memset (mpeg2dec->quantizer_matrix, 0, 4 * 64 * sizeof (uint8_t)); rb->memset (mpeg2dec->quantizer_matrix, 0, 4 * 64 * sizeof (uint8_t));
mpeg2dec->chunk_buffer = (uint8_t *) mpeg2_malloc (BUFFER_SIZE + 4, mpeg2dec->chunk_buffer = (uint8_t *)mpeg2_malloc(BUFFER_SIZE + 4,
MPEG2_ALLOC_CHUNK); MPEG2_ALLOC_CHUNK);
mpeg2dec->sequence.width = (unsigned)-1; mpeg2dec->sequence.width = (unsigned)-1;
mpeg2_reset (mpeg2dec, 1); mpeg2_reset (mpeg2dec, 1);

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

File diff suppressed because it is too large Load diff

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

@ -29,26 +29,11 @@
#include "attributes.h" #include "attributes.h"
#include "mpeg2_internal.h" #include "mpeg2_internal.h"
/* idct main entry point */ #if defined(CPU_COLDFIRE) || defined (CPU_ARM)
void (* mpeg2_idct_copy) (int16_t * block, uint8_t * dest, int stride); #define IDCT_ASM
void (* mpeg2_idct_add) (int last, int16_t * block, #endif
uint8_t * dest, int stride);
#ifdef CPU_COLDFIRE #ifndef IDCT_ASM
/* 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 */
#define W1 2841 /* 2048 * sqrt (2) * cos (1 * pi / 16) */ #define W1 2841 /* 2048 * sqrt (2) * cos (1 * pi / 16) */
#define W2 2676 /* 2048 * sqrt (2) * cos (2 * 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 * to +-3826 - this is the worst case for a column IDCT where the
* column inputs are 16-bit values. * column inputs are 16-bit values.
*/ */
uint8_t mpeg2_clip[3840 * 2 + 256] IBSS_ATTR; #define CLIP(i) \
#define CLIP(i) ((mpeg2_clip + 3840)[i]) ({ typeof (i) _i = (i); \
if ((_i & 0xff) != _i) \
_i = ~(_i >> (8*sizeof(_i) - 1)); \
_i; })
#if 0 #if 0
#define BUTTERFLY(t0,t1,W0,W1,d0,d1) \ #define BUTTERFLY(t0,t1,W0,W1,d0,d1) \
@ -89,7 +77,8 @@ static inline void idct_row (int16_t * const block)
/* shortcut */ /* shortcut */
if (likely (!(block[1] | ((int32_t *)block)[1] | ((int32_t *)block)[2] | 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); uint32_t tmp = (uint16_t) (block[0] >> 1);
tmp |= tmp << 16; tmp |= tmp << 16;
((int32_t *)block)[0] = tmp; ((int32_t *)block)[0] = tmp;
@ -175,16 +164,19 @@ static inline void idct_col (int16_t * const block)
block[8*7] = (a0 - b0) >> 17; 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) const int stride)
{ {
int i; int i;
for (i = 0; i < 8; i++) for (i = 0; i < 8; i++)
idct_row (block + 8 * i); idct_row (block + 8 * i);
for (i = 0; i < 8; i++) for (i = 0; i < 8; i++)
idct_col (block + i); idct_col (block + i);
do {
do
{
dest[0] = CLIP (block[0]); dest[0] = CLIP (block[0]);
dest[1] = CLIP (block[1]); dest[1] = CLIP (block[1]);
dest[2] = CLIP (block[2]); 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[6] = CLIP (block[6]);
dest[7] = CLIP (block[7]); dest[7] = CLIP (block[7]);
((int32_t *)block)[0] = 0; ((int32_t *)block)[1] = 0; ((int32_t *)block)[0] = 0;
((int32_t *)block)[2] = 0; ((int32_t *)block)[3] = 0; ((int32_t *)block)[1] = 0;
((int32_t *)block)[2] = 0;
((int32_t *)block)[3] = 0;
dest += stride; dest += stride;
block += 8; 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) uint8_t * dest, const int stride)
{ {
int i; 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++) for (i = 0; i < 8; i++)
idct_row (block + 8 * i); idct_row (block + 8 * i);
for (i = 0; i < 8; i++) for (i = 0; i < 8; i++)
idct_col (block + i); idct_col (block + i);
do {
do
{
dest[0] = CLIP (block[0] + dest[0]); dest[0] = CLIP (block[0] + dest[0]);
dest[1] = CLIP (block[1] + dest[1]); dest[1] = CLIP (block[1] + dest[1]);
dest[2] = CLIP (block[2] + dest[2]); 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[6] = CLIP (block[6] + dest[6]);
dest[7] = CLIP (block[7] + dest[7]); dest[7] = CLIP (block[7] + dest[7]);
((int32_t *)block)[0] = 0; ((int32_t *)block)[1] = 0; ((int32_t *)block)[0] = 0;
((int32_t *)block)[2] = 0; ((int32_t *)block)[3] = 0; ((int32_t *)block)[1] = 0;
((int32_t *)block)[2] = 0;
((int32_t *)block)[3] = 0;
dest += stride; dest += stride;
block += 8; block += 8;
} while (--i); }
} else { while (--i);
int DC; }
else
DC = (block[0] + 64) >> 7; {
int DC = (block[0] + 64) >> 7;
block[0] = block[63] = 0; block[0] = block[63] = 0;
i = 8; i = 8;
do {
do
{
dest[0] = CLIP (DC + dest[0]); dest[0] = CLIP (DC + dest[0]);
dest[1] = CLIP (DC + dest[1]); dest[1] = CLIP (DC + dest[1]);
dest[2] = CLIP (DC + dest[2]); 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[6] = CLIP (DC + dest[6]);
dest[7] = CLIP (DC + dest[7]); dest[7] = CLIP (DC + dest[7]);
dest += stride; dest += stride;
} while (--i); }
while (--i);
} }
} }
#endif /* CPU selection */ #endif /* IDCT_ASM */
void mpeg2_idct_init (void) 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; 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++) for (i = 0; i < 64; i++)
{ {
j = default_mpeg2_scan_norm[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 .global mpeg2_idct_copy
.type mpeg2_idct_copy_arm, %function .type mpeg2_idct_copy, %function
.global mpeg2_idct_add_arm .global mpeg2_idct_add
.type mpeg2_idct_add_arm, %function .type mpeg2_idct_add, %function
/* Custom calling convention: /* Custom calling convention:
@ -265,7 +265,7 @@
sub r0, r0, #16 sub r0, r0, #16
bx lr bx lr
mpeg2_idct_copy_arm: mpeg2_idct_copy:
stmfd sp!, { r1-r2, r4-r12, lr } stmfd sp!, { r1-r2, r4-r12, lr }
bl .idct bl .idct
ldmfd sp!, { r1-r2 } ldmfd sp!, { r1-r2 }
@ -313,7 +313,7 @@ mpeg2_idct_copy_arm:
blo 1b blo 1b
ldmfd sp!, { r4-r12, pc } ldmfd sp!, { r4-r12, pc }
mpeg2_idct_add_arm: mpeg2_idct_add:
cmp r0, #129 cmp r0, #129
mov r0, r1 mov r0, r1
ldreqsh r1, [r0, #0] ldreqsh r1, [r0, #0]

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

@ -18,10 +18,10 @@
* *
****************************************************************************/ ****************************************************************************/
.global mpeg2_idct_copy_coldfire .global mpeg2_idct_copy
.type mpeg2_idct_copy_coldfire, @function .type mpeg2_idct_copy, @function
.global mpeg2_idct_add_coldfire .global mpeg2_idct_add
.type mpeg2_idct_add_coldfire, @function .type mpeg2_idct_add, @function
/* The IDCT itself. /* The IDCT itself.
* Input: %a0: block pointer * Input: %a0: block pointer
@ -240,7 +240,7 @@
.align 2 .align 2
mpeg2_idct_copy_coldfire: mpeg2_idct_copy:
lea.l (-11*4,%sp), %sp lea.l (-11*4,%sp), %sp
movem.l %d2-%d7/%a2-%a6, (%sp) | save some registers movem.l %d2-%d7/%a2-%a6, (%sp) | save some registers
move.l (11*4+4,%sp), %a0 | %a0 - block pointer for idct move.l (11*4+4,%sp), %a0 | %a0 - block pointer for idct
@ -339,7 +339,7 @@ mpeg2_idct_copy_coldfire:
.align 2 .align 2
mpeg2_idct_add_coldfire: mpeg2_idct_add:
lea.l (-11*4,%sp), %sp lea.l (-11*4,%sp), %sp
movem.l %d2-%d7/%a2-%a6, (%sp) movem.l %d2-%d7/%a2-%a6, (%sp)
movem.l (11*4+4,%sp), %d0/%a0-%a2 | %d0 - last value 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 * You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software * along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*
* $Id$
*/ */
#include "plugin.h" #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_16;
extern mpeg2_mc_fct MC_avg_xy_8; 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, MC_put_o_16, MC_put_x_16, MC_put_y_16, MC_put_xy_16,

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

@ -27,21 +27,22 @@
#define MPEG2_VERSION(a,b,c) (((a)<<16)|((b)<<8)|(c)) #define MPEG2_VERSION(a,b,c) (((a)<<16)|((b)<<8)|(c))
#define MPEG2_RELEASE MPEG2_VERSION (0, 4, 0) /* 0.4.0 */ #define MPEG2_RELEASE MPEG2_VERSION (0, 4, 0) /* 0.4.0 */
#define SEQ_FLAG_MPEG2 1 #define SEQ_FLAG_MPEG2 1
#define SEQ_FLAG_CONSTRAINED_PARAMETERS 2 #define SEQ_FLAG_CONSTRAINED_PARAMETERS 2
#define SEQ_FLAG_PROGRESSIVE_SEQUENCE 4 #define SEQ_FLAG_PROGRESSIVE_SEQUENCE 4
#define SEQ_FLAG_LOW_DELAY 8 #define SEQ_FLAG_LOW_DELAY 8
#define SEQ_FLAG_COLOUR_DESCRIPTION 16 #define SEQ_FLAG_COLOUR_DESCRIPTION 16
#define SEQ_MASK_VIDEO_FORMAT 0xe0 #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_PAL 0x20
#define SEQ_VIDEO_FORMAT_NTSC 0x40 #define SEQ_VIDEO_FORMAT_NTSC 0x40
#define SEQ_VIDEO_FORMAT_SECAM 0x60 #define SEQ_VIDEO_FORMAT_SECAM 0x60
#define SEQ_VIDEO_FORMAT_MAC 0x80 #define SEQ_VIDEO_FORMAT_MAC 0x80
#define SEQ_VIDEO_FORMAT_UNSPECIFIED 0xa0 #define SEQ_VIDEO_FORMAT_UNSPECIFIED 0xa0
typedef struct mpeg2_sequence_s { typedef struct mpeg2_sequence_s
{
unsigned int width, height; unsigned int width, height;
unsigned int chroma_width, chroma_height; unsigned int chroma_width, chroma_height;
unsigned int byte_rate; unsigned int byte_rate;
@ -59,11 +60,12 @@ typedef struct mpeg2_sequence_s {
uint8_t matrix_coefficients; uint8_t matrix_coefficients;
} mpeg2_sequence_t; } mpeg2_sequence_t;
#define GOP_FLAG_DROP_FRAME 1 #define GOP_FLAG_DROP_FRAME 1
#define GOP_FLAG_BROKEN_LINK 2 #define GOP_FLAG_BROKEN_LINK 2
#define GOP_FLAG_CLOSED_GOP 4 #define GOP_FLAG_CLOSED_GOP 4
typedef struct mpeg2_gop_s { typedef struct mpeg2_gop_s
{
uint8_t hours; uint8_t hours;
uint8_t minutes; uint8_t minutes;
uint8_t seconds; uint8_t seconds;
@ -71,35 +73,39 @@ typedef struct mpeg2_gop_s {
uint32_t flags; uint32_t flags;
} mpeg2_gop_t; } mpeg2_gop_t;
#define PIC_MASK_CODING_TYPE 7 #define PIC_MASK_CODING_TYPE 7
#define PIC_FLAG_CODING_TYPE_I 1 #define PIC_FLAG_CODING_TYPE_I 1
#define PIC_FLAG_CODING_TYPE_P 2 #define PIC_FLAG_CODING_TYPE_P 2
#define PIC_FLAG_CODING_TYPE_B 3 #define PIC_FLAG_CODING_TYPE_B 3
#define PIC_FLAG_CODING_TYPE_D 4 #define PIC_FLAG_CODING_TYPE_D 4
#define PIC_FLAG_TOP_FIELD_FIRST 8 #define PIC_FLAG_TOP_FIELD_FIRST 8
#define PIC_FLAG_PROGRESSIVE_FRAME 16 #define PIC_FLAG_PROGRESSIVE_FRAME 16
#define PIC_FLAG_COMPOSITE_DISPLAY 32 #define PIC_FLAG_COMPOSITE_DISPLAY 32
#define PIC_FLAG_SKIP 64 #define PIC_FLAG_SKIP 64
#define PIC_FLAG_TAGS 128 #define PIC_FLAG_TAGS 128
#define PIC_MASK_COMPOSITE_DISPLAY 0xfffff000 #define PIC_MASK_COMPOSITE_DISPLAY 0xfffff000
typedef struct mpeg2_picture_s { typedef struct mpeg2_picture_s
{
unsigned int temporal_reference; unsigned int temporal_reference;
unsigned int nb_fields; unsigned int nb_fields;
uint32_t tag, tag2; uint32_t tag, tag2;
uint32_t flags; uint32_t flags;
struct { struct
int x, y; {
int x, y;
} display_offset[3]; } display_offset[3];
} mpeg2_picture_t; } mpeg2_picture_t;
typedef struct mpeg2_fbuf_s { typedef struct mpeg2_fbuf_s
{
uint8_t * buf[3]; uint8_t * buf[3];
void * id; void * id;
} mpeg2_fbuf_t; } mpeg2_fbuf_t;
typedef struct mpeg2_info_s { typedef struct mpeg2_info_s
{
const mpeg2_sequence_t * sequence; const mpeg2_sequence_t * sequence;
const mpeg2_gop_t * gop; const mpeg2_gop_t * gop;
const mpeg2_picture_t * current_picture; const mpeg2_picture_t * current_picture;
@ -116,32 +122,37 @@ typedef struct mpeg2_info_s {
typedef struct mpeg2dec_s mpeg2dec_t; typedef struct mpeg2dec_s mpeg2dec_t;
typedef struct mpeg2_decoder_s mpeg2_decoder_t; typedef struct mpeg2_decoder_s mpeg2_decoder_t;
typedef enum { typedef enum
STATE_BUFFER = 0, {
STATE_SEQUENCE = 1, STATE_BUFFER = 0,
STATE_SEQUENCE = 1,
STATE_SEQUENCE_REPEATED = 2, STATE_SEQUENCE_REPEATED = 2,
STATE_GOP = 3, STATE_GOP = 3,
STATE_PICTURE = 4, STATE_PICTURE = 4,
STATE_SLICE_1ST = 5, STATE_SLICE_1ST = 5,
STATE_PICTURE_2ND = 6, STATE_PICTURE_2ND = 6,
STATE_SLICE = 7, STATE_SLICE = 7,
STATE_END = 8, STATE_END = 8,
STATE_INVALID = 9, STATE_INVALID = 9,
STATE_INVALID_END = 10 STATE_INVALID_END = 10
} mpeg2_state_t; } mpeg2_state_t;
typedef struct mpeg2_convert_init_s { typedef struct mpeg2_convert_init_s
{
unsigned int id_size; unsigned int id_size;
unsigned int buf_size[3]; unsigned int buf_size[3];
void (* start) (void * id, const mpeg2_fbuf_t * fbuf, void (* start)(void * id, const mpeg2_fbuf_t * fbuf,
const mpeg2_picture_t * picture, const mpeg2_gop_t * gop); const mpeg2_picture_t * picture, const mpeg2_gop_t * gop);
void (* copy) (void * id, uint8_t * const * src, unsigned int v_offset); void (* copy)(void * id, uint8_t * const * src, unsigned int v_offset);
} mpeg2_convert_init_t; } mpeg2_convert_init_t;
typedef enum {
MPEG2_CONVERT_SET = 0, typedef enum
{
MPEG2_CONVERT_SET = 0,
MPEG2_CONVERT_STRIDE = 1, MPEG2_CONVERT_STRIDE = 1,
MPEG2_CONVERT_START = 2 MPEG2_CONVERT_START = 2
} mpeg2_convert_stage_t; } mpeg2_convert_stage_t;
typedef int mpeg2_convert_t (int stage, void * id, typedef int mpeg2_convert_t (int stage, void * id,
const mpeg2_sequence_t * sequence, int stride, const mpeg2_sequence_t * sequence, int stride,
void * arg, mpeg2_convert_init_t * result); void * arg, mpeg2_convert_init_t * result);
@ -168,12 +179,13 @@ void mpeg2_init_fbuf (mpeg2_decoder_t * decoder, uint8_t * current_fbuf[3],
uint8_t * forward_fbuf[3], uint8_t * backward_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); 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_MPEG2DEC = 0,
MPEG2_ALLOC_YUV = 2, MPEG2_ALLOC_CHUNK = 1,
MPEG2_ALLOC_YUV = 2,
MPEG2_ALLOC_CONVERT_ID = 3, MPEG2_ALLOC_CONVERT_ID = 3,
MPEG2_ALLOC_CONVERTED = 4 MPEG2_ALLOC_CONVERTED = 4
} mpeg2_alloc_t; } mpeg2_alloc_t;
void * mpeg2_malloc (unsigned size, mpeg2_alloc_t reason); void * mpeg2_malloc (unsigned size, mpeg2_alloc_t reason);

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

@ -20,26 +20,28 @@
* along with this program; if not, write to the Free Software * along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA * 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 */ #include "config.h" /* for Rockbox CPU_ #defines */
/* macroblock modes */ /* macroblock modes */
#define MACROBLOCK_INTRA 1 #define MACROBLOCK_INTRA 1
#define MACROBLOCK_PATTERN 2 #define MACROBLOCK_PATTERN 2
#define MACROBLOCK_MOTION_BACKWARD 4 #define MACROBLOCK_MOTION_BACKWARD 4
#define MACROBLOCK_MOTION_FORWARD 8 #define MACROBLOCK_MOTION_FORWARD 8
#define MACROBLOCK_QUANT 16 #define MACROBLOCK_QUANT 16
#define DCT_TYPE_INTERLACED 32 #define DCT_TYPE_INTERLACED 32
/* motion_type */ /* motion_type */
#define MOTION_TYPE_SHIFT 6 #define MOTION_TYPE_SHIFT 6
#define MC_FIELD 1 #define MC_FIELD 1
#define MC_FRAME 2 #define MC_FRAME 2
#define MC_16X8 2 #define MC_16X8 2
#define MC_DMV 3 #define MC_DMV 3
/* picture structure */ /* picture structure */
#define TOP_FIELD 1 #define TOP_FIELD 1
#define BOTTOM_FIELD 2 #define BOTTOM_FIELD 2
#define FRAME_PICTURE 3 #define FRAME_PICTURE 3
/* picture coding type */ /* picture coding type */
@ -50,18 +52,20 @@
typedef void mpeg2_mc_fct (uint8_t *, const uint8_t *, int, int); typedef void mpeg2_mc_fct (uint8_t *, const uint8_t *, int, int);
typedef struct { typedef struct
{
uint8_t * ref[2][3]; uint8_t * ref[2][3];
uint8_t ** ref2[2]; uint8_t ** ref2[2];
int pmv[2][2]; int pmv[2][2];
int f_code[2]; int f_code[2];
} motion_t; } motion_t;
typedef void motion_parser_t (mpeg2_decoder_t * decoder, typedef void motion_parser_t(mpeg2_decoder_t * decoder,
motion_t * motion, motion_t * motion,
mpeg2_mc_fct * const * table); mpeg2_mc_fct * const * table);
struct mpeg2_decoder_s { struct mpeg2_decoder_s
{
/* first, state that carries information from one macroblock to the */ /* first, state that carries information from one macroblock to the */
/* next inside a slice, and is never used outside of mpeg2_slice() */ /* next inside a slice, and is never used outside of mpeg2_slice() */
@ -102,7 +106,7 @@ struct mpeg2_decoder_s {
uint8_t * picture_dest[3]; uint8_t * picture_dest[3];
void (* convert) (void * convert_id, uint8_t * const * src, void (* convert) (void * convert_id, uint8_t * const * src,
unsigned int v_offset); unsigned int v_offset);
void * convert_id; void * convert_id;
int dmv_offset; int dmv_offset;
@ -152,11 +156,13 @@ struct mpeg2_decoder_s {
int mpeg1; int mpeg1;
}; };
typedef struct { typedef struct
{
mpeg2_fbuf_t fbuf; mpeg2_fbuf_t fbuf;
} fbuf_alloc_t; } fbuf_alloc_t;
struct mpeg2dec_s { struct mpeg2dec_s
{
mpeg2_decoder_t decoder; mpeg2_decoder_t decoder;
mpeg2_info_t info; mpeg2_info_t info;
@ -208,8 +214,8 @@ struct mpeg2dec_s {
unsigned int convert_id_size; unsigned int convert_id_size;
int convert_stride; int convert_stride;
void (* convert_start) (void * id, const mpeg2_fbuf_t * fbuf, void (* convert_start) (void * id, const mpeg2_fbuf_t * fbuf,
const mpeg2_picture_t * picture, const mpeg2_picture_t * picture,
const mpeg2_gop_t * gop); const mpeg2_gop_t * gop);
uint8_t * buf_start; uint8_t * buf_start;
uint8_t * buf_end; uint8_t * buf_end;
@ -222,19 +228,6 @@ struct mpeg2dec_s {
uint8_t new_quantizer_matrix[4][64]; 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 */ /* decode.c */
mpeg2_state_t mpeg2_seek_header (mpeg2dec_t * mpeg2dec); mpeg2_state_t mpeg2_seek_header (mpeg2dec_t * mpeg2dec);
mpeg2_state_t mpeg2_parse_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 */ /* idct.c */
void mpeg2_idct_init (void); 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 */ /* motion_comp.c */
void mpeg2_mc_init (void); void mpeg2_mc_init (void);
typedef struct { typedef struct
{
mpeg2_mc_fct * put [8]; mpeg2_mc_fct * put [8];
mpeg2_mc_fct * avg [8]; mpeg2_mc_fct * avg [8];
} mpeg2_mc_t; } mpeg2_mc_t;
extern const mpeg2_mc_t mpeg2_mc;
#endif /* MPEG2_INTERNAL_H */

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

File diff suppressed because it is too large Load diff

40
apps/plugins/mpegplayer/vlc.h
View file

@ -21,35 +21,35 @@
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/ */
#define GETWORD(bit_buf,shift,bit_ptr) \ #define GETWORD(bit_buf, shift, bit_ptr) \
do { \ do { \
bit_buf |= ((bit_ptr[0] << 8) | bit_ptr[1]) << (shift); \ bit_buf |= ((bit_ptr[0] << 8) | bit_ptr[1]) << (shift); \
bit_ptr += 2; \ bit_ptr += 2; \
} while (0) } while (0)
static inline void bitstream_init (mpeg2_decoder_t * decoder, static inline void bitstream_init (mpeg2_decoder_t * decoder,
const uint8_t * start) const uint8_t * start)
{ {
decoder->bitstream_buf = decoder->bitstream_buf =
(start[0] << 24) | (start[1] << 16) | (start[2] << 8) | start[3]; (start[0] << 24) | (start[1] << 16) | (start[2] << 8) | start[3];
decoder->bitstream_ptr = start + 4; decoder->bitstream_ptr = start + 4;
decoder->bitstream_bits = -16; decoder->bitstream_bits = -16;
} }
/* make sure that there are at least 16 valid bits in bit_buf */ /* make sure that there are at least 16 valid bits in bit_buf */
#define NEEDBITS(bit_buf,bits,bit_ptr) \ #define NEEDBITS(bit_buf, bits, bit_ptr) \
do { \ do { \
if (unlikely (bits > 0)) { \ if (unlikely (bits > 0)) { \
GETWORD (bit_buf, bits, bit_ptr); \ GETWORD (bit_buf, bits, bit_ptr); \
bits -= 16; \ bits -= 16; \
} \ } \
} while (0) } while (0)
/* remove num valid bits from bit_buf */ /* remove num valid bits from bit_buf */
#define DUMPBITS(bit_buf,bits,num) \ #define DUMPBITS(bit_buf, bits, num) \
do { \ do { \
bit_buf <<= (num); \ bit_buf <<= (num); \
bits += (num); \ bits += (num); \
} while (0) } while (0)
/* take num bits from the high part of bit_buf and zero extend them */ /* take num bits from the high part of bit_buf and zero extend them */
@ -124,7 +124,7 @@ static const MBtab MB_B [] ICONST_ATTR = {
{0, 0}, {INTRA|QUANT, 6}, {0, 0}, {INTRA|QUANT, 6},
{BWD|CODED|QUANT, 6}, {FWD|CODED|QUANT, 6}, {BWD|CODED|QUANT, 6}, {FWD|CODED|QUANT, 6},
{INTER|CODED|QUANT, 5}, {INTER|CODED|QUANT, 5}, {INTER|CODED|QUANT, 5}, {INTER|CODED|QUANT, 5},
{INTRA, 5}, {INTRA, 5}, {INTRA, 5}, {INTRA, 5},
{FWD, 4}, {FWD, 4}, {FWD, 4}, {FWD, 4}, {FWD, 4}, {FWD, 4}, {FWD, 4}, {FWD, 4},
{FWD|CODED, 4}, {FWD|CODED, 4}, {FWD|CODED, 4}, {FWD|CODED, 4}, {FWD|CODED, 4}, {FWD|CODED, 4}, {FWD|CODED, 4}, {FWD|CODED, 4},
{BWD, 3}, {BWD, 3}, {BWD, 3}, {BWD, 3}, {BWD, 3}, {BWD, 3}, {BWD, 3}, {BWD, 3},
@ -301,7 +301,7 @@ static const DCTtab DCT_B14_8 [] ICONST_ATTR = {
}; };
static const DCTtab DCT_B14AC_5 [] ICONST_ATTR = { static const DCTtab DCT_B14AC_5 [] ICONST_ATTR = {
{ 1, 3, 5}, { 5, 1, 5}, { 4, 1, 5}, { 1, 3, 5}, { 5, 1, 5}, { 4, 1, 5},
{ 1, 2, 4}, { 1, 2, 4}, { 3, 1, 4}, { 3, 1, 4}, { 1, 2, 4}, { 1, 2, 4}, { 3, 1, 4}, { 3, 1, 4},
{ 2, 1, 3}, { 2, 1, 3}, { 2, 1, 3}, { 2, 1, 3}, { 2, 1, 3}, { 2, 1, 3}, { 2, 1, 3}, { 2, 1, 3},
{129, 0, 2}, {129, 0, 2}, {129, 0, 2}, {129, 0, 2}, {129, 0, 2}, {129, 0, 2}, {129, 0, 2}, {129, 0, 2},
@ -311,7 +311,7 @@ static const DCTtab DCT_B14AC_5 [] ICONST_ATTR = {
}; };
static const DCTtab DCT_B14DC_5 [] ICONST_ATTR = { static const DCTtab DCT_B14DC_5 [] ICONST_ATTR = {
{ 1, 3, 5}, { 5, 1, 5}, { 4, 1, 5}, { 1, 3, 5}, { 5, 1, 5}, { 4, 1, 5},
{ 1, 2, 4}, { 1, 2, 4}, { 3, 1, 4}, { 3, 1, 4}, { 1, 2, 4}, { 1, 2, 4}, { 3, 1, 4}, { 3, 1, 4},
{ 2, 1, 3}, { 2, 1, 3}, { 2, 1, 3}, { 2, 1, 3}, { 2, 1, 3}, { 2, 1, 3}, { 2, 1, 3}, { 2, 1, 3},
{ 1, 1, 1}, { 1, 1, 1}, { 1, 1, 1}, { 1, 1, 1}, { 1, 1, 1}, { 1, 1, 1}, { 1, 1, 1}, { 1, 1, 1},
@ -393,7 +393,7 @@ static const DCTtab DCT_B15_8 [] ICONST_ATTR = {
static const MBAtab MBA_5 [] ICONST_ATTR = { static const MBAtab MBA_5 [] ICONST_ATTR = {
{6, 5}, {5, 5}, {4, 4}, {4, 4}, {3, 4}, {3, 4}, {6, 5}, {5, 5}, {4, 4}, {4, 4}, {3, 4}, {3, 4},
{2, 3}, {2, 3}, {2, 3}, {2, 3}, {1, 3}, {1, 3}, {1, 3}, {1, 3}, {2, 3}, {2, 3}, {2, 3}, {2, 3}, {1, 3}, {1, 3}, {1, 3}, {1, 3},
{0, 1}, {0, 1}, {0, 1}, {0, 1}, {0, 1}, {0, 1}, {0, 1}, {0, 1}, {0, 1}, {0, 1}, {0, 1}, {0, 1}, {0, 1}, {0, 1}, {0, 1}, {0, 1},
{0, 1}, {0, 1}, {0, 1}, {0, 1}, {0, 1}, {0, 1}, {0, 1}, {0, 1} {0, 1}, {0, 1}, {0, 1}, {0, 1}, {0, 1}, {0, 1}, {0, 1}, {0, 1}