summaryrefslogtreecommitdiff
path: root/test/timer-thread.cpp
AgeCommit message (Collapse)Author
2020-11-15libcamera: Move EventDispatcher to internal APILaurent Pinchart
There's no user of the EventDispatcher (and the related EventNotifier and Timer classes) outside of libcamera. Move those classes to the internal API. Signed-off-by: Laurent Pinchart <laurent.pinchart@ideasonboard.com> Reviewed-by: Kieran Bingham <kieran.bingham@ideasonboard.com> Reviewed-by: Niklas Söderlund <niklas.soderlund@ragnatech.se>
2020-08-25meson: Remove -Wno-unused-parameterLaurent Pinchart
We build libcamera with -Wno-unused-parameter and this doesn't cause much issue internally. However, it prevents catching unused parameters in inline functions defined in public headers. This can lead to compilation warnings for applications compiled without -Wno-unused-parameter. To catch those issues, remove -Wno-unused-parameter and fix all the related warnings with [[maybe_unused]]. Signed-off-by: Laurent Pinchart <laurent.pinchart@ideasonboard.com> Reviewed-by: Kieran Bingham <kieran.bingham@ideasonboard.com> Reviewed-by: Niklas Söderlund <niklas.soderlund@ragnatech.se>
2020-05-16libcamera: Move internal headers to include/libcamera/internal/Laurent Pinchart
The libcamera internal headers are located in src/libcamera/include/. The directory is added to the compiler headers search path with a meson include_directories() directive, and internal headers are included with (e.g. for the internal semaphore.h header) #include "semaphore.h" All was well, until libcxx decided to implement the C++20 synchronization library. The __threading_support header gained a #include <semaphore.h> to include the pthread's semaphore support. As include_directories() adds src/libcamera/include/ to the compiler search path with -I, the internal semaphore.h is included instead of the pthread version. Needless to say, the compiler isn't happy. Three options have been considered to fix this issue: - Use -iquote instead of -I. The -iquote option instructs gcc to only consider the header search path for headers included with the "" version. Meson unfortunately doesn't support this option. - Rename the internal semaphore.h header. This was deemed to be the beginning of a long whack-a-mole game, where namespace clashes with system libraries would appear over time (possibly dependent on particular system configurations) and would need to be constantly fixed. - Move the internal headers to another directory to create a unique namespace through path components. This causes lots of churn in all the existing source files through the all project. The first option would be best, but isn't available to us due to missing support in meson. Even if -iquote support was added, we would need to fix the problem before a new version of meson containing the required support would be released. The third option is thus the only practical solution available. Bite the bullet, and do it, moving headers to include/libcamera/internal/. Signed-off-by: Laurent Pinchart <laurent.pinchart@ideasonboard.com> Acked-by: Jacopo Mondi <jacopo@jmondi.org>
2019-10-07test: timer-thread: Test starting a timer from another threadLaurent Pinchart
Timers can't be started from another thread. Ensure that attempting to do so fails. Signed-off-by: Laurent Pinchart <laurent.pinchart@ideasonboard.com> Reviewed-by: Niklas Söderlund <niklas.soderlund@ragnatech.se>
2019-08-17test: Simplify tests with parent-child relationshipsLaurent Pinchart
Create object instances with a parent to avoid the need for reparenting objects manually. Signed-off-by: Laurent Pinchart <laurent.pinchart@ideasonboard.com> Reviewed-by: Jacopo Mondi <jacopo@jmondi.org> Reviewed-by: Niklas Söderlund <niklas.soderlund@ragnatech.se>
2019-08-17test: Add Timer thread move testLaurent Pinchart
The test verifies correct behaviour of a running timer moved to a different thread. Signed-off-by: Laurent Pinchart <laurent.pinchart@ideasonboard.com> Reviewed-by: Jacopo Mondi <jacopo@jmondi.org> Reviewed-by: Niklas Söderlund <niklas.soderlund@ragnatech.se>
generated by cgit v1.2.1 (git 2.18.0) at 2025-06-01 21:58:19 +0000
> 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 
# 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]
            ba4 = raw[..., 4:5*((self.w+3)>>2):5]
            """
            assemble 10 bit numbers
            """
            ch0 = np.left_shift((np.left_shift(ba0, 2) + (ba4 % 4)), 6)
            ch1 = np.left_shift((np.left_shift(ba1, 2) + (np.right_shift(ba4, 2) % 4)), 6)
            ch2 = np.left_shift((np.left_shift(ba2, 2) + (np.right_shift(ba4, 4) % 4)), 6)
            ch3 = np.left_shift((np.left_shift(ba3, 2) + (np.right_shift(ba4, 6) % 4)), 6)
            """
            interleave bits
            """
            mat = np.empty((self.h, self.w), dtype=ch0.dtype)

            mat[..., 0::4] = ch0
            mat[..., 1::4] = ch1
            mat[..., 2::4] = ch2
            mat[..., 3::4] = ch3

            """
            There is som eleaking memory somewhere in the code. This code here
            seemed to make things good enough that the code would run for
            reasonable numbers of images, however this is techincally just a
            workaround. (sorry)
            """
            ba0, ba1, ba2, ba3, ba4 = None, None, None, None, None
            del ba0, ba1, ba2, ba3, ba4
            ch0, ch1, ch2, ch3 = None, None, None, None
            del ch0, ch1, ch2, ch3

            """
        same as before but 12 bit case
        """
        elif self.sigbits == 12:
            lin_len = ((((((self.w+self.pad+1)>>1)) * 3)+31)>>5) * 32
            raw = np.array(raw).reshape(-1, lin_len).astype(np.int64)[:self.h, ...]
            ba0 = raw[..., 0:3*((self.w+1)>>1):3]
            ba1 = raw[..., 1:3*((self.w+1)>>1):3]
            ba2 = raw[..., 2:3*((self.w+1)>>1):3]
            ch0 = np.left_shift((np.left_shift(ba0, 4) + ba2 % 16), 4)
            ch1 = np.left_shift((np.left_shift(ba1, 4) + (np.right_shift(ba2, 4)) % 16), 4)
            mat = np.empty((self.h, self.w), dtype=ch0.dtype)
            mat[..., 0::2] = ch0
            mat[..., 1::2] = ch1

        else:
            """
            data is neither 10 nor 12 or incorrect data
            """
            print('ERROR: wrong bit format, only 10 or 12 bit supported')
            return 0

        """
        separate bayer channels
        """
        c0 = mat[0::2, 0::2]
        c1 = mat[0::2, 1::2]
        c2 = mat[1::2, 0::2]
        c3 = mat[1::2, 1::2]
        self.channels = [c0, c1, c2, c3]
        return 1

    """
    obtain 16x16 patch centred at macbeth square centre for each channel
    """
    def get_patches(self, cen_coords, size=16):
        """
        obtain channel widths and heights
        """
        ch_w, ch_h = self.w, self.h
        cen_coords = list(np.array((cen_coords[0])).astype(np.int32))
        self.cen_coords = cen_coords
        """
        squares are ordered by stacking macbeth chart columns from
        left to right. Some useful patch indices:
            white = 3
            black = 23
            'reds' = 9, 10
            'blues' = 2, 5, 8, 20, 22
            'greens' = 6, 12, 17
            greyscale = 3, 7, 11, 15, 19, 23
        """
        all_patches = []
        for ch in self.channels:
            ch_patches = []
            for cen in cen_coords:
                '''
                macbeth centre is placed at top left of central 2x2 patch
                to account for rounding
                Patch pixels are sorted by pixel brightness so spatial
                information is lost.
                '''
                patch = ch[cen[1]-7:cen[1]+9, cen[0]-7:cen[0]+9].flatten()
                patch.sort()
                if patch[-5] == (2**self.sigbits-1)*2**(16-self.sigbits):
                    self.saturated = True
                ch_patches.append(patch)
                # print('\nNew Patch\n')
            all_patches.append(ch_patches)
            # print('\n\nNew Channel\n\n')
        self.patches = all_patches
        return 1


def brcm_load_image(Cam, im_str):
    """
    Load image where raw data and metadata is in the BRCM format
    """
    try:
        """
        create byte array
        """
        with open(im_str, 'rb') as image:
            f = image.read()
            b = bytearray(f)
        """
        return error if incorrect image address
        """
    except FileNotFoundError:
        print('\nERROR:\nInvalid image address')
        Cam.log += '\nWARNING: Invalid image address'
        return 0

    """
    return error if problem reading file
    """
    if f is None:
        print('\nERROR:\nProblem reading file')
        Cam.log += '\nWARNING: Problem readin file'
        return 0

    # print('\nLooking for EOI and BRCM header')
    """
    find end of image followed by BRCM header by turning
    bytearray into hex string and string matching with regexp
    """
    start = -1
    match = bytearray(b'\xff\xd9@BRCM')
    match_str = binascii.hexlify(match)
    b_str = binascii.hexlify(b)
    """
    note index is divided by two to go from string to hex
    """
    indices = [m.start()//2 for m in re.finditer(match_str, b_str)]
    # print(indices)
    try:
        start = indices[0] + 3
    except IndexError:
        print('\nERROR:\nNo Broadcom header found')
        Cam.log += '\nWARNING: No Broadcom header found!'
        return 0
    """
    extract data after header
    """
    # print('\nExtracting data after header')
    buf = b[start:start+32768]
    Img = Image(buf)
    Img.str = im_str
    # print('Data found successfully')

    """
    obtain metadata
    """
    # print('\nReading metadata')
    Img.get_meta()
    Cam.log += '\nExposure : {} us'.format(Img.exposure)
    Cam.log += '\nNormalised gain : {}'.format(Img.againQ8_norm)
    # print('Metadata read successfully')

    """
    obtain raw image data
    """
    # print('\nObtaining raw image data')
    raw = b[start+32768:]
    Img.get_image(raw)
    """
    delete raw to stop memory errors
    """
    raw = None
    del raw
    # print('Raw image data obtained successfully')

    return Img


def dng_load_image(Cam, im_str):
    try:
        Img = Image(None)

        # RawPy doesn't load all the image tags that we need, so we use py3exiv2
        metadata = pyexif.ImageMetadata(im_str)
        metadata.read()

        Img.ver = 100  # random value
        Img.w = metadata['Exif.SubImage1.ImageWidth'].value
        Img.pad = 0
        Img.h = metadata['Exif.SubImage1.ImageLength'].value
        white = metadata['Exif.SubImage1.WhiteLevel'].value
        Img.sigbits = int(white).bit_length()
        Img.fmt = (Img.sigbits - 4) // 2
        Img.exposure = int(metadata['Exif.Photo.ExposureTime'].value*1000000)
        Img.againQ8 = metadata['Exif.Photo.ISOSpeedRatings'].value*256/100
        Img.againQ8_norm = Img.againQ8 / 256
        Img.camName = metadata['Exif.Image.Model'].value
        Img.blacklevel = int(metadata['Exif.SubImage1.BlackLevel'].value[0])
        Img.blacklevel_16 = Img.blacklevel << (16 - Img.sigbits)
        bayer_case = {
            '0 1 1 2': (0, (0, 1, 2, 3)),
            '1 2 0 1': (1, (2, 0, 3, 1)),
            '2 1 1 0': (2, (3, 2, 1, 0)),
            '1 0 2 1': (3, (1, 0, 3, 2))
        }
        cfa_pattern = metadata['Exif.SubImage1.CFAPattern'].value
        Img.pattern = bayer_case[cfa_pattern][0]
        Img.order = bayer_case[cfa_pattern][1]

        # Now use RawPy tp get the raw Bayer pixels
        raw_im = raw.imread(im_str)
        raw_data = raw_im.raw_image
        shift = 16 - Img.sigbits
        c0 = np.left_shift(raw_data[0::2, 0::2].astype(np.int64), shift)
        c1 = np.left_shift(raw_data[0::2, 1::2].astype(np.int64), shift)
        c2 = np.left_shift(raw_data[1::2, 0::2].astype(np.int64), shift)
        c3 = np.left_shift(raw_data[1::2, 1::2].astype(np.int64), shift)
        Img.channels = [c0, c1, c2, c3]

    except Exception:
        print("\nERROR: failed to load DNG file", im_str)
        print("Either file does not exist or is incompatible")
        Cam.log += '\nERROR: DNG file does not exist or is incompatible'
        raise

    return Img


'''
load image from file location and perform calibration
check correct filetype

mac boolean is true if image is expected to contain macbeth chart and false
if not (alsc images don't have macbeth charts)
'''
def load_image(Cam, im_str, mac_config=None, show=False, mac=True, show_meta=False):
    """
    check image is correct filetype
    """
    if '.jpg' in im_str or '.jpeg' in im_str or '.brcm' in im_str or '.dng' in im_str:
        if '.dng' in im_str:
            Img = dng_load_image(Cam, im_str)
        else:
            Img = brcm_load_image(Cam, im_str)
        if show_meta:
            Img.print_meta()

        if mac:
            """
            find macbeth centres, discarding images that are too dark or light
            """
            av_chan = (np.mean(np.array(Img.channels), axis=0)/(2**16))
            av_val = np.mean(av_chan)
            # print(av_val)
            if av_val < Img.blacklevel_16/(2**16)+1/64:
                macbeth = None
                print('\nError: Image too dark!')
                Cam.log += '\nWARNING: Image too dark!'
            else:
                macbeth = find_macbeth(Cam, av_chan, mac_config)

            """
            if no macbeth found return error
            """
            if macbeth is None:
                print('\nERROR: No macbeth chart found')
                return 0
            mac_cen_coords = macbeth[1]
            # print('\nMacbeth centres located successfully')

            """
            obtain image patches
            """
            # print('\nObtaining image patches')
            Img.get_patches(mac_cen_coords)
            if Img.saturated:
                print('\nERROR: Macbeth patches have saturated')
                Cam.log += '\nWARNING: Macbeth patches have saturated!'
                return 0

        """
        clear memory
        """
        Img.buf = None
        del Img.buf

        # print('Image patches obtained successfully')

        """
        optional debug
        """
        if show and __name__ == '__main__':
            copy = sum(Img.channels)/2**18
            copy = np.reshape(copy, (Img.h//2, Img.w//2)).astype(np.float64)
            copy, _ = reshape(copy, 800)
            represent(copy)

        return Img

        """
    return error if incorrect filetype
    """
    else:
        # print('\nERROR:\nInvalid file extension')
        return 0


"""
bytearray splice to number little endian
"""
def ba_to_b(b):
    total = 0
    for i in range(len(b)):
        total += 256**i * b[i]
    return total
generated by cgit v1.2.1 (git 2.18.0) at 2025-06-01 21:58:19 +0000