/*

 * 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

34.6M

{

24

34.6M

#if BITS_IN_JSAMPLE != 16

25

34.6M

  my_cconvert_ptr cconvert = (my_cconvert_ptr)cinfo->cconvert;

26

34.6M

  register int y, cb, cr;

27

34.6M

  register _JSAMPROW outptr;

28

34.6M

  register _JSAMPROW inptr0, inptr1, inptr2;

29

34.6M

  register JDIMENSION col;

30

34.6M

  JDIMENSION num_cols = cinfo->output_width;

31

  /* copy these pointers into registers if possible */

32

34.6M

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

33

34.6M

  register int *Crrtab = cconvert->Cr_r_tab;

34

34.6M

  register int *Cbbtab = cconvert->Cb_b_tab;

35

34.6M

  register JLONG *Crgtab = cconvert->Cr_g_tab;

36

34.6M

  register JLONG *Cbgtab = cconvert->Cb_g_tab;

37

34.6M

  SHIFT_TEMPS

38

39

69.2M

  while (--num_rows >= 0) {

40

34.6M

    JLONG rgb;

41

34.6M

    unsigned int r, g, b;

42

34.6M

    inptr0 = input_buf[0][input_row];

43

34.6M

    inptr1 = input_buf[1][input_row];

44

34.6M

    inptr2 = input_buf[2][input_row];

45

34.6M

    input_row++;

46

34.6M

    outptr = *output_buf++;

47

48

34.6M

    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

449M

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

62

414M

      y  = *inptr0++;

63

414M

      cb = *inptr1++;

64

414M

      cr = *inptr2++;

65

414M

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

66

414M

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

67

414M

                                            SCALEBITS))];

68

414M

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

69

414M

      rgb = PACK_SHORT_565(r, g, b);

70

71

414M

      y  = *inptr0++;

72

414M

      cb = *inptr1++;

73

414M

      cr = *inptr2++;

74

414M

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

75

414M

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

76

414M

                                            SCALEBITS))];

77

414M

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

78

414M

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

79

80

414M

      WRITE_TWO_ALIGNED_PIXELS(outptr, rgb);

81

414M

      outptr += 4;

82

414M

    }

83

34.6M

    if (num_cols & 1) {

84

3.50M

      y  = *inptr0;

85

3.50M

      cb = *inptr1;

86

3.50M

      cr = *inptr2;

87

3.50M

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

88

3.50M

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

89

3.50M

                                            SCALEBITS))];

90

3.50M

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

91

3.50M

      rgb = PACK_SHORT_565(r, g, b);

92

3.50M

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

93

3.50M

    }

94

34.6M

  }

95

#else

96

  ERREXIT(cinfo, JERR_CONVERSION_NOTIMPL);

97

#endif

98

34.6M

}

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

24.8M

{

107

24.8M

#if BITS_IN_JSAMPLE != 16

108

24.8M

  my_cconvert_ptr cconvert = (my_cconvert_ptr)cinfo->cconvert;

109

24.8M

  register int y, cb, cr;

110

24.8M

  register _JSAMPROW outptr;

111

24.8M

  register _JSAMPROW inptr0, inptr1, inptr2;

112

24.8M

  register JDIMENSION col;

113

24.8M

  JDIMENSION num_cols = cinfo->output_width;

114

  /* copy these pointers into registers if possible */

115

24.8M

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

116

24.8M

  register int *Crrtab = cconvert->Cr_r_tab;

117

24.8M

  register int *Cbbtab = cconvert->Cb_b_tab;

118

24.8M

  register JLONG *Crgtab = cconvert->Cr_g_tab;

119

24.8M

  register JLONG *Cbgtab = cconvert->Cb_g_tab;

120

24.8M

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

121

24.8M

  SHIFT_TEMPS

122

123

49.7M

  while (--num_rows >= 0) {

124

24.8M

    JLONG rgb;

125

24.8M

    unsigned int r, g, b;

126

127

24.8M

    inptr0 = input_buf[0][input_row];

128

24.8M

    inptr1 = input_buf[1][input_row];

129

24.8M

    inptr2 = input_buf[2][input_row];

130

24.8M

    input_row++;

131

24.8M

    outptr = *output_buf++;

132

24.8M

    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

304M

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

147

279M

      y  = *inptr0++;

148

279M

      cb = *inptr1++;

149

279M

      cr = *inptr2++;

150

279M

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

151

279M

      g = range_limit[DITHER_565_G(y +

152

279M

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

153

279M

                                                     SCALEBITS)), d0)];

154

279M

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

155

279M

      d0 = DITHER_ROTATE(d0);

156

279M

      rgb = PACK_SHORT_565(r, g, b);

157

158

279M

      y  = *inptr0++;

159

279M

      cb = *inptr1++;

160

279M

      cr = *inptr2++;

161

279M

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

162

279M

      g = range_limit[DITHER_565_G(y +

163

279M

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

164

279M

                                                     SCALEBITS)), d0)];

165

279M

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

166

279M

      d0 = DITHER_ROTATE(d0);

167

279M

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

168

169

279M

      WRITE_TWO_ALIGNED_PIXELS(outptr, rgb);

170

279M

      outptr += 4;

171

279M

    }

172

24.8M

    if (num_cols & 1) {

173

2.38M

      y  = *inptr0;

174

2.38M

      cb = *inptr1;

175

2.38M

      cr = *inptr2;

176

2.38M

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

177

2.38M

      g = range_limit[DITHER_565_G(y +

178

2.38M

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

179

2.38M

                                                     SCALEBITS)), d0)];

180

2.38M

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

181

2.38M

      rgb = PACK_SHORT_565(r, g, b);

182

2.38M

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

183

2.38M

    }

184

24.8M

  }

185

#else

186

  ERREXIT(cinfo, JERR_CONVERSION_NOTIMPL);

187

#endif

188

24.8M

}

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

908k

{

197

908k

  register _JSAMPROW outptr;

198

908k

  register _JSAMPROW inptr0, inptr1, inptr2;

199

908k

  register JDIMENSION col;

200

908k

  JDIMENSION num_cols = cinfo->output_width;

201

908k

  SHIFT_TEMPS

202

203

1.81M

  while (--num_rows >= 0) {

204

908k

    JLONG rgb;

205

908k

    unsigned int r, g, b;

206

207

908k

    inptr0 = input_buf[0][input_row];

208

908k

    inptr1 = input_buf[1][input_row];

209

908k

    inptr2 = input_buf[2][input_row];

210

908k

    input_row++;

211

908k

    outptr = *output_buf++;

212

908k

    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

16.7M

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

222

15.8M

      r = *inptr0++;

223

15.8M

      g = *inptr1++;

224

15.8M

      b = *inptr2++;

225

15.8M

      rgb = PACK_SHORT_565(r, g, b);

226

227

15.8M

      r = *inptr0++;

228

15.8M

      g = *inptr1++;

229

15.8M

      b = *inptr2++;

230

15.8M

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

231

232

15.8M

      WRITE_TWO_ALIGNED_PIXELS(outptr, rgb);

233

15.8M

      outptr += 4;

234

15.8M

    }

235

908k

    if (num_cols & 1) {

236

101k

      r = *inptr0;

237

101k

      g = *inptr1;

238

101k

      b = *inptr2;

239

101k

      rgb = PACK_SHORT_565(r, g, b);

240

101k

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

241

101k

    }

242

908k

  }

243

908k

}

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

724k

{

252

724k

  register _JSAMPROW outptr;

253

724k

  register _JSAMPROW inptr0, inptr1, inptr2;

254

724k

  register JDIMENSION col;

255

724k

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

256

724k

  JDIMENSION num_cols = cinfo->output_width;

257

724k

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

258

724k

  SHIFT_TEMPS

259

260

1.44M

  while (--num_rows >= 0) {

261

724k

    JLONG rgb;

262

724k

    unsigned int r, g, b;

263

264

724k

    inptr0 = input_buf[0][input_row];

265

724k

    inptr1 = input_buf[1][input_row];

266

724k

    inptr2 = input_buf[2][input_row];

267

724k

    input_row++;

268

724k

    outptr = *output_buf++;

269

724k

    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

13.5M

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

279

12.8M

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

280

12.8M

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

281

12.8M

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

282

12.8M

      d0 = DITHER_ROTATE(d0);

283

12.8M

      rgb = PACK_SHORT_565(r, g, b);

284

285

12.8M

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

286

12.8M

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

287

12.8M

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

288

12.8M

      d0 = DITHER_ROTATE(d0);

289

12.8M

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

290

291

12.8M

      WRITE_TWO_ALIGNED_PIXELS(outptr, rgb);

292

12.8M

      outptr += 4;

293

12.8M

    }

294

724k

    if (num_cols & 1) {

295

78.3k

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

296

78.3k

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

297

78.3k

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

298

78.3k

      rgb = PACK_SHORT_565(r, g, b);

299

78.3k

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

300

78.3k

    }

301

724k

  }

302

724k

}

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

15.2M

{

311

15.2M

  register _JSAMPROW inptr, outptr;

312

15.2M

  register JDIMENSION col;

313

15.2M

  JDIMENSION num_cols = cinfo->output_width;

314

315

30.5M

  while (--num_rows >= 0) {

316

15.2M

    JLONG rgb;

317

15.2M

    unsigned int g;

318

319

15.2M

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

320

15.2M

    outptr = *output_buf++;

321

15.2M

    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

239M

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

329

224M

      g = *inptr++;

330

224M

      rgb = PACK_SHORT_565(g, g, g);

331

224M

      g = *inptr++;

332

224M

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

333

224M

      WRITE_TWO_ALIGNED_PIXELS(outptr, rgb);

334

224M

      outptr += 4;

335

224M

    }

336

15.2M

    if (num_cols & 1) {

337

12.3M

      g = *inptr;

338

12.3M

      rgb = PACK_SHORT_565(g, g, g);

339

12.3M

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

340

12.3M

    }

341

15.2M

  }

342

15.2M

}

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

10.1M

{

351

10.1M

  register _JSAMPROW inptr, outptr;

352

10.1M

  register JDIMENSION col;

353

10.1M

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

354

10.1M

  JDIMENSION num_cols = cinfo->output_width;

355

10.1M

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

356

357

20.3M

  while (--num_rows >= 0) {

358

10.1M

    JLONG rgb;

359

10.1M

    unsigned int g;

360

361

10.1M

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

362

10.1M

    outptr = *output_buf++;

363

10.1M

    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

153M

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

372

143M

      g = *inptr++;

373

143M

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

374

143M

      rgb = PACK_SHORT_565(g, g, g);

375

143M

      d0 = DITHER_ROTATE(d0);

376

377

143M

      g = *inptr++;

378

143M

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

379

143M

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

380

143M

      d0 = DITHER_ROTATE(d0);

381

382

143M

      WRITE_TWO_ALIGNED_PIXELS(outptr, rgb);

383

143M

      outptr += 4;

384

143M

    }

385

10.1M

    if (num_cols & 1) {

386

8.44M

      g = *inptr;

387

8.44M

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

388

8.44M

      rgb = PACK_SHORT_565(g, g, g);

389

8.44M

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

390

8.44M

    }

391

10.1M

  }

392

10.1M

}

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