FFmpeg: libavcodec/libschroedingerdec.c Source File

FFmpeg

[フレーム]

libavcodec

libschroedingerdec.c

Go to the documentation of this file.

1 /*

2 * Dirac decoder support via Schroedinger libraries

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 */

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 */

30 #include <string.h>

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"

40 #include <schroedinger/schro.h>

41 #include <schroedinger/schrodebug.h>

42 #include <schroedinger/schrovideoformat.h>

44 /** SchroFrame and Pts relation */

45 typedef struct LibSchroFrameContext {

46 SchroFrame *frame;

47 int64_t pts;

48 } LibSchroFrameContext;

50 /** libschroedinger decoder private data */

51 typedef struct SchroDecoderParams {

52 /** Schroedinger video format */

53 SchroVideoFormat *format;

55 /** Schroedinger frame format */

56 SchroFrameFormat frame_format;

58 /** decoder handle */

59 SchroDecoder* decoder;

61 /** queue storing decoded frames */

62 FFSchroQueue dec_frame_queue;

64 /** end of sequence signalled */

65 int eos_signalled;

67 /** end of sequence pulled */

68 int eos_pulled;

69 } SchroDecoderParams;

71 typedef struct SchroParseUnitContext {

72 const uint8_t *buf;

73 int buf_size;

74 } SchroParseUnitContext;

77 static void libschroedinger_decode_buffer_free(SchroBuffer *schro_buf,

78 void *priv)

79 {

80 av_freep(&priv);

81 }

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 }

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;

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->time_base.den = p_schro_params->format->frame_rate_numerator;

199 avctx->time_base.num = 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

222 *got_frame = 0;

223

224 parse_context_init(&parse_ctx, buf, buf_size);

225 if (!buf_size) {

226 if (!p_schro_params->eos_signalled) {

227 state = schro_decoder_push_end_of_stream(decoder);

228 p_schro_params->eos_signalled = 1;

229 }

230 }

231

232 /* Loop through all the individual parse units in the input buffer */

233 do {

234 if ((enc_buf = find_next_parse_unit(&parse_ctx))) {

235 /* Set Schrotag with the pts to be recovered after decoding*/

236 enc_buf->tag = schro_tag_new(av_malloc(sizeof(int64_t)), av_free);

237 if (!enc_buf->tag->value) {

238 av_log(avctx, AV_LOG_ERROR, "Unable to allocate SchroTag\n");

239 return AVERROR(ENOMEM);

240 }

241 AV_WN(64, enc_buf->tag->value, pts);

242 /* Push buffer into decoder. */

243 if (SCHRO_PARSE_CODE_IS_PICTURE(enc_buf->data[4]) &&

244 SCHRO_PARSE_CODE_NUM_REFS(enc_buf->data[4]) > 0)

245 avctx->has_b_frames = 1;

246 state = schro_decoder_push(decoder, enc_buf);

247 if (state == SCHRO_DECODER_FIRST_ACCESS_UNIT)

248 libschroedinger_handle_first_access_unit(avctx);

249 go = 1;

250 } else

251 outer = 0;

252

253 while (go) {

254 /* Parse data and process result. */

255 state = schro_decoder_wait(decoder);

256 switch (state) {

257 case SCHRO_DECODER_FIRST_ACCESS_UNIT:

258 libschroedinger_handle_first_access_unit(avctx);

259 break;

260

261 case SCHRO_DECODER_NEED_BITS:

262 /* Need more input data - stop iterating over what we have. */

263 go = 0;

264 break;

265

266 case SCHRO_DECODER_NEED_FRAME:

267 /* Decoder needs a frame - create one and push it in. */

268 frame = ff_create_schro_frame(avctx,

269 p_schro_params->frame_format);

270 schro_decoder_add_output_picture(decoder, frame);

271 break;

272

273 case SCHRO_DECODER_OK:

274 /* Pull a frame out of the decoder. */

275 tag = schro_decoder_get_picture_tag(decoder);

276 frame = schro_decoder_pull(decoder);

277

278 if (frame) {

279 /* Add relation between schroframe and pts. */

280 framewithpts = av_malloc(sizeof(LibSchroFrameContext));

281 if (!framewithpts) {

282 av_log(avctx, AV_LOG_ERROR, "Unable to allocate FrameWithPts\n");

283 return AVERROR(ENOMEM);

284 }

285 framewithpts->frame = frame;

286 framewithpts->pts = AV_RN64(tag->value);

287 ff_schro_queue_push_back(&p_schro_params->dec_frame_queue,

288 framewithpts);

289 }

290 break;

291 case SCHRO_DECODER_EOS:

292 go = 0;

293 p_schro_params->eos_pulled = 1;

294 schro_decoder_reset(decoder);

295 outer = 0;

296 break;

297

298 case SCHRO_DECODER_ERROR:

299 return -1;

300 break;

301 }

302 }

303 } while (outer);

304

305 /* Grab next frame to be returned from the top of the queue. */

306 framewithpts = ff_schro_queue_pop(&p_schro_params->dec_frame_queue);

307

308 if (framewithpts && framewithpts->frame) {

309 int ret;

310

311 if ((ret = ff_get_buffer(avctx, avframe, 0)) < 0)

312 return ret;

313

314 memcpy(avframe->data[0],

315 framewithpts->frame->components[0].data,

316 framewithpts->frame->components[0].length);

317

318 memcpy(avframe->data[1],

319 framewithpts->frame->components[1].data,

320 framewithpts->frame->components[1].length);

321

322 memcpy(avframe->data[2],

323 framewithpts->frame->components[2].data,

324 framewithpts->frame->components[2].length);

325

326 /* Fill frame with current buffer data from Schroedinger. */

327 avframe->pkt_pts = framewithpts->pts;

328 avframe->linesize[0] = framewithpts->frame->components[0].stride;

329 avframe->linesize[1] = framewithpts->frame->components[1].stride;

330 avframe->linesize[2] = framewithpts->frame->components[2].stride;

331

332 *got_frame = 1;

333

334 /* Now free the frame resources. */

335 libschroedinger_decode_frame_free(framewithpts->frame);

336 av_free(framewithpts);

337 } else {

338 data = NULL;

339 *got_frame = 0;

340 }

341 return buf_size;

342 }

343

344

345 static av_cold int libschroedinger_decode_close(AVCodecContext *avctx)

346 {

347 SchroDecoderParams *p_schro_params = avctx->priv_data;

348 /* Free the decoder. */

349 schro_decoder_free(p_schro_params->decoder);

350 av_freep(&p_schro_params->format);

351

352 /* Free data in the output frame queue. */

353 ff_schro_queue_free(&p_schro_params->dec_frame_queue,

354 libschroedinger_decode_frame_free);

355

356 return 0;

357 }

358

359 static void libschroedinger_flush(AVCodecContext *avctx)

360 {

361 /* Got a seek request. Free the decoded frames queue and then reset

362 * the decoder */

363 SchroDecoderParams *p_schro_params = avctx->priv_data;

364

365 /* Free data in the output frame queue. */

366 ff_schro_queue_free(&p_schro_params->dec_frame_queue,

367 libschroedinger_decode_frame_free);

368

369 ff_schro_queue_init(&p_schro_params->dec_frame_queue);

370 schro_decoder_reset(p_schro_params->decoder);

371 p_schro_params->eos_pulled = 0;

372 p_schro_params->eos_signalled = 0;

373 }

374

375 AVCodec ff_libschroedinger_decoder = {

376 .name = "libschroedinger",

377 .long_name = NULL_IF_CONFIG_SMALL("libschroedinger Dirac 2.2"),

378 .type = AVMEDIA_TYPE_VIDEO,

379 .id = AV_CODEC_ID_DIRAC,

380 .priv_data_size = sizeof(SchroDecoderParams),

381 .init = libschroedinger_decode_init,

382 .close = libschroedinger_decode_close,

383 .decode = libschroedinger_decode_frame,

384 .capabilities = CODEC_CAP_DELAY,

385 .flush = libschroedinger_flush,

386 };

Generated on Sat Jan 25 2014 19:51:50 for FFmpeg by doxygen 1.8.2