FFmpeg  4.4.6
pnmenc.c
Go to the documentation of this file.
1 /*
2  * PNM image format
3  * Copyright (c) 2002, 2003 Fabrice Bellard
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  */
21 
22 #include "libavutil/intreadwrite.h"
23 #include "libavutil/imgutils.h"
24 #include "libavutil/pixdesc.h"
25 #include "avcodec.h"
26 #include "internal.h"
27 
29  const AVFrame *p, int *got_packet)
30 {
31  uint8_t *bytestream, *bytestream_start, *bytestream_end;
32  int i, h, h1, c, n, linesize, ret;
33  uint8_t *ptr, *ptr1, *ptr2;
35  avctx->width, avctx->height, 1);
36 
37  if ((ret = ff_alloc_packet2(avctx, pkt, size + 200, 0)) < 0)
38  return ret;
39 
40  bytestream_start =
41  bytestream = pkt->data;
42  bytestream_end = pkt->data + pkt->size;
43 
44  h = avctx->height;
45  h1 = h;
46  switch (avctx->pix_fmt) {
48  c = '4';
49  n = (avctx->width + 7) >> 3;
50  break;
51  case AV_PIX_FMT_GRAY8:
52  c = '5';
53  n = avctx->width;
54  break;
56  c = '5';
57  n = avctx->width * 2;
58  break;
59  case AV_PIX_FMT_RGB24:
60  c = '6';
61  n = avctx->width * 3;
62  break;
63  case AV_PIX_FMT_RGB48BE:
64  c = '6';
65  n = avctx->width * 6;
66  break;
67  case AV_PIX_FMT_YUV420P:
68  if (avctx->width & 1 || avctx->height & 1) {
69  av_log(avctx, AV_LOG_ERROR, "pgmyuv needs even width and height\n");
70  return AVERROR(EINVAL);
71  }
72  c = '5';
73  n = avctx->width;
74  h1 = (h * 3) / 2;
75  break;
77  c = '5';
78  n = avctx->width * 2;
79  h1 = (h * 3) / 2;
80  break;
81  case AV_PIX_FMT_GBRPF32:
82  c = 'F';
83  n = avctx->width * 4;
84  break;
85  default:
86  return -1;
87  }
88  snprintf(bytestream, bytestream_end - bytestream,
89  "P%c\n%d %d\n", c, avctx->width, h1);
90  bytestream += strlen(bytestream);
91  if (avctx->pix_fmt == AV_PIX_FMT_GBRPF32)
92  snprintf(bytestream, bytestream_end - bytestream,
93  "%f\n", avctx->pix_fmt == AV_PIX_FMT_GBRPF32BE ? 1.f: -1.f);
94  bytestream += strlen(bytestream);
95  if (avctx->pix_fmt != AV_PIX_FMT_MONOWHITE &&
96  avctx->pix_fmt != AV_PIX_FMT_GBRPF32) {
97  int maxdepth = (1 << av_pix_fmt_desc_get(avctx->pix_fmt)->comp[0].depth) - 1;
98  snprintf(bytestream, bytestream_end - bytestream,
99  "%d\n", maxdepth);
100  bytestream += strlen(bytestream);
101  }
102 
103  if (avctx->pix_fmt == AV_PIX_FMT_GBRPF32) {
104  float *r = (float *)p->data[2];
105  float *g = (float *)p->data[0];
106  float *b = (float *)p->data[1];
107 
108  for (int i = 0; i < avctx->height; i++) {
109  for (int j = 0; j < avctx->width; j++) {
110  AV_WN32(bytestream + 0, av_float2int(r[j]));
111  AV_WN32(bytestream + 4, av_float2int(g[j]));
112  AV_WN32(bytestream + 8, av_float2int(b[j]));
113  bytestream += 12;
114  }
115 
116  r += p->linesize[2] / 4;
117  g += p->linesize[0] / 4;
118  b += p->linesize[1] / 4;
119  }
120  } else {
121  ptr = p->data[0];
122  linesize = p->linesize[0];
123  for (i = 0; i < h; i++) {
124  memcpy(bytestream, ptr, n);
125  bytestream += n;
126  ptr += linesize;
127  }
128  }
129 
130  if (avctx->pix_fmt == AV_PIX_FMT_YUV420P || avctx->pix_fmt == AV_PIX_FMT_YUV420P16BE) {
131  h >>= 1;
132  n >>= 1;
133  ptr1 = p->data[1];
134  ptr2 = p->data[2];
135  for (i = 0; i < h; i++) {
136  memcpy(bytestream, ptr1, n);
137  bytestream += n;
138  memcpy(bytestream, ptr2, n);
139  bytestream += n;
140  ptr1 += p->linesize[1];
141  ptr2 += p->linesize[2];
142  }
143  }
144  pkt->size = bytestream - bytestream_start;
146  *got_packet = 1;
147 
148  return 0;
149 }
150 
152 {
153 #if FF_API_CODED_FRAME
156  avctx->coded_frame->key_frame = 1;
158 #endif
159 
160  return 0;
161 }
162 
163 #if CONFIG_PGM_ENCODER
165  .name = "pgm",
166  .long_name = NULL_IF_CONFIG_SMALL("PGM (Portable GrayMap) image"),
167  .type = AVMEDIA_TYPE_VIDEO,
168  .id = AV_CODEC_ID_PGM,
169  .init = pnm_encode_init,
170  .encode2 = pnm_encode_frame,
171  .pix_fmts = (const enum AVPixelFormat[]){
173  },
174  .caps_internal = FF_CODEC_CAP_INIT_THREADSAFE,
175 };
176 #endif
177 
178 #if CONFIG_PGMYUV_ENCODER
180  .name = "pgmyuv",
181  .long_name = NULL_IF_CONFIG_SMALL("PGMYUV (Portable GrayMap YUV) image"),
182  .type = AVMEDIA_TYPE_VIDEO,
183  .id = AV_CODEC_ID_PGMYUV,
184  .init = pnm_encode_init,
185  .encode2 = pnm_encode_frame,
186  .pix_fmts = (const enum AVPixelFormat[]){
188  },
189  .caps_internal = FF_CODEC_CAP_INIT_THREADSAFE,
190 };
191 #endif
192 
193 #if CONFIG_PPM_ENCODER
195  .name = "ppm",
196  .long_name = NULL_IF_CONFIG_SMALL("PPM (Portable PixelMap) image"),
197  .type = AVMEDIA_TYPE_VIDEO,
198  .id = AV_CODEC_ID_PPM,
199  .init = pnm_encode_init,
200  .encode2 = pnm_encode_frame,
201  .pix_fmts = (const enum AVPixelFormat[]){
203  },
204  .caps_internal = FF_CODEC_CAP_INIT_THREADSAFE,
205 };
206 #endif
207 
208 #if CONFIG_PBM_ENCODER
210  .name = "pbm",
211  .long_name = NULL_IF_CONFIG_SMALL("PBM (Portable BitMap) image"),
212  .type = AVMEDIA_TYPE_VIDEO,
213  .id = AV_CODEC_ID_PBM,
214  .init = pnm_encode_init,
215  .encode2 = pnm_encode_frame,
216  .pix_fmts = (const enum AVPixelFormat[]){ AV_PIX_FMT_MONOWHITE,
217  AV_PIX_FMT_NONE },
218  .caps_internal = FF_CODEC_CAP_INIT_THREADSAFE,
219 };
220 #endif
221 
222 #if CONFIG_PFM_ENCODER
224  .name = "pfm",
225  .long_name = NULL_IF_CONFIG_SMALL("PFM (Portable FloatMap) image"),
226  .type = AVMEDIA_TYPE_VIDEO,
227  .id = AV_CODEC_ID_PFM,
228  .init = pnm_encode_init,
229  .encode2 = pnm_encode_frame,
230  .pix_fmts = (const enum AVPixelFormat[]){ AV_PIX_FMT_GBRPF32,
231  AV_PIX_FMT_NONE },
232  .caps_internal = FF_CODEC_CAP_INIT_THREADSAFE,
233 };
234 #endif
AVCodec ff_ppm_encoder
AVCodec ff_pgmyuv_encoder
AVCodec ff_pfm_encoder
AVCodec ff_pbm_encoder
AVCodec ff_pgm_encoder
#define av_cold
Definition: attributes.h:88
uint8_t
Libavcodec external API header.
int ff_alloc_packet2(AVCodecContext *avctx, AVPacket *avpkt, int64_t size, int64_t min_size)
Check AVPacket size and/or allocate data.
Definition: encode.c:33
@ AV_CODEC_ID_PGM
Definition: codec_id.h:113
@ AV_CODEC_ID_PBM
Definition: codec_id.h:112
@ AV_CODEC_ID_PGMYUV
Definition: codec_id.h:114
@ AV_CODEC_ID_PPM
Definition: codec_id.h:111
@ AV_CODEC_ID_PFM
Definition: codec_id.h:302
#define AV_PKT_FLAG_KEY
The packet contains a keyframe.
Definition: packet.h:410
#define AVERROR(e)
Definition: error.h:43
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:194
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
int av_image_get_buffer_size(enum AVPixelFormat pix_fmt, int width, int height, int align)
Return the size in bytes of the amount of data required to store an image with the given parameters.
Definition: imgutils.c:466
@ AV_PICTURE_TYPE_I
Intra.
Definition: avutil.h:274
for(j=16;j >0;--j)
misc image utilities
int i
Definition: input.c:407
static av_always_inline uint32_t av_float2int(float f)
Reinterpret a float as a 32-bit integer.
Definition: intfloat.h:50
#define AV_WN32(p, v)
Definition: intreadwrite.h:376
#define FF_CODEC_CAP_INIT_THREADSAFE
The codec does not modify any global variables in the init function, allowing to call the init functi...
Definition: internal.h:41
common internal API header
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.
Definition: internal.h:117
#define FF_DISABLE_DEPRECATION_WARNINGS
Definition: internal.h:83
#define FF_ENABLE_DEPRECATION_WARNINGS
Definition: internal.h:84
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:2573
#define AV_PIX_FMT_GBRPF32
Definition: pixfmt.h:428
AVPixelFormat
Pixel format.
Definition: pixfmt.h:64
@ AV_PIX_FMT_GRAY16BE
Y , 16bpp, big-endian.
Definition: pixfmt.h:97
@ AV_PIX_FMT_YUV420P16BE
planar YUV 4:2:0, 24bpp, (1 Cr & Cb sample per 2x2 Y samples), big-endian
Definition: pixfmt.h:132
@ AV_PIX_FMT_NONE
Definition: pixfmt.h:65
@ AV_PIX_FMT_RGB24
packed RGB 8:8:8, 24bpp, RGBRGB...
Definition: pixfmt.h:68
@ AV_PIX_FMT_YUV420P
planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
Definition: pixfmt.h:66
@ AV_PIX_FMT_GBRPF32BE
IEEE-754 single precision planar GBR 4:4:4, 96bpp, big-endian.
Definition: pixfmt.h:318
@ AV_PIX_FMT_GRAY8
Y , 8bpp.
Definition: pixfmt.h:74
@ AV_PIX_FMT_RGB48BE
packed RGB 16:16:16, 48bpp, 16R, 16G, 16B, the 2-byte value for each R/G/B component is stored as big...
Definition: pixfmt.h:102
@ AV_PIX_FMT_MONOWHITE
Y , 1bpp, 0 is white, 1 is black, in each byte pixels are ordered from the msb to the lsb.
Definition: pixfmt.h:75
static av_cold int pnm_encode_init(AVCodecContext *avctx)
Definition: pnmenc.c:151
static int pnm_encode_frame(AVCodecContext *avctx, AVPacket *pkt, const AVFrame *p, int *got_packet)
Definition: pnmenc.c:28
#define snprintf
Definition: snprintf.h:34
main external API structure.
Definition: avcodec.h:536
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:746
int width
picture width / height.
Definition: avcodec.h:709
attribute_deprecated AVFrame * coded_frame
the picture in the bitstream
Definition: avcodec.h:1768
AVCodec.
Definition: codec.h:197
const char * name
Name of the codec implementation.
Definition: codec.h:204
int depth
Number of bits in the component.
Definition: pixdesc.h:58
This structure describes decoded (raw) audio or video data.
Definition: frame.h:318
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:332
int key_frame
1 -> keyframe, 0-> not
Definition: frame.h:396
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
Definition: frame.h:349
enum AVPictureType pict_type
Picture type of the frame.
Definition: frame.h:401
This structure stores compressed data.
Definition: packet.h:346
int flags
A combination of AV_PKT_FLAG values.
Definition: packet.h:375
int size
Definition: packet.h:370
uint8_t * data
Definition: packet.h:369
AVComponentDescriptor comp[4]
Parameters that describe how pixels are packed.
Definition: pixdesc.h:117
#define av_log(a,...)
AVPacket * pkt
Definition: movenc.c:59
int size
const char * b
Definition: vf_curves.c:118
const char * g
Definition: vf_curves.c:117
const char * r
Definition: vf_curves.c:116
static double c[64]