libvo/vo_zr.c

   1 /*
   2  * vo_zr.c - playback on zoran cards
   3  * Copyright (C) Rik Snel 2001,2002, License GNU GPL v2
   4  */
   5
   6 /* $Id$ */
   7
   8 #include <stdio.h>
   9 #include <stdlib.h>
  10 #include <string.h>
  11 #include <unistd.h>
  12 #include <fcntl.h>
  13 #include <errno.h>
  14 #include <sys/stat.h>
  15 #include <sys/types.h>
  16 #include <sys/time.h>
  17 #include <sys/mman.h>
  18 #include <sys/ioctl.h>
  19 #include <linux/types.h>
  20 #include <linux/videodev.h>
  21 #include "videodev_mjpeg.h"
  22
  23 #include "config.h"
  24
  25 #include "video_out.h"
  26 #include "video_out_internal.h"
  27 #include "mp_msg.h"
  28 #include "m_option.h"
  29 #include "fastmemcpy.h"
  30
  31 #include "jpeg_enc.h"
  32
  33 static vo_info_t info =
  34 {
  35         "Zoran ZR360[56]7/ZR36060 Driver (DC10(+)/buz/lml33/MatroxRR)",
  36         "zr",
  37         "Rik Snel <rsnel@cube.dyndns.org>",
  38         ""
  39 };
  40
  41 LIBVO_EXTERN (zr)
  42
  43 #define ZR_MAX_DEVICES 4
  44 /* General variables */
  45
  46 typedef struct {
  47         int width;
  48         int height;
  49         int xoff;
  50         int yoff;
  51         int set;
  52 } geo_t;
  53
  54 static int zr_count = 1;
  55 static int zr_parsing = 0;
  56 static int framenum;
  57
  58 typedef struct {
  59         /* commandline args given for this device (and defaults) */
  60         int vdec, hdec;         /* requested decimation 1,2,4 */
  61         int fd;                 /* force decimation */
  62         int xdoff, ydoff;       /* offset from upperleft of screen
  63                                  * default is 'centered' */
  64         int quality;            /* jpeg quality 1=best, 20=bad */
  65         geo_t g;                /* view window (zrcrop) */
  66         char *device;           /* /dev/video1 */
  67         int bw;                 /* if bw == 1, display in black&white */
  68         int norm;               /* PAL/NTSC */
  69
  70         /* buffers + pointers + info */
  71
  72         unsigned char *image;
  73         int image_width, image_height, size;
  74         int off_y, off_c, stride;    /* for use by 'draw slice/frame' */
  75
  76         unsigned char *buf;   /* the jpeg images will be placed here */
  77         jpeg_enc_t *j;
  78         unsigned char *y_data, *u_data, *v_data; /* used by the jpeg encoder */
  79         int y_stride, u_stride, v_stride; /* these point somewhere in image */
  80
  81         /* information for (and about) the zoran card */
  82
  83         int vdes;                       /* file descriptor of card */
  84         int frame, synco, queue;        /* buffer management */
  85         struct mjpeg_sync zs;           /* state information */
  86         struct mjpeg_params p;
  87         struct mjpeg_requestbuffers zrq;
  88         struct video_capability vc;     /* max resolution and so on */
  89         int fields, stretchy; /* must the *image be interlaced
  90                                            or stretched to fit on the screen? */
  91 } zr_info_t;
  92
  93 static zr_info_t zr_info[ZR_MAX_DEVICES] = {
  94         {1, 1, 1, -1, -1, 2, {0, 0, 0, 0, 0}, NULL, 0, VIDEO_MODE_AUTO, NULL, 0, 0, 0, 0, 0,
  95         0, NULL, NULL, NULL, NULL, NULL, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
  96         {1, 1, 1, -1, -1, 2, {0, 0, 0, 0, 0}, NULL, 0, VIDEO_MODE_AUTO, NULL, 0, 0, 0, 0, 0,
  97         0, NULL, NULL, NULL, NULL, NULL, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
  98         {1, 1, 1, -1, -1, 2, {0, 0, 0, 0, 0}, NULL, 0, VIDEO_MODE_AUTO, NULL, 0, 0, 0, 0, 0,
  99         0, NULL, NULL, NULL, NULL, NULL, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
 100         {1, 1, 1, -1, -1, 2, {0, 0, 0, 0, 0}, NULL, 0, VIDEO_MODE_AUTO, NULL, 0, 0, 0, 0, 0,
 101         0, NULL, NULL, NULL, NULL, NULL, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}};
 102
 103
 104
 105
 106 #define MJPEG_NBUFFERS  2
 107 #define MJPEG_SIZE      1024*256
 108
 109
 110 int zoran_getcap(zr_info_t *zr) {
 111         char* dev = NULL;
 112
 113         if (zr->device)
 114                 dev = zr->device;
 115         else {
 116                 struct stat vstat;
 117                 const char *devs[] = {
 118                     "/dev/video",
 119                     "/dev/video0",
 120                     "/dev/v4l/video0",
 121                     "/dev/v4l0",
 122                     "/dev/v4l",
 123                     NULL
 124                 };
 125                 int i = 0;
 126
 127                 do
 128                 {
 129                     if ((stat(devs[i], &vstat) == 0) && S_ISCHR(vstat.st_mode))
 130                     {
 131                         dev = devs[i];
 132                         mp_msg(MSGT_VO, MSGL_V, "zr: found video device %s\n", dev);
 133                         break;
 134                     }
 135                 } while (devs[++i] != NULL);
 136
 137                 if (!dev)
 138                 {
 139                     mp_msg(MSGT_VO, MSGL_ERR, "zr: unable to find video device\n");
 140                     return 1;
 141                 }
 142         }
 143
 144         zr->vdes = open(dev, O_RDWR);
 145
 146         if (zr->vdes < 0) {
 147                 mp_msg(MSGT_VO, MSGL_ERR, "zr: error opening %s: %s\n",
 148                        dev, strerror(errno));
 149                 return 1;
 150         }
 151
 152         /* before we can ask for the maximum resolution, we must set
 153          * the correct tv norm */
 154
 155         if (ioctl(zr->vdes, MJPIOC_G_PARAMS, &zr->p) < 0) {
 156                 mp_msg(MSGT_VO, MSGL_ERR, "zr: device at %s is probably not a DC10(+)/buz/lml33\n", dev);
 157                 return 1;
 158         }
 159
 160         if (zr->p.norm != zr->norm && zr->norm != VIDEO_MODE_AUTO) {
 161                 /* attempt to set requested norm */
 162                 zr->p.norm = zr->norm;
 163                 if (ioctl(zr->vdes, MJPIOC_S_PARAMS, &zr->p) < 0) {
 164                         mp_msg(MSGT_VO, MSGL_ERR,
 165                                 "zr: unable to change video norm, use another program to change it (XawTV)\n");
 166                         return 1;
 167                 }
 168                 ioctl(zr->vdes, MJPIOC_G_PARAMS, &zr->p);
 169                 if (zr->norm != zr->p.norm) {
 170                         mp_msg(MSGT_VO, MSGL_ERR,
 171                                 "zr: unable to change video norm, use another program to change it (XawTV)\n");
 172                         return 1;
 173                 }
 174         }
 175
 176         if (ioctl(zr->vdes, VIDIOCGCAP, &zr->vc) < 0) {
 177                 mp_msg(MSGT_VO, MSGL_ERR, "zr: error getting video capabilities from %s\n", dev);
 178                 return 1;
 179         }
 180         mp_msg(MSGT_VO, MSGL_V, "zr: MJPEG card reports maxwidth=%d, maxheight=%d\n", zr->vc.maxwidth, zr->vc.maxheight);
 181
 182         return 0;
 183 }
 184
 185 int init_zoran(zr_info_t *zr, int stretchx, int stretchy) {
 186         /* center the image, and stretch it as far as possible (try to keep
 187          * aspect) and check if it fits */
 188         if (zr->image_width > zr->vc.maxwidth) {
 189                 mp_msg(MSGT_VO, MSGL_ERR, "zr: movie to be played is too wide, max width currently %d\n", zr->vc.maxwidth);
 190                 return 1;
 191         }
 192
 193         if (zr->image_height > zr->vc.maxheight) {
 194                 mp_msg(MSGT_VO, MSGL_ERR, "zr: movie to be played is too high, max height currently %d\n", zr->vc.maxheight);
 195                 return 1;
 196         }
 197
 198         zr->p.decimation = 0;
 199         zr->p.HorDcm = stretchx;
 200         zr->p.VerDcm = stretchy;
 201         zr->p.TmpDcm = 1;
 202         zr->p.field_per_buff = zr->fields;
 203         if (zr->xdoff == -1) {
 204                 zr->p.img_x = (zr->vc.maxwidth -
 205                                 zr->p.HorDcm*(int)zr->image_width/zr->hdec)/2;
 206         } else {
 207                 zr->p.img_x = zr->xdoff;
 208         }
 209         if (zr->ydoff == -1) {
 210                 zr->p.img_y = (zr->vc.maxheight - zr->p.VerDcm*
 211                                 (3-zr->fields)*(int)zr->image_height)/4;
 212         } else {
 213                 zr->p.img_y = zr->ydoff;
 214         }
 215         zr->p.img_width = zr->p.HorDcm*zr->image_width/zr->hdec;
 216         zr->p.img_height = zr->p.VerDcm*zr->image_height/zr->fields;
 217         mp_msg(MSGT_VO, MSGL_V, "zr: geometry (after 'scaling'): %dx%d+%d+%d fields=%d, w=%d, h=%d\n", zr->p.img_width, (3-zr->fields)*zr->p.img_height, zr->p.img_x, zr->p.img_y, zr->fields, zr->image_width/zr->hdec, zr->image_height);
 218
 219         if (ioctl(zr->vdes, MJPIOC_S_PARAMS, &zr->p) < 0) {
 220                 mp_msg(MSGT_VO, MSGL_ERR, "zr: error setting display parameters\n");
 221                 return 1;
 222         }
 223
 224         zr->zrq.count = MJPEG_NBUFFERS;
 225         zr->zrq.size = MJPEG_SIZE;
 226
 227         if (ioctl(zr->vdes, MJPIOC_REQBUFS, &zr->zrq)) {
 228                 mp_msg(MSGT_VO, MSGL_ERR, "zr: error requesting %d buffers of size %d\n", zr->zrq.count, zr->zrq.size);
 229                 return 1;
 230         }
 231
 232         /* the buffer count allocated may be different to the request */
 233         zr->buf = (unsigned char*)mmap(0, zr->zrq.count*zr->zrq.size,
 234                         PROT_READ|PROT_WRITE, MAP_SHARED, zr->vdes, 0);
 235
 236         if (zr->buf == MAP_FAILED) {
 237                 mp_msg(MSGT_VO, MSGL_ERR, "zr: error requesting %d buffers of size %d\n", zr->zrq.count, zr->zrq.size);
 238                 return 1;
 239         }
 240
 241         mp_msg(MSGT_VO, MSGL_V, "zr: got %d buffers of size %d (wanted %d buffers of size %d)\n", zr->zrq.count, zr->zrq.size, MJPEG_NBUFFERS, MJPEG_SIZE);
 242         if (zr->zrq.count < MJPEG_NBUFFERS) {
 243                 mp_msg(MSGT_VO, MSGL_V, "zr: got not enough buffers\n");
 244                 return 1;
 245         }
 246
 247         zr->queue = 0;
 248         zr->synco = 0;
 249
 250         return 0;
 251 }
 252
 253 void uninit_zoran(zr_info_t *zr) {
 254         if (zr->image) {
 255                 free(zr->image);
 256                 zr->image=NULL;
 257         }
 258         while (zr->queue > zr->synco + 1) {
 259                 if (ioctl(zr->vdes, MJPIOC_SYNC, &zr->zs) < 0)
 260                         mp_msg(MSGT_VO, MSGL_ERR, "zr: error waiting for buffers to become free\n");
 261                 zr->synco++;
 262         }
 263         /* stop streaming */
 264         zr->frame = -1;
 265         if (ioctl(zr->vdes, MJPIOC_QBUF_PLAY, &zr->frame) < 0)
 266                 mp_msg(MSGT_VO, MSGL_ERR, "zr: error stopping playback of last frame\n");
 267         if (munmap(zr->buf,zr->zrq.count*zr->zrq.size))
 268            mp_msg(MSGT_VO, MSGL_ERR, "zr: error unmapping buffer\n");
 269         close(zr->vdes);
 270 }
 271
 272 int zr_geometry_sane(geo_t *g, unsigned int width, unsigned int height) {
 273         if (g->set) {
 274                 if (g->width%2 != 0 || g->height%2 != 0 ||
 275                                 g->xoff%2 != 0 || g->yoff%2 != 0) {
 276                         mp_msg(MSGT_VO, MSGL_ERR, "zr: arguments in -zrcrop must be multiples of 2\n");
 277                         return 1;
 278                 }
 279                 if (g->width <= 0 || g->height <= 0 ||
 280                                 g->xoff < 0 || g->yoff < 0) {
 281                         mp_msg(MSGT_VO, MSGL_ERR, "zr: width and height must be positive and offset nonnegative\n");
 282                         return 1;
 283                 }
 284                 if (g->width + g->xoff > width) {
 285                         mp_msg(MSGT_VO, MSGL_ERR, "zr: width+xoffset (%d+%d>%d) is too big\n", g->width, g->xoff, width);
 286                         return 1;
 287                 }
 288                 if (g->height + g->yoff > height) {
 289                         mp_msg(MSGT_VO, MSGL_ERR, "zr: height+yoffset (%d+%d>%d) is too big\n", g->height, g->yoff, height);
 290                         return 1;
 291                 }
 292         } else {
 293                 g->width = width;
 294                 g->height = height;
 295                 g->xoff = 0;
 296                 g->yoff = 0;
 297                 g->set = 1;
 298         }
 299         return 0;
 300 }
 301
 302
 303 static int config(uint32_t width, uint32_t height, uint32_t d_width,
 304         uint32_t d_height, uint32_t flags, char *title, uint32_t format)
 305 {
 306         int i, tmp, stretchx, stretchy;
 307         framenum = 0;
 308         if (format != IMGFMT_YV12 && format != IMGFMT_YUY2) {
 309                 printf("vo_zr called with wrong format");
 310                 return 1;
 311         }
 312         for (i = 0; i < zr_count; i++) {
 313                 zr_info_t *zr = &zr_info[i];
 314                 geo_t *g = &zr->g;
 315
 316                 zr->stride = 2*width;
 317                 if (zr_geometry_sane(g, width, height)) return 1;
 318
 319                 /* we must know the maximum resolution of the device
 320                  * it differs for DC10+ and buz for example */
 321                 zoran_getcap(zr); /*must be called before init_zoran */
 322                 /* make the scaling decision
 323                  * we are capable of stretching the image in the horizontal
 324                  * direction by factors 1, 2 and 4
 325                  * we can stretch the image in the vertical direction by a
 326                  * factor of 1 and 2 AND we must decide about interlacing */
 327                 if (g->width > zr->vc.maxwidth/2 ||
 328                                 g->height > zr->vc.maxheight/2) {
 329                         stretchx = 1;
 330                         stretchy = 1;
 331                         zr->fields = 2;
 332                         if (zr->vdec == 2) {
 333                                 zr->fields = 1;
 334                         } else if (zr->vdec == 4) {
 335                                 zr->fields = 1;
 336                                 stretchy = 2;
 337                         }
 338                         stretchx = zr->hdec;
 339                 } else if (g->width > zr->vc.maxwidth/4 ||
 340                                 g->height > zr->vc.maxheight/4) {
 341                         stretchx = 2;
 342                         stretchy = 1;
 343                         zr->fields = 1;
 344                         if (zr->vdec == 2) {
 345                                 stretchy = 2;
 346                         } else if (zr->vdec == 4) {
 347                                 if (!zr->fd) {
 348                                         mp_msg(MSGT_VO, MSGL_WARN, "zr: vertical decimation too high, changing to 2 (use -zrfd to keep vdec=4)\n");
 349                                         zr->vdec = 2;
 350                                 }
 351                                 stretchy = 2;
 352                         }
 353                         if (zr->hdec == 2) {
 354                                 stretchx = 4;
 355                         } else if (zr->hdec == 4){
 356                                 if (!zr->fd) {
 357                                         mp_msg(MSGT_VO, MSGL_WARN, "zr: horizontal decimation too high, changing to 2 (use -zrfd to keep hdec=4)\n");
 358                                         zr->hdec = 2;
 359                                 }
 360                                 stretchx = 4;
 361                         }
 362                 } else {
 363                         /* output image is maximally stretched */
 364                         stretchx = 4;
 365                         stretchy = 2;
 366                         zr->fields = 1;
 367                         if (zr->vdec != 1 && !zr->fd) {
 368                                 mp_msg(MSGT_VO, MSGL_WARN, "zr: vertical decimation too high, changing to 1 (use -zrfd to keep vdec=%d)\n", zr->vdec);
 369                                 zr->vdec = 1;
 370                         }
 371                         if (zr->hdec != 1 && !zr->fd) {
 372                                 mp_msg(MSGT_VO, MSGL_WARN, "zr: vertical decimation too high, changing to 1 (use -zrfd to keep hdec=%d)\n", zr->hdec);
 373                                 zr->hdec = 1;
 374                         }
 375                 }
 376                 /* It can be that the original frame was too big for display,
 377                  * or that the width of the decimated image (for example) after
 378                  * padding up to a multiple of 16 has become too big. (orig
 379                  * width 720 (exactly right for the Buz) after decimation 360,
 380                  * after padding up to a multiple of 16 368, display 736 -> too
 381                  * large). In these situations we auto(re)crop. */
 382                 tmp = 16*((g->width - 1)/(zr->hdec*16) + 1);
 383                 if (stretchx*tmp > zr->vc.maxwidth) {
 384                         g->xoff += 2*((g->width - zr->hdec*(tmp-16))/4);
 385                         /* g->off must be a multiple of 2 */
 386                         g->width = zr->hdec*(tmp - 16);
 387                         g->set = 0; /* we abuse this field to
 388                                        report that g has changed*/
 389                 }
 390                 tmp = 8*zr->fields*((g->height - 1)/(zr->vdec*zr->fields*8)+1);
 391                 if (stretchy*tmp > zr->vc.maxheight) {
 392                         g->yoff += 2*((g->height - zr->vdec*
 393                                                 (tmp - 8*zr->fields))/4);
 394                         g->height = zr->vdec*(tmp - 8*zr->fields);
 395                         g->set = 0;
 396                 }
 397                 if (!g->set)
 398                         mp_msg(MSGT_VO, MSGL_V, "zr: auto(re)cropping %dx%d+%d+%d to make the image fit on the screen\n", g->width, g->height, g->xoff, g->yoff);
 399
 400                 /* the height must be a multiple of fields*8 and the width
 401                  * must be a multiple of 16 */
 402                 /* add some black borders to make it so, and center the image*/
 403                 zr->image_height = zr->fields*8*((g->height/zr->vdec - 1)/
 404                                 (zr->fields*8) + 1);
 405                 zr->image_width = (zr->hdec*16)*((g->width - 1)/(zr->hdec*16) + 1);
 406                 zr->off_y = (zr->image_height - g->height/zr->vdec)/2;
 407                 if (zr->off_y%2 != 0) zr->off_y++;
 408                 zr->off_y *= zr->image_width;
 409                 zr->off_c = zr->off_y/4;
 410                 zr->off_y += (zr->image_width - g->width)/2;
 411                 if (zr->off_y%2 != 0) zr->off_y--;
 412                 zr->off_c += (zr->image_width - g->width)/4;
 413                 zr->size = zr->image_width*zr->image_height;
 414                 mp_msg(MSGT_VO, MSGL_V, "zr: input: %dx%d, cropped: %dx%d, output: %dx%d, off_y=%d, off_c=%d\n", width, height, g->width, g->height, zr->image_width, zr->image_height, zr->off_y, zr->off_c);
 415
 416                 zr->image = malloc(2*zr->size); /* this buffer allows for YUV422 data,
 417                                          * so it is a bit too big for YUV420 */
 418                 if (!zr->image) {
 419                         mp_msg(MSGT_VO, MSGL_ERR, "zr: Memory exhausted\n");
 420                         return 1;
 421                 }
 422                 /* and make sure that the borders are _really_ black */
 423                 switch (format) {
 424                         case IMGFMT_YV12:
 425                                 memset(zr->image, 0, zr->size);
 426                                 memset(zr->image + zr->size, 0x80, zr->size/4);
 427                                 memset(zr->image + 3*zr->size/2, 0x80, zr->size/4);
 428                                 zr->y_data = zr->image;
 429                                 zr->u_data = zr->image + zr->size;
 430                                 zr->v_data = zr->image + 3*zr->size/2;
 431
 432                                 zr->y_stride = zr->image_width;
 433                                 zr->u_stride = zr->image_width/2;
 434                                 zr->v_stride = zr->image_width/2;
 435
 436                                 zr->j = jpeg_enc_init(zr->image_width/zr->hdec,
 437                                                 zr->image_height/zr->fields,
 438                                                 zr->hdec, zr->y_stride*zr->fields,
 439                                                 zr->hdec, zr->u_stride*zr->fields,
 440                                                 zr->hdec, zr->v_stride*zr->fields,
 441                                                 1, zr->quality, zr->bw);
 442                                 break;
 443                         case IMGFMT_YUY2:
 444                                 for (tmp = 0; tmp < 2*zr->size; tmp+=4) {
 445                                         zr->image[tmp] = 0;
 446                                         zr->image[tmp+1] = 0x80;
 447                                         zr->image[tmp+2] = 0;
 448                                         zr->image[tmp+3] = 0x80;
 449                                 }
 450
 451                                 zr->y_data = zr->image;
 452                                 zr->u_data = zr->image + 1;
 453                                 zr->v_data = zr->image + 3;
 454
 455                                 zr->y_stride = 2*zr->image_width;
 456                                 zr->u_stride = 2*zr->image_width;
 457                                 zr->v_stride = 2*zr->image_width;
 458
 459                                 zr->j = jpeg_enc_init(zr->image_width/zr->hdec,
 460                                                 zr->image_height/zr->fields,
 461                                                 zr->hdec*2,
 462                                                 zr->y_stride*zr->fields,
 463                                                 zr->hdec*4,
 464                                                 zr->u_stride*zr->fields,
 465                                                 zr->hdec*4,
 466                                                 zr->v_stride*zr->fields,
 467                                                 0, zr->quality, zr->bw);
 468                                 break;
 469                         default:
 470                                 mp_msg(MSGT_VO, MSGL_FATAL, "zr: internal inconsistency in vo_zr\n");
 471                 }
 472
 473
 474                 if (zr->j == NULL) {
 475                         mp_msg(MSGT_VO, MSGL_ERR, "zr: error initializing the jpeg encoder\n");
 476                         return 1;
 477                 }
 478
 479                 if (init_zoran(zr, stretchx, stretchy)) {
 480                         return 1;
 481                 }
 482
 483         }
 484         return 0;
 485 }
 486
 487 static void draw_osd(void) {
 488 }
 489
 490 static void flip_page (void) {
 491         int i, j, k;
 492         //FILE *fp;
 493         //char filename[100];
 494         /* do we have a free buffer? */
 495         for (j = 0; j < zr_count; j++) {
 496                 zr_info_t *zr = &zr_info[j];
 497                 /* using MJPEG_NBUFFERS here, using the real number of
 498                  * buffers may give sync issues (real number of buffers
 499                  * is always sufficient) */
 500                 if (zr->queue-zr->synco < MJPEG_NBUFFERS) {
 501                         zr->frame = zr->queue;
 502                 } else {
 503                         if (ioctl(zr->vdes, MJPIOC_SYNC, &zr->zs) < 0)
 504                                 mp_msg(MSGT_VO, MSGL_ERR, "zr: error waiting for buffers to become free\n");
 505                         zr->frame = zr->zs.frame;
 506                         zr->synco++;
 507                 }
 508                 k=0;
 509                 for (i = 0; i < zr->fields; i++)
 510                         k+=jpeg_enc_frame(zr->j, zr->y_data + i*zr->y_stride,
 511                                         zr->u_data + i*zr->u_stride,
 512                                         zr->v_data + i*zr->v_stride,
 513                                         zr->buf + zr->frame*zr->zrq.size+k);
 514                 if (k > zr->zrq.size) mp_msg(MSGT_VO, MSGL_WARN, "zr: jpeg image too large for maximum buffer size. Lower the jpeg encoding\nquality or the resolution of the movie.\n");
 515         }
 516         /* Warning: Only the first jpeg image contains huffman- and
 517          * quantisation tables, so don't expect files other than
 518          * test0001.jpg to be readable */
 519         /*sprintf(filename, "test%04d.jpg", framenum);
 520         fp = fopen(filename, "w");
 521         if (!fp) exit(1);
 522         fwrite(buf+frame*zrq.size, 1, k, fp);
 523         fclose(fp);*/
 524         /*fp = fopen("test1.jpg", "r");
 525         fread(buf+frame*zrq.size, 1, 2126, fp);
 526         fclose(fp);*/
 527
 528         for (j = 0; j < zr_count; j++) {
 529                 zr_info_t *zr = &zr_info[j];
 530                 if (ioctl(zr->vdes, MJPIOC_QBUF_PLAY, &zr->frame) < 0)
 531                         mp_msg(MSGT_VO, MSGL_ERR, "zr: error queueing buffer for playback\n");
 532                 zr->queue++;
 533         }
 534
 535         framenum++;
 536         return;
 537 }
 538
 539 static int draw_frame(uint8_t * src[]) {
 540         int i, j;
 541         char *source, *dest;
 542         //printf("draw frame called\n");
 543         for (j = 0; j < zr_count; j++) {
 544                 zr_info_t *zr = &zr_info[j];
 545                 geo_t *g = &zr->g;
 546                 source = src[0] + 2*g->yoff*zr->vdec*zr->stride + 2*g->xoff;
 547                 dest = zr->image + 2*zr->off_y;
 548                 for (i = 0; i < g->height/zr->vdec; i++) {
 549                         fast_memcpy(dest, source, zr->image_width*2);
 550                         dest += 2*zr->image_width;
 551                         source += zr->vdec*zr->stride;
 552                 }
 553         }
 554         return 0;
 555 }
 556
 557 static int query_format(uint32_t format) {
 558         if(format==IMGFMT_YV12 || format==IMGFMT_YUY2)
 559             return VFCAP_CSP_SUPPORTED|VFCAP_CSP_SUPPORTED_BY_HW;
 560         return 0;
 561 }
 562
 563 static void uninit(void) {
 564         int j;
 565         mp_msg(MSGT_VO, MSGL_V, "zr: uninit called\n");
 566         for (j = 0; j < zr_count; j++) {
 567                 jpeg_enc_uninit(zr_info[j].j);
 568                 uninit_zoran(&zr_info[j]);
 569         }
 570 }
 571
 572 static void check_events(void) {
 573 }
 574
 575
 576 static int draw_slice(uint8_t *srcimg[], int stride[],
 577                 int wf, int hf, int xf, int yf) {
 578         int i, j, w, h, x, y;
 579         /* Apply 'geometry', crop unwanted parts */
 580         uint8_t *dst;
 581         //printf("before: w=%d, h=%d, x=%d, y=%d, src0=%p, src1=%p, src2=%p\n", w, h, x, y, srcimg[0], srcimg[1], srcimg[2]);
 582         for (j = 0; j < zr_count; j++) {
 583                 uint8_t *src=srcimg[0];
 584                 uint8_t *src1=srcimg[1];
 585                 uint8_t *src2=srcimg[2];
 586                 zr_info_t *zr = &zr_info[j];
 587                 geo_t *g = &zr->g;
 588                 w = wf; h = hf; x = xf; y = yf;
 589                 if (x < g->xoff) {
 590                         src += g->xoff - x;
 591                         src1 += (g->xoff - x)/2;
 592                         src2 += (g->xoff - x)/2;
 593                         w -= g->xoff - x;
 594                         if (w < 0) break; //return 0;
 595                         x = 0 /*g.xoff*/;
 596                 } else {
 597                         x -= g->xoff;
 598                 }
 599                 if (x + w > g->width) {
 600                         w = g->width - x;
 601                         if (w < 0) break; //return 0;
 602                 }
 603                 if (y < g->yoff) {
 604                         src += (g->yoff - y)*stride[0];
 605                         src1 += ((g->yoff - y)/2)*stride[1];
 606                         src2 += ((g->yoff - y)/2)*stride[2];
 607                         h -= g->yoff - y;
 608                         if (h < 0) break; //return 0;
 609                         y = 0;
 610                 } else {
 611                         y -= g->yoff;
 612                 }
 613                 if (y + h > g->height) {
 614                         h = g->height - y;
 615                         if (h < 0) break; //return 0;
 616                 }
 617                 //printf("after: w=%d, h=%d, x=%d, y=%d, src0=%p, src1=%p, src2=%p\n", w, h, x, y, srcimg[0], srcimg[1], srcimg[2]);
 618                 dst=zr->image + zr->off_y + zr->image_width*(y/zr->vdec)+x;
 619                 // copy Y:
 620                 for (i = 0; i < h; i++) {
 621                         if ((i + x)%zr->vdec == 0) {
 622                                 fast_memcpy(dst,src,w);
 623                                 dst+=zr->image_width;
 624                         }
 625                         src+=stride[0];
 626
 627                 }
 628                 if (!zr->bw) {
 629                         // copy U+V:
 630                         uint8_t *dst1=zr->image + zr->size + zr->off_c+ (y/(zr->vdec*2))*zr->image_width/2+(x/2);
 631                         uint8_t *dst2=zr->image + 3*zr->size/2 + zr->off_c +
 632                                         (y/(zr->vdec*2))*
 633                                         zr->image_width/2+(x/2);
 634                         for (i = 0; i< h/2; i++) {
 635                                 if ((i+x/2)%zr->vdec == 0) {
 636                                         fast_memcpy(dst1,src1,w/2);
 637                                         fast_memcpy(dst2,src2,w/2);
 638                                         dst1+=zr->image_width/2;
 639                                         dst2+=zr->image_width/2;
 640                                 }
 641                                 src1+=stride[1];
 642                                 src2+=stride[2];
 643                         }
 644                 }
 645         }
 646         return 0;
 647 }
 648
 649
 650 /* copied and adapted from vo_aa_parseoption */
 651 int
 652 vo_zr_parseoption(m_option_t* conf, char *opt, char *param){
 653     /* got an option starting with zr */
 654     zr_info_t *zr = &zr_info[zr_parsing];
 655     int i;
 656     /* do WE need it ?, always */
 657     if (!strcasecmp(opt, "zrdev")) {
 658         if (param == NULL) return ERR_MISSING_PARAM;
 659         //if ((i=getcolor(param))==-1) return ERR_OUT_OF_RANGE;
 660         //aaopt_osdcolor=i;
 661         free(zr->device);
 662         zr->device = malloc(strlen(param)+1);
 663         strcpy(zr->device, param);
 664         mp_msg(MSGT_VO, MSGL_V, "zr: using device %s\n", zr->device);
 665         return 1;
 666     } else if (!strcasecmp(opt, "zrbw")) {
 667             if (param != NULL) {
 668                     return ERR_OUT_OF_RANGE;
 669             }
 670             zr->bw = 1;
 671             return 1;
 672     } else if (!strcasecmp(opt, "zrfd")) {
 673             if (param != NULL) {
 674                     return ERR_OUT_OF_RANGE;
 675             }
 676             zr->fd = 1;
 677             return 1;
 678     } else if (!strcasecmp(opt, "zrcrop")){
 679         geo_t *g = &zr->g;
 680         if (g->set == 1) {
 681                 zr_parsing++;
 682                 zr_count++;
 683                 zr = &zr_info[zr_parsing];
 684                 g = &zr->g;
 685                 if (zr_count > 4) {
 686                         mp_msg(MSGT_VO, MSGL_ERR, "zr: too many simultaneus display devices requested (max. is 4)\n");
 687                         return ERR_OUT_OF_RANGE;
 688                 }
 689         }
 690         if (param == NULL) return ERR_MISSING_PARAM;
 691         if (sscanf(param, "%dx%d+%d+%d", &g->width, &g->height,
 692                                 &g->xoff, &g->yoff) != 4) {
 693                 g->xoff = 0; g->yoff = 0;
 694                 if (sscanf(param, "%dx%d", &g->width, &g->height) != 2) {
 695                         mp_msg(MSGT_VO, MSGL_ERR, "zr: argument to -zrcrop must be of the form 352x288+16+0\n");
 696                         return ERR_OUT_OF_RANGE;
 697                 }
 698         }
 699         g->set = 1;
 700         mp_msg(MSGT_VO, MSGL_V, "zr: cropping %s\n", param);
 701         return 1;
 702     }else if (!strcasecmp(opt, "zrhdec")) {
 703         i = atoi(param);
 704         if (i != 1 && i != 2 && i != 4) return ERR_OUT_OF_RANGE;
 705         zr->hdec = i;
 706         return 1;
 707     }else if (!strcasecmp(opt, "zrvdec")) {
 708         i = atoi(param);
 709         if (i != 1 && i != 2 && i != 4) return ERR_OUT_OF_RANGE;
 710         zr->vdec = i;
 711         return 1;
 712     }else if (!strcasecmp(opt, "zrxdoff")) {
 713         i = atoi(param);
 714         zr->xdoff = i;
 715         return 1;
 716     }else if (!strcasecmp(opt, "zrydoff")) {
 717         i = atoi(param);
 718         zr->ydoff = i;
 719         return 1;
 720     }else if (!strcasecmp(opt, "zrquality")) {
 721         i = atoi(param);
 722         if (i < 1 || i > 20) return ERR_OUT_OF_RANGE;
 723         zr->quality = i;
 724         return 1;
 725     }else if (!strcasecmp(opt, "zrnorm")) {
 726         if (param == NULL) return ERR_MISSING_PARAM;
 727         if (!strcasecmp(param, "NTSC")) {
 728             mp_msg(MSGT_VO, MSGL_V, "zr: Norm set to NTSC\n");
 729             zr->norm = VIDEO_MODE_NTSC;
 730             return 1;
 731         } else if (!strcasecmp(param, "PAL")) {
 732             mp_msg(MSGT_VO, MSGL_V, "zr: Norm set to PAL\n");
 733             zr->norm = VIDEO_MODE_PAL;
 734             return 1;
 735         } else {
 736            return ERR_OUT_OF_RANGE;
 737         }
 738     }else if (!strcasecmp(opt, "zrhelp")){
 739         printf("Help for -vo zr: Zoran ZR360[56]7/ZR36060 based MJPEG capture/playback cards\n");
 740         printf("\n");
 741         printf("Here are the zr options:\n");
 742         printf(
 743                     "\n"
 744                     "  -zrcrop     specify part of the input image that\n"
 745                     "              you want to see as an x-style geometry string\n"
 746                     "              example: -zrcrop 352x288+16+0\n"
 747                     "  -zrvdec     vertical decimation 1, 2 or 4\n"
 748                     "  -zrhdec     horizontal decimation 1, 2 or 4\n"
 749                     "  -zrfd       decimation is only done if the primitive\n"
 750                     "              hardware upscaler can correct for the decimation,\n"
 751                     "              this switch allows you to see the effects\n"
 752                     "              of too much decimation\n"
 753                     "  -zrbw       display in black&white (speed increase)\n"
 754                     "  -zrxdoff    x offset from upper-left of TV screen (default is 'centered')\n"
 755                     "  -zrydoff    y offset from upper-left of TV screen (default is 'centered')\n"
 756                     "  -zrquality  jpeg compression quality [BEST] 1 - 20 [VERY BAD]\n"
 757                     "  -zrdev      playback device (example -zrdev /dev/video1)\n"
 758                     "  -zrnorm     specify norm PAL/NTSC (default: leave at current setting)\n"
 759                     "\n"
 760                     "Cinerama support: additional occurances of -zrcrop activate cinerama mode,\n"
 761                     "suppose you have a 704x272 movie, two DC10+ cards and two beamers (or tv's),\n"
 762                     "then you would issue the following command:\n\n"
 763                     "mplayer -vo zr -zrcrop 352x272+0+0 -zrdev /dev/video0 -zrcrop 352x272+352+0 \\\n"
 764                     "       -zrdev /dev/video1 movie.avi\n\n"
 765                     "Options appearing after the second -zrcrop apply to the second card, it is\n"
 766                     "possible to dispay at a different jpeg quality or at different decimations.\n\n"
 767                     "The parameters -zrxdoff and -zrydoff can be used to align the two images.\n"
 768                     "The maximum number of zoran cards participating in cinerama is 4, so you can\n"
 769                     "build a 2x2 vidiwall. (untested for obvious reasons, the setup wit a buz and\n"
 770                     "a DC10+ (and no beamers) is tested, however)\n"
 771               );
 772         exit(0);
 773
 774     }
 775     return ERR_NOT_AN_OPTION;
 776 }
 777
 778 void vo_zr_revertoption(m_option_t* opt,char* param) {
 779
 780   zr_info_t *zr = &zr_info[1];
 781   zr_count = 1;
 782   zr_parsing = 0;
 783
 784   if (!strcasecmp(param, "zrdev")) {
 785     if(zr->device)
 786       free(zr->device);
 787     zr->device=NULL;
 788   } else if (!strcasecmp(param, "zrbw"))
 789     zr->bw=0;
 790   else if (!strcasecmp(param, "zrfd"))
 791     zr->fd=0;
 792   else if (!strcasecmp(param, "zrcrop"))
 793     zr->g.set = zr->g.xoff = zr->g.yoff = 0;
 794   else if (!strcasecmp(param, "zrhdec"))
 795     zr->hdec = 1;
 796   else if (!strcasecmp(param, "zrvdec"))
 797     zr->vdec = 1;
 798   else if (!strcasecmp(param, "zrxdoff"))
 799     zr->xdoff = -1;
 800   else if (!strcasecmp(param, "zrydoff"))
 801     zr->ydoff = -1;
 802   else if (!strcasecmp(param, "zrquality"))
 803     zr->quality = 2;
 804   else if (!strcasecmp(param, "zrnorm"))
 805     zr->norm = VIDEO_MODE_AUTO;
 806
 807 }
 808
 809 static int preinit(const char *arg)
 810 {
 811     if(arg)
 812     {
 813         printf("vo_zr: Unknown subdevice: %s\n",arg);
 814         return ENOSYS;
 815     }
 816     return 0;
 817 }
 818
 819 static int control(uint32_t request, void *data, ...)
 820 {
 821   switch (request) {
 822   case VOCTRL_QUERY_FORMAT:
 823     return query_format(*((uint32_t*)data));
 824   }
 825   return VO_NOTIMPL;
 826 }