1 /*
2 * AVS2 decoding using the davs2 library
3 *
4 * Copyright (C) 2018 Yiqun Xu, <yiqun.xu@vipl.ict.ac.cn>
5 * Falei Luo, <falei.luo@gmail.com>
6 * Huiwen Ren, <hwrenx@gmail.com>
7 *
8 * This file is part of FFmpeg.
9 *
10 * FFmpeg is free software; you can redistribute it and/or
11 * modify it under the terms of the GNU Lesser General Public
12 * License as published by the Free Software Foundation; either
13 * version 2.1 of the License, or (at your option) any later version.
14 *
15 * FFmpeg is distributed in the hope that it will be useful,
16 * but WITHOUT ANY WARRANTY; without even the implied warranty of
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
18 * Lesser General Public License for more details.
19 *
20 * You should have received a copy of the GNU Lesser General Public
21 * License along with FFmpeg; if not, write to the Free Software
22 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
23 */
24
25 #include "libavutil/cpu.h"
26 #include "avcodec.h"
27 #include "codec_internal.h"
28 #include "avs2.h"
29 #include "davs2.h"
30
31 typedef struct DAVS2Context {
32 void *decoder;
33
34 AVFrame *frame;
35 davs2_param_t param; // decoding parameters
36 davs2_packet_t packet; // input bitstream
37
38 davs2_picture_t out_frame; // output data, frame data
39 davs2_seq_info_t headerset; // output data, sequence header
40
41 }DAVS2Context;
42
davs2_init(AVCodecContext * avctx)43 static av_cold int davs2_init(AVCodecContext *avctx)
44 {
45 DAVS2Context *cad = avctx->priv_data;
46 int cpu_flags = av_get_cpu_flags();
47
48 /* init the decoder */
49 cad->param.threads = avctx->thread_count;
50 cad->param.info_level = 0;
51 cad->param.disable_avx = !(cpu_flags & AV_CPU_FLAG_AVX &&
52 cpu_flags & AV_CPU_FLAG_AVX2);
53 cad->decoder = davs2_decoder_open(&cad->param);
54
55 if (!cad->decoder) {
56 av_log(avctx, AV_LOG_ERROR, "decoder created error.");
57 return AVERROR_EXTERNAL;
58 }
59
60 av_log(avctx, AV_LOG_VERBOSE, "decoder created. %p\n", cad->decoder);
61 return 0;
62 }
63
davs2_dump_frames(AVCodecContext * avctx,davs2_picture_t * pic,int * got_frame,davs2_seq_info_t * headerset,int ret_type,AVFrame * frame)64 static int davs2_dump_frames(AVCodecContext *avctx, davs2_picture_t *pic, int *got_frame,
65 davs2_seq_info_t *headerset, int ret_type, AVFrame *frame)
66 {
67 DAVS2Context *cad = avctx->priv_data;
68 int bytes_per_sample = pic->bytes_per_sample;
69 int plane = 0;
70 int line = 0;
71
72 if (!headerset) {
73 *got_frame = 0;
74 return 0;
75 }
76
77 if (!pic || ret_type == DAVS2_GOT_HEADER) {
78 avctx->width = headerset->width;
79 avctx->height = headerset->height;
80 avctx->pix_fmt = headerset->output_bit_depth == 10 ?
81 AV_PIX_FMT_YUV420P10 : AV_PIX_FMT_YUV420P;
82 /* It should be picture_reorder_delay, but libdavs2 doesn't export that
83 * info.
84 * Use FFMAX since has_b_frames could be set by AVS2 parser in theory,
85 * which doesn't do it yet.
86 */
87 avctx->has_b_frames = FFMAX(avctx->has_b_frames, !headerset->low_delay);
88
89 if (headerset->frame_rate_id < 16)
90 avctx->framerate = ff_avs2_frame_rate_tab[headerset->frame_rate_id];
91 *got_frame = 0;
92 return 0;
93 }
94
95 switch (pic->type) {
96 case DAVS2_PIC_I:
97 case DAVS2_PIC_G:
98 frame->pict_type = AV_PICTURE_TYPE_I;
99 break;
100 case DAVS2_PIC_P:
101 case DAVS2_PIC_S:
102 frame->pict_type = AV_PICTURE_TYPE_P;
103 break;
104 case DAVS2_PIC_B:
105 frame->pict_type = AV_PICTURE_TYPE_B;
106 break;
107 case DAVS2_PIC_F:
108 frame->pict_type = AV_PICTURE_TYPE_S;
109 break;
110 default:
111 av_log(avctx, AV_LOG_ERROR, "Decoder error: unknown frame type\n");
112 return AVERROR_EXTERNAL;
113 }
114
115 for (plane = 0; plane < 3; ++plane) {
116 int size_line = pic->widths[plane] * bytes_per_sample;
117 frame->buf[plane] = av_buffer_alloc(size_line * pic->lines[plane]);
118
119 if (!frame->buf[plane]){
120 av_log(avctx, AV_LOG_ERROR, "Decoder error: allocation failure, can't dump frames.\n");
121 return AVERROR(ENOMEM);
122 }
123
124 frame->data[plane] = frame->buf[plane]->data;
125 frame->linesize[plane] = size_line;
126
127 for (line = 0; line < pic->lines[plane]; ++line)
128 memcpy(frame->data[plane] + line * size_line,
129 pic->planes[plane] + line * pic->strides[plane],
130 pic->widths[plane] * bytes_per_sample);
131 }
132
133 frame->width = cad->headerset.width;
134 frame->height = cad->headerset.height;
135 frame->pts = cad->out_frame.pts;
136 frame->format = avctx->pix_fmt;
137
138 *got_frame = 1;
139 return 0;
140 }
141
davs2_flush(AVCodecContext * avctx)142 static void davs2_flush(AVCodecContext *avctx)
143 {
144 DAVS2Context *cad = avctx->priv_data;
145 int ret = DAVS2_GOT_FRAME;
146
147 while (ret == DAVS2_GOT_FRAME) {
148 ret = davs2_decoder_flush(cad->decoder, &cad->headerset, &cad->out_frame);
149 davs2_decoder_frame_unref(cad->decoder, &cad->out_frame);
150 }
151
152 if (ret == DAVS2_ERROR) {
153 av_log(avctx, AV_LOG_WARNING, "Decoder flushing failed.\n");
154 }
155 }
156
send_delayed_frame(AVCodecContext * avctx,AVFrame * frame,int * got_frame)157 static int send_delayed_frame(AVCodecContext *avctx, AVFrame *frame, int *got_frame)
158 {
159 DAVS2Context *cad = avctx->priv_data;
160 int ret = DAVS2_DEFAULT;
161
162 ret = davs2_decoder_flush(cad->decoder, &cad->headerset, &cad->out_frame);
163 if (ret == DAVS2_ERROR) {
164 av_log(avctx, AV_LOG_ERROR, "Decoder error: can't flush delayed frame\n");
165 return AVERROR_EXTERNAL;
166 }
167 if (ret == DAVS2_GOT_FRAME) {
168 ret = davs2_dump_frames(avctx, &cad->out_frame, got_frame, &cad->headerset, ret, frame);
169 davs2_decoder_frame_unref(cad->decoder, &cad->out_frame);
170 }
171 return ret;
172 }
173
davs2_end(AVCodecContext * avctx)174 static av_cold int davs2_end(AVCodecContext *avctx)
175 {
176 DAVS2Context *cad = avctx->priv_data;
177
178 /* close the decoder */
179 if (cad->decoder) {
180 davs2_flush(avctx);
181 davs2_decoder_close(cad->decoder);
182 cad->decoder = NULL;
183 }
184
185 return 0;
186 }
187
davs2_decode_frame(AVCodecContext * avctx,AVFrame * frame,int * got_frame,AVPacket * avpkt)188 static int davs2_decode_frame(AVCodecContext *avctx, AVFrame *frame,
189 int *got_frame, AVPacket *avpkt)
190 {
191 DAVS2Context *cad = avctx->priv_data;
192 int buf_size = avpkt->size;
193 const uint8_t *buf_ptr = avpkt->data;
194 int ret = DAVS2_DEFAULT;
195
196 /* end of stream, output what is still in the buffers */
197 if (!buf_size) {
198 return send_delayed_frame(avctx, frame, got_frame);
199 }
200
201 cad->packet.data = buf_ptr;
202 cad->packet.len = buf_size;
203 cad->packet.pts = avpkt->pts;
204 cad->packet.dts = avpkt->dts;
205
206 ret = davs2_decoder_send_packet(cad->decoder, &cad->packet);
207
208
209 if (ret == DAVS2_ERROR) {
210 av_log(avctx, AV_LOG_ERROR, "Decoder error: can't read packet\n");
211 return AVERROR_EXTERNAL;
212 }
213
214 ret = davs2_decoder_recv_frame(cad->decoder, &cad->headerset, &cad->out_frame);
215
216 if (ret != DAVS2_DEFAULT) {
217 ret = davs2_dump_frames(avctx, &cad->out_frame, got_frame, &cad->headerset, ret, frame);
218 davs2_decoder_frame_unref(cad->decoder, &cad->out_frame);
219 }
220
221 return ret == 0 ? buf_size : ret;
222 }
223
224 const FFCodec ff_libdavs2_decoder = {
225 .p.name = "libdavs2",
226 .p.long_name = NULL_IF_CONFIG_SMALL("libdavs2 AVS2-P2/IEEE1857.4"),
227 .p.type = AVMEDIA_TYPE_VIDEO,
228 .p.id = AV_CODEC_ID_AVS2,
229 .priv_data_size = sizeof(DAVS2Context),
230 .init = davs2_init,
231 .close = davs2_end,
232 FF_CODEC_DECODE_CB(davs2_decode_frame),
233 .flush = davs2_flush,
234 .p.capabilities = AV_CODEC_CAP_DELAY | AV_CODEC_CAP_OTHER_THREADS,
235 .caps_internal = FF_CODEC_CAP_AUTO_THREADS,
236 .p.pix_fmts = (const enum AVPixelFormat[]) { AV_PIX_FMT_YUV420P,
237 AV_PIX_FMT_NONE },
238 .p.wrapper_name = "libdavs2",
239 };
240