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; }