This thread has been locked.

If you have a related question, please click the "Ask a related question" button in the top right corner. The newly created question will be automatically linked to this question.

DM365 Capture and Display

Other Parts Discussed in Thread: TVP5158

Hi,


I am implementing DM365 TVP5158 -> CCDC-> Capture-> Display. Capture resolution is 720 x 576 PAL.


I am running it on a message thread so that I can add additional tasks later.

Currently I have modified the working IPIPE in accordance to my requirement. My capture and display thread uses only AVSERVER_bufputFull and AVSEREVER_bufGet Empty functions.
 AVSERVER_bufGetNextTskInfo() is modified in the following way.

int AVSERVER_bufGetNextTskInfo(int tskId, int streamId, OSA_BufHndl **pBufHndl, OSA_TskHndl **pTskHndl)
{
  VIDEO_CaptureStream *pCaptureStream=NULL;
  VIDEO_EncodeStream  *pEncodeStream=NULL;
  VIDEO_DisplayStream *pDisplayStream=NULL;
 
  int nextTskId;

  *pTskHndl=NULL;
  *pBufHndl=NULL;

  if(streamId<0 || streamId >= AVSERVER_MAX_STREAMS) {
    OSA_ERROR("Incorrect streamId (%d)\n", streamId);
    return OSA_EFAIL;
  }

/*  if(tskId <=VIDEO_TSK_NONE || tskId >= VIDEO_TSK_STREAM) {
    OSA_ERROR("Incorrect tskId (%d)\n", tskId);
    return OSA_EFAIL;
  }*/

  if(tskId <= VIDEO_TSK_RESIZE) {
    pCaptureStream = &gVIDEO_ctrl.captureStream[streamId];
    pDisplayStream = &gVIDEO_ctrl.displayStream;

    nextTskId = VIDEO_TSK_NONE;

    if(tskId==VIDEO_TSK_CAPTURE) {
      nextTskId = pCaptureStream->captureNextTsk;
    }

    if(nextTskId==VIDEO_TSK_NONE) {

      *pBufHndl= &gVIDEO_ctrl.displayStream.bufDisplayIn;
      *pTskHndl = &gVIDEO_ctrl.displayTsk;
      //*pBufHndl = &pDisplayStream->bufDisplayIn;
      //*pTskHndl = &pCaptureStream->displayCopyTsk;
//      return OSA_EFAIL;
    }

  }


When I run the code I see that buffers not being allocated for CAPTURE OUT which is mainly because of AVSERVER_getemptybuf() function. Could anyone please look into it and let me know if anything more needs to be changed ? or some patch which does just capture and display but in threads. I have tried modifying for a real long time and stuck here right now.

Also, I was just checking of at least capture happens and to validate it I tried opening dumping the frame into a file using fwrite but it says " Read only filesystem". I have changed the folder permissions also but in vain!

Please anyone out there help me with this or let me know if I'm missing something!

Attached is the application log!

0458.App_log.txt
 AVSERVER API: Creating TSKs...DONE
SYSTEM.MSTPRI0 value changed to 00440011

CONFIGURING AVSERVER FOR DM365 .....
queue id:98307
 AVSERVER API: Sending START.
 AVSERVER MAIN: Recevied CMD = 0x0400, state = 0x0000
 AVSERVER MAIN: AVS[   10.466752] mt9p031 1-0048: No MT9P031 chip detected, register read ffffff87
ERVER_tskConnectInit() ...
 *** WARNING  FD: exceeded max input size for FD, disabling FD (current input 720x576)!!!
 AVSERVER MAIN: Create captureTsk ...
Inside capture main function cmd = 0x300
 CAPTURE: Recevied CMD = 0x0300
 CAPTURE: Create...
 CAPTURE: Opening capture on imager TVP515X.
 SENSOR FPS VALUE = 25
 Sensor Mode Info,
 Width      =  704 
 Height     =  288 
 fps        =   25 
 Bin Enable =    0 
 
 Sensor Frame Timing Info,
 fps                  = 25
 t_frame (ns)         = 40000000.000000
 t_row   (ns)         = 25062.500000
 t_pclk  (ns)         = 15.625000
 W                    = 704
 H                    = 576
 SW                   = 1595
 SD                   = 0
 HB                   = 450
 VB                   = 1020
 HBmin                = 450
 VBmin                = 9
 f_pclk               = 64000000
 shutterOverhead (ns) = 6656.250000
 col_size             = 703
 row_size             = 575
 col_skip             = 0
 row_skip             = 0
 col_bin              = 0
 row_bin              = 0
 col_start            = 8
 row_start            = 0
 pll_M                = 16
 pll_N                = 1
 pll_DIV              = 2
 
######Imager Id Check succes
Common Setting Applied
 CAPTURE: Create...DONE
 AVSERVER MAIN: Create displayTsk ...
 DISPLAY: Recevied CMD = 0x0300
 DISPLAY: Create...
prm->dstVirtAddr=1081470976, prm->copyWidth=720, prm->copyHeight=480, prm->dstOffsetH = 736, prm->dstoffsetV=480, prm->dstStartX=0,dstStartY=0,srcStartX=0,srcStartY=0
INvalid parameters passed
 DRV_DATA_FORMAT_YUV420
prm->dstVirtAddr=1083244544, prm->copyWidth=720, prm->copyHeight=480, prm->dstOffsetH = 736, prm->dstoffsetV=480, prm->dstStartX=0,dstStartY=0,srcStartX=0,srcStartY=0
INvalid parameters passed
 DRV_DATA_FORMAT_YUV420
prm->dstVirtAddr=1085374464, prm->copyWidth=720, prm->copyHeight=480, prm->dstOffsetH = 736, prm->dstoffsetV=480, prm->dstStartX=0,dstStartY=0,srcStartX=0,srcStartY=0
INvalid parameters passed
 DRV_DATA_FORMAT_YUV420
 AVSERVER MAIN: Allocing Buffers ...
 AVSERVER MAIN: Allocating buffers ...
 ERROR  (avServer.c|AVSERVER_bufGetEmpty|814): OSA_bufGetEmpty(1, 0, -1)
 ERROR  (avServer.c|AVSERVER_bufGetEmpty|814): OSA_bufGetEmpty(1, 1, -1)
 AVSERVER MAIN: Assigning Display buffers: 3 of size 636032 bytes
 AVSERVER MAIN: Allocating buffers ...DONE
 AVSERVER MAIN: Start captureTsk ...
 CAPTURE: Start...
 DISPLAY: Create...DONE
 CAPTURE: Start...DONE
 AVSERVER MAIN: Start DONE
 AVSERVER API: Sending START...DONE
mkdosfs 2.11 (12 Mar 2005)
unable to get drive geometry, using default 255/63/dev/ram0 has 255 heads and 63 sectors per track,
logical sector size is 512,
using 0xf8 media descriptor, with 8192 sectors;
file system has 2 12-bit FATs and 4 sectors per cluster.
FAT size is 6 sectors, and provides 2036 clusters.
Root directory contains 512 slots.
Volume ID is 54168b32, no volume label.
CAPTURE: Isif Buf 0
DRV_isisfGetOutBufinfo executed
 RAwbuf Vir address = 1122148352
Rawbufinfo != null
Pbuf->Virtual address = 1081470976
 displaycopytsk == tskid
prm->copyWidth=0, prm->copyHeight=0,srcStartX=0,srcStartY=0
 DISPLAY: Copying to Buf 0 (0, 0)
prm->dstVirtAddr=1081470976, prm->copyWidth=720, prm->copyHeight=480, prm->dstOffsetH = 736, prm->dstoffsetV=480, prm->dstStartX=360,dstStartY=240,srcStartX=0,srcStartY=0
INvalid parameters passed
 ERROR  (videoDisplayThr.c|VIDEO_displayCopyRun|83): DRV_frameCopy()
dispaly copy run executed
Inside file print
OffsetH =736,OffserV = 576
error in opening file
: Read-only file system
 [FILE ] Writing to file [IMG_0001.pgm] (1271808 bytes) ... ERROR 
AVServer_bufputfull executed
DRV_isifbufoutbuf executed
 DISPLAY: Get Buf 0 
 DISPLAY: Get Buf 0 
 ERROR  (drv_display.c|DRV_displayPutBuf|542): VIDIOC_QBUF
CAPTURE: Isif Buf 1
DRV_isisfGetOutBufinfo executed
 RAwbuf Vir address = 1124208640
Rawbufinfo != null
Pbuf->Virtual address = 1083244544
 displaycopytsk == tskid
prm->copyWidth=0, prm->copyHeight=0,srcStartX=0,srcStartY=0
 DISPLAY: Copying to Buf 2 (0, 0)
prm->dstVirtAddr=1085374464, prm->copyWidth=720, prm->copyHeight=480, prm->dstOffsetH = 736, prm->dstoffsetV=480, prm->dstStartX=360,dstStartY=240,srcStartX=0,srcStartY=0
INvalid parameters passed
 ERROR  (videoDisplayThr.c|VIDEO_displayCopyRun|83): DRV_frameCopy()
dispaly copy run executed
Inside file print
OffsetH =736,OffserV = 576
error in opening file
: Read-only file system
 [FILE ] Writing to file [IMG_0001.pgm] (1271808 bytes) ... ERROR 
AVServer_bufputfull executed
 DISPLAY: Get Buf 1 
 DISPLAY: Get Buf 2 
DRV_isifbufoutbuf executed
 DISPLAY: Put Buf 0 
CAPTURE: Isif Buf 2
DRV_isisfGetOutBufinfo executed
 RAwbuf Vir address = 1126219776
Rawbufinfo != null
Pbuf->Virtual address = 1085374464
 displaycopytsk == tskid
dispaly copy run executed
Inside file print
OffsetH =736,OffserV = 576
error in opening file
: Read-only file system
 [FILE ] Writing to file [IMG_0001.pgm] (1271808 bytes) ... ERROR 
AVServer_bufputfull executed
 DISPLAY: Get Buf 2 
 ERROR  (drv_display.c|DRV_displayPutBuf|542): VIDIOC_QBUF

Thanks & Regards,

Swathi

  • Hi Prabhakar,

    Thanks for the reply. Yes! Kernel is 2.6.37. The patch seems to work but I want to implement using the OSA message threads.

    I fail to understand why AVSERVER_bufGetNextTskInfo() function seems to be conflicting with the way modified above.  Any inputs on it would be appreciated.

    Attached is the way my Avserver.c file is written.

    1016.avServer.txt
    #include <avserver.h>
    #include <osa_cmem.h>
    #include <avserver_ui.h>
    
    Uint32 FrameSkipMask[AVSERVER_MAX_FRAMERATE+1] =
    {
    	0x00000000,
    	0x00000001,0x20004000,0x20080200,0x20404040,0x2082082,
    	0x21084210,0x01111111,0x11111111,0x24892488,0x24924924,
    	0x24924949,0x2949494A,0x2949A94A,0x29A9A94A,0x2AAAAAAA,
    	0x2AAAEAAA,0x2EAAEAAA,0x2B5AD6B5,0x35AD6B5B,0x1B6DB6DB,
    	0x1BDDB6DB,0x1BDDBDDB,0x3BDDBDDB,0x1EF7BDEF,0x1F7DF7DF,
    	0x1F7FF7DF,0x1F7FF7FF,0x1FFFF7FF,0x1FFFFFFF,0x3FFFFFFF
    };
    
    Uint32 AVSERVER_getFrameSkipMask(int fps)
    {
      if(fps>30)
    	fps = 30;
    
      return FrameSkipMask[fps];
    }
    
    int AVSERVER_bufAlloc()
    {
      int status=OSA_SOK;
      OSA_BufHndl *pBufHndl;
      OSA_BufInfo *pBufInfo;
      OSA_BufCreate *pBufCreatePrm;
      int bufId, i, k;
      VIDEO_EncodeStream *pEncodeStream;
      VIDEO_CaptureStream *pCaptureStream;
      Uint32 maxbufSize = 0;
      Uint32 bufSize;
    
      #ifdef AVSERVER_DEBUG_MAIN_THR
      OSA_printf(" AVSERVER MAIN: Allocating buffers ...\n");
      #endif
    
      for(i=0; i<gAVSERVER_config.numCaptureStream; i++) {
    
        pCaptureStream = &gVIDEO_ctrl.captureStream[i];
    
        bufSize = pCaptureStream->captureOutOffsetH * pCaptureStream->captureOutOffsetV;
    
        if(gAVSERVER_config.captureYuvFormat == DRV_DATA_FORMAT_YUV420)
          bufSize += bufSize/2;
        else
          bufSize += bufSize;
    
        bufSize += VIDEO_BUF_HEADER_SIZE;
    /*
    #ifdef YUV_MODE_INTERLACED
        pBufHndl      = &pCaptureStream->bufDeiIn;
        pBufCreatePrm = &pCaptureStream->bufDeiInCreatePrm;
    
        #ifdef AVSERVER_DEBUG_MAIN_THR
        OSA_printf(" AVSERVER MAIN: Stream %d: Allocating DEI buffers: %d of size %d bytes\n", i, pBufCreatePrm->numBuf, bufSize);
        #endif
    
        if(   gAVSERVER_config.captureRawInMode==AVSERVER_CAPTURE_RAW_IN_MODE_ISIF_IN
          &&  pCaptureStream->captureNextTsk == VIDEO_TSK_DEI
          ) {
    
    
          for(k=0; k<pBufCreatePrm->numBuf; k++) {
            pBufInfo = DRV_ipipeGetRszBufInfo(i, k);
    
            pBufCreatePrm->bufVirtAddr[k] = pBufInfo->virtAddr;
            pBufCreatePrm->bufPhysAddr[k] = pBufInfo->physAddr;
            if(pBufCreatePrm->bufVirtAddr[k]==NULL||pBufCreatePrm->bufPhysAddr[k]==NULL) {
              OSA_ERROR("DRV_ipipeGetRszBufInfo fail\n");
              return OSA_EFAIL;
            }
          }
    
        } else {
    
          for(k=0; k<pBufCreatePrm->numBuf; k++) {
    
            pBufInfo = DRV_isifGetOutBufInfo(k);
            pBufCreatePrm->bufVirtAddr[k] = pBufInfo->virtAddr;
            pBufCreatePrm->bufPhysAddr[k] = pBufInfo->physAddr;
    
            if(pBufCreatePrm->bufVirtAddr[k]==NULL||pBufCreatePrm->bufPhysAddr[k]==NULL) {
              OSA_ERROR("OSA_cmemAlloc()\n");
              return OSA_EFAIL;
            }
          }
        }
    
        if(pBufCreatePrm->numBuf)
          status |= OSA_bufCreate(pBufHndl, pBufCreatePrm);
    #endif
    
        pBufHndl      = &pCaptureStream->bufLdcIn;
        pBufCreatePrm = &pCaptureStream->bufLdcInCreatePrm;
    
        #ifdef AVSERVER_DEBUG_MAIN_THR
        OSA_printf(" AVSERVER MAIN: Stream %d: Allocating LDC buffers: %d of size %d bytes\n", i, pBufCreatePrm->numBuf, bufSize);
        #endif
    
        if(   gAVSERVER_config.captureRawInMode==AVSERVER_CAPTURE_RAW_IN_MODE_ISIF_IN
          &&  pCaptureStream->captureNextTsk == VIDEO_TSK_LDC
          ) {
    
          for(k=0; k<pBufCreatePrm->numBuf; k++) {
    
            pBufInfo = DRV_ipipeGetRszBufInfo(i, k);
    
            pBufCreatePrm->bufVirtAddr[k] = pBufInfo->virtAddr;
            pBufCreatePrm->bufPhysAddr[k] = pBufInfo->physAddr;
            if(pBufCreatePrm->bufVirtAddr[k]==NULL||pBufCreatePrm->bufPhysAddr[k]==NULL) {
              OSA_ERROR("DRV_ipipeGetRszBufInfo fail\n");
              return OSA_EFAIL;
            }
          }
    
        } else {
    
          for(k=0; k<pBufCreatePrm->numBuf; k++) {
            pBufCreatePrm->bufVirtAddr[k] = OSA_cmemAlloc(bufSize, 32);
            pBufCreatePrm->bufPhysAddr[k] = OSA_cmemGetPhysAddr(pBufCreatePrm->bufVirtAddr[k]);
    
            if(pBufCreatePrm->bufVirtAddr[k]==NULL||pBufCreatePrm->bufPhysAddr[k]==NULL) {
              OSA_ERROR("OSA_cmemAlloc()\n");
              return OSA_EFAIL;
            }
          }
        }
    
        if(pBufCreatePrm->numBuf)
          status |= OSA_bufCreate(pBufHndl, pBufCreatePrm);
    
        pBufHndl      = &pCaptureStream->bufVnfIn;
        pBufCreatePrm = &pCaptureStream->bufVnfInCreatePrm;
    
        #ifdef AVSERVER_DEBUG_MAIN_THR
        OSA_printf(" AVSERVER MAIN: Stream %d: Allocating VNF buffers: %d of size %d bytes\n", i, pBufCreatePrm->numBuf, bufSize);
        #endif
    
        if(   gAVSERVER_config.captureRawInMode==AVSERVER_CAPTURE_RAW_IN_MODE_ISIF_IN
          &&  pCaptureStream->captureNextTsk == VIDEO_TSK_VNF
          ) {
    
          for(k=0; k<pBufCreatePrm->numBuf; k++) {
    
            pBufInfo = DRV_ipipeGetRszBufInfo(i, k);
    
            pBufCreatePrm->bufVirtAddr[k] = pBufInfo->virtAddr;
            pBufCreatePrm->bufPhysAddr[k] = pBufInfo->physAddr;
            if(pBufCreatePrm->bufVirtAddr[k]==NULL||pBufCreatePrm->bufPhysAddr[k]==NULL) {
              OSA_ERROR("DRV_ipipeGetRszBufInfo fail\n");
              return OSA_EFAIL;
            }
          }
    
        } else {
    
          for(k=0; k<pBufCreatePrm->numBuf; k++) {
            pBufCreatePrm->bufVirtAddr[k] = OSA_cmemAlloc(bufSize, 32);
            pBufCreatePrm->bufPhysAddr[k] = OSA_cmemGetPhysAddr(pBufCreatePrm->bufVirtAddr[k]);
    
            if(pBufCreatePrm->bufVirtAddr[k]==NULL||pBufCreatePrm->bufPhysAddr[k]==NULL) {
              OSA_ERROR("OSA_cmemAlloc() fail\n");
              return OSA_EFAIL;
            }
          }
        }
        if(pBufCreatePrm->numBuf)
          status |= OSA_bufCreate(pBufHndl, pBufCreatePrm);
    
        pBufHndl      = &pCaptureStream->bufEncodeIn;
        pBufCreatePrm = &pCaptureStream->bufEncodeInCreatePrm;
    
        #ifdef AVSERVER_DEBUG_MAIN_THR
        OSA_printf(" AVSERVER MAIN: Stream %d: Allocating Encode IN buffers: %d of size %d bytes\n", i, pBufCreatePrm->numBuf, bufSize);
        #endif
    
        if(   gAVSERVER_config.captureRawInMode==AVSERVER_CAPTURE_RAW_IN_MODE_ISIF_IN
          &&  pCaptureStream->captureNextTsk == VIDEO_TSK_ENCODE
          ) {
    
          for(k=0; k<pBufCreatePrm->numBuf; k++) {
    
            pBufInfo = DRV_ipipeGetRszBufInfo(i, k);
    
            pBufCreatePrm->bufVirtAddr[k] = pBufInfo->virtAddr;
            pBufCreatePrm->bufPhysAddr[k] = pBufInfo->physAddr;
          }
    
        } else {
    
          for(k=0; k<pBufCreatePrm->numBuf; k++) {
            pBufCreatePrm->bufVirtAddr[k] = OSA_cmemAlloc(bufSize, 32);
            pBufCreatePrm->bufPhysAddr[k] = OSA_cmemGetPhysAddr(pBufCreatePrm->bufVirtAddr[k]);
    
            if(pBufCreatePrm->bufVirtAddr[k]==NULL||pBufCreatePrm->bufPhysAddr[k]==NULL) {
              OSA_ERROR("OSA_cmemAlloc()\n");
              return OSA_EFAIL;
            }
          }
        }
        if(pBufCreatePrm->numBuf)
          status |= OSA_bufCreate(pBufHndl, pBufCreatePrm);
    
        pBufHndl      = &pCaptureStream->bufResizeIn;
        pBufCreatePrm = &pCaptureStream->bufResizeInCreatePrm;
    
        #ifdef AVSERVER_DEBUG_MAIN_THR
        OSA_printf(" AVSERVER MAIN: Stream %d: Assigning Resize IN buffers: %d of size %d bytes\n", i, pBufCreatePrm->numBuf, bufSize);
        #endif
    
        for(k=0; k<pBufCreatePrm->numBuf; k++) {
    #ifdef YUV_MODE_INTERLACED
          pBufCreatePrm->bufVirtAddr[k] = OSA_cmemAlloc(bufSize * 2, 32);
          pBufCreatePrm->bufPhysAddr[k] = OSA_cmemGetPhysAddr(pBufCreatePrm->bufVirtAddr[k]);
    #else
          pBufCreatePrm->bufVirtAddr[k] = pCaptureStream->bufEncodeInCreatePrm.bufVirtAddr[k];
          pBufCreatePrm->bufPhysAddr[k] = pCaptureStream->bufEncodeInCreatePrm.bufPhysAddr[k];
    #endif
        }
    
        if(pBufCreatePrm->numBuf) {
          status |= OSA_bufCreate(pBufHndl, pBufCreatePrm);
        }
    
    #ifndef YUV_MODE_INTERLACED
        if(pCaptureStream->bufResizeIn.numBuf) {
    
          #ifdef AVSERVER_DEBUG_MAIN_THR
          OSA_printf(" AVSERVER MAIN: Stream %d: Getting Encode IN buffers\n", i);
          #endif
    
          while( OSA_bufGetEmpty(&pCaptureStream->bufEncodeIn, &bufId, OSA_TIMEOUT_NONE) == OSA_SOK) {
            #ifdef AVSERVER_DEBUG_MAIN_THR
            OSA_printf(" AVSERVER MAIN: Stream %d: Encode IN buffers %d\n", i, bufId);
            #endif
          }
        }
    #endif
    */
        if(gAVSERVER_config.captureRawInMode==AVSERVER_CAPTURE_RAW_IN_MODE_ISIF_IN)
        {
          #ifdef AVSERVER_DEBUG_MAIN_THR
          OSA_printf(" AVSERVER MAIN: Stream %d: Getting Capture OUT buffers\n", i);
          #endif
    
          while( AVSERVER_bufGetEmpty( VIDEO_TSK_CAPTURE, i, &bufId, OSA_TIMEOUT_NONE) != NULL) {
            #ifdef AVSERVER_DEBUG_MAIN_THR
            OSA_printf(" AVSERVER MAIN: Stream %d: Capture OUT buffers %d\n", i, bufId);
            #endif
          }
        }
    
    #ifdef YUV_MODE_INTERLACED
        while( AVSERVER_bufGetEmpty( VIDEO_TSK_CAPTURE, i, &bufId, OSA_TIMEOUT_NONE) != NULL) {
    	  #ifdef AVSERVER_DEBUG_MAIN_THR
    	  OSA_printf(" AVSERVER MAIN: Stream %d: Capture OUT buffers %d\n", i, bufId);
    	  #endif
        }
    #endif
      }
    /*
      bufSize = OSA_align(gVIDEO_ctrl.faceDetectStream.fdOffsetH, 32)*gVIDEO_ctrl.faceDetectStream.fdHeight*2;
      bufSize += VIDEO_BUF_HEADER_SIZE;
    
      pBufHndl      = &gVIDEO_ctrl.faceDetectStream.bufFdIn;
      pBufCreatePrm = &gVIDEO_ctrl.faceDetectStream.bufFdInCreatePrm;
    
      #ifdef AVSERVER_DEBUG_MAIN_THR
      OSA_printf(" AVSERVER MAIN: Allocating FD buffers: %d of size %d bytes\n", pBufCreatePrm->numBuf, bufSize);
      #endif
    
      for(k=0; k<pBufCreatePrm->numBuf; k++) {
        pBufCreatePrm->bufVirtAddr[k] = OSA_cmemAlloc(bufSize, 32);
        pBufCreatePrm->bufPhysAddr[k] = OSA_cmemGetPhysAddr(pBufCreatePrm->bufVirtAddr[k]);
    
        if(pBufCreatePrm->bufVirtAddr[k]==NULL||pBufCreatePrm->bufPhysAddr[k]==NULL) {
          OSA_ERROR("OSA_cmemAlloc()\n");
          return OSA_EFAIL;
        }
      }
    
      if(pBufCreatePrm->numBuf)
        status |= OSA_bufCreate(pBufHndl, pBufCreatePrm);
    
      // Buffer Allocation: DMVA Buffers 
      bufSize = OSA_align(gVIDEO_ctrl.dmvaAppStream.dmvaOffsetH, 32)*gVIDEO_ctrl.dmvaAppStream.dmvaHeight*2;
      bufSize += VIDEO_BUF_HEADER_SIZE;
    
      pBufHndl      = &gVIDEO_ctrl.dmvaAppStream.bufDmvaIn;
      pBufCreatePrm = &gVIDEO_ctrl.dmvaAppStream.bufDmvaInCreatePrm;
    
      #ifdef AVSERVER_DEBUG_MAIN_THR
      OSA_printf(" AVSERVER MAIN: Allocating DMVA buffers: %d of size %d bytes\n", pBufCreatePrm->numBuf, bufSize);
      #endif
    
      for(k=0; k<pBufCreatePrm->numBuf; k++) {
        pBufCreatePrm->bufVirtAddr[k] = OSA_cmemAlloc(bufSize, 32);
        pBufCreatePrm->bufPhysAddr[k] = OSA_cmemGetPhysAddr(pBufCreatePrm->bufVirtAddr[k]);
    
        if(pBufCreatePrm->bufVirtAddr[k]==NULL||pBufCreatePrm->bufPhysAddr[k]==NULL) {
          OSA_ERROR("OSA_cmemAlloc()\n");
          return OSA_EFAIL;
        }
      }
    
      if(pBufCreatePrm->numBuf)
        status |= OSA_bufCreate(pBufHndl, pBufCreatePrm);
    */
      /* Buffer Allocation: Display Buffers */
      pBufHndl      = &gVIDEO_ctrl.displayStream.bufDisplayIn;
      pBufCreatePrm = &gVIDEO_ctrl.displayStream.bufDisplayInCreatePrm;
    
      #ifdef AVSERVER_DEBUG_MAIN_THR
      OSA_printf(" AVSERVER MAIN: Assigning Display buffers: %d of size %d bytes\n", pBufCreatePrm->numBuf, bufSize);
      #endif
    
      for(k=0; k<pBufCreatePrm->numBuf; k++) {
        pBufCreatePrm->bufVirtAddr[k] = gVIDEO_ctrl.displayStream.displayInfo.virtAddr[k];
        pBufCreatePrm->bufPhysAddr[k] = gVIDEO_ctrl.displayStream.displayInfo.physAddr[k];
      }
    
      if(pBufCreatePrm->numBuf)
        status |= OSA_bufCreate(pBufHndl, pBufCreatePrm);
    /*
      for(i=0; i<gAVSERVER_config.numEncodeStream; i++) {
        pEncodeStream = &gVIDEO_ctrl.encodeStream[i];
    
        bufSize = gAVSERVER_config.encodeConfig[i].cropWidth*gAVSERVER_config.encodeConfig[i].cropHeight;
    
        switch(gAVSERVER_config.encodeConfig[i].codecType) {
          default:
          case ALG_VID_CODEC_MJPEG:
            bufSize /= 1;
            break;
    
          case ALG_VID_CODEC_H264:
          case ALG_VID_CODEC_MPEG4:
            bufSize /= 2;
            break;
        }
    
    	// Reducing the buf size to avoid memory alloc errors for 5 MP use case 
    	if(gAVSERVER_UI_config.mode == AVSERVER_UI_CAPTURE_MODE_5_MEGA)
    		bufSize = bufSize - (128 * KB);
    
        bufSize += VIDEO_BUF_HEADER_SIZE;
    
        bufSize = OSA_align(bufSize, KB);
    
        pBufHndl      = &pEncodeStream->bufEncryptIn;
        pBufCreatePrm = &pEncodeStream->bufEncryptInCreatePrm;
    
        #ifdef AVSERVER_DEBUG_MAIN_THR
        OSA_printf(" AVSERVER MAIN: Stream %d: Allocating Encrypt buffers: %d of size %d bytes\n", i, pBufCreatePrm->numBuf, bufSize);
        #endif
    
        for(k=0; k<pBufCreatePrm->numBuf; k++) {
          pBufCreatePrm->bufVirtAddr[k] = OSA_cmemAlloc(bufSize, 32);
          pBufCreatePrm->bufPhysAddr[k] = OSA_cmemGetPhysAddr(pBufCreatePrm->bufVirtAddr[k]);
    
          if(pBufCreatePrm->bufVirtAddr[k]==NULL||pBufCreatePrm->bufPhysAddr[k]==NULL) {
            OSA_ERROR("OSA_cmemAlloc()\n");
            return OSA_EFAIL;
          }
        }
    
        if(pBufCreatePrm->numBuf)
          status |= OSA_bufCreate(pBufHndl, pBufCreatePrm);
    
        pBufHndl      = &pEncodeStream->bufStreamIn;
        pBufCreatePrm = &pEncodeStream->bufStreamInCreatePrm;
    
        #ifdef AVSERVER_DEBUG_MAIN_THR
        OSA_printf(" AVSERVER MAIN: Stream %d: Allocating Stream buffers: %d of size %d bytes\n", i, pBufCreatePrm->numBuf, bufSize);
        #endif
    
        for(k=0; k<pBufCreatePrm->numBuf; k++) {
          pBufCreatePrm->bufVirtAddr[k] = OSA_cmemAlloc(bufSize, 32);
          pBufCreatePrm->bufPhysAddr[k] = OSA_cmemGetPhysAddr(pBufCreatePrm->bufVirtAddr[k]);
    
          if(pBufCreatePrm->bufVirtAddr[k]==NULL||pBufCreatePrm->bufPhysAddr[k]==NULL) {
            OSA_ERROR("OSA_cmemAlloc()\n");
            return OSA_EFAIL;
          }
        }
    
        if(pBufCreatePrm->numBuf)
          status |= OSA_bufCreate(pBufHndl, pBufCreatePrm);
      }
    
    	maxbufSize = 32;
    	for(i=0; i<gAVSERVER_config.numEncodeStream; i++)
    	{
    		pEncodeStream = &gVIDEO_ctrl.encodeStream[i];
    		bufSize = ALG_vidEncGetMVdataSize( pEncodeStream->algEncHndl );
    		if( maxbufSize < bufSize )
    		{
    			maxbufSize = bufSize;
    		}
    	}
    	gVIDEO_ctrl.motionStream.maxbufsize = maxbufSize;
    	pBufHndl      = &gVIDEO_ctrl.motionStream.bufMotionIn;
        pBufCreatePrm = &gVIDEO_ctrl.motionStream.bufMotionInCreatePrm;
    
        #ifdef AVSERVER_DEBUG_MAIN_THR
        OSA_printf(" AVSERVER MAIN: Allocating MotionDetect buffers: %d of size %d bytes\n", pBufCreatePrm->numBuf, bufSize);
        #endif
    
    	for(k=0; k<pBufCreatePrm->numBuf; k++)
    	{
        pBufCreatePrm->bufVirtAddr[k] = OSA_cmemAlloc(maxbufSize, 32);
        pBufCreatePrm->bufPhysAddr[k] = OSA_cmemGetPhysAddr(pBufCreatePrm->bufVirtAddr[k]);
    
        if(pBufCreatePrm->bufVirtAddr[k]==NULL)
        {
          OSA_ERROR("OSA_cmemAlloc()\n");
          return OSA_EFAIL;
        }
      }
      if(pBufCreatePrm->numBuf)
      	status |= OSA_bufCreate(pBufHndl, pBufCreatePrm);*/
    
      if(status!=OSA_SOK)
        OSA_ERROR("\n");
    
      #ifdef AVSERVER_DEBUG_MAIN_THR
      OSA_printf(" AVSERVER MAIN: Allocating buffers ...DONE\n");
      #endif
    
      return status;
    }
    
    int AVSERVER_bufFree()
    {
      int i, k, status=OSA_SOK;
      VIDEO_EncodeStream *pEncodeStream;
      VIDEO_CaptureStream *pCaptureStream;
    
      for(i=0; i<gAVSERVER_config.numCaptureStream; i++) {
    
        pCaptureStream = &gVIDEO_ctrl.captureStream[i];
    
        if(   gAVSERVER_config.captureRawInMode==AVSERVER_CAPTURE_RAW_IN_MODE_ISIF_IN
          &&  pCaptureStream->captureNextTsk == VIDEO_TSK_LDC
          ) {
    
        } else {
          for(k=0; k<pCaptureStream->bufLdcInCreatePrm.numBuf; k++)
            OSA_cmemFree(pCaptureStream->bufLdcInCreatePrm.bufVirtAddr[k]);
        }
    
        if(   gAVSERVER_config.captureRawInMode==AVSERVER_CAPTURE_RAW_IN_MODE_ISIF_IN
          &&  pCaptureStream->captureNextTsk == VIDEO_TSK_VNF
          ) {
    
        } else {
          for(k=0; k<pCaptureStream->bufVnfInCreatePrm.numBuf; k++)
            OSA_cmemFree(pCaptureStream->bufVnfInCreatePrm.bufVirtAddr[k]);
        }
    
        if(   gAVSERVER_config.captureRawInMode==AVSERVER_CAPTURE_RAW_IN_MODE_ISIF_IN
          &&  pCaptureStream->captureNextTsk == VIDEO_TSK_ENCODE
          ) {
    
        } else {
          for(k=0; k<pCaptureStream->bufEncodeInCreatePrm.numBuf; k++)
            OSA_cmemFree(pCaptureStream->bufEncodeInCreatePrm.bufVirtAddr[k]);
        }
    #ifdef YUV_MODE_INTERLACED
          for(k=0; k<pCaptureStream->bufResizeInCreatePrm.numBuf; k++)
            OSA_cmemFree(pCaptureStream->bufResizeInCreatePrm.bufVirtAddr[k]);
    #endif
    
        if(pCaptureStream->bufLdcInCreatePrm.numBuf)
          OSA_bufDelete(&pCaptureStream->bufLdcIn);
    
        if(pCaptureStream->bufVnfInCreatePrm.numBuf)
          OSA_bufDelete(&pCaptureStream->bufVnfIn);
    
        if(pCaptureStream->bufResizeInCreatePrm.numBuf)
          OSA_bufDelete(&pCaptureStream->bufResizeIn);
    
        if(pCaptureStream->bufEncodeInCreatePrm.numBuf)
          OSA_bufDelete(&pCaptureStream->bufEncodeIn);
      }
    
      for(k=0; k<gVIDEO_ctrl.faceDetectStream.bufFdInCreatePrm.numBuf; k++)
        OSA_cmemFree(gVIDEO_ctrl.faceDetectStream.bufFdInCreatePrm.bufVirtAddr[k]);
    
      if(gVIDEO_ctrl.faceDetectStream.bufFdInCreatePrm.numBuf)
        OSA_bufDelete(&gVIDEO_ctrl.faceDetectStream.bufFdIn);
    
      for(k=0; k<gVIDEO_ctrl.dmvaAppStream.bufDmvaInCreatePrm.numBuf; k++)
        OSA_cmemFree(gVIDEO_ctrl.dmvaAppStream.bufDmvaInCreatePrm.bufVirtAddr[k]);
    
      if(gVIDEO_ctrl.dmvaAppStream.bufDmvaInCreatePrm.numBuf)
        OSA_bufDelete(&gVIDEO_ctrl.dmvaAppStream.bufDmvaIn);
    
      if(gVIDEO_ctrl.displayStream.bufDisplayInCreatePrm.numBuf)
        OSA_bufDelete(&gVIDEO_ctrl.displayStream.bufDisplayIn);
    
      for(i=0; i<gAVSERVER_config.numEncodeStream; i++) {
        pEncodeStream = &gVIDEO_ctrl.encodeStream[i];
    
        for(k=0; k<pEncodeStream->bufEncryptInCreatePrm.numBuf; k++)
          OSA_cmemFree(pEncodeStream->bufEncryptInCreatePrm.bufVirtAddr[k]);
    
        for(k=0; k<pEncodeStream->bufStreamInCreatePrm.numBuf; k++)
          OSA_cmemFree(pEncodeStream->bufStreamInCreatePrm.bufVirtAddr[k]);
    
        if(pEncodeStream->bufEncryptInCreatePrm.numBuf)
          OSA_bufDelete(&pEncodeStream->bufEncryptIn);
    
        if(pEncodeStream->bufStreamInCreatePrm.numBuf)
          OSA_bufDelete(&pEncodeStream->bufStreamIn);
      }
    
    	for(k=0; k<gVIDEO_ctrl.motionStream.bufMotionInCreatePrm.numBuf; k++)
    	{
    	  if( gVIDEO_ctrl.motionStream.bufMotionInCreatePrm.bufVirtAddr[k])
    	  {
    			OSA_cmemFree(gVIDEO_ctrl.motionStream.bufMotionInCreatePrm.bufVirtAddr[k]);
    	  }
    	}
    
    	if( gVIDEO_ctrl.motionStream.bufMotionInCreatePrm.numBuf )
    		OSA_bufDelete(&(gVIDEO_ctrl.motionStream.bufMotionIn));
    
      return status;
    }
    
    
    int AVSERVER_tskConnectInit()
    {
      int i, status;
      VIDEO_EncodeStream *pEncodeStream;
      VIDEO_CaptureStream *pCaptureStream;
    
      gVIDEO_ctrl.alawEnable = FALSE;
    
      if(gAVSERVER_config.captureRawInMode==AVSERVER_CAPTURE_RAW_IN_MODE_ISIF_IN)
      {
        gAVSERVER_config.captureSingleResize = FALSE;
    
        if(gAVSERVER_config.numCaptureStream > 2)
          gAVSERVER_config.numCaptureStream = 2;
      }
    
      if(!gAVSERVER_config.aewb_config.saldreEnable) {
    	if(gAVSERVER_config.captureRawInMode==AVSERVER_CAPTURE_RAW_IN_MODE_DDR_IN)
        	gVIDEO_ctrl.alawEnable = TRUE;
      }
    
      #ifdef YUV_MODE
      gVIDEO_ctrl.alawEnable = FALSE;
      #endif
    
      if(gAVSERVER_config.vstabTskEnable)
      {
        gAVSERVER_config.sensorMode |= DRV_IMGS_SENSOR_MODE_VSTAB;
      }
    
      if(gAVSERVER_config.vnfTskEnable)
      {
        gAVSERVER_config.sensorMode |= DRV_IMGS_SENSOR_MODE_PIXEL_PAD;
      }
    
      i = gAVSERVER_config.faceDetectConfig.captureStreamId;
    
      gVIDEO_ctrl.faceDetectStream.fdWidth  = gAVSERVER_config.captureConfig[i].width;
      gVIDEO_ctrl.faceDetectStream.fdHeight = gAVSERVER_config.captureConfig[i].height;
      gVIDEO_ctrl.faceDetectStream.fdOffsetH = 320;
    
      if(gVIDEO_ctrl.faceDetectStream.fdWidth>gVIDEO_ctrl.faceDetectStream.fdOffsetH) {
        OSA_printf(" *** WARNING  FD: exceeded max input size for FD, disabling FD (current input %dx%d)!!!\n",
          gVIDEO_ctrl.faceDetectStream.fdWidth, gVIDEO_ctrl.faceDetectStream.fdHeight
          );
        gAVSERVER_config.faceDetectConfig.fdEnable = FALSE;
      }
    
      memset(&gVIDEO_ctrl.faceDetectStream.faceStatus, 0, sizeof(gVIDEO_ctrl.faceDetectStream.faceStatus));
    
      i = gAVSERVER_config.dmvaAppConfig.captureStreamId;
    
      gVIDEO_ctrl.dmvaAppStream.dmvaWidth  = gAVSERVER_config.captureConfig[i].width;
      gVIDEO_ctrl.dmvaAppStream.dmvaHeight = gAVSERVER_config.captureConfig[i].height;
      gVIDEO_ctrl.dmvaAppStream.dmvaOffsetH = gAVSERVER_config.captureConfig[i].width;
    
      if(gVIDEO_ctrl.dmvaAppStream.dmvaWidth>gVIDEO_ctrl.dmvaAppStream.dmvaOffsetH) {
        OSA_printf(" *** WARNING  DMVA: exceeded max input size for DMVA, disabling DMVA (current input %dx%d)!!!\n",
          gVIDEO_ctrl.dmvaAppStream.dmvaWidth, gVIDEO_ctrl.dmvaAppStream.dmvaHeight
          );
        gAVSERVER_config.dmvaAppConfig.dmvaEnable = FALSE;
      }
    
      memset(&gVIDEO_ctrl.dmvaAppStream.algDmvalHndl, 0, sizeof(gVIDEO_ctrl.dmvaAppStream.algDmvalHndl));
    
      memset(&gVIDEO_ctrl.vsStream.vsStatus, 0xFF, sizeof(gVIDEO_ctrl.vsStream.vsStatus));
      memset(&gVIDEO_ctrl.aewbStream.aewbStatus, 0, sizeof(gVIDEO_ctrl.aewbStream.aewbStatus));
    
      for(i=0; i<gAVSERVER_config.numCaptureStream; i++) {
        pCaptureStream = &gVIDEO_ctrl.captureStream[i];
    
        pCaptureStream->bufLdcInCreatePrm.numBuf = 0;
        pCaptureStream->bufVnfInCreatePrm.numBuf = 0;
        pCaptureStream->bufResizeInCreatePrm.numBuf = 0;
        pCaptureStream->bufDeiInCreatePrm.numBuf = 0;
        pCaptureStream->bufEncodeInCreatePrm.numBuf = VIDEO_NUM_BUF;
    
        if(gAVSERVER_config.captureSingleResize && i > 0) {
    
        } else {
          if(gAVSERVER_config.deiTskEnable)
            pCaptureStream->bufDeiInCreatePrm.numBuf = VIDEO_NUM_BUF;
    
          if(gAVSERVER_config.ldcTskEnable)
            pCaptureStream->bufLdcInCreatePrm.numBuf = VIDEO_NUM_BUF;
    
          if(gAVSERVER_config.vnfTskEnable)
            pCaptureStream->bufVnfInCreatePrm.numBuf = VIDEO_NUM_BUF;
    
          if(gAVSERVER_config.captureSingleResize) {
            pCaptureStream->bufResizeInCreatePrm.numBuf = pCaptureStream->bufEncodeInCreatePrm.numBuf;
          }
        }
      }
    
      gVIDEO_ctrl.displayStream.bufDisplayInCreatePrm.numBuf = VIDEO_NUM_BUF;
    
      gVIDEO_ctrl.faceDetectStream.bufFdInCreatePrm.numBuf = VIDEO_NUM_BUF;
    
      if(gAVSERVER_config.dmvaAppConfig.dmvaEnable == TRUE)
    	gVIDEO_ctrl.dmvaAppStream.bufDmvaInCreatePrm.numBuf = VIDEO_NUM_BUF;
      else
    	gVIDEO_ctrl.dmvaAppStream.bufDmvaInCreatePrm.numBuf = 0;
    
      gVIDEO_ctrl.motionStream.bufMotionInCreatePrm.numBuf = VIDEO_NUM_BUF;
    
      for(i=0; i<gAVSERVER_config.numEncodeStream; i++) {
        pEncodeStream = &gVIDEO_ctrl.encodeStream[i];
    
        pEncodeStream->fileSaveState = VIDEO_STREAM_FILE_SAVE_STATE_IDLE;
        pEncodeStream->fileSaveIndex = 0;
        pEncodeStream->fileSaveHndl  = NULL;
    
        pEncodeStream->bufEncryptInCreatePrm.numBuf = 0;
    
        if(gAVSERVER_config.encryptTskEnable)
          pEncodeStream->bufEncryptInCreatePrm.numBuf = VIDEO_NUM_BUF;
    
        pEncodeStream->bufStreamInCreatePrm.numBuf = VIDEO_NUM_BUF;
      }
    
      status = AVSERVER_tskConnectReset();
    
      return status;
    }
    
    int AVSERVER_tskConnectExit()
    {
      int status;
    
      status = AVSERVER_bufFree();
    
      return status;
    }
    
    
    int AVSERVER_tskConnectReset()
    {
      int i, status=OSA_SOK;
      VIDEO_CaptureStream *pCaptureStream;
      VIDEO_CaptureConfig *pCaptureConfig;
      VIDEO_EncodeStream *pEncodeStream;
      VIDEO_EncodeConfig *pEncodeConfig;
    
      for(i=0; i<gAVSERVER_config.numCaptureStream; i++) {
    
        pCaptureStream = &gVIDEO_ctrl.captureStream[i];
        pCaptureConfig = &gAVSERVER_config.captureConfig[i];
    
        pCaptureStream->captureNextTsk = VIDEO_TSK_NONE;
    
        //pCaptureStream->displayCopyTsk = VIDEO_TSK_NONE;
    
        pCaptureStream->displayCopyTsk = VIDEO_TSK_CAPTURE;
      }
    
      return status;
    }
    
    int AVSERVER_bufGetNextTskInfo(int tskId, int streamId, OSA_BufHndl **pBufHndl, OSA_TskHndl **pTskHndl)
    {
      VIDEO_CaptureStream *pCaptureStream=NULL;
      VIDEO_EncodeStream  *pEncodeStream=NULL;
      VIDEO_DisplayStream *pDisplayStream=NULL;
      
      int nextTskId;
    
      *pTskHndl=NULL;
      *pBufHndl=NULL;
    
      if(streamId<0 || streamId >= AVSERVER_MAX_STREAMS) {
        OSA_ERROR("Incorrect streamId (%d)\n", streamId);
        return OSA_EFAIL;
      }
    
    /*  if(tskId <=VIDEO_TSK_NONE || tskId >= VIDEO_TSK_STREAM) {
        OSA_ERROR("Incorrect tskId (%d)\n", tskId);
        return OSA_EFAIL;
      }*/
    
      if(tskId <= VIDEO_TSK_RESIZE) {
        pCaptureStream = &gVIDEO_ctrl.captureStream[streamId];
        pDisplayStream = &gVIDEO_ctrl.displayStream;
    
        nextTskId = VIDEO_TSK_NONE;
    
        if(tskId==VIDEO_TSK_CAPTURE) {
          nextTskId = pCaptureStream->captureNextTsk;
        } 
    
        if(nextTskId==VIDEO_TSK_NONE) {
    
          *pBufHndl= &gVIDEO_ctrl.displayStream.bufDisplayIn;
          *pTskHndl = &gVIDEO_ctrl.displayTsk;
          //*pBufHndl = &pDisplayStream->bufDisplayIn;
          //*pTskHndl = &pCaptureStream->displayCopyTsk;
    //      return OSA_EFAIL;
        }
    
      }
    
    
      return OSA_SOK;
    }
    
    int AVSERVER_bufGetCurTskInfo(int tskId, int streamId, OSA_BufHndl **pBufHndl)
    {
      VIDEO_CaptureStream *pCaptureStream=NULL;
      VIDEO_EncodeStream  *pEncodeStream=NULL;
    
      *pBufHndl=NULL;
    
      if(streamId<0 || streamId >= AVSERVER_MAX_STREAMS) {
        OSA_ERROR("Incorrect streamId (%d)\n", streamId);
        return OSA_EFAIL;
      }
    
      if(tskId <= VIDEO_TSK_CAPTURE || tskId > VIDEO_TSK_STREAM) {
        OSA_ERROR("Incorrect tskId (%d)\n", tskId);
        return OSA_EFAIL;
      }
    
      if(tskId <= VIDEO_TSK_ENCODE) {
        pCaptureStream = &gVIDEO_ctrl.captureStream[streamId];
        if(tskId==VIDEO_TSK_DEI) {
          *pBufHndl = &pCaptureStream->bufDeiIn;
        } else
        if(tskId==VIDEO_TSK_LDC) {
          *pBufHndl = &pCaptureStream->bufLdcIn;
        } else
        if(tskId==VIDEO_TSK_VNF) {
          *pBufHndl = &pCaptureStream->bufVnfIn;
        } else
        if(tskId==VIDEO_TSK_RESIZE) {
          *pBufHndl = &pCaptureStream->bufResizeIn;
        } else
        if(tskId==VIDEO_TSK_ENCODE) {
          *pBufHndl = &pCaptureStream->bufEncodeIn;
        } else {
          OSA_ERROR("Incorrect tskId (%d)\n", tskId);
          return OSA_EFAIL;
        }
    
      } else {
    
        pEncodeStream  = &gVIDEO_ctrl.encodeStream[streamId];
    
        if(tskId==VIDEO_TSK_ENCRYPT) {
          *pBufHndl = &pEncodeStream->bufEncryptIn;
        } else
        if(tskId==VIDEO_TSK_STREAM) {
          *pBufHndl = &pEncodeStream->bufStreamIn;
        } else {
          OSA_ERROR("Incorrect tskId (%d)\n", tskId);
          return OSA_EFAIL;
        }
      }
    
      return OSA_SOK;
    }
    
    OSA_BufInfo *AVSERVER_bufGetEmpty(int tskId, int streamId, int *bufId, int timeout)
    {
      OSA_BufHndl *pBufHndl;
      OSA_TskHndl *pTskHndl;
      int status;
    
      *bufId = -1;
    
      status = AVSERVER_bufGetNextTskInfo(tskId, streamId, &pBufHndl, &pTskHndl);
      if(status!=OSA_SOK) {
        OSA_ERROR("AVSERVER_bufGetNextTskInfo(%d, %d)\n", tskId, streamId);
        return NULL;
      }
    
      status = OSA_bufGetEmpty(pBufHndl, bufId, timeout);
      if(status!=OSA_SOK) {
        OSA_ERROR("OSA_bufGetEmpty(%d, %d, %d)\n", tskId, streamId, *bufId);
        return NULL;
      }
    
      return OSA_bufGetBufInfo(pBufHndl, *bufId);
    }
    
    OSA_BufInfo *AVSERVER_bufPutFull(int tskId, int streamId, int bufId)
    {
      OSA_BufHndl *pBufHndl;
      OSA_TskHndl *pTskHndl;
      int status;
    
      status = AVSERVER_bufGetNextTskInfo(tskId, streamId, &pBufHndl, &pTskHndl);
      if(status!=OSA_SOK) {
        OSA_ERROR("AVSERVER_bufGetNextTskInfo(%d, %d)\n", tskId, streamId);
        return NULL;
      }
    
      status = OSA_bufPutFull(pBufHndl, bufId);
      if(status!=OSA_SOK) {
        OSA_ERROR("OSA_bufPutFull(%d, %d, %d)\n", tskId, streamId, bufId);
        return NULL;
      }
    
      status = OSA_tskSendMsg(pTskHndl, NULL, AVSERVER_CMD_NEW_DATA, (void*)streamId, 0);
      if(status!=OSA_SOK) {
        OSA_ERROR("OSA_tskSendMsg(AVSERVER_CMD_NEW_DATA, %d, %d)\n", tskId, streamId);
        return NULL;
      }
    
      return OSA_bufGetBufInfo(pBufHndl, bufId);
    }
    
    OSA_BufInfo *AVSERVER_bufGetFull(int tskId, int streamId, int *bufId, int timeout)
    {
      OSA_BufHndl *pBufHndl;
      int status;
    
      *bufId = -1;
    
      status = AVSERVER_bufGetCurTskInfo(tskId, streamId, &pBufHndl);
      if(status!=OSA_SOK) {
        OSA_ERROR("AVSERVER_bufGetCurTskInfo(%d, %d)\n", tskId, streamId);
        return NULL;
      }
    
      status = OSA_bufGetFull(pBufHndl, bufId, timeout);
      if(status!=OSA_SOK) {
        OSA_ERROR("OSA_bufGetFull(%d, %d, %d)\n", tskId, streamId, *bufId);
        return NULL;
      }
    
      return OSA_bufGetBufInfo(pBufHndl, *bufId);
    }
    
    OSA_BufInfo *AVSERVER_bufPutEmpty(int tskId, int streamId, int bufId)
    {
      OSA_BufHndl *pBufHndl;
      int status;
    
      status = AVSERVER_bufGetCurTskInfo(tskId, streamId, &pBufHndl);
      if(status!=OSA_SOK) {
        OSA_ERROR("AVSERVER_bufGetCurTskInfo(%d, %d)\n", tskId, streamId);
        return NULL;
      }
    
      status = OSA_bufPutEmpty(pBufHndl, bufId);
      if(status!=OSA_SOK) {
        OSA_ERROR("OSA_bufPutEmpty(%d, %d, %d)\n", tskId, streamId, bufId);
        return NULL;
      }
    
      return OSA_bufGetBufInfo(pBufHndl, bufId);
    }
    
    

    Thanks,

    Swathi

  • Hi Prabhakar,


    I was testing the patch provided by you. When I tried to compile the patch provided, it gave me davincifb_ioctl.h , davinci_osd.h, videodev2.h, davinci_display.h, videohd.h files missing.

    Although I have added these header files, I just want to confirm from you, if the kernel was to support v4l2 drivers, wouldn't all these header files be available ?

    Also, I want to know what is the driver and device nod being used in DM365 IPNC rdk 5.1.0 Avserver Code, because I find only /dev/video2 and /dev/video3 supported for display and not sure about the capture drivers being used.

    Thanks,

    Swathi

  • Hi,

    Although I have added these header files, I just want to confirm from you, if the kernel was to support v4l2 drivers, wouldn't all these header files be available ?

    The sample application which I pointed out is not related to IPNC RDK, Its for a PSP release which TI provides.

    Also, I want to know what is the driver and device nod being used in DM365 IPNC rdk 5.1.0 Avserver Code, because I find only /dev/video2 and /dev/video3 supported for display and not sure about the capture drivers being used.

    Sorry I am not aware about IPNC RDK

    Thanks,

    --Prabhakar