4998
|
1 #include <stdio.h>
|
|
2 #include <stdlib.h>
|
|
3
|
|
4 #include "config.h"
|
|
5 #include "mp_msg.h"
|
|
6
|
|
7 #include "vd_internal.h"
|
|
8
|
|
9 static vd_info_t info =
|
|
10 {
|
5465
|
11 "MPEG 1/2 Video decoder v2.0",
|
4998
|
12 "libmpeg2",
|
|
13 VFM_MPEG,
|
|
14 "A'rpi",
|
|
15 "Aaron & Walken",
|
|
16 "native"
|
|
17 };
|
|
18
|
|
19 LIBVD_EXTERN(libmpeg2)
|
|
20
|
5465
|
21 #define USE_SIGJMP_TRICK
|
4998
|
22
|
5465
|
23 #ifdef USE_SIGJMP_TRICK
|
|
24 #include <signal.h>
|
|
25 #include <setjmp.h>
|
|
26 #endif
|
|
27
|
|
28 //#include "libmpdemux/parse_es.h"
|
|
29
|
|
30 #include "libvo/video_out.h" // FIXME!!!
|
|
31
|
4998
|
32 #include "libmpeg2/mpeg2.h"
|
|
33 #include "libmpeg2/mpeg2_internal.h"
|
5465
|
34 #include "libmpeg2/mm_accel.h"
|
4998
|
35
|
5465
|
36 #include "../cpudetect.h"
|
|
37
|
|
38 mpeg2_config_t config; // FIXME!!!
|
|
39 static picture_t *picture=NULL; // exported from libmpeg2/decode.c
|
|
40
|
|
41 static int table_init_state=0;
|
|
42
|
|
43 #ifdef MPEG12_POSTPROC
|
|
44 #include "../postproc/postprocess.h"
|
|
45 int quant_store[MPEG2_MBR+1][MPEG2_MBC+1]; // [Review]
|
|
46 #endif
|
4998
|
47
|
|
48 // to set/get/query special features/parameters
|
|
49 static int control(sh_video_t *sh,int cmd,void* arg,...){
|
|
50 return CONTROL_UNKNOWN;
|
|
51 }
|
|
52
|
5465
|
53 static vo_frame_t frames[3];
|
|
54
|
4998
|
55 // init driver
|
|
56 static int init(sh_video_t *sh){
|
5465
|
57
|
|
58 config.flags = 0;
|
|
59 if(gCpuCaps.hasMMX)
|
|
60 config.flags |= MM_ACCEL_X86_MMX;
|
|
61 if(gCpuCaps.hasMMX2)
|
|
62 config.flags |= MM_ACCEL_X86_MMXEXT;
|
|
63 if(gCpuCaps.has3DNow)
|
|
64 config.flags |= MM_ACCEL_X86_3DNOW;
|
|
65 #ifdef HAVE_MLIB
|
|
66 config.flags |= MM_ACCEL_MLIB;
|
|
67 #endif
|
|
68
|
|
69 picture=malloc(sizeof(picture_t)); // !!! NEW HACK :) !!!
|
|
70 memset(picture,0,sizeof(picture_t));
|
|
71 header_state_init (picture);
|
|
72
|
|
73 if(!table_init_state){
|
|
74 idct_init ();
|
|
75 motion_comp_init ();
|
|
76 table_init_state=1;
|
|
77 }
|
|
78
|
5003
|
79 picture->pp_options=divx_quality;
|
5465
|
80
|
|
81 picture->forward_reference_frame=&frames[0];
|
|
82 picture->backward_reference_frame=&frames[1];
|
|
83 picture->temp_frame=&frames[2];
|
|
84 picture->current_frame=NULL;
|
|
85
|
4998
|
86 // send seq header to the decoder: *** HACK ***
|
5465
|
87 // mpeg2_decode_data(NULL,videobuffer,videobuffer+videobuf_len,0);
|
|
88 // mpeg2_allocate_image_buffers (picture);
|
5124
|
89 return mpcodecs_config_vo(sh,sh->disp_w,sh->disp_h,IMGFMT_YV12);
|
4998
|
90 }
|
|
91
|
|
92 // uninit driver
|
|
93 static void uninit(sh_video_t *sh){
|
5465
|
94 // mpeg2_free_image_buffers (picture);
|
|
95 }
|
|
96
|
|
97 static void draw_slice (vo_frame_t * frame, uint8_t ** src){
|
|
98 vo_functions_t * output = frame->vo;
|
|
99 int stride[3];
|
|
100 int y=picture->slice<<4;
|
|
101
|
|
102 stride[0]=picture->coded_picture_width;
|
|
103 stride[1]=stride[2]=stride[0]/2;
|
|
104
|
|
105 output->draw_slice (src,
|
|
106 stride, picture->display_picture_width,
|
|
107 (y+16<=picture->display_picture_height) ? 16 :
|
|
108 picture->display_picture_height-y,
|
|
109 0, y);
|
|
110
|
|
111 ++picture->slice;
|
4998
|
112 }
|
|
113
|
5465
|
114 static int in_slice_flag=0; // FIXME! move to picture struct
|
|
115 static int drop_frame=0; // FIXME! move to picture struct
|
|
116
|
|
117 static mp_image_t* parse_chunk (sh_video_t* sh, int code, uint8_t * buffer, int framedrop){
|
|
118 mp_image_t* mpi=NULL;
|
|
119
|
|
120 // stats_header (code, buffer);
|
|
121
|
|
122 if (in_slice_flag && ((!code) || (code >= 0xb0))) {
|
|
123 // ok, we've completed decoding a frame/field!
|
|
124 in_slice_flag = 0;
|
|
125 mpi=picture->display_frame->mpi;
|
|
126 if(picture->picture_structure!=FRAME_PICTURE && !picture->second_field)
|
|
127 mpi=NULL; // we don't draw first fields!
|
|
128 }
|
|
129
|
|
130 switch (code) {
|
|
131 case 0x00: /* picture_start_code */
|
|
132 if (header_process_picture_header (picture, buffer)) {
|
|
133 printf ("bad picture header\n");
|
|
134 }
|
|
135 drop_frame = framedrop && (picture->picture_coding_type == B_TYPE);
|
|
136 drop_frame |= framedrop>=2; // hard drop
|
|
137 break;
|
|
138
|
|
139 case 0xb3: /* sequence_header_code */
|
|
140 if (header_process_sequence_header (picture, buffer)) {
|
|
141 printf ("bad sequence header\n");
|
|
142 }
|
|
143 break;
|
|
144
|
|
145 case 0xb5: /* extension_start_code */
|
|
146 if (header_process_extension (picture, buffer)) {
|
|
147 printf ("bad extension\n");
|
|
148 }
|
|
149 break;
|
|
150
|
|
151 default:
|
|
152 if (code >= 0xb0) break;
|
|
153
|
|
154 if (!in_slice_flag) {
|
|
155 in_slice_flag = 1;
|
|
156
|
|
157 // set current_frame pointer:
|
|
158 if (!picture->second_field){
|
|
159 mp_image_t* mpi;
|
|
160 int flags;
|
|
161 if (picture->picture_coding_type == B_TYPE){
|
5485
|
162 flags=vd_use_slices?MP_IMGFLAG_DRAW_CALLBACK:0;
|
5465
|
163 picture->display_frame=
|
|
164 picture->current_frame = picture->temp_frame;
|
|
165 } else {
|
|
166 flags=MP_IMGFLAG_PRESERVE|MP_IMGFLAG_READABLE;
|
|
167 picture->current_frame = picture->forward_reference_frame;
|
|
168 picture->display_frame=
|
|
169 picture->forward_reference_frame = picture->backward_reference_frame;
|
|
170 picture->backward_reference_frame = picture->current_frame;
|
|
171 }
|
|
172 mpi=mpcodecs_get_image(sh,MP_IMGTYPE_IPB, flags,
|
|
173 picture->coded_picture_width,
|
|
174 picture->coded_picture_height);
|
|
175 // ok, lets see what did we get:
|
|
176 if(mpi->flags&MP_IMGFLAG_DRAW_CALLBACK &&
|
|
177 !(mpi->flags&MP_IMGFLAG_DIRECT)){
|
|
178 // nice, filter/vo likes draw_callback :)
|
|
179 picture->current_frame->copy=draw_slice;
|
|
180 } else
|
|
181 picture->current_frame->copy=NULL;
|
|
182 // let's, setup pointers!
|
|
183 picture->current_frame->base[0]=mpi->planes[0];
|
|
184 picture->current_frame->base[1]=mpi->planes[1];
|
|
185 picture->current_frame->base[2]=mpi->planes[2];
|
|
186 picture->current_frame->mpi=mpi; // tricky!
|
|
187 mp_msg(MSGT_DECVIDEO,MSGL_DBG2,"mpeg2: [%c] %p %s \n",
|
|
188 (picture->picture_coding_type == B_TYPE) ? 'B':'P',
|
|
189 mpi, (mpi->flags&MP_IMGFLAG_DIRECT)?"DR!":"");
|
|
190 }
|
|
191
|
|
192 picture->current_frame->vo=sh->video_out;
|
|
193 picture->slice=0;
|
|
194
|
|
195 }
|
|
196
|
|
197 if (!drop_frame) {
|
|
198 slice_process (picture, code, buffer);
|
|
199 #ifdef ARCH_X86
|
|
200 if (config.flags & MM_ACCEL_X86_MMX) __asm__ __volatile__ ("emms");
|
|
201 #endif
|
|
202 }
|
|
203
|
5145
|
204 }
|
4998
|
205 return mpi;
|
|
206 }
|
|
207
|
5465
|
208 #ifdef USE_SIGJMP_TRICK
|
|
209
|
|
210 static jmp_buf mpeg2_jmp_buf;
|
|
211
|
|
212 static void mpeg2_sighandler(int sig){
|
|
213 longjmp(mpeg2_jmp_buf,1);
|
|
214 }
|
|
215 #endif
|
|
216
|
|
217 // decode a frame
|
|
218 static mp_image_t* decode(sh_video_t *sh,void* data,int len,int flags){
|
|
219 static uint32_t code;
|
|
220 static uint8_t* pos;
|
|
221 static uint8_t* current;
|
|
222 uint8_t* end=data+len;
|
|
223 static mp_image_t* mpi;
|
|
224 mp_image_t* ret=NULL;
|
|
225 int framedrop=flags&3;
|
|
226 void* old_sigh;
|
|
227
|
|
228 // Note: static is REQUIRED because of longjmp() may destroy stack!
|
|
229 pos=NULL;
|
|
230 current=data;
|
|
231 mpi=NULL;
|
|
232
|
|
233 #ifdef USE_SIGJMP_TRICK
|
|
234 old_sigh=signal(SIGSEGV,mpeg2_sighandler);
|
|
235 #endif
|
|
236
|
|
237 while(current<end){
|
|
238 // FIND NEXT HEAD:
|
|
239 static unsigned int head;
|
|
240 static uint8_t c;
|
|
241 head=-1;
|
|
242 //--------------------
|
|
243 while(current<end){
|
|
244 c=current[0];
|
|
245 ++current;
|
|
246 head<<=8;
|
|
247 if(head==0x100) break; // synced
|
|
248 head|=c;
|
|
249 }
|
|
250 //--------------------
|
|
251 if(pos){
|
|
252 #ifdef USE_SIGJMP_TRICK
|
|
253 if(setjmp(mpeg2_jmp_buf)){
|
|
254 #ifdef ARCH_X86
|
|
255 if (config.flags & MM_ACCEL_X86_MMX) __asm__ __volatile__ ("emms");
|
|
256 #endif
|
|
257 printf("@@@ libmpeg2 returned from sig11... (bad file?) @@@\n");
|
|
258 } else
|
|
259 #endif
|
|
260 {
|
|
261 ret=parse_chunk(sh, code&0xFF, pos, framedrop);
|
|
262 if(ret) mpi=ret;
|
|
263 }
|
|
264 }
|
|
265 //--------------------
|
|
266 pos=current;code=head|c;
|
|
267 }
|
|
268
|
|
269 #ifdef USE_SIGJMP_TRICK
|
|
270 signal(SIGSEGV,old_sigh); // restore sighandler
|
|
271 #endif
|
|
272
|
|
273 if(code==0x1FF){
|
|
274 ret=parse_chunk(sh, 0xFF, NULL, framedrop); // send 'end of frame'
|
|
275 if(ret) mpi=ret;
|
|
276 }
|
|
277
|
|
278 return mpi;
|
|
279 }
|