Hello Every One

I'm using Qt 4.7. I've done the camera project with that I'm able to capture the images but unable to record the video....can any one please help me??
Qt Code: 
  1. struct v4l2_buffer buf;
  2. unsigned int i,size,buf_size;
  3. char filename[] = "quickcam-0000.jpg";
  4. int dev, ret;
  5. FILE *file;
  6. void *mem;
  7.  
  8. unsigned char data[65000];
  9.  
  10.  
  11.  
  12.  
  13. WebCam::WebCam( QWidget *parent  ): QWidget( parent )
  14.  
  15. {
  16.  
  17.     setWindowTitle("Project : Qt/E USB Camera Image capture");
  18.  
  19.     resize( QSize(320, 240).expandedTo(minimumSizeHint()) );
  20.  
  21.     video_open("/dev/video0");
  22.  
  23.     QPixmap pixmap("logo.png");
  24.  
  25.         qDebug("Testing......................!! \n");
  26.  
  27.         QSplashScreen splash(pixmap);
  28.         splash.showMessage("Initialize...", 0,"Red");
  29.         qApp->processEvents();
  30.  
  31.         sleep(3);
  32.  
  33.         splash.finish(&splash);
  34.         splash.deleteLater();
  35.  
  36.         video_set_format();
  37.         video_reqbufs();
  38.         map_the_buffers();
  39.         Queue_the_buffers();
  40.         video_enable(dev,1);
  41.         start_streaming();
  42.         changepmBKImage();
  43.         m_ppmPaint = new QPixmap(320, 240);
  44.  
  45.         capt = new QTimer( this );
  46.         capt->start(1);
  47.         connect( capt, SIGNAL(timeout()), SLOT(slotTimeout()) );
  48. }
  49.  
  50. WebCam::~WebCam()
  51. {
  52.         qDebug("Testing......................1 \n");
  53.         qWarning("USB-WebCamera exit!! \n");
  54.         capt->stop();
  55.         video_enable(dev,0);
  56.         munmap(mem,buf.length);
  57.         close();
  58. }
  59.  
  60. void WebCam::start_streaming()
  61. {
  62.  
  63.     DIR* FD;
  64.     struct dirent* in_file;
  65.     char    buffer[40];
  66.     char *last_four = &buffer[9];
  67.     char   num[5];
  68.     int number,final=0;
  69.  
  70.         qDebug("Start streaming..................@1 \n");
  71.  
  72.         memset(&buf, 0, sizeof buf);
  73.         buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
  74.         buf.memory = V4L2_MEMORY_MMAP;
  75.         ret = ioctl(dev, VIDIOC_DQBUF, &buf);
  76.         if (ret < 0)
  77.         {
  78.             qDebug("Start streaming..................@2 \n");
  79.             printf("Unable to dequeue buffer (%d).\n", errno);
  80.             close();
  81.         }
  82.  
  83.  
  84.  if (NULL == (FD = opendir ("/home/stesalit/Desktop/images")))
  85.     {
  86.         fprintf(stderr, "Error : Failed to open input directory\n");
  87.  
  88.     }
  89.     while ((in_file = readdir(FD)))
  90.     {
  91.  
  92.         if (!strcmp (in_file->d_name, "."))
  93.             continue;
  94.         if (!strcmp (in_file->d_name, ".."))
  95.             continue;
  96.         strcpy(buffer,in_file->d_name);
  97.         strcpy(num,last_four);
  98.         number = atoi(num);
  99.         if (number > final)
  100.         final = number;
  101.  
  102.     }
  103.  
  104.         // Save the image.
  105.  
  106.         sprintf(filename, "/home/stesalit/Desktop/images/quickcam-%03u.jpg", final+1);
  107.  
  108.         file = fopen(filename, "wb");
  109.         if (file != NULL)
  110.         {
  111.                 unsigned char *input;
  112.                 int input_size;
  113.                 unsigned char *output;
  114.                 //QWidgetData *output;
  115.                 qDebug("Start streaming..................@4 \n");
  116.                 input = (unsigned char*)mem;
  117.                 input_size=buf.bytesused;
  118.                 int has_dht = 0;
  119.                 output = (unsigned char*)data;
  120.                 unsigned char hdr[4];
  121.                 int o_count=0;
  122.                 int r_count=0;
  123.                 int size;
  124.                 output[o_count++]=0xFF;
  125.                 output[o_count ++]=0xD8;
  126.                 r_count += 2;
  127.  
  128.                 while(!has_dht)
  129.                 {
  130.                     qDebug("Start streaming..................@5 \n");
  131.  
  132.                         memcpy(hdr, input+r_count, 4);
  133.                         r_count += 4;
  134.  
  135.                         if(hdr[1]==0xC4) has_dht = 1;
  136.                         else if(hdr[1]==0xDA) break;
  137.  
  138.                         // skip to the next marker
  139.                         size = (hdr[2]<<8) + hdr[3];
  140.                         memcpy(output+o_count, hdr, 4);
  141.                         o_count += 4;
  142.  
  143.                         memcpy(output+o_count, input+r_count, size-2);
  144.  
  145.                         r_count += (size-2);
  146.                         o_count += (size-2);
  147.                 }
  148.  
  149.                 if(!has_dht)
  150.                 {
  151.                         memcpy(output+o_count, huffman_table, sizeof(huffman_table));
  152.                         o_count += sizeof(huffman_table);
  153.                         memcpy(output+o_count, hdr, 4);
  154.                         o_count += 4;
  155.                 }
  156.                 // Process the remaining data in one go
  157.                 memcpy(output+o_count, input+r_count, input_size-r_count);
  158.                 o_count += (input_size-r_count);
  159.                 r_count += (input_size-r_count);
  160.  
  161.                 input=NULL;
  162.                 output=NULL;
  163.                 fwrite(data,o_count,1,file);
  164.                 fclose(file);
  165.         }
  166.  
  167.         // Requeue the buffer.
  168.         ret = ioctl(dev, VIDIOC_QBUF, &buf);
  169.         if (ret < 0)
  170.         {
  171.                  printf("Unable to requeue buffer (%d).\n", errno);
  172.                  close();
  173.         }
  174.  
  175.         fflush(stdout);
  176. }
  177.  
  178.  
  179. void WebCam::Queue_the_buffers()
  180. {
  181.         memset(&buf, 0, sizeof buf);
  182.         buf.index = VAL;
  183.         buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
  184.         buf.memory = V4L2_MEMORY_MMAP;
  185.         ret = ioctl(dev, VIDIOC_QBUF, &buf);
  186.         if (ret < 0)
  187.         {
  188.                 printf("Unable to queue buffer (%d).\n", errno);
  189.                 close();
  190.         }
  191. }
  192.  
  193.  
  194. void WebCam::map_the_buffers()
  195. {
  196.         memset(&buf, 0, sizeof buf);
  197.         buf.index = VAL;
  198.         buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
  199.         buf.memory = V4L2_MEMORY_MMAP;
  200.         ret = ioctl(dev, VIDIOC_QUERYBUF, &buf);
  201.         if (ret < 0)
  202.         {
  203.                 printf("Unable to query buffer %u (%d).\n", VAL, errno);
  204.                 close();
  205.         }
  206.  
  207.         printf("length: %u offset: %u\n", buf.length, buf.m.offset);
  208.  
  209.         mem = mmap(0, buf.length, PROT_READ, MAP_SHARED, dev, buf.m.offset);
  210.         if (mem == MAP_FAILED)
  211.         {
  212.                 printf("Unable to map buffer %u (%d)\n", VAL, errno);
  213.                 close();
  214.         }
  215.         printf("Buffer %u mapped at address %p\n", VAL, mem);
  216. }
  217.  
  218. int WebCam::video_set_format()
  219. {
  220.         struct v4l2_format fmt;
  221.  
  222.         memset(&fmt, 0, sizeof fmt);
  223.         fmt.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
  224.         fmt.fmt.pix.width = 320;
  225.         fmt.fmt.pix.height = 240;
  226.         fmt.fmt.pix.pixelformat = V4L2_PIX_FMT_MJPEG;
  227.         fmt.fmt.pix.field = V4L2_FIELD_ANY;
  228.  
  229.         ret = ioctl(dev, VIDIOC_S_FMT, &fmt);
  230.         if (ret < 0) {
  231.                 printf("Unable to set format: %d.\n", errno);
  232.                 return ret;
  233.         }
  234.  
  235.         printf("Video format set: width: %u height: %u buffer size: %u\n",
  236.                       fmt.fmt.pix.width, fmt.fmt.pix.height, fmt.fmt.pix.sizeimage);
  237.  
  238.         return 0;
  239. }
  240.  
  241. int WebCam::video_reqbufs()
  242. {
  243.         struct v4l2_requestbuffers rb;
  244.  
  245.         memset(&rb, 0, sizeof rb);
  246.         rb.count = 16;
  247.         rb.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
  248.         rb.memory = V4L2_MEMORY_MMAP;
  249.  
  250.         ret = ioctl(dev, VIDIOC_REQBUFS, &rb);
  251.         if (ret < 0)
  252.         {
  253.              printf("Unable to allocate buffers: %d.\n", errno);
  254.              return ret;
  255.         }
  256.  
  257.         printf("%u buffers allocated.\n", rb.count);
  258.         return 0;
  259. }
  260.  
  261. int WebCam::video_enable(int dev, int enable)
  262. {
  263.         int type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
  264.  
  265.         ret = ioctl(dev, enable ? VIDIOC_STREAMON : VIDIOC_STREAMOFF, &type);
  266.         if (ret < 0) {
  267.                 printf("Unable to %s capture: %d.\n", enable ? "start" : "stop", errno);
  268.                 return ret;
  269.         }
  270.  
  271.         return 0;
  272. }
  273.  
  274. int WebCam::video_open(const char *devname)
  275. {
  276.         struct v4l2_capability cap;
  277.  
  278.         dev = open(devname, O_RDWR);
  279.         if (dev < 0) {
  280.                 printf("Error opening device %s: %d.\n", devname, errno);
  281.                 exit(1);
  282.         }
  283.  
  284.         memset(&cap, 0, sizeof cap);
  285.         ret = ioctl(dev, VIDIOC_QUERYCAP, &cap);
  286.         if (ret < 0) {
  287.                 printf("Error opening device %s: unable to query device.\n",devname);
  288.                 close();
  289.                 return ret;
  290.         }
  291.  
  292.         if ((cap.capabilities & V4L2_CAP_VIDEO_CAPTURE) == 0) {
  293.                 printf("Error opening device %s: video capture not supported.\n",
  294.                                 devname);
  295.                 close();
  296.                 return -EINVAL;
  297.         }
  298.  
  299.        printf("Device %s opened: %s.\n", devname, cap.card);
  300.        return dev;
  301. }
  302.  
  303. void WebCam::slotTimeout()
  304. {
  305.         start_streaming();
  306.         changepmBKImage();
  307.         repaint();
  308. }
  309.  
  310. void WebCam::paintEvent( QPaintEvent * )
  311. {
  312.         QPainter painter(this);
  313.  
  314.         drawImage();
  315.  
  316.         painter.drawPixmap(0, 0, *m_ppmPaint);
  317. }
  318.  
  319. void WebCam::changepmBKImage()
  320. {
  321.         QString strFilename;
  322.  
  323.  
  324.         strFilename.sprintf("/root/quickcam-%03d.jpg", VAL1);
  325.  
  326.         if (!m_pmBk.load(strFilename)) {
  327.                 qDebug("QPixmap load error\n");
  328.         }
  329. }
  330.  
  331. void WebCam::drawImage()
  332. {
  333.         QMatrix matrix;
  334.         QPainter painter(this);
  335.         QString  strTime;
  336.  
  337.        matrix.scale(-1.0,1.0);
  338.  
  339.        resize(width(),height());
  340.  
  341.        painter.begin(m_ppmPaint);
  342.  
  343.        painter.drawPixmap(QPoint(0,0),m_pmBk);
  344.  
  345.        painter.begin(this);
  346.        painter.end();
  347.  
  348.  
  349. }
To copy to clipboard, switch view to plain text mode