include <ofUCUtils.h>
  include <ofConstants.h>
  
  ifdef TARGET_LINUX
  
  include <stdio.h>
  include <stdint.h>
  include <ofUtils.h>
  
  // ugly hack to make this work with
  // new ffmpeg include path in ubuntu jaunty
  // with -MMD flag in the compiler
  // this will throw a warning instead of an error
  // comment out the two lines that doesn't work for you
  // to avoid the warnings
  extern "C"
  {
  include <avformat.h>
  include <swscale.h>
  include <libavformat/avformat.h>
  include <libswscale/swscale.h>
  }
  
  define FOURCC(a,b,c,d) (unsigned int)((((unsigned int)a))+(((unsigned int)b)<<8)+(((unsigned int)c)<<16)+(((unsigned int)d)<<24))
  
  typedef struct PixelFormatTag {
          PixelFormat pix_fmt;
      unsigned int fourcc;
  } PixelFormatTag;
  
  static const PixelFormatTag pixelFormatTags[] = {
          /* Planar formats */
      { PIX_FMT_YUV420P,         FOURCC('I', '4', '2', '0') },
      { PIX_FMT_YUV420P,         FOURCC('I', 'Y', 'U', 'V') },
      { PIX_FMT_YUV420P,         FOURCC('Y', 'V', '1', '2') },
      { PIX_FMT_YUV410P,         FOURCC('Y', 'U', 'V', '9') },
      { PIX_FMT_YUV411P,         FOURCC('Y', '4', '1', 'B') },
      { PIX_FMT_YUV422P,         FOURCC('Y', '4', '2', 'B') },
      { PIX_FMT_GRAY8,           FOURCC('Y', '8', '0', '0') },
      { PIX_FMT_GRAY8,           FOURCC(' ', ' ', 'Y', '8') },
  
      //v4l
      { PIX_FMT_GRAY8,           FOURCC('G', 'R', 'E', 'Y') },
      //{ PIX_FMT_...         FOURCC('H', '2', '4', '0') },        //HI420 BT848, seems to not exist in ffmpeg
      { PIX_FMT_RGB565,          FOURCC('R', 'G', 'B', '6') },        //RGB565
      { PIX_FMT_RGB555 ,         FOURCC('R', 'G', 'B', '5') },        //RGB15
      { PIX_FMT_RGB32,           FOURCC('R', 'G', 'B', '4') },        //RGB32
      { PIX_FMT_YUYV422,         FOURCC('Y', 'U', 'Y', 'V') },
      { PIX_FMT_UYYVYY411,FOURCC('Y', '4', '1', '1') },        //YUV411 is this correct??
      //FOURCC( 'R', 'A', 'W', ' ' );                                                //BT848, seems to not exist in ffmpeg
      { PIX_FMT_YUV422P,         FOURCC('Y', '4', '2', 'P') },        //YUV422P
      { PIX_FMT_YUV411P,         FOURCC('4', '1', '1', 'P') },        //YUV411P
      { PIX_FMT_YUV420P,         FOURCC('Y', 'U', '1', '2') },
  
      //v4l2
      { PIX_FMT_UYVY422,         FOURCC('U', 'Y', 'V', 'Y') },
      { PIX_FMT_YUV411P,         FOURCC('Y', '4', '1', 'P') },
      //{ PIX_FMT_YVU410P, FOURCC('Y', 'V', 'U', '9') },
      { PIX_FMT_YUV410P,         FOURCC('Y', 'U', 'V', '9') },         // is this correct or YUV410 non-planar
      { PIX_FMT_YUV422P,         FOURCC('4', '2', '2', 'P') },
      { PIX_FMT_YUV411P,         FOURCC('4', '1', '1', 'P') },
      { PIX_FMT_NV12,            FOURCC('N', 'V', '1', '2') },
      { PIX_FMT_NV21,            FOURCC('N', 'V', '2', '1') },
      { PIX_FMT_YUV422,          FOURCC('Y', 'Y', 'U', 'V') },
      { PIX_FMT_RGB32_1,         FOURCC('R', 'G', 'B', '1') },        // is this correct?
      { PIX_FMT_RGB555,          FOURCC('R', 'G', 'B', 'O') },
      { PIX_FMT_RGB565,          FOURCC('R', 'G', 'B', 'P') },
      //{ PIX_FMT_RGB555X,  FOURCC('R', 'G', 'B', 'Q') },
      //{ PIX_FMT_RGB565X,  FOURCC('R', 'G', 'B', 'R') },
      { PIX_FMT_BGR32,           FOURCC('B', 'G', 'R', '4') },
  
      //vid21394
      { PIX_FMT_YUYV422,         FOURCC('Y', 'U', 'Y', '2') },        // is this correct?
      { PIX_FMT_GRAY8,           FOURCC('Y', '8', '0', '0') },        // is this correct?
  
      /* dcam */
      { PIX_FMT_YUV444P,         FOURCC('Y', '4', '4', '4') },         // is this correct or non-planar?
      { PIX_FMT_GRAY16,          FOURCC('Y', '1', '6', '0') },         // is this correct?
      { PIX_FMT_RGB24,           FOURCC('R', 'G', 'B', ' ') },
  
      /* Packed formats */
      { PIX_FMT_YUYV422,         FOURCC('Y', 'U', 'Y', '2') },
      { PIX_FMT_YUYV422,         FOURCC('Y', '4', '2', '2') },
      { PIX_FMT_UYVY422,         FOURCC('U', 'Y', 'V', 'Y') },
      { PIX_FMT_GRAY8,           FOURCC('G', 'R', 'E', 'Y') },
      { PIX_FMT_RGB555,          FOURCC('R', 'G', 'B', 15) },
      { PIX_FMT_BGR555,          FOURCC('B', 'G', 'R', 15) },
      { PIX_FMT_RGB565,          FOURCC('R', 'G', 'B', 16) },
      { PIX_FMT_BGR565,          FOURCC('B', 'G', 'R', 16) },
      { PIX_FMT_BGR24,           FOURCC('B', 'G', 'R', '3') },
      { PIX_FMT_RGB24,           FOURCC('R', 'G', 'B', '3') },
  
      /* quicktime */
      { PIX_FMT_UYVY422,         FOURCC('2', 'v', 'u', 'y') },
      { PIX_FMT_UYVY422,         FOURCC('A', 'V', 'U', 'I') },
  
      { PIX_FMT_NONE, 0 },
  };
  
  //--------------------------------------------------------------------
  PixelFormat fourcc_to_pix_fmt( unsigned int fourcc)
  {
          const PixelFormatTag * tags = pixelFormatTags;
          while (tags->pix_fmt >= 0) {
                  if (tags->fourcc == fourcc)
                          return tags->pix_fmt;
          tags++;
      }
      return PIX_FMT_NONE;
  }
  
  //--------------------------------------------------------------------
  void new_frame_cb (unicap_event_t event, unicap_handle_t handle,
              unicap_data_buffer_t * buffer, void *usr_data){
  
          ((ofUCUtils*)usr_data)->new_frame(buffer);
  }
  
  //--------------------------------------------------------------------
  ofUCUtils::ofUCUtils(){
  
          verbose                        = false;
          bUCFrameNew                = false;
          pixels                        = NULL;
          src                                = NULL;
          dst                                = NULL;
          deviceReady                = false;
          doConversion        = false;
          pthread_mutex_init(&capture_mutex,NULL);
  }
  
  //--------------------------------------------------------------------
  ofUCUtils::~ofUCUtils(){
  
          close_unicap();
          pthread_mutex_destroy(&capture_mutex);
  }
  
  //--------------------------------------------------------------------
  bool ofUCUtils::open_device(int d) {
  
          if (!SUCCESS(unicap_enumerate_devices (NULL, &device, d))) {
                  ofLog(OF_LOG_ERROR,"ofUCUtils: Error selecting device \%d", d);
                  return false;
          } else {
  
                  if (!SUCCESS(unicap_open (&handle, &device))) {
                          ofLog(OF_LOG_ERROR,"ofUCUtils: Error opening device \%d: \%s", d,        device.identifier);
                          return false;
                  }
                  deviceReady = true;
          }
          ofLog(OF_LOG_NOTICE,"ofUCUtils: Using device \%s",device.device);
          ofLog(OF_LOG_NOTICE,"ofUCUtils: Using module \%s",device.vendor_name);
  
          return true;
  }
  
  //--------------------------------------------------------------------
  char * ofUCUtils::device_identifier(void){
  
          return device.identifier;
  
  }
  
  //--------------------------------------------------------------------
  // If a 24 bit video format is founded this is the preferred one, if not, the first
  // returned by unicap is selected.
  //
  // Then it tries to set the desired width and height, if these fails, tries find the
  // nearest size or to set the default width and height.
  //
  // On V4L devices 24 bit format is always BGR, so it needs conversion.
  // On some V4L devices using non-default width/heigth it reports BGR but returns RGB.
  // ffmpeg color conversion
  void ofUCUtils::set_format(int w, int h) {
          if(!deviceReady)
                  return;
          d_width=w;
          d_height=h;
          unicap_format_t formats[MAX_FORMATS];
          int format_count;
          unicap_status_t status = STATUS_SUCCESS;
          int rgb24 = -1;
  
          ofLog(OF_LOG_NOTICE,"ofUCUtils : Available formats for this device:");
          for (format_count = 0; SUCCESS (status) && (format_count < MAX_FORMATS); format_count++) {
                  status = unicap_enumerate_formats (handle, NULL, &formats[format_count], format_count);
                  if (SUCCESS (status)) {
                          if (formats[format_count].bpp == 24) {
                                  rgb24 = format_count;
                          }
                          ofLog(OF_LOG_NOTICE,
                                          "ofUCUtils : \%d: \%s, min size: \%dx\%d, max size:\%dx\%d, default size: \%dx\%d",
                                          format_count, formats[format_count].identifier,
                                          formats[format_count].min_size.width,
                                          formats[format_count].min_size.height,
                                          formats[format_count].max_size.width,
                                          formats[format_count].max_size.height,
                                          formats[format_count].size.width,
                                          formats[format_count].size.height);
                          ofLog(OF_LOG_VERBOSE,"ofUCUtils: available sizes for this format:");
                          for(int i=0; i<formats[format_count].size_count;i++){
                                  ofLog(OF_LOG_VERBOSE,"          \%dx\%d",formats[format_count].sizes[i].width,formats[format_count].sizes[i].height);
                          }
                  }
          }
  
          if (format_count > 0) {
                  int selected_format = 0;
                  if (rgb24 != -1)
                          selected_format = rgb24;
                  else{
                          for(selected_format=0;selected_format<format_count;selected_format++){
                                  format = formats[selected_format];
                                  if(fourcc_to_pix_fmt(format.fourcc)!=-1)
                                          break;
                          }
                  }
                  format = formats[selected_format];
  
                  src_pix_fmt=fourcc_to_pix_fmt(format.fourcc);
                  if( src_pix_fmt==-1){
                          ofLog(OF_LOG_ERROR,"ofUCUtils : Format not suported\n");
                          return;
                  }
  
                  bool exactMatch  = false;
                  int sizeDiff = 99999999;
                  int mostAproxSize = -1;
  
                  for(int i=0; i<format.size_count;i++){
                          if(format.sizes[i].width == w && format.sizes[i].height==h){
                                  exactMatch=true;
                                  format.size.width  = format.sizes[i].width;
                                  format.size.height = format.sizes[i].height;
                                  break;
                          }else{
                                  if(abs(format.sizes[i].width-w)+abs(format.sizes[i].height-h)<sizeDiff){
                                          sizeDiff=abs(format.sizes[i].width-w)+abs(format.sizes[i].height-h);
                                          mostAproxSize=i;
                                  }
                          }
                  }
                  if(!exactMatch && mostAproxSize!=-1){
                          format.size.width  = format.sizes[mostAproxSize].width;
                          format.size.height = format.sizes[mostAproxSize].height;
  
                          ofLog(OF_LOG_WARNING, "ofUCUtils : Can't set video format \%s, with size \%dx\%d, will use \%dx\%d",
                                                          format.identifier, w, h,
                                                          format.size.width, format.size.height);
                  }else if(format.size_count==0){
                          int defaultFormatWidth = format.size.width;
                          int defaultFormatHeight = format.size.height;
  
                          format.size.width  = w;
                          format.size.height = h;
  
                          ofLog(OF_LOG_WARNING, "ofUCUtils : Can't recognize supported video sizes for \%s, trying with requested size: \%i,\%i",
                                                                                  format.identifier, format.size.width, format.size.height);
  
                          if ( !SUCCESS ( unicap_set_format (handle, &format) ) ) {
                                  format.size.width  = defaultFormatWidth;
                                  format.size.height = defaultFormatHeight;
  
                                  ofLog(OF_LOG_WARNING, "ofUCUtils : Can't set requested size, trying with format defaults: \%i,\%i",
                                                  defaultFormatWidth, defaultFormatHeight);
                          }else{
                                  exactMatch=true; //if we can set the requested size -> exactMatch
                          }
                          ofLog(OF_LOG_WARNING, "ofUCUtils : If this doesn't work try using the reported default size in initGrabber:",
                                          defaultFormatWidth, defaultFormatHeight);
                  }
                  if ( !SUCCESS ( unicap_set_format (handle, &format) ) ) {
                          ofLog(OF_LOG_ERROR, "ofUCUtils : Failed to set alternative video format!");
                          return;
                  }
                  ofLog(OF_LOG_NOTICE,"ofUCUtils : Selected format: \%s, with size \%dx\%d\n", format.identifier,
                                  format.size.width, format.size.height);
  
                  if(src_pix_fmt!=PIX_FMT_RGB24 || !exactMatch){
                          doConversion = true;
                          src=new AVPicture;
                          avpicture_alloc(src,src_pix_fmt,format.size.width,format.size.height);
                          dst=new AVPicture;
                          avpicture_alloc(dst,PIX_FMT_RGB24,d_width,d_height);
  
                          toRGB_convert_ctx = sws_getContext(
                                                          format.size.width, format.size.height, src_pix_fmt,
                                                          d_width, d_height, PIX_FMT_RGB24,
                                                          VIDEOGRABBER_RESIZE_FLAGS, NULL, NULL, NULL);
  
                          ofLog(OF_LOG_NOTICE,"ofUCUtils: Converting to RGB24 (\%i,\%i)\n",w,h);
  
                          pixels=new unsigned char[d_width*d_height*3];
                  }
  
             if( !SUCCESS( unicap_get_format( handle, &format ) ) )
             {
                     ofLog(OF_LOG_ERROR, "can't get format" );
                     return;
             }
  
                  format.buffer_type = UNICAP_BUFFER_TYPE_SYSTEM;
  
             if( !SUCCESS( unicap_set_format( handle, &format ) ) )
             {
                     ofLog(OF_LOG_WARNING, "ofUCUtils: Failed to activate SYSTEM_BUFFERS" );
             }
          }
  }
  
  //--------------------------------------------------------------------
  void ofUCUtils::start_capture() {
  
          if(!deviceReady)
                  return;
  
          int status = STATUS_SUCCESS;
          if (!SUCCESS ( status = unicap_register_callback (handle, UNICAP_EVENT_NEW_FRAME, (unicap_callback_t) new_frame_cb, (void *) this) ) )
                  ofLog(OF_LOG_ERROR,"ofUCUtils: error registering callback");
          if (!SUCCESS ( status = unicap_start_capture (handle) ) )
                  ofLog(OF_LOG_ERROR,"ofUCUtils: error starting capture: \%i,\%i",status,STATUS_INVALID_HANDLE);
  }
  
  //--------------------------------------------------------------------
  void ofUCUtils::queryUC_imageProperties(void) {
  
          unicap_property_t property;
          ofLog(OF_LOG_NOTICE,"ofUCUtils : Video settings:");
          const int PPTY_TYPE_MAPPED_FLOAT=UNICAP_PROPERTY_TYPE_UNKNOWN + 1;
          int status = STATUS_SUCCESS;
          int ppty_type;
          for (int i=0; i<MAX_PROPERTIES; i++) {
                  status = unicap_enumerate_properties(handle, NULL, &property, i);
                  if ( !SUCCESS( status ))
                          return;
  
                  status = unicap_get_property(handle, &property );
                  if ( !SUCCESS( status )) {
                          ofLog(OF_LOG_ERROR,"ofUCUtils : Error getting \%s value\n", property.identifier);
                          return;
                  }
  
                  ppty_type = property.type;
                  switch (ppty_type) {
                  case PPTY_TYPE_MAPPED_FLOAT:
                  case UNICAP_PROPERTY_TYPE_RANGE:
                  case UNICAP_PROPERTY_TYPE_VALUE_LIST:
                          if (property.value>0 && property.value<1) {
                                  ofLog(OF_LOG_NOTICE,"\t\%s: 1/%.0f \n", property.identifier, 1/property.value);
                          } else {
                                  ofLog(OF_LOG_NOTICE,"\t\%s: %.2f \n", property.identifier, property.value);
                          }
                          break;
                  case UNICAP_PROPERTY_TYPE_MENU:
                          printf("\t\%s: \%s \n", property.identifier, property.menu_item);
                          break;
                  default:
                          break;
                  }
  
          }
  
  }
  
  //--------------------------------------------------------------------
  void ofUCUtils::new_frame (unicap_data_buffer_t * buffer)
  {
          if(!deviceReady)
                  return;
  
          if(doConversion){
                  avpicture_fill(src,buffer->data,src_pix_fmt,format.size.width,format.size.height);
  
                  if(sws_scale(toRGB_convert_ctx,
                          src->data, src->linesize, 0, buffer->format.size.height,
                          dst->data, dst->linesize)<0)
                                  ofLog(OF_LOG_ERROR,"ofUCUtils: can't convert colorspaces");
  
                  lock_buffer();
                          avpicture_layout(dst,PIX_FMT_RGB24,d_width,d_height,pixels,d_width*d_height*3);
  
          }else{
                  lock_buffer();
                          pixels=buffer->data;
          }
          bUCFrameNew = true;
          unlock_buffer();
  }
  
  //--------------------------------------------------------------------
  bool ofUCUtils::getFrameUC(unsigned char ** _pixels) {
          if(bUCFrameNew){
                  lock_buffer();
                  bUCFrameNew = false;
                  memcpy(*_pixels,pixels,d_width*d_height*3);
                  //*_pixels=pixels;
                  unlock_buffer();
                  return true;
          }else{
                  return false;
          }
  }
  
  //--------------------------------------------------------------------
  void ofUCUtils::listUCDevices() {
  
          int status = STATUS_SUCCESS;
          int dev_count;
          unicap_device_t devices[MAX_DEVICES];
          printf("listing available capture devices\n");
          printf("---\n");
          for (dev_count = 0; SUCCESS (status) && (dev_count < MAX_DEVICES); dev_count++) {
                  status = unicap_enumerate_devices (NULL, &devices[dev_count], dev_count);
                  if (SUCCESS (status))
                          printf ("Video device \%d: \%s\n", dev_count,
                                          devices[dev_count].identifier);
          }
          printf("---\n");
  
  }
  
  void ofUCUtils::close_unicap() {
  
          if(!deviceReady)
                  return;
  
          unicap_stop_capture(handle);
          bUCFrameNew=false;
  
          if( src_pix_fmt != PIX_FMT_RGB24 ){
  
                  if ( dst != NULL ){
                          avpicture_free(dst);
                          delete dst;
                  }
  
                  if ( pixels != NULL ) {
                          delete[] pixels;
                  }
  
                  if ( src != NULL ){
                          //avpicture_free(src);
                          delete src;
                  }
  
          }
          deviceReady=false;
  
  }
  
  //--------------------------------------------------------------------
  void ofUCUtils::lock_buffer(){
          pthread_mutex_lock( &capture_mutex );
  }
  
  //--------------------------------------------------------------------
  void ofUCUtils::unlock_buffer(){
          pthread_mutex_unlock( &capture_mutex );
  }
  
  endif