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
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
|
#pragma once
/*
* Copyright (C) 2005-2013 Team XBMC
* http://xbmc.org
*
* This Program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2, or (at your option)
* any later version.
*
* This Program 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 General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with XBMC; see the file COPYING. If not, see
* <http://www.gnu.org/licenses/>.
*
*/
#include <utility>
#include <vector>
#include "guilib/TextureManager.h"
#include "threads/CriticalSection.h"
#include "utils/Job.h"
/*!
\ingroup textures,jobs
\brief Image loader job class
Used by the CGUILargeTextureManager to perform asynchronous loading of textures.
\sa CGUILargeTextureManager and CJob
*/
class CImageLoader : public CJob
{
public:
CImageLoader(const std::string &path, const bool useCache);
virtual ~CImageLoader();
/*!
\brief Work function that loads in a particular image.
*/
virtual bool DoWork();
bool m_use_cache; ///< Whether or not to use any caching with this image
std::string m_path; ///< path of image to load
CBaseTexture *m_texture; ///< Texture object to load the image into \sa CBaseTexture.
};
/*!
\ingroup textures
\brief Background texture loading manager
Used to load textures for the user interface asynchronously, allowing fluid framerates
while background loading textures.
\sa IJobCallback, CGUITexture
*/
class CGUILargeTextureManager : public IJobCallback
{
public:
CGUILargeTextureManager();
virtual ~CGUILargeTextureManager();
/*!
\brief Callback from CImageLoader on completion of a loaded image
Transfers texture information from the loading job to our allocated texture list.
\sa CImageLoader, IJobCallback
*/
virtual void OnJobComplete(unsigned int jobID, bool success, CJob *job);
/*!
\brief Request a texture to be loaded in the background.
Loaded textures are reference counted, hence this call may immediately return with the texture
object filled if the texture has been previously loaded, else will return with an empty texture
object if it is being loaded.
\param path path of the image to load.
\param texture texture object to hold the resulting texture
\param orientation orientation of resulting texture
\param firstRequest true if this is the first time we are requesting this texture
\return true if the image exists, else false.
\sa CGUITextureArray and CGUITexture
*/
bool GetImage(const std::string &path, CTextureArray &texture, bool firstRequest, bool useCache = true);
/*!
\brief Request a texture to be unloaded.
When textures are finished with, this function should be called. This decrements the texture's
reference count, and schedules it to be unloaded once the reference count reaches zero. If the
texture is still queued for loading, or is in the process of loading, the image load is cancelled.
\param path path of the image to release.
\param immediately if set true the image is immediately unloaded once its reference count reaches zero
rather than being unloaded after a delay.
*/
void ReleaseImage(const std::string &path, bool immediately = false);
/*!
\brief Cleanup images that are no longer in use.
Loaded textures are reference counted, and upon reaching reference count 0 through ReleaseImage()
they are flagged as unused with the current time. After a delay they may be unloaded, hence
CleanupUnusedImages() should be called periodically to ensure this occurs.
\param immediately set to true to cleanup images regardless of whether the delay has passed
*/
void CleanupUnusedImages(bool immediately = false);
private:
class CLargeTexture
{
public:
CLargeTexture(const std::string &path);
virtual ~CLargeTexture();
void AddRef();
bool DecrRef(bool deleteImmediately);
bool DeleteIfRequired(bool deleteImmediately = false);
void SetTexture(CBaseTexture* texture);
const std::string &GetPath() const { return m_path; };
const CTextureArray &GetTexture() const { return m_texture; };
private:
static const unsigned int TIME_TO_DELETE = 2000;
unsigned int m_refCount;
std::string m_path;
CTextureArray m_texture;
unsigned int m_timeToDelete;
};
void QueueImage(const std::string &path, bool useCache = true);
std::vector< std::pair<unsigned int, CLargeTexture *> > m_queued;
std::vector<CLargeTexture *> m_allocated;
typedef std::vector<CLargeTexture *>::iterator listIterator;
typedef std::vector< std::pair<unsigned int, CLargeTexture *> >::iterator queueIterator;
CCriticalSection m_listSection;
};
extern CGUILargeTextureManager g_largeTextureManager;
|
