xcore/buffer_pool.cpp

/*
 * buffer_pool.cpp - buffer pool
 *
 *  Copyright (c) 2014-2015 Intel Corporation
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 * Author: Wind Yuan <feng.yuan@intel.com>
 */

#include "buffer_pool.h"

namespace XCam {

BufferProxy::BufferProxy (const VideoBufferInfo &info, const SmartPtr<BufferData> &data)
    : VideoBuffer (info)
    , _data (data)
{
    XCAM_ASSERT (data.ptr ());
}

BufferProxy::BufferProxy (const SmartPtr<BufferData> &data)
    : _data (data)
{
    XCAM_ASSERT (data.ptr ());
}

BufferProxy::~BufferProxy ()
{
    if (_pool.ptr ()) {
        _pool->release (_data);
    }
    _data.release ();
}

uint8_t *
BufferProxy::map ()
{
    XCAM_ASSERT (_data.ptr ());
    return _data->map ();
}

bool
BufferProxy::unmap ()
{
    XCAM_ASSERT (_data.ptr ());
    return _data->unmap ();
}

int
BufferProxy::get_fd ()
{
    XCAM_ASSERT (_data.ptr ());
    return _data->get_fd ();
}

BufferPool::BufferPool ()
    : _allocated_num (0)
    , _max_count (0)
    , _started (false)
{
}

BufferPool::~BufferPool ()
{
}

bool
BufferPool::set_video_info (const VideoBufferInfo &info)
{
    VideoBufferInfo new_info = info;
    SmartLock lock (_mutex);

    XCAM_FAIL_RETURN (
        ERROR,
        fixate_video_info (new_info),
        false,
        "BufferPool fixate video info failed");
    update_video_info_unsafe (new_info);
    return true;
}

void
BufferPool::update_video_info_unsafe (const VideoBufferInfo &info)
{
    _buffer_info = info;
}

bool
BufferPool::reserve (uint32_t max_count)
{
    uint32_t i = 0;

    XCAM_ASSERT (max_count);

    SmartLock lock (_mutex);

    for (i = _allocated_num; i < max_count; ++i) {
        SmartPtr<BufferData> new_data = allocate_data (_buffer_info);
        if (!new_data.ptr ())
            break;
        _buf_list.push (new_data);
    }

    XCAM_FAIL_RETURN (
        ERROR,
        i > 0,
        false,
        "BufferPool reserve failed with none buffer data allocated");

    if (i != max_count) {
        XCAM_LOG_WARNING ("BufferPool expect to reserve %d data but only reserved %d", max_count, i);
    }
    _max_count = i;
    _allocated_num = _max_count;
    _started = true;

    return true;
}

bool
BufferPool::add_data_unsafe (const SmartPtr<BufferData> &data)
{
    if (!data.ptr ())
        return false;

    _buf_list.push (data);
    ++_allocated_num;

    XCAM_ASSERT (_allocated_num <= _max_count || !_max_count);
    return true;
}

SmartPtr<VideoBuffer>
BufferPool::get_buffer (const SmartPtr<BufferPool> &self)
{
    SmartPtr<BufferProxy> ret_buf;
    SmartPtr<BufferData> data;

    {
        SmartLock lock (_mutex);
        if (!_started)
            return NULL;
    }

    XCAM_ASSERT (self.ptr () == this);
    XCAM_FAIL_RETURN(
        WARNING,
        self.ptr () == this,
        NULL,
        "BufferPool get_buffer failed since parameter<self> not this");

    data = _buf_list.pop ();
    if (!data.ptr ()) {
        XCAM_LOG_DEBUG ("BufferPool failed to get buffer");
        return NULL;
    }
    ret_buf = create_buffer_from_data (data);
    ret_buf->set_buf_pool (self);

    return ret_buf;
}

SmartPtr<VideoBuffer>
BufferPool::get_buffer ()
{
    return get_buffer (SmartPtr<BufferPool>(this));
}

void
BufferPool::stop ()
{
    {
        SmartLock lock (_mutex);
        _started = false;
    }
    _buf_list.pause_pop ();
}

void
BufferPool::release (SmartPtr<BufferData> &data)
{
    {
        SmartLock lock (_mutex);
        if (!_started)
            return;
    }
    _buf_list.push (data);
}

bool
BufferPool::fixate_video_info (VideoBufferInfo &info)
{
    XCAM_UNUSED (info);
    return true;
}

SmartPtr<BufferProxy>
BufferPool::create_buffer_from_data (SmartPtr<BufferData> &data)
{
    const VideoBufferInfo &info = get_video_info ();

    XCAM_ASSERT (data.ptr ());
    return new BufferProxy (info, data);
}

};