/*

 * 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

27.0M

{

24

27.0M

#if BITS_IN_JSAMPLE != 16

25

27.0M

  my_cconvert_ptr cconvert = (my_cconvert_ptr)cinfo->cconvert;

26

27.0M

  register int y, cb, cr;

27

27.0M

  register _JSAMPROW outptr;

28

27.0M

  register _JSAMPROW inptr0, inptr1, inptr2;

29

27.0M

  register JDIMENSION col;

30

27.0M

  JDIMENSION num_cols = cinfo->output_width;

31

  /* copy these pointers into registers if possible */

32

27.0M

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

33

27.0M

  register int *Crrtab = cconvert->Cr_r_tab;

34

27.0M

  register int *Cbbtab = cconvert->Cb_b_tab;

35

27.0M

  register JLONG *Crgtab = cconvert->Cr_g_tab;

36

27.0M

  register JLONG *Cbgtab = cconvert->Cb_g_tab;

37

27.0M

  SHIFT_TEMPS

38

39

54.1M

  while (--num_rows >= 0) {

40

27.0M

    JLONG rgb;

41

27.0M

    unsigned int r, g, b;

42

27.0M

    inptr0 = input_buf[0][input_row];

43

27.0M

    inptr1 = input_buf[1][input_row];

44

27.0M

    inptr2 = input_buf[2][input_row];

45

27.0M

    input_row++;

46

27.0M

    outptr = *output_buf++;

47

48

27.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

408M

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

62

381M

      y  = *inptr0++;

63

381M

      cb = *inptr1++;

64

381M

      cr = *inptr2++;

65

381M

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

66

381M

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

67

381M

                                            SCALEBITS))];

68

381M

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

69

381M

      rgb = PACK_SHORT_565(r, g, b);

70

71

381M

      y  = *inptr0++;

72

381M

      cb = *inptr1++;

73

381M

      cr = *inptr2++;

74

381M

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

75

381M

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

76

381M

                                            SCALEBITS))];

77

381M

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

78

381M

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

79

80

381M

      WRITE_TWO_ALIGNED_PIXELS(outptr, rgb);

81

381M

      outptr += 4;

82

381M

    }

83

27.0M

    if (num_cols & 1) {

84

2.66M

      y  = *inptr0;

85

2.66M

      cb = *inptr1;

86

2.66M

      cr = *inptr2;

87

2.66M

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

88

2.66M

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

89

2.66M

                                            SCALEBITS))];

90

2.66M

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

91

2.66M

      rgb = PACK_SHORT_565(r, g, b);

92

2.66M

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

93

2.66M

    }

94

27.0M

  }

95

#else

96

  ERREXIT(cinfo, JERR_CONVERSION_NOTIMPL);

97

#endif

98

27.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

20.3M

{

107

20.3M

#if BITS_IN_JSAMPLE != 16

108

20.3M

  my_cconvert_ptr cconvert = (my_cconvert_ptr)cinfo->cconvert;

109

20.3M

  register int y, cb, cr;

110

20.3M

  register _JSAMPROW outptr;

111

20.3M

  register _JSAMPROW inptr0, inptr1, inptr2;

112

20.3M

  register JDIMENSION col;

113

20.3M

  JDIMENSION num_cols = cinfo->output_width;

114

  /* copy these pointers into registers if possible */

115

20.3M

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

116

20.3M

  register int *Crrtab = cconvert->Cr_r_tab;

117

20.3M

  register int *Cbbtab = cconvert->Cb_b_tab;

118

20.3M

  register JLONG *Crgtab = cconvert->Cr_g_tab;

119

20.3M

  register JLONG *Cbgtab = cconvert->Cb_g_tab;

120

20.3M

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

121

20.3M

  SHIFT_TEMPS

122

123

40.6M

  while (--num_rows >= 0) {

124

20.3M

    JLONG rgb;

125

20.3M

    unsigned int r, g, b;

126

127

20.3M

    inptr0 = input_buf[0][input_row];

128

20.3M

    inptr1 = input_buf[1][input_row];

129

20.3M

    inptr2 = input_buf[2][input_row];

130

20.3M

    input_row++;

131

20.3M

    outptr = *output_buf++;

132

20.3M

    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

206M

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

147

186M

      y  = *inptr0++;

148

186M

      cb = *inptr1++;

149

186M

      cr = *inptr2++;

150

186M

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

151

186M

      g = range_limit[DITHER_565_G(y +

152

186M

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

153

186M

                                                     SCALEBITS)), d0)];

154

186M

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

155

186M

      d0 = DITHER_ROTATE(d0);

156

186M

      rgb = PACK_SHORT_565(r, g, b);

157

158

186M

      y  = *inptr0++;

159

186M

      cb = *inptr1++;

160

186M

      cr = *inptr2++;

161

186M

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

162

186M

      g = range_limit[DITHER_565_G(y +

163

186M

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

164

186M

                                                     SCALEBITS)), d0)];

165

186M

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

166

186M

      d0 = DITHER_ROTATE(d0);

167

186M

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

168

169

186M

      WRITE_TWO_ALIGNED_PIXELS(outptr, rgb);

170

186M

      outptr += 4;

171

186M

    }

172

20.3M

    if (num_cols & 1) {

173

2.08M

      y  = *inptr0;

174

2.08M

      cb = *inptr1;

175

2.08M

      cr = *inptr2;

176

2.08M

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

177

2.08M

      g = range_limit[DITHER_565_G(y +

178

2.08M

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

179

2.08M

                                                     SCALEBITS)), d0)];

180

2.08M

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

181

2.08M

      rgb = PACK_SHORT_565(r, g, b);

182

2.08M

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

183

2.08M

    }

184

20.3M

  }

185

#else

186

  ERREXIT(cinfo, JERR_CONVERSION_NOTIMPL);

187

#endif

188

20.3M

}

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

291k

{

197

291k

  register _JSAMPROW outptr;

198

291k

  register _JSAMPROW inptr0, inptr1, inptr2;

199

291k

  register JDIMENSION col;

200

291k

  JDIMENSION num_cols = cinfo->output_width;

201

291k

  SHIFT_TEMPS

202

203

582k

  while (--num_rows >= 0) {

204

291k

    JLONG rgb;

205

291k

    unsigned int r, g, b;

206

207

291k

    inptr0 = input_buf[0][input_row];

208

291k

    inptr1 = input_buf[1][input_row];

209

291k

    inptr2 = input_buf[2][input_row];

210

291k

    input_row++;

211

291k

    outptr = *output_buf++;

212

291k

    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.94M

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

222

3.65M

      r = *inptr0++;

223

3.65M

      g = *inptr1++;

224

3.65M

      b = *inptr2++;

225

3.65M

      rgb = PACK_SHORT_565(r, g, b);

226

227

3.65M

      r = *inptr0++;

228

3.65M

      g = *inptr1++;

229

3.65M

      b = *inptr2++;

230

3.65M

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

231

232

3.65M

      WRITE_TWO_ALIGNED_PIXELS(outptr, rgb);

233

3.65M

      outptr += 4;

234

3.65M

    }

235

291k

    if (num_cols & 1) {

236

3.57k

      r = *inptr0;

237

3.57k

      g = *inptr1;

238

3.57k

      b = *inptr2;

239

3.57k

      rgb = PACK_SHORT_565(r, g, b);

240

3.57k

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

241

3.57k

    }

242

291k

  }

243

291k

}

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

290k

{

252

290k

  register _JSAMPROW outptr;

253

290k

  register _JSAMPROW inptr0, inptr1, inptr2;

254

290k

  register JDIMENSION col;

255

290k

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

256

290k

  JDIMENSION num_cols = cinfo->output_width;

257

290k

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

258

290k

  SHIFT_TEMPS

259

260

580k

  while (--num_rows >= 0) {

261

290k

    JLONG rgb;

262

290k

    unsigned int r, g, b;

263

264

290k

    inptr0 = input_buf[0][input_row];

265

290k

    inptr1 = input_buf[1][input_row];

266

290k

    inptr2 = input_buf[2][input_row];

267

290k

    input_row++;

268

290k

    outptr = *output_buf++;

269

290k

    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.37M

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

279

3.08M

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

280

3.08M

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

281

3.08M

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

282

3.08M

      d0 = DITHER_ROTATE(d0);

283

3.08M

      rgb = PACK_SHORT_565(r, g, b);

284

285

3.08M

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

286

3.08M

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

287

3.08M

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

288

3.08M

      d0 = DITHER_ROTATE(d0);

289

3.08M

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

290

291

3.08M

      WRITE_TWO_ALIGNED_PIXELS(outptr, rgb);

292

3.08M

      outptr += 4;

293

3.08M

    }

294

290k

    if (num_cols & 1) {

295

2.52k

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

296

2.52k

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

297

2.52k

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

298

2.52k

      rgb = PACK_SHORT_565(r, g, b);

299

2.52k

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

300

2.52k

    }

301

290k

  }

302

290k

}

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

5.85M

{

311

5.85M

  register _JSAMPROW inptr, outptr;

312

5.85M

  register JDIMENSION col;

313

5.85M

  JDIMENSION num_cols = cinfo->output_width;

314

315

11.7M

  while (--num_rows >= 0) {

316

5.85M

    JLONG rgb;

317

5.85M

    unsigned int g;

318

319

5.85M

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

320

5.85M

    outptr = *output_buf++;

321

5.85M

    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

145M

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

329

139M

      g = *inptr++;

330

139M

      rgb = PACK_SHORT_565(g, g, g);

331

139M

      g = *inptr++;

332

139M

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

333

139M

      WRITE_TWO_ALIGNED_PIXELS(outptr, rgb);

334

139M

      outptr += 4;

335

139M

    }

336

5.85M

    if (num_cols & 1) {

337

3.91M

      g = *inptr;

338

3.91M

      rgb = PACK_SHORT_565(g, g, g);

339

3.91M

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

340

3.91M

    }

341

5.85M

  }

342

5.85M

}

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

3.23M

{

351

3.23M

  register _JSAMPROW inptr, outptr;

352

3.23M

  register JDIMENSION col;

353

3.23M

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

354

3.23M

  JDIMENSION num_cols = cinfo->output_width;

355

3.23M

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

356

357

6.46M

  while (--num_rows >= 0) {

358

3.23M

    JLONG rgb;

359

3.23M

    unsigned int g;

360

361

3.23M

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

362

3.23M

    outptr = *output_buf++;

363

3.23M

    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

104M

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

372

101M

      g = *inptr++;

373

101M

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

374

101M

      rgb = PACK_SHORT_565(g, g, g);

375

101M

      d0 = DITHER_ROTATE(d0);

376

377

101M

      g = *inptr++;

378

101M

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

379

101M

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

380

101M

      d0 = DITHER_ROTATE(d0);

381

382

101M

      WRITE_TWO_ALIGNED_PIXELS(outptr, rgb);

383

101M

      outptr += 4;

384

101M

    }

385

3.23M

    if (num_cols & 1) {

386

1.94M

      g = *inptr;

387

1.94M

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

388

1.94M

      rgb = PACK_SHORT_565(g, g, g);

389

1.94M

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

390

1.94M

    }

391

3.23M

  }

392

3.23M

}

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