src/android/jpeg/encoder_libjpeg.h


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46

/* SPDX-License-Identifier: LGPL-2.1-or-later */
/*
 * Copyright (C) 2020, Google Inc.
 *
 * encoder_libjpeg.h - JPEG encoding using libjpeg
 */
#ifndef __ANDROID_JPEG_ENCODER_LIBJPEG_H__
#define __ANDROID_JPEG_ENCODER_LIBJPEG_H__

#include "encoder.h"

#include "libcamera/internal/formats.h"
#include "libcamera/internal/framebuffer.h"

#include <jpeglib.h>

class EncoderLibJpeg : public Encoder
{
public:
	EncoderLibJpeg();
	~EncoderLibJpeg();

	int configure(const libcamera::StreamConfiguration &cfg) override;
	int encode(const libcamera::FrameBuffer &source,
		   libcamera::Span<uint8_t> destination,
		   libcamera::Span<const uint8_t> exifData,
		   unsigned int quality) override;
	int encode(libcamera::Span<const uint8_t> source,
		   libcamera::Span<uint8_t> destination,
		   libcamera::Span<const uint8_t> exifData,
		   unsigned int quality);

private:
	void compressRGB(libcamera::Span<const uint8_t> frame);
	void compressNV(libcamera::Span<const uint8_t> frame);

	struct jpeg_compress_struct compress_;
	struct jpeg_error_mgr jerr_;

	const libcamera::PixelFormatInfo *pixelFormatInfo_;

	bool nv_;
	bool nvSwap_;
};

#endif /* __ANDROID_JPEG_ENCODER_LIBJPEG_H__ */
# SPDX-License-Identifier: BSD-2-Clause
#
# Copyright (C) 2019-2020, Raspberry Pi (Trading) Limited
#
# ctt_image_load.py - camera tuning tool image loading

from ctt_tools import *
from ctt_macbeth_locator import *
import json
import pyexiv2 as pyexif
import rawpy as raw


"""
Image class load image from raw data and extracts metadata.

Once image is extracted from data, it finds 24 16x16 patches for each
channel, centred at the macbeth chart squares
"""
class Image:
    def __init__(self, buf):
        self.buf = buf
        self.patches = None
        self.saturated = False

    '''
    obtain metadata from buffer
    '''
    def get_meta(self):
        self.ver = ba_to_b(self.buf[4:5])
        self.w = ba_to_b(self.buf[0xd0:0xd2])
        self.h = ba_to_b(self.buf[0xd2:0xd4])
        self.pad = ba_to_b(self.buf[0xd4:0xd6])
        self.fmt = self.buf[0xf5]
        self.sigbits = 2*self.fmt + 4
        self.pattern = self.buf[0xf4]
        self.exposure = ba_to_b(self.buf[0x90:0x94])
        self.againQ8 = ba_to_b(self.buf[0x94:0x96])
        self.againQ8_norm = self.againQ8/256
        camName = self.buf[0x10:0x10+128]
        camName_end = camName.find(0x00)
        self.camName = self.buf[0x10:0x10+128][:camName_end].decode()

        """
        Channel order depending on bayer pattern
        """
        bayer_case = {
            0: (0, 1, 2, 3),   # red
            1: (2, 0, 3, 1),   # green next to red
            2: (3, 2, 1, 0),   # green next to blue
            3: (1, 0, 3, 2),   # blue
            128: (0, 1, 2, 3)  # arbitrary order for greyscale casw
        }
        self.order = bayer_case[self.pattern]

        '''
        manual blacklevel - not robust
        '''
        if 'ov5647' in self.camName:
            self.blacklevel = 16
        else:
            self.blacklevel = 64
        self.blacklevel_16 = self.blacklevel << (6)
        return 1

    '''
    print metadata for debug
    '''
    def print_meta(self):
        print('\nData:')
        print('      ver = {}'.format(self.ver))
        print('      w = {}'.format(self.w))
        print('      h = {}'.format(self.h))
        print('      pad = {}'.format(self.pad))
        print('      fmt = {}'.format(self.fmt))
        print('      sigbits = {}'.format(self.sigbits))
        print('      pattern = {}'.format(self.pattern))
        print('      exposure = {}'.format(self.exposure))
        print('      againQ8 = {}'.format(self.againQ8))
        print('      againQ8_norm = {}'.format(self.againQ8_norm))
        print('      camName = {}'.format(self.camName))
        print('      blacklevel = {}'.format(self.blacklevel))
        print('      blacklevel_16 = {}'.format(self.blacklevel_16))

        return 1

    """
    get image from raw scanline data
    """
    def get_image(self, raw):
        self.dptr = []
        """
        check if data is 10 or 12 bits
        """
        if self.sigbits == 10:
            """
            calc length of scanline
            """
            lin_len = ((((((self.w+self.pad+3)>>2)) * 5)+31)>>5) * 32
            """
            stack scan lines into matrix
            """
            raw = np.array(raw).reshape(-1, lin_len).astype(np.int64)[:self.h, ...]
            """
            separate 5 bits in each package, stopping when w is satisfied
            """
            ba0 = raw[..., 0:5*((self.w+3)>>2):5]
            ba1 = raw[..., 1:5*((self.w+3)>>2):5]
            ba2 = raw[..., 2:5*((self.w+3)>>2):5]
            ba3 = raw[..., 3:5*((self.w+3)>>2):5]