Author: qboosh Date: Sun Jan 23 16:29:00 2011 GMT Module: packages Tag: HEAD ---- Log message: - added avt patch (AVT cameras support enhancement from vendor) - P: libdc1394*(avt) - release 2
---- Files affected: packages/libdc1394: libdc1394.spec (1.31 -> 1.32) , libdc1394-avt.patch (NONE -> 1.1) (NEW) ---- Diffs: ================================================================ Index: packages/libdc1394/libdc1394.spec diff -u packages/libdc1394/libdc1394.spec:1.31 packages/libdc1394/libdc1394.spec:1.32 --- packages/libdc1394/libdc1394.spec:1.31 Thu Jan 6 09:23:39 2011 +++ packages/libdc1394/libdc1394.spec Sun Jan 23 17:28:55 2011 @@ -7,13 +7,15 @@ Summary(pl.UTF-8): Biblioteka dla specyfikacji Kamera Cyfrowa 1394 Name: libdc1394 Version: 2.1.3 -Release: 1 +Release: 2 License: LGPL v2.1+ Group: Libraries Source0: http://downloads.sourceforge.net/libdc1394/%{name}-%{version}.tar.gz # Source0-md5: d8b2cbfae1b329fdeaa638da80427334 Patch0: %{name}-link.patch Patch1: %{name}-ac.patch +# libdc1394-2.1.2 vs libdc1394_avt-2.1.2 diff (http://www.alliedvisiontec.com/fileadmin/content/PDF/Software/AVT_software/zip_files/AVTFire4Linux3v0.src.tar/libdc1394_avt-2.1.2.tar.gz) +Patch2: %{name}-avt.patch URL: http://sourceforge.net/projects/libdc1394/ BuildRequires: autoconf >= 2.60 BuildRequires: automake >= 1:1.9.6 @@ -24,6 +26,7 @@ BuildRequires: xorg-lib-libX11-devel BuildRequires: xorg-lib-libXext-devel BuildRequires: xorg-lib-libXv-devel +Provides: libdc1394(avt) = %{version}-%{release} Requires: libraw1394 >= 1.2.0 Requires: libusb >= 1.0 BuildRoot: %{tmpdir}/%{name}-%{version}-root-%(id -u -n) @@ -45,6 +48,7 @@ Summary: libdc1394 header files Summary(pl.UTF-8): Pliki nagłówkowe libdc1394 Group: Development/Libraries +Provides: libdc1394-devel(avt) = %{version}-%{release} Requires: %{name} = %{version}-%{release} Requires: libraw1394-devel >= 1.2.0 Requires: libusb-devel >= 1.0 @@ -59,6 +63,7 @@ Summary: Static libdc1394 library Summary(pl.UTF-8): Statyczna biblioteka libdc1394 Group: Development/Libraries +Provides: libdc1394-static(avt) = %{version}-%{release} Requires: %{name}-devel = %{version}-%{release} %description static @@ -71,6 +76,7 @@ %setup -q %patch0 -p1 %patch1 -p1 +%patch2 -p1 %build %{__libtoolize} @@ -90,6 +96,7 @@ # man pages for noinst examples %{__rm} $RPM_BUILD_ROOT%{_mandir}/man1/{dc1394_multiview,grab_{color,gray,partial}_image}.1 +%{__rm} $RPM_BUILD_ROOT%{_mandir}/man1/avt_singleview.1 %clean rm -rf $RPM_BUILD_ROOT @@ -126,6 +133,11 @@ All persons listed below can be reached at <cvs_login>@pld-linux.org $Log$ +Revision 1.32 2011/01/23 16:28:55 qboosh +- added avt patch (AVT cameras support enhancement from vendor) +- P: libdc1394*(avt) +- release 2 + Revision 1.31 2011/01/06 08:23:39 qboosh - updated to 2.1.3 ================================================================ Index: packages/libdc1394/libdc1394-avt.patch diff -u /dev/null packages/libdc1394/libdc1394-avt.patch:1.1 --- /dev/null Sun Jan 23 17:29:01 2011 +++ packages/libdc1394/libdc1394-avt.patch Sun Jan 23 17:28:55 2011 @@ -0,0 +1,7522 @@ +diff -Nur libdc1394-2.1.2/dc1394/bayer_avt.c libdc1394_avt-2.1.2/dc1394/bayer_avt.c +--- libdc1394-2.1.2/dc1394/bayer_avt.c 1970-01-01 01:00:00.000000000 +0100 ++++ libdc1394_avt-2.1.2/dc1394/bayer_avt.c 2010-01-12 16:30:41.000000000 +0100 +@@ -0,0 +1,342 @@ ++/* ++ * 1394-Based Digital Camera Control Library ++ * ++ * AVT Bayer pattern decoding functions ++ * ++ * Copyright (C) 2010 Allied Vision Technologies GmbH ++ * ++ * This library is free software; you can redistribute it and/or ++ * modify it under the terms of the GNU Lesser General Public ++ * License as published by the Free Software Foundation; either ++ * version 2.1 of the License, or (at your option) any later version. ++ * ++ * This library is distributed in the hope that it will be useful, ++ * but WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ * Lesser General Public License for more details. ++ * ++ * You should have received a copy of the GNU Lesser General Public ++ * License along with this library; if not, write to the Free Software ++ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA ++ */ ++ ++#include <stdint.h> ++#include <dc1394/types.h> ++#include <dc1394/log.h> ++#include <string.h> ++ ++#ifndef MIN ++ #define MIN(a,b) ((a) < (b) ? (a) : (b)) ++#endif ++#ifndef MAX ++ #define MAX(a,b) ((a) < (b) ? (b) : (a)) ++#endif ++ ++//! Structure for accessing data in the YUV 4:4:4 format (YUV) ++typedef struct ++{ ++ uint8_t Y; //!< Luma ++ uint8_t U; //!< U ++ uint8_t V; //!< V ++} S_YUV444; ++ ++//! Structure for accessing data in the YUV 4:2:2 format (UYVY) ++typedef struct ++{ ++ uint8_t U; //!< the U part for both pixels ++ uint8_t Y0; //!< the intensity of the first pixel ++ uint8_t V; //!< the V part for both pixels ++ uint8_t Y1; //!< the intensity of the second pixel ++} S_YUV422; ++ ++//! Structure for accessing data in the 24 bit RGB format ++typedef struct ++{ ++ uint8_t R; //!< red ++ uint8_t G; //!< green ++ uint8_t B; //!< blue ++} S_RGB8; ++ ++//////////////////////////////////////////////////////////////////////////////// ++// Convert raw mode with 8 bit values ++//////////////////////////////////////////////////////////////////////////////// ++ ++void dc1394_avt_Raw8ToYUV444(uint8_t *pDst1, const uint8_t *pSrc, uint32_t XSize, uint32_t YSize, dc1394color_filter_t bayerPattern) ++{ ++ const uint8_t *pBuf = pSrc; ++ const uint8_t *pR,*pB,*pG0,*pG1; // G0:the green pixel in the same column as the red pixel ++ uint32_t i,j; ++ S_YUV444 *pDst = (S_YUV444*) pDst1; ++ uint32_t uColorOffsetY = (uint32_t) bayerPattern/2; ++ uint32_t uColorOffsetX = (uint32_t) bayerPattern%2; ++ int16_t U; ++ int16_t V; ++ uint8_t G; ++ ++ ++ for(i=uColorOffsetY; i<YSize+uColorOffsetY-1; i++,pBuf+=XSize) ++ { ++ switch((i&1)+2*uColorOffsetX) ++ { ++ case 3: ++ pB = pBuf; ++ pG0 = pB+1; ++ pG1 = pB+XSize; ++ pR = pG1+1; ++ break; ++ case 2: ++ pG1 = pBuf; ++ pR = pG1+1; ++ pB = pG1+XSize; ++ pG0 = pB+1; ++ break; ++ case 1: ++ pG0 = pBuf; ++ pB = pG0+1; ++ pR = pG0+XSize; ++ pG1 = pR+1; ++ break; ++ case 0: ++ default: ++ pR = pBuf; ++ pG1 = pR+1; ++ pG0 = pR+XSize; ++ pB = pG0+1; ++ break; ++ } ++ ++ // Go through all pixels ++ for(j=uColorOffsetX;j<XSize+uColorOffsetX-1;j++) ++ { ++ G = (uint8_t)(((uint16_t)*pG0+*pG1)/2); ++ U = ((*pB)<<7) - 43* *pR - 85* G; ++ V = ((*pR)<<7) -107* G - 21* *pB; ++ pDst->Y = (uint8_t)(( 77* *pR +150* G + 29* *pB) >>8); ++ pDst->U = (uint8_t)((U>>8) + 128); ++ pDst->V = (uint8_t)((V>>8) + 128); ++ ++ pDst++; ++ ++ if(j&1) ++ { ++ pB +=2; ++ pG1 +=2; ++ } ++ else ++ { ++ pR +=2; ++ pG0 +=2; ++ } ++ } ++ pDst->Y = (pDst-1)->Y; ++ pDst->U = (pDst-1)->U; ++ pDst->V = (pDst-1)->V; ++ ++ pDst++; ++ } ++ ++ memcpy(pDst,pDst-XSize,XSize*sizeof(S_YUV444)); ++} ++ ++ ++/* ++ * Inplace YUV444->YUV422 conversion with horizontal averaging. ++ * A 4x1 averaging window is used. ++ * Image width is expected to be a multiple of 2. ++ * The resulting data is not packed in YUV 422 format, data format is still YUV444. ++ * However, valid U and V components are stored only for pixels with even X-coordinate. ++ */ ++void dc1394_avt_YUV_averaging_4(uint8_t *pDst, uint32_t XSize, uint32_t YSize) ++{ ++ S_YUV444 *dst = (S_YUV444*) pDst; ++ ++ S_YUV444 *pLineEnd = dst + XSize - 4; ++ S_YUV444 *pFrameEnd = dst + (XSize*YSize) - 2; ++ ++ for(;;) ++ { ++ dst[0].U = (uint8_t) ( ( (uint16_t) dst[0].U + dst[1].U + dst[2].U + dst[3].U ) / 4 ); ++ dst[0].V = (uint8_t) ( ( (uint16_t) dst[0].V + dst[1].V + dst[2].V + dst[3].V ) / 4 ); ++ ++ if( dst == pLineEnd ) ++ { ++ /* a smaller averaging window is used for the last column */ ++ dst += 2; ++ dst[0].U = (uint8_t) ( ( (uint16_t) dst[0].U + dst[1].U ) / 2 ); ++ dst[0].V = (uint8_t) ( ( (uint16_t) dst[0].V + dst[1].V ) / 2 ); ++ if( dst == pFrameEnd ) ++ { ++ break; ++ } ++ pLineEnd += XSize; ++ } ++ dst += 2; ++ } ++} ++ ++ ++/* ++ * Inplace YUV444->YUV422 conversion with horizontal averaging. ++ * A 2x1 averaging window is used. ++ * Image width is expected to be a multiple of 2. ++ * The resulting data is not packed in YUV 422 format, data format is still YUV444. ++ * However, valid U and V components are stored only for pixels with even X-coordinate. ++ */ ++void dc1394_avt_YUV_averaging_2(void *pDst, uint32_t XSize, uint32_t YSize) ++ ++{ ++ ++ S_YUV444 *dst = (S_YUV444*) ( pDst); ++ ++ S_YUV444 *pFrameEnd = dst+(XSize*YSize); ++ ++ for(;;) ++ { ++ dst[0].U = (uint8_t) ( ( (uint16_t) dst[0].U + dst[1].U ) / 2 ); ++ dst[0].V = (uint8_t) ( ( (uint16_t) dst[0].V + dst[1].V ) / 2 ); ++ dst += 2; ++ if( dst >= pFrameEnd ) ++ { ++ break; ++ } ++ } ++} ++ ++ ++/* ++ * Inplace YUV444->YUV422 conversion with horizontal averaging. ++ * A 4x2 averaging window is used. ++ * Image width is expected to be a multiple of 2. ++ * The resulting data is not packed in YUV 422 format, data format is still YUV444. ++ * However, valid U and V components are stored only for pixels with even X-coordinate. ++ */ ++void dc1394_avt_YUV_averaging_42(uint8_t *pDst, uint32_t XSize, uint32_t YSize) ++{ ++ S_YUV444 *pYUV = (S_YUV444 *) pDst; ++ S_YUV444 *pYUV_NextRow = pYUV + XSize; ++ S_YUV444 *pLineEnd = pYUV + XSize - 4; ++ S_YUV444 *pFrameEnd = pYUV + (XSize*(YSize-1)); ++ ++ /* special treatment for first pixel */ ++ pYUV[0].U = (uint8_t) ( ( (uint16_t) pYUV[0].U + pYUV[1].U + pYUV[2].U + ++ pYUV_NextRow[0].U + pYUV_NextRow[1].U + pYUV_NextRow[2].U + 3 ) / 6 ); ++ pYUV[0].V = (uint8_t) ( ( (uint16_t) pYUV[0].V + pYUV[1].V + pYUV[2].V + ++ pYUV_NextRow[0].V + pYUV_NextRow[1].V + pYUV_NextRow[2].V + 3 ) / 6 ); ++ ++ for (;;) ++ { ++ /* main loop - standard processing */ ++ pYUV += 2; ++ pYUV_NextRow += 2; ++ pYUV[0].U = (uint8_t) ( ( (uint16_t) pYUV[-1].U + pYUV[0].U + pYUV[1].U + pYUV[2].U + ++ pYUV_NextRow[-1].U + pYUV_NextRow[0].U + pYUV_NextRow[1].U + pYUV_NextRow[2].U + 4 ) / 8 ); ++ pYUV[0].V = (uint8_t) ( ( (uint16_t) pYUV[-1].V + pYUV[0].V + pYUV[1].V + pYUV[2].V + ++ pYUV_NextRow[-1].V + pYUV_NextRow[0].V + pYUV_NextRow[1].V + pYUV_NextRow[2].V + 4 ) / 8 ); ++ ++ if( pYUV == pLineEnd ) ++ { ++ /* special treatment for last pixel of each row */ ++ pYUV += 2; ++ pYUV_NextRow += 2; ++ pYUV[0].U = (uint8_t) ( ( (uint16_t) pYUV[-1].U + pYUV[0].U + pYUV[1].U + ++ pYUV_NextRow[-1].U + pYUV_NextRow[0].U + pYUV_NextRow[1].U + 3 ) / 6 ); ++ pYUV[0].V = (uint8_t) ( ( (uint16_t) pYUV[-1].V + pYUV[0].V + pYUV[1].V + ++ pYUV_NextRow[-1].V + pYUV_NextRow[0].V + pYUV_NextRow[1].V + 3 ) / 6 ); ++ pLineEnd += XSize; ++ ++ pYUV += 2; ++ pYUV_NextRow += 2; ++ if ( pYUV == pFrameEnd ) ++ { ++ break; ++ } ++ ++ /* special treatment for first pixel of each row */ ++ pYUV[0].U = (uint8_t) ( ( (uint16_t) pYUV[0].U + pYUV[1].U + pYUV[2].U + ++ pYUV_NextRow[0].U + pYUV_NextRow[1].U + pYUV_NextRow[2].U + 3 ) / 6 ); ++ pYUV[0].V = (uint8_t) ( ( (uint16_t) pYUV[0].V + pYUV[1].V + pYUV[2].V + ++ pYUV_NextRow[0].V + pYUV_NextRow[1].V + pYUV_NextRow[2].V + 3 ) / 6 ); ++ } ++ } ++ ++ /* special treatment for last line */ ++ pYUV[0].U = (uint8_t) ( ( (uint16_t) pYUV[0].U + pYUV[1].U + pYUV[2].U + 1 ) / 3 ); ++ pYUV[0].V = (uint8_t) ( ( (uint16_t) pYUV[0].V + pYUV[1].V + pYUV[2].V + 1 ) / 3 ); ++ for (;;) ++ { ++ pYUV += 2; ++ pYUV[0].U = (uint8_t) ( ( (uint16_t) pYUV[-1].U + pYUV[0].U + pYUV[1].U + pYUV[2].U + 2 ) / 4 ); ++ pYUV[0].V = (uint8_t) ( ( (uint16_t) pYUV[-1].V + pYUV[0].V + pYUV[1].V + pYUV[2].V + 2 ) / 4 ); ++ if( pYUV == pLineEnd ) ++ { ++ /* special treatment for last pixel */ ++ pYUV += 2; ++ pYUV[0].U = (uint8_t) ( ( (uint16_t) pYUV[-1].U + pYUV[0].U + pYUV[1].U + 1 ) / 3 ); ++ pYUV[0].V = (uint8_t) ( ( (uint16_t) pYUV[-1].V + pYUV[0].V + pYUV[1].V + 1 ) / 3 ); ++ break; ++ } ++ } ++} ++ ++ ++ ++/* ++ * Inplace YUV422->RGB conversion. ++ * Image width is expected to be a multiple of 2. ++ * The input data is expected to be in "YUV422 unpacked" format as produced by ++ * dc1394_avt_YUV_averaging_2, dc1394_avt_YUV_averaging_4, dc1394_avt_YUV_averaging_42. ++ */ ++void dc1394_avt_YUV422UnpackedToRGB(uint8_t *pDst, uint32_t nPixelCount) ++{ ++ S_RGB8 *rgb = (S_RGB8*) (pDst); ++ S_RGB8 *pFrameEnd = rgb + nPixelCount - 2; ++ for(;;) ++ { ++ S_YUV444 *yuv = (S_YUV444*) rgb; ++ uint8_t Y0 = yuv[0].Y; ++ uint8_t U = yuv[0].U; ++ uint8_t V = yuv[0].V; ++ uint8_t Y1 = yuv[1].Y; ++ ++ const int32_t vr = (int16_t) ( (float) (V-128) * 1.4022 ); ++ const int32_t uvg = (int16_t) ( (float) (V-128) * (-0.7144) ) + ++ (int16_t) ( (float) (U-128) * (-0.3457) ); ++ const int32_t ub = (int16_t) ( (float) (U-128) * 1.7710 ); ++ ++ rgb[0].R = MAX( MIN( (int32_t) Y0 + vr , 255 ), 0); ++ rgb[0].G = MAX( MIN( (int32_t) Y0 + uvg, 255 ), 0); ++ rgb[0].B = MAX( MIN( (int32_t) Y0 + ub , 255 ), 0); ++ rgb[1].R = MAX( MIN( (int32_t) Y1 + vr , 255 ), 0); ++ rgb[1].G = MAX( MIN( (int32_t) Y1 + uvg, 255 ), 0); ++ rgb[1].B = MAX( MIN( (int32_t) Y1 + ub , 255 ), 0); ++ ++ if( rgb == pFrameEnd ) ++ { ++ break; ++ } ++ rgb += 2; ++ } ++} ++ ++void dc1394_avt_Raw8ToRGB_YUV422(uint8_t *restrict pDst, const uint8_t *restrict pSrc, uint32_t XSize, uint32_t YSize, dc1394color_filter_t bayerPattern) ++{ ++ dc1394_avt_Raw8ToYUV444(pDst, pSrc, XSize, YSize, bayerPattern); ++ dc1394_avt_YUV_averaging_2( pDst, XSize, YSize); ++ dc1394_avt_YUV422UnpackedToRGB(pDst, XSize*YSize ); ++} ++ ++void dc1394_avt_Raw8ToRGB_LCAA(uint8_t *restrict pDst, const uint8_t *restrict pSrc, uint32_t XSize, uint32_t YSize, dc1394color_filter_t bayerPattern) ++{ ++ dc1394_avt_Raw8ToYUV444(pDst, pSrc, XSize, YSize, bayerPattern); ++ dc1394_avt_YUV_averaging_4(pDst, XSize, YSize ); ++ dc1394_avt_YUV422UnpackedToRGB(pDst, XSize*YSize); ++} ++ ++void dc1394_avt_Raw8ToRGB_LCAAV(uint8_t *restrict pDst, const uint8_t *restrict pSrc, uint32_t XSize, uint32_t YSize, dc1394color_filter_t bayerPattern) ++{ ++ dc1394_avt_Raw8ToYUV444(pDst, pSrc, XSize, YSize, bayerPattern); ++ dc1394_avt_YUV_averaging_42( pDst, XSize, YSize); ++ dc1394_avt_YUV422UnpackedToRGB(pDst, XSize*YSize); ++} ++ ++ +diff -Nur libdc1394-2.1.2/dc1394/bayer.c libdc1394_avt-2.1.2/dc1394/bayer.c +--- libdc1394-2.1.2/dc1394/bayer.c 2009-06-11 06:05:47.000000000 +0200 ++++ libdc1394_avt-2.1.2/dc1394/bayer.c 2010-01-12 15:47:01.000000000 +0100 +@@ -26,6 +26,7 @@ + #include <stdlib.h> + #include <string.h> + #include "conversions.h" ++#include "vendor/avt.h" + + #define CLIP(in, out)\ + in = in < 0 ? 0 : in;\ +@@ -37,6 +38,16 @@ + in = in > ((1<<bits)-1) ? ((1<<bits)-1) : in;\ + out=in; + ++ ++/* debayering methods defined in bayer_avt.c */ ++extern void dc1394_avt_Raw8ToRGB_YUV422(uint8_t *restrict pDst, const uint8_t *restrict pSrc, uint32_t XSize, uint32_t YSize, dc1394color_filter_t bayerPattern); ++ ++extern void dc1394_avt_Raw8ToRGB_LCAA(uint8_t *restrict pDst, const uint8_t *restrict pSrc, uint32_t XSize, uint32_t YSize, dc1394color_filter_t bayerPattern); ++ ++extern void dc1394_avt_Raw8ToRGB_LCAAV(uint8_t *restrict pDst, const uint8_t *restrict pSrc, uint32_t XSize, uint32_t YSize, dc1394color_filter_t bayerPattern); ++ ++ ++ + void + ClearBorders(uint8_t *rgb, int sx, int sy, int w) + { +@@ -1997,6 +2008,15 @@ + return dc1394_bayer_VNG(bayer, rgb, sx, sy, tile); + case DC1394_BAYER_METHOD_AHD: + return dc1394_bayer_AHD(bayer, rgb, sx, sy, tile); ++ case DC1394_BAYER_METHOD_AVT_YUV422: ++ dc1394_avt_Raw8ToRGB_YUV422( rgb, bayer, sx, sy, tile); ++ return DC1394_SUCCESS; ++ case DC1394_BAYER_METHOD_AVT_LCAA: ++ dc1394_avt_Raw8ToRGB_LCAA( rgb, bayer, sx, sy, tile); ++ return DC1394_SUCCESS; ++ case DC1394_BAYER_METHOD_AVT_LCAAV: ++ dc1394_avt_Raw8ToRGB_LCAAV( rgb, bayer, sx, sy, tile); ++ return DC1394_SUCCESS; + default: + return DC1394_INVALID_BAYER_METHOD; + } +@@ -2006,6 +2026,10 @@ + dc1394error_t + dc1394_bayer_decoding_16bit(const uint16_t *restrict bayer, uint16_t *restrict rgb, uint32_t sx, uint32_t sy, dc1394color_filter_t tile, dc1394bayer_method_t method, uint32_t bits) + { ++ /* bits=0 indicates MSB-aligned data */ ++ if(bits==0) ++ bits = 16; ++ + switch (method) { + case DC1394_BAYER_METHOD_NEAREST: + return dc1394_bayer_NearestNeighbor_uint16(bayer, rgb, sx, sy, tile, bits); +@@ -2023,6 +2047,10 @@ + return dc1394_bayer_VNG_uint16(bayer, rgb, sx, sy, tile, bits); + case DC1394_BAYER_METHOD_AHD: + return dc1394_bayer_AHD_uint16(bayer, rgb, sx, sy, tile, bits); ++ case DC1394_BAYER_METHOD_AVT_YUV422: ++ case DC1394_BAYER_METHOD_AVT_LCAA: ++ case DC1394_BAYER_METHOD_AVT_LCAAV: ++ return DC1394_FUNCTION_NOT_SUPPORTED; + default: + return DC1394_INVALID_BAYER_METHOD; + } +@@ -2064,7 +2092,9 @@ + + // bit depth is conserved for 16 bit and set to 8bit for 8bit: + if ( (in->color_coding==DC1394_COLOR_CODING_RAW16) || +- (in->color_coding==DC1394_COLOR_CODING_MONO16) ) ++ (in->color_coding==DC1394_COLOR_CODING_MONO16) || ++ (in->color_coding==DC1394_COLOR_CODING_AVT_RAW12) || ++ (in->color_coding==DC1394_COLOR_CODING_AVT_MONO12) ) + out->data_depth=in->data_depth; + else + out->data_depth=8; +@@ -2148,6 +2178,15 @@ + return dc1394_bayer_VNG(in->image, out->image, in->size[0], in->size[1], in->color_filter); + case DC1394_BAYER_METHOD_AHD: + return dc1394_bayer_AHD(in->image, out->image, in->size[0], in->size[1], in->color_filter); ++ case DC1394_BAYER_METHOD_AVT_YUV422: ++ dc1394_avt_Raw8ToRGB_YUV422(out->image, in->image, in->size[0], in->size[1], in->color_filter); ++ return DC1394_SUCCESS; ++ case DC1394_BAYER_METHOD_AVT_LCAA: ++ dc1394_avt_Raw8ToRGB_LCAA(out->image, in->image, in->size[0], in->size[1], in->color_filter); ++ return DC1394_SUCCESS; ++ case DC1394_BAYER_METHOD_AVT_LCAAV: ++ dc1394_avt_Raw8ToRGB_LCAAV(out->image, in->image, in->size[0], in->size[1], in->color_filter); ++ return DC1394_SUCCESS; + } + break; + case DC1394_COLOR_CODING_MONO16: +@@ -2156,23 +2195,33 @@ + if(DC1394_SUCCESS != Adapt_buffer_bayer(in,out,method)) + return DC1394_MEMORY_ALLOCATION_FAILURE; + ++ int bits; ++ if(in->camera && DC1394_AVT_VENDOR_ID==in->camera->vendor_id) ++ bits = 16; ++ else ++ bits = in->data_depth; ++ + switch (method) { + case DC1394_BAYER_METHOD_NEAREST: +- return dc1394_bayer_NearestNeighbor_uint16((uint16_t*)in->image, (uint16_t*)out->image, in->size[0], in->size[1], in->color_filter, in->data_depth); ++ return dc1394_bayer_NearestNeighbor_uint16((uint16_t*)in->image, (uint16_t*)out->image, in->size[0], in->size[1], in->color_filter, bits); + case DC1394_BAYER_METHOD_SIMPLE: +- return dc1394_bayer_Simple_uint16((uint16_t*)in->image, (uint16_t*)out->image, in->size[0], in->size[1], in->color_filter, in->data_depth); ++ return dc1394_bayer_Simple_uint16((uint16_t*)in->image, (uint16_t*)out->image, in->size[0], in->size[1], in->color_filter, bits); + case DC1394_BAYER_METHOD_BILINEAR: +- return dc1394_bayer_Bilinear_uint16((uint16_t*)in->image, (uint16_t*)out->image, in->size[0], in->size[1], in->color_filter, in->data_depth); ++ return dc1394_bayer_Bilinear_uint16((uint16_t*)in->image, (uint16_t*)out->image, in->size[0], in->size[1], in->color_filter, bits); + case DC1394_BAYER_METHOD_HQLINEAR: +- return dc1394_bayer_HQLinear_uint16((uint16_t*)in->image, (uint16_t*)out->image, in->size[0], in->size[1], in->color_filter, in->data_depth); ++ return dc1394_bayer_HQLinear_uint16((uint16_t*)in->image, (uint16_t*)out->image, in->size[0], in->size[1], in->color_filter, bits); + case DC1394_BAYER_METHOD_DOWNSAMPLE: +- return dc1394_bayer_Downsample_uint16((uint16_t*)in->image, (uint16_t*)out->image, in->size[0], in->size[1], in->color_filter, in->data_depth); ++ return dc1394_bayer_Downsample_uint16((uint16_t*)in->image, (uint16_t*)out->image, in->size[0], in->size[1], in->color_filter, bits); + case DC1394_BAYER_METHOD_EDGESENSE: +- return dc1394_bayer_EdgeSense_uint16((uint16_t*)in->image, (uint16_t*)out->image, in->size[0], in->size[1], in->color_filter, in->data_depth); ++ return dc1394_bayer_EdgeSense_uint16((uint16_t*)in->image, (uint16_t*)out->image, in->size[0], in->size[1], in->color_filter, bits); + case DC1394_BAYER_METHOD_VNG: +- return dc1394_bayer_VNG_uint16((uint16_t*)in->image, (uint16_t*)out->image, in->size[0], in->size[1], in->color_filter, in->data_depth); ++ return dc1394_bayer_VNG_uint16((uint16_t*)in->image, (uint16_t*)out->image, in->size[0], in->size[1], in->color_filter, bits); + case DC1394_BAYER_METHOD_AHD: +- return dc1394_bayer_AHD_uint16((uint16_t*)in->image, (uint16_t*)out->image, in->size[0], in->size[1], in->color_filter, in->data_depth); ++ return dc1394_bayer_AHD_uint16((uint16_t*)in->image, (uint16_t*)out->image, in->size[0], in->size[1], in->color_filter, bits); ++ case DC1394_BAYER_METHOD_AVT_YUV422: ++ case DC1394_BAYER_METHOD_AVT_LCAA: ++ case DC1394_BAYER_METHOD_AVT_LCAAV: ++ return DC1394_FUNCTION_NOT_SUPPORTED; + } + break; + default: +diff -Nur libdc1394-2.1.2/dc1394/conversions.c libdc1394_avt-2.1.2/dc1394/conversions.c +--- libdc1394-2.1.2/dc1394/conversions.c 2009-06-11 06:05:47.000000000 +0200 ++++ libdc1394_avt-2.1.2/dc1394/conversions.c 2010-01-14 18:19:49.000000000 +0100 +@@ -23,6 +23,7 @@ + #include <string.h> + #include <stdlib.h> + #include "conversions.h" ++#include "vendor/avt.h" + + // this should disappear... + extern void swab(); +@@ -217,12 +218,76 @@ + } + + dc1394error_t ++dc1394_MONO12_to_YUV422(const uint8_t* restrict src, uint8_t* restrict dest, uint32_t width, uint32_t height, uint32_t byte_order, uint32_t bits) ++{ ++ if(width%2!=0) ++ return DC1394_FUNCTION_NOT_SUPPORTED; ++ ++ const uint8_t * packed = src; ++ const uint8_t * const frameEnd = src + (width*height*3/2); ++ uint8_t * yuv = dest; ++ ++ switch (byte_order) { ++ case DC1394_BYTE_ORDER_YUYV: ++ if( bits == 12 || bits == 0 ) { ++ while( packed < frameEnd ) { ++ yuv[0] = packed[0]; ++ yuv[1] = 128; ++ yuv[2] = packed[2]; ++ yuv[3] = 128; ++ yuv += 4; ++ packed += 3; ++ } ++ } <<Diff was trimmed, longer than 597 lines>> ---- CVS-web: http://cvs.pld-linux.org/cgi-bin/cvsweb.cgi/packages/libdc1394/libdc1394.spec?r1=1.31&r2=1.32&f=u _______________________________________________ pld-cvs-commit mailing list [email protected] http://lists.pld-linux.org/mailman/listinfo/pld-cvs-commit
