1

#ifndef RENDER_SLICES_H

     2

#define RENDER_SLICES_H

     3

     4

#include "render.h"

     5

     6

#define RENDER_SLICES_MAX 2

     7

     8

struct render_slices;

     9

    10

struct render_slice_info {

    11

    // our index

    12

    size_t index;

    13

    14

    // the render info

    15

    struct render *render_info;

    16

    17

    // where to put the pixel data

    18

    unsigned char *render_buf;

    19

};

    20

    21

/*

    22

 * Split the given render operation into multiple slices that can be rendered

    23

 * induvidually.

    24

 *

    25

 * A segment is a single row of a slice. The raw pixel data for each segment

    26

 * should be stored into the render_buf item in that slice's render_slice_info.

    27

 * When a full segment has been stored into the render_buf, you should call

    28

 * render_slices_segment_done with that slice's index as an argument, and then

    29

 * proceed based on its return code.

    30

 *

    31

 * Returns a struct render_slices handle which can be used to operate on the

    32

 * slices, or NULL on failure.

    33

 */

    34

struct render_slices *render_slices_alloc (struct render *render);

    35

    36

/*

    37

 * Get the number of slices that need to be rendered, which is also the valid

    38

 * range of index values for render_slices_get_slice_info.

    39

 */

    40

int render_slices_get_count (struct render_slices *ctx);

    41

    42

/*

    43

 * Get the struct render_slice_info corresponding to the given index. This

    44

 * the information required to render the segment. The index is used as an

    45

 * argument to render_slices_segment_done.

    46

 */

    47

struct render_slice_info *render_slices_get_slice_info (struct render_slices *ctx, int index);

    48

    49

/*

    50

 * You may call render_slices_segment_done again for any slice now, including

    51

 * those which returned ~SLICE_CONTINUE earlier.

    52

 */

    53

#define SLICE_CONTINUE 0x01

    54

    55

/*

    56

 * You may call render_slices_process_row next.

    57

 */

    58

#define SLICE_PROCESS_ROW 0x02

    59

    60

// XXX: you can't modify the slice's row buffer until these return SLICE_CONTINUE

    61

    62

/*

    63

 * The render_buf for the render_slice_info with the given index value contains

    64

 * the full information for the next row of the render_info render. Returns a

    65

 * bitwise-OR of the SLICE_* flags, or -1 for an error:

    66

 *

    67

 * Valid return values:

    68

 *  zero

    69

 *      Do not call segment_done for this index, or process_row right now.

    70

 *      Information for some slice needed to complete the next row is missing,

    71

 *      and the other segments must call segment_done first.

    72

 * 

    73

 *  SLICE_PROCESS_ROW

    74

 *      Do not call segment_done for this index or any others, but do call

    75

 *      process_row as soon as possible, and then continue once it returns

    76

 *      (see render_slices_process_row).

    77

 *  

    78

 *  SLICE_CONTINUE & SLICE_PROCESS_ROW

    79

 *      You should call process_row next, but you can also call segment_done

    80

 *      for all segments that returned ~SLICE_CONTINUE earlier.

    81

 *

    82

 * -1   - An error occured. Rendering must be aborted.

    83

 *

    84

 */

    85

int render_slices_segment_done (struct render_slices *ctx, int index);

    86

    87

/*

    88

 * Process a completed row and generate output in the PNG format (how that is

    89

 * handled depends on the render given to render_slices_alloc/init). Returns a

    90

 * bitwise-OR of the SLICE_* flags, or -1 for an error:

    91

 *

    92

 * Valid return values :

    93

 *  zero

    94

 *      The PNG is done - you don't need to call segment_done or process_row

    95

 *      anymore, doing so will result in an error. You don't need to deinit

    96

 *      ctx, but you may need to free it.

    97

 *

    98

 *  SLICE_CONTINUE

    99

 *      You may call render_slices_segment_done again for those slices that

   100

 *      returned ~SLICE_CONTINUE earlier.

   101

 *

   102

 *  SLICE_CONTINUE & SLICE_PROCESS_ROW

   103

 *      In addition to calling render_slices_segment_done again, you may also

   104

 *      call render_slices_process_row again.

   105

 *

   106

 * -1   - An error occured. Rendering must be aborted.

   107

 */

   108

int render_slices_process_row (struct render_slices *ctx);

   109

   110

/*

   111

 * Signifiy that the render has been completed. This will flush out buffered

   112

 * output data.

   113

 */

   114

int render_slices_done (struct render_slices *ctx);

   115

   116

/*

   117

 * Free a render_slices. The rendering may or may not be complete.

   118

 */

   119

void render_slices_free (struct render_slices *ctx);

   120

   121

#endif /* RENDER_SLICES_H */