How do i write a comparable cffi:translate-into foreign defmethod for this cffi:translate-from-foreign?

Question 1

This should be the exact reverse definition to your translate-from-foreign method definition. I can't test it right now, but you might want to try if it works:

(defmethod cffi:translate-to-foreign (value (type cv-size-type))
  (let ((plist ()))
    (setf (getf plist 'width) (size-width value)
          (getf plist 'height) (size-height value))
    (call-next-method plist type)))

As the other answer correctly points out, you definitely must change the type for size in the defcfun from :int64 to (:struct cv-size), otherwise this method won't be called.

Question 2

Update 2016-10-12

Here is a demo much better and really simple!

You just have to add :class xxx to cffi:defcstruct then (cffi:defmethod translate-into-foreign-memory (object (type xxx) pointer) yyyy), it will pass structure by value to a foreign function automatically!! Amazing!!

And (cffi:defmethod translate-from-foreign (pointer (type xxx)) zzzz) will convert the returned structure data into lisp data.

OK, here is the code:

(defcstruct (%CvSize :class cv-size)
  (width :int)
  (height :int))
(defmethod translate-into-foreign-memory (object (type cv-size) pointer)
  (with-foreign-slots ((width height) pointer (:struct %CvSize))
    ;; After this declare this method, you could just pass a two member
    ;;   list as a (:struct %CvSize)
    (setf width (nth 0 object))
    (setf height (nth 1 object))))
(defmethod translate-from-foreign (pointer (type cv-size))
  (with-foreign-slots ((width height) pointer (:struct %CvSize))
    ;; You can change this and get return value in other format
    ;; for example: (values width height)
    (list width height)))
(defcfun ("cvGetSize" %cvGetSize)
    (:struct %CvSize) ;; Here must use (:struct xxx)
  "C: CvSize cvGetSize(const CvArr* arr)"
  (arr :pointer))
(defcfun ("cvCreateImage" %cvCreateImage)
    %IplImage
  "C: IplImage* cvCreateImage(CvSize size, int depth, int channels)"
  (size (:struct %CvSize)) ;; Here must use (:struct xxx)
  (depth %IPL_DEPTH)
  (channels :int))

Test code for `%cvGetSize`:

(defmacro with-pointer-to-pointer ((var pointer) &body body)
  `(with-foreign-object (,var :pointer)
     (setf (mem-ref ,var :pointer)
           ,pointer)
     (progn ,@body)))
(defun release-image (image)
  (with-pointer-to-pointer (pointer image)
    (%cvReleaseImage pointer)))
(defmacro with-load-image ((var filename &optional (iscolor :%CV_LOAD_IMAGE_COLOR)) &body body)
  "Wrap %cvLoadImage and make sure %cvReleaseImage."
  (let ((result (gensym)))
    `(let ((,var (%cvLoadImage ,filename ,iscolor))
           ,result)
       (unwind-protect
            (setf ,result
                  (multiple-value-list (progn ,@body)))
         (release-image ,var))
       (values-list ,result))))
(defun image-width-height (filename)
  (with-load-image (image filename)
    (%cvGetSize image)))
(image-width-height "/path/to/image.jpg")
;;=>
;; (962 601)

Note: return value is no longer a pointer or something weird, it return a list(you can change the code in (cffi:defmethod translate-from-foreign () xxxx) to make it convert the returned value to other types.

Test code for `%cvCreateImage`:

(%cvCreateImage (list 480 640))

Note: Yeah! Just pass a list and will be automatically convert to (:struct %CvSize) ! That is great, isn't it?!!! No need to use make-instance or other weird code anymore ^_^

Note: of cause you have to cffi:define-foreign-libray and cffi:use-foreign-library first like this:

(cffi:define-foreign-library opencv-highgui
  (:darwin (:or "libopencv_highgui.dylib"))
  (:linux (:or "libhighgui.so"
               "libopencv_highgui.so"))
  (t (:default "libhighgui")))

(cffi:use-foreign-library opencv-highgui)

Old answer below(please ignore this ugly solution!)

Here is the code works fine:

(cffi:define-foreign-type cv-size ()
  ((width :reader width :initarg :width)
   (height :reader height :initarg :height))
  (:actual-type :int64)
  (:simple-parser %cv-size))
(defmethod translate-to-foreign (value (type cv-size))
  (+ (width value)
     (ash (height value) 32)))
(defmethod translate-from-foreign (value (type cv-size))
  (values (- value
             (ash (ash value -32) 32))
          (ash value -32)))
(cffi:defcfun ("cvGetSize" %cvGetSize)
    %cv-size
  "C: CvSize cvGetSize(const CvArr* arr)"
  (arr :pointer))
(cffi:defcfun ("cvCreateImage" %cvCreateImage)
    %IplImage
  "C: IplImage* cvCreateImage(CvSize size, int depth, int channels)"
  (size %cv-size)
  (depth %IPL_DEPTH)
  (channels :int))

Note: (:actual-type :int64) means the actual type of cv-size is :int64(C int64).

Note: (:simple-parser %cv-size) means you can place %cv-size to return-type or parameter-type like :pointer :int do in cffi:defcfun. Please take a look at the declaration %cvGetSize and %cvCreateImage.

Test code for %cvGetSize:

(defmacro with-pointer-to-pointer ((var pointer) &body body)
  `(with-foreign-object (,var :pointer)
     (setf (mem-ref ,var :pointer)
           ,pointer)
     (progn ,@body)))
(defun release-image (image)
  (with-pointer-to-pointer (pointer image)
    (%cvReleaseImage pointer)))
(defmacro with-load-image ((var filename &optional (iscolor :%CV_LOAD_IMAGE_COLOR)) &body body)
  "Wrap %cvLoadImage and make sure %cvReleaseImage."
  (let ((result (gensym)))
    `(let ((,var (%cvLoadImage ,filename ,iscolor))
           ,result)
       (unwind-protect
            (setf ,result
                  (multiple-value-list (progn ,@body)))
         (release-image ,var))
       (values-list ,result))))
(defun image-width-height (filename)
  (with-load-image (image filename)
    (%cvGetSize image)))
(image-width-height "/path/to/image.jpg")
;;=>
;; 962
;; 601

Test code for %cvCreateImage:

(%cvCreateImage (make-instance 'cv-size
                               :width 480
                               :height 640))

Note: of cause you have to cffi:define-foreign-libray and cffi:use-foreign-library first like this:

(cffi:define-foreign-library opencv-highgui
  (:darwin (:or "libopencv_highgui.dylib"))
  (:linux (:or "libhighgui.so"
               "libopencv_highgui.so"))
  (t (:default "libhighgui")))

(cffi:use-foreign-library opencv-highgui)

Question 3

From what I can see in CFFI's code, you may use the following as a top-level form instead of defining your own translate-from-foreign and translate-into-foreign-memory (or translate-to-foreign):

(cffi:translation-forms-for-class cv-size cv-size-type)

EDIT: Some notes about your defcfuns.

The defcfun for cvGetSize should declare the argument as (:pointer cv-arr), I think. I don't know how cv-arr is declared.

The defcfun for cvCreateImage should pass a (:struct cv-size) instead of :int64. The former is supposed to be correct on all platforms, while the latter may not work where int is not 32-bit, where field alignment makes the struct not be compact and where the total size of the struct may be different from sizeof(int) + sizeof(int).

Still on cvCreateImage, it should return a (:pointer ipl-image), although I'm not sure if structs are handled by value or by pointer when the type is not directly (:struct <name>). Better check this out at the CFFI mailing list, or chatting in #lisp @ irc.freenode.net.