/*
* libopenraw - cfapattern.cpp
*
* Copyright (C) 2012 Hubert Figuière
*
* 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 3 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, see
* <http://www.gnu.org/licenses/>.
*/
#include <stdint.h>
#include <stddef.h>
#include <array>
#include <boost/static_assert.hpp>
#include <libopenraw/consts.h>
#include "cfapattern.hpp"
namespace OpenRaw {
namespace Internals {
/** alias the colours. */
static const uint8_t RED = OR_PATTERN_COLOUR_RED;
static const uint8_t GREEN = OR_PATTERN_COLOUR_GREEN;
static const uint8_t BLUE = OR_PATTERN_COLOUR_BLUE;
static const uint8_t RGGB_PATTERN[] = { RED, GREEN, GREEN, BLUE };
static const uint8_t GBRG_PATTERN[] = { GREEN, BLUE, RED, GREEN };
static const uint8_t BGGR_PATTERN[] = { BLUE, GREEN, GREEN, RED };
static const uint8_t GRBG_PATTERN[] = { GREEN, RED, BLUE, GREEN };
class Cfa2x2RgbPattern
: public CfaPattern
{
public:
Cfa2x2RgbPattern(::or_cfa_pattern pattern)
: CfaPattern(pattern, 2, 2)
{
switch(pattern) {
case OR_CFA_PATTERN_RGGB:
setPatternPattern(RGGB_PATTERN, 4);
break;
case OR_CFA_PATTERN_GBRG:
setPatternPattern(GBRG_PATTERN, 4);
break;
case OR_CFA_PATTERN_BGGR:
setPatternPattern(BGGR_PATTERN, 4);
break;
case OR_CFA_PATTERN_GRBG:
setPatternPattern(GRBG_PATTERN, 4);
break;
default:
break;
}
}
};
}
const CfaPattern*
CfaPattern::twoByTwoPattern(::or_cfa_pattern pattern)
{
static std::array<CfaPattern*, _OR_CFA_PATTERN_INVALID> s_patterns
= { { NULL, NULL, NULL, NULL, NULL, NULL } };
// this should be updated if we change the enum
BOOST_STATIC_ASSERT(_OR_CFA_PATTERN_INVALID == 6);
if((pattern == OR_CFA_PATTERN_NON_RGB22) ||
(pattern >= _OR_CFA_PATTERN_INVALID)) {
return NULL;
}
CfaPattern* pat = s_patterns[pattern];
if(!pat) {
pat = new Internals::Cfa2x2RgbPattern(pattern);
s_patterns[pattern] = pat;
}
return pat;
}
class CfaPattern::Private
{
public:
friend class Internals::Cfa2x2RgbPattern;
Private()
: x(0), y(0), n_colours(0)
, pattern_type(OR_CFA_PATTERN_NONE)
, pattern(NULL)
{}
uint16_t x;
uint16_t y;
uint16_t n_colours;
::or_cfa_pattern pattern_type;
const uint8_t* pattern;
};
CfaPattern::CfaPattern()
: d(new CfaPattern::Private)
{
}
CfaPattern::CfaPattern(::or_cfa_pattern pattern,
uint16_t width, uint16_t height)
: d(new CfaPattern::Private)
{
setSize(width, height);
setPatternType(pattern);
}
CfaPattern::~CfaPattern()
{
delete d;
}
void CfaPattern::setSize(uint16_t x, uint16_t y)
{
d->x = x;
d->y = y;
if(x != 2 || y != 2) {
d->pattern_type = OR_CFA_PATTERN_NON_RGB22;
}
else if(!is2by2Rgb()) {
d->pattern_type = OR_CFA_PATTERN_NONE;
}
}
bool CfaPattern::is2by2Rgb() const
{
return (d->pattern_type != OR_CFA_PATTERN_NONE)
&& (d->pattern_type != OR_CFA_PATTERN_NON_RGB22);
}
void
CfaPattern::setPatternPattern(const uint8_t* pattern, uint16_t count)
{
if(count != d->x * d->y) {
d->pattern = NULL;
// TODO deal with the error
return;
}
d->pattern = pattern;
}
const uint8_t*
CfaPattern::patternPattern(uint16_t& count) const
{
if(d->pattern) {
count = d->x * d->y;
return d->pattern;
}
count = 0;
return NULL;
}
void CfaPattern::setPatternType(::or_cfa_pattern pattern)
{
d->pattern_type = pattern;
if(is2by2Rgb()) {
setSize(2, 2);
d->n_colours = 3;
}
}
::or_cfa_pattern
CfaPattern::patternType() const
{
return d->pattern_type;
}
}
/*
Local Variables:
mode:c++
c-file-style:"stroustrup"
c-file-offsets:((innamespace . 0))
tab-width:2
c-basic-offset:2
indent-tabs-mode:nil
fill-column:80
End:
*/