← Back to branch summary

~binli/ubuntu/vivid/pulseaudio/load-extcon-module

« back to all changes in this revision

Viewing changes to .pc/0304-memblock-Change-pa_memblock_new_malloced-to-an-inlin.patch/src/pulsecore/memblock.h

  • Committer: Bin Li
  • Date: 2016-01-23 15:04:48 UTC
  • Revision ID: bin.li@canonical.com-20160123150448-5ockvw4p5xxntda4
init the 1:6.0-0ubuntu9.15 from silo 12

Show diffs side-by-side

added added

removed removed

Lines of Context:
.pc/0304-memblock-Change-pa_memblock_new_malloced-to-an-inlin.patch/src/pulsecore/memblock.h
 
1
#ifndef foopulsememblockhfoo
 
2
#define foopulsememblockhfoo
 
3
 
 
4
/***
 
5
  This file is part of PulseAudio.
 
6
 
 
7
  Copyright 2004-2006 Lennart Poettering
 
8
  Copyright 2006 Pierre Ossman <ossman@cendio.se> for Cendio AB
 
9
 
 
10
  PulseAudio is free software; you can redistribute it and/or modify
 
11
  it under the terms of the GNU Lesser General Public License as
 
12
  published by the Free Software Foundation; either version 2.1 of the
 
13
  License, or (at your option) any later version.
 
14
 
 
15
  PulseAudio is distributed in the hope that it will be useful, but
 
16
  WITHOUT ANY WARRANTY; without even the implied warranty of
 
17
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
 
18
  Lesser General Public License for more details.
 
19
 
 
20
  You should have received a copy of the GNU Lesser General Public
 
21
  License along with PulseAudio; if not, see <http://www.gnu.org/licenses/>.
 
22
***/
 
23
 
 
24
typedef struct pa_memblock pa_memblock;
 
25
 
 
26
#include <sys/types.h>
 
27
#include <inttypes.h>
 
28
 
 
29
#include <pulse/def.h>
 
30
#include <pulsecore/atomic.h>
 
31
#include <pulsecore/memchunk.h>
 
32
 
 
33
/* A pa_memblock is a reference counted memory block. PulseAudio
 
34
 * passes references to pa_memblocks around instead of copying
 
35
 * data. See pa_memchunk for a structure that describes parts of
 
36
 * memory blocks. */
 
37
 
 
38
/* The type of memory this block points to */
 
39
typedef enum pa_memblock_type {
 
40
    PA_MEMBLOCK_POOL,             /* Memory is part of the memory pool */
 
41
    PA_MEMBLOCK_POOL_EXTERNAL,    /* Data memory is part of the memory pool but the pa_memblock structure itself is not */
 
42
    PA_MEMBLOCK_APPENDED,         /* The data is appended to the memory block */
 
43
    PA_MEMBLOCK_USER,             /* User supplied memory, to be freed with free_cb */
 
44
    PA_MEMBLOCK_FIXED,            /* Data is a pointer to fixed memory that needs not to be freed */
 
45
    PA_MEMBLOCK_IMPORTED,         /* Memory is imported from another process via shm */
 
46
    PA_MEMBLOCK_TYPE_MAX
 
47
} pa_memblock_type_t;
 
48
 
 
49
typedef struct pa_mempool pa_mempool;
 
50
typedef struct pa_mempool_stat pa_mempool_stat;
 
51
typedef struct pa_memimport_segment pa_memimport_segment;
 
52
typedef struct pa_memimport pa_memimport;
 
53
typedef struct pa_memexport pa_memexport;
 
54
 
 
55
typedef void (*pa_memimport_release_cb_t)(pa_memimport *i, uint32_t block_id, void *userdata);
 
56
typedef void (*pa_memexport_revoke_cb_t)(pa_memexport *e, uint32_t block_id, void *userdata);
 
57
 
 
58
/* Please note that updates to this structure are not locked,
 
59
 * i.e. n_allocated might be updated at a point in time where
 
60
 * n_accumulated is not yet. Take these values with a grain of salt,
 
61
 * they are here for purely statistical reasons.*/
 
62
struct pa_mempool_stat {
 
63
    pa_atomic_t n_allocated;
 
64
    pa_atomic_t n_accumulated;
 
65
    pa_atomic_t n_imported;
 
66
    pa_atomic_t n_exported;
 
67
    pa_atomic_t allocated_size;
 
68
    pa_atomic_t accumulated_size;
 
69
    pa_atomic_t imported_size;
 
70
    pa_atomic_t exported_size;
 
71
 
 
72
    pa_atomic_t n_too_large_for_pool;
 
73
    pa_atomic_t n_pool_full;
 
74
 
 
75
    pa_atomic_t n_allocated_by_type[PA_MEMBLOCK_TYPE_MAX];
 
76
    pa_atomic_t n_accumulated_by_type[PA_MEMBLOCK_TYPE_MAX];
 
77
};
 
78
 
 
79
/* Allocate a new memory block of type PA_MEMBLOCK_MEMPOOL or PA_MEMBLOCK_APPENDED, depending on the size */
 
80
pa_memblock *pa_memblock_new(pa_mempool *, size_t length);
 
81
 
 
82
/* Allocate a new memory block of type PA_MEMBLOCK_MEMPOOL. If the requested size is too large, return NULL */
 
83
pa_memblock *pa_memblock_new_pool(pa_mempool *, size_t length);
 
84
 
 
85
/* Allocate a new memory block of type PA_MEMBLOCK_USER */
 
86
pa_memblock *pa_memblock_new_user(pa_mempool *, void *data, size_t length, pa_free_cb_t free_cb, void *free_cb_data, bool read_only);
 
87
 
 
88
/* A special case of pa_memblock_new_user: take a memory buffer previously allocated with pa_xmalloc()  */
 
89
#define pa_memblock_new_malloced(p,data,length) pa_memblock_new_user(p, data, length, pa_xfree, data, 0)
 
90
 
 
91
/* Allocate a new memory block of type PA_MEMBLOCK_FIXED */
 
92
pa_memblock *pa_memblock_new_fixed(pa_mempool *, void *data, size_t length, bool read_only);
 
93
 
 
94
void pa_memblock_unref(pa_memblock*b);
 
95
pa_memblock* pa_memblock_ref(pa_memblock*b);
 
96
 
 
97
/* This special unref function has to be called by the owner of the
 
98
memory of a static memory block when he wants to release all
 
99
references to the memory. This causes the memory to be copied and
 
100
converted into a pool of malloc'ed memory block. Please note that this
 
101
function is not multiple caller safe, i.e. needs to be locked
 
102
manually if called from more than one thread at the same time. */
 
103
void pa_memblock_unref_fixed(pa_memblock*b);
 
104
 
 
105
bool pa_memblock_is_ours(pa_memblock *b);
 
106
bool pa_memblock_is_read_only(pa_memblock *b);
 
107
bool pa_memblock_is_silence(pa_memblock *b);
 
108
bool pa_memblock_ref_is_one(pa_memblock *b);
 
109
void pa_memblock_set_is_silence(pa_memblock *b, bool v);
 
110
 
 
111
void* pa_memblock_acquire(pa_memblock *b);
 
112
void *pa_memblock_acquire_chunk(const pa_memchunk *c);
 
113
void pa_memblock_release(pa_memblock *b);
 
114
 
 
115
size_t pa_memblock_get_length(pa_memblock *b);
 
116
pa_mempool * pa_memblock_get_pool(pa_memblock *b);
 
117
 
 
118
pa_memblock *pa_memblock_will_need(pa_memblock *b);
 
119
 
 
120
/* The memory block manager */
 
121
pa_mempool* pa_mempool_new(bool shared, size_t size);
 
122
void pa_mempool_free(pa_mempool *p);
 
123
const pa_mempool_stat* pa_mempool_get_stat(pa_mempool *p);
 
124
void pa_mempool_vacuum(pa_mempool *p);
 
125
int pa_mempool_get_shm_id(pa_mempool *p, uint32_t *id);
 
126
bool pa_mempool_is_shared(pa_mempool *p);
 
127
bool pa_mempool_is_remote_writable(pa_mempool *p);
 
128
void pa_mempool_set_is_remote_writable(pa_mempool *p, bool writable);
 
129
size_t pa_mempool_block_size_max(pa_mempool *p);
 
130
 
 
131
/* For receiving blocks from other nodes */
 
132
pa_memimport* pa_memimport_new(pa_mempool *p, pa_memimport_release_cb_t cb, void *userdata);
 
133
void pa_memimport_free(pa_memimport *i);
 
134
pa_memblock* pa_memimport_get(pa_memimport *i, uint32_t block_id, uint32_t shm_id,
 
135
                              size_t offset, size_t size, bool writable);
 
136
int pa_memimport_process_revoke(pa_memimport *i, uint32_t block_id);
 
137
 
 
138
/* For sending blocks to other nodes */
 
139
pa_memexport* pa_memexport_new(pa_mempool *p, pa_memexport_revoke_cb_t cb, void *userdata);
 
140
void pa_memexport_free(pa_memexport *e);
 
141
int pa_memexport_put(pa_memexport *e, pa_memblock *b, uint32_t *block_id, uint32_t *shm_id, size_t *offset, size_t *size);
 
142
int pa_memexport_process_release(pa_memexport *e, uint32_t id);
 
143
 
 
144
#endif