src/ptlib/unix/shmvideo.cxx

   1 /*
   2  * shmvideo.cxx
   3  *
   4  * This file contains the class hierarchy for both shared memory video
   5  * input and output devices.
   6  *
   7  * Copyright (c) 2003 Pai-Hsiang Hsiao
   8  * Copyright (c) 1998-2003 Equivalence Pty. Ltd.
   9  *
  10  * The contents of this file are subject to the Mozilla Public License
  11  * Version 1.0 (the "License"); you may not use this file except in
  12  * compliance with the License. You may obtain a copy of the License at
  13  * http://www.mozilla.org/MPL/
  14  *
  15  * $Log$
  16  * Revision 1.4  2007/05/16 07:54:21  csoutheren
  17  * Fix problems created by gcc 4.2.0
  18  *
  19  * Revision 1.3  2007/04/20 06:34:48  csoutheren
  20  * Fix compilation on MacOSX
  21  *
  22  * Revision 1.2  2007/04/14 07:08:55  rjongbloed
  23  * Major update of video subsystem:
  24  *   Abstracted video frame info (width, height etc) into separate class.
  25  *   Changed devices, converter and video file to use above.
  26  *   Enhanced video file hint detection for frame rate and more
  27  *     flexible formats.
  28  *   Fixed issue if need to convert both colour format and size, had to do
  29  *     colour format first or it didn't convert size.
  30  *   Win32 video output device can be selected by "MSWIN" alone.
  31  *
  32  * Revision 1.1  2006/07/18 05:17:24  csoutheren
  33  * Added shared memory video devices
  34  * Thanks to Hannes Friederich
  35  *
  36  * Revision 1.2  2003/06/12 21:34:13  shawn
  37  * makes code consistent with documentation
  38  *
  39  * Revision 1.1  2003/06/12 19:39:11  shawn
  40  * Added shared memory video input/output devices.  Video frames of these two
  41  * devices are stored in a named shared memory region and can be accessed by
  42  * other applications.
  43  *
  44  *
  45  */
  46
  47 #define P_FORCE_STATIC_PLUGIN
  48
  49 #include <ptlib.h>
  50 #include <ptlib/videoio.h>
  51 #include <ptlib/vconvert.h>
  52 #include <ptlib/unix/ptlib/shmvideo.h>
  53
  54 #ifdef __MACOSX__
  55 namespace PWLibStupidOSXHacks {
  56         int loadShmVideoStuff;
  57 };
  58
  59 #endif
  60
  61 class PColourConverter;
  62
  63 static const char *
  64 ShmKeyFileName()
  65 {
  66   return "/dev/null";
  67 }
  68
  69 BOOL
  70 PVideoOutputDevice_Shm::shmInit()
  71 {
  72   semLock = sem_open(SEM_NAME_OF_OUTPUT_DEVICE,
  73                      O_RDWR, S_IRUSR|S_IWUSR, 0);
  74
  75   if (semLock != (sem_t *)SEM_FAILED) {
  76     shmKey = ftok(ShmKeyFileName(), 0);
  77     if (shmKey >= 0) {
  78       shmId = shmget(shmKey, SHMVIDEO_BUFSIZE, 0666);
  79       if (shmId >= 0) {
  80         shmPtr = shmat(shmId, NULL, 0);
  81         if (shmPtr) {
  82           return TRUE;
  83         }
  84         else {
  85           PTRACE(1, "SHMV\t shmInit can not attach shared memory" << endl);
  86           shmctl(shmId, IPC_RMID, NULL);
  87           sem_close(semLock);
  88         }
  89       }
  90       else {
  91         PTRACE(1, "SHMV\t shmInit can not find the shared memory" << endl);
  92         sem_close(semLock);
  93       }
  94     }
  95     else {
  96       PTRACE(1, "SHMV\t shmInit can not create key for shared memory" << endl);
  97       sem_close(semLock);
  98     }
  99   }
 100   else {
 101     PTRACE(1, "SHMV\t shmInit can not create semaphore" << endl);
 102   }
 103
 104   semLock = (sem_t *)SEM_FAILED;
 105   shmKey = -1;
 106   shmId = -1;
 107   shmPtr = NULL;
 108
 109   return FALSE;
 110 }
 111
 112 PVideoOutputDevice_Shm::PVideoOutputDevice_Shm()
 113 {
 114         colourFormat = "RGB24";
 115         bytesPerPixel = 3;
 116         frameStore.SetSize(frameWidth * frameHeight * bytesPerPixel);
 117
 118   semLock = (sem_t *)SEM_FAILED;
 119   shmKey = -1;
 120   shmId = -1;
 121   shmPtr = NULL;
 122
 123   PTRACE(6, "SHMV\t Constructor of PVideoOutputDevice_Shm");
 124 }
 125
 126 BOOL PVideoOutputDevice_Shm::SetColourFormat(const PString & colourFormat)
 127 {
 128         if( colourFormat == "RGB32")
 129                 bytesPerPixel = 4;
 130         else if(colourFormat == "RGB24")
 131                 bytesPerPixel = 3;
 132         else
 133                 return false;
 134
 135         return PVideoOutputDevice::SetColourFormat(colourFormat) && SetFrameSize(frameWidth, frameHeight);
 136 }
 137
 138 BOOL PVideoOutputDevice_Shm::SetFrameSize(unsigned width, unsigned height)
 139 {
 140         if (!PVideoOutputDevice::SetFrameSize(width, height))
 141                 return FALSE;
 142
 143         return frameStore.SetSize(frameWidth*frameHeight*bytesPerPixel);
 144 }
 145
 146 PINDEX PVideoOutputDevice_Shm::GetMaxFrameBytes()
 147 {
 148         return frameStore.GetSize();
 149 }
 150
 151 BOOL PVideoOutputDevice_Shm::SetFrameData(unsigned x, unsigned y,
 152                                          unsigned width, unsigned height,
 153                                          const BYTE * data,
 154                                          BOOL endFrame)
 155 {
 156         if (x+width > frameWidth || y+height > frameHeight)
 157                 return FALSE;
 158
 159         if (x == 0 && width == frameWidth && y == 0 && height == frameHeight) {
 160                 if (converter != NULL)
 161                         converter->Convert(data, frameStore.GetPointer());
 162                 else
 163                         memcpy(frameStore.GetPointer(), data, height*width*bytesPerPixel);
 164         }
 165         else {
 166                 if (converter != NULL) {
 167                         PAssertAlways("Converted output of partial RGB frame not supported");
 168                         return FALSE;
 169                 }
 170
 171                 if (x == 0 && width == frameWidth)
 172                         memcpy(frameStore.GetPointer() + y*width*bytesPerPixel, data, height*width*bytesPerPixel);
 173                 else {
 174                         for (unsigned dy = 0; dy < height; dy++)
 175                                 memcpy(frameStore.GetPointer() + ((y+dy)*width + x)*bytesPerPixel,
 176                                            data + dy*width*bytesPerPixel, width*bytesPerPixel);
 177                 }
 178         }
 179
 180         if (endFrame)
 181                 return EndFrame();
 182
 183         return TRUE;
 184 }
 185
 186 BOOL
 187 PVideoOutputDevice_Shm::Open(const PString & name,
 188                            BOOL /*startImmediate*/)
 189 {
 190   PTRACE(1, "SHMV\t Open of PVideoOutputDevice_Shm");
 191
 192   Close();
 193
 194   if (shmInit() == TRUE) {
 195     deviceName = name;
 196     return TRUE;
 197   }
 198   else {
 199     return FALSE;
 200   }
 201 }
 202
 203 BOOL
 204 PVideoOutputDevice_Shm::IsOpen()
 205 {
 206   if (semLock != (sem_t *)SEM_FAILED) {
 207     return TRUE;
 208   }
 209   else {
 210     return FALSE;
 211   }
 212 }
 213
 214 BOOL
 215 PVideoOutputDevice_Shm::Close()
 216 {
 217   if (semLock != (sem_t *)SEM_FAILED) {
 218     shmdt(shmPtr);
 219     sem_close(semLock);
 220     shmPtr = NULL;
 221   }
 222   return TRUE;
 223 }
 224
 225 PStringList
 226 PVideoOutputDevice_Shm::GetDeviceNames() const
 227 {
 228   PStringList list;
 229   list += "shm";
 230   return list;
 231 }
 232
 233 BOOL
 234 PVideoOutputDevice_Shm::EndFrame()
 235 {
 236   long *ptr = (long *)shmPtr;
 237
 238   if (semLock == (sem_t *)SEM_FAILED) {
 239     return FALSE;
 240   }
 241
 242   if (bytesPerPixel != 3 && bytesPerPixel != 4) {
 243     PTRACE(1, "SHMV\t EndFrame() does not handle bytesPerPixel!={3,4}"<<endl);
 244     return FALSE;
 245   }
 246
 247   if (frameWidth*frameHeight*bytesPerPixel > SHMVIDEO_FRAMESIZE) {
 248     return FALSE;
 249   }
 250
 251   // write header info so the consumer knows what to expect
 252   ptr[0] = frameWidth;
 253   ptr[1] = frameHeight;
 254   ptr[2] = bytesPerPixel;
 255
 256   PTRACE(1, "writing " << frameStore.GetSize() << " bytes" << endl);
 257   if (memcpy((char *)shmPtr+sizeof(long)*3,
 258              frameStore, frameStore.GetSize()) == NULL) {
 259     return FALSE;
 260   }
 261
 262   sem_post(semLock);
 263
 264   return TRUE;
 265 }
 266
 267 ///////////////////////////////////////////////////////////////////////////////
 268
 269 PCREATE_VIDINPUT_PLUGIN(Shm);
 270
 271 BOOL
 272 PVideoInputDevice_Shm::shmInit()
 273 {
 274   semLock = sem_open(SEM_NAME_OF_INPUT_DEVICE,
 275                      O_RDWR, S_IRUSR|S_IWUSR, 0);
 276
 277   if (semLock != (sem_t *)SEM_FAILED) {
 278     shmKey = ftok(ShmKeyFileName(), 100);
 279     if (shmKey >= 0) {
 280       shmId = shmget(shmKey, SHMVIDEO_BUFSIZE, 0666);
 281       if (shmId >= 0) {
 282         shmPtr = shmat(shmId, NULL, 0);
 283         if (shmPtr) {
 284           return TRUE;
 285         }
 286         else {
 287           PTRACE(1, "SHMV\t shmInit can not attach shared memory" << endl);
 288           shmctl(shmId, IPC_RMID, NULL);
 289           sem_close(semLock);
 290         }
 291       }
 292       else {
 293         PTRACE(1, "SHMV\t shmInit can not find the shared memory" << endl);
 294         sem_close(semLock);
 295       }
 296     }
 297     else {
 298       PTRACE(1, "SHMV\t shmInit can not create key for shared memory" << endl);
 299       sem_close(semLock);
 300     }
 301   }
 302   else {
 303     PTRACE(1, "SHMV\t shmInit can not create semaphore" << endl);
 304   }
 305
 306   semLock = (sem_t *)SEM_FAILED;
 307   shmKey = -1;
 308   shmId = -1;
 309   shmPtr = NULL;
 310
 311   return FALSE;
 312 }
 313
 314 PVideoInputDevice_Shm::PVideoInputDevice_Shm()
 315 {
 316   semLock = (sem_t *)SEM_FAILED;
 317   shmKey = -1;
 318   shmId = -1;
 319   shmPtr = NULL;
 320
 321   PTRACE(4, "SHMV\t Constructor of PVideoInputDevice_Shm");
 322 }
 323
 324 BOOL
 325 PVideoInputDevice_Shm::Open(const PString & name,
 326                           BOOL /*startImmediate*/)
 327 {
 328   PTRACE(1, "SHMV\t Open of PVideoInputDevice_Shm");
 329
 330   Close();
 331
 332   if (shmInit() == TRUE) {
 333     deviceName = name;
 334     return TRUE;
 335   }
 336   else {
 337     return FALSE;
 338   }
 339 }
 340
 341 BOOL
 342 PVideoInputDevice_Shm::IsOpen()
 343 {
 344   if (semLock != (sem_t *)SEM_FAILED) {
 345     return TRUE;
 346   }
 347   else {
 348     return FALSE;
 349   }
 350 }
 351
 352 BOOL
 353 PVideoInputDevice_Shm::Close()
 354 {
 355   if (semLock != (sem_t *)SEM_FAILED) {
 356     shmdt(shmPtr);
 357     sem_close(semLock);
 358     shmPtr = NULL;
 359   }
 360   return TRUE;
 361 }
 362
 363 BOOL PVideoInputDevice_Shm::IsCapturing()
 364 {
 365         return TRUE;
 366 }
 367
 368 PINDEX PVideoInputDevice_Shm::GetMaxFrameBytes()
 369 {
 370         return videoFrameSize;
 371 }
 372
 373 PStringList
 374 PVideoInputDevice_Shm::GetInputDeviceNames()
 375 {
 376   PStringList list;
 377   list += "shm";
 378   return list;
 379 }
 380
 381 BOOL
 382 PVideoInputDevice_Shm::GetFrameSizeLimits(unsigned & minWidth,
 383                                         unsigned & minHeight,
 384                                         unsigned & maxWidth,
 385                                         unsigned & maxHeight)
 386 {
 387   minWidth  = 176;
 388   minHeight = 144;
 389   maxWidth  = 352;
 390   maxHeight =  288;
 391
 392   return TRUE;
 393 }
 394
 395 static void RGBtoYUV420PSameSize (const BYTE *, BYTE *, unsigned, BOOL,
 396                                   int, int);
 397
 398
 399 #define rgbtoyuv(r, g, b, y, u, v) \
 400   y=(BYTE)(((int)30*r  +(int)59*g +(int)11*b)/100); \
 401   u=(BYTE)(((int)-17*r  -(int)33*g +(int)50*b+12800)/100); \
 402   v=(BYTE)(((int)50*r  -(int)42*g -(int)8*b+12800)/100); \
 403
 404
 405
 406 static void RGBtoYUV420PSameSize (const BYTE * rgb,
 407                                   BYTE * yuv,
 408                                   unsigned rgbIncrement,
 409                                   BOOL flip,
 410                                   int srcFrameWidth, int srcFrameHeight)
 411 {
 412   const unsigned planeSize = srcFrameWidth*srcFrameHeight;
 413   const unsigned halfWidth = srcFrameWidth >> 1;
 414
 415   // get pointers to the data
 416   BYTE * yplane  = yuv;
 417   BYTE * uplane  = yuv + planeSize;
 418   BYTE * vplane  = yuv + planeSize + (planeSize >> 2);
 419   const BYTE * rgbIndex = rgb;
 420
 421   for (int y = 0; y < (int) srcFrameHeight; y++) {
 422     BYTE * yline  = yplane + (y * srcFrameWidth);
 423     BYTE * uline  = uplane + ((y >> 1) * halfWidth);
 424     BYTE * vline  = vplane + ((y >> 1) * halfWidth);
 425
 426     if (flip)
 427       rgbIndex = rgb + (srcFrameWidth*(srcFrameHeight-1-y)*rgbIncrement);
 428
 429     for (int x = 0; x < (int) srcFrameWidth; x+=2) {
 430       rgbtoyuv(rgbIndex[0], rgbIndex[1], rgbIndex[2],*yline, *uline, *vline);
 431       rgbIndex += rgbIncrement;
 432       yline++;
 433       rgbtoyuv(rgbIndex[0], rgbIndex[1], rgbIndex[2],*yline, *uline, *vline);
 434       rgbIndex += rgbIncrement;
 435       yline++;
 436       uline++;
 437       vline++;
 438     }
 439   }
 440 }
 441
 442
 443 BOOL PVideoInputDevice_Shm::GetFrame(PBYTEArray & frame)
 444 {
 445         PINDEX returned;
 446         if (!GetFrameData(frame.GetPointer(GetMaxFrameBytes()), &returned))
 447                 return FALSE;
 448
 449         frame.SetSize(returned);
 450         return TRUE;
 451 }
 452
 453 BOOL
 454 PVideoInputDevice_Shm::GetFrameData(BYTE * buffer, PINDEX * bytesReturned)
 455 {
 456   m_pacing.Delay(1000/GetFrameRate());
 457
 458   return GetFrameDataNoDelay(buffer, bytesReturned);
 459 }
 460
 461 BOOL
 462 PVideoInputDevice_Shm::GetFrameDataNoDelay (BYTE *buffer, PINDEX *bytesReturned)
 463 {
 464   long *bufPtr = (long *)shmPtr;
 465
 466   unsigned width = 0;
 467   unsigned height = 0;
 468   unsigned rgbIncrement = 4;
 469
 470   GetFrameSize (width, height);
 471
 472   bufPtr[0] = width;
 473   bufPtr[1] = height;
 474
 475   if (semLock != (sem_t *)SEM_FAILED && sem_trywait(semLock) == 0) {
 476     if (bufPtr[0] == (long)width && bufPtr[1] == (long)height) {
 477       rgbIncrement = bufPtr[2];
 478       RGBtoYUV420PSameSize ((BYTE *)(bufPtr+3), buffer, rgbIncrement, FALSE,
 479                             width, height);
 480
 481           *bytesReturned = videoFrameSize;
 482       return TRUE;
 483     }
 484   }
 485
 486   return FALSE;
 487 }
 488
 489 BOOL PVideoInputDevice_Shm::TestAllFormats()
 490 {
 491         return TRUE;
 492 }
 493
 494 BOOL PVideoInputDevice_Shm::Start()
 495 {
 496         return TRUE;
 497 }
 498
 499 BOOL PVideoInputDevice_Shm::Stop()
 500 {
 501         return TRUE;
 502 }