>
> Add a few more methods and accessors so that other files don't need to
> manipulate the struct members directly. Move the struct definition to a
> private header which only the dcc-* files will include.
> ---
> server/Makefile.am | 1 +
> server/dcc-encoders.c | 11 +++---
> server/dcc-encoders.h | 4 +--
> server/dcc-private.h | 87 ++++++++++++++++++++++++++++++++++++++++++++
> server/dcc-send.c | 2 +-
> server/dcc.c | 59 ++++++++++++++++++++++++++----
> server/dcc.h | 93
> ++++++++++++------------------------------------
> server/display-channel.c | 18 +++++-----
> server/display-channel.h | 3 +-
> server/image-cache.h | 1 -
> server/stream.c | 56 ++++++++++++++---------------
> server/stream.h | 2 +-
> 12 files changed, 211 insertions(+), 126 deletions(-)
> create mode 100644 server/dcc-private.h
>
> diff --git a/server/Makefile.am b/server/Makefile.am
> index cca3b9b..25a51bf 100644
> --- a/server/Makefile.am
> +++ b/server/Makefile.am
> @@ -146,6 +146,7 @@ libserver_la_SOURCES = \
> dcc-send.c \
> dcc.h \
> display-limits.h \
> + dcc-private.h \
> dcc-encoders.c \
> dcc-encoders.h \
> $(NULL)
> diff --git a/server/dcc-encoders.c b/server/dcc-encoders.c
> index f1dd1bb..0433ebf 100644
> --- a/server/dcc-encoders.c
> +++ b/server/dcc-encoders.c
> @@ -21,6 +21,7 @@
>
> #include <glib.h>
>
> +#include "dcc-private.h"
> #include "dcc-encoders.h"
> #include "display-channel.h"
>
> @@ -647,8 +648,8 @@ static GlzSharedDictionary
> *create_glz_dictionary(DisplayChannelClient *dcc,
> return glz_shared_dictionary_new(RED_CHANNEL_CLIENT(dcc)->client, id,
> glz_dict);
> }
>
> -GlzSharedDictionary *dcc_get_glz_dictionary(DisplayChannelClient *dcc,
> - uint8_t id, int window_size)
> +GlzSharedDictionary *get_glz_dictionary_for_dcc(DisplayChannelClient *dcc,
> + uint8_t id, int window_size)
This name change looks odd. Why?
> {
> GlzSharedDictionary *shared_dict;
>
> @@ -676,9 +677,9 @@ static GlzSharedDictionary
> *restore_glz_dictionary(DisplayChannelClient *dcc,
> return glz_shared_dictionary_new(RED_CHANNEL_CLIENT(dcc)->client, id,
> glz_dict);
> }
>
> -GlzSharedDictionary *dcc_restore_glz_dictionary(DisplayChannelClient *dcc,
> - uint8_t id,
> - GlzEncDictRestoreData
> *restore_data)
> +GlzSharedDictionary *restore_glz_dictionary_for_dcc(DisplayChannelClient
> *dcc,
> + uint8_t id,
> + GlzEncDictRestoreData
> *restore_data)
> {
> GlzSharedDictionary *shared_dict = NULL;
>
> diff --git a/server/dcc-encoders.h b/server/dcc-encoders.h
> index 84f9f93..2e391a6 100644
> --- a/server/dcc-encoders.h
> +++ b/server/dcc-encoders.h
> @@ -75,9 +75,9 @@ typedef struct GlzSharedDictionary {
> RedClient *client; // channel clients of the same client share the dict
> } GlzSharedDictionary;
>
> -GlzSharedDictionary* dcc_get_glz_dictionary
> (DisplayChannelClient *dcc,
> +GlzSharedDictionary* get_glz_dictionary_for_dcc
> (DisplayChannelClient *dcc,
> uint8_t id,
> int
> window_size);
> -GlzSharedDictionary* dcc_restore_glz_dictionary
> (DisplayChannelClient *dcc,
> +GlzSharedDictionary* restore_glz_dictionary_for_dcc
> (DisplayChannelClient *dcc,
> uint8_t id,
> GlzEncDictRestoreData
> *restore_data);
>
> diff --git a/server/dcc-private.h b/server/dcc-private.h
> new file mode 100644
> index 0000000..29b55ff
> --- /dev/null
> +++ b/server/dcc-private.h
> @@ -0,0 +1,87 @@
> +/* -*- Mode: C; c-basic-offset: 4; indent-tabs-mode: nil -*- */
> +/*
> + Copyright (C) 2009-2015 Red Hat, Inc.
> +
> + This library is free software; you can redistribute it and/or
> + modify it under the terms of the GNU Lesser General Public
> + License as published by the Free Software Foundation; either
> + version 2.1 of the License, or (at your option) any later version.
> +
> + This library 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
> + Lesser General Public License for more details.
> +
> + You should have received a copy of the GNU Lesser General Public
> + License along with this library; if not, see
> <http://www.gnu.org/licenses/>.
> +*/
> +#ifndef DCC_PRIVATE_H_
> +#define DCC_PRIVATE_H_
> +
> +#include "cache-item.h"
> +#include "dcc.h"
> +#include "dcc-encoders.h"
> +#include "stream.h"
> +
> +struct DisplayChannelClient {
> + CommonGraphicsChannelClient common;
> + uint32_t id;
> + SpiceImageCompression image_compression;
> + spice_wan_compression_t jpeg_state;
> + spice_wan_compression_t zlib_glz_state;
> + int jpeg_quality;
> + int zlib_level;
> +
> + QuicData quic_data;
> + QuicContext *quic;
> + LzData lz_data;
> + LzContext *lz;
> + JpegData jpeg_data;
> + JpegEncoderContext *jpeg;
> +#ifdef USE_LZ4
> + Lz4Data lz4_data;
> + Lz4EncoderContext *lz4;
> +#endif
> + ZlibData zlib_data;
> + ZlibEncoder *zlib;
> +
> + int expect_init;
> +
> + PixmapCache *pixmap_cache;
> + uint32_t pixmap_cache_generation;
> + int pending_pixmaps_sync;
> +
> + RedCacheItem *palette_cache[PALETTE_CACHE_HASH_SIZE];
> + Ring palette_cache_lru;
> + long palette_cache_available;
> + uint32_t palette_cache_items;
> +
> + struct {
> + uint32_t stream_outbuf_size;
> + uint8_t *stream_outbuf; // caution stream buffer is also used as
> compress bufs!!!
> +
> + FreeList free_list;
> + uint64_t pixmap_cache_items[MAX_DRAWABLE_PIXMAP_CACHE_ITEMS];
> + int num_pixmap_cache_items;
> + } send_data;
> +
> + /* global lz encoding entities */
> + GlzSharedDictionary *glz_dict;
> + GlzEncoderContext *glz;
> + GlzData glz_data;
> +
> + Ring glz_drawables; // all the living lz drawable, ordered
> by encoding time
> + Ring glz_drawables_inst_to_free; // list of instances to
> be freed
> + pthread_mutex_t glz_drawables_inst_to_free_lock;
> +
> + uint8_t surface_client_created[NUM_SURFACES];
> + QRegion surface_client_lossy_region[NUM_SURFACES];
> +
> + StreamAgent stream_agents[NUM_STREAMS];
> + int use_video_encoder_rate_control;
> + uint32_t streams_max_latency;
> + uint64_t streams_max_bit_rate;
> + bool gl_draw_ongoing;
> +};
> +
> +#endif /* DCC_PRIVATE_H_ */
> diff --git a/server/dcc-send.c b/server/dcc-send.c
> index f0f2e16..109c0b0 100644
> --- a/server/dcc-send.c
> +++ b/server/dcc-send.c
> @@ -19,7 +19,7 @@
> #include <config.h>
> #endif
>
> -#include "dcc.h"
> +#include "dcc-private.h"
> #include "display-channel.h"
>
> #include <common/marshaller.h>
> diff --git a/server/dcc.c b/server/dcc.c
> index b9e4eb3..da5089b 100644
> --- a/server/dcc.c
> +++ b/server/dcc.c
> @@ -19,7 +19,7 @@
> #include <config.h>
> #endif
>
> -#include "dcc.h"
> +#include "dcc-private.h"
> #include "display-channel.h"
>
> #define DISPLAY_CLIENT_SHORT_TIMEOUT 15000000000ULL //nano
> @@ -1373,9 +1373,9 @@ static int dcc_handle_init(DisplayChannelClient *dcc,
> SpiceMsgcDisplayInit *init
> ring_init(&dcc->glz_drawables);
> ring_init(&dcc->glz_drawables_inst_to_free);
> pthread_mutex_init(&dcc->glz_drawables_inst_to_free_lock, NULL);
> - dcc->glz_dict = dcc_get_glz_dictionary(dcc,
> - init->glz_dictionary_id,
> -
> init->glz_dictionary_window_size);
> + dcc->glz_dict = get_glz_dictionary_for_dcc(dcc,
> + init->glz_dictionary_id,
> +
> init->glz_dictionary_window_size);
> spice_return_val_if_fail(dcc->glz_dict, FALSE);
>
> return TRUE;
> @@ -1481,9 +1481,9 @@ static int
> dcc_handle_migrate_glz_dictionary(DisplayChannelClient *dcc,
> ring_init(&dcc->glz_drawables);
> ring_init(&dcc->glz_drawables_inst_to_free);
> pthread_mutex_init(&dcc->glz_drawables_inst_to_free_lock, NULL);
> - dcc->glz_dict = dcc_restore_glz_dictionary(dcc,
> - migrate->glz_dict_id,
> - &migrate->glz_dict_data);
> + dcc->glz_dict = restore_glz_dictionary_for_dcc(dcc,
> + migrate->glz_dict_id,
> + &migrate->glz_dict_data);
> return dcc->glz_dict != NULL;
> }
>
> @@ -1607,3 +1607,48 @@ int dcc_handle_migrate_data(DisplayChannelClient *dcc,
> uint32_t size, void *mess
> red_channel_client_ack_zero_messages_window(RED_CHANNEL_CLIENT(dcc));
> return TRUE;
> }
> +
> +StreamAgent* dcc_get_stream_agent(DisplayChannelClient *dcc, int stream_id)
> +{
> + return &dcc->stream_agents[stream_id];
> +}
> +
> +GlzSharedDictionary* dcc_get_glz_dictionary(DisplayChannelClient *dcc)
> +{
> + return dcc->glz_dict;
> +}
> +
> +spice_wan_compression_t dcc_get_jpeg_state(DisplayChannelClient *dcc)
> +{
> + return dcc->jpeg_state;
> +}
> +
> +spice_wan_compression_t dcc_get_zlib_glz_state(DisplayChannelClient *dcc)
> +{
> + return dcc->zlib_glz_state;
> +}
> +
> +gboolean dcc_use_video_encoder_rate_control(DisplayChannelClient *dcc)
> +{
> + return dcc->use_video_encoder_rate_control;
> +}
> +
> +uint32_t dcc_get_max_stream_latency(DisplayChannelClient *dcc)
> +{
> + return dcc->streams_max_latency;
> +}
> +
> +void dcc_set_max_stream_latency(DisplayChannelClient *dcc, uint32_t latency)
> +{
> + dcc->streams_max_latency = latency;
> +}
> +
> +uint64_t dcc_get_max_stream_bit_rate(DisplayChannelClient *dcc)
> +{
> + return dcc->streams_max_bit_rate;
> +}
> +
> +void dcc_set_max_stream_bit_rate(DisplayChannelClient *dcc, uint64_t rate)
> +{
> + dcc->streams_max_bit_rate = rate;
> +}
All these stream access suggests they should be put in a structure.
Future work by the way...
> diff --git a/server/dcc.h b/server/dcc.h
> index 864a768..d89a3f4 100644
> --- a/server/dcc.h
> +++ b/server/dcc.h
> @@ -18,11 +18,9 @@
> #ifndef DCC_H_
> # define DCC_H_
>
> -#include "red-worker.h"
> +#include "image-cache.h"
> #include "pixmap-cache.h"
> -#include "cache-item.h"
> -#include "dcc-encoders.h"
> -#include "stream.h"
> +#include "red-worker.h"
> #include "display-limits.h"
>
> #define PALETTE_CACHE_HASH_SHIFT 8
> @@ -42,6 +40,12 @@
>
> #define MAX_PIPE_SIZE 50
>
> +/* FIXME: remove */
> +typedef struct DisplayChannel DisplayChannel;
> +typedef struct Stream Stream;
> +typedef struct StreamAgent StreamAgent;
> +typedef struct GlzSharedDictionary GlzSharedDictionary;
> +
Hope temporary
> typedef struct WaitForChannels {
> SpiceMsgWaitForChannels header;
> SpiceWaitForChannel buf[MAX_CACHE_CLIENTS];
> @@ -54,72 +58,11 @@ typedef struct FreeList {
> WaitForChannels wait;
> } FreeList;
>
> -struct DisplayChannelClient {
> - CommonGraphicsChannelClient common;
> - uint32_t id;
> - SpiceImageCompression image_compression;
> - spice_wan_compression_t jpeg_state;
> - spice_wan_compression_t zlib_glz_state;
> - int jpeg_quality;
> - int zlib_level;
> -
> - QuicData quic_data;
> - QuicContext *quic;
> - LzData lz_data;
> - LzContext *lz;
> - JpegData jpeg_data;
> - JpegEncoderContext *jpeg;
> -#ifdef USE_LZ4
> - Lz4Data lz4_data;
> - Lz4EncoderContext *lz4;
> -#endif
> - ZlibData zlib_data;
> - ZlibEncoder *zlib;
> -
> - int expect_init;
> -
> - PixmapCache *pixmap_cache;
> - uint32_t pixmap_cache_generation;
> - int pending_pixmaps_sync;
> -
> - RedCacheItem *palette_cache[PALETTE_CACHE_HASH_SIZE];
> - Ring palette_cache_lru;
> - long palette_cache_available;
> - uint32_t palette_cache_items;
> -
> - struct {
> - uint32_t stream_outbuf_size;
> - uint8_t *stream_outbuf; // caution stream buffer is also used as
> compress bufs!!!
> -
> - FreeList free_list;
> - uint64_t pixmap_cache_items[MAX_DRAWABLE_PIXMAP_CACHE_ITEMS];
> - int num_pixmap_cache_items;
> - } send_data;
> -
> - /* global lz encoding entities */
> - GlzSharedDictionary *glz_dict;
> - GlzEncoderContext *glz;
> - GlzData glz_data;
> -
> - Ring glz_drawables; // all the living lz drawable, ordered
> by encoding time
> - Ring glz_drawables_inst_to_free; // list of instances to
> be freed
> - pthread_mutex_t glz_drawables_inst_to_free_lock;
> -
> - uint8_t surface_client_created[NUM_SURFACES];
> - QRegion surface_client_lossy_region[NUM_SURFACES];
> -
> - StreamAgent stream_agents[NUM_STREAMS];
> - int use_video_encoder_rate_control;
> - uint32_t streams_max_latency;
> - uint64_t streams_max_bit_rate;
> - bool gl_draw_ongoing;
> -};
> -
> -#define DCC_TO_WORKER(dcc) \
> - (SPICE_CONTAINEROF((dcc)->common.base.channel, CommonGraphicsChannel,
> base)->worker)
> -#define DCC_TO_DC(dcc) \
> - SPICE_CONTAINEROF((dcc)->common.base.channel, DisplayChannel,
> common.base)
> -#define RCC_TO_DCC(rcc) SPICE_CONTAINEROF((rcc), DisplayChannelClient,
> common.base)
> +typedef struct DisplayChannelClient DisplayChannelClient;
> +
> +#define DCC_TO_WORKER(dcc)
> ((RedWorker*)((CommonGraphicsChannel*)((RedChannelClient*)dcc)->channel)->worker)
> +#define DCC_TO_DC(dcc) ((DisplayChannel*)((RedChannelClient*)dcc)->channel)
> +#define RCC_TO_DCC(rcc) ((DisplayChannelClient*)rcc)
>
Here some static inline function would be better, at least we can't convert
an image to a DC. But it's just temporary.
Note that DCC_TO_WORKER is unused, worker field in CommonGraphicsChannel was
removed quite a while ago.
> typedef struct RedSurfaceCreateItem {
> RedPipeItem pipe_item;
> @@ -227,4 +170,14 @@ int dcc_compress_image
> (DisplayCha
> int
> can_lossy,
> compress_send_data_t*
> o_comp_data);
>
> +StreamAgent * dcc_get_stream_agent
> (DisplayChannelClient *dcc, int stream_id);
> +GlzSharedDictionary * dcc_get_glz_dictionary
> (DisplayChannelClient *dcc);
> +spice_wan_compression_t dcc_get_jpeg_state
> (DisplayChannelClient *dcc);
> +spice_wan_compression_t dcc_get_zlib_glz_state
> (DisplayChannelClient *dcc);
> +gboolean dcc_use_video_encoder_rate_control
> (DisplayChannelClient *dcc);
> +uint32_t dcc_get_max_stream_latency(DisplayChannelClient *dcc);
> +void dcc_set_max_stream_latency(DisplayChannelClient *dcc, uint32_t
> latency);
> +uint64_t dcc_get_max_stream_bit_rate(DisplayChannelClient *dcc);
> +void dcc_set_max_stream_bit_rate(DisplayChannelClient *dcc, uint64_t rate);
> +
> #endif /* DCC_H_ */
> diff --git a/server/display-channel.c b/server/display-channel.c
> index 615cac5..b4468de 100644
> --- a/server/display-channel.c
> +++ b/server/display-channel.c
> @@ -279,7 +279,7 @@ static void streams_update_visible_region(DisplayChannel
> *display, Drawable *dra
> }
>
> FOREACH_CLIENT(display, link, next, dcc) {
> - agent = &dcc->stream_agents[get_stream_id(display, stream)];
> + agent = dcc_get_stream_agent(dcc, get_stream_id(display,
> stream));
>
> if (region_intersects(&agent->vis_region,
> &drawable->tree_item.base.rgn)) {
> region_exclude(&agent->vis_region,
> &drawable->tree_item.base.rgn);
> @@ -1269,7 +1269,7 @@ void display_channel_free_some(DisplayChannel *display)
> spice_debug("#draw=%d, #glz_draw=%d", display->drawable_count,
> display->glz_drawable_count);
> FOREACH_CLIENT(display, link, next, dcc) {
> - GlzSharedDictionary *glz_dict = dcc ? dcc->glz_dict : NULL;
> + GlzSharedDictionary *glz_dict = dcc_get_glz_dictionary(dcc);
dcc test here was really worthless
>
> if (glz_dict) {
> // encoding using the dictionary is prevented since the
> following operations might
> @@ -1284,7 +1284,7 @@ void display_channel_free_some(DisplayChannel *display)
> }
>
> FOREACH_CLIENT(display, link, next, dcc) {
> - GlzSharedDictionary *glz_dict = dcc ? dcc->glz_dict : NULL;
> + GlzSharedDictionary *glz_dict = dcc_get_glz_dictionary(dcc);
>
> if (glz_dict) {
> pthread_rwlock_unlock(&glz_dict->encode_lock);
> @@ -2077,16 +2077,16 @@ void
> display_channel_process_surface_cmd(DisplayChannel *display, RedSurfaceCmd
>
> void display_channel_update_compression(DisplayChannel *display,
> DisplayChannelClient *dcc)
> {
> - if (dcc->jpeg_state == SPICE_WAN_COMPRESSION_AUTO) {
> - display->enable_jpeg = dcc->common.is_low_bandwidth;
> + if (dcc_get_jpeg_state(dcc) == SPICE_WAN_COMPRESSION_AUTO) {
> + display->enable_jpeg =
> ((CommonGraphicsChannelClient*)dcc)->is_low_bandwidth;
> } else {
> - display->enable_jpeg = (dcc->jpeg_state ==
> SPICE_WAN_COMPRESSION_ALWAYS);
> + display->enable_jpeg = (dcc_get_jpeg_state(dcc) ==
> SPICE_WAN_COMPRESSION_ALWAYS);
> }
>
> - if (dcc->zlib_glz_state == SPICE_WAN_COMPRESSION_AUTO) {
> - display->enable_zlib_glz_wrap = dcc->common.is_low_bandwidth;
> + if (dcc_get_zlib_glz_state(dcc) == SPICE_WAN_COMPRESSION_AUTO) {
> + display->enable_zlib_glz_wrap =
> ((CommonGraphicsChannelClient*)dcc)->is_low_bandwidth;
> } else {
> - display->enable_zlib_glz_wrap = (dcc->zlib_glz_state ==
> SPICE_WAN_COMPRESSION_ALWAYS);
> + display->enable_zlib_glz_wrap = (dcc_get_zlib_glz_state(dcc) ==
> SPICE_WAN_COMPRESSION_ALWAYS);
> }
> spice_info("jpeg %s", display->enable_jpeg ? "enabled" : "disabled");
> spice_info("zlib-over-glz %s", display->enable_zlib_glz_wrap ? "enabled"
> : "disabled");
> diff --git a/server/display-channel.h b/server/display-channel.h
> index 7c1bfde..af705de 100644
> --- a/server/display-channel.h
> +++ b/server/display-channel.h
> @@ -44,8 +44,7 @@
> #include "tree.h"
> #include "stream.h"
> #include "dcc.h"
> -#include "display-limits.h"
> -
> +#include "dcc-encoders.h"
>
> typedef struct DependItem {
> Drawable *drawable;
> diff --git a/server/image-cache.h b/server/image-cache.h
> index 38a318e..dfe863e 100644
> --- a/server/image-cache.h
> +++ b/server/image-cache.h
> @@ -25,7 +25,6 @@
>
> /* FIXME: move back to display-channel.h (once structs are private) */
> typedef struct Drawable Drawable;
> -typedef struct DisplayChannelClient DisplayChannelClient;
>
We definitively should consider using struct Xxxx instead of moving
these typedef everytime in order to compile...
> typedef struct ImageCacheItem {
> RingItem lru_link;
> diff --git a/server/stream.c b/server/stream.c
> index 85a0255..dc3202d 100644
> --- a/server/stream.c
> +++ b/server/stream.c
> @@ -66,7 +66,7 @@ void stream_agent_stats_print(StreamAgent *agent)
> static void stream_create_destroy_item_release(RedPipeItem *base)
> {
> StreamCreateDestroyItem *item = SPICE_CONTAINEROF(base,
> StreamCreateDestroyItem, base);
> - DisplayChannel *display =
> (DisplayChannel*)item->agent->dcc->common.base.channel;
> + DisplayChannel *display = DCC_TO_DC(item->agent->dcc);
> stream_agent_unref(display, item->agent);
> free(item);
> }
> @@ -105,17 +105,17 @@ void stream_stop(DisplayChannel *display, Stream
> *stream)
> FOREACH_CLIENT(display, link, next, dcc) {
> StreamAgent *stream_agent;
>
> - stream_agent = &dcc->stream_agents[get_stream_id(display, stream)];
> + stream_agent = dcc_get_stream_agent(dcc, get_stream_id(display,
> stream));
> region_clear(&stream_agent->vis_region);
> region_clear(&stream_agent->clip);
> - if (stream_agent->video_encoder &&
> dcc->use_video_encoder_rate_control) {
> + if (stream_agent->video_encoder &&
> dcc_use_video_encoder_rate_control(dcc)) {
> uint64_t stream_bit_rate =
> stream_agent->video_encoder->get_bit_rate(stream_agent->video_encoder);
>
> - if (stream_bit_rate > dcc->streams_max_bit_rate) {
> + if (stream_bit_rate > dcc_get_max_stream_bit_rate(dcc)) {
> spice_debug("old max-bit-rate=%.2f new=%.2f",
> - dcc->streams_max_bit_rate / 8.0 / 1024.0 /
> 1024.0,
> + dcc_get_max_stream_bit_rate(dcc) / 8.0 / 1024.0
> / 1024.0,
> stream_bit_rate / 8.0 / 1024.0 / 1024.0);
> - dcc->streams_max_bit_rate = stream_bit_rate;
> + dcc_set_max_stream_bit_rate(dcc, stream_bit_rate);
> }
> }
> red_channel_client_pipe_add(RED_CHANNEL_CLIENT(dcc),
> stream_destroy_item_new(stream_agent));
> @@ -311,7 +311,7 @@ static void attach_stream(DisplayChannel *display,
> Drawable *drawable, Stream *s
> StreamAgent *agent;
> QRegion clip_in_draw_dest;
>
> - agent = &dcc->stream_agents[get_stream_id(display, stream)];
> + agent = dcc_get_stream_agent(dcc, get_stream_id(display, stream));
> region_or(&agent->vis_region, &drawable->tree_item.base.rgn);
>
> region_init(&clip_in_draw_dest);
> @@ -365,10 +365,10 @@ static void before_reattach_stream(DisplayChannel
> *display,
> index = get_stream_id(display, stream);
> DRAWABLE_FOREACH_DPI_SAFE(stream->current, ring_item, next, dpi) {
> dcc = dpi->dcc;
> - agent = &dcc->stream_agents[index];
> + agent = dcc_get_stream_agent(dcc, index);
>
> - if (!dcc->use_video_encoder_rate_control &&
> - !dcc->common.is_low_bandwidth) {
> + if (!dcc_use_video_encoder_rate_control(dcc) &&
> + !((CommonGraphicsChannelClient*)dcc)->is_low_bandwidth) {
> continue;
> }
>
> @@ -376,7 +376,7 @@ static void before_reattach_stream(DisplayChannel
> *display,
> #ifdef STREAM_STATS
> agent->stats.num_drops_pipe++;
> #endif
> - if (dcc->use_video_encoder_rate_control) {
> + if (dcc_use_video_encoder_rate_control(dcc)) {
> agent->video_encoder->notify_server_frame_drop(agent->video_encoder);
> } else {
> ++agent->drops;
> @@ -388,9 +388,9 @@ static void before_reattach_stream(DisplayChannel
> *display,
> FOREACH_CLIENT(display, link, link_next, dcc) {
> double drop_factor;
>
> - agent = &dcc->stream_agents[index];
> + agent = dcc_get_stream_agent(dcc, index);
>
> - if (dcc->use_video_encoder_rate_control) {
> + if (dcc_use_video_encoder_rate_control(dcc)) {
> continue;
> }
> if (agent->frames / agent->fps < FPS_TEST_INTERVAL) {
> @@ -613,16 +613,16 @@ static void
> dcc_update_streams_max_latency(DisplayChannelClient *dcc, StreamAgen
> uint32_t new_max_latency = 0;
> int i;
>
> - if (dcc->streams_max_latency != remove_agent->client_required_latency) {
> + if (dcc_get_max_stream_latency(dcc) !=
> remove_agent->client_required_latency) {
> return;
> }
>
> - dcc->streams_max_latency = 0;
> + dcc_set_max_stream_latency(dcc, 0);
> if (DCC_TO_DC(dcc)->stream_count == 1) {
> return;
> }
> for (i = 0; i < NUM_STREAMS; i++) {
> - StreamAgent *other_agent = &dcc->stream_agents[i];
> + StreamAgent *other_agent = dcc_get_stream_agent(dcc, i);
> if (other_agent == remove_agent || !other_agent->video_encoder) {
> continue;
> }
> @@ -630,7 +630,7 @@ static void
> dcc_update_streams_max_latency(DisplayChannelClient *dcc, StreamAgen
> new_max_latency = other_agent->client_required_latency;
> }
> }
> - dcc->streams_max_latency = new_max_latency;
> + dcc_set_max_stream_latency(dcc, new_max_latency);
> }
>
> static uint64_t get_initial_bit_rate(DisplayChannelClient *dcc, Stream
> *stream)
> @@ -659,7 +659,7 @@ static uint64_t get_initial_bit_rate(DisplayChannelClient
> *dcc, Stream *stream)
> net_test_bit_rate =
> main_channel_client_is_network_info_initialized(mcc) ?
> main_channel_client_get_bitrate_per_sec(mcc)
> :
> 0;
> - bit_rate = MAX(dcc->streams_max_bit_rate, net_test_bit_rate);
> + bit_rate = MAX(dcc_get_max_stream_bit_rate(dcc), net_test_bit_rate);
> if (bit_rate == 0) {
> /*
> * In case we are after a spice session migration,
> @@ -667,7 +667,7 @@ static uint64_t get_initial_bit_rate(DisplayChannelClient
> *dcc, Stream *stream)
> * If the network info is not initialized due to another reason,
> * the low_bandwidth flag is FALSE.
> */
> - bit_rate = dcc->common.is_low_bandwidth ?
> + bit_rate = ((CommonGraphicsChannelClient*)dcc)->is_low_bandwidth
> ?
> RED_STREAM_DEFAULT_LOW_START_BIT_RATE :
> RED_STREAM_DEFAULT_HIGH_START_BIT_RATE;
> }
> @@ -711,23 +711,23 @@ static void update_client_playback_delay(void *opaque,
> uint32_t delay_ms)
> {
> StreamAgent *agent = opaque;
> DisplayChannelClient *dcc = agent->dcc;
> - RedsState *reds = red_channel_get_server(dcc->common.base.channel);
> + RedsState *reds =
> red_channel_get_server(((RedChannelClient*)dcc)->channel);
>
> dcc_update_streams_max_latency(dcc, agent);
>
> agent->client_required_latency = delay_ms;
> - if (delay_ms > agent->dcc->streams_max_latency) {
> - agent->dcc->streams_max_latency = delay_ms;
> + if (delay_ms > dcc_get_max_stream_latency(agent->dcc)) {
> + dcc_set_max_stream_latency(agent->dcc, delay_ms);
> }
> - spice_debug("resetting client latency: %u",
> agent->dcc->streams_max_latency);
> + spice_debug("resetting client latency: %u",
> dcc_get_max_stream_latency(agent->dcc));
> main_dispatcher_set_mm_time_latency(reds_get_main_dispatcher(reds),
> RED_CHANNEL_CLIENT(agent->dcc)->client,
> - agent->dcc->streams_max_latency);
> +
> dcc_get_max_stream_latency(agent->dcc));
> }
>
> void dcc_create_stream(DisplayChannelClient *dcc, Stream *stream)
> {
> - StreamAgent *agent = &dcc->stream_agents[get_stream_id(DCC_TO_DC(dcc),
> stream)];
> + StreamAgent *agent = dcc_get_stream_agent(dcc,
> get_stream_id(DCC_TO_DC(dcc), stream));
>
> spice_return_if_fail(region_is_empty(&agent->vis_region));
>
> @@ -742,7 +742,7 @@ void dcc_create_stream(DisplayChannelClient *dcc, Stream
> *stream)
> agent->fps = MAX_FPS;
> agent->dcc = dcc;
>
> - if (dcc->use_video_encoder_rate_control) {
> + if (dcc_use_video_encoder_rate_control(dcc)) {
> VideoEncoderRateControlCbs video_cbs;
> uint64_t initial_bit_rate;
>
> @@ -806,7 +806,7 @@ static void
> dcc_detach_stream_gracefully(DisplayChannelClient *dcc,
> {
> DisplayChannel *display = DCC_TO_DC(dcc);
> int stream_id = get_stream_id(display, stream);
> - StreamAgent *agent = &dcc->stream_agents[stream_id];
> + StreamAgent *agent = dcc_get_stream_agent(dcc, stream_id);
>
> /* stopping the client from playing older frames at once*/
> region_clear(&agent->clip);
> @@ -903,7 +903,7 @@ void stream_detach_behind(DisplayChannel *display,
> QRegion *region, Drawable *dr
> item = ring_next(ring, item);
>
> FOREACH_CLIENT(display, link, next, dcc) {
> - StreamAgent *agent = &dcc->stream_agents[get_stream_id(display,
> stream)];
> + StreamAgent *agent = dcc_get_stream_agent(dcc,
> get_stream_id(display, stream));
>
> if (region_intersects(&agent->vis_region, region)) {
> dcc_detach_stream_gracefully(dcc, stream, drawable);
> diff --git a/server/stream.h b/server/stream.h
> index 511d752..5622b75 100644
> --- a/server/stream.h
> +++ b/server/stream.h
> @@ -24,7 +24,7 @@
> #include "utils.h"
> #include "video-encoder.h"
> #include "red-channel.h"
> -#include "image-cache.h"
> +#include "dcc.h"
>
> #define RED_STREAM_DETACTION_MAX_DELTA (NSEC_PER_SEC / 5)
> #define RED_STREAM_CONTINUS_MAX_DELTA NSEC_PER_SEC
Frediano
_______________________________________________
Spice-devel mailing list
Spice-devel@xxxxxxxxxxxxxxxxxxxxx
https://lists.freedesktop.org/mailman/listinfo/spice-devel