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  }
72 
73  return 0;
74 }
75 
76 static av_always_inline void write16_internal(int big_endian, void *p, int value)
77 {
78  if (big_endian) AV_WB16(p, value);
79  else AV_WL16(p, value);
80 }
81 
82 static av_always_inline void write32_internal(int big_endian, void *p, int value)
83 {
84  if (big_endian) AV_WB32(p, value);
85  else AV_WL32(p, value);
86 }
87 
88 #define write16(p, value) write16_internal(s->big_endian, p, value)
89 #define write32(p, value) write32_internal(s->big_endian, p, value)
90 
91 static void encode_rgb48_10bit(AVCodecContext *avctx, const AVFrame *pic,
92  uint8_t *dst)
93 {
94  DPXContext *s = avctx->priv_data;
95  const uint8_t *src = pic->data[0];
96  int x, y;
97 
98  for (y = 0; y < avctx->height; y++) {
99  for (x = 0; x < avctx->width; x++) {
100  int value;
101  if (s->big_endian) {
102  value = ((AV_RB16(src + 6*x + 4) & 0xFFC0U) >> 4)
103  | ((AV_RB16(src + 6*x + 2) & 0xFFC0U) << 6)
104  | ((AV_RB16(src + 6*x + 0) & 0xFFC0U) << 16);
105  } else {
106  value = ((AV_RL16(src + 6*x + 4) & 0xFFC0U) >> 4)
107  | ((AV_RL16(src + 6*x + 2) & 0xFFC0U) << 6)
108  | ((AV_RL16(src + 6*x + 0) & 0xFFC0U) << 16);
109  }
110  write32(dst, value);
111  dst += 4;
112  }
113  src += pic->linesize[0];
114  }
115 }
116 
117 static void encode_gbrp10(AVCodecContext *avctx, const AVFrame *pic, uint8_t *dst)
118 {
119  DPXContext *s = avctx->priv_data;
120  const uint8_t *src[3] = {pic->data[0], pic->data[1], pic->data[2]};
121  int x, y, i;
122 
123  for (y = 0; y < avctx->height; y++) {
124  for (x = 0; x < avctx->width; x++) {
125  int value;
126  if (s->big_endian) {
127  value = (AV_RB16(src[0] + 2*x) << 12)
128  | (AV_RB16(src[1] + 2*x) << 2)
129  | ((unsigned)AV_RB16(src[2] + 2*x) << 22);
130  } else {
131  value = (AV_RL16(src[0] + 2*x) << 12)
132  | (AV_RL16(src[1] + 2*x) << 2)
133  | ((unsigned)AV_RL16(src[2] + 2*x) << 22);
134  }
135  write32(dst, value);
136  dst += 4;
137  }
138  for (i = 0; i < 3; i++)
139  src[i] += pic->linesize[i];
140  }
141 }
142 
143 static void encode_gbrp12(AVCodecContext *avctx, const AVFrame *pic, uint8_t *dst)
144 {
145  DPXContext *s = avctx->priv_data;
146  const uint16_t *src[3] = {(uint16_t*)pic->data[0],
147  (uint16_t*)pic->data[1],
148  (uint16_t*)pic->data[2]};
149  int x, y, i, pad;
150  pad = avctx->width*6;
151  pad = (FFALIGN(pad, 4) - pad) >> 1;
152  for (y = 0; y < avctx->height; y++) {
153  for (x = 0; x < avctx->width; x++) {
154  uint16_t value[3];
155  if (s->big_endian) {
156  value[1] = AV_RB16(src[0] + x) << 4;
157  value[2] = AV_RB16(src[1] + x) << 4;
158  value[0] = AV_RB16(src[2] + x) << 4;
159  } else {
160  value[1] = AV_RL16(src[0] + x) << 4;
161  value[2] = AV_RL16(src[1] + x) << 4;
162  value[0] = AV_RL16(src[2] + x) << 4;
163  }
164  for (i = 0; i < 3; i++, dst += 2)
165  write16(dst, value[i]);
166  }
167  for (i = 0; i < pad; i++, dst += 2)
168  AV_WN16(dst, 0);
169  for (i = 0; i < 3; i++)
170  src[i] += pic->linesize[i]/2;
171  }
172 }
173 
175  const AVFrame *frame, int *got_packet)
176 {
177  DPXContext *s = avctx->priv_data;
178  int size, ret, need_align, len;
179  uint8_t *buf;
180 
181 #define HEADER_SIZE 1664 /* DPX Generic header */
182  if (s->bits_per_component == 10)
183  size = avctx->height * avctx->width * 4;
184  else if (s->bits_per_component == 12) {
185  // 3 components, 12 bits put on 16 bits
186  len = avctx->width*6;
187  size = FFALIGN(len, 4);
188  need_align = size - len;
189  size *= avctx->height;
190  } else {
191  // N components, M bits
192  len = avctx->width * s->num_components * s->bits_per_component >> 3;
193  size = FFALIGN(len, 4);
194  need_align = size - len;
195  size *= avctx->height;
196  }
197  if ((ret = ff_get_encode_buffer(avctx, pkt, size + HEADER_SIZE, 0)) < 0)
198  return ret;
199  buf = pkt->data;
200 
201  memset(buf, 0, HEADER_SIZE);
202 
203  /* File information header */
204  write32(buf, MKBETAG('S','D','P','X'));
205  write32(buf + 4, HEADER_SIZE);
206  memcpy (buf + 8, "V1.0", 4);
207  write32(buf + 20, 1); /* new image */
208  write32(buf + 24, HEADER_SIZE);
209  if (!(avctx->flags & AV_CODEC_FLAG_BITEXACT))
210  memcpy (buf + 160, LIBAVCODEC_IDENT, FFMIN(sizeof(LIBAVCODEC_IDENT), 100));
211  write32(buf + 660, 0xFFFFFFFF); /* unencrypted */
212 
213  /* Image information header */
214  write16(buf + 768, 0); /* orientation; left to right, top to bottom */
215  write16(buf + 770, 1); /* number of elements */
216  write32(buf + 772, avctx->width);
217  write32(buf + 776, avctx->height);
218  buf[800] = s->descriptor;
219  buf[801] = 2; /* linear transfer */
220  buf[802] = 2; /* linear colorimetric */
221  buf[803] = s->bits_per_component;
222  write16(buf + 804, (s->bits_per_component == 10 || s->bits_per_component == 12) ?
223  1 : 0); /* packing method */
224  write32(buf + 808, HEADER_SIZE); /* data offset */
225 
226  /* Image source information header */
227  write32(buf + 1628, avctx->sample_aspect_ratio.num);
228  write32(buf + 1632, avctx->sample_aspect_ratio.den);
229 
230  switch(s->bits_per_component) {
231  case 8:
232  case 16:
233  if (need_align) {
234  int j;
235  const uint8_t *src = frame->data[0];
236  uint8_t *dst = pkt->data + HEADER_SIZE;
237  size = (len + need_align) * avctx->height;
238  for (j=0; j<avctx->height; j++) {
239  memcpy(dst, src, len);
240  memset(dst + len, 0, need_align);
241  dst += len + need_align;
242  src += frame->linesize[0];
243  }
244  } else {
246  (const uint8_t**)frame->data, frame->linesize,
247  avctx->pix_fmt,
248  avctx->width, avctx->height, 1);
249  }
250  if (size < 0)
251  return size;
252  break;
253  case 10:
254  if (s->planar)
255  encode_gbrp10(avctx, frame, buf + HEADER_SIZE);
256  else
257  encode_rgb48_10bit(avctx, frame, buf + HEADER_SIZE);
258  break;
259  case 12:
260  encode_gbrp12(avctx, frame, buf + HEADER_SIZE);
261  break;
262  default:
263  av_log(avctx, AV_LOG_ERROR, "Unsupported bit depth: %d\n", s->bits_per_component);
264  return -1;
265  }
266 
267  size += HEADER_SIZE;
268 
269  write32(buf + 16, size); /* file size */
270 
271  *got_packet = 1;
272 
273  return 0;
274 }
275 
277  .name = "dpx",
278  .long_name = NULL_IF_CONFIG_SMALL("DPX (Digital Picture Exchange) image"),
279  .type = AVMEDIA_TYPE_VIDEO,
280  .id = AV_CODEC_ID_DPX,
281  .capabilities = AV_CODEC_CAP_DR1,
282  .priv_data_size = sizeof(DPXContext),
283  .init = encode_init,
284  .encode2 = encode_frame,
285  .pix_fmts = (const enum AVPixelFormat[]){
294  .caps_internal = FF_CODEC_CAP_INIT_THREADSAFE,
295 };
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:276
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:2564
write16
#define write16(p, value)
Definition: dpxenc.c:88
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:76
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:174
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:82
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:89
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:143
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
HEADER_SIZE
#define HEADER_SIZE
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
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:271
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:117
encode_rgb48_10bit
static void encode_rgb48_10bit(AVCodecContext *avctx, const AVFrame *pic, uint8_t *dst)
Definition: dpxenc.c:91
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