From d34041569e71fc9bd772354e94dc9d16061072a5 Mon Sep 17 00:00:00 2001 From: arpi_esp Date: Sat, 24 Feb 2001 20:28:24 +0000 Subject: Initial revision git-svn-id: svn://svn.mplayerhq.hu/mplayer/trunk@2 b3059339-0415-0410-9bf9-f77b7e298cf2 --- libmpeg2/decode.c | 319 ++++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 319 insertions(+) create mode 100644 libmpeg2/decode.c (limited to 'libmpeg2/decode.c') diff --git a/libmpeg2/decode.c b/libmpeg2/decode.c new file mode 100644 index 0000000000..e8bbb02112 --- /dev/null +++ b/libmpeg2/decode.c @@ -0,0 +1,319 @@ +/* Copyright (C) Aaron Holtzman - Nov 1999 */ +/* Some cleanup & hacking by A'rpi/ESP-team - Oct 2000 */ + +/* mpeg2dec version: */ +#define PACKAGE "mpeg2dec" +//#define VERSION "0.1.7-cvs" +#define VERSION "0.1.8-cvs" + +#include +#include +#include +#include +#include + +#include "config.h" + +//#include "video_out.h" + +#include "mpeg2.h" +#include "mpeg2_internal.h" + +#include "../linux/shmem.h" + +//#include "motion_comp.h" +//#include "idct.h" +//#include "header.h" +//#include "slice.h" +//#include "stats.h" + +#include "attributes.h" +#ifdef __i386__ +#include "mmx.h" +#endif + +//this is where we keep the state of the decoder +//picture_t picture_data; +//picture_t *picture=&picture_data; +picture_t *picture=NULL; + +//global config struct +mpeg2_config_t config; + +// the maximum chunk size is determined by vbv_buffer_size which is 224K for +// MP@ML streams. (we make no pretenses ofdecoding anything more than that) +//static uint8_t chunk_buffer[224 * 1024 + 4]; +//static uint32_t shift = 0; + +static int drop_flag = 0; +static int drop_frame = 0; + +int quant_store[MBR+1][MBC+1]; // [Review] + +void mpeg2_init (void) +{ + + printf (PACKAGE"-"VERSION" (C) 2000 Aaron Holtzman \n"); + config.flags = 0; +#ifdef HAVE_MMX + config.flags |= MM_ACCEL_X86_MMX; +#endif +#ifdef HAVE_SSE + config.flags |= MM_ACCEL_X86_MMXEXT; +#endif +#ifdef HAVE_3DNOW + config.flags |= MM_ACCEL_X86_3DNOW; +#endif +#ifdef HAVE_MLIB + config.flags |= MM_ACCEL_MLIB; +#endif + + printf("libmpeg2 config flags = 0x%X\n",config.flags); + + picture=shmem_alloc(sizeof(picture_t)); // !!! NEW HACK :) !!! + + header_state_init (picture); + picture->repeat_count=0; + + picture->pp_options=0; + + idct_init (); + motion_comp_init (); +} + +void mpeg2_allocate_image_buffers (picture_t * picture) +{ + int frame_size,buff_size; + unsigned char *base=NULL; + + // height+1 requires for yuv2rgb_mmx code (it reads next line after last) + frame_size = picture->coded_picture_width * (1+picture->coded_picture_height); + frame_size = (frame_size+31)&(~31); // align to 32 byte boundary + buff_size = frame_size + (frame_size/4)*2; // 4Y + 1U + 1V + + // allocate images in YV12 format + base = shmem_alloc(buff_size); + picture->throwaway_frame[0] = base; + picture->throwaway_frame[1] = base + frame_size * 5 / 4; + picture->throwaway_frame[2] = base + frame_size; + + base = shmem_alloc(buff_size); + picture->backward_reference_frame[0] = base; + picture->backward_reference_frame[1] = base + frame_size * 5 / 4; + picture->backward_reference_frame[2] = base + frame_size; + + base = shmem_alloc(buff_size); + picture->forward_reference_frame[0] = base; + picture->forward_reference_frame[1] = base + frame_size * 5 / 4; + picture->forward_reference_frame[2] = base + frame_size; + + base = shmem_alloc(buff_size); + picture->pp_frame[0] = base; + picture->pp_frame[1] = base + frame_size * 5 / 4; + picture->pp_frame[2] = base + frame_size; + +} + +static void decode_reorder_frames (void) +{ + if (picture->picture_coding_type != B_TYPE) { + + //reuse the soon to be outdated forward reference frame + picture->current_frame[0] = picture->forward_reference_frame[0]; + picture->current_frame[1] = picture->forward_reference_frame[1]; + picture->current_frame[2] = picture->forward_reference_frame[2]; + + //make the backward reference frame the new forward reference frame + picture->forward_reference_frame[0] = + picture->backward_reference_frame[0]; + picture->forward_reference_frame[1] = + picture->backward_reference_frame[1]; + picture->forward_reference_frame[2] = + picture->backward_reference_frame[2]; + + picture->backward_reference_frame[0] = picture->current_frame[0]; + picture->backward_reference_frame[1] = picture->current_frame[1]; + picture->backward_reference_frame[2] = picture->current_frame[2]; + + } else { + + picture->current_frame[0] = picture->throwaway_frame[0]; + picture->current_frame[1] = picture->throwaway_frame[1]; + picture->current_frame[2] = picture->throwaway_frame[2]; + + } +} + +static int in_slice_flag=0; + +static int parse_chunk (vo_functions_t * output, int code, uint8_t * buffer) +{ + int is_frame_done = 0; + + stats_header (code, buffer); + + is_frame_done = in_slice_flag && ((!code) || (code >= 0xb0)); + if (is_frame_done) { + in_slice_flag = 0; + + if(picture->picture_structure != FRAME_PICTURE) printf("Field! %d \n",picture->second_field); + + if ( ((HACK_MODE == 2) || (picture->mpeg1)) + && ((picture->picture_structure == FRAME_PICTURE) || + (picture->second_field)) + ) { + uint8_t ** bar; + int stride[3]; + + if (picture->picture_coding_type == B_TYPE) + bar = picture->throwaway_frame; + else + bar = picture->forward_reference_frame; + + stride[0]=picture->coded_picture_width; + stride[1]=stride[2]=stride[0]/2; + + if(picture->pp_options){ + // apply OpenDivX postprocess filter + postprocess(bar, stride[0], + picture->pp_frame, stride[0], + picture->coded_picture_width, picture->coded_picture_height, + &quant_store[1][1], (MBC+1), picture->pp_options); + output->draw_slice (picture->pp_frame, stride, + picture->display_picture_width, + picture->display_picture_height, 0, 0); + } else { + output->draw_slice (bar, stride, + picture->display_picture_width, + picture->display_picture_height, 0, 0); + } + + } +#ifdef ARCH_X86 + if (config.flags & MM_ACCEL_X86_MMX) emms (); +#endif + output->flip_page (); + } + + switch (code) { + case 0x00: /* picture_start_code */ + if (header_process_picture_header (picture, buffer)) { + printf ("bad picture header\n"); + exit (1); + } + + drop_frame = drop_flag && (picture->picture_coding_type == B_TYPE); + //decode_reorder_frames (); + break; + + case 0xb3: /* sequence_header_code */ + if (header_process_sequence_header (picture, buffer)) { + printf ("bad sequence header\n"); + exit (1); + } + break; + + case 0xb5: /* extension_start_code */ + if (header_process_extension (picture, buffer)) { + printf ("bad extension\n"); + exit (1); + } + break; + + default: +// if (code >= 0xb9) printf ("stream not demultiplexed ?\n"); + if (code >= 0xb0) break; + + if (!(in_slice_flag)) { + in_slice_flag = 1; + + if(!(picture->second_field)) decode_reorder_frames (); + } + + if (!drop_frame) { + uint8_t ** bar; + + slice_process (picture, code, buffer); + + if ((HACK_MODE < 2) && (!(picture->mpeg1))) { + uint8_t * foo[3]; + uint8_t ** bar; + //frame_t * bar; + int stride[3]; + int offset; + + if (picture->picture_coding_type == B_TYPE) + bar = picture->throwaway_frame; + else + bar = picture->forward_reference_frame; + + offset = (code-1) * 4 * picture->coded_picture_width; + if ((! HACK_MODE) && (picture->picture_coding_type == B_TYPE)) + offset = 0; + + foo[0] = bar[0] + 4 * offset; + foo[1] = bar[1] + offset; + foo[2] = bar[2] + offset; + + stride[0]=picture->coded_picture_width; + stride[1]=stride[2]=stride[0]/2; + + output->draw_slice (foo, stride, + picture->display_picture_width, 16, 0, (code-1)*16); + } +#ifdef ARCH_X86 + if (config.flags & MM_ACCEL_X86_MMX) emms (); +#endif + + } + } + + return is_frame_done; +} + + +int mpeg2_decode_data (vo_functions_t *output, uint8_t *current, uint8_t *end) +{ + //static uint8_t code = 0xff; + //static uint8_t chunk_buffer[65536]; + //static uint8_t *chunk_ptr = chunk_buffer; + //static uint32_t shift = 0; + uint8_t code; + uint8_t *pos=NULL; + uint8_t *start=current; + int ret = 0; + +// printf("RCVD %d bytes\n",end-current); + +while(current