int decode_frame() {
uint8_t buffer[4096];
mpeg2_state_t state;
size_t size;
const mpeg2_info_t *info = mpeg2_info(decoder);
for (;;) {
state = mpeg2_parse(decoder);
switch (state) {
case STATE_BUFFER:
size = fread(buffer, 1, 4096, source);
if (size <= 0) {
return -1;
}
mpeg2_buffer(decoder, buffer, buffer + 4096);
break;
case STATE_SEQUENCE:
mpeg2_convert(decoder, mpeg2convert_rgb32, NULL);
break;
case STATE_SLICE:
case STATE_END:
case STATE_INVALID_END:
present_frame(
info->sequence->width,
info->sequence->height,
info->display_fbuf->buf[0]);
return 0;
case STATE_INVALID:
return -2;
default:
break;
}
}
}
unsigned int mpeg_idle(mpeg_struct_t *Mpeg_Struct, new_screen* ScreenBuff, FileInfo_t *mpgfile)
{
if(!Mpeg_Struct) return 0;
if(!Mpeg_Struct->FrameReady)
{
do
{
Mpeg_Struct->state = mpeg2_parse(Mpeg_Struct->decoder);
switch (Mpeg_Struct->state)
{
case STATE_BUFFER:
//size = fread (buffer, 1, _BUFFER_SIZE_, mpgfile);
Mpeg_Struct->size = read_from_buffer(Mpeg_Struct->buffer, 1, _BUFFER_SIZE_, mpgfile);
if(!Mpeg_Struct->size) break;
mpeg2_buffer (Mpeg_Struct->decoder, Mpeg_Struct->buffer, Mpeg_Struct->buffer + Mpeg_Struct->size);
break;
case STATE_SEQUENCE:
mpeg2_convert (Mpeg_Struct->decoder, Mpeg_Struct->mpeg_convert, NULL);
break;
case STATE_SLICE:
case STATE_END:
case STATE_INVALID_END:
if (Mpeg_Struct->info->display_fbuf) Mpeg_Struct->FrameReady = 1;
break;
default:
break;
}
}while(!Mpeg_Struct->FrameReady && Mpeg_Struct->size);
}
#ifndef AVR32
if(Mpeg_Struct->FrameReady == true && (timer_tick(&Mpeg_Struct->FrameDisplay) == true || Mpeg_Struct->EnableFrameLimit == false))
#else
if(Mpeg_Struct->FrameReady == true)
#endif
{
Mpeg_Struct->FrameReady = false;
/*save_ppm (ScreenBuff, Mpeg_Struct->info->sequence->width, Mpeg_Struct->info->sequence->height,
Mpeg_Struct->info->display_fbuf->buf[0], Mpeg_Struct->framenum++);*/
_Fps++;
//Mpeg_Struct->->info
if(Mpeg_Struct->info->current_picture->temporal_reference != Mpeg_Struct->temporal_reference)
{
Mpeg_Struct->temporal_reference = Mpeg_Struct->info->current_picture->temporal_reference;
Mpeg_Struct->CallbackDisplayFrame((void*)Mpeg_Struct->CallbackDisplayFrameVariable, Mpeg_Struct->info->display_fbuf->buf[0], 0, 0, Mpeg_Struct->info->sequence->width, Mpeg_Struct->info->sequence->height);
}
if(CntToDetermineTheFps != rtcSecUpdate)
{
CntToDetermineTheFps = rtcSecUpdate;
//UARTPuts(DebugCom, "Screen fill capability = ", -1);
UARTPutNum(DebugCom, _Fps);
UARTPuts(DebugCom, "Fps\n\r", -1);
_Fps = 0;
}
}
//if(Mpeg_Struct->size == 0) mpeg2_close (Mpeg_Struct->decoder);
return Mpeg_Struct->size;
}
void decode_mpeg2(decode_t *decode)
{
mpeg2dec_t *decoder = NULL;
const mpeg2_info_t *info = NULL;
const mpeg2_sequence_t *sequence = NULL;
mpeg2_state_t state;
size_t size;
uint32_t ac = 0;
WriteDataFn writer = write_yuv420p;
if (decode->format == TC_CODEC_RGB) {
tc_log_info(__FILE__, "using libmpeg2convert"
" RGB24 conversion");
writer = write_rgb24;
}
ac = mpeg2_accel(MPEG2_ACCEL_DETECT);
show_accel(ac);
decoder = mpeg2_init();
if (decoder == NULL) {
tc_log_error(__FILE__, "Could not allocate a decoder object.");
import_exit(1);
}
info = mpeg2_info(decoder);
size = (size_t)-1;
do {
state = mpeg2_parse(decoder);
sequence = info->sequence;
switch (state) {
case STATE_BUFFER:
size = tc_pread(decode->fd_in, buffer, BUFFER_SIZE);
mpeg2_buffer(decoder, buffer, buffer + size);
break;
case STATE_SEQUENCE:
if (decode->format == TC_CODEC_RGB) {
mpeg2_convert(decoder, mpeg2convert_rgb24, NULL);
}
break;
case STATE_SLICE:
case STATE_END:
case STATE_INVALID_END:
if (info->display_fbuf) {
writer(decode, info, sequence);
}
break;
default:
/* can't happen */
break;
}
} while (size);
mpeg2_close(decoder);
import_exit(0);
}
static void sample2 (FILE * mpgfile)
{
#define BUFFER_SIZE 4096
uint8_t buffer[BUFFER_SIZE];
mpeg2dec_t * decoder;
const mpeg2_info_t * info;
mpeg2_state_t state;
size_t size;
int framenum = 0;
decoder = mpeg2_init ();
if (decoder == NULL) {
fprintf (stderr, "Could not allocate a decoder object.\n");
exit (1);
}
info = mpeg2_info (decoder);
size = (size_t)-1;
do {
state = mpeg2_parse (decoder);
switch (state) {
case STATE_BUFFER:
size = fread (buffer, 1, BUFFER_SIZE, mpgfile);
mpeg2_buffer (decoder, buffer, buffer + size);
break;
case STATE_SEQUENCE:
mpeg2_convert (decoder, mpeg2convert_rgb24, NULL);
break;
case STATE_SLICE:
case STATE_END:
case STATE_INVALID_END:
if (info->display_fbuf)
save_ppm (info->sequence->width, info->sequence->height,
info->display_fbuf->buf[0], framenum++);
break;
default:
break;
}
} while (size);
mpeg2_close (decoder);
}
static void sample2 (FILE * file)
{
#define BUFFER_SIZE 4096
uint8_t buffer[BUFFER_SIZE];
mpeg2dec_t * mpeg2dec;
const mpeg2_info_t * info;
int state;
int size;
int framenum = 0;
mpeg2dec = mpeg2_init ();
if (mpeg2dec == NULL)
exit (1);
info = mpeg2_info (mpeg2dec);
size = BUFFER_SIZE;
do {
state = mpeg2_parse (mpeg2dec);
switch (state) {
case -1:
size = fread (buffer, 1, BUFFER_SIZE, file);
mpeg2_buffer (mpeg2dec, buffer, buffer + size);
break;
case STATE_SEQUENCE:
mpeg2_convert (mpeg2dec, convert_rgb24, NULL);
break;
case STATE_SLICE:
case STATE_END:
if (info->display_fbuf)
save_ppm (info->sequence->width, info->sequence->height,
info->display_fbuf->buf[0], framenum++);
break;
}
} while (size);
mpeg2_close (mpeg2dec);
}
static int _initmpeg2(FILE *mpgfile,int *w, int *h)
{
static uint8_t buffer[BUFFER_SIZE];
mpeg2_state_t state;
struct fbuf_s * current_fbuf;
size_t size;
int pixels;
int i;
global_mpegfile=mpgfile;
if (decoder!=NULL) {
mpeg2_close (decoder);
decoder=NULL;
}
decoder = mpeg2_init ();
if (decoder == NULL) {
fprintf (stderr, "Could not allocate a decoder object.\n");
exit (1);
}
info = mpeg2_info (decoder);
size = (size_t)-1;
do {
state = mpeg2_parse (decoder);
if (state==STATE_BUFFER) {
//fprintf(stderr,"Got STATE_BUFFER\n");
size = fread (buffer, 1, BUFFER_SIZE, global_mpegfile);
mpeg2_buffer (decoder, buffer, buffer + size);
}
else if (state==STATE_SEQUENCE) {
//fprintf(stderr,"Got STATE_SEQUENCE\n");
mpeg2_convert (decoder, mpeg2convert_rgb24, NULL);
mpeg2_custom_fbuf (decoder, 1);
if (w!=NULL) *w=info->sequence->width;
if (h!=NULL) *h=info->sequence->height;
pixels = info->sequence->width * info->sequence->height;
for (i = 0; i < 3; i++) {
fbuf[i].rgb[0] = (uint8_t *) malloc (3 * pixels);
fbuf[i].rgb[1] = fbuf[i].rgb[2] = NULL;
if (!fbuf[i].rgb[0]) {
fprintf (stderr, "Could not allocate an output buffer.\n");
exit (1);
}
fbuf[i].used = 0;
}
for (i = 0; i < 2; i++) {
current_fbuf = get_fbuf ();
mpeg2_set_buf (decoder, current_fbuf->rgb, current_fbuf);
}
break;
}
else if (state==STATE_PICTURE
|| state==STATE_SLICE
|| state==STATE_END
|| state==STATE_INVALID_END) {
//if (state==STATE_SLICE) fprintf(stderr,"Got STATE_PICTURE\n");
//if (state==STATE_SLICE) fprintf(stderr,"Got STATE_SLICE\n");
//if (state==STATE_END) fprintf(stderr,"Got STATE_END\n");
//if (state==STATE_INVALID_END) fprintf(stderr,"Got STATE_INVALID_END\n");
fprintf(stderr,"GOT unexpected state during initialization.\n");
return 0;
}
} while (size);
return 1;
}
int _getmpeg2frame(unsigned char *rgb,int gray)
{
int i;
static uint8_t buffer[BUFFER_SIZE];
mpeg2_state_t state;
size_t size;
int pixels;
struct fbuf_s * current_fbuf;
int done=0;
size = (size_t)-1;
do {
state = mpeg2_parse (decoder);
if (state==STATE_BUFFER) {
//fprintf(stderr,"Got STATE_BUFFER\n");
size = fread (buffer, 1, BUFFER_SIZE, global_mpegfile);
mpeg2_buffer (decoder, buffer, buffer + size);
}
else if (state==STATE_SEQUENCE) {
//fprintf(stderr,"Got STATE_SEQUENCE\n");
mpeg2_convert (decoder, mpeg2convert_rgb24, NULL);
mpeg2_custom_fbuf (decoder, 1);
pixels = info->sequence->width * info->sequence->height;
for (i = 0; i < 3; i++) {
fbuf[i].rgb[0] = (uint8_t *) malloc (3 * pixels);
fbuf[i].rgb[1] = fbuf[i].rgb[2] = NULL;
if (!fbuf[i].rgb[0]) {
fprintf (stderr, "Could not allocate an output buffer.\n");
exit (1);
}
fbuf[i].used = 0;
}
for (i = 0; i < 2; i++) {
current_fbuf = get_fbuf ();
mpeg2_set_buf (decoder, current_fbuf->rgb, current_fbuf);
}
}
else if (state==STATE_PICTURE) {
//fprintf(stderr,"Got STATE_PICTURE\n");
current_fbuf = get_fbuf ();
mpeg2_set_buf (decoder, current_fbuf->rgb, current_fbuf);
}
else if (state==STATE_SLICE
|| state==STATE_END
|| state==STATE_INVALID_END) {
//if (state==STATE_SLICE) fprintf(stderr,"Got STATE_SLICE\n");
//if (state==STATE_END) fprintf(stderr,"Got STATE_END\n");
//if (state==STATE_INVALID_END) fprintf(stderr,"Got STATE_INVALID_END\n");
if (info->display_fbuf)
{
int jj;
int pixels;
uint8_t *base;
base=info->display_fbuf->buf[0];
/* we have a complete image ready */
if (gray)
{
pixels=info->sequence->width*info->sequence->height;
for (jj=0;jj<pixels;jj++)
{
rgb[jj]=(base[0]+base[1]+base[3])/3;
base+=3;
}
}
else
{
pixels=3*info->sequence->width*info->sequence->height;
/* we have a complete image ready */
memcpy(rgb,base,pixels*sizeof(unsigned char));
}
done=1;
}
if (info->discard_fbuf)
((struct fbuf_s *)info->discard_fbuf->id)->used = 0;
if (state != STATE_SLICE)
for (i = 0; i < 3; i++)
free (fbuf[i].rgb[0]);
if (state==STATE_END)
{
//fprintf(stderr,"Got STATE_END\n");
rewindmpeg2();
}
if (state==STATE_INVALID_END)
{
//fprintf(stderr,"Got STATE_INVALID_END\n");
rewindmpeg2();
}
/* we got a single frame */
if (done)
{
if (size!=0) return 1;
return 0;
}
}
} while (size);
return 0;
}
void getframe(Mpeg2 *mpg, Texture *dst) {
int frame_ready=0;
size_t blocksize=MPEG_BUFFER_SIZE;
static unsigned char bufz[MPEG_BUFFER_SIZE+1];
int invalid=0;
do {
mpg->state = mpeg2_parse(mpg->decoder);
switch (mpg->state) {
case STATE_BUFFER:
blocksize = MPEG_BUFFER_SIZE;
//if (mpg->whereami+blocksize > mpg->datasize-1) blocksize = mpg->datasize-mpg->whereami-1;
//if (blocksize>0)
if (mpg->stream_from_disk) {
blocksize=fread(bufz, 1, MPEG_BUFFER_SIZE, mpg->f);
mpeg2_buffer(mpg->decoder, bufz, bufz+blocksize);
} else {
mpeg2_buffer(mpg->decoder, mpg->data+mpg->whereami, mpg->data+mpg->whereami+blocksize);
mpg->whereami += blocksize;
}
break;
case STATE_SEQUENCE:
mpeg2_convert(mpg->decoder, mpeg2convert_bgr32, NULL);
break;
case STATE_INVALID_END: {
//FILE *foo;
//foo=fopen("moi.txt", "a");
//fprintf(foo, "STATE_INVALID_END: %d, %i, %i\n", blocksize, (int)ftell(mpg->f), (int)filelength(fileno(mpg->f)));
//fclose(foo);
invalid=2;
frame_ready++;
break;
}
case STATE_SLICE:
case STATE_END:
frame_ready++;
break;
case STATE_INVALID: {
//FILE *foo;
//foo=fopen("moi.txt", "a");
//fprintf(foo, "STATE_INVALID: %d, %i, %i\n", blocksize, (int)ftell(mpg->f), (int)filelength(fileno(mpg->f)));
//fclose(foo);
invalid=3;
frame_ready++;
break;
}
case STATE_SEQUENCE_REPEATED:
case STATE_GOP:
case STATE_PICTURE:
case STATE_SLICE_1ST:
case STATE_PICTURE_2ND:
break;
default:
break;
}
} while (!frame_ready);
mpg->framenum++;
if (invalid) mpg->end=invalid;
// if (mpg->state==STATE_END || mpg->state==STATE_INVALID_END) mpg->end=1; //mpg->framenum=0, mpg->whereami=0;
if (mpg->state==STATE_END) mpg->end=1;
}
