blob: 02cbe57c820dac73820a1b95a0030597d701de40
1 | /* |
2 | * Dirac decoder support via Schroedinger libraries |
3 | * Copyright (c) 2008 BBC, Anuradha Suraparaju <asuraparaju at gmail dot com > |
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 | /** |
23 | * @file |
24 | * Dirac decoder support via libschroedinger-1.0 libraries. More details about |
25 | * the Schroedinger project can be found at http://www.diracvideo.org/. |
26 | * The library implements Dirac Specification Version 2.2. |
27 | * (http://dirac.sourceforge.net/specification.html). |
28 | */ |
29 | |
30 | #include <string.h> |
31 | |
32 | #include "libavutil/imgutils.h" |
33 | #include "libavutil/internal.h" |
34 | #include "libavutil/intreadwrite.h" |
35 | #include "libavutil/mem.h" |
36 | #include "avcodec.h" |
37 | #include "internal.h" |
38 | #include "libschroedinger.h" |
39 | |
40 | #include <schroedinger/schro.h> |
41 | #include <schroedinger/schrodebug.h> |
42 | #include <schroedinger/schrovideoformat.h> |
43 | |
44 | /** SchroFrame and Pts relation */ |
45 | typedef struct LibSchroFrameContext { |
46 | SchroFrame *frame; |
47 | int64_t pts; |
48 | } LibSchroFrameContext; |
49 | |
50 | /** libschroedinger decoder private data */ |
51 | typedef struct SchroDecoderParams { |
52 | /** Schroedinger video format */ |
53 | SchroVideoFormat *format; |
54 | |
55 | /** Schroedinger frame format */ |
56 | SchroFrameFormat frame_format; |
57 | |
58 | /** decoder handle */ |
59 | SchroDecoder* decoder; |
60 | |
61 | /** queue storing decoded frames */ |
62 | FFSchroQueue dec_frame_queue; |
63 | |
64 | /** end of sequence signalled */ |
65 | int eos_signalled; |
66 | |
67 | /** end of sequence pulled */ |
68 | int eos_pulled; |
69 | } SchroDecoderParams; |
70 | |
71 | typedef struct SchroParseUnitContext { |
72 | const uint8_t *buf; |
73 | int buf_size; |
74 | } SchroParseUnitContext; |
75 | |
76 | |
77 | static void libschroedinger_decode_buffer_free(SchroBuffer *schro_buf, |
78 | void *priv) |
79 | { |
80 | av_freep(&priv); |
81 | } |
82 | |
83 | static void parse_context_init(SchroParseUnitContext *parse_ctx, |
84 | const uint8_t *buf, int buf_size) |
85 | { |
86 | parse_ctx->buf = buf; |
87 | parse_ctx->buf_size = buf_size; |
88 | } |
89 | |
90 | static SchroBuffer *find_next_parse_unit(SchroParseUnitContext *parse_ctx) |
91 | { |
92 | SchroBuffer *enc_buf = NULL; |
93 | int next_pu_offset = 0; |
94 | unsigned char *in_buf; |
95 | |
96 | if (parse_ctx->buf_size < 13 || |
97 | parse_ctx->buf[0] != 'B' || |
98 | parse_ctx->buf[1] != 'B' || |
99 | parse_ctx->buf[2] != 'C' || |
100 | parse_ctx->buf[3] != 'D') |
101 | return NULL; |
102 | |
103 | next_pu_offset = (parse_ctx->buf[5] << 24) + |
104 | (parse_ctx->buf[6] << 16) + |
105 | (parse_ctx->buf[7] << 8) + |
106 | parse_ctx->buf[8]; |
107 | |
108 | if (next_pu_offset == 0 && |
109 | SCHRO_PARSE_CODE_IS_END_OF_SEQUENCE(parse_ctx->buf[4])) |
110 | next_pu_offset = 13; |
111 | |
112 | if (next_pu_offset <= 0 || parse_ctx->buf_size < next_pu_offset) |
113 | return NULL; |
114 | |
115 | in_buf = av_malloc(next_pu_offset); |
116 | if (!in_buf) { |
117 | av_log(parse_ctx, AV_LOG_ERROR, "Unable to allocate input buffer\n"); |
118 | return NULL; |
119 | } |
120 | |
121 | memcpy(in_buf, parse_ctx->buf, next_pu_offset); |
122 | enc_buf = schro_buffer_new_with_data(in_buf, next_pu_offset); |
123 | enc_buf->free = libschroedinger_decode_buffer_free; |
124 | enc_buf->priv = in_buf; |
125 | |
126 | parse_ctx->buf += next_pu_offset; |
127 | parse_ctx->buf_size -= next_pu_offset; |
128 | |
129 | return enc_buf; |
130 | } |
131 | |
132 | /** |
133 | * Returns FFmpeg chroma format. |
134 | */ |
135 | static enum AVPixelFormat get_chroma_format(SchroChromaFormat schro_pix_fmt) |
136 | { |
137 | int num_formats = sizeof(schro_pixel_format_map) / |
138 | sizeof(schro_pixel_format_map[0]); |
139 | int idx; |
140 | |
141 | for (idx = 0; idx < num_formats; ++idx) |
142 | if (schro_pixel_format_map[idx].schro_pix_fmt == schro_pix_fmt) |
143 | return schro_pixel_format_map[idx].ff_pix_fmt; |
144 | return AV_PIX_FMT_NONE; |
145 | } |
146 | |
147 | static av_cold int libschroedinger_decode_init(AVCodecContext *avctx) |
148 | { |
149 | |
150 | SchroDecoderParams *p_schro_params = avctx->priv_data; |
151 | /* First of all, initialize our supporting libraries. */ |
152 | schro_init(); |
153 | |
154 | schro_debug_set_level(avctx->debug); |
155 | p_schro_params->decoder = schro_decoder_new(); |
156 | schro_decoder_set_skip_ratio(p_schro_params->decoder, 1); |
157 | |
158 | if (!p_schro_params->decoder) |
159 | return -1; |
160 | |
161 | /* Initialize the decoded frame queue. */ |
162 | ff_schro_queue_init(&p_schro_params->dec_frame_queue); |
163 | return 0; |
164 | } |
165 | |
166 | static void libschroedinger_decode_frame_free(void *frame) |
167 | { |
168 | schro_frame_unref(frame); |
169 | } |
170 | |
171 | static void libschroedinger_handle_first_access_unit(AVCodecContext *avctx) |
172 | { |
173 | SchroDecoderParams *p_schro_params = avctx->priv_data; |
174 | SchroDecoder *decoder = p_schro_params->decoder; |
175 | |
176 | p_schro_params->format = schro_decoder_get_video_format(decoder); |
177 | |
178 | /* Tell FFmpeg about sequence details. */ |
179 | if (av_image_check_size(p_schro_params->format->width, |
180 | p_schro_params->format->height, 0, avctx) < 0) { |
181 | av_log(avctx, AV_LOG_ERROR, "invalid dimensions (%dx%d)\n", |
182 | p_schro_params->format->width, p_schro_params->format->height); |
183 | avctx->height = avctx->width = 0; |
184 | return; |
185 | } |
186 | avctx->height = p_schro_params->format->height; |
187 | avctx->width = p_schro_params->format->width; |
188 | avctx->pix_fmt = get_chroma_format(p_schro_params->format->chroma_format); |
189 | |
190 | if (ff_get_schro_frame_format(p_schro_params->format->chroma_format, |
191 | &p_schro_params->frame_format) == -1) { |
192 | av_log(avctx, AV_LOG_ERROR, |
193 | "This codec currently only supports planar YUV 4:2:0, 4:2:2 " |
194 | "and 4:4:4 formats.\n"); |
195 | return; |
196 | } |
197 | |
198 | avctx->framerate.num = p_schro_params->format->frame_rate_numerator; |
199 | avctx->framerate.den = p_schro_params->format->frame_rate_denominator; |
200 | } |
201 | |
202 | static int libschroedinger_decode_frame(AVCodecContext *avctx, |
203 | void *data, int *got_frame, |
204 | AVPacket *avpkt) |
205 | { |
206 | const uint8_t *buf = avpkt->data; |
207 | int buf_size = avpkt->size; |
208 | int64_t pts = avpkt->pts; |
209 | SchroTag *tag; |
210 | |
211 | SchroDecoderParams *p_schro_params = avctx->priv_data; |
212 | SchroDecoder *decoder = p_schro_params->decoder; |
213 | SchroBuffer *enc_buf; |
214 | SchroFrame* frame; |
215 | AVFrame *avframe = data; |
216 | int state; |
217 | int go = 1; |
218 | int outer = 1; |
219 | SchroParseUnitContext parse_ctx; |
220 | LibSchroFrameContext *framewithpts = NULL; |
221 | int ret; |
222 | |
223 | *got_frame = 0; |
224 | |
225 | parse_context_init(&parse_ctx, buf, buf_size); |
226 | if (!buf_size) { |
227 | if (!p_schro_params->eos_signalled) { |
228 | state = schro_decoder_push_end_of_stream(decoder); |
229 | p_schro_params->eos_signalled = 1; |
230 | } |
231 | } |
232 | |
233 | /* Loop through all the individual parse units in the input buffer */ |
234 | do { |
235 | if ((enc_buf = find_next_parse_unit(&parse_ctx))) { |
236 | /* Set Schrotag with the pts to be recovered after decoding*/ |
237 | enc_buf->tag = schro_tag_new(av_malloc(sizeof(int64_t)), av_free); |
238 | if (!enc_buf->tag->value) { |
239 | av_log(avctx, AV_LOG_ERROR, "Unable to allocate SchroTag\n"); |
240 | return AVERROR(ENOMEM); |
241 | } |
242 | AV_WN(64, enc_buf->tag->value, pts); |
243 | /* Push buffer into decoder. */ |
244 | if (SCHRO_PARSE_CODE_IS_PICTURE(enc_buf->data[4]) && |
245 | SCHRO_PARSE_CODE_NUM_REFS(enc_buf->data[4]) > 0) |
246 | avctx->has_b_frames = 1; |
247 | state = schro_decoder_push(decoder, enc_buf); |
248 | if (state == SCHRO_DECODER_FIRST_ACCESS_UNIT) |
249 | libschroedinger_handle_first_access_unit(avctx); |
250 | go = 1; |
251 | } else |
252 | outer = 0; |
253 | |
254 | while (go) { |
255 | /* Parse data and process result. */ |
256 | state = schro_decoder_wait(decoder); |
257 | switch (state) { |
258 | case SCHRO_DECODER_FIRST_ACCESS_UNIT: |
259 | libschroedinger_handle_first_access_unit(avctx); |
260 | break; |
261 | |
262 | case SCHRO_DECODER_NEED_BITS: |
263 | /* Need more input data - stop iterating over what we have. */ |
264 | go = 0; |
265 | break; |
266 | |
267 | case SCHRO_DECODER_NEED_FRAME: |
268 | /* Decoder needs a frame - create one and push it in. */ |
269 | frame = ff_create_schro_frame(avctx, |
270 | p_schro_params->frame_format); |
271 | if (!frame) |
272 | return AVERROR(ENOMEM); |
273 | schro_decoder_add_output_picture(decoder, frame); |
274 | break; |
275 | |
276 | case SCHRO_DECODER_OK: |
277 | /* Pull a frame out of the decoder. */ |
278 | tag = schro_decoder_get_picture_tag(decoder); |
279 | frame = schro_decoder_pull(decoder); |
280 | |
281 | if (frame) { |
282 | /* Add relation between schroframe and pts. */ |
283 | framewithpts = av_malloc(sizeof(LibSchroFrameContext)); |
284 | if (!framewithpts) { |
285 | av_log(avctx, AV_LOG_ERROR, "Unable to allocate FrameWithPts\n"); |
286 | return AVERROR(ENOMEM); |
287 | } |
288 | framewithpts->frame = frame; |
289 | framewithpts->pts = AV_RN64(tag->value); |
290 | ff_schro_queue_push_back(&p_schro_params->dec_frame_queue, |
291 | framewithpts); |
292 | } |
293 | break; |
294 | case SCHRO_DECODER_EOS: |
295 | go = 0; |
296 | p_schro_params->eos_pulled = 1; |
297 | schro_decoder_reset(decoder); |
298 | outer = 0; |
299 | break; |
300 | |
301 | case SCHRO_DECODER_ERROR: |
302 | return -1; |
303 | break; |
304 | } |
305 | } |
306 | } while (outer); |
307 | |
308 | /* Grab next frame to be returned from the top of the queue. */ |
309 | framewithpts = ff_schro_queue_pop(&p_schro_params->dec_frame_queue); |
310 | |
311 | if (framewithpts && framewithpts->frame && framewithpts->frame->components[0].stride) { |
312 | |
313 | if ((ret = ff_get_buffer(avctx, avframe, 0)) < 0) |
314 | goto end; |
315 | |
316 | memcpy(avframe->data[0], |
317 | framewithpts->frame->components[0].data, |
318 | framewithpts->frame->components[0].length); |
319 | |
320 | memcpy(avframe->data[1], |
321 | framewithpts->frame->components[1].data, |
322 | framewithpts->frame->components[1].length); |
323 | |
324 | memcpy(avframe->data[2], |
325 | framewithpts->frame->components[2].data, |
326 | framewithpts->frame->components[2].length); |
327 | |
328 | /* Fill frame with current buffer data from Schroedinger. */ |
329 | avframe->pts = framewithpts->pts; |
330 | #if FF_API_PKT_PTS |
331 | FF_DISABLE_DEPRECATION_WARNINGS |
332 | avframe->pkt_pts = avframe->pts; |
333 | FF_ENABLE_DEPRECATION_WARNINGS |
334 | #endif |
335 | avframe->linesize[0] = framewithpts->frame->components[0].stride; |
336 | avframe->linesize[1] = framewithpts->frame->components[1].stride; |
337 | avframe->linesize[2] = framewithpts->frame->components[2].stride; |
338 | |
339 | *got_frame = 1; |
340 | } else { |
341 | data = NULL; |
342 | *got_frame = 0; |
343 | } |
344 | ret = buf_size; |
345 | end: |
346 | /* Now free the frame resources. */ |
347 | if (framewithpts && framewithpts->frame) |
348 | libschroedinger_decode_frame_free(framewithpts->frame); |
349 | av_freep(&framewithpts); |
350 | return ret; |
351 | } |
352 | |
353 | |
354 | static av_cold int libschroedinger_decode_close(AVCodecContext *avctx) |
355 | { |
356 | SchroDecoderParams *p_schro_params = avctx->priv_data; |
357 | /* Free the decoder. */ |
358 | schro_decoder_free(p_schro_params->decoder); |
359 | av_freep(&p_schro_params->format); |
360 | |
361 | /* Free data in the output frame queue. */ |
362 | ff_schro_queue_free(&p_schro_params->dec_frame_queue, |
363 | libschroedinger_decode_frame_free); |
364 | |
365 | return 0; |
366 | } |
367 | |
368 | static void libschroedinger_flush(AVCodecContext *avctx) |
369 | { |
370 | /* Got a seek request. Free the decoded frames queue and then reset |
371 | * the decoder */ |
372 | SchroDecoderParams *p_schro_params = avctx->priv_data; |
373 | |
374 | /* Free data in the output frame queue. */ |
375 | ff_schro_queue_free(&p_schro_params->dec_frame_queue, |
376 | libschroedinger_decode_frame_free); |
377 | |
378 | ff_schro_queue_init(&p_schro_params->dec_frame_queue); |
379 | schro_decoder_reset(p_schro_params->decoder); |
380 | p_schro_params->eos_pulled = 0; |
381 | p_schro_params->eos_signalled = 0; |
382 | } |
383 | |
384 | AVCodec ff_libschroedinger_decoder = { |
385 | .name = "libschroedinger", |
386 | .long_name = NULL_IF_CONFIG_SMALL("libschroedinger Dirac 2.2"), |
387 | .type = AVMEDIA_TYPE_VIDEO, |
388 | .id = AV_CODEC_ID_DIRAC, |
389 | .priv_data_size = sizeof(SchroDecoderParams), |
390 | .init = libschroedinger_decode_init, |
391 | .close = libschroedinger_decode_close, |
392 | .decode = libschroedinger_decode_frame, |
393 | .capabilities = AV_CODEC_CAP_DELAY | AV_CODEC_CAP_DR1, |
394 | .flush = libschroedinger_flush, |
395 | }; |
396 |