Changeset 4364

Show
Ignore:
Timestamp:
01/25/09 02:44:54 (6 years ago)
Author:
douglask
Message:

set_size_cif() was incorrectly being used with codecs that are not restricted to CIF & QCIF capture resolutions.

Also, due to widescreen resolutions, set_size_cif() was getting confused in setting outh_ & outw_. It now discriminates based on input height rather than input width.

Location:
vic/branches/mpeg4
Files:
10 modified

Legend:

Unmodified
Added
Removed
  • vic/branches/mpeg4/tcl/ui-ctrlmenu.tcl

    r4311 r4364  
    639639        } 
    640640        if [inList 420 $formats] { 
    641                 set fmtList "$fmtList bvc pvh" 
     641                set fmtList "$fmtList bvc pvh h261as h264 mpeg4" 
    642642        } 
    643643        if [inList cif $sizes] { 
    644                 set fmtList "$fmtList h261 h261as h263+ h263 mpeg4 h264" 
     644                set fmtList "$fmtList h261 h263 h263+" 
    645645        } 
    646646        if [inList jpeg $formats] { 
  • vic/branches/mpeg4/tcl/ui-util.tcl

    r4042 r4364  
    9393proc isCIF fmt { 
    9494        # only supported CIF format is h.261/3/3+ 
    95         if { $fmt =="h264" || $fmt == "mpeg4" || $fmt == "h261" || $fmt == "h263+" || $fmt == "h263" } { 
     95        if { $fmt == "h261" || $fmt == "h263" || $fmt == "h263+" } { 
    9696                return 1 
    9797        } 
  • vic/branches/mpeg4/video/grabber-bttv.cpp

    r4311 r4364  
    143143 
    144144  if(!strcmp(cformat, "422")) cformat_ = CF_422; 
     145  if(!strcmp(cformat, "420")) cformat_ = CF_420; 
    145146  if(!strcmp(cformat, "cif")) cformat_ = CF_CIF; 
    146147 
     
    363364    set_size_422(basewidth_ / decimate_, baseheight_ / decimate_); 
    364365    break; 
     366  case CF_420: 
     367    set_size_420(basewidth_ / decimate_, baseheight_ / decimate_); 
     368    break; 
    365369  case CF_CIF: 
    366     set_size_420(basewidth_ / decimate_, baseheight_ / decimate_); 
     370    set_size_cif(basewidth_ / decimate_, baseheight_ / decimate_); 
    367371    break; 
    368372  } 
  • vic/branches/mpeg4/video/grabber-plx.cpp

    r4311 r4364  
    517517        converter_ = RGB_Converter_420::instance(); 
    518518        image_ = StandardVideoImage::allocate(capwin_->tkwin(), w, h); 
    519         set_size_420(w, h); 
     519        set_size_cif(w, h); 
    520520        allocref(); 
    521521} 
  • vic/branches/mpeg4/video/grabber-v4l2.cpp

    r4346 r4364  
    269269                } 
    270270 
    271                 if (capability.capabilities & V4L2_CAP_VIDEO_CAPTURE == 0) { 
     271                if ((capability.capabilities & V4L2_CAP_VIDEO_CAPTURE) == 0) { 
    272272                        debug_msg("%s, %s can't capture\n",capability.card,capability.bus_info); 
    273273                        v4l2_close(fd); 
     
    369369                fmt.fmt.pix.pixelformat = V4L2_PIX_FMT_YUV420; 
    370370                if (-1 != v4l2_ioctl(fd_, VIDIOC_S_FMT, &fmt) ) { 
    371                         if (fmt.fmt.pix.height == test_height[i] && fmt.fmt.pix.width == test_width[i] && fmt.fmt.pix.pixelformat == V4L2_PIX_FMT_YUV420) { 
     371                        if (fmt.fmt.pix.height == test_height[i] && fmt.fmt.pix.width >= test_width[i] && fmt.fmt.pix.pixelformat == V4L2_PIX_FMT_YUV420) { 
    372372                                have_YUV420P = 1; 
    373373                                debug_msg("Device supports V4L2_PIX_FMT_YUV420 capture at %dx%d\n",test_width[i],test_height[i]); 
     
    381381                fmt.fmt.pix.pixelformat = V4L2_PIX_FMT_YUV422P; 
    382382                if (-1 != v4l2_ioctl(fd_, VIDIOC_S_FMT, &fmt) ) { 
    383                         if (fmt.fmt.pix.height == test_height[i] && fmt.fmt.pix.width == test_width[i] && fmt.fmt.pix.pixelformat == V4L2_PIX_FMT_YUV422P) { 
     383                        if (fmt.fmt.pix.height == test_height[i] && fmt.fmt.pix.width >= test_width[i] && fmt.fmt.pix.pixelformat == V4L2_PIX_FMT_YUV422P) { 
    384384                                have_YUV422P = 1; 
    385385                                debug_msg("Device supports V4L2_PIX_FMT_YUV422 capture at %dx%d\n",test_width[i],test_height[i]); 
     
    393393                fmt.fmt.pix.pixelformat = V4L2_PIX_FMT_YUYV; 
    394394                if (-1 != v4l2_ioctl(fd_, VIDIOC_S_FMT, &fmt) ) { 
    395                         if (fmt.fmt.pix.height == test_height[i] && fmt.fmt.pix.width == test_width[i]) { 
     395                        if (fmt.fmt.pix.height == test_height[i] && fmt.fmt.pix.width >= test_width[i]) { 
    396396                                have_YUV422 = 1; 
    397397                                debug_msg("Device supports V4L2_PIX_FMT_YUYV (YUV 4:2:2) capture at %dx%d\n",test_width[i],test_height[i]); 
     
    406406                fmt.fmt.pix.pixelformat = V4L2_PIX_FMT_MJPEG; 
    407407                if (-1 != v4l2_ioctl(fd_, VIDIOC_S_FMT, &fmt) ) { 
    408                         if (fmt.fmt.pix.height == test_height[i] && fmt.fmt.pix.width == test_width[i] && fmt.fmt.pix.pixelformat == V4L2_PIX_FMT_MJPEG) { 
     408                        if (fmt.fmt.pix.height == test_height[i] && fmt.fmt.pix.width >= test_width[i] && fmt.fmt.pix.pixelformat == V4L2_PIX_FMT_MJPEG) { 
    409409                                have_MJPEG = 1; 
    410410                                debug_msg("Device supports V4L2_PIX_FMT_MJPEG capture at %dx%d\n",test_width[i],test_height[i]); 
     
    418418                fmt.fmt.pix.pixelformat = V4L2_PIX_FMT_JPEG; 
    419419                if (-1 != v4l2_ioctl(fd_, VIDIOC_S_FMT, &fmt) ) { 
    420                         if (fmt.fmt.pix.height == test_height[i] && fmt.fmt.pix.width == test_width[i] && fmt.fmt.pix.pixelformat == V4L2_PIX_FMT_JPEG) { 
     420                        if (fmt.fmt.pix.height == test_height[i] && fmt.fmt.pix.width >= test_width[i] && fmt.fmt.pix.pixelformat == V4L2_PIX_FMT_JPEG) { 
    421421                                have_MJPEG = 1; 
    422422                                debug_msg("Device supports V4L2_PIX_FMT_JPEG capture at %dx%d\n",test_width[i],test_height[i]); 
     
    712712                tempbuf.type = vimage[0].vidbuf.type; 
    713713                while ((err = v4l2_ioctl(fd_, VIDIOC_DQBUF, &tempbuf)) < 0 && 
    714                        (errno == EINTR)); 
     714                       (errno == EINTR)) ; 
    715715 
    716716                if (err < 0) { 
     
    893893                switch (cformat_) { 
    894894                case CF_CIF: 
    895                         set_size_420(width_, height_); 
     895                        set_size_cif(width_, height_); 
    896896                        debug_msg(" cif\n"); 
    897897                        break; 
     
    945945                                                debug_msg("\nV4L2: Failed to set format\n"); 
    946946 
    947                                         if ( ( fmt.fmt.pix.width != (unsigned int)width_ ) || 
    948                                                                 ( fmt.fmt.pix.height !=  (unsigned int)height_ ) ) { 
     947                                        if ( fmt.fmt.pix.width > (unsigned int)width_ ) 
     948                                                inw_ = width_ = fmt.fmt.pix.width; 
     949 
     950 
     951                                        if ( ( fmt.fmt.pix.width == (unsigned int)width_ ) || 
     952                                                                ( fmt.fmt.pix.height == (unsigned int)height_ ) )  { 
     953                                                debug_msg("V4L2: setting format: width=%d height=%d\n", fmt.fmt.pix.width, fmt.fmt.pix.height); 
     954                                                format_ok = 1; 
     955                                                break; 
     956                                        } else { 
    949957 
    950958                                                debug_msg("V4L2: failed to set format! requested %dx%d, got %dx%d\n", width_, height_, fmt.fmt.pix.width, fmt.fmt.pix.height); 
     
    10281036                                                        } 
    10291037                                                        break; 
    1030  
    10311038                                                } 
    1032  
    1033                                         } else { 
    1034                                                 debug_msg("V4L2: setting format: width=%d height=%d\n", fmt.fmt.pix.width, fmt.fmt.pix.height); 
    1035                                                 format_ok = 1; 
    10361039                                        } 
    1037                                         break; 
    10381040                                } 
    1039  
    10401041                        } 
    10411042                } 
  • vic/branches/mpeg4/video/grabber-video4linux.cpp

    r4311 r4364  
    984984    switch (cformat_) { 
    985985    case CF_CIF: 
    986         set_size_420(width_, height_); 
     986        set_size_cif(width_, height_); 
    987987        debug_msg(" cif"); 
    988988        break; 
  • vic/branches/mpeg4/video/grabber-win32.cpp

    r4311 r4364  
    6464        Miro_dc20_NT, 
    6565        AV_Master, 
    66     Intel_SVR3, 
     66        Intel_SVR3, 
    6767}; 
    6868 
     
    101101                debug_msg("Device=ISVR III\n"); 
    102102                return (Intel_SVR3); 
    103     } 
     103        } 
     104 
    104105        debug_msg("Device=Generic: %s\n", deviceName); 
    105106        return (Generic); 
     
    210211                return; 
    211212 
    212         if (ICDecompress(hIC_, 0, &bihIn_, in, &bihOut_, rgb_) != ICERR_OK) 
     213        if (ICDecompress(hIC_, 0, &bihIn_, in, &bihOut_, rgb_) != ICERR_OK) 
    213214                debug_msg("ICDecompress failed!\n"); 
    214215 
     
    360361 
    361362        HANDLE                  frame_sem_; 
    362     HANDLE          cb_mutex_; 
     363        HANDLE                  cb_mutex_; 
    363364        LPBYTE                  last_frame_; 
    364365        Converter               *converter_; 
     
    374375        VfwCIFGrabber(const int dev); 
    375376        ~VfwCIFGrabber(); 
     377 protected: 
     378        virtual void start(); 
     379        virtual void setsize(); 
     380}; 
     381 
     382class Vfw420Grabber : public VfwGrabber  
     383{ 
     384 public: 
     385        Vfw420Grabber(const int dev); 
     386        ~Vfw420Grabber(); 
    376387 protected: 
    377388        virtual void start(); 
     
    417428         
    418429        for (int index = 0 ; index < n; index++) { 
    419                 if (capGetDriverDescription(index, 
     430                if (capGetDriverDescription(index, 
    420431                                            (LPSTR)deviceName, 
    421432                                            sizeof(deviceName), 
     
    424435                        debug_msg("Adding device %d\n", index); 
    425436                        devs_[index] = new VfwDevice(strdup(deviceName), index); 
    426                 } else 
     437                } else 
    427438                        devs_[index] = NULL; 
    428439        } 
     
    448459                switch (get_device_type(name)) { 
    449460                case gray_QuickCam_95: 
    450                         attributes_ = "format { 422 420 } size { small cif } port { QuickCam } "; 
     461                        attributes_ = "format { 422 420 cif } size { small cif } port { QuickCam } "; 
    451462                        break; 
    452463                case Generic: 
    453464                default: 
    454                         attributes_ = "format { 422 420 } size { large small cif } port { external-in } "; 
     465                        attributes_ = "format { 422 420 cif } size { large small cif } port { external-in } "; 
    455466                        break; 
    456467                } 
     
    478489                if (strcmp(argv[2], "422") == 0) 
    479490                        o = grabber_ = new Vfw422Grabber(vfwdev_); 
     491                if (strcmp(argv[2], "420") == 0) 
     492                        o = grabber_ = new Vfw420Grabber(vfwdev_); 
    480493                else if (strcmp(argv[2], "cif") == 0) 
    481494                        o = grabber_ = new VfwCIFGrabber(vfwdev_); 
     
    542555} 
    543556 
     557void VfwCIFGrabber::setsize() 
     558{ 
     559        int w = basewidth_ / decimate_; 
     560        int h = baseheight_ / decimate_; 
     561        debug_msg("VfwCIFGrabber::setsize: %dx%d\n", w, h); 
     562        set_size_cif(w, h); 
     563        allocref(); 
     564} 
     565 
     566Vfw420Grabber::Vfw420Grabber(const int dev) : VfwGrabber(dev) 
     567{ 
     568        debug_msg("Vfw420Grabber\n"); 
     569} 
     570 
     571Vfw420Grabber::~Vfw420Grabber() 
     572{ 
     573        debug_msg("~Vfw420Grabber\n"); 
     574} 
     575 
     576void Vfw420Grabber::setsize() 
     577{ 
     578        int w = basewidth_ / decimate_; 
     579        int h = baseheight_ / decimate_; 
     580        debug_msg("Vfw420Grabber::setsize: %dx%d\n", w, h); 
     581        set_size_420(w, h); 
     582        allocref(); 
     583} 
     584 
    544585Vfw422Grabber::Vfw422Grabber(const int dev) : VfwGrabber(dev) 
    545586{ 
     
    557598        debug_msg("Vfw422Grabber::setsize: %dx%d\n", w, h); 
    558599        set_size_422(w, h); 
    559         allocref(); 
    560 } 
    561  
    562 void VfwCIFGrabber::setsize() 
    563 { 
    564         int w = basewidth_ / decimate_; 
    565         int h = baseheight_ / decimate_; 
    566         debug_msg("VfwCIFGrabber::setsize: %dx%d\n", w, h); 
    567         set_size_cif(w, h); 
    568600        allocref(); 
    569601} 
     
    618650        } 
    619651 
    620     /* lock out VideoHandler until everything is set up - cmg */ 
    621     cb_mutex_ = CreateMutex(NULL,FALSE,NULL); 
    622     WaitForSingleObject(cb_mutex_,INFINITE); 
     652        /* lock out VideoHandler until everything is set up - cmg */ 
     653        cb_mutex_ = CreateMutex(NULL,FALSE,NULL); 
     654        WaitForSingleObject(cb_mutex_,INFINITE); 
    623655 
    624656        if ((capwin_ = capCreateCaptureWindow((LPSTR)"Capture Window", WS_POPUP | WS_CAPTION, 
     
    685717        case Miro_dc20_NT: 
    686718        case AV_Master: 
    687     case Generic: 
    688                 if (useconfig_) { 
     719        case Generic: 
     720                if (useconfig_) { 
    689721                        if (caps_.fHasDlgVideoFormat) capDlgVideoFormat(capwin_); 
    690722                        if (caps_.fHasDlgVideoSource) capDlgVideoSource(capwin_); 
     
    693725                fmtsize_ = capGetVideoFormatSize(capwin_); 
    694726                fmt_ = (LPBITMAPINFOHEADER) new u_char [fmtsize_]; 
    695             capGetVideoFormat(capwin_, fmt_, fmtsize_); 
     727                capGetVideoFormat(capwin_, fmt_, fmtsize_); 
    696728                break; 
    697729        case Intel_SVR3: 
     
    887919                break; 
    888920        } 
    889     /* allow video handler callback to progress */ 
    890     ReleaseMutex(cb_mutex_); 
    891     Grabber::timeout(); 
     921        /* allow video handler callback to progress */ 
     922        ReleaseMutex(cb_mutex_); 
     923        Grabber::timeout(); 
     924} 
     925 
     926 
     927void Vfw420Grabber::start() 
     928{ 
     929        VfwGrabber::start(); 
     930        switch (fmt_->biCompression) { 
     931        case BI_RGB: 
     932                converter(new RGB_Converter_420(fmt_->biBitCount, (u_int8_t *)(fmt_ + 1), fmt_->biClrUsed)); 
     933                break; 
     934        case mmioFOURCC('Y','U','Y','V'): 
     935                converter(new YUYV_Converter_420()); 
     936                break; 
     937        default: 
     938                converter(new IC_Converter_420(fmt_->biCompression, fmt_->biBitCount, fmt_->biWidth, fmt_->biHeight)); 
     939                break; 
     940        } 
     941        /* allow video handler callback to progress */ 
     942        ReleaseMutex(cb_mutex_); 
     943        Grabber::timeout(); 
    892944} 
    893945 
     
    908960            } 
    909961        } 
    910     /* allow video handler callback to progress */ 
    911     ReleaseMutex(cb_mutex_); 
    912     Grabber::timeout(); 
     962        /* allow video handler callback to progress */ 
     963        ReleaseMutex(cb_mutex_); 
     964        Grabber::timeout(); 
    913965} 
    914966 
    915967void VfwGrabber::stop() 
    916968{ 
    917     debug_msg("VfwWindow::stop() thread=%x\n", GetCurrentThreadId()); 
    918  
    919     if (cb_mutex_!=NULL) { 
    920         CloseHandle(cb_mutex_); 
    921         cb_mutex_=0; 
    922     } else  
    923         return; 
    924  
    925     if (capturing_) 
    926         capCaptureStop(capwin_); 
    927     /* ensure this won't be called */ 
    928     capSetCallbackOnVideoStream(capwin_, NULL); 
    929     capturing_ = 0; 
    930     capture_=0; 
    931     if (frame_sem_!=0 ) { 
    932         ReleaseSemaphore(frame_sem_, 1, NULL); 
    933         CloseHandle(frame_sem_); 
    934     } 
     969        debug_msg("VfwWindow::stop() thread=%x\n", GetCurrentThreadId()); 
     970 
     971        if (cb_mutex_!=NULL) { 
     972                CloseHandle(cb_mutex_); 
     973                cb_mutex_=0; 
     974        } else  
     975                return; 
     976 
     977        if (capturing_) 
     978                capCaptureStop(capwin_); 
     979        /* ensure this won't be called */ 
     980        capSetCallbackOnVideoStream(capwin_, NULL); 
     981        capturing_ = 0; 
     982        capture_=0; 
     983        if (frame_sem_!=0 ) { 
     984                ReleaseSemaphore(frame_sem_, 1, NULL); 
     985                CloseHandle(frame_sem_); 
     986        } 
    935987#ifdef NDEF 
    936988        if (caps_.fHasOverlay) 
     
    10181070 
    10191071        VfwGrabber *gp = (VfwGrabber*)capGetUserData(hwnd); 
    1020     /* in case we are not fast enough */ 
    1021     if (gp==NULL) return ((LRESULT)TRUE); 
    1022  
    1023     /* Block grab code until frame has been copied into last_frame_ (in capture function) */ 
    1024     WaitForSingleObject(gp->cb_mutex_,INFINITE); 
     1072        /* in case we are not fast enough */ 
     1073        if (gp==NULL) return ((LRESULT)TRUE); 
     1074 
     1075        /* Block grab code until frame has been copied into last_frame_ (in capture function) */ 
     1076        WaitForSingleObject(gp->cb_mutex_,INFINITE); 
    10251077 
    10261078#ifdef DEBUG__   
     
    10351087                debug_msg("Frames not ready! %d\n", not_done); 
    10361088 
    1037     /* Release to process frame in grab */ 
    1038     ReleaseMutex(gp->cb_mutex_); 
     1089        /* Release to process frame in grab */ 
     1090        ReleaseMutex(gp->cb_mutex_); 
    10391091        return ((LRESULT)TRUE); 
    10401092} 
     
    10601112#endif 
    10611113 
    1062     /* block the VideoHandler callback code until we've processed frame */ 
    1063     WaitForSingleObject(cb_mutex_,INFINITE); 
    1064  
    1065     if (last_frame_ == NULL || capturing_ == 0) { 
    1066         ReleaseMutex(cb_mutex_); 
     1114        /* block the VideoHandler callback code until we've processed frame */ 
     1115        WaitForSingleObject(cb_mutex_,INFINITE); 
     1116 
     1117        if (last_frame_ == NULL || capturing_ == 0) { 
     1118                ReleaseMutex(cb_mutex_); 
    10671119                return (FALSE); 
    1068     } 
     1120        } 
    10691121 
    10701122        converter_->convert((u_int8_t*)last_frame_, basewidth_ / decimate_, baseheight_ / decimate_, frame_, outw_, outh_, TRUE); 
     
    10751127        int rval = (target_->consume(&f)); 
    10761128 
    1077     /* release block so that VideoHandler can get new frame */ 
    1078     ReleaseMutex(cb_mutex_); 
    1079     return rval; 
    1080 } 
     1129        /* release block so that VideoHandler can get new frame */ 
     1130        ReleaseMutex(cb_mutex_); 
     1131        return rval; 
     1132} 
  • vic/branches/mpeg4/video/grabber-win32DS.cpp

    r4363 r4364  
    597597           break; 
    598598       case CF_422: 
    599            set_size_cif(width_, height_); 
     599           set_size_422(width_, height_); 
    600600           break; 
    601601   } 
     
    996996   strcat(attri_, "format { 420 422 cif } size { "); 
    997997            
    998    if (o.minWidth() > (CIF_BASE_WIDTH / 2)) { 
     998   if (o.minHeight() > (CIF_BASE_HEIGHT / 2)) { 
    999999     strcat(attri_, "large"); 
    10001000   } else if (o.maxWidth() < NTSC_BASE_WIDTH) { 
  • vic/branches/mpeg4/video/grabber-xv.cpp

    r4311 r4364  
    362362        capwin_->setsize(w, h); 
    363363        capwin_->converter(RGB_Converter_420::instance()); 
    364         set_size_420(w, h); 
     364        set_size_cif(w, h); 
    365365        allocref(); 
    366366} 
  • vic/branches/mpeg4/video/grabber.cpp

    r4311 r4364  
    456456 
    457457        int ispal; 
    458         switch (w) { 
    459         case 640: 
    460                 /* for qcam */ 
     458        switch (h) { 
     459        case 576: 
     460                /* 4CIF */ 
     461                ispal = 1; 
     462                outw_ = 704; 
     463                outh_ = 576; 
     464                break; 
     465 
     466        case 480: 
     467                /* NTSC */ 
    461468                ispal = 0; 
    462                 outw_ = 640; 
    463                 outh_ = 480; 
     469                outw_ = 704; 
     470                outh_ = 576; 
    464471                break; 
    465         case 320: 
    466                 /* 1/2 NTSC */ 
     472 
     473        case 240: 
     474                /* 1/4 NTSC */ 
    467475                ispal = 0; 
    468476                outw_ = 352; 
     
    470478                break; 
    471479 
    472         case 160: 
     480        case 120: 
    473481                /* 1/8 NTSC */ 
    474482                ispal = 0; 
     
    477485                break; 
    478486 
    479         case 352: 
    480                 /* 1/2 CIF */ 
     487        case 288: 
     488                /* 1/4 CIF */ 
    481489                ispal = 1; 
    482490                outw_ = 352; 
     
    484492                break; 
    485493 
    486         case 176: 
     494        case 144: 
    487495                /* 1/8 CIF */ 
    488                 ispal = 1; 
    489                 outw_ = 176; 
    490                 outh_ = 144; 
    491                 break; 
    492  
    493         case 384: 
    494                 /* 1/2 PAL */ 
    495                 ispal = 1; 
    496                 outw_ = 352; 
    497                 outh_ = 288; 
    498                 break; 
    499  
    500         case 192: 
    501                 /* 1/8 PAL */ 
    502496                ispal = 1; 
    503497                outw_ = 176;