FFmpeg
dpxenc.c
Go to the documentation of this file.
1 /*
2  * DPX (.dpx) image encoder
3  * Copyright (c) 2011 Peter Ross <pross@xvid.org>
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/common.h"
23 #include "libavutil/intreadwrite.h"
24 #include "libavutil/imgutils.h"
25 #include "avcodec.h"
26 #include "encode.h"
27 #include "internal.h"
28 
29 typedef struct DPXContext {
34  int planar;
35 } DPXContext;
36 
38 {
39  DPXContext *s = avctx->priv_data;
41 
42  s->big_endian = !!(desc->flags & AV_PIX_FMT_FLAG_BE);
43  s->bits_per_component = desc->comp[0].depth;
44  s->num_components = desc->nb_components;
45  s->descriptor = (desc->flags & AV_PIX_FMT_FLAG_ALPHA) ? 51 : 50;
46  s->planar = !!(desc->flags & AV_PIX_FMT_FLAG_PLANAR);
47 
48  switch (avctx->pix_fmt) {
49  case AV_PIX_FMT_ABGR:
50  s->descriptor = 52;
51  break;
54  case AV_PIX_FMT_GRAY8:
55  s->descriptor = 6;
56  break;
61  case AV_PIX_FMT_RGB24:
64  case AV_PIX_FMT_RGBA:
65  break;
66  case AV_PIX_FMT_RGB48LE:
67  case AV_PIX_FMT_RGB48BE:
68  if (avctx->bits_per_raw_sample)
69  s->bits_per_component = avctx->bits_per_raw_sample;
70  break;
71  default:
72  av_log(avctx, AV_LOG_INFO, "unsupported pixel format\n");
73  return -1;
74  }
75 
76  return 0;
77 }
78 
79 static av_always_inline void write16_internal(int big_endian, void *p, int value)
80 {
81  if (big_endian) AV_WB16(p, value);
82  else AV_WL16(p, value);
83 }
84 
85 static av_always_inline void write32_internal(int big_endian, void *p, int value)
86 {
87  if (big_endian) AV_WB32(p, value);
88  else AV_WL32(p, value);
89 }
90 
91 #define write16(p, value) write16_internal(s->big_endian, p, value)
92 #define write32(p, value) write32_internal(s->big_endian, p, value)
93 
94 static void encode_rgb48_10bit(AVCodecContext *avctx, const AVFrame *pic,
95  uint8_t *dst)
96 {
97  DPXContext *s = avctx->priv_data;
98  const uint8_t *src = pic->data[0];
99  int x, y;
100 
101  for (y = 0; y < avctx->height; y++) {
102  for (x = 0; x < avctx->width; x++) {
103  int value;
104  if (s->big_endian) {
105  value = ((AV_RB16(src + 6*x + 4) & 0xFFC0U) >> 4)
106  | ((AV_RB16(src + 6*x + 2) & 0xFFC0U) << 6)
107  | ((AV_RB16(src + 6*x + 0) & 0xFFC0U) << 16);
108  } else {
109  value = ((AV_RL16(src + 6*x + 4) & 0xFFC0U) >> 4)
110  | ((AV_RL16(src + 6*x + 2) & 0xFFC0U) << 6)
111  | ((AV_RL16(src + 6*x + 0) & 0xFFC0U) << 16);
112  }
113  write32(dst, value);
114  dst += 4;
115  }
116  src += pic->linesize[0];
117  }
118 }
119 
120 static void encode_gbrp10(AVCodecContext *avctx, const AVFrame *pic, uint8_t *dst)
121 {
122  DPXContext *s = avctx->priv_data;
123  const uint8_t *src[3] = {pic->data[0], pic->data[1], pic->data[2]};
124  int x, y, i;
125 
126  for (y = 0; y < avctx->height; y++) {
127  for (x = 0; x < avctx->width; x++) {
128  int value;
129  if (s->big_endian) {
130  value = (AV_RB16(src[0] + 2*x) << 12)
131  | (AV_RB16(src[1] + 2*x) << 2)
132  | ((unsigned)AV_RB16(src[2] + 2*x) << 22);
133  } else {
134  value = (AV_RL16(src[0] + 2*x) << 12)
135  | (AV_RL16(src[1] + 2*x) << 2)
136  | ((unsigned)AV_RL16(src[2] + 2*x) << 22);
137  }
138  write32(dst, value);
139  dst += 4;
140  }
141  for (i = 0; i < 3; i++)
142  src[i] += pic->linesize[i];
143  }
144 }
145 
146 static void encode_gbrp12(AVCodecContext *avctx, const AVFrame *pic, uint8_t *dst)
147 {
148  DPXContext *s = avctx->priv_data;
149  const uint16_t *src[3] = {(uint16_t*)pic->data[0],
150  (uint16_t*)pic->data[1],
151  (uint16_t*)pic->data[2]};
152  int x, y, i, pad;
153  pad = avctx->width*6;
154  pad = (FFALIGN(pad, 4) - pad) >> 1;
155  for (y = 0; y < avctx->height; y++) {
156  for (x = 0; x < avctx->width; x++) {
157  uint16_t value[3];
158  if (s->big_endian) {
159  value[1] = AV_RB16(src[0] + x) << 4;
160  value[2] = AV_RB16(src[1] + x) << 4;
161  value[0] = AV_RB16(src[2] + x) << 4;
162  } else {
163  value[1] = AV_RL16(src[0] + x) << 4;
164  value[2] = AV_RL16(src[1] + x) << 4;
165  value[0] = AV_RL16(src[2] + x) << 4;
166  }
167  for (i = 0; i < 3; i++, dst += 2)
168  write16(dst, value[i]);
169  }
170  for (i = 0; i < pad; i++, dst += 2)
171  AV_WN16(dst, 0);
172  for (i = 0; i < 3; i++)
173  src[i] += pic->linesize[i]/2;
174  }
175 }
176 
178  const AVFrame *frame, int *got_packet)
179 {
180  DPXContext *s = avctx->priv_data;
181  int size, ret, need_align, len;
182  uint8_t *buf;
183 
184 #define HEADER_SIZE 1664 /* DPX Generic header */
185  if (s->bits_per_component == 10)
186  size = avctx->height * avctx->width * 4;
187  else if (s->bits_per_component == 12) {
188  // 3 components, 12 bits put on 16 bits
189  len = avctx->width*6;
190  size = FFALIGN(len, 4);
191  need_align = size - len;
192  size *= avctx->height;
193  } else {
194  // N components, M bits
195  len = avctx->width * s->num_components * s->bits_per_component >> 3;
196  size = FFALIGN(len, 4);
197  need_align = size - len;
198  size *= avctx->height;
199  }
200  if ((ret = ff_get_encode_buffer(avctx, pkt, size + HEADER_SIZE, 0)) < 0)
201  return ret;
202  buf = pkt->data;
203 
204  memset(buf, 0, HEADER_SIZE);
205 
206  /* File information header */
207  write32(buf, MKBETAG('S','D','P','X'));
208  write32(buf + 4, HEADER_SIZE);
209  memcpy (buf + 8, "V1.0", 4);
210  write32(buf + 20, 1); /* new image */
211  write32(buf + 24, HEADER_SIZE);
212  if (!(avctx->flags & AV_CODEC_FLAG_BITEXACT))
213  memcpy (buf + 160, LIBAVCODEC_IDENT, FFMIN(sizeof(LIBAVCODEC_IDENT), 100));
214  write32(buf + 660, 0xFFFFFFFF); /* unencrypted */
215 
216  /* Image information header */
217  write16(buf + 768, 0); /* orientation; left to right, top to bottom */
218  write16(buf + 770, 1); /* number of elements */
219  write32(buf + 772, avctx->width);
220  write32(buf + 776, avctx->height);
221  buf[800] = s->descriptor;
222  buf[801] = 2; /* linear transfer */
223  buf[802] = 2; /* linear colorimetric */
224  buf[803] = s->bits_per_component;
225  write16(buf + 804, (s->bits_per_component == 10 || s->bits_per_component == 12) ?
226  1 : 0); /* packing method */
227  write32(buf + 808, HEADER_SIZE); /* data offset */
228 
229  /* Image source information header */
230  write32(buf + 1628, avctx->sample_aspect_ratio.num);
231  write32(buf + 1632, avctx->sample_aspect_ratio.den);
232 
233  switch(s->bits_per_component) {
234  case 8:
235  case 16:
236  if (need_align) {
237  int j;
238  const uint8_t *src = frame->data[0];
239  uint8_t *dst = pkt->data + HEADER_SIZE;
240  size = (len + need_align) * avctx->height;
241  for (j=0; j<avctx->height; j++) {
242  memcpy(dst, src, len);
243  memset(dst + len, 0, need_align);
244  dst += len + need_align;
245  src += frame->linesize[0];
246  }
247  } else {
249  (const uint8_t**)frame->data, frame->linesize,
250  avctx->pix_fmt,
251  avctx->width, avctx->height, 1);
252  }
253  if (size < 0)
254  return size;
255  break;
256  case 10:
257  if (s->planar)
258  encode_gbrp10(avctx, frame, buf + HEADER_SIZE);
259  else
260  encode_rgb48_10bit(avctx, frame, buf + HEADER_SIZE);
261  break;
262  case 12:
263  encode_gbrp12(avctx, frame, buf + HEADER_SIZE);
264  break;
265  default:
266  av_log(avctx, AV_LOG_ERROR, "Unsupported bit depth: %d\n", s->bits_per_component);
267  return -1;
268  }
269 
270  size += HEADER_SIZE;
271 
272  write32(buf + 16, size); /* file size */
273 
275  *got_packet = 1;
276 
277  return 0;
278 }
279 
281  .name = "dpx",
282  .long_name = NULL_IF_CONFIG_SMALL("DPX (Digital Picture Exchange) image"),
283  .type = AVMEDIA_TYPE_VIDEO,
284  .id = AV_CODEC_ID_DPX,
285  .capabilities = AV_CODEC_CAP_DR1,
286  .priv_data_size = sizeof(DPXContext),
287  .init = encode_init,
288  .encode2 = encode_frame,
289  .pix_fmts = (const enum AVPixelFormat[]){
298  .caps_internal = FF_CODEC_CAP_INIT_THREADSAFE,
299 };
AVCodec
AVCodec.
Definition: codec.h:202
FF_CODEC_CAP_INIT_THREADSAFE
#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:42
AVPixelFormat
AVPixelFormat
Pixel format.
Definition: pixfmt.h:64
AV_CODEC_ID_DPX
@ AV_CODEC_ID_DPX
Definition: codec_id.h:178
init
static av_cold int init(AVCodecContext *avctx)
Definition: avrndec.c:31
LIBAVCODEC_IDENT
#define LIBAVCODEC_IDENT
Definition: version.h:42
AV_WL32
#define AV_WL32(p, v)
Definition: intreadwrite.h:426
ff_dpx_encoder
const AVCodec ff_dpx_encoder
Definition: dpxenc.c:280
AV_PIX_FMT_GBRP10BE
@ AV_PIX_FMT_GBRP10BE
planar GBR 4:4:4 30bpp, big-endian
Definition: pixfmt.h:162
av_pix_fmt_desc_get
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:2540
write16
#define write16(p, value)
Definition: dpxenc.c:91
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:303
AV_PIX_FMT_RGBA64BE
@ AV_PIX_FMT_RGBA64BE
packed RGBA 16:16:16:16, 64bpp, 16R, 16G, 16B, 16A, the 2-byte value for each R/G/B/A component is st...
Definition: pixfmt.h:195
internal.h
AVPacket::data
uint8_t * data
Definition: packet.h:373
DPXContext::descriptor
int descriptor
Definition: dpxenc.c:33
encode.h
write16_internal
static av_always_inline void write16_internal(int big_endian, void *p, int value)
Definition: dpxenc.c:79
AV_PKT_FLAG_KEY
#define AV_PKT_FLAG_KEY
The packet contains a keyframe.
Definition: packet.h:425
AVFrame::data
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:317
DPXContext::bits_per_component
int bits_per_component
Definition: dpxenc.c:31
encode_frame
static int encode_frame(AVCodecContext *avctx, AVPacket *pkt, const AVFrame *frame, int *got_packet)
Definition: dpxenc.c:177
AV_PIX_FMT_GRAY16BE
@ AV_PIX_FMT_GRAY16BE
Y , 16bpp, big-endian.
Definition: pixfmt.h:97
U
#define U(x)
Definition: vp56_arith.h:37
AVCodecContext::flags
int flags
AV_CODEC_FLAG_*.
Definition: avcodec.h:463
AVRational::num
int num
Numerator.
Definition: rational.h:59
pkt
AVPacket * pkt
Definition: movenc.c:59
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:180
av_cold
#define av_cold
Definition: attributes.h:90
write32_internal
static av_always_inline void write32_internal(int big_endian, void *p, int value)
Definition: dpxenc.c:85
intreadwrite.h
s
#define s(width, name)
Definition: cbs_vp9.c:257
AV_PIX_FMT_GBRP12LE
@ AV_PIX_FMT_GBRP12LE
planar GBR 4:4:4 36bpp, little-endian
Definition: pixfmt.h:245
pix_fmts
static enum AVPixelFormat pix_fmts[]
Definition: libkvazaar.c:290
AVCodecContext::bits_per_raw_sample
int bits_per_raw_sample
Bits per sample/pixel of internal libavcodec pixel/sample format.
Definition: avcodec.h:1425
AV_PIX_FMT_FLAG_ALPHA
#define AV_PIX_FMT_FLAG_ALPHA
The pixel format has an alpha channel.
Definition: pixdesc.h:147
AV_RL16
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_WL24 unsigned int_TMPL AV_RL16
Definition: bytestream.h:94
write32
#define write32(p, value)
Definition: dpxenc.c:92
AV_PIX_FMT_GBRP10LE
@ AV_PIX_FMT_GBRP10LE
planar GBR 4:4:4 30bpp, little-endian
Definition: pixfmt.h:163
AV_PIX_FMT_RGBA
@ AV_PIX_FMT_RGBA
packed RGBA 8:8:8:8, 32bpp, RGBARGBA...
Definition: pixfmt.h:93
AV_WB16
#define AV_WB16(p, v)
Definition: intreadwrite.h:405
DPXContext::planar
int planar
Definition: dpxenc.c:34
AV_PIX_FMT_RGB48LE
@ AV_PIX_FMT_RGB48LE
packed RGB 16:16:16, 48bpp, 16R, 16G, 16B, the 2-byte value for each R/G/B component is stored as lit...
Definition: pixfmt.h:103
AV_PIX_FMT_RGBA64LE
@ AV_PIX_FMT_RGBA64LE
packed RGBA 16:16:16:16, 64bpp, 16R, 16G, 16B, 16A, the 2-byte value for each R/G/B/A component is st...
Definition: pixfmt.h:196
src
#define src
Definition: vp8dsp.c:255
AV_PIX_FMT_GRAY8
@ AV_PIX_FMT_GRAY8
Y , 8bpp.
Definition: pixfmt.h:74
AV_PIX_FMT_ABGR
@ AV_PIX_FMT_ABGR
packed ABGR 8:8:8:8, 32bpp, ABGRABGR...
Definition: pixfmt.h:94
DPXContext::num_components
int num_components
Definition: dpxenc.c:32
for
for(j=16;j >0;--j)
Definition: h264pred_template.c:469
AV_WB32
#define AV_WB32(p, v)
Definition: intreadwrite.h:419
DPXContext
Definition: dpxenc.c:29
AV_PIX_FMT_RGB24
@ AV_PIX_FMT_RGB24
packed RGB 8:8:8, 24bpp, RGBRGB...
Definition: pixfmt.h:68
AV_CODEC_CAP_DR1
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() or get_encode_buffer() for allocating buffers and supports custom allocators.
Definition: codec.h:52
AVPacket::size
int size
Definition: packet.h:374
NULL_IF_CONFIG_SMALL
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.
Definition: internal.h:117
encode_gbrp12
static void encode_gbrp12(AVCodecContext *avctx, const AVFrame *pic, uint8_t *dst)
Definition: dpxenc.c:146
size
int size
Definition: twinvq_data.h:10344
MKBETAG
#define MKBETAG(a, b, c, d)
Definition: macros.h:56
AV_WL16
#define AV_WL16(p, v)
Definition: intreadwrite.h:412
AVPacket::flags
int flags
A combination of AV_PKT_FLAG values.
Definition: packet.h:379
HEADER_SIZE
#define HEADER_SIZE
AV_LOG_INFO
#define AV_LOG_INFO
Standard information.
Definition: log.h:191
i
int i
Definition: input.c:406
AV_PIX_FMT_RGB48BE
@ 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
common.h
av_always_inline
#define av_always_inline
Definition: attributes.h:49
value
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf default value
Definition: writing_filters.txt:86
FFMIN
#define FFMIN(a, b)
Definition: macros.h:49
AV_PIX_FMT_FLAG_BE
#define AV_PIX_FMT_FLAG_BE
Pixel format is big-endian.
Definition: pixdesc.h:116
AVCodec::name
const char * name
Name of the codec implementation.
Definition: codec.h:209
len
int len
Definition: vorbis_enc_data.h:426
AVCodecContext::height
int height
Definition: avcodec.h:556
AVCodecContext::pix_fmt
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:593
avcodec.h
ret
ret
Definition: filter_design.txt:187
frame
these buffered frames must be flushed immediately if a new input produces new the filter must not call request_frame to get more It must just process the frame or queue it The task of requesting more frames is left to the filter s request_frame method or the application If a filter has several the filter must be ready for frames arriving randomly on any input any filter with several inputs will most likely require some kind of queuing mechanism It is perfectly acceptable to have a limited queue and to drop frames when the inputs are too unbalanced request_frame For filters that do not use the this method is called when a frame is wanted on an output For a it should directly call filter_frame on the corresponding output For a if there are queued frames already one of these frames should be pushed If the filter should request a frame on one of its repeatedly until at least one frame has been pushed Return or at least make progress towards producing a frame
Definition: filter_design.txt:264
AV_PIX_FMT_GBRP12BE
@ AV_PIX_FMT_GBRP12BE
planar GBR 4:4:4 36bpp, big-endian
Definition: pixfmt.h:244
AVCodecContext
main external API structure.
Definition: avcodec.h:383
encode_gbrp10
static void encode_gbrp10(AVCodecContext *avctx, const AVFrame *pic, uint8_t *dst)
Definition: dpxenc.c:120
encode_rgb48_10bit
static void encode_rgb48_10bit(AVCodecContext *avctx, const AVFrame *pic, uint8_t *dst)
Definition: dpxenc.c:94
ff_get_encode_buffer
int ff_get_encode_buffer(AVCodecContext *avctx, AVPacket *avpkt, int64_t size, int flags)
Get a buffer for a packet.
Definition: encode.c:78
AVRational::den
int den
Denominator.
Definition: rational.h:60
AV_PIX_FMT_NONE
@ AV_PIX_FMT_NONE
Definition: pixfmt.h:65
AV_PIX_FMT_FLAG_PLANAR
#define AV_PIX_FMT_FLAG_PLANAR
At least one pixel component is not in the first data plane.
Definition: pixdesc.h:132
encode_init
static av_cold int encode_init(AVCodecContext *avctx)
Definition: dpxenc.c:37
desc
const char * desc
Definition: libsvtav1.c:79
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
AV_PIX_FMT_GRAY16LE
@ AV_PIX_FMT_GRAY16LE
Y , 16bpp, little-endian.
Definition: pixfmt.h:98
AV_CODEC_FLAG_BITEXACT
#define AV_CODEC_FLAG_BITEXACT
Use only bitexact stuff (except (I)DCT).
Definition: avcodec.h:272
AVPixFmtDescriptor
Descriptor that unambiguously describes how the bits of a pixel are stored in the up to 4 data planes...
Definition: pixdesc.h:69
av_image_copy_to_buffer
int av_image_copy_to_buffer(uint8_t *dst, int dst_size, const uint8_t *const src_data[4], const int src_linesize[4], enum AVPixelFormat pix_fmt, int width, int height, int align)
Copy image data from an image into a buffer.
Definition: imgutils.c:501
FFALIGN
#define FFALIGN(x, a)
Definition: macros.h:78
AVPacket
This structure stores compressed data.
Definition: packet.h:350
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:410
AVCodecContext::width
int width
picture width / height.
Definition: avcodec.h:556
imgutils.h
AVFrame::linesize
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
Definition: frame.h:334
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:28
AVCodecContext::sample_aspect_ratio
AVRational sample_aspect_ratio
sample aspect ratio (0 if unknown) That is the width of a pixel divided by the height of the pixel.
Definition: avcodec.h:753
DPXContext::big_endian
int big_endian
Definition: dpxenc.c:30
AV_RB16
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_WL24 unsigned int_TMPL AV_WL16 uint64_t_TMPL AV_WB64 unsigned int_TMPL AV_WB32 unsigned int_TMPL AV_WB24 unsigned int_TMPL AV_RB16
Definition: bytestream.h:98
AV_WN16
#define AV_WN16(p, v)
Definition: intreadwrite.h:372