/*

 * 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

35.0M

{

24

35.0M

#if BITS_IN_JSAMPLE != 16

25

35.0M

  my_cconvert_ptr cconvert = (my_cconvert_ptr)cinfo->cconvert;

26

35.0M

  register int y, cb, cr;

27

35.0M

  register _JSAMPROW outptr;

28

35.0M

  register _JSAMPROW inptr0, inptr1, inptr2;

29

35.0M

  register JDIMENSION col;

30

35.0M

  JDIMENSION num_cols = cinfo->output_width;

31

  /* copy these pointers into registers if possible */

32

35.0M

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

33

35.0M

  register int *Crrtab = cconvert->Cr_r_tab;

34

35.0M

  register int *Cbbtab = cconvert->Cb_b_tab;

35

35.0M

  register JLONG *Crgtab = cconvert->Cr_g_tab;

36

35.0M

  register JLONG *Cbgtab = cconvert->Cb_g_tab;

37

35.0M

  SHIFT_TEMPS

38

39

70.0M

  while (--num_rows >= 0) {

40

35.0M

    JLONG rgb;

41

35.0M

    unsigned int r, g, b;

42

35.0M

    inptr0 = input_buf[0][input_row];

43

35.0M

    inptr1 = input_buf[1][input_row];

44

35.0M

    inptr2 = input_buf[2][input_row];

45

35.0M

    input_row++;

46

35.0M

    outptr = *output_buf++;

47

48

35.0M

    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

649M

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

62

614M

      y  = *inptr0++;

63

614M

      cb = *inptr1++;

64

614M

      cr = *inptr2++;

65

614M

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

66

614M

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

67

614M

                                            SCALEBITS))];

68

614M

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

69

614M

      rgb = PACK_SHORT_565(r, g, b);

70

71

614M

      y  = *inptr0++;

72

614M

      cb = *inptr1++;

73

614M

      cr = *inptr2++;

74

614M

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

75

614M

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

76

614M

                                            SCALEBITS))];

77

614M

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

78

614M

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

79

80

614M

      WRITE_TWO_ALIGNED_PIXELS(outptr, rgb);

81

614M

      outptr += 4;

82

614M

    }

83

35.0M

    if (num_cols & 1) {

84

4.35M

      y  = *inptr0;

85

4.35M

      cb = *inptr1;

86

4.35M

      cr = *inptr2;

87

4.35M

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

88

4.35M

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

89

4.35M

                                            SCALEBITS))];

90

4.35M

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

91

4.35M

      rgb = PACK_SHORT_565(r, g, b);

92

4.35M

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

93

4.35M

    }

94

35.0M

  }

95

#else

96

  ERREXIT(cinfo, JERR_CONVERSION_NOTIMPL);

97

#endif

98

35.0M

}

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

27.5M

{

107

27.5M

#if BITS_IN_JSAMPLE != 16

108

27.5M

  my_cconvert_ptr cconvert = (my_cconvert_ptr)cinfo->cconvert;

109

27.5M

  register int y, cb, cr;

110

27.5M

  register _JSAMPROW outptr;

111

27.5M

  register _JSAMPROW inptr0, inptr1, inptr2;

112

27.5M

  register JDIMENSION col;

113

27.5M

  JDIMENSION num_cols = cinfo->output_width;

114

  /* copy these pointers into registers if possible */

115

27.5M

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

116

27.5M

  register int *Crrtab = cconvert->Cr_r_tab;

117

27.5M

  register int *Cbbtab = cconvert->Cb_b_tab;

118

27.5M

  register JLONG *Crgtab = cconvert->Cr_g_tab;

119

27.5M

  register JLONG *Cbgtab = cconvert->Cb_g_tab;

120

27.5M

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

121

27.5M

  SHIFT_TEMPS

122

123

55.0M

  while (--num_rows >= 0) {

124

27.5M

    JLONG rgb;

125

27.5M

    unsigned int r, g, b;

126

127

27.5M

    inptr0 = input_buf[0][input_row];

128

27.5M

    inptr1 = input_buf[1][input_row];

129

27.5M

    inptr2 = input_buf[2][input_row];

130

27.5M

    input_row++;

131

27.5M

    outptr = *output_buf++;

132

27.5M

    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

357M

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

147

330M

      y  = *inptr0++;

148

330M

      cb = *inptr1++;

149

330M

      cr = *inptr2++;

150

330M

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

151

330M

      g = range_limit[DITHER_565_G(y +

152

330M

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

153

330M

                                                     SCALEBITS)), d0)];

154

330M

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

155

330M

      d0 = DITHER_ROTATE(d0);

156

330M

      rgb = PACK_SHORT_565(r, g, b);

157

158

330M

      y  = *inptr0++;

159

330M

      cb = *inptr1++;

160

330M

      cr = *inptr2++;

161

330M

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

162

330M

      g = range_limit[DITHER_565_G(y +

163

330M

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

164

330M

                                                     SCALEBITS)), d0)];

165

330M

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

166

330M

      d0 = DITHER_ROTATE(d0);

167

330M

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

168

169

330M

      WRITE_TWO_ALIGNED_PIXELS(outptr, rgb);

170

330M

      outptr += 4;

171

330M

    }

172

27.5M

    if (num_cols & 1) {

173

3.13M

      y  = *inptr0;

174

3.13M

      cb = *inptr1;

175

3.13M

      cr = *inptr2;

176

3.13M

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

177

3.13M

      g = range_limit[DITHER_565_G(y +

178

3.13M

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

179

3.13M

                                                     SCALEBITS)), d0)];

180

3.13M

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

181

3.13M

      rgb = PACK_SHORT_565(r, g, b);

182

3.13M

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

183

3.13M

    }

184

27.5M

  }

185

#else

186

  ERREXIT(cinfo, JERR_CONVERSION_NOTIMPL);

187

#endif

188

27.5M

}

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

3.47M

{

197

3.47M

  register _JSAMPROW outptr;

198

3.47M

  register _JSAMPROW inptr0, inptr1, inptr2;

199

3.47M

  register JDIMENSION col;

200

3.47M

  JDIMENSION num_cols = cinfo->output_width;

201

3.47M

  SHIFT_TEMPS

202

203

6.94M

  while (--num_rows >= 0) {

204

3.47M

    JLONG rgb;

205

3.47M

    unsigned int r, g, b;

206

207

3.47M

    inptr0 = input_buf[0][input_row];

208

3.47M

    inptr1 = input_buf[1][input_row];

209

3.47M

    inptr2 = input_buf[2][input_row];

210

3.47M

    input_row++;

211

3.47M

    outptr = *output_buf++;

212

3.47M

    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

15.3M

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

222

11.8M

      r = *inptr0++;

223

11.8M

      g = *inptr1++;

224

11.8M

      b = *inptr2++;

225

11.8M

      rgb = PACK_SHORT_565(r, g, b);

226

227

11.8M

      r = *inptr0++;

228

11.8M

      g = *inptr1++;

229

11.8M

      b = *inptr2++;

230

11.8M

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

231

232

11.8M

      WRITE_TWO_ALIGNED_PIXELS(outptr, rgb);

233

11.8M

      outptr += 4;

234

11.8M

    }

235

3.47M

    if (num_cols & 1) {

236

2.94M

      r = *inptr0;

237

2.94M

      g = *inptr1;

238

2.94M

      b = *inptr2;

239

2.94M

      rgb = PACK_SHORT_565(r, g, b);

240

2.94M

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

241

2.94M

    }

242

3.47M

  }

243

3.47M

}

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

3.40M

{

252

3.40M

  register _JSAMPROW outptr;

253

3.40M

  register _JSAMPROW inptr0, inptr1, inptr2;

254

3.40M

  register JDIMENSION col;

255

3.40M

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

256

3.40M

  JDIMENSION num_cols = cinfo->output_width;

257

3.40M

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

258

3.40M

  SHIFT_TEMPS

259

260

6.81M

  while (--num_rows >= 0) {

261

3.40M

    JLONG rgb;

262

3.40M

    unsigned int r, g, b;

263

264

3.40M

    inptr0 = input_buf[0][input_row];

265

3.40M

    inptr1 = input_buf[1][input_row];

266

3.40M

    inptr2 = input_buf[2][input_row];

267

3.40M

    input_row++;

268

3.40M

    outptr = *output_buf++;

269

3.40M

    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

14.7M

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

279

11.3M

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

280

11.3M

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

281

11.3M

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

282

11.3M

      d0 = DITHER_ROTATE(d0);

283

11.3M

      rgb = PACK_SHORT_565(r, g, b);

284

285

11.3M

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

286

11.3M

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

287

11.3M

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

288

11.3M

      d0 = DITHER_ROTATE(d0);

289

11.3M

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

290

291

11.3M

      WRITE_TWO_ALIGNED_PIXELS(outptr, rgb);

292

11.3M

      outptr += 4;

293

11.3M

    }

294

3.40M

    if (num_cols & 1) {

295

2.87M

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

296

2.87M

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

297

2.87M

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

298

2.87M

      rgb = PACK_SHORT_565(r, g, b);

299

2.87M

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

300

2.87M

    }

301

3.40M

  }

302

3.40M

}

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

12.8M

{

311

12.8M

  register _JSAMPROW inptr, outptr;

312

12.8M

  register JDIMENSION col;

313

12.8M

  JDIMENSION num_cols = cinfo->output_width;

314

315

25.7M

  while (--num_rows >= 0) {

316

12.8M

    JLONG rgb;

317

12.8M

    unsigned int g;

318

319

12.8M

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

320

12.8M

    outptr = *output_buf++;

321

12.8M

    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

263M

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

329

251M

      g = *inptr++;

330

251M

      rgb = PACK_SHORT_565(g, g, g);

331

251M

      g = *inptr++;

332

251M

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

333

251M

      WRITE_TWO_ALIGNED_PIXELS(outptr, rgb);

334

251M

      outptr += 4;

335

251M

    }

336

12.8M

    if (num_cols & 1) {

337

7.02M

      g = *inptr;

338

7.02M

      rgb = PACK_SHORT_565(g, g, g);

339

7.02M

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

340

7.02M

    }

341

12.8M

  }

342

12.8M

}

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

6.73M

{

351

6.73M

  register _JSAMPROW inptr, outptr;

352

6.73M

  register JDIMENSION col;

353

6.73M

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

354

6.73M

  JDIMENSION num_cols = cinfo->output_width;

355

6.73M

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

356

357

13.4M

  while (--num_rows >= 0) {

358

6.73M

    JLONG rgb;

359

6.73M

    unsigned int g;

360

361

6.73M

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

362

6.73M

    outptr = *output_buf++;

363

6.73M

    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

167M

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

372

160M

      g = *inptr++;

373

160M

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

374

160M

      rgb = PACK_SHORT_565(g, g, g);

375

160M

      d0 = DITHER_ROTATE(d0);

376

377

160M

      g = *inptr++;

378

160M

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

379

160M

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

380

160M

      d0 = DITHER_ROTATE(d0);

381

382

160M

      WRITE_TWO_ALIGNED_PIXELS(outptr, rgb);

383

160M

      outptr += 4;

384

160M

    }

385

6.73M

    if (num_cols & 1) {

386

3.61M

      g = *inptr;

387

3.61M

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

388

3.61M

      rgb = PACK_SHORT_565(g, g, g);

389

3.61M

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

390

3.61M

    }

391

6.73M

  }

392

6.73M

}

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