?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Support chapter seeking with ordered chapters
[mplayer.git] / libmpcodecs / vd_xanim.c
blobeb06eef122007f7425cf1ab02174aa4abcb4ff3a
1 /*
2 XAnim Video Codec DLL support
3
4 It partly emulates the Xanim codebase.
5 You need the -rdynamic flag to use this with gcc.
6
7 (C) 2001-2002 Alex Beregszaszi
8 and Arpad Gereoffy <arpi@thot.banki.hu>
9 */
10
11 #include <stdio.h>
12 #include <stdlib.h>
13 #include <string.h> /* strerror */
14
15 #include "config.h"
16
17 #include "mp_msg.h"
18
19 #include "vd_internal.h"
20
21 static const vd_info_t info = {
22 "XAnim codecs",
23 "xanim",
24 "A'rpi & Alex",
25 "Xanim (http://xanim.va.pubnix.com/)",
26 "binary codec plugins"
27 };
28
29 LIBVD_EXTERN(xanim)
30
31 #ifdef __FreeBSD__
32 #include <unistd.h>
33 #endif
34
35 #include <dlfcn.h> /* dlsym, dlopen, dlclose */
36 #include <stdarg.h> /* va_alist, va_start, va_end */
37 #include <errno.h> /* strerror, errno */
38
39 #include "mp_msg.h"
40 #include "mpbswap.h"
41
42 #include "osdep/timer.h"
43
44 #if 0
45 /* this should be removed */
46 #ifndef RTLD_NOW
47 #define RLTD_NOW 2
48 #endif
49 #ifndef RTLD_LAZY
50 #define RLTD_LAZY 1
51 #endif
52 #ifndef RTLD_GLOBAL
53 #define RLTD_GLOBAL 256
54 #endif
55 #endif
56
57 typedef struct
58 {
59 unsigned int what;
60 unsigned int id;
61 int (*iq_func)(); /* init/query function */
62 unsigned int (*dec_func)(); /* opt decode function */
63 } XAVID_FUNC_HDR;
64
65 #define XAVID_WHAT_NO_MORE 0x0000
66 #define XAVID_AVI_QUERY 0x0001
67 #define XAVID_QT_QUERY 0x0002
68 #define XAVID_DEC_FUNC 0x0100
69
70 #define XAVID_API_REV 0x0003
71
72 typedef struct
73 {
74 unsigned int api_rev;
75 char *desc;
76 char *rev;
77 char *copyright;
78 char *mod_author;
79 char *authors;
80 unsigned int num_funcs;
81 XAVID_FUNC_HDR *funcs;
82 } XAVID_MOD_HDR;
83
84 /* XA CODEC .. */
85 typedef struct
86 {
87 void *anim_hdr;
88 unsigned int compression;
89 unsigned int x, y;
90 unsigned int depth;
91 void *extra;
92 unsigned int xapi_rev;
93 unsigned int (*decoder)();
94 char *description;
95 unsigned int avi_ctab_flag;
96 unsigned int (*avi_read_ext)();
97 } XA_CODEC_HDR;
98
99 #define CODEC_SUPPORTED 1
100 #define CODEC_UNKNOWN 0
101 #define CODEC_UNSUPPORTED -1
102
103 /* fuckin colormap structures for xanim */
104 typedef struct
105 {
106 unsigned short red;
107 unsigned short green;
108 unsigned short blue;
109 unsigned short gray;
110 } ColorReg;
111
112 typedef struct XA_ACTION_STRUCT
113 {
114 int type;
115 int cmap_rev;
116 unsigned char *data;
117 struct XA_ACTION_STRUCT *next;
118 struct XA_CHDR_STRUCT *chdr;
119 ColorReg *h_cmap;
120 unsigned int *map;
121 struct XA_ACTION_STRUCT *next_same_chdr;
122 } XA_ACTION;
123
124 typedef struct XA_CHDR_STRUCT
125 {
126 unsigned int rev;
127 ColorReg *cmap;
128 unsigned int csize, coff;
129 unsigned int *map;
130 unsigned int msize, moff;
131 struct XA_CHDR_STRUCT *next;
132 XA_ACTION *acts;
133 struct XA_CHDR_STRUCT *new_chdr;
134 } XA_CHDR;
135
136 typedef struct
137 {
138 unsigned int cmd;
139 unsigned int skip_flag;
140 unsigned int imagex, imagey; /* image buffer size */
141 unsigned int imaged; /* image depth */
142 XA_CHDR *chdr; /* color map header */
143 unsigned int map_flag;
144 unsigned int *map;
145 unsigned int xs, ys;
146 unsigned int xe, ye;
147 unsigned int special;
148 void *extra;
149 } XA_DEC_INFO;
150
151 typedef struct
152 {
153 unsigned int file_num;
154 unsigned int anim_type;
155 unsigned int imagex;
156 unsigned int imagey;
157 unsigned int imagec;
158 unsigned int imaged;
159 } XA_ANIM_HDR;
160
161 typedef struct {
162 XA_DEC_INFO *decinfo;
163 void *file_handler;
164 long (*iq_func)(XA_CODEC_HDR *codec_hdr);
165 unsigned int (*dec_func)(unsigned char *image, unsigned char *delta,
166 unsigned int dsize, XA_DEC_INFO *dec_info);
167 mp_image_t *mpi;
168 } vd_xanim_ctx;
169
170 #if 0
171 typedef char xaBYTE;
172 typedef short xaSHORT;
173 typedef int xaLONG;
174
175 typedef unsigned char xaUBYTE;
176 typedef unsigned short xaUSHORT;
177 typedef unsigned int xaULONG;
178 #endif
179
180 #define xaFALSE 0
181 #define xaTRUE 1
182
183 #define ACT_DLTA_NORM 0x00000000
184 #define ACT_DLTA_BODY 0x00000001
185 #define ACT_DLTA_XOR 0x00000002
186 #define ACT_DLTA_NOP 0x00000004
187 #define ACT_DLTA_MAPD 0x00000008
188 #define ACT_DLTA_DROP 0x00000010
189 #define ACT_DLTA_BAD 0x80000000
190
191 #define XA_CLOSE_FUNCS 5
192 int xa_close_funcs = 0;
193 void *xa_close_func[XA_CLOSE_FUNCS];
194
195 /* load, init and query */
196 static int xacodec_load(sh_video_t *sh, char *filename)
197 {
198 vd_xanim_ctx *priv = sh->context;
199 void *(*what_the)();
200 char *error;
201 XAVID_MOD_HDR *mod_hdr;
202 XAVID_FUNC_HDR *func;
203 int i;
204
205 // priv->file_handler = dlopen(filename, RTLD_NOW|RTLD_GLOBAL);
206 priv->file_handler = dlopen(filename, RTLD_LAZY);
207 if (!priv->file_handler)
208 {
209 error = dlerror();
210 if (error)
211 mp_msg(MSGT_DECVIDEO, MSGL_FATAL, "xacodec: failed to dlopen %s while %s\n", filename, error);
212 else
213 mp_msg(MSGT_DECVIDEO, MSGL_FATAL, "xacodec: failed to dlopen %s\n", filename);
214 return 0;
215 }
216
217 what_the = dlsym(priv->file_handler, "What_The");
218 if ((error = dlerror()) != NULL)
219 {
220 mp_msg(MSGT_DECVIDEO, MSGL_FATAL, "xacodec: failed to init %s while %s\n", filename, error);
221 dlclose(priv->file_handler);
222 return 0;
223 }
224
225 mod_hdr = what_the();
226 if (!mod_hdr)
227 {
228 mp_msg(MSGT_DECVIDEO, MSGL_FATAL, "xacodec: initializer function failed in %s\n", filename);
229 dlclose(priv->file_handler);
230 return 0;
231 }
232
233 mp_msg(MSGT_DECVIDEO, MSGL_V, "=== XAnim Codec ===\n");
234 mp_msg(MSGT_DECVIDEO, MSGL_V, " Filename: %s (API revision: %x)\n", filename, mod_hdr->api_rev);
235 mp_msg(MSGT_DECVIDEO, MSGL_V, " Codec: %s. Rev: %s\n", mod_hdr->desc, mod_hdr->rev);
236 if (mod_hdr->copyright)
237 mp_msg(MSGT_DECVIDEO, MSGL_V, " %s\n", mod_hdr->copyright);
238 if (mod_hdr->mod_author)
239 mp_msg(MSGT_DECVIDEO, MSGL_V, " Module Author(s): %s\n", mod_hdr->mod_author);
240 if (mod_hdr->authors)
241 mp_msg(MSGT_DECVIDEO, MSGL_V, " Codec Author(s): %s\n", mod_hdr->authors);
242
243 if (mod_hdr->api_rev > XAVID_API_REV)
244 {
245 mp_msg(MSGT_DECVIDEO, MSGL_FATAL, "xacodec: not supported api revision (%d) in %s\n",
246 mod_hdr->api_rev, filename);
247 dlclose(priv->file_handler);
248 return 0;
249 }
250
251 func = mod_hdr->funcs;
252 if (!func)
253 {
254 mp_msg(MSGT_DECVIDEO, MSGL_FATAL, "xacodec: function table error in %s\n", filename);
255 dlclose(priv->file_handler);
256 return 0;
257 }
258
259 mp_msg(MSGT_DECVIDEO, MSGL_DBG2, "Exported functions by codec: [functable: %p entries: %d]\n",
260 mod_hdr->funcs, mod_hdr->num_funcs);
261 for (i = 0; i < (int)mod_hdr->num_funcs; i++)
262 {
263 mp_msg(MSGT_DECVIDEO, MSGL_DBG2, " %d: %d %d [iq:%p d:%p]\n",
264 i, func[i].what, func[i].id, func[i].iq_func, func[i].dec_func);
265 if (func[i].what & XAVID_AVI_QUERY)
266 {
267 mp_msg(MSGT_DECVIDEO, MSGL_DBG2, " %p: avi init/query func (id: %d)\n",
268 func[i].iq_func, func[i].id);
269 priv->iq_func = (void *)func[i].iq_func;
270 }
271 if (func[i].what & XAVID_QT_QUERY)
272 {
273 mp_msg(MSGT_DECVIDEO, MSGL_DBG2, " %p: qt init/query func (id: %d)\n",
274 func[i].iq_func, func[i].id);
275 priv->iq_func = (void *)func[i].iq_func;
276 }
277 if (func[i].what & XAVID_DEC_FUNC)
278 {
279 mp_msg(MSGT_DECVIDEO, MSGL_DBG2, " %p: decoder func (init/query: %p) (id: %d)\n",
280 func[i].dec_func, func[i].iq_func, func[i].id);
281 priv->dec_func = (void *)func[i].dec_func;
282 }
283 }
284 return 1;
285 }
286
287 static int xacodec_query(sh_video_t *sh, XA_CODEC_HDR *codec_hdr)
288 {
289 vd_xanim_ctx *priv = sh->context;
290 long ret;
291
292 #if 0
293 /* the brute one */
294 if (priv->dec_func)
295 {
296 codec_hdr->decoder = priv->dec_func;
297 mp_msg(MSGT_DECVIDEO, MSGL_DBG2, "We got decoder's address at init! %p\n", codec_hdr->decoder);
298 return 1;
299 }
300 #endif
301
302 ret = priv->iq_func(codec_hdr);
303 switch(ret)
304 {
305 case CODEC_SUPPORTED:
306 priv->dec_func = (void *)codec_hdr->decoder;
307 mp_msg(MSGT_DECVIDEO, MSGL_DBG2, "Codec is supported: found decoder for %s at %p\n",
308 codec_hdr->description, codec_hdr->decoder);
309 return 1;
310 case CODEC_UNSUPPORTED:
311 mp_msg(MSGT_DECVIDEO, MSGL_FATAL, "Codec (%s) is unsupported by dll\n",
312 codec_hdr->description);
313 return 0;
314 case CODEC_UNKNOWN:
315 default:
316 mp_msg(MSGT_DECVIDEO, MSGL_FATAL, "Codec (%s) is unknown by dll\n",
317 codec_hdr->description);
318 return 0;
319 }
320 }
321
322 void XA_Print(char *fmt, ...)
323 {
324 va_list vallist;
325 char buf[1024];
326
327 va_start(vallist, fmt);
328 vsnprintf(buf, 1024, fmt, vallist);
329 mp_msg(MSGT_XACODEC, MSGL_DBG2, "[xacodec] %s\n", buf);
330 va_end(vallist);
331
332 return;
333 }
334
335 /* 0 is no debug (needed by 3ivX) */
336 long xa_debug = 0;
337
338 void TheEnd1(char *err_mess)
339 {
340 XA_Print("error: %s - exiting\n", err_mess);
341 /* we should exit here... */
342
343 return;
344 }
345
346 void XA_Add_Func_To_Free_Chain(XA_ANIM_HDR *anim_hdr, void (*function)())
347 {
348 // XA_Print("XA_Add_Func_To_Free_Chain('anim_hdr: %08x', 'function: %08x')",
349 // anim_hdr, function);
350 xa_close_func[xa_close_funcs] = function;
351 if (xa_close_funcs+1 < XA_CLOSE_FUNCS)
352 xa_close_funcs++;
353
354 return;
355 }
356
357
358 unsigned long XA_Time_Read(void)
359 {
360 return GetTimer(); //(GetRelativeTime());
361 }
362
363 void XA_dummy(void)
364 {
365 XA_Print("dummy() called");
366 }
367
368 void XA_Gen_YUV_Tabs(XA_ANIM_HDR *anim_hdr)
369 {
370 XA_Print("XA_Gen_YUV_Tabs('anim_hdr: %08x')", anim_hdr);
371 return;
372 }
373
374 void JPG_Setup_Samp_Limit_Table(XA_ANIM_HDR *anim_hdr)
375 {
376 XA_Print("JPG_Setup_Samp_Limit_Table('anim_hdr: %08x')", anim_hdr);
377 return;
378 }
379
380 void JPG_Alloc_MCU_Bufs(XA_ANIM_HDR *anim_hdr, unsigned int width,
381 unsigned int height, unsigned int full_flag)
382 {
383 XA_Print("JPG_Alloc_MCU_Bufs('anim_hdr: %08x', 'width: %d', 'height: %d', 'full_flag: %d')",
384 anim_hdr, width, height, full_flag);
385 return;
386 }
387
388 /* --------------- 4x4 pixel YUV block fillers [CVID] ----------------- */
389
390 typedef struct
391 {
392 unsigned char r0, g0, b0;
393 unsigned char r1, g1, b1;
394 unsigned char r2, g2, b2;
395 unsigned char r3, g3, b3;
396 unsigned int clr0_0, clr0_1, clr0_2, clr0_3;
397 unsigned int clr1_0, clr1_1, clr1_2, clr1_3;
398 unsigned int clr2_0, clr2_1, clr2_2, clr2_3;
399 unsigned int clr3_0, clr3_1, clr3_2, clr3_3;
400 } XA_2x2_Color;
401
402 #define SET_4_YUV_PIXELS(image,x,y,cmap2x2) \
403 image->planes[0][((x)+0)+((y)+0)*image->stride[0]]=cmap2x2->clr0_0;\
404 image->planes[0][((x)+1)+((y)+0)*image->stride[0]]=cmap2x2->clr0_1;\
405 image->planes[0][((x)+0)+((y)+1)*image->stride[0]]=cmap2x2->clr0_2;\
406 image->planes[0][((x)+1)+((y)+1)*image->stride[0]]=cmap2x2->clr0_3;\
407 image->planes[1][((x)>>1)+((y)>>1)*image->stride[1]]=cmap2x2->clr1_0;\
408 image->planes[2][((x)>>1)+((y)>>1)*image->stride[2]]=cmap2x2->clr1_1;
409
410 void XA_2x2_OUT_1BLK_Convert(unsigned char *image_p, unsigned int x, unsigned int y,
411 unsigned int imagex, XA_2x2_Color *cmap2x2)
412 {
413 mp_image_t *mpi = (mp_image_t *)image_p;
414
415 #if 0
416 SET_4_YUV_PIXELS(mpi,x,y,cmap2x2)
417 #else
418 SET_4_YUV_PIXELS(mpi,x,y,cmap2x2)
419 SET_4_YUV_PIXELS(mpi,x+2,y,cmap2x2)
420 SET_4_YUV_PIXELS(mpi,x,y+2,cmap2x2)
421 SET_4_YUV_PIXELS(mpi,x+2,y+2,cmap2x2)
422 #endif
423
424 return;
425 }
426
427 void XA_2x2_OUT_4BLKS_Convert(unsigned char *image_p, unsigned int x, unsigned int y,
428 unsigned int imagex, XA_2x2_Color *cm0, XA_2x2_Color *cm1, XA_2x2_Color *cm2,
429 XA_2x2_Color *cm3)
430 {
431 mp_image_t *mpi = (mp_image_t *)image_p;
432
433 SET_4_YUV_PIXELS(mpi,x,y,cm0)
434 SET_4_YUV_PIXELS(mpi,x+2,y,cm1)
435 SET_4_YUV_PIXELS(mpi,x,y+2,cm2)
436 SET_4_YUV_PIXELS(mpi,x+2,y+2,cm3)
437 return;
438 }
439
440 void *YUV2x2_Blk_Func(unsigned int image_type, int blks, unsigned int dith_flag)
441 {
442 mp_dbg(MSGT_DECVIDEO,MSGL_DBG2, "YUV2x2_Blk_Func(image_type=%d, blks=%d, dith_flag=%d)\n",
443 image_type, blks, dith_flag);
444 switch(blks){
445 case 1:
446 return (void*) XA_2x2_OUT_1BLK_Convert;
447 case 4:
448 return (void*) XA_2x2_OUT_4BLKS_Convert;
449 }
450
451 mp_msg(MSGT_DECVIDEO,MSGL_WARN,"Unimplemented: YUV2x2_Blk_Func(image_type=%d blks=%d dith=%d)\n",image_type,blks,dith_flag);
452 return (void*) XA_dummy;
453 }
454
455 // Take Four Y's and UV and put them into a 2x2 Color structure.
456
457 void XA_YUV_2x2_clr(XA_2x2_Color *cmap2x2, unsigned int Y0, unsigned int Y1,
458 unsigned int Y2, unsigned int Y3, unsigned int U, unsigned int V,
459 unsigned int map_flag, unsigned int *map, XA_CHDR *chdr)
460 {
461
462 mp_dbg(MSGT_DECVIDEO,MSGL_DBG3, "XA_YUV_2x2_clr(%p [%d,%d,%d,%d][%d][%d] %d %p %p)\n",
463 cmap2x2,Y0,Y1,Y2,Y3,U,V,map_flag,map,chdr);
464
465 cmap2x2->clr0_0=Y0;
466 cmap2x2->clr0_1=Y1;
467 cmap2x2->clr0_2=Y2;
468 cmap2x2->clr0_3=Y3;
469 cmap2x2->clr1_0=U;
470 cmap2x2->clr1_1=V;
471 return;
472 }
473
474 void *YUV2x2_Map_Func(unsigned int image_type, unsigned int dith_type)
475 {
476 mp_dbg(MSGT_DECVIDEO,MSGL_DBG2, "YUV2x2_Map_Func('image_type: %d', 'dith_type: %d')",
477 image_type, dith_type);
478 return (void*)XA_YUV_2x2_clr;
479 }
480
481 /* -------------------- whole YUV frame converters ------------------------- */
482
483 typedef struct
484 {
485 unsigned char *Ybuf;
486 unsigned char *Ubuf;
487 unsigned char *Vbuf;
488 unsigned char *the_buf;
489 unsigned int the_buf_size;
490 unsigned short y_w, y_h;
491 unsigned short uv_w, uv_h;
492 } YUVBufs;
493
494 typedef struct
495 {
496 unsigned long Uskip_mask;
497 long *YUV_Y_tab;
498 long *YUV_UB_tab;
499 long *YUV_VR_tab;
500 long *YUV_UG_tab;
501 long *YUV_VG_tab;
502 } YUVTabs;
503
504 YUVBufs jpg_YUVBufs;
505 YUVTabs def_yuv_tabs;
506
507 /* -------------- YUV 4x4 1x1 1x1 (4:1:0 aka YVU9) [Indeo 3,4,5] ------------------ */
508
509 void XA_YUV1611_Convert(unsigned char *image_p, unsigned int imagex, unsigned int imagey,
510 unsigned int i_x, unsigned int i_y, YUVBufs *yuv, YUVTabs *yuv_tabs,
511 unsigned int map_flag, unsigned int *map, XA_CHDR *chdr)
512 {
513 sh_video_t *sh = (sh_video_t*)image_p;
514 vd_xanim_ctx *priv = sh->context;
515 mp_image_t *mpi;
516 int y;
517 int ystride=(yuv->y_w)?yuv->y_w:imagex;
518 int uvstride=(yuv->uv_w)?yuv->uv_w:(imagex/4);
519
520 mp_dbg(MSGT_DECVIDEO,MSGL_DBG3, "YUVTabs: %d %p %p %p %p %p\n",yuv_tabs->Uskip_mask,
521 yuv_tabs->YUV_Y_tab,
522 yuv_tabs->YUV_UB_tab,
523 yuv_tabs->YUV_VR_tab,
524 yuv_tabs->YUV_UG_tab,
525 yuv_tabs->YUV_VG_tab );
526
527 mp_dbg(MSGT_DECVIDEO,MSGL_DBG3, "XA_YUV1611_Convert('image: %08x', 'imagex: %d', 'imagey: %d', 'i_x: %d', 'i_y: %d', 'yuv_bufs: %08x', 'yuv_tabs: %08x', 'map_flag: %d', 'map: %08x', 'chdr: %08x')",
528 image_p, imagex, imagey, i_x, i_y, yuv, yuv_tabs, map_flag, map, chdr);
529
530 mp_dbg(MSGT_DECVIDEO,MSGL_DBG3, "YUV: %p %p %p %X (%d) %dx%d %dx%d\n",
531 yuv->Ybuf,yuv->Ubuf,yuv->Vbuf,yuv->the_buf,yuv->the_buf_size,
532 yuv->y_w,yuv->y_h,yuv->uv_w,yuv->uv_h);
533
534 if(!yuv_tabs->YUV_Y_tab){
535 // standard YVU9 - simply export it!
536 mpi = mpcodecs_get_image(sh, MP_IMGTYPE_EXPORT, 0,
537 sh->disp_w, sh->disp_h);
538 priv->mpi=mpi; if(!mpi) return; // ERROR!
539 mpi->planes[0]=yuv->Ybuf;
540 mpi->planes[1]=yuv->Ubuf;
541 mpi->planes[2]=yuv->Vbuf;
542 mpi->width=imagex;
543 mpi->stride[0]=ystride; //i_x; // yuv->y_w
544 mpi->stride[1]=mpi->stride[2]=uvstride; //i_x/4; // yuv->uv_w
545 return;
546 }
547
548 // allocate TEMP buffer and convert the image:
549 mpi = mpcodecs_get_image(sh, MP_IMGTYPE_TEMP, MP_IMGFLAG_ACCEPT_STRIDE,
550 sh->disp_w, sh->disp_h);
551 priv->mpi=mpi; if(!mpi) return; // ERROR!
552
553 // convert the Y plane:
554 for(y=0;y<(int)imagey;y++){
555 unsigned int x;
556 unsigned char* s=yuv->Ybuf+ystride*y;
557 unsigned char* d=mpi->planes[0]+mpi->stride[0]*y;
558 for(x=0;x<imagex;x++) d[x]=s[x]<<1;
559 }
560
561 imagex>>=2;
562 imagey>>=2;
563
564 // convert the U plane:
565 for(y=0;y<(int)imagey;y++){
566 unsigned int x;
567 unsigned char* s=yuv->Ubuf+uvstride*y;
568 unsigned char* d=mpi->planes[1]+mpi->stride[1]*y;
569 for(x=0;x<imagex;x++) d[x]=s[x]<<1;
570 }
571
572 // convert the V plane:
573 for(y=0;y<(int)imagey;y++){
574 unsigned int x;
575 unsigned char* s=yuv->Vbuf+uvstride*y;
576 unsigned char* d=mpi->planes[2]+mpi->stride[2]*y;
577 for(x=0;x<imagex;x++) d[x]=s[x]<<1;
578 }
579 }
580
581 void *XA_YUV1611_Func(unsigned int image_type)
582 {
583 mp_dbg(MSGT_DECVIDEO,MSGL_DBG2, "XA_YUV1611_Func('image_type: %d')", image_type);
584 return (void *)XA_YUV1611_Convert;
585 }
586
587 /* --------------- YUV 2x2 1x1 1x1 (4:2:0 aka YV12) [3ivX,H263] ------------ */
588
589 void XA_YUV221111_Convert(unsigned char *image_p, unsigned int imagex, unsigned int imagey,
590 unsigned int i_x, unsigned int i_y, YUVBufs *yuv, YUVTabs *yuv_tabs, unsigned int map_flag,
591 unsigned int *map, XA_CHDR *chdr)
592 {
593 sh_video_t *sh = (sh_video_t*)image_p;
594 vd_xanim_ctx *priv = sh->context;
595 mp_image_t *mpi;
596 // note: 3ivX codec doesn't set y_w, uv_w, they are random junk :(
597 int ystride=imagex; //(yuv->y_w)?yuv->y_w:imagex;
598 int uvstride=imagex/2; //(yuv->uv_w)?yuv->uv_w:(imagex/2);
599
600 mp_dbg(MSGT_DECVIDEO,MSGL_DBG3, "XA_YUV221111_Convert(%p %dx%d %d;%d [%dx%d] %p %p %d %p %p)\n",
601 image_p,imagex,imagey,i_x,i_y, sh->disp_w, sh->disp_h,
602 yuv,yuv_tabs,map_flag,map,chdr);
603
604 mp_dbg(MSGT_DECVIDEO,MSGL_DBG3, "YUV: %p %p %p %X (%X) %Xx%X %Xx%X\n",
605 yuv->Ybuf,yuv->Ubuf,yuv->Vbuf,yuv->the_buf,yuv->the_buf_size,
606 yuv->y_w,yuv->y_h,yuv->uv_w,yuv->uv_h);
607
608 // standard YV12 - simply export it!
609 mpi = mpcodecs_get_image(sh, MP_IMGTYPE_EXPORT, 0, sh->disp_w, sh->disp_h);
610 priv->mpi=mpi; if(!mpi) return; // ERROR!
611 mpi->planes[0]=yuv->Ybuf;
612 mpi->planes[1]=yuv->Ubuf;
613 mpi->planes[2]=yuv->Vbuf;
614 mpi->width=imagex;
615 mpi->stride[0]=ystride; //i_x; // yuv->y_w
616 mpi->stride[1]=mpi->stride[2]=uvstride; //=i_x/4; // yuv->uv_w
617 }
618
619 void *XA_YUV221111_Func(unsigned int image_type)
620 {
621 mp_dbg(MSGT_DECVIDEO,MSGL_DBG2, "XA_YUV221111_Func('image_type: %d')\n",image_type);
622 return (void *)XA_YUV221111_Convert;
623 }
624
625 /* *** EOF XANIM *** */
626
627 // to set/get/query special features/parameters
628 static int control(sh_video_t *sh,int cmd,void* arg,...){
629 return CONTROL_UNKNOWN;
630 }
631
632 // init driver
633 static int init(sh_video_t *sh)
634 {
635 vd_xanim_ctx *priv;
636 char *def_path = XACODEC_PATH;
637 char dll[1024];
638 XA_CODEC_HDR codec_hdr;
639 int i;
640
641 priv = malloc(sizeof(vd_xanim_ctx));
642 if (!priv)
643 return 0;
644 sh->context = priv;
645 memset(priv, 0, sizeof(vd_xanim_ctx));
646
647 if(!mpcodecs_config_vo(sh,sh->disp_w,sh->disp_h,IMGFMT_YV12)) return 0;
648
649 priv->iq_func = NULL;
650 priv->dec_func = NULL;
651
652 for (i=0; i < XA_CLOSE_FUNCS; i++)
653 xa_close_func[i] = NULL;
654
655 if (getenv("XANIM_MOD_DIR"))
656 def_path = getenv("XANIM_MOD_DIR");
657
658 snprintf(dll, 1024, "%s/%s", def_path, sh->codec->dll);
659 if (xacodec_load(sh, dll) == 0)
660 return 0;
661
662 codec_hdr.xapi_rev = XAVID_API_REV;
663 codec_hdr.anim_hdr = malloc(4096);
664 codec_hdr.description = sh->codec->info;
665 codec_hdr.compression = bswap_32(sh->bih->biCompression);
666 codec_hdr.decoder = NULL;
667 codec_hdr.x = sh->bih->biWidth; /* ->disp_w */
668 codec_hdr.y = sh->bih->biHeight; /* ->disp_h */
669 /* extra fields to store palette */
670 codec_hdr.avi_ctab_flag = 0;
671 codec_hdr.avi_read_ext = NULL;
672 codec_hdr.extra = NULL;
673
674 switch(sh->codec->outfmt[sh->outfmtidx])
675 {
676 case IMGFMT_BGR32:
677 codec_hdr.depth = 32;
678 break;
679 case IMGFMT_BGR24:
680 codec_hdr.depth = 24;
681 break;
682 case IMGFMT_IYUV:
683 case IMGFMT_I420:
684 case IMGFMT_YV12:
685 codec_hdr.depth = 12;
686 break;
687 case IMGFMT_YVU9:
688 codec_hdr.depth = 9;
689 break;
690 default:
691 mp_msg(MSGT_DECVIDEO, MSGL_FATAL, "xacodec: not supported image out format (%s)\n",
692 vo_format_name(sh->codec->outfmt[sh->outfmtidx]));
693 return 0;
694 }
695 mp_msg(MSGT_DECVIDEO, MSGL_INFO, "xacodec: querying for input %dx%d %dbit [fourcc: %4x] (%s)...\n",
696 codec_hdr.x, codec_hdr.y, codec_hdr.depth, codec_hdr.compression, codec_hdr.description);
697
698 if (xacodec_query(sh, &codec_hdr) == 0)
699 return 0;
700
701 // free(codec_hdr.anim_hdr);
702
703 priv->decinfo = malloc(sizeof(XA_DEC_INFO));
704 if (priv->decinfo == NULL)
705 {
706 mp_msg(MSGT_DECVIDEO, MSGL_FATAL, "xacodec: memory allocation error: %s\n",
707 strerror(errno));
708 return 0;
709 }
710 priv->decinfo->cmd = 0;
711 priv->decinfo->skip_flag = 0;
712 priv->decinfo->imagex = priv->decinfo->xe = codec_hdr.x;
713 priv->decinfo->imagey = priv->decinfo->ye = codec_hdr.y;
714 priv->decinfo->imaged = codec_hdr.depth;
715 priv->decinfo->chdr = NULL;
716 priv->decinfo->map_flag = 0; /* xaFALSE */
717 priv->decinfo->map = NULL;
718 priv->decinfo->xs = priv->decinfo->ys = 0;
719 priv->decinfo->special = 0;
720 priv->decinfo->extra = codec_hdr.extra;
721 mp_msg(MSGT_DECVIDEO, MSGL_DBG2, "decinfo->extra, filled by codec: %p [%s]\n",
722 &priv->decinfo->extra, (char *)priv->decinfo->extra);
723
724 return 1;
725 }
726
727 // uninit driver
728 static void uninit(sh_video_t *sh)
729 {
730 vd_xanim_ctx *priv = sh->context;
731 int i;
732 void (*close_func)();
733
734 for (i=0; i < XA_CLOSE_FUNCS; i++)
735 if (xa_close_func[i])
736 {
737 close_func = xa_close_func[i];
738 close_func();
739 }
740 dlclose(priv->file_handler);
741 if (priv->decinfo != NULL)
742 free(priv->decinfo);
743 free(priv);
744 }
745
746 // unsigned int (*dec_func)(unsigned char *image, unsigned char *delta,
747 // unsigned int dsize, XA_DEC_INFO *dec_info);
748
749 // decode a frame
750 static mp_image_t* decode(sh_video_t *sh, void *data, int len, int flags)
751 {
752 vd_xanim_ctx *priv = sh->context;
753 unsigned int ret;
754
755 if (len <= 0)
756 return NULL; // skipped frame
757
758 priv->decinfo->skip_flag = (flags&3)?1:0;
759
760 if(sh->codec->outflags[sh->outfmtidx] & CODECS_FLAG_STATIC){
761 // allocate static buffer for cvid-like codecs:
762 priv->mpi = mpcodecs_get_image(sh, MP_IMGTYPE_STATIC,
763 MP_IMGFLAG_ACCEPT_STRIDE|MP_IMGFLAG_PREFER_ALIGNED_STRIDE,
764 (sh->disp_w+3)&(~3), (sh->disp_h+3)&(~3));
765 if (!priv->mpi) return NULL;
766 ret = priv->dec_func((uint8_t*)priv->mpi, data, len, priv->decinfo);
767 } else {
768 // left the buffer allocation to the codecs, pass sh_video && priv
769 priv->mpi=NULL;
770 ret = priv->dec_func((uint8_t*)sh, data, len, priv->decinfo);
771 }
772
773 if (ret == ACT_DLTA_NORM)
774 return priv->mpi;
775
776 if (ret & ACT_DLTA_MAPD)
777 mp_msg(MSGT_DECVIDEO, MSGL_DBG2, "mapd\n");
778 /*
779 if (!(ret & ACT_DLT_MAPD))
780 xacodec_driver->decinfo->map_flag = 0;
781 else
782 {
783 xacodec_driver->decinfo->map_flag = 1;
784 xacodec_driver->decinfo->map = ...
785 }
786 */
787
788 if (ret & ACT_DLTA_XOR)
789 {
790 mp_msg(MSGT_DECVIDEO, MSGL_DBG2, "xor\n");
791 return priv->mpi;
792 }
793
794 /* nothing changed */
795 if (ret & ACT_DLTA_NOP)
796 {
797 mp_msg(MSGT_DECVIDEO, MSGL_DBG2, "nop\n");
798 return NULL;
799 }
800
801 /* frame dropped (also display latest frame) */
802 if (ret & ACT_DLTA_DROP)
803 {
804 mp_msg(MSGT_DECVIDEO, MSGL_DBG2, "drop\n");
805 return NULL;
806 }
807
808 if (ret & ACT_DLTA_BAD)
809 {
810 mp_msg(MSGT_DECVIDEO, MSGL_DBG2, "bad\n");
811 return NULL;
812 }
813
814 /* used for double buffer */
815 if (ret & ACT_DLTA_BODY)
816 {
817 mp_msg(MSGT_DECVIDEO, MSGL_DBG2, "body\n");
818 return NULL;
819 }
820
821 return priv->mpi;
822 }
MPlayer development branch