Lines Matching defs:bq
48 pa_memblockq* bq;
53 bq = pa_xnew0(pa_memblockq, 1);
54 bq->name = pa_xstrdup(name);
56 bq->sample_spec = *sample_spec;
57 bq->base = pa_frame_size(sample_spec);
58 bq->read_index = bq->write_index = idx;
61 (unsigned long) maxlength, (unsigned long) tlength, (unsigned long) bq->base, (unsigned long) prebuf, (unsigned long) minreq, (unsigned long) maxrewind);
63 bq->in_prebuf = true;
65 pa_memblockq_set_maxlength(bq, maxlength);
66 pa_memblockq_set_tlength(bq, tlength);
67 pa_memblockq_set_minreq(bq, minreq);
68 pa_memblockq_set_prebuf(bq, prebuf);
69 pa_memblockq_set_maxrewind(bq, maxrewind);
72 (unsigned long) bq->maxlength, (unsigned long) bq->tlength, (unsigned long) bq->base, (unsigned long) bq->prebuf, (unsigned long) bq->minreq, (unsigned long) bq->maxrewind);
75 bq->silence = *silence;
76 pa_memblock_ref(bq->silence.memblock);
79 bq->mcalign = pa_mcalign_new(bq->base);
81 return bq;
84 void pa_memblockq_free(pa_memblockq* bq) {
85 pa_assert(bq);
87 pa_memblockq_silence(bq);
89 if (bq->silence.memblock)
90 pa_memblock_unref(bq->silence.memblock);
92 if (bq->mcalign)
93 pa_mcalign_free(bq->mcalign);
95 pa_xfree(bq->name);
96 pa_xfree(bq);
99 static void fix_current_read(pa_memblockq *bq) {
100 pa_assert(bq);
102 if (PA_UNLIKELY(!bq->blocks)) {
103 bq->current_read = NULL;
107 if (PA_UNLIKELY(!bq->current_read))
108 bq->current_read = bq->blocks;
111 while (PA_UNLIKELY(bq->current_read->index > bq->read_index))
113 if (bq->current_read->prev)
114 bq->current_read = bq->current_read->prev;
119 while (PA_LIKELY(bq->current_read != NULL) && PA_UNLIKELY(bq->current_read->index + (int64_t) bq->current_read->chunk.length <= bq->read_index))
120 bq->current_read = bq->current_read->next;
127 static void fix_current_write(pa_memblockq *bq) {
128 pa_assert(bq);
130 if (PA_UNLIKELY(!bq->blocks)) {
131 bq->current_write = NULL;
135 if (PA_UNLIKELY(!bq->current_write))
136 bq->current_write = bq->blocks_tail;
139 while (PA_UNLIKELY(bq->current_write->index + (int64_t) bq->current_write->chunk.length <= bq->write_index))
141 if (bq->current_write->next)
142 bq->current_write = bq->current_write->next;
147 while (PA_LIKELY(bq->current_write != NULL) && PA_UNLIKELY(bq->current_write->index > bq->write_index))
148 bq->current_write = bq->current_write->prev;
155 static bool can_push(pa_memblockq *bq, size_t l) {
158 pa_assert(bq);
160 if (bq->read_index > bq->write_index) {
161 int64_t d = bq->read_index - bq->write_index;
169 end = bq->blocks_tail ? bq->blocks_tail->index + (int64_t) bq->blocks_tail->chunk.length : bq->write_index;
172 if (bq->write_index + (int64_t) l > end)
173 if (bq->write_index + (int64_t) l - bq->read_index > (int64_t) bq->maxlength)
179 static void write_index_changed(pa_memblockq *bq, int64_t old_write_index, bool account) {
182 pa_assert(bq);
184 delta = bq->write_index - old_write_index;
187 bq->requested -= delta;
189 bq->missing -= delta;
192 pa_log_debug("[%s] pushed/seeked %lli: requested counter at %lli, account=%i", bq->name, (long long) delta, (long long) bq->requested, account);
196 static void read_index_changed(pa_memblockq *bq, int64_t old_read_index) {
199 pa_assert(bq);
201 delta = bq->read_index - old_read_index;
202 bq->missing += delta;
205 pa_log_debug("[%s] popped %lli: missing counter at %lli", bq->name, (long long) delta, (long long) bq->missing);
209 int pa_memblockq_push(pa_memblockq* bq, const pa_memchunk *uchunk) {
214 pa_assert(bq);
220 pa_assert(uchunk->length % bq->base == 0);
221 pa_assert(uchunk->index % bq->base == 0);
223 if (!can_push(bq, uchunk->length))
226 old = bq->write_index;
229 fix_current_write(bq);
230 q = bq->current_write;
236 while (bq->write_index + (int64_t) chunk.length > q->index)
244 q = bq->blocks_tail;
251 if (bq->write_index >= q->index + (int64_t) q->chunk.length)
254 else if (bq->write_index + (int64_t) chunk.length <= q->index) {
257 } else if (bq->write_index <= q->index &&
258 bq->write_index + (int64_t) chunk.length >= q->index + (int64_t) q->chunk.length) {
265 drop_block(bq, p);
266 } else if (bq->write_index >= q->index) {
270 if (bq->write_index + (int64_t) chunk.length < q->index + (int64_t) q->chunk.length) {
284 d = (size_t) (bq->write_index + (int64_t) chunk.length - q->index);
296 bq->blocks_tail = p;
299 bq->n_blocks++;
303 if (!(q->chunk.length = (size_t) (bq->write_index - q->index))) {
307 drop_block(bq, p);
315 pa_assert(bq->write_index + (int64_t)chunk.length > q->index &&
316 bq->write_index + (int64_t)chunk.length < q->index + (int64_t)q->chunk.length &&
317 bq->write_index < q->index);
321 d = (size_t) (bq->write_index + (int64_t) chunk.length - q->index);
331 pa_assert(bq->write_index >= q->index + (int64_t)q->chunk.length);
332 pa_assert(!q->next || (bq->write_index + (int64_t)chunk.length <= q->next->index));
338 bq->write_index == q->index + (int64_t) q->chunk.length) {
341 bq->write_index += (int64_t) chunk.length;
345 pa_assert(!bq->blocks || (bq->write_index + (int64_t)chunk.length <= bq->blocks->index));
352 n->index = bq->write_index;
353 bq->write_index += (int64_t) n->chunk.length;
355 n->next = q ? q->next : bq->blocks;
361 bq->blocks_tail = n;
366 bq->blocks = n;
368 bq->n_blocks++;
372 write_index_changed(bq, old, true);
376 bool pa_memblockq_prebuf_active(pa_memblockq *bq) {
377 pa_assert(bq);
379 if (bq->in_prebuf)
380 return pa_memblockq_get_length(bq) < bq->prebuf;
382 return bq->prebuf > 0 && bq->read_index >= bq->write_index;
385 static bool update_prebuf(pa_memblockq *bq) {
386 pa_assert(bq);
388 if (bq->in_prebuf) {
390 if (pa_memblockq_get_length(bq) < bq->prebuf)
393 bq->in_prebuf = false;
397 if (bq->prebuf > 0 && bq->read_index >= bq->write_index) {
398 bq->in_prebuf = true;
406 int pa_memblockq_peek(pa_memblockq* bq, pa_memchunk *chunk) {
408 pa_assert(bq);
412 if (update_prebuf(bq))
415 fix_current_read(bq);
418 if (!bq->current_read || bq->current_read->index > bq->read_index) {
422 if (bq->current_read)
423 length = (size_t) (bq->current_read->index - bq->read_index);
424 else if (bq->write_index > bq->read_index)
425 length = (size_t) (bq->write_index - bq->read_index);
430 if (bq->silence.memblock) {
431 *chunk = bq->silence;
453 *chunk = bq->current_read->chunk;
456 pa_assert(bq->read_index >= bq->current_read->index);
457 d = bq->read_index - bq->current_read->index;
464 int pa_memblockq_peek_fixed_size(pa_memblockq *bq, size_t block_size, pa_memchunk *chunk) {
470 pa_assert(bq);
473 pa_assert(bq->silence.memblock);
475 if (pa_memblockq_peek(bq, &tchunk) < 0)
497 item = bq->current_read;
498 ri = bq->read_index + tchunk.length;
504 tchunk = bq->silence;
537 void pa_memblockq_drop(pa_memblockq *bq, size_t length) {
539 pa_assert(bq);
540 pa_assert(length % bq->base == 0);
542 old = bq->read_index;
547 if (update_prebuf(bq))
550 fix_current_read(bq);
552 if (bq->current_read) {
558 p = bq->current_read->index + (int64_t) bq->current_read->chunk.length;
559 pa_assert(p >= bq->read_index);
560 d = p - bq->read_index;
565 bq->read_index += d;
571 bq->read_index += (int64_t) length;
576 drop_backlog(bq);
577 read_index_changed(bq, old);
580 void pa_memblockq_rewind(pa_memblockq *bq, size_t length) {
582 pa_assert(bq);
583 pa_assert(length % bq->base == 0);
585 old = bq->read_index;
589 bq->read_index -= (int64_t) length;
591 read_index_changed(bq, old);
594 bool pa_memblockq_is_readable(pa_memblockq *bq) {
595 pa_assert(bq);
597 if (pa_memblockq_prebuf_active(bq))
600 if (pa_memblockq_get_length(bq) <= 0)
606 size_t pa_memblockq_get_length(pa_memblockq *bq) {
607 pa_assert(bq);
609 if (bq->write_index <= bq->read_index)
612 return (size_t) (bq->write_index - bq->read_index);
615 void pa_memblockq_seek(pa_memblockq *bq, int64_t offset, pa_seek_mode_t seek, bool account) {
617 pa_assert(bq);
619 old = bq->write_index;
623 bq->write_index += offset;
626 bq->write_index = offset;
629 bq->write_index = bq->read_index + offset;
632 bq->write_index = (bq->blocks_tail ? bq->blocks_tail->index + (int64_t) bq->blocks_tail->chunk.length : bq->read_index) + offset;
638 drop_backlog(bq);
639 write_index_changed(bq, old, account);
642 void pa_memblockq_flush_write(pa_memblockq *bq, bool account) {
644 pa_assert(bq);
646 pa_memblockq_silence(bq);
648 old = bq->write_index;
649 bq->write_index = bq->read_index;
651 pa_memblockq_prebuf_force(bq);
652 write_index_changed(bq, old, account);
655 void pa_memblockq_flush_read(pa_memblockq *bq) {
657 pa_assert(bq);
659 pa_memblockq_silence(bq);
661 old = bq->read_index;
662 bq->read_index = bq->write_index;
664 pa_memblockq_prebuf_force(bq);
665 read_index_changed(bq, old);
668 size_t pa_memblockq_get_tlength(pa_memblockq *bq) {
669 pa_assert(bq);
671 return bq->tlength;
674 size_t pa_memblockq_get_minreq(pa_memblockq *bq) {
675 pa_assert(bq);
677 return bq->minreq;
680 size_t pa_memblockq_get_maxrewind(pa_memblockq *bq) {
681 pa_assert(bq);
683 return bq->maxrewind;
686 int64_t pa_memblockq_get_read_index(pa_memblockq *bq) {
687 pa_assert(bq);
689 return bq->read_index;
692 int64_t pa_memblockq_get_write_index(pa_memblockq *bq) {
693 pa_assert(bq);
695 return bq->write_index;
698 int pa_memblockq_push_align(pa_memblockq* bq, const pa_memchunk *chunk) {
701 pa_assert(bq);
704 if (bq->base == 1)
705 return pa_memblockq_push(bq, chunk);
707 if (!can_push(bq, pa_mcalign_csize(bq->mcalign, chunk->length)))
710 pa_mcalign_push(bq->mcalign, chunk);
712 while (pa_mcalign_pop(bq->mcalign, &rchunk) >= 0) {
714 r = pa_memblockq_push(bq, &rchunk);
718 pa_mcalign_flush(bq->mcalign);
726 void pa_memblockq_prebuf_disable(pa_memblockq *bq) {
727 pa_assert(bq);
729 bq->in_prebuf = false;
732 void pa_memblockq_prebuf_force(pa_memblockq *bq) {
733 pa_assert(bq);
735 if (bq->prebuf > 0)
736 bq->in_prebuf = true;
739 size_t pa_memblockq_get_maxlength(pa_memblockq *bq) {
740 pa_assert(bq);
742 return bq->maxlength;
745 size_t pa_memblockq_get_prebuf(pa_memblockq *bq) {
746 pa_assert(bq);
748 return bq->prebuf;
751 size_t pa_memblockq_pop_missing(pa_memblockq *bq) {
754 pa_assert(bq);
757 pa_log_debug("[%s] pop: %lli", bq->name, (long long) bq->missing);
760 if (bq->missing <= 0)
763 if (((size_t) bq->missing < bq->minreq) &&
764 !pa_memblockq_prebuf_active(bq))
767 l = (size_t) bq->missing;
769 bq->requested += bq->missing;
770 bq->missing = 0;
773 pa_log_debug("[%s] sent %lli: request counter is at %lli", bq->name, (long long) l, (long long) bq->requested);
779 void pa_memblockq_set_maxlength(pa_memblockq *bq, size_t maxlength) {
780 pa_assert(bq);
782 bq->maxlength = ((maxlength+bq->base-1)/bq->base)*bq->base;
784 if (bq->maxlength < bq->base)
785 bq->maxlength = bq->base;
787 if (bq->tlength > bq->maxlength)
788 pa_memblockq_set_tlength(bq, bq->maxlength);
791 void pa_memblockq_set_tlength(pa_memblockq *bq, size_t tlength) {
793 pa_assert(bq);
796 tlength = bq->maxlength;
798 old_tlength = bq->tlength;
799 bq->tlength = ((tlength+bq->base-1)/bq->base)*bq->base;
801 if (bq->tlength > bq->maxlength)
802 bq->tlength = bq->maxlength;
804 if (bq->minreq > bq->tlength)
805 pa_memblockq_set_minreq(bq, bq->tlength);
807 if (bq->prebuf > bq->tlength+bq->base-bq->minreq)
808 pa_memblockq_set_prebuf(bq, bq->tlength+bq->base-bq->minreq);
810 bq->missing += (int64_t) bq->tlength - (int64_t) old_tlength;
813 void pa_memblockq_set_minreq(pa_memblockq *bq, size_t minreq) {
814 pa_assert(bq);
816 bq->minreq = (minreq/bq->base)*bq->base;
818 if (bq->minreq > bq->tlength)
819 bq->minreq = bq->tlength;
821 if (bq->minreq < bq->base)
822 bq->minreq = bq->base;
824 if (bq->prebuf > bq->tlength+bq->base-bq->minreq)
825 pa_memblockq_set_prebuf(bq, bq->tlength+bq->base-bq->minreq);
828 void pa_memblockq_set_prebuf(pa_memblockq *bq, size_t prebuf) {
829 pa_assert(bq);
832 prebuf = bq->tlength+bq->base-bq->minreq;
834 bq->prebuf = ((prebuf+bq->base-1)/bq->base)*bq->base;
836 if (prebuf > 0 && bq->prebuf < bq->base)
837 bq->prebuf = bq->base;
839 if (bq->prebuf > bq->tlength+bq->base-bq->minreq)
840 bq->prebuf = bq->tlength+bq->base-bq->minreq;
842 if (bq->prebuf <= 0 || pa_memblockq_get_length(bq) >= bq->prebuf)
843 bq->in_prebuf = false;
846 void pa_memblockq_set_maxrewind(pa_memblockq *bq, size_t maxrewind) {
847 pa_assert(bq);
849 bq->maxrewind = (maxrewind/bq->base)*bq->base;
852 void pa_memblockq_apply_attr(pa_memblockq *bq, const pa_buffer_attr *a) {
853 pa_assert(bq);
856 pa_memblockq_set_maxlength(bq, a->maxlength);
857 pa_memblockq_set_tlength(bq, a->tlength);
858 pa_memblockq_set_minreq(bq, a->minreq);
859 pa_memblockq_set_prebuf(bq, a->prebuf);
862 void pa_memblockq_get_attr(pa_memblockq *bq, pa_buffer_attr *a) {
863 pa_assert(bq);
866 a->maxlength = (uint32_t) pa_memblockq_get_maxlength(bq);
867 a->tlength = (uint32_t) pa_memblockq_get_tlength(bq);
868 a->prebuf = (uint32_t) pa_memblockq_get_prebuf(bq);
869 a->minreq = (uint32_t) pa_memblockq_get_minreq(bq);
872 int pa_memblockq_splice(pa_memblockq *bq, pa_memblockq *source) {
874 pa_assert(bq);
877 pa_memblockq_prebuf_disable(bq);
889 if (pa_memblockq_push_align(bq, &chunk) < 0) {
896 pa_memblockq_seek(bq, (int64_t) chunk.length, PA_SEEK_RELATIVE, true);
898 pa_memblockq_drop(bq, chunk.length);
902 void pa_memblockq_willneed(pa_memblockq *bq) {
905 pa_assert(bq);
907 fix_current_read(bq);
909 for (q = bq->current_read; q; q = q->next)
913 void pa_memblockq_set_silence(pa_memblockq *bq, pa_memchunk *silence) {
914 pa_assert(bq);
916 if (bq->silence.memblock)
917 pa_memblock_unref(bq->silence.memblock);
920 bq->silence = *silence;
921 pa_memblock_ref(bq->silence.memblock);
923 pa_memchunk_reset(&bq->silence);
926 bool pa_memblockq_is_empty(pa_memblockq *bq) {
927 pa_assert(bq);
929 return !bq->blocks;
932 void pa_memblockq_silence(pa_memblockq *bq) {
933 pa_assert(bq);
935 while (bq->blocks)
936 drop_block(bq, bq->blocks);
938 pa_assert(bq->n_blocks == 0);
941 unsigned pa_memblockq_get_nblocks(pa_memblockq *bq) {
942 pa_assert(bq);
944 return bq->n_blocks;
947 size_t pa_memblockq_get_base(pa_memblockq *bq) {
948 pa_assert(bq);
950 return bq->base;