FFmpeg coverage

Directory: ../../../ffmpeg/
File: src/libavcodec/imm5.c
Date: 2026-10-22 02:10:50
Exec Total Coverage
Lines: 0 98 0.0%
Functions: 0 5 0.0%
Branches: 0 42 0.0%
Line Branch Exec Source
1 /*
2 * Copyright (c) 2019 Paul B Mahol
3 *
4 * This file is part of FFmpeg.
5 *
6 * FFmpeg is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
10 *
11 * FFmpeg is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
15 *
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with FFmpeg; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
19 */
20
21 #include "libavutil/attributes.h"
22 #include "libavutil/attributes_internal.h"
23 #include "libavutil/intreadwrite.h"
24
25 #include "avcodec.h"
26 #include "codec_internal.h"
27 #include "decode.h"
28 #include "internal.h"
29
30 typedef struct IMM5Context {
31 AVCodecContext *h264_avctx; // wrapper context for H264
32 AVCodecContext *hevc_avctx; // wrapper context for HEVC
33 AVCodecContext *codec_avctx;
34 } IMM5Context;
35
36 static const struct IMM5_unit {
37 uint8_t bits[14];
38 uint8_t len;
39 } IMM5_units[14] = {
40 { { 0x00, 0x00, 0x00, 0x01, 0x67, 0x42, 0x80, 0x1E, 0xF4, 0x0B, 0x0F, 0x88 }, 12 },
41 { { 0x00, 0x00, 0x00, 0x01, 0x67, 0x42, 0x80, 0x1E, 0xF4, 0x05, 0x83, 0xE2 }, 12 },
42 { { 0x00, 0x00, 0x00, 0x01, 0x67, 0x42, 0x80, 0x1E, 0xF4, 0x05, 0x81, 0xE8, 0x80 }, 13 },
43 { { 0x00, 0x00, 0x00, 0x01, 0x67, 0x42, 0x80, 0x1E, 0xF4, 0x0B, 0x04, 0xA2 }, 12 },
44 { { 0x00, 0x00, 0x00, 0x01, 0x67, 0x42, 0x80, 0x1E, 0xF4, 0x05, 0x81, 0x28, 0x80 }, 13 },
45 { { 0x00, 0x00, 0x00, 0x01, 0x67, 0x42, 0x80, 0x1E, 0xF4, 0x05, 0x80, 0x92, 0x20 }, 13 },
46 { { 0x00, 0x00, 0x00, 0x01, 0x67, 0x42, 0x00, 0x1E, 0x9A, 0x74, 0x0B, 0x0F, 0xC8 }, 13 },
47 { { 0x00, 0x00, 0x00, 0x01, 0x67, 0x42, 0x00, 0x1E, 0x9A, 0x74, 0x05, 0x83, 0xF2 }, 13 },
48 { { 0x00, 0x00, 0x00, 0x01, 0x67, 0x42, 0x00, 0x1E, 0x9A, 0x74, 0x05, 0x81, 0xEC, 0x80 }, 14 },
49 { { 0x00, 0x00, 0x00, 0x01, 0x67, 0x42, 0x00, 0x1E, 0x9A, 0x74, 0x0B, 0x04, 0xB2 }, 13 },
50 { { 0x00, 0x00, 0x00, 0x01, 0x67, 0x42, 0x00, 0x1E, 0x9A, 0x74, 0x05, 0x81, 0x2C, 0x80 }, 14 },
51 { { 0x00, 0x00, 0x00, 0x01, 0x67, 0x42, 0x00, 0x1E, 0x9A, 0x74, 0x05, 0x80, 0x93, 0x20 }, 14 },
52 { { 0x00, 0x00, 0x00, 0x01, 0x68, 0xDE, 0x3C, 0x80 }, 8 },
53 { { 0x00, 0x00, 0x00, 0x01, 0x68, 0xCE, 0x32, 0x28 }, 8 },
54 };
55
56 ✗ static av_cold int imm5_init(AVCodecContext *avctx)
57 {
58 ✗ IMM5Context *ctx = avctx->priv_data;
59 int ret;
60
61 EXTERN const FFCodec ff_h264_decoder;
62 ✗ ctx->h264_avctx = avcodec_alloc_context3(&ff_h264_decoder.p);
63 ✗ if (!ctx->h264_avctx)
64 ✗ return AVERROR(ENOMEM);
65 ✗ ctx->h264_avctx->thread_count = 1;
66 ✗ ctx->h264_avctx->flags = avctx->flags;
67 ✗ ctx->h264_avctx->flags2 = avctx->flags2;
68 ✗ ctx->h264_avctx->max_pixels = avctx->max_pixels;
69 ✗ ret = avcodec_open2(ctx->h264_avctx, NULL, NULL);
70 ✗ if (ret < 0)
71 ✗ return ret;
72 ✗ ctx->codec_avctx = ctx->h264_avctx;
73
74 EXTERN const FFCodec ff_hevc_decoder;
75 ✗ ctx->hevc_avctx = avcodec_alloc_context3(&ff_hevc_decoder.p);
76 ✗ if (!ctx->hevc_avctx)
77 ✗ return AVERROR(ENOMEM);
78 ✗ ctx->hevc_avctx->thread_count = 1;
79 ✗ ctx->hevc_avctx->flags = avctx->flags;
80 ✗ ctx->hevc_avctx->flags2 = avctx->flags2;
81 ✗ ctx->hevc_avctx->max_pixels = avctx->max_pixels;
82 ✗ ret = avcodec_open2(ctx->hevc_avctx, NULL, NULL);
83 ✗ if (ret < 0)
84 ✗ return ret;
85
86 ✗ return 0;
87 }
88
89 ✗ static int imm5_send_packet(AVCodecContext *avctx, AVPacket *avpkt)
90 {
91 ✗ IMM5Context *ctx = avctx->priv_data;
92 ✗ AVCodecContext *codec_avctx = ctx->h264_avctx;
93 int ret;
94
95 ✗ if (avpkt->size > 24 && avpkt->data[8] <= 1 && AV_RL32(avpkt->data + 4) + 24ULL <= avpkt->size) {
96 ✗ int codec_type = avpkt->data[1];
97 ✗ int index = avpkt->data[10];
98 ✗ int new_size = AV_RL32(avpkt->data + 4);
99 int offset, off;
100
101 ✗ if (codec_type == 0xA) {
102 ✗ codec_avctx = ctx->hevc_avctx;
103 ✗ } else if (index == 17) {
104 ✗ index = 4;
105 ✗ } else if (index == 18) {
106 ✗ index = 5;
107 }
108
109 ✗ if (index >= 1 && index <= 12) {
110 ✗ ret = av_packet_make_writable(avpkt);
111 ✗ if (ret < 0)
112 ✗ return ret;
113
114 ✗ index -= 1;
115 ✗ off = offset = IMM5_units[index].len;
116 ✗ if (codec_type == 2) {
117 ✗ offset += IMM5_units[12].len;
118 } else {
119 ✗ offset += IMM5_units[13].len;
120 }
121
122 ✗ avpkt->data += 24 - offset;
123 ✗ avpkt->size = new_size + offset;
124
125 ✗ memcpy(avpkt->data, IMM5_units[index].bits, IMM5_units[index].len);
126 ✗ if (codec_type == 2) {
127 ✗ memcpy(avpkt->data + off, IMM5_units[12].bits, IMM5_units[12].len);
128 } else {
129 ✗ memcpy(avpkt->data + off, IMM5_units[13].bits, IMM5_units[13].len);
130 }
131 } else {
132 ✗ avpkt->data += 24;
133 ✗ avpkt->size -= 24;
134 }
135 }
136
137 ✗ ctx->codec_avctx = codec_avctx;
138 ✗ ret = avcodec_send_packet(codec_avctx, avpkt);
139 ✗ if (ret < 0)
140 ✗ av_log(avctx, AV_LOG_ERROR, "Error submitting a packet for decoding\n");
141 ✗ return ret;
142 }
143
144 ✗ static int imm5_receive_frame(AVCodecContext *avctx, AVFrame *frame)
145 {
146 ✗ IMM5Context *ctx = avctx->priv_data;
147 ✗ AVPacket *avpkt = avctx->internal->in_pkt;
148 int ret;
149
150 ✗ while ((ret = avcodec_receive_frame(ctx->codec_avctx, frame)) == AVERROR(EAGAIN)) {
151 ✗ ret = ff_decode_get_packet(avctx, avpkt);
152 ✗ if (ret == AVERROR_EOF) {
153 ✗ avcodec_send_packet(ctx->codec_avctx, NULL);
154 ✗ continue;
155 }
156 ✗ if (ret < 0)
157 ✗ return ret;
158 ✗ ret = imm5_send_packet(avctx, avpkt);
159 ✗ av_packet_unref(avpkt);
160 ✗ if (ret < 0)
161 ✗ return ret;
162 }
163 ✗ if (ret < 0)
164 ✗ return ret;
165
166 ✗ AVCodecContext *codec_avctx = ctx->codec_avctx;
167 ✗ avctx->pix_fmt = codec_avctx->pix_fmt;
168 ✗ avctx->coded_width = codec_avctx->coded_width;
169 ✗ avctx->coded_height = codec_avctx->coded_height;
170 ✗ avctx->width = codec_avctx->width;
171 ✗ avctx->height = codec_avctx->height;
172 ✗ avctx->bit_rate = codec_avctx->bit_rate;
173 ✗ avctx->colorspace = codec_avctx->colorspace;
174 ✗ avctx->color_range = codec_avctx->color_range;
175 ✗ avctx->color_trc = codec_avctx->color_trc;
176 ✗ avctx->color_primaries = codec_avctx->color_primaries;
177 ✗ avctx->chroma_sample_location = codec_avctx->chroma_sample_location;
178
179 ✗ return 0;
180 }
181
182 ✗ static av_cold void imm5_flush(AVCodecContext *avctx)
183 {
184 ✗ IMM5Context *ctx = avctx->priv_data;
185
186 ✗ avcodec_flush_buffers(ctx->h264_avctx);
187 ✗ avcodec_flush_buffers(ctx->hevc_avctx);
188 ✗ }
189
190 ✗ static av_cold int imm5_close(AVCodecContext *avctx)
191 {
192 ✗ IMM5Context *ctx = avctx->priv_data;
193
194 ✗ avcodec_free_context(&ctx->h264_avctx);
195 ✗ avcodec_free_context(&ctx->hevc_avctx);
196
197 ✗ return 0;
198 }
199
200 const FFCodec ff_imm5_decoder = {
201 .p.name = "imm5",
202 CODEC_LONG_NAME("Infinity IMM5"),
203 .p.type = AVMEDIA_TYPE_VIDEO,
204 .p.id = AV_CODEC_ID_IMM5,
205 .p.capabilities = AV_CODEC_CAP_DELAY,
206 .init = imm5_init,
207 FF_CODEC_RECEIVE_FRAME_CB(imm5_receive_frame),
208 .close = imm5_close,
209 .flush = imm5_flush,
210 .priv_data_size = sizeof(IMM5Context),
211 .caps_internal = FF_CODEC_CAP_INIT_CLEANUP,
212 };
213