view.cpp

   1 /* view submodule for rawv
   2  * Copyright (C) 2010,2011  Kirill Smelkov <kirr@navytux.spb.ru>
   3  * Copyright (C) 2011  Marine Bridge and Navigation Systems (http://mns.spb.ru/)
   4  *
   5  * This library is free software: you can Use, Study, Modify and Redistribute
   6  * it under the terms of the GNU Lesser General Public License version 2.1, or
   7  * any later version. This library is distributed WITHOUT ANY WARRANTY. See
   8  * COPYING.LIB file for full License terms.
   9  */
  10
  11 #include "rawv.h"
  12
  13 #include <stdio.h>
  14 #include <SDL.h>
  15 #include "sdlu.h"
  16
  17 using std::min;
  18
  19 namespace rawv {
  20
  21 /******** View ********/
  22
  23 View::View(int width, int height, bool upscale, const char *title)
  24 {
  25     fprintf(stderr, "Viewing w: %i h: %i upscale: %i\n", width, height, upscale);
  26
  27     if (SDL_InitSubSystem(SDL_INIT_VIDEO) < 0)
  28         die("SDL_INIT_VIDEO: %s", SDL_GetError());
  29
  30     display = SDL_SetVideoMode(width, height, /*bpp=*/0, /*flags=*/0UL);
  31     if (!display)
  32         die("SDL_SetVideoMode: %s", SDL_GetError());
  33
  34     if (title)
  35         SDL_WM_SetCaption(title, NULL);
  36
  37     overlay = SDL_CreateYUVOverlay(width, height, SDL_YUY2_OVERLAY, display);
  38     if (!overlay)
  39         die("SDL_CreateYUVOverlay: %s", SDL_GetError());
  40
  41     this->upscale = upscale;
  42
  43 }
  44
  45 View::~View()
  46 {
  47     SDL_FreeYUVOverlay(overlay);
  48     SDL_QuitSubSystem(SDL_INIT_VIDEO);  // XXX needed at all?
  49 }
  50
  51
  52 void View::display_frame(const Frame *f)
  53 {
  54 #if 0
  55         double tstamp = buf->timestamp.tv_sec + 1E-6*buf->timestamp.tv_usec;
  56
  57         fprintf(stderr, "buf[%i]  timestamp: %.7lf  sequence: %u\n", buf->index, tstamp, buf->sequence);
  58 #endif
  59
  60     SDL_Rect rsrc, rdst;
  61     int w, h;
  62     int i, j, istart;
  63     int bt;
  64
  65
  66     w = min(f->width,  overlay->w);
  67     h = min(f->height, overlay->h);
  68
  69     bt = f->interlace_tb_swapped;
  70     if (bt)
  71         /* bt=+1    -> h=2k
  72          * bt=-1    -> h=2k-1
  73          */
  74         h = (h & ~1U) - int((1-bt)/2);
  75
  76     /* for bt=-1, we have to start from 1, for bt=0,+1 - from 0'th line */
  77     istart = 0;
  78     if (bt==-1) {
  79         istart = 1;
  80         bt = -bt;   /* account for i 0->1 move */
  81     }
  82
  83
  84     SDL_LockYUVOverlay(overlay);
  85
  86     switch (f->pixfmt_4cc) {
  87         case MKTAG32('Y','U','Y','V'):
  88         case MKTAG32('Y','U','Y','2'):
  89
  90             if (
  91                 overlay->pitches[0] == f->bytesperline &&
  92                 overlay->w == f->width  && w == f->width &&
  93                 overlay->h == f->height && h == f->height &&
  94                 !bt
  95             )
  96             {
  97                 /* special case for w=w, h=h, fmt=fmt, stride=stride, lines=01234... -- one large memcpy */
  98                 memcpy(overlay->pixels[0], f->start, h*w * /*pixsize_yuy2*/ 2);
  99             }
 100             else {
 101                 for (i=istart; i<h; ++i) {
 102                     memcpy(overlay->pixels[0] + (i+bt)*overlay->pitches[0],
 103                         f->start + i*f->bytesperline,
 104                         w * /*pixsize_yuy2*/ 2);
 105
 106                     bt = -bt;
 107                 }
 108             }
 109
 110             break;
 111
 112         case MKTAG32('U','Y','V','Y'):
 113
 114             /* TODO optimize me through mmx */
 115             for (i=istart; i<h; ++i) {
 116                 __u8 *dst = overlay->pixels[0] + (i+bt)*overlay->pitches[0];
 117                 __u8 *src = f->start + i*f->bytesperline;
 118
 119                 for (j=0; j<w/2; j++) {
 120                     /* YUYV <- UYVY */
 121                     dst[0] = src[1];
 122                     dst[1] = src[0];
 123                     dst[2] = src[3];
 124                     dst[3] = src[2];
 125
 126                     dst += 4;
 127                     src += 4;
 128                 }
 129
 130                 bt = -bt;
 131             }
 132
 133             break;
 134
 135         case MKTAG32('Y','8','0','0'):
 136         case MKTAG32('Y','8',' ',' '):
 137         case MKTAG32('G','R','E','Y'):
 138
 139             for (i=istart; i<h; ++i) {
 140                 __u8 *dst = overlay->pixels[0] + (i+bt)*overlay->pitches[0];
 141                 __u8 *src = f->start + i*f->bytesperline;
 142
 143                 for (j=0; j<w; ++j) {
 144                     dst[0] = src[0];
 145                     dst[1] = 0x80;  /* 0-level for Cb/Cr */
 146
 147                     dst += 2;
 148                     src += 1;
 149                 }
 150
 151                 bt = -bt;
 152             }
 153
 154             break;
 155
 156         default:
 157             die("view: W: unsupported pixfmt 0x%08x", f->pixfmt_4cc);
 158     }
 159
 160
 161
 162     SDL_UnlockYUVOverlay(overlay);
 163
 164     /* blit overlay to its associated surface */
 165     rsrc.x = 0;
 166     rsrc.y = 0;
 167     rsrc.w = w;
 168     rsrc.h = h;
 169
 170     rdst.x = 0;
 171     rdst.y = 0;
 172
 173     if (!upscale) {
 174         rdst.w = w;
 175         rdst.h = h;
 176     }
 177     else {
 178         double ratio_w = (double)overlay->w / (w ? w : 1);
 179         double ratio_h = (double)overlay->h / (h ? h : 1);
 180
 181         /* keep aspect ratio */
 182         double ratio = min(ratio_w, ratio_h);
 183
 184         rdst.w = w * ratio;
 185         rdst.h = h * ratio;
 186
 187         /* center picture */
 188         rdst.x = w * (ratio_w - ratio) / 2;
 189         rdst.y = h * (ratio_h - ratio) / 2;
 190     }
 191
 192     SDLU_DisplayYUVOverlay(overlay, &rsrc, &rdst);
 193 }
 194
 195
 196 void View::__display_frame(const Frame *f, void *self)
 197 {
 198     ((View *)self)->display_frame(f);
 199 }
 200
 201
 202 }   // rawv::