FFmpeg: libavcodec/pnmenc.c Source File

FFmpeg

[フレーム]

libavcodec

pnmenc.c

Go to the documentation of this file.

1 /*

2 * PNM image format

4 *

5 * This file is part of FFmpeg.

6 *

7 * FFmpeg is free software; you can redistribute it and/or

8 * modify it under the terms of the GNU Lesser General Public

9 * License as published by the Free Software Foundation; either

10 * version 2.1 of the License, or (at your option) any later version.

11 *

12 * FFmpeg is distributed in the hope that it will be useful,

13 * but WITHOUT ANY WARRANTY; without even the implied warranty of

14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU

15 * Lesser General Public License for more details.

16 *

17 * You should have received a copy of the GNU Lesser General Public

18 * License along with FFmpeg; if not, write to the Free Software

19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA

20 */

22 #include "libavutil/pixdesc.h"

23 #include "avcodec.h"

24 #include "internal.h"

26 static int pnm_encode_frame(AVCodecContext *avctx, AVPacket *pkt,

27 const AVFrame *p, int *got_packet)

28 {

29 uint8_t *bytestream, *bytestream_start, *bytestream_end;

30 int i, h, h1, c, n, linesize, ret;

31 uint8_t *ptr, *ptr1, *ptr2;

33 if ((ret = ff_alloc_packet2(avctx, pkt, avpicture_get_size(avctx->pix_fmt,

34 avctx->width,

35 avctx->height) + 200)) < 0)

36 return ret;

38 bytestream_start =

39 bytestream = pkt->data;

40 bytestream_end = pkt->data + pkt->size;

42 h = avctx->height;

43 h1 = h;

44 switch (avctx->pix_fmt) {

45 case AV_PIX_FMT_MONOWHITE:

46 c = '4';

47 n = (avctx->width + 7) >> 3;

48 break;

49 case AV_PIX_FMT_GRAY8:

50 c = '5';

51 n = avctx->width;

52 break;

53 case AV_PIX_FMT_GRAY16BE:

54 c = '5';

55 n = avctx->width * 2;

56 break;

57 case AV_PIX_FMT_RGB24:

58 c = '6';

59 n = avctx->width * 3;

60 break;

61 case AV_PIX_FMT_RGB48BE:

62 c = '6';

63 n = avctx->width * 6;

64 break;

65 case AV_PIX_FMT_YUV420P:

66 if (avctx->width & 1 || avctx->height & 1) {

67 av_log(avctx, AV_LOG_ERROR, "pgmyuv needs even width and height\n");

68 return AVERROR(EINVAL);

69 }

70 c = '5';

71 n = avctx->width;

72 h1 = (h * 3) / 2;

73 break;

74 case AV_PIX_FMT_YUV420P16BE:

75 c = '5';

76 n = avctx->width * 2;

77 h1 = (h * 3) / 2;

78 break;

79 default:

80 return -1;

81 }

82 snprintf(bytestream, bytestream_end - bytestream,

83 "P%c\n%d %d\n", c, avctx->width, h1);

84 bytestream += strlen(bytestream);

85 if (avctx->pix_fmt != AV_PIX_FMT_MONOWHITE) {

86 int maxdepth = (1 << (av_pix_fmt_desc_get(avctx->pix_fmt)->comp[0].depth_minus1 + 1)) - 1;

87 snprintf(bytestream, bytestream_end - bytestream,

88 "%d\n", maxdepth);

89 bytestream += strlen(bytestream);

90 }

92 ptr = p->data[0];

93 linesize = p->linesize[0];

94 for (i = 0; i < h; i++) {

95 memcpy(bytestream, ptr, n);

96 bytestream += n;

97 ptr += linesize;

98 }

100 if (avctx->pix_fmt == AV_PIX_FMT_YUV420P || avctx->pix_fmt == AV_PIX_FMT_YUV420P16BE) {

101 h >>= 1;

102 n >>= 1;

103 ptr1 = p->data[1];

104 ptr2 = p->data[2];

105 for (i = 0; i < h; i++) {

106 memcpy(bytestream, ptr1, n);

107 bytestream += n;

108 memcpy(bytestream, ptr2, n);

109 bytestream += n;

110 ptr1 += p->linesize[1];

111 ptr2 += p->linesize[2];

112 }

113 }

114 pkt->size = bytestream - bytestream_start;

115 pkt->flags |= AV_PKT_FLAG_KEY;

116 *got_packet = 1;

117

118 return 0;

119 }

120

121 static av_cold int pnm_encode_init(AVCodecContext *avctx)

122 {

123 avctx->coded_frame = av_frame_alloc();

124 if (!avctx->coded_frame)

125 return AVERROR(ENOMEM);

126

127 avctx->coded_frame->pict_type = AV_PICTURE_TYPE_I;

128 avctx->coded_frame->key_frame = 1;

129

130 return 0;

131 }

132

133 static av_cold int pnm_encode_close(AVCodecContext *avctx)

134 {

135 av_frame_free(&avctx->coded_frame);

136 return 0;

137 }

138

139 #if CONFIG_PGM_ENCODER

140 AVCodec ff_pgm_encoder = {

141 .name = "pgm",

142 .long_name = NULL_IF_CONFIG_SMALL("PGM (Portable GrayMap) image"),

143 .type = AVMEDIA_TYPE_VIDEO,

144 .id = AV_CODEC_ID_PGM,

145 .init = pnm_encode_init,

146 .close = pnm_encode_close,

147 .encode2 = pnm_encode_frame,

148 .pix_fmts = (const enum AVPixelFormat[]){

149 AV_PIX_FMT_GRAY8, AV_PIX_FMT_GRAY16BE, AV_PIX_FMT_NONE

150 },

151 };

152 #endif

153

154 #if CONFIG_PGMYUV_ENCODER

155 AVCodec ff_pgmyuv_encoder = {

156 .name = "pgmyuv",

157 .long_name = NULL_IF_CONFIG_SMALL("PGMYUV (Portable GrayMap YUV) image"),

158 .type = AVMEDIA_TYPE_VIDEO,

159 .id = AV_CODEC_ID_PGMYUV,

160 .init = pnm_encode_init,

161 .close = pnm_encode_close,

162 .encode2 = pnm_encode_frame,

163 .pix_fmts = (const enum AVPixelFormat[]){

164 AV_PIX_FMT_YUV420P, AV_PIX_FMT_YUV420P16BE, AV_PIX_FMT_NONE

165 },

166 };

167 #endif

168

169 #if CONFIG_PPM_ENCODER

170 AVCodec ff_ppm_encoder = {

171 .name = "ppm",

172 .long_name = NULL_IF_CONFIG_SMALL("PPM (Portable PixelMap) image"),

173 .type = AVMEDIA_TYPE_VIDEO,

174 .id = AV_CODEC_ID_PPM,

175 .init = pnm_encode_init,

176 .close = pnm_encode_close,

177 .encode2 = pnm_encode_frame,

178 .pix_fmts = (const enum AVPixelFormat[]){

179 AV_PIX_FMT_RGB24, AV_PIX_FMT_RGB48BE, AV_PIX_FMT_NONE

180 },

181 };

182 #endif

183

184 #if CONFIG_PBM_ENCODER

185 AVCodec ff_pbm_encoder = {

186 .name = "pbm",

187 .long_name = NULL_IF_CONFIG_SMALL("PBM (Portable BitMap) image"),

188 .type = AVMEDIA_TYPE_VIDEO,

189 .id = AV_CODEC_ID_PBM,

190 .init = pnm_encode_init,

191 .close = pnm_encode_close,

192 .encode2 = pnm_encode_frame,

193 .pix_fmts = (const enum AVPixelFormat[]){ AV_PIX_FMT_MONOWHITE,

194 AV_PIX_FMT_NONE },

195 };

196 #endif

Generated on Sat Jan 25 2014 19:51:53 for FFmpeg by doxygen 1.8.2