/*

 * jdcol565.c

 *

 * This file was part of the Independent JPEG Group's software:

 * Copyright (C) 1991-1997, Thomas G. Lane.

 * Modifications:

 * Copyright (C) 2013, Linaro Limited.

 * Copyright (C) 2014-2015, 2022, D. R. Commander.

 * For conditions of distribution and use, see the accompanying README.ijg

 * file.

 *

 * This file contains output colorspace conversion routines.

 */

/* This file is included by jdcolor.c */

INLINE

LOCAL(void)

ycc_rgb565_convert_internal(j_decompress_ptr cinfo, _JSAMPIMAGE input_buf,

                            JDIMENSION input_row, _JSAMPARRAY output_buf,

                            int num_rows)

{

#if BITS_IN_JSAMPLE != 16

  my_cconvert_ptr cconvert = (my_cconvert_ptr)cinfo->cconvert;

  register int y, cb, cr;

  register _JSAMPROW outptr;

  register _JSAMPROW inptr0, inptr1, inptr2;

  register JDIMENSION col;

  JDIMENSION num_cols = cinfo->output_width;

  /* copy these pointers into registers if possible */

  register _JSAMPLE *range_limit = (_JSAMPLE *)cinfo->sample_range_limit;

  register int *Crrtab = cconvert->Cr_r_tab;

  register int *Cbbtab = cconvert->Cb_b_tab;

  register JLONG *Crgtab = cconvert->Cr_g_tab;

  register JLONG *Cbgtab = cconvert->Cb_g_tab;

  SHIFT_TEMPS

  while (--num_rows >= 0) {

    JLONG rgb;

    unsigned int r, g, b;

    inptr0 = input_buf[0][input_row];

    inptr1 = input_buf[1][input_row];

    inptr2 = input_buf[2][input_row];

    input_row++;

    outptr = *output_buf++;

    if (PACK_NEED_ALIGNMENT(outptr)) {

      y  = *inptr0++;

      cb = *inptr1++;

      cr = *inptr2++;

      r = range_limit[y + Crrtab[cr]];

      g = range_limit[y + ((int)RIGHT_SHIFT(Cbgtab[cb] + Crgtab[cr],

                                            SCALEBITS))];

      b = range_limit[y + Cbbtab[cb]];

      rgb = PACK_SHORT_565(r, g, b);

      *(INT16 *)outptr = (INT16)rgb;

      outptr += 2;

      num_cols--;

    }

    for (col = 0; col < (num_cols >> 1); col++) {

      y  = *inptr0++;

      cb = *inptr1++;

      cr = *inptr2++;

      r = range_limit[y + Crrtab[cr]];

      g = range_limit[y + ((int)RIGHT_SHIFT(Cbgtab[cb] + Crgtab[cr],

                                            SCALEBITS))];

      b = range_limit[y + Cbbtab[cb]];

      rgb = PACK_SHORT_565(r, g, b);

      y  = *inptr0++;

      cb = *inptr1++;

      cr = *inptr2++;

      r = range_limit[y + Crrtab[cr]];

      g = range_limit[y + ((int)RIGHT_SHIFT(Cbgtab[cb] + Crgtab[cr],

                                            SCALEBITS))];

      b = range_limit[y + Cbbtab[cb]];

      rgb = PACK_TWO_PIXELS(rgb, PACK_SHORT_565(r, g, b));

      WRITE_TWO_ALIGNED_PIXELS(outptr, rgb);

      outptr += 4;

    }

    if (num_cols & 1) {

      y  = *inptr0;

      cb = *inptr1;

      cr = *inptr2;

      r = range_limit[y + Crrtab[cr]];

      g = range_limit[y + ((int)RIGHT_SHIFT(Cbgtab[cb] + Crgtab[cr],

                                            SCALEBITS))];

      b = range_limit[y + Cbbtab[cb]];

      rgb = PACK_SHORT_565(r, g, b);

      *(INT16 *)outptr = (INT16)rgb;

    }

  }

#else

  ERREXIT(cinfo, JERR_CONVERSION_NOTIMPL);

#endif

}

Unexecuted instantiation: jdcolor-8.c:ycc_rgb565_convert_be

jdcolor-8.c:ycc_rgb565_convert_le

Line

Count

Source

23

10.7M

{

24

10.7M

#if BITS_IN_JSAMPLE != 16

25

10.7M

  my_cconvert_ptr cconvert = (my_cconvert_ptr)cinfo->cconvert;

26

10.7M

  register int y, cb, cr;

27

10.7M

  register _JSAMPROW outptr;

28

10.7M

  register _JSAMPROW inptr0, inptr1, inptr2;

29

10.7M

  register JDIMENSION col;

30

10.7M

  JDIMENSION num_cols = cinfo->output_width;

31

  /* copy these pointers into registers if possible */

32

10.7M

  register _JSAMPLE *range_limit = (_JSAMPLE *)cinfo->sample_range_limit;

33

10.7M

  register int *Crrtab = cconvert->Cr_r_tab;

34

10.7M

  register int *Cbbtab = cconvert->Cb_b_tab;

35

10.7M

  register JLONG *Crgtab = cconvert->Cr_g_tab;

36

10.7M

  register JLONG *Cbgtab = cconvert->Cb_g_tab;

37

10.7M

  SHIFT_TEMPS

38

39

21.5M

  while (--num_rows >= 0) {

40

10.7M

    JLONG rgb;

41

10.7M

    unsigned int r, g, b;

42

10.7M

    inptr0 = input_buf[0][input_row];

43

10.7M

    inptr1 = input_buf[1][input_row];

44

10.7M

    inptr2 = input_buf[2][input_row];

45

10.7M

    input_row++;

46

10.7M

    outptr = *output_buf++;

47

48

10.7M

    if (PACK_NEED_ALIGNMENT(outptr)) {

49

0

      y  = *inptr0++;

50

0

      cb = *inptr1++;

51

0

      cr = *inptr2++;

52

0

      r = range_limit[y + Crrtab[cr]];

53

0

      g = range_limit[y + ((int)RIGHT_SHIFT(Cbgtab[cb] + Crgtab[cr],

54

0

                                            SCALEBITS))];

55

0

      b = range_limit[y + Cbbtab[cb]];

56

0

      rgb = PACK_SHORT_565(r, g, b);

57

0

      *(INT16 *)outptr = (INT16)rgb;

58

0

      outptr += 2;

59

0

      num_cols--;

60

0

    }

61

318M

    for (col = 0; col < (num_cols >> 1); col++) {

62

307M

      y  = *inptr0++;

63

307M

      cb = *inptr1++;

64

307M

      cr = *inptr2++;

65

307M

      r = range_limit[y + Crrtab[cr]];

66

307M

      g = range_limit[y + ((int)RIGHT_SHIFT(Cbgtab[cb] + Crgtab[cr],

67

307M

                                            SCALEBITS))];

68

307M

      b = range_limit[y + Cbbtab[cb]];

69

307M

      rgb = PACK_SHORT_565(r, g, b);

70

71

307M

      y  = *inptr0++;

72

307M

      cb = *inptr1++;

73

307M

      cr = *inptr2++;

74

307M

      r = range_limit[y + Crrtab[cr]];

75

307M

      g = range_limit[y + ((int)RIGHT_SHIFT(Cbgtab[cb] + Crgtab[cr],

76

307M

                                            SCALEBITS))];

77

307M

      b = range_limit[y + Cbbtab[cb]];

78

307M

      rgb = PACK_TWO_PIXELS(rgb, PACK_SHORT_565(r, g, b));

79

80

307M

      WRITE_TWO_ALIGNED_PIXELS(outptr, rgb);

81

307M

      outptr += 4;

82

307M

    }

83

10.7M

    if (num_cols & 1) {

84

1.57M

      y  = *inptr0;

85

1.57M

      cb = *inptr1;

86

1.57M

      cr = *inptr2;

87

1.57M

      r = range_limit[y + Crrtab[cr]];

88

1.57M

      g = range_limit[y + ((int)RIGHT_SHIFT(Cbgtab[cb] + Crgtab[cr],

89

1.57M

                                            SCALEBITS))];

90

1.57M

      b = range_limit[y + Cbbtab[cb]];

91

1.57M

      rgb = PACK_SHORT_565(r, g, b);

92

1.57M

      *(INT16 *)outptr = (INT16)rgb;

93

1.57M

    }

94

10.7M

  }

95

#else

96

  ERREXIT(cinfo, JERR_CONVERSION_NOTIMPL);

97

#endif

98

10.7M

}

Unexecuted instantiation: jdcolor-12.c:ycc_rgb565_convert_be

Unexecuted instantiation: jdcolor-12.c:ycc_rgb565_convert_le

Unexecuted instantiation: jdcolor-16.c:ycc_rgb565_convert_be

Unexecuted instantiation: jdcolor-16.c:ycc_rgb565_convert_le

INLINE

LOCAL(void)

ycc_rgb565D_convert_internal(j_decompress_ptr cinfo, _JSAMPIMAGE input_buf,

                             JDIMENSION input_row, _JSAMPARRAY output_buf,

                             int num_rows)

{

#if BITS_IN_JSAMPLE != 16

  my_cconvert_ptr cconvert = (my_cconvert_ptr)cinfo->cconvert;

  register int y, cb, cr;

  register _JSAMPROW outptr;

  register _JSAMPROW inptr0, inptr1, inptr2;

  register JDIMENSION col;

  JDIMENSION num_cols = cinfo->output_width;

  /* copy these pointers into registers if possible */

  register _JSAMPLE *range_limit = (_JSAMPLE *)cinfo->sample_range_limit;

  register int *Crrtab = cconvert->Cr_r_tab;

  register int *Cbbtab = cconvert->Cb_b_tab;

  register JLONG *Crgtab = cconvert->Cr_g_tab;

  register JLONG *Cbgtab = cconvert->Cb_g_tab;

  JLONG d0 = dither_matrix[cinfo->output_scanline & DITHER_MASK];

  SHIFT_TEMPS

  while (--num_rows >= 0) {

    JLONG rgb;

    unsigned int r, g, b;

    inptr0 = input_buf[0][input_row];

    inptr1 = input_buf[1][input_row];

    inptr2 = input_buf[2][input_row];

    input_row++;

    outptr = *output_buf++;

    if (PACK_NEED_ALIGNMENT(outptr)) {

      y  = *inptr0++;

      cb = *inptr1++;

      cr = *inptr2++;

      r = range_limit[DITHER_565_R(y + Crrtab[cr], d0)];

      g = range_limit[DITHER_565_G(y +

                                   ((int)RIGHT_SHIFT(Cbgtab[cb] + Crgtab[cr],

                                                     SCALEBITS)), d0)];

      b = range_limit[DITHER_565_B(y + Cbbtab[cb], d0)];

      rgb = PACK_SHORT_565(r, g, b);

      *(INT16 *)outptr = (INT16)rgb;

      outptr += 2;

      num_cols--;

    }

    for (col = 0; col < (num_cols >> 1); col++) {

      y  = *inptr0++;

      cb = *inptr1++;

      cr = *inptr2++;

      r = range_limit[DITHER_565_R(y + Crrtab[cr], d0)];

      g = range_limit[DITHER_565_G(y +

                                   ((int)RIGHT_SHIFT(Cbgtab[cb] + Crgtab[cr],

                                                     SCALEBITS)), d0)];

      b = range_limit[DITHER_565_B(y + Cbbtab[cb], d0)];

      d0 = DITHER_ROTATE(d0);

      rgb = PACK_SHORT_565(r, g, b);

      y  = *inptr0++;

      cb = *inptr1++;

      cr = *inptr2++;

      r = range_limit[DITHER_565_R(y + Crrtab[cr], d0)];

      g = range_limit[DITHER_565_G(y +

                                   ((int)RIGHT_SHIFT(Cbgtab[cb] + Crgtab[cr],

                                                     SCALEBITS)), d0)];

      b = range_limit[DITHER_565_B(y + Cbbtab[cb], d0)];

      d0 = DITHER_ROTATE(d0);

      rgb = PACK_TWO_PIXELS(rgb, PACK_SHORT_565(r, g, b));

      WRITE_TWO_ALIGNED_PIXELS(outptr, rgb);

      outptr += 4;

    }

    if (num_cols & 1) {

      y  = *inptr0;

      cb = *inptr1;

      cr = *inptr2;

      r = range_limit[DITHER_565_R(y + Crrtab[cr], d0)];

      g = range_limit[DITHER_565_G(y +

                                   ((int)RIGHT_SHIFT(Cbgtab[cb] + Crgtab[cr],

                                                     SCALEBITS)), d0)];

      b = range_limit[DITHER_565_B(y + Cbbtab[cb], d0)];

      rgb = PACK_SHORT_565(r, g, b);

      *(INT16 *)outptr = (INT16)rgb;

    }

  }

#else

  ERREXIT(cinfo, JERR_CONVERSION_NOTIMPL);

#endif

}

Unexecuted instantiation: jdcolor-8.c:ycc_rgb565D_convert_be

jdcolor-8.c:ycc_rgb565D_convert_le

Line

Count

Source

106

7.09M

{

107

7.09M

#if BITS_IN_JSAMPLE != 16

108

7.09M

  my_cconvert_ptr cconvert = (my_cconvert_ptr)cinfo->cconvert;

109

7.09M

  register int y, cb, cr;

110

7.09M

  register _JSAMPROW outptr;

111

7.09M

  register _JSAMPROW inptr0, inptr1, inptr2;

112

7.09M

  register JDIMENSION col;

113

7.09M

  JDIMENSION num_cols = cinfo->output_width;

114

  /* copy these pointers into registers if possible */

115

7.09M

  register _JSAMPLE *range_limit = (_JSAMPLE *)cinfo->sample_range_limit;

116

7.09M

  register int *Crrtab = cconvert->Cr_r_tab;

117

7.09M

  register int *Cbbtab = cconvert->Cb_b_tab;

118

7.09M

  register JLONG *Crgtab = cconvert->Cr_g_tab;

119

7.09M

  register JLONG *Cbgtab = cconvert->Cb_g_tab;

120

7.09M

  JLONG d0 = dither_matrix[cinfo->output_scanline & DITHER_MASK];

121

7.09M

  SHIFT_TEMPS

122

123

14.1M

  while (--num_rows >= 0) {

124

7.09M

    JLONG rgb;

125

7.09M

    unsigned int r, g, b;

126

127

7.09M

    inptr0 = input_buf[0][input_row];

128

7.09M

    inptr1 = input_buf[1][input_row];

129

7.09M

    inptr2 = input_buf[2][input_row];

130

7.09M

    input_row++;

131

7.09M

    outptr = *output_buf++;

132

7.09M

    if (PACK_NEED_ALIGNMENT(outptr)) {

133

0

      y  = *inptr0++;

134

0

      cb = *inptr1++;

135

0

      cr = *inptr2++;

136

0

      r = range_limit[DITHER_565_R(y + Crrtab[cr], d0)];

137

0

      g = range_limit[DITHER_565_G(y +

138

0

                                   ((int)RIGHT_SHIFT(Cbgtab[cb] + Crgtab[cr],

139

0

                                                     SCALEBITS)), d0)];

140

0

      b = range_limit[DITHER_565_B(y + Cbbtab[cb], d0)];

141

0

      rgb = PACK_SHORT_565(r, g, b);

142

0

      *(INT16 *)outptr = (INT16)rgb;

143

0

      outptr += 2;

144

0

      num_cols--;

145

0

    }

146

112M

    for (col = 0; col < (num_cols >> 1); col++) {

147

105M

      y  = *inptr0++;

148

105M

      cb = *inptr1++;

149

105M

      cr = *inptr2++;

150

105M

      r = range_limit[DITHER_565_R(y + Crrtab[cr], d0)];

151

105M

      g = range_limit[DITHER_565_G(y +

152

105M

                                   ((int)RIGHT_SHIFT(Cbgtab[cb] + Crgtab[cr],

153

105M

                                                     SCALEBITS)), d0)];

154

105M

      b = range_limit[DITHER_565_B(y + Cbbtab[cb], d0)];

155

105M

      d0 = DITHER_ROTATE(d0);

156

105M

      rgb = PACK_SHORT_565(r, g, b);

157

158

105M

      y  = *inptr0++;

159

105M

      cb = *inptr1++;

160

105M

      cr = *inptr2++;

161

105M

      r = range_limit[DITHER_565_R(y + Crrtab[cr], d0)];

162

105M

      g = range_limit[DITHER_565_G(y +

163

105M

                                   ((int)RIGHT_SHIFT(Cbgtab[cb] + Crgtab[cr],

164

105M

                                                     SCALEBITS)), d0)];

165

105M

      b = range_limit[DITHER_565_B(y + Cbbtab[cb], d0)];

166

105M

      d0 = DITHER_ROTATE(d0);

167

105M

      rgb = PACK_TWO_PIXELS(rgb, PACK_SHORT_565(r, g, b));

168

169

105M

      WRITE_TWO_ALIGNED_PIXELS(outptr, rgb);

170

105M

      outptr += 4;

171

105M

    }

172

7.09M

    if (num_cols & 1) {

173

1.27M

      y  = *inptr0;

174

1.27M

      cb = *inptr1;

175

1.27M

      cr = *inptr2;

176

1.27M

      r = range_limit[DITHER_565_R(y + Crrtab[cr], d0)];

177

1.27M

      g = range_limit[DITHER_565_G(y +

178

1.27M

                                   ((int)RIGHT_SHIFT(Cbgtab[cb] + Crgtab[cr],

179

1.27M

                                                     SCALEBITS)), d0)];

180

1.27M

      b = range_limit[DITHER_565_B(y + Cbbtab[cb], d0)];

181

1.27M

      rgb = PACK_SHORT_565(r, g, b);

182

1.27M

      *(INT16 *)outptr = (INT16)rgb;

183

1.27M

    }

184

7.09M

  }

185

#else

186

  ERREXIT(cinfo, JERR_CONVERSION_NOTIMPL);

187

#endif

188

7.09M

}

Unexecuted instantiation: jdcolor-12.c:ycc_rgb565D_convert_be

Unexecuted instantiation: jdcolor-12.c:ycc_rgb565D_convert_le

Unexecuted instantiation: jdcolor-16.c:ycc_rgb565D_convert_be

Unexecuted instantiation: jdcolor-16.c:ycc_rgb565D_convert_le

INLINE

LOCAL(void)

rgb_rgb565_convert_internal(j_decompress_ptr cinfo, _JSAMPIMAGE input_buf,

                            JDIMENSION input_row, _JSAMPARRAY output_buf,

                            int num_rows)

{

  register _JSAMPROW outptr;

  register _JSAMPROW inptr0, inptr1, inptr2;

  register JDIMENSION col;

  JDIMENSION num_cols = cinfo->output_width;

  SHIFT_TEMPS

  while (--num_rows >= 0) {

    JLONG rgb;

    unsigned int r, g, b;

    inptr0 = input_buf[0][input_row];

    inptr1 = input_buf[1][input_row];

    inptr2 = input_buf[2][input_row];

    input_row++;

    outptr = *output_buf++;

    if (PACK_NEED_ALIGNMENT(outptr)) {

      r = *inptr0++;

      g = *inptr1++;

      b = *inptr2++;

      rgb = PACK_SHORT_565(r, g, b);

      *(INT16 *)outptr = (INT16)rgb;

      outptr += 2;

      num_cols--;

    }

    for (col = 0; col < (num_cols >> 1); col++) {

      r = *inptr0++;

      g = *inptr1++;

      b = *inptr2++;

      rgb = PACK_SHORT_565(r, g, b);

      r = *inptr0++;

      g = *inptr1++;

      b = *inptr2++;

      rgb = PACK_TWO_PIXELS(rgb, PACK_SHORT_565(r, g, b));

      WRITE_TWO_ALIGNED_PIXELS(outptr, rgb);

      outptr += 4;

    }

    if (num_cols & 1) {

      r = *inptr0;

      g = *inptr1;

      b = *inptr2;

      rgb = PACK_SHORT_565(r, g, b);

      *(INT16 *)outptr = (INT16)rgb;

    }

  }

}

Unexecuted instantiation: jdcolor-8.c:rgb_rgb565_convert_be

jdcolor-8.c:rgb_rgb565_convert_le

Line

Count

Source

196

340k

{

197

340k

  register _JSAMPROW outptr;

198

340k

  register _JSAMPROW inptr0, inptr1, inptr2;

199

340k

  register JDIMENSION col;

200

340k

  JDIMENSION num_cols = cinfo->output_width;

201

340k

  SHIFT_TEMPS

202

203

681k

  while (--num_rows >= 0) {

204

340k

    JLONG rgb;

205

340k

    unsigned int r, g, b;

206

207

340k

    inptr0 = input_buf[0][input_row];

208

340k

    inptr1 = input_buf[1][input_row];

209

340k

    inptr2 = input_buf[2][input_row];

210

340k

    input_row++;

211

340k

    outptr = *output_buf++;

212

340k

    if (PACK_NEED_ALIGNMENT(outptr)) {

213

0

      r = *inptr0++;

214

0

      g = *inptr1++;

215

0

      b = *inptr2++;

216

0

      rgb = PACK_SHORT_565(r, g, b);

217

0

      *(INT16 *)outptr = (INT16)rgb;

218

0

      outptr += 2;

219

0

      num_cols--;

220

0

    }

221

3.16M

    for (col = 0; col < (num_cols >> 1); col++) {

222

2.82M

      r = *inptr0++;

223

2.82M

      g = *inptr1++;

224

2.82M

      b = *inptr2++;

225

2.82M

      rgb = PACK_SHORT_565(r, g, b);

226

227

2.82M

      r = *inptr0++;

228

2.82M

      g = *inptr1++;

229

2.82M

      b = *inptr2++;

230

2.82M

      rgb = PACK_TWO_PIXELS(rgb, PACK_SHORT_565(r, g, b));

231

232

2.82M

      WRITE_TWO_ALIGNED_PIXELS(outptr, rgb);

233

2.82M

      outptr += 4;

234

2.82M

    }

235

340k

    if (num_cols & 1) {

236

9.31k

      r = *inptr0;

237

9.31k

      g = *inptr1;

238

9.31k

      b = *inptr2;

239

9.31k

      rgb = PACK_SHORT_565(r, g, b);

240

9.31k

      *(INT16 *)outptr = (INT16)rgb;

241

9.31k

    }

242

340k

  }

243

340k

}

Unexecuted instantiation: jdcolor-12.c:rgb_rgb565_convert_be

Unexecuted instantiation: jdcolor-12.c:rgb_rgb565_convert_le

Unexecuted instantiation: jdcolor-16.c:rgb_rgb565_convert_be

Unexecuted instantiation: jdcolor-16.c:rgb_rgb565_convert_le

INLINE

LOCAL(void)

rgb_rgb565D_convert_internal(j_decompress_ptr cinfo, _JSAMPIMAGE input_buf,

                             JDIMENSION input_row, _JSAMPARRAY output_buf,

                             int num_rows)

{

  register _JSAMPROW outptr;

  register _JSAMPROW inptr0, inptr1, inptr2;

  register JDIMENSION col;

  register _JSAMPLE *range_limit = (_JSAMPLE *)cinfo->sample_range_limit;

  JDIMENSION num_cols = cinfo->output_width;

  JLONG d0 = dither_matrix[cinfo->output_scanline & DITHER_MASK];

  SHIFT_TEMPS

  while (--num_rows >= 0) {

    JLONG rgb;

    unsigned int r, g, b;

    inptr0 = input_buf[0][input_row];

    inptr1 = input_buf[1][input_row];

    inptr2 = input_buf[2][input_row];

    input_row++;

    outptr = *output_buf++;

    if (PACK_NEED_ALIGNMENT(outptr)) {

      r = range_limit[DITHER_565_R(*inptr0++, d0)];

      g = range_limit[DITHER_565_G(*inptr1++, d0)];

      b = range_limit[DITHER_565_B(*inptr2++, d0)];

      rgb = PACK_SHORT_565(r, g, b);

      *(INT16 *)outptr = (INT16)rgb;

      outptr += 2;

      num_cols--;

    }

    for (col = 0; col < (num_cols >> 1); col++) {

      r = range_limit[DITHER_565_R(*inptr0++, d0)];

      g = range_limit[DITHER_565_G(*inptr1++, d0)];

      b = range_limit[DITHER_565_B(*inptr2++, d0)];

      d0 = DITHER_ROTATE(d0);

      rgb = PACK_SHORT_565(r, g, b);

      r = range_limit[DITHER_565_R(*inptr0++, d0)];

      g = range_limit[DITHER_565_G(*inptr1++, d0)];

      b = range_limit[DITHER_565_B(*inptr2++, d0)];

      d0 = DITHER_ROTATE(d0);

      rgb = PACK_TWO_PIXELS(rgb, PACK_SHORT_565(r, g, b));

      WRITE_TWO_ALIGNED_PIXELS(outptr, rgb);

      outptr += 4;

    }

    if (num_cols & 1) {

      r = range_limit[DITHER_565_R(*inptr0, d0)];

      g = range_limit[DITHER_565_G(*inptr1, d0)];

      b = range_limit[DITHER_565_B(*inptr2, d0)];

      rgb = PACK_SHORT_565(r, g, b);

      *(INT16 *)outptr = (INT16)rgb;

    }

  }

}

Unexecuted instantiation: jdcolor-8.c:rgb_rgb565D_convert_be

jdcolor-8.c:rgb_rgb565D_convert_le

Line

Count

Source

251

340k

{

252

340k

  register _JSAMPROW outptr;

253

340k

  register _JSAMPROW inptr0, inptr1, inptr2;

254

340k

  register JDIMENSION col;

255

340k

  register _JSAMPLE *range_limit = (_JSAMPLE *)cinfo->sample_range_limit;

256

340k

  JDIMENSION num_cols = cinfo->output_width;

257

340k

  JLONG d0 = dither_matrix[cinfo->output_scanline & DITHER_MASK];

258

340k

  SHIFT_TEMPS

259

260

681k

  while (--num_rows >= 0) {

261

340k

    JLONG rgb;

262

340k

    unsigned int r, g, b;

263

264

340k

    inptr0 = input_buf[0][input_row];

265

340k

    inptr1 = input_buf[1][input_row];

266

340k

    inptr2 = input_buf[2][input_row];

267

340k

    input_row++;

268

340k

    outptr = *output_buf++;

269

340k

    if (PACK_NEED_ALIGNMENT(outptr)) {

270

0

      r = range_limit[DITHER_565_R(*inptr0++, d0)];

271

0

      g = range_limit[DITHER_565_G(*inptr1++, d0)];

272

0

      b = range_limit[DITHER_565_B(*inptr2++, d0)];

273

0

      rgb = PACK_SHORT_565(r, g, b);

274

0

      *(INT16 *)outptr = (INT16)rgb;

275

0

      outptr += 2;

276

0

      num_cols--;

277

0

    }

278

3.15M

    for (col = 0; col < (num_cols >> 1); col++) {

279

2.81M

      r = range_limit[DITHER_565_R(*inptr0++, d0)];

280

2.81M

      g = range_limit[DITHER_565_G(*inptr1++, d0)];

281

2.81M

      b = range_limit[DITHER_565_B(*inptr2++, d0)];

282

2.81M

      d0 = DITHER_ROTATE(d0);

283

2.81M

      rgb = PACK_SHORT_565(r, g, b);

284

285

2.81M

      r = range_limit[DITHER_565_R(*inptr0++, d0)];

286

2.81M

      g = range_limit[DITHER_565_G(*inptr1++, d0)];

287

2.81M

      b = range_limit[DITHER_565_B(*inptr2++, d0)];

288

2.81M

      d0 = DITHER_ROTATE(d0);

289

2.81M

      rgb = PACK_TWO_PIXELS(rgb, PACK_SHORT_565(r, g, b));

290

291

2.81M

      WRITE_TWO_ALIGNED_PIXELS(outptr, rgb);

292

2.81M

      outptr += 4;

293

2.81M

    }

294

340k

    if (num_cols & 1) {

295

9.29k

      r = range_limit[DITHER_565_R(*inptr0, d0)];

296

9.29k

      g = range_limit[DITHER_565_G(*inptr1, d0)];

297

9.29k

      b = range_limit[DITHER_565_B(*inptr2, d0)];

298

9.29k

      rgb = PACK_SHORT_565(r, g, b);

299

9.29k

      *(INT16 *)outptr = (INT16)rgb;

300

9.29k

    }

301

340k

  }

302

340k

}

Unexecuted instantiation: jdcolor-12.c:rgb_rgb565D_convert_be

Unexecuted instantiation: jdcolor-12.c:rgb_rgb565D_convert_le

Unexecuted instantiation: jdcolor-16.c:rgb_rgb565D_convert_be

Unexecuted instantiation: jdcolor-16.c:rgb_rgb565D_convert_le

INLINE

LOCAL(void)

gray_rgb565_convert_internal(j_decompress_ptr cinfo, _JSAMPIMAGE input_buf,

                             JDIMENSION input_row, _JSAMPARRAY output_buf,

                             int num_rows)

{

  register _JSAMPROW inptr, outptr;

  register JDIMENSION col;

  JDIMENSION num_cols = cinfo->output_width;

  while (--num_rows >= 0) {

    JLONG rgb;

    unsigned int g;

    inptr = input_buf[0][input_row++];

    outptr = *output_buf++;

    if (PACK_NEED_ALIGNMENT(outptr)) {

      g = *inptr++;

      rgb = PACK_SHORT_565(g, g, g);

      *(INT16 *)outptr = (INT16)rgb;

      outptr += 2;

      num_cols--;

    }

    for (col = 0; col < (num_cols >> 1); col++) {

      g = *inptr++;

      rgb = PACK_SHORT_565(g, g, g);

      g = *inptr++;

      rgb = PACK_TWO_PIXELS(rgb, PACK_SHORT_565(g, g, g));

      WRITE_TWO_ALIGNED_PIXELS(outptr, rgb);

      outptr += 4;

    }

    if (num_cols & 1) {

      g = *inptr;

      rgb = PACK_SHORT_565(g, g, g);

      *(INT16 *)outptr = (INT16)rgb;

    }

  }

}

Unexecuted instantiation: jdcolor-8.c:gray_rgb565_convert_be

jdcolor-8.c:gray_rgb565_convert_le

Line

Count

Source

310

2.59M

{

311

2.59M

  register _JSAMPROW inptr, outptr;

312

2.59M

  register JDIMENSION col;

313

2.59M

  JDIMENSION num_cols = cinfo->output_width;

314

315

5.18M

  while (--num_rows >= 0) {

316

2.59M

    JLONG rgb;

317

2.59M

    unsigned int g;

318

319

2.59M

    inptr = input_buf[0][input_row++];

320

2.59M

    outptr = *output_buf++;

321

2.59M

    if (PACK_NEED_ALIGNMENT(outptr)) {

322

0

      g = *inptr++;

323

0

      rgb = PACK_SHORT_565(g, g, g);

324

0

      *(INT16 *)outptr = (INT16)rgb;

325

0

      outptr += 2;

326

0

      num_cols--;

327

0

    }

328

78.2M

    for (col = 0; col < (num_cols >> 1); col++) {

329

75.6M

      g = *inptr++;

330

75.6M

      rgb = PACK_SHORT_565(g, g, g);

331

75.6M

      g = *inptr++;

332

75.6M

      rgb = PACK_TWO_PIXELS(rgb, PACK_SHORT_565(g, g, g));

333

75.6M

      WRITE_TWO_ALIGNED_PIXELS(outptr, rgb);

334

75.6M

      outptr += 4;

335

75.6M

    }

336

2.59M

    if (num_cols & 1) {

337

1.18M

      g = *inptr;

338

1.18M

      rgb = PACK_SHORT_565(g, g, g);

339

1.18M

      *(INT16 *)outptr = (INT16)rgb;

340

1.18M

    }

341

2.59M

  }

342

2.59M

}

Unexecuted instantiation: jdcolor-12.c:gray_rgb565_convert_be

Unexecuted instantiation: jdcolor-12.c:gray_rgb565_convert_le

Unexecuted instantiation: jdcolor-16.c:gray_rgb565_convert_be

Unexecuted instantiation: jdcolor-16.c:gray_rgb565_convert_le

INLINE

LOCAL(void)

gray_rgb565D_convert_internal(j_decompress_ptr cinfo, _JSAMPIMAGE input_buf,

                              JDIMENSION input_row, _JSAMPARRAY output_buf,

                              int num_rows)

{

  register _JSAMPROW inptr, outptr;

  register JDIMENSION col;

  register _JSAMPLE *range_limit = (_JSAMPLE *)cinfo->sample_range_limit;

  JDIMENSION num_cols = cinfo->output_width;

  JLONG d0 = dither_matrix[cinfo->output_scanline & DITHER_MASK];

  while (--num_rows >= 0) {

    JLONG rgb;

    unsigned int g;

    inptr = input_buf[0][input_row++];

    outptr = *output_buf++;

    if (PACK_NEED_ALIGNMENT(outptr)) {

      g = *inptr++;

      g = range_limit[DITHER_565_R(g, d0)];

      rgb = PACK_SHORT_565(g, g, g);

      *(INT16 *)outptr = (INT16)rgb;

      outptr += 2;

      num_cols--;

    }

    for (col = 0; col < (num_cols >> 1); col++) {

      g = *inptr++;

      g = range_limit[DITHER_565_R(g, d0)];

      rgb = PACK_SHORT_565(g, g, g);

      d0 = DITHER_ROTATE(d0);

      g = *inptr++;

      g = range_limit[DITHER_565_R(g, d0)];

      rgb = PACK_TWO_PIXELS(rgb, PACK_SHORT_565(g, g, g));

      d0 = DITHER_ROTATE(d0);

      WRITE_TWO_ALIGNED_PIXELS(outptr, rgb);

      outptr += 4;

    }

    if (num_cols & 1) {

      g = *inptr;

      g = range_limit[DITHER_565_R(g, d0)];

      rgb = PACK_SHORT_565(g, g, g);

      *(INT16 *)outptr = (INT16)rgb;

    }

  }

}

Unexecuted instantiation: jdcolor-8.c:gray_rgb565D_convert_be

jdcolor-8.c:gray_rgb565D_convert_le

Line

Count

Source

350

1.93M

{

351

1.93M

  register _JSAMPROW inptr, outptr;

352

1.93M

  register JDIMENSION col;

353

1.93M

  register _JSAMPLE *range_limit = (_JSAMPLE *)cinfo->sample_range_limit;

354

1.93M

  JDIMENSION num_cols = cinfo->output_width;

355

1.93M

  JLONG d0 = dither_matrix[cinfo->output_scanline & DITHER_MASK];

356

357

3.86M

  while (--num_rows >= 0) {

358

1.93M

    JLONG rgb;

359

1.93M

    unsigned int g;

360

361

1.93M

    inptr = input_buf[0][input_row++];

362

1.93M

    outptr = *output_buf++;

363

1.93M

    if (PACK_NEED_ALIGNMENT(outptr)) {

364

0

      g = *inptr++;

365

0

      g = range_limit[DITHER_565_R(g, d0)];

366

0

      rgb = PACK_SHORT_565(g, g, g);

367

0

      *(INT16 *)outptr = (INT16)rgb;

368

0

      outptr += 2;

369

0

      num_cols--;

370

0

    }

371

63.7M

    for (col = 0; col < (num_cols >> 1); col++) {

372

61.8M

      g = *inptr++;

373

61.8M

      g = range_limit[DITHER_565_R(g, d0)];

374

61.8M

      rgb = PACK_SHORT_565(g, g, g);

375

61.8M

      d0 = DITHER_ROTATE(d0);

376

377

61.8M

      g = *inptr++;

378

61.8M

      g = range_limit[DITHER_565_R(g, d0)];

379

61.8M

      rgb = PACK_TWO_PIXELS(rgb, PACK_SHORT_565(g, g, g));

380

61.8M

      d0 = DITHER_ROTATE(d0);

381

382

61.8M

      WRITE_TWO_ALIGNED_PIXELS(outptr, rgb);

383

61.8M

      outptr += 4;

384

61.8M

    }

385

1.93M

    if (num_cols & 1) {

386

1.00M

      g = *inptr;

387

1.00M

      g = range_limit[DITHER_565_R(g, d0)];

388

1.00M

      rgb = PACK_SHORT_565(g, g, g);

389

1.00M

      *(INT16 *)outptr = (INT16)rgb;

390

1.00M

    }

391

1.93M

  }

392

1.93M

}

Unexecuted instantiation: jdcolor-12.c:gray_rgb565D_convert_be

Unexecuted instantiation: jdcolor-12.c:gray_rgb565D_convert_le

Unexecuted instantiation: jdcolor-16.c:gray_rgb565D_convert_be

Unexecuted instantiation: jdcolor-16.c:gray_rgb565D_convert_le