FFmpeg  2.1.1
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/pixdesc.h"
23 #include "avcodec.h"
24 #include "internal.h"
25 #include "pnm.h"
26 
27 
29  const AVFrame *p, int *got_packet)
30 {
31  PNMContext *s = avctx->priv_data;
32  int i, h, h1, c, n, linesize, ret;
33  uint8_t *ptr, *ptr1, *ptr2;
34 
35  if ((ret = ff_alloc_packet2(avctx, pkt, avpicture_get_size(avctx->pix_fmt,
36  avctx->width,
37  avctx->height) + 200)) < 0)
38  return ret;
39 
40  s->bytestream_start =
41  s->bytestream = pkt->data;
42  s->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  default:
82  return -1;
83  }
85  "P%c\n%d %d\n", c, avctx->width, h1);
86  s->bytestream += strlen(s->bytestream);
87  if (avctx->pix_fmt != AV_PIX_FMT_MONOWHITE) {
88  int maxdepth = (1 << (av_pix_fmt_desc_get(avctx->pix_fmt)->comp[0].depth_minus1 + 1)) - 1;
90  "%d\n", maxdepth);
91  s->bytestream += strlen(s->bytestream);
92  }
93 
94  ptr = p->data[0];
95  linesize = p->linesize[0];
96  for (i = 0; i < h; i++) {
97  memcpy(s->bytestream, ptr, n);
98  s->bytestream += n;
99  ptr += linesize;
100  }
101 
102  if (avctx->pix_fmt == AV_PIX_FMT_YUV420P || avctx->pix_fmt == AV_PIX_FMT_YUV420P16BE) {
103  h >>= 1;
104  n >>= 1;
105  ptr1 = p->data[1];
106  ptr2 = p->data[2];
107  for (i = 0; i < h; i++) {
108  memcpy(s->bytestream, ptr1, n);
109  s->bytestream += n;
110  memcpy(s->bytestream, ptr2, n);
111  s->bytestream += n;
112  ptr1 += p->linesize[1];
113  ptr2 += p->linesize[2];
114  }
115  }
116  pkt->size = s->bytestream - s->bytestream_start;
117  pkt->flags |= AV_PKT_FLAG_KEY;
118  *got_packet = 1;
119 
120  return 0;
121 }
122 
123 
124 #if CONFIG_PGM_ENCODER
125 AVCodec ff_pgm_encoder = {
126  .name = "pgm",
127  .long_name = NULL_IF_CONFIG_SMALL("PGM (Portable GrayMap) image"),
128  .type = AVMEDIA_TYPE_VIDEO,
129  .id = AV_CODEC_ID_PGM,
130  .priv_data_size = sizeof(PNMContext),
131  .encode2 = pnm_encode_frame,
132  .pix_fmts = (const enum AVPixelFormat[]){
134  },
135 };
136 #endif
137 
138 #if CONFIG_PGMYUV_ENCODER
139 AVCodec ff_pgmyuv_encoder = {
140  .name = "pgmyuv",
141  .long_name = NULL_IF_CONFIG_SMALL("PGMYUV (Portable GrayMap YUV) image"),
142  .type = AVMEDIA_TYPE_VIDEO,
143  .id = AV_CODEC_ID_PGMYUV,
144  .priv_data_size = sizeof(PNMContext),
145  .encode2 = pnm_encode_frame,
146  .pix_fmts = (const enum AVPixelFormat[]){
148  },
149 };
150 #endif
151 
152 #if CONFIG_PPM_ENCODER
153 AVCodec ff_ppm_encoder = {
154  .name = "ppm",
155  .long_name = NULL_IF_CONFIG_SMALL("PPM (Portable PixelMap) image"),
156  .type = AVMEDIA_TYPE_VIDEO,
157  .id = AV_CODEC_ID_PPM,
158  .priv_data_size = sizeof(PNMContext),
159  .encode2 = pnm_encode_frame,
160  .pix_fmts = (const enum AVPixelFormat[]){
162  },
163 };
164 #endif
165 
166 #if CONFIG_PBM_ENCODER
167 AVCodec ff_pbm_encoder = {
168  .name = "pbm",
169  .long_name = NULL_IF_CONFIG_SMALL("PBM (Portable BitMap) image"),
170  .type = AVMEDIA_TYPE_VIDEO,
171  .id = AV_CODEC_ID_PBM,
172  .priv_data_size = sizeof(PNMContext),
173  .encode2 = pnm_encode_frame,
174  .pix_fmts = (const enum AVPixelFormat[]){ AV_PIX_FMT_MONOWHITE,
175  AV_PIX_FMT_NONE },
176 };
177 #endif
int ff_alloc_packet2(AVCodecContext *avctx, AVPacket *avpkt, int64_t size)
Check AVPacket size and/or allocate data.
Definition: utils.c:1500
const char * s
Definition: avisynth_c.h:668
This structure describes decoded (raw) audio or video data.
Definition: frame.h:96
packed RGB 8:8:8, 24bpp, RGBRGB...
Definition: avcodec.h:4536
int size
Definition: avcodec.h:1064
AVComponentDescriptor comp[4]
Parameters that describe how pixels are packed.
Definition: pixdesc.h:88
void av_log(void *avcl, int level, const char *fmt,...) av_printf_format(3
Send the specified message to the log if the level is less than or equal to the current av_log_level...
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:1342
uint8_t * bytestream
Definition: pnm.h:28
Pixel format.
Definition: avcodec.h:4533
AVCodec.
Definition: avcodec.h:2922
Y , 8bpp.
Definition: avcodec.h:4542
packed RGB 16:16:16, 48bpp, 16R, 16G, 16B, the 2-byte value for each R/G/B component is stored as big...
Definition: avcodec.h:4579
uint8_t
const char * name
Name of the codec implementation.
Definition: avcodec.h:2929
#define AV_PKT_FLAG_KEY
The packet contains a keyframe.
Definition: avcodec.h:1113
uint16_t depth_minus1
number of bits in the component minus 1
Definition: pixdesc.h:45
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: avcodec.h:4147
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:151
uint8_t * bytestream_end
Definition: pnm.h:30
Libavcodec external API header.
AVPixelFormat
Pixel format.
Definition: pixfmt.h:66
int flags
A combination of AV_PKT_FLAG values.
Definition: avcodec.h:1069
ret
Definition: avfilter.c:961
int width
picture width / height.
Definition: avcodec.h:1314
int n
Definition: avisynth_c.h:588
static int pnm_encode_frame(AVCodecContext *avctx, AVPacket *pkt, const AVFrame *p, int *got_packet)
Definition: pnmenc.c:28
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:1938
Definition: pnm.h:27
planar YUV 4:2:0, 12bpp, (1 Cr &amp; Cb sample per 2x2 Y samples)
Definition: avcodec.h:4534
main external API structure.
Definition: avcodec.h:1146
uint8_t * data
Definition: avcodec.h:1063
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
Definition: frame.h:124
#define snprintf
Definition: snprintf.h:34
void * priv_data
Definition: avcodec.h:1182
Y , 1bpp, 0 is white, 1 is black, in each byte pixels are ordered from the msb to the lsb...
Definition: avcodec.h:4543
common internal api header.
static double c[64]
planar YUV 4:2:0, 24bpp, (1 Cr &amp; Cb sample per 2x2 Y samples), big-endian
Definition: avcodec.h:4597
uint8_t * bytestream_start
Definition: pnm.h:29
int avpicture_get_size(enum AVPixelFormat pix_fmt, int width, int height)
Calculate the size in bytes that a picture of the given width and height would occupy if stored in th...
Definition: avpicture.c:49
#define AVERROR(e)
static AVPacket pkt
Definition: demuxing.c:52
This structure stores compressed data.
Definition: avcodec.h:1040
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:107
Y , 16bpp, big-endian.
Definition: avcodec.h:4567