libavcodec/ohdec.c - third_party/ffmpeg - Git at Google

 /*
  * This file is part of FFmpeg.
  *
  * Copyright (c) 2025 Zhao Zhili <quinkblack@foxmail.com>
  *
  * FFmpeg is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
  * License as published by the Free Software Foundation; either
  * version 2.1 of the License, or (at your option) any later version.
  *
  * FFmpeg is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Lesser General Public License for more details.
  *
  * You should have received a copy of the GNU Lesser General Public
  * License along with FFmpeg; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  */

 #include "config_components.h"

 #include <stdbool.h>
 #include <multimedia/player_framework/native_avcapability.h>
 #include <multimedia/player_framework/native_avcodec_videodecoder.h>

 #include "libavutil/fifo.h"
 #include "libavutil/hwcontext_oh.h"
 #include "libavutil/imgutils.h"
 #include "libavutil/mem.h"
 #include "libavutil/opt.h"
 #include "libavutil/refstruct.h"
 #include "libavutil/thread.h"

 #include "avcodec.h"
 #include "codec_internal.h"
 #include "decode.h"
 #include "hwconfig.h"
 #include "ohcodec.h"
 #include "pthread_internal.h"

 typedef struct OHCodecDecContext {
     AVClass *avclass;
     OH_AVCodec *dec;
     /* A RefStruct reference backing dec. Each hardware frame has a reference count to
      * dec. dec will be destroyed only after oh_decode_close and all hardware
      * frames have been released.
      */
     OH_AVCodec **dec_ref;

     AVMutex input_mutex;
     AVCond input_cond;
     AVFifo *input_queue;

     AVMutex output_mutex;
     AVCond output_cond;
     AVFifo *output_queue;

     AVPacket pkt;

     int decode_status;
     bool eof_sent;

     bool output_to_window;
     bool got_stream_info;
     int width;
     int height;
     int stride;
     int slice_height;
     OH_AVPixelFormat pix_fmt;

     char *name;
     int allow_sw;
     unsigned mutex_cond_cnt;
 } OHCodecDecContext;

 #define OFFSET(x) offsetof(OHCodecDecContext, x)
 DEFINE_OFFSET_ARRAY(OHCodecDecContext, mutex_cond, mutex_cond_cnt,
                     (OFFSET(input_mutex), OFFSET(output_mutex)),
                     (OFFSET(input_cond), OFFSET(output_cond)));

 typedef struct OHCodecBuffer {
     uint32_t index;
     OH_AVBuffer *buffer;
     OH_AVCodec **dec_ref;  ///< RefStruct reference
 } OHCodecBuffer;

 static void oh_decode_release(AVRefStructOpaque unused, void *obj)
 {
     OH_AVCodec **decp = obj;
     OH_AVErrCode err = OH_VideoDecoder_Destroy(*decp);
     if (err == AV_ERR_OK)
         av_log(NULL, AV_LOG_DEBUG, "Destroy decoder success\n");
     else
         av_log(NULL, AV_LOG_ERROR, "Destroy decoder failed, %d, %s\n",
                err, av_err2str(ff_oh_err_to_ff_err(err)));
 }

 static int oh_decode_create(OHCodecDecContext *s, AVCodecContext *avctx)
 {
     const char *name = s->name;

     if (!name) {
         const char *mime = ff_oh_mime(avctx->codec_id, avctx);
         if (!mime)
             return AVERROR_BUG;
         OH_AVCapability *cap = OH_AVCodec_GetCapabilityByCategory(mime, false, HARDWARE);
         if (!cap) {
             if (!s->allow_sw) {
                 av_log(avctx, AV_LOG_ERROR, "Failed to get hardware codec %s\n", mime);
                 return AVERROR_EXTERNAL;
             }
             av_log(avctx, AV_LOG_WARNING,
                    "Failed to get hardware codec %s, try software backend\n", mime);
             cap = OH_AVCodec_GetCapabilityByCategory(mime, false, SOFTWARE);
             if (!cap) {
                 av_log(avctx, AV_LOG_ERROR, "Failed to get software codec %s\n", mime);
                 return AVERROR_EXTERNAL;
             }
         }
         name = OH_AVCapability_GetName(cap);
         if (!name)
             return AVERROR_EXTERNAL;
     }

     s->dec = OH_VideoDecoder_CreateByName(name);
     if (!s->dec) {
         av_log(avctx, AV_LOG_ERROR, "Create decoder with name %s failed\n", name);
         return AVERROR_EXTERNAL;
     }
     av_log(avctx, AV_LOG_DEBUG, "Create decoder %s success\n", name);

     s->dec_ref = av_refstruct_alloc_ext(sizeof(*s->dec_ref), 0, NULL, oh_decode_release);
     if (!s->dec_ref) {
         oh_decode_release((AVRefStructOpaque){.nc = NULL }, &s->dec);
         s->dec = NULL;
         return AVERROR(ENOMEM);
     }
     *s->dec_ref = s->dec;

     return 0;
 }

 static int oh_decode_set_format(OHCodecDecContext *s, AVCodecContext *avctx)
 {
     int ret;
     OHNativeWindow *window = NULL;

     if (avctx->hw_device_ctx) {
         AVHWDeviceContext *device_ctx = (AVHWDeviceContext*)(avctx->hw_device_ctx->data);
         if (device_ctx->type == AV_HWDEVICE_TYPE_OHCODEC) {
             AVOHCodecDeviceContext *dev = device_ctx->hwctx;
             window = dev->native_window;
             s->output_to_window = true;
         } else {
             av_log(avctx, AV_LOG_WARNING, "Ignore invalid hw device type %s\n",
                    av_hwdevice_get_type_name(device_ctx->type));
         }
     }

     if (avctx->width <= 0 || avctx->height <= 0) {
         av_log(avctx, AV_LOG_ERROR,
                "Invalid width/height (%dx%d), width and height are mandatory for ohcodec\n",
                avctx->width, avctx->height);
         return AVERROR(EINVAL);
     }

     OH_AVFormat *format = OH_AVFormat_Create();
     if (!format)
         return AVERROR(ENOMEM);

     OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, avctx->width);
     OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, avctx->height);
     if (!s->output_to_window)
         OH_AVFormat_SetIntValue(format, OH_MD_KEY_PIXEL_FORMAT,
                                 AV_PIXEL_FORMAT_NV12);
     else
         OH_AVFormat_SetIntValue(format, OH_MD_KEY_PIXEL_FORMAT,
                                 AV_PIXEL_FORMAT_SURFACE_FORMAT);
     OH_AVErrCode err = OH_VideoDecoder_Configure(s->dec, format);
     OH_AVFormat_Destroy(format);
     if (err != AV_ERR_OK) {
         ret = ff_oh_err_to_ff_err(err);
         av_log(avctx, AV_LOG_ERROR, "Decoder configure failed, %d, %s\n",
                err, av_err2str(ret));
         return ret;
     }

     if (s->output_to_window) {
         err = OH_VideoDecoder_SetSurface(s->dec, window);
         if (err != AV_ERR_OK) {
             ret = ff_oh_err_to_ff_err(err);
             av_log(avctx, AV_LOG_ERROR, "Set surface failed, %d, %s\n",
                    err, av_err2str(ret));
             return ret;
         }
     }

     return 0;
 }

 static void oh_decode_on_err(OH_AVCodec *codec, int32_t err, void *userdata)
 {
     AVCodecContext *avctx = userdata;
     OHCodecDecContext *s = avctx->priv_data;

     // Careful on the lock order.
     // Always lock input first.
     ff_mutex_lock(&s->input_mutex);
     ff_mutex_lock(&s->output_mutex);
     s->decode_status = ff_oh_err_to_ff_err(err);
     ff_mutex_unlock(&s->output_mutex);
     ff_mutex_unlock(&s->input_mutex);

     ff_cond_signal(&s->output_cond);
     ff_cond_signal(&s->input_cond);
 }

 static void oh_decode_on_stream_changed(OH_AVCodec *codec, OH_AVFormat *format,
                                         void *userdata)
 {
     AVCodecContext *avctx = userdata;
     OHCodecDecContext *s = avctx->priv_data;
     int32_t n;
     double d;

     if (!OH_AVFormat_GetIntValue(format, OH_MD_KEY_VIDEO_PIC_WIDTH, &s->width) ||
         !OH_AVFormat_GetIntValue(format, OH_MD_KEY_VIDEO_PIC_HEIGHT, &s->height) ||
         !OH_AVFormat_GetIntValue(format, OH_MD_KEY_VIDEO_STRIDE, &s->stride) ||
         !OH_AVFormat_GetIntValue(format, OH_MD_KEY_VIDEO_SLICE_HEIGHT,
                                  &s->slice_height)) {
         av_log(avctx, AV_LOG_ERROR, "Get dimension info from format failed\n");
         goto out;
     }

     if (ff_set_dimensions(avctx, s->width, s->height) < 0)
         goto out;

     if (s->stride <= 0 || s->slice_height <= 0) {
         av_log(avctx, AV_LOG_ERROR,
                "Buffer stride (%d) or slice height (%d) is invalid\n",
                s->stride, s->slice_height);
         goto out;
     }

     if (OH_AVFormat_GetIntValue(format, OH_MD_KEY_PIXEL_FORMAT, &n)) {
         s->pix_fmt = n;
         /* When use output_to_window, the returned format is the memory
          * layout of hardware frame, not AV_PIXEL_FORMAT_SURFACE_FORMAT as
          * expected.
          */
         if (s->output_to_window)
             avctx->pix_fmt = AV_PIX_FMT_OHCODEC;
         else
             avctx->pix_fmt = ff_oh_pix_to_ff_pix(s->pix_fmt);
         // Check whether this pixel format is supported
         if (avctx->pix_fmt == AV_PIX_FMT_NONE) {
             av_log(avctx, AV_LOG_ERROR, "Unsupported OH_AVPixelFormat %d\n",
                    n);
             goto out;
         }
     } else {
         av_log(avctx, AV_LOG_ERROR, "Failed to get pixel format\n");
         goto out;
     }

     if (OH_AVFormat_GetIntValue(format,
                                 OH_MD_KEY_MATRIX_COEFFICIENTS,
                                 &n))
         avctx->colorspace = n;
     if (OH_AVFormat_GetIntValue(format,
                                 OH_MD_KEY_COLOR_PRIMARIES,
                                 &n))
         avctx->color_primaries = n;
     if (OH_AVFormat_GetIntValue(format,
                                 OH_MD_KEY_TRANSFER_CHARACTERISTICS,
                                 &n))
         avctx->color_trc = n;
     if (OH_AVFormat_GetIntValue(format,
                                 OH_MD_KEY_RANGE_FLAG,
                                 &n))
         avctx->color_range = n ? AVCOL_RANGE_JPEG : AVCOL_RANGE_MPEG;

     if (OH_AVFormat_GetDoubleValue(format, OH_MD_KEY_VIDEO_SAR, &d)) {
         AVRational sar = av_d2q(d, 4096 * 4);
         ff_set_sar(avctx, sar);
     }

     s->got_stream_info = true;

     return;
 out:
     av_log(avctx, AV_LOG_ERROR, "Invalid format from decoder: %s\n",
            OH_AVFormat_DumpInfo(format));
     oh_decode_on_err(codec, AV_ERR_UNKNOWN, userdata);
 }

 static void oh_decode_on_need_input(OH_AVCodec *codec, uint32_t index,
                                     OH_AVBuffer *buffer, void *userdata)
 {
     AVCodecContext *avctx = userdata;
     OHCodecDecContext *s = avctx->priv_data;
     OHBufferQueueItem item = {
         index, buffer,
     };

     ff_mutex_lock(&s->input_mutex);
     int ret = av_fifo_write(s->input_queue, &item, 1);
     if (ret >= 0)
         ff_cond_signal(&s->input_cond);
     ff_mutex_unlock(&s->input_mutex);

     if (ret < 0)
         oh_decode_on_err(codec, AV_ERR_NO_MEMORY, userdata);
 }

 static void oh_decode_on_output(OH_AVCodec *codec, uint32_t index,
                                 OH_AVBuffer *buffer, void *userdata)
 {
     AVCodecContext *avctx = userdata;
     OHCodecDecContext *s = avctx->priv_data;
     OHBufferQueueItem item = {
         index, buffer,
     };

     ff_mutex_lock(&s->output_mutex);
     int ret = av_fifo_write(s->output_queue, &item, 1);
     if (ret >= 0)
         ff_cond_signal(&s->output_cond);
     ff_mutex_unlock(&s->output_mutex);

     if (ret < 0)
         oh_decode_on_err(codec, AV_ERR_NO_MEMORY, userdata);
 }

 static int oh_decode_start(OHCodecDecContext *s, AVCodecContext *avctx)
 {
     int ret;
     OH_AVErrCode err;
     OH_AVCodecCallback cb = {
         .onError = oh_decode_on_err,
         .onStreamChanged = oh_decode_on_stream_changed,
         .onNeedInputBuffer = oh_decode_on_need_input,
         .onNewOutputBuffer = oh_decode_on_output,
     };

     err = OH_VideoDecoder_RegisterCallback(s->dec, cb, avctx);
     if (err != AV_ERR_OK) {
         ret = ff_oh_err_to_ff_err(err);
         av_log(avctx, AV_LOG_ERROR, "Register callback failed, %d, %s\n",
                err, av_err2str(ret));
         return ret;
     }
     err = OH_VideoDecoder_Prepare(s->dec);
     if (err != AV_ERR_OK) {
         ret = ff_oh_err_to_ff_err(err);
         av_log(avctx, AV_LOG_ERROR, "Prepare failed, %d, %s\n",
                err, av_err2str(ret));
         return ret;
     }
     err = OH_VideoDecoder_Start(s->dec);
     if (err != AV_ERR_OK) {
         ret = ff_oh_err_to_ff_err(err);
         av_log(avctx, AV_LOG_ERROR, "Start failed, %d, %s\n",
                err, av_err2str(ret));
         return ret;
     }

     return 0;
 }

 static av_cold int oh_decode_init(AVCodecContext *avctx)
 {
     OHCodecDecContext *s = avctx->priv_data;

     // Initialize these fields first, so oh_decode_close can destroy them safely
     int ret = ff_pthread_init(s, mutex_cond_offsets);
     if (ret < 0)
         return ret;

     ret = oh_decode_create(s, avctx);
     if (ret < 0)
         return ret;
     ret = oh_decode_set_format(s, avctx);
     if (ret < 0)
         return ret;

     size_t fifo_size = 16;
     s->input_queue = av_fifo_alloc2(fifo_size, sizeof(OHBufferQueueItem),
                                     AV_FIFO_FLAG_AUTO_GROW);
     s->output_queue = av_fifo_alloc2(fifo_size, sizeof(OHBufferQueueItem),
                                      AV_FIFO_FLAG_AUTO_GROW);
     if (!s->input_queue || !s->output_queue)
         return AVERROR(ENOMEM);

     ret = oh_decode_start(s, avctx);
     if (ret < 0)
         return ret;

     return 0;
 }

 static av_cold int oh_decode_close(AVCodecContext *avctx)
 {
     OHCodecDecContext *s = avctx->priv_data;

     if (s->dec) {
         /* Stop but don't destroy dec directly, to keep hardware frames on
          * the fly valid.
          */
         OH_AVErrCode err = OH_VideoDecoder_Stop(s->dec);
         if (err == AV_ERR_OK)
             av_log(avctx, AV_LOG_DEBUG, "Stop decoder success\n");
         else
             av_log(avctx, AV_LOG_ERROR, "Stop decoder failed, %d, %s\n",
                    err, av_err2str(ff_oh_err_to_ff_err(err)));
         s->dec = NULL;
         av_refstruct_unref(&s->dec_ref);
     }

     av_packet_unref(&s->pkt);

     av_fifo_freep2(&s->input_queue);

     av_fifo_freep2(&s->output_queue);

     ff_pthread_free(s, mutex_cond_offsets);

     return 0;
 }

 static void oh_buffer_release(void *opaque, uint8_t *data)
 {
     if (!opaque)
         return;

     OHCodecBuffer *buffer = opaque;

     if (buffer->buffer) {
         OH_AVCodec *dec = *buffer->dec_ref;
         OH_AVCodecBufferAttr attr;
         OH_AVErrCode err = OH_AVBuffer_GetBufferAttr(buffer->buffer, &attr);
         if (err == AV_ERR_OK && !(attr.flags & AVCODEC_BUFFER_FLAGS_DISCARD))
             OH_VideoDecoder_RenderOutputBuffer(dec, buffer->index);
         else
             OH_VideoDecoder_FreeOutputBuffer(dec, buffer->index);
     }

     av_refstruct_unref(&buffer->dec_ref);
     av_free(buffer);
 }

 static int oh_decode_wrap_hw_buffer(AVCodecContext *avctx, AVFrame *frame,
                                     OHBufferQueueItem *output,
                                     const OH_AVCodecBufferAttr *attr)
 {
     OHCodecDecContext *s = avctx->priv_data;

     frame->width = s->width;
     frame->height = s->height;
     int ret = ff_decode_frame_props(avctx, frame);
     if (ret < 0)
         return ret;

     frame->format = AV_PIX_FMT_OHCODEC;
     OHCodecBuffer *buffer = av_mallocz(sizeof(*buffer));
     if (!buffer)
         return AVERROR(ENOMEM);

     buffer->dec_ref = av_refstruct_ref(s->dec_ref);

     buffer->index = output->index;
     buffer->buffer = output->buffer;
     frame->buf[0] = av_buffer_create((uint8_t *)buffer->buffer, 1,
                                      oh_buffer_release,
                                      buffer, AV_BUFFER_FLAG_READONLY);
     if (!frame->buf[0]) {
         oh_buffer_release(buffer, NULL);
         return AVERROR(ENOMEM);
     }
     // Point to OH_AVBuffer
     frame->data[3] = frame->buf[0]->data;
     frame->pts = av_rescale_q(attr->pts, AV_TIME_BASE_Q, avctx->pkt_timebase);
     frame->pkt_dts = AV_NOPTS_VALUE;

     return 0;
 }

 static int oh_decode_wrap_sw_buffer(AVCodecContext *avctx, AVFrame *frame,
                                     OHBufferQueueItem *output,
                                     const OH_AVCodecBufferAttr *attr)
 {
     OHCodecDecContext *s = avctx->priv_data;

     frame->format = avctx->pix_fmt;
     frame->width = s->width;
     frame->height = s->height;
     int ret = ff_get_buffer(avctx, frame, 0);
     if (ret < 0)
         return ret;

     frame->pts = av_rescale_q(attr->pts, AV_TIME_BASE_Q, avctx->pkt_timebase);
     frame->pkt_dts = AV_NOPTS_VALUE;

     uint8_t *p = OH_AVBuffer_GetAddr(output->buffer);
     if (!p) {
         av_log(avctx, AV_LOG_ERROR, "Failed to get output buffer addr\n");
         return AVERROR_EXTERNAL;
     }

     uint8_t *src[4] = {0};
     int src_linesizes[4] = {0};

     ret = av_image_fill_linesizes(src_linesizes, frame->format, s->stride);
     if (ret < 0)
         return ret;
     ret = av_image_fill_pointers(src, frame->format, s->slice_height, p,
                                  src_linesizes);
     if (ret < 0)
         return ret;
     av_image_copy2(frame->data, frame->linesize, src, src_linesizes,
                    frame->format, frame->width, frame->height);

     OH_AVErrCode err = OH_VideoDecoder_FreeOutputBuffer(s->dec, output->index);
     if (err != AV_ERR_OK) {
         ret = ff_oh_err_to_ff_err(err);
         av_log(avctx, AV_LOG_ERROR, "FreeOutputBuffer failed, %d, %s\n", err,
                av_err2str(ret));
         return ret;
     }

     return 0;
 }

 static int oh_decode_output_frame(AVCodecContext *avctx, AVFrame *frame,
                                   OHBufferQueueItem *output)
 {
     OHCodecDecContext *s = avctx->priv_data;
     OH_AVCodecBufferAttr attr;

     OH_AVErrCode err = OH_AVBuffer_GetBufferAttr(output->buffer, &attr);
     if (err != AV_ERR_OK)
         return ff_oh_err_to_ff_err(err);

     if (attr.flags & AVCODEC_BUFFER_FLAGS_EOS) {
         av_log(avctx, AV_LOG_DEBUG, "Buffer flag eos\n");
         OH_VideoDecoder_FreeOutputBuffer(s->dec, output->index);
         return AVERROR_EOF;
     }

     if (!s->got_stream_info) {
         // This shouldn't happen, add a warning message.
         av_log(avctx, AV_LOG_WARNING,
                "decoder didn't notify stream info, try get format explicitly\n");

         OH_AVFormat *format = OH_VideoDecoder_GetOutputDescription(s->dec);
         if (!format) {
             av_log(avctx, AV_LOG_ERROR, "GetOutputDescription failed\n");
             return AVERROR_EXTERNAL;
         }

         oh_decode_on_stream_changed(s->dec, format, avctx);
         OH_AVFormat_Destroy(format);
         if (!s->got_stream_info)
             return AVERROR_EXTERNAL;
     }

     if (s->output_to_window)
         return oh_decode_wrap_hw_buffer(avctx, frame, output, &attr);
     return oh_decode_wrap_sw_buffer(avctx, frame, output, &attr);
 }

 static int oh_decode_send_pkt(AVCodecContext *avctx, OHBufferQueueItem *input)
 {
     OHCodecDecContext *s = avctx->priv_data;
     OH_AVErrCode err;
     int ret;

     if (!s->pkt.size && !s->eof_sent) {
         OH_AVCodecBufferAttr attr = {
             .flags = AVCODEC_BUFFER_FLAGS_EOS,
         };
         err = OH_AVBuffer_SetBufferAttr(input->buffer, &attr);
         if (err != AV_ERR_OK)
             return ff_oh_err_to_ff_err(err);
         err = OH_VideoDecoder_PushInputBuffer(s->dec, input->index);
         if (err != AV_ERR_OK)
             return ff_oh_err_to_ff_err(err);
         s->eof_sent = true;
         return 0;
     }

     uint8_t *p = OH_AVBuffer_GetAddr(input->buffer);
     int32_t n = OH_AVBuffer_GetCapacity(input->buffer);
     if (!p || n <= 0) {
         av_log(avctx, AV_LOG_ERROR,
                "Failed to get buffer addr (%p) or capacity (%d)\n",
                p, n);
         return AVERROR_EXTERNAL;
     }
     n = FFMIN(s->pkt.size, n);
     memcpy(p, s->pkt.data, n);

     OH_AVCodecBufferAttr attr = {
             .size = n,
             .offset = 0,
             .pts = av_rescale_q(s->pkt.pts, avctx->pkt_timebase,
                                 AV_TIME_BASE_Q),
             .flags = (s->pkt.flags & AV_PKT_FLAG_KEY)
                      ? AVCODEC_BUFFER_FLAGS_SYNC_FRAME : 0,
     };

     err = OH_AVBuffer_SetBufferAttr(input->buffer, &attr);
     if (err != AV_ERR_OK) {
         ret = ff_oh_err_to_ff_err(err);
         return ret;
     }
     err = OH_VideoDecoder_PushInputBuffer(s->dec, input->index);
     if (err != AV_ERR_OK) {
         ret = ff_oh_err_to_ff_err(err);
         av_log(avctx, AV_LOG_ERROR, "Push input buffer failed, %d, %s\n",
                err, av_err2str(ret));
         return ret;
     }

     if (n < s->pkt.size) {
         s->pkt.size -= n;
         s->pkt.data += n;
     } else {
         av_packet_unref(&s->pkt);
     }

     return 0;
 }

 static int oh_decode_receive_frame(AVCodecContext *avctx, AVFrame *frame)
 {
     OHCodecDecContext *s = avctx->priv_data;

     while (1) {
         OHBufferQueueItem buffer = {0};
         int ret;

         // Try get output
         ff_mutex_lock(&s->output_mutex);
         while (!s->decode_status) {
             if (av_fifo_read(s->output_queue, &buffer, 1) >= 0)
                 break;
             // Only wait after send EOF
             if (s->eof_sent && !s->decode_status)
                 ff_cond_wait(&s->output_cond, &s->output_mutex);
             else
                 break;
         }

         ret = s->decode_status;
         ff_mutex_unlock(&s->output_mutex);

         // Got a frame
         if (buffer.buffer)
             return oh_decode_output_frame(avctx, frame, &buffer);
         if (ret < 0)
             return ret;

         if (!s->pkt.size) {
             /* fetch new packet or eof */
             ret = ff_decode_get_packet(avctx, &s->pkt);
             if (ret < 0 && ret != AVERROR_EOF)
                 return ret;
         }

         // Wait input buffer
         ff_mutex_lock(&s->input_mutex);
         while (!s->decode_status) {
             if (av_fifo_read(s->input_queue, &buffer, 1) >= 0)
                 break;
             ff_cond_wait(&s->input_cond, &s->input_mutex);
         }

         ret = s->decode_status;
         ff_mutex_unlock(&s->input_mutex);

         if (ret < 0)
             return ret;

         ret = oh_decode_send_pkt(avctx, &buffer);
         if (ret < 0)
             return ret;
     }

     return AVERROR(EAGAIN);
 }

 static void oh_decode_flush(AVCodecContext *avctx)
 {
     OHCodecDecContext *s = avctx->priv_data;

     OH_VideoDecoder_Flush(s->dec);

     ff_mutex_lock(&s->input_mutex);
     ff_mutex_lock(&s->output_mutex);
     av_fifo_reset2(s->input_queue);
     av_fifo_reset2(s->output_queue);
     s->decode_status = 0;
     s->eof_sent = false;
     ff_mutex_unlock(&s->output_mutex);
     ff_mutex_unlock(&s->input_mutex);

     OH_VideoDecoder_Start(s->dec);
 }

 static const AVCodecHWConfigInternal *const oh_hw_configs[] = {
     &(const AVCodecHWConfigInternal) {
         .public = {
             .pix_fmt = AV_PIX_FMT_OHCODEC,
             .methods = AV_CODEC_HW_CONFIG_METHOD_AD_HOC |
                        AV_CODEC_HW_CONFIG_METHOD_HW_DEVICE_CTX,
             .device_type = AV_HWDEVICE_TYPE_OHCODEC,
         },
         .hwaccel = NULL,
     },
     NULL
 };

 #define VD (AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_DECODING_PARAM)
 static const AVOption ohcodec_vdec_options[] = {
     {"codec_name", "Select codec by name",
          OFFSET(name), AV_OPT_TYPE_STRING, .flags = VD},
     {"allow_sw", "Allow software decoding",
          OFFSET(allow_sw), AV_OPT_TYPE_BOOL, {.i64 = 0}, 0, 1, VD},
     {NULL}
 };

 #define DECLARE_OHCODEC_VCLASS(short_name)                                     \
   static const AVClass short_name##_oh_dec_class = {                           \
       .class_name = #short_name "_ohcodec",                                    \
       .item_name = av_default_item_name,                                       \
       .option = ohcodec_vdec_options,                                          \
       .version = LIBAVUTIL_VERSION_INT,                                        \
   };

 #define DECLARE_OHCODEC_VDEC(short_name, full_name, codec_id, bsf)             \
   DECLARE_OHCODEC_VCLASS(short_name)                                           \
   const FFCodec ff_##short_name##_oh_decoder = {                               \
       .p.name = #short_name "_ohcodec",                                        \
       CODEC_LONG_NAME(full_name " OpenHarmony Codec"),                         \
       .p.type = AVMEDIA_TYPE_VIDEO,                                            \
       .p.id = codec_id,                                                        \
       .p.priv_class = &short_name##_oh_dec_class,                              \
       .priv_data_size = sizeof(OHCodecDecContext),                             \
       .init = oh_decode_init,                                                  \
       FF_CODEC_RECEIVE_FRAME_CB(oh_decode_receive_frame),                      \
       .flush = oh_decode_flush,                                                \
       .close = oh_decode_close,                                                \
       .p.capabilities = AV_CODEC_CAP_DELAY | AV_CODEC_CAP_AVOID_PROBING |      \
                         AV_CODEC_CAP_HARDWARE,                                 \
       .caps_internal = FF_CODEC_CAP_INIT_CLEANUP,                              \
       .bsfs = bsf,                                                             \
       .hw_configs = oh_hw_configs,                                             \
       .p.wrapper_name = "ohcodec",                                             \
   };

 #if CONFIG_H264_OH_DECODER
 DECLARE_OHCODEC_VDEC(h264, "H.264", AV_CODEC_ID_H264, "h264_mp4toannexb")
 #endif

 #if CONFIG_HEVC_OH_DECODER
 DECLARE_OHCODEC_VDEC(hevc, "H.265", AV_CODEC_ID_HEVC, "hevc_mp4toannexb")
 #endif
	/*
	* This file is part of FFmpeg.
	*
	* Copyright (c) 2025 Zhao Zhili <quinkblack@foxmail.com>
	*
	* FFmpeg is free software; you can redistribute it and/or
	* modify it under the terms of the GNU Lesser General Public
	* License as published by the Free Software Foundation; either
	* version 2.1 of the License, or (at your option) any later version.
	*
	* FFmpeg is distributed in the hope that it will be useful,
	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	* Lesser General Public License for more details.
	*
	* You should have received a copy of the GNU Lesser General Public
	* License along with FFmpeg; if not, write to the Free Software
	* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
	*/

	#include "config_components.h"

	#include <stdbool.h>
	#include <multimedia/player_framework/native_avcapability.h>
	#include <multimedia/player_framework/native_avcodec_videodecoder.h>

	#include "libavutil/fifo.h"
	#include "libavutil/hwcontext_oh.h"
	#include "libavutil/imgutils.h"
	#include "libavutil/mem.h"
	#include "libavutil/opt.h"
	#include "libavutil/refstruct.h"
	#include "libavutil/thread.h"

	#include "avcodec.h"
	#include "codec_internal.h"
	#include "decode.h"
	#include "hwconfig.h"
	#include "ohcodec.h"
	#include "pthread_internal.h"

	typedef struct OHCodecDecContext {
	AVClass *avclass;
	OH_AVCodec *dec;
	/* A RefStruct reference backing dec. Each hardware frame has a reference count to
	* dec. dec will be destroyed only after oh_decode_close and all hardware
	* frames have been released.
	*/
	OH_AVCodec **dec_ref;

	AVMutex input_mutex;
	AVCond input_cond;
	AVFifo *input_queue;

	AVMutex output_mutex;
	AVCond output_cond;
	AVFifo *output_queue;

	AVPacket pkt;

	int decode_status;
	bool eof_sent;

	bool output_to_window;
	bool got_stream_info;
	int width;
	int height;
	int stride;
	int slice_height;
	OH_AVPixelFormat pix_fmt;

	char *name;
	int allow_sw;
	unsigned mutex_cond_cnt;
	} OHCodecDecContext;

	#define OFFSET(x) offsetof(OHCodecDecContext, x)
	DEFINE_OFFSET_ARRAY(OHCodecDecContext, mutex_cond, mutex_cond_cnt,
	(OFFSET(input_mutex), OFFSET(output_mutex)),
	(OFFSET(input_cond), OFFSET(output_cond)));

	typedef struct OHCodecBuffer {
	uint32_t index;
	OH_AVBuffer *buffer;
	OH_AVCodec **dec_ref; ///< RefStruct reference
	} OHCodecBuffer;

	static void oh_decode_release(AVRefStructOpaque unused, void *obj)
	{
	OH_AVCodec **decp = obj;
	OH_AVErrCode err = OH_VideoDecoder_Destroy(*decp);
	if (err == AV_ERR_OK)
	av_log(NULL, AV_LOG_DEBUG, "Destroy decoder success\n");
	else
	av_log(NULL, AV_LOG_ERROR, "Destroy decoder failed, %d, %s\n",
	err, av_err2str(ff_oh_err_to_ff_err(err)));
	}

	static int oh_decode_create(OHCodecDecContext s, AVCodecContext avctx)
	{
	const char *name = s->name;

	if (!name) {
	const char *mime = ff_oh_mime(avctx->codec_id, avctx);
	if (!mime)
	return AVERROR_BUG;
	OH_AVCapability *cap = OH_AVCodec_GetCapabilityByCategory(mime, false, HARDWARE);
	if (!cap) {
	if (!s->allow_sw) {
	av_log(avctx, AV_LOG_ERROR, "Failed to get hardware codec %s\n", mime);
	return AVERROR_EXTERNAL;
	}
	av_log(avctx, AV_LOG_WARNING,
	"Failed to get hardware codec %s, try software backend\n", mime);
	cap = OH_AVCodec_GetCapabilityByCategory(mime, false, SOFTWARE);
	if (!cap) {
	av_log(avctx, AV_LOG_ERROR, "Failed to get software codec %s\n", mime);
	return AVERROR_EXTERNAL;
	}
	}
	name = OH_AVCapability_GetName(cap);
	if (!name)
	return AVERROR_EXTERNAL;
	}

	s->dec = OH_VideoDecoder_CreateByName(name);
	if (!s->dec) {
	av_log(avctx, AV_LOG_ERROR, "Create decoder with name %s failed\n", name);
	return AVERROR_EXTERNAL;
	}
	av_log(avctx, AV_LOG_DEBUG, "Create decoder %s success\n", name);

	s->dec_ref = av_refstruct_alloc_ext(sizeof(*s->dec_ref), 0, NULL, oh_decode_release);
	if (!s->dec_ref) {
	oh_decode_release((AVRefStructOpaque){.nc = NULL }, &s->dec);
	s->dec = NULL;
	return AVERROR(ENOMEM);
	}
	*s->dec_ref = s->dec;

	return 0;
	}

	static int oh_decode_set_format(OHCodecDecContext s, AVCodecContext avctx)
	{
	int ret;
	OHNativeWindow *window = NULL;

	if (avctx->hw_device_ctx) {
	AVHWDeviceContext device_ctx = (AVHWDeviceContext)(avctx->hw_device_ctx->data);
	if (device_ctx->type == AV_HWDEVICE_TYPE_OHCODEC) {
	AVOHCodecDeviceContext *dev = device_ctx->hwctx;
	window = dev->native_window;
	s->output_to_window = true;
	} else {
	av_log(avctx, AV_LOG_WARNING, "Ignore invalid hw device type %s\n",
	av_hwdevice_get_type_name(device_ctx->type));
	}
	}

	if (avctx->width <= 0 \|\| avctx->height <= 0) {
	av_log(avctx, AV_LOG_ERROR,
	"Invalid width/height (%dx%d), width and height are mandatory for ohcodec\n",
	avctx->width, avctx->height);
	return AVERROR(EINVAL);
	}

	OH_AVFormat *format = OH_AVFormat_Create();
	if (!format)
	return AVERROR(ENOMEM);

	OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, avctx->width);
	OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, avctx->height);
	if (!s->output_to_window)
	OH_AVFormat_SetIntValue(format, OH_MD_KEY_PIXEL_FORMAT,
	AV_PIXEL_FORMAT_NV12);
	else
	OH_AVFormat_SetIntValue(format, OH_MD_KEY_PIXEL_FORMAT,
	AV_PIXEL_FORMAT_SURFACE_FORMAT);
	OH_AVErrCode err = OH_VideoDecoder_Configure(s->dec, format);
	OH_AVFormat_Destroy(format);
	if (err != AV_ERR_OK) {
	ret = ff_oh_err_to_ff_err(err);
	av_log(avctx, AV_LOG_ERROR, "Decoder configure failed, %d, %s\n",
	err, av_err2str(ret));
	return ret;
	}

	if (s->output_to_window) {
	err = OH_VideoDecoder_SetSurface(s->dec, window);
	if (err != AV_ERR_OK) {
	ret = ff_oh_err_to_ff_err(err);
	av_log(avctx, AV_LOG_ERROR, "Set surface failed, %d, %s\n",
	err, av_err2str(ret));
	return ret;
	}
	}

	return 0;
	}

	static void oh_decode_on_err(OH_AVCodec codec, int32_t err, void userdata)
	{
	AVCodecContext *avctx = userdata;
	OHCodecDecContext *s = avctx->priv_data;

	// Careful on the lock order.
	// Always lock input first.
	ff_mutex_lock(&s->input_mutex);
	ff_mutex_lock(&s->output_mutex);
	s->decode_status = ff_oh_err_to_ff_err(err);
	ff_mutex_unlock(&s->output_mutex);
	ff_mutex_unlock(&s->input_mutex);

	ff_cond_signal(&s->output_cond);
	ff_cond_signal(&s->input_cond);
	}

	static void oh_decode_on_stream_changed(OH_AVCodec codec, OH_AVFormat format,
	void *userdata)
	{
	AVCodecContext *avctx = userdata;
	OHCodecDecContext *s = avctx->priv_data;
	int32_t n;
	double d;

	if (!OH_AVFormat_GetIntValue(format, OH_MD_KEY_VIDEO_PIC_WIDTH, &s->width) \|\|
	!OH_AVFormat_GetIntValue(format, OH_MD_KEY_VIDEO_PIC_HEIGHT, &s->height) \|\|
	!OH_AVFormat_GetIntValue(format, OH_MD_KEY_VIDEO_STRIDE, &s->stride) \|\|
	!OH_AVFormat_GetIntValue(format, OH_MD_KEY_VIDEO_SLICE_HEIGHT,
	&s->slice_height)) {
	av_log(avctx, AV_LOG_ERROR, "Get dimension info from format failed\n");
	goto out;
	}

	if (ff_set_dimensions(avctx, s->width, s->height) < 0)
	goto out;

	if (s->stride <= 0 \|\| s->slice_height <= 0) {
	av_log(avctx, AV_LOG_ERROR,
	"Buffer stride (%d) or slice height (%d) is invalid\n",
	s->stride, s->slice_height);
	goto out;
	}

	if (OH_AVFormat_GetIntValue(format, OH_MD_KEY_PIXEL_FORMAT, &n)) {
	s->pix_fmt = n;
	/* When use output_to_window, the returned format is the memory
	* layout of hardware frame, not AV_PIXEL_FORMAT_SURFACE_FORMAT as
	* expected.
	*/
	if (s->output_to_window)
	avctx->pix_fmt = AV_PIX_FMT_OHCODEC;
	else
	avctx->pix_fmt = ff_oh_pix_to_ff_pix(s->pix_fmt);
	// Check whether this pixel format is supported
	if (avctx->pix_fmt == AV_PIX_FMT_NONE) {
	av_log(avctx, AV_LOG_ERROR, "Unsupported OH_AVPixelFormat %d\n",
	n);
	goto out;
	}
	} else {
	av_log(avctx, AV_LOG_ERROR, "Failed to get pixel format\n");
	goto out;
	}

	if (OH_AVFormat_GetIntValue(format,
	OH_MD_KEY_MATRIX_COEFFICIENTS,
	&n))
	avctx->colorspace = n;
	if (OH_AVFormat_GetIntValue(format,
	OH_MD_KEY_COLOR_PRIMARIES,
	&n))
	avctx->color_primaries = n;
	if (OH_AVFormat_GetIntValue(format,
	OH_MD_KEY_TRANSFER_CHARACTERISTICS,
	&n))
	avctx->color_trc = n;
	if (OH_AVFormat_GetIntValue(format,
	OH_MD_KEY_RANGE_FLAG,
	&n))
	avctx->color_range = n ? AVCOL_RANGE_JPEG : AVCOL_RANGE_MPEG;

	if (OH_AVFormat_GetDoubleValue(format, OH_MD_KEY_VIDEO_SAR, &d)) {
	AVRational sar = av_d2q(d, 4096 * 4);
	ff_set_sar(avctx, sar);
	}

	s->got_stream_info = true;

	return;
	out:
	av_log(avctx, AV_LOG_ERROR, "Invalid format from decoder: %s\n",
	OH_AVFormat_DumpInfo(format));
	oh_decode_on_err(codec, AV_ERR_UNKNOWN, userdata);
	}

	static void oh_decode_on_need_input(OH_AVCodec *codec, uint32_t index,
	OH_AVBuffer buffer, void userdata)
	{
	AVCodecContext *avctx = userdata;
	OHCodecDecContext *s = avctx->priv_data;
	OHBufferQueueItem item = {
	index, buffer,
	};

	ff_mutex_lock(&s->input_mutex);
	int ret = av_fifo_write(s->input_queue, &item, 1);
	if (ret >= 0)
	ff_cond_signal(&s->input_cond);
	ff_mutex_unlock(&s->input_mutex);

	if (ret < 0)
	oh_decode_on_err(codec, AV_ERR_NO_MEMORY, userdata);
	}

	static void oh_decode_on_output(OH_AVCodec *codec, uint32_t index,
	OH_AVBuffer buffer, void userdata)
	{
	AVCodecContext *avctx = userdata;
	OHCodecDecContext *s = avctx->priv_data;
	OHBufferQueueItem item = {
	index, buffer,
	};

	ff_mutex_lock(&s->output_mutex);
	int ret = av_fifo_write(s->output_queue, &item, 1);
	if (ret >= 0)
	ff_cond_signal(&s->output_cond);
	ff_mutex_unlock(&s->output_mutex);

	if (ret < 0)
	oh_decode_on_err(codec, AV_ERR_NO_MEMORY, userdata);
	}

	static int oh_decode_start(OHCodecDecContext s, AVCodecContext avctx)
	{
	int ret;
	OH_AVErrCode err;
	OH_AVCodecCallback cb = {
	.onError = oh_decode_on_err,
	.onStreamChanged = oh_decode_on_stream_changed,
	.onNeedInputBuffer = oh_decode_on_need_input,
	.onNewOutputBuffer = oh_decode_on_output,
	};

	err = OH_VideoDecoder_RegisterCallback(s->dec, cb, avctx);
	if (err != AV_ERR_OK) {
	ret = ff_oh_err_to_ff_err(err);
	av_log(avctx, AV_LOG_ERROR, "Register callback failed, %d, %s\n",
	err, av_err2str(ret));
	return ret;
	}
	err = OH_VideoDecoder_Prepare(s->dec);
	if (err != AV_ERR_OK) {
	ret = ff_oh_err_to_ff_err(err);
	av_log(avctx, AV_LOG_ERROR, "Prepare failed, %d, %s\n",
	err, av_err2str(ret));
	return ret;
	}
	err = OH_VideoDecoder_Start(s->dec);
	if (err != AV_ERR_OK) {
	ret = ff_oh_err_to_ff_err(err);
	av_log(avctx, AV_LOG_ERROR, "Start failed, %d, %s\n",
	err, av_err2str(ret));
	return ret;
	}

	return 0;
	}

	static av_cold int oh_decode_init(AVCodecContext *avctx)
	{
	OHCodecDecContext *s = avctx->priv_data;

	// Initialize these fields first, so oh_decode_close can destroy them safely
	int ret = ff_pthread_init(s, mutex_cond_offsets);
	if (ret < 0)
	return ret;

	ret = oh_decode_create(s, avctx);
	if (ret < 0)
	return ret;
	ret = oh_decode_set_format(s, avctx);
	if (ret < 0)
	return ret;

	size_t fifo_size = 16;
	s->input_queue = av_fifo_alloc2(fifo_size, sizeof(OHBufferQueueItem),
	AV_FIFO_FLAG_AUTO_GROW);
	s->output_queue = av_fifo_alloc2(fifo_size, sizeof(OHBufferQueueItem),
	AV_FIFO_FLAG_AUTO_GROW);
	if (!s->input_queue \|\| !s->output_queue)
	return AVERROR(ENOMEM);

	ret = oh_decode_start(s, avctx);
	if (ret < 0)
	return ret;

	return 0;
	}

	static av_cold int oh_decode_close(AVCodecContext *avctx)
	{
	OHCodecDecContext *s = avctx->priv_data;

	if (s->dec) {
	/* Stop but don't destroy dec directly, to keep hardware frames on
	* the fly valid.
	*/
	OH_AVErrCode err = OH_VideoDecoder_Stop(s->dec);
	if (err == AV_ERR_OK)
	av_log(avctx, AV_LOG_DEBUG, "Stop decoder success\n");
	else
	av_log(avctx, AV_LOG_ERROR, "Stop decoder failed, %d, %s\n",
	err, av_err2str(ff_oh_err_to_ff_err(err)));
	s->dec = NULL;
	av_refstruct_unref(&s->dec_ref);
	}

	av_packet_unref(&s->pkt);

	av_fifo_freep2(&s->input_queue);

	av_fifo_freep2(&s->output_queue);

	ff_pthread_free(s, mutex_cond_offsets);

	return 0;
	}

	static void oh_buffer_release(void opaque, uint8_t data)
	{
	if (!opaque)
	return;

	OHCodecBuffer *buffer = opaque;

	if (buffer->buffer) {
	OH_AVCodec dec = buffer->dec_ref;
	OH_AVCodecBufferAttr attr;
	OH_AVErrCode err = OH_AVBuffer_GetBufferAttr(buffer->buffer, &attr);
	if (err == AV_ERR_OK && !(attr.flags & AVCODEC_BUFFER_FLAGS_DISCARD))
	OH_VideoDecoder_RenderOutputBuffer(dec, buffer->index);
	else
	OH_VideoDecoder_FreeOutputBuffer(dec, buffer->index);
	}

	av_refstruct_unref(&buffer->dec_ref);
	av_free(buffer);
	}

	static int oh_decode_wrap_hw_buffer(AVCodecContext avctx, AVFrame frame,
	OHBufferQueueItem *output,
	const OH_AVCodecBufferAttr *attr)
	{
	OHCodecDecContext *s = avctx->priv_data;

	frame->width = s->width;
	frame->height = s->height;
	int ret = ff_decode_frame_props(avctx, frame);
	if (ret < 0)
	return ret;

	frame->format = AV_PIX_FMT_OHCODEC;
	OHCodecBuffer buffer = av_mallocz(sizeof(buffer));
	if (!buffer)
	return AVERROR(ENOMEM);

	buffer->dec_ref = av_refstruct_ref(s->dec_ref);

	buffer->index = output->index;
	buffer->buffer = output->buffer;
	frame->buf[0] = av_buffer_create((uint8_t *)buffer->buffer, 1,
	oh_buffer_release,
	buffer, AV_BUFFER_FLAG_READONLY);
	if (!frame->buf[0]) {
	oh_buffer_release(buffer, NULL);
	return AVERROR(ENOMEM);
	}
	// Point to OH_AVBuffer
	frame->data[3] = frame->buf[0]->data;
	frame->pts = av_rescale_q(attr->pts, AV_TIME_BASE_Q, avctx->pkt_timebase);
	frame->pkt_dts = AV_NOPTS_VALUE;

	return 0;
	}

	static int oh_decode_wrap_sw_buffer(AVCodecContext avctx, AVFrame frame,
	OHBufferQueueItem *output,
	const OH_AVCodecBufferAttr *attr)
	{
	OHCodecDecContext *s = avctx->priv_data;

	frame->format = avctx->pix_fmt;
	frame->width = s->width;
	frame->height = s->height;
	int ret = ff_get_buffer(avctx, frame, 0);
	if (ret < 0)
	return ret;

	frame->pts = av_rescale_q(attr->pts, AV_TIME_BASE_Q, avctx->pkt_timebase);
	frame->pkt_dts = AV_NOPTS_VALUE;

	uint8_t *p = OH_AVBuffer_GetAddr(output->buffer);
	if (!p) {
	av_log(avctx, AV_LOG_ERROR, "Failed to get output buffer addr\n");
	return AVERROR_EXTERNAL;
	}

	uint8_t *src[4] = {0};
	int src_linesizes[4] = {0};

	ret = av_image_fill_linesizes(src_linesizes, frame->format, s->stride);
	if (ret < 0)
	return ret;
	ret = av_image_fill_pointers(src, frame->format, s->slice_height, p,
	src_linesizes);
	if (ret < 0)
	return ret;
	av_image_copy2(frame->data, frame->linesize, src, src_linesizes,
	frame->format, frame->width, frame->height);

	OH_AVErrCode err = OH_VideoDecoder_FreeOutputBuffer(s->dec, output->index);
	if (err != AV_ERR_OK) {
	ret = ff_oh_err_to_ff_err(err);
	av_log(avctx, AV_LOG_ERROR, "FreeOutputBuffer failed, %d, %s\n", err,
	av_err2str(ret));
	return ret;
	}

	return 0;
	}

	static int oh_decode_output_frame(AVCodecContext avctx, AVFrame frame,
	OHBufferQueueItem *output)
	{
	OHCodecDecContext *s = avctx->priv_data;
	OH_AVCodecBufferAttr attr;

	OH_AVErrCode err = OH_AVBuffer_GetBufferAttr(output->buffer, &attr);
	if (err != AV_ERR_OK)
	return ff_oh_err_to_ff_err(err);

	if (attr.flags & AVCODEC_BUFFER_FLAGS_EOS) {
	av_log(avctx, AV_LOG_DEBUG, "Buffer flag eos\n");
	OH_VideoDecoder_FreeOutputBuffer(s->dec, output->index);
	return AVERROR_EOF;
	}

	if (!s->got_stream_info) {
	// This shouldn't happen, add a warning message.
	av_log(avctx, AV_LOG_WARNING,
	"decoder didn't notify stream info, try get format explicitly\n");

	OH_AVFormat *format = OH_VideoDecoder_GetOutputDescription(s->dec);
	if (!format) {
	av_log(avctx, AV_LOG_ERROR, "GetOutputDescription failed\n");
	return AVERROR_EXTERNAL;
	}

	oh_decode_on_stream_changed(s->dec, format, avctx);
	OH_AVFormat_Destroy(format);
	if (!s->got_stream_info)
	return AVERROR_EXTERNAL;
	}

	if (s->output_to_window)
	return oh_decode_wrap_hw_buffer(avctx, frame, output, &attr);
	return oh_decode_wrap_sw_buffer(avctx, frame, output, &attr);
	}

	static int oh_decode_send_pkt(AVCodecContext avctx, OHBufferQueueItem input)
	{
	OHCodecDecContext *s = avctx->priv_data;
	OH_AVErrCode err;
	int ret;

	if (!s->pkt.size && !s->eof_sent) {
	OH_AVCodecBufferAttr attr = {
	.flags = AVCODEC_BUFFER_FLAGS_EOS,
	};
	err = OH_AVBuffer_SetBufferAttr(input->buffer, &attr);
	if (err != AV_ERR_OK)
	return ff_oh_err_to_ff_err(err);
	err = OH_VideoDecoder_PushInputBuffer(s->dec, input->index);
	if (err != AV_ERR_OK)
	return ff_oh_err_to_ff_err(err);
	s->eof_sent = true;
	return 0;
	}

	uint8_t *p = OH_AVBuffer_GetAddr(input->buffer);
	int32_t n = OH_AVBuffer_GetCapacity(input->buffer);
	if (!p \|\| n <= 0) {
	av_log(avctx, AV_LOG_ERROR,
	"Failed to get buffer addr (%p) or capacity (%d)\n",
	p, n);
	return AVERROR_EXTERNAL;
	}
	n = FFMIN(s->pkt.size, n);
	memcpy(p, s->pkt.data, n);

	OH_AVCodecBufferAttr attr = {
	.size = n,
	.offset = 0,
	.pts = av_rescale_q(s->pkt.pts, avctx->pkt_timebase,
	AV_TIME_BASE_Q),
	.flags = (s->pkt.flags & AV_PKT_FLAG_KEY)
	? AVCODEC_BUFFER_FLAGS_SYNC_FRAME : 0,
	};

	err = OH_AVBuffer_SetBufferAttr(input->buffer, &attr);
	if (err != AV_ERR_OK) {
	ret = ff_oh_err_to_ff_err(err);
	return ret;
	}
	err = OH_VideoDecoder_PushInputBuffer(s->dec, input->index);
	if (err != AV_ERR_OK) {
	ret = ff_oh_err_to_ff_err(err);
	av_log(avctx, AV_LOG_ERROR, "Push input buffer failed, %d, %s\n",
	err, av_err2str(ret));
	return ret;
	}

	if (n < s->pkt.size) {
	s->pkt.size -= n;
	s->pkt.data += n;
	} else {
	av_packet_unref(&s->pkt);
	}

	return 0;
	}

	static int oh_decode_receive_frame(AVCodecContext avctx, AVFrame frame)
	{
	OHCodecDecContext *s = avctx->priv_data;

	while (1) {
	OHBufferQueueItem buffer = {0};
	int ret;

	// Try get output
	ff_mutex_lock(&s->output_mutex);
	while (!s->decode_status) {
	if (av_fifo_read(s->output_queue, &buffer, 1) >= 0)
	break;
	// Only wait after send EOF
	if (s->eof_sent && !s->decode_status)
	ff_cond_wait(&s->output_cond, &s->output_mutex);
	else
	break;
	}

	ret = s->decode_status;
	ff_mutex_unlock(&s->output_mutex);

	// Got a frame
	if (buffer.buffer)
	return oh_decode_output_frame(avctx, frame, &buffer);
	if (ret < 0)
	return ret;

	if (!s->pkt.size) {
	/* fetch new packet or eof */
	ret = ff_decode_get_packet(avctx, &s->pkt);
	if (ret < 0 && ret != AVERROR_EOF)
	return ret;
	}

	// Wait input buffer
	ff_mutex_lock(&s->input_mutex);
	while (!s->decode_status) {
	if (av_fifo_read(s->input_queue, &buffer, 1) >= 0)
	break;
	ff_cond_wait(&s->input_cond, &s->input_mutex);
	}

	ret = s->decode_status;
	ff_mutex_unlock(&s->input_mutex);

	if (ret < 0)
	return ret;

	ret = oh_decode_send_pkt(avctx, &buffer);
	if (ret < 0)
	return ret;
	}

	return AVERROR(EAGAIN);
	}

	static void oh_decode_flush(AVCodecContext *avctx)
	{
	OHCodecDecContext *s = avctx->priv_data;

	OH_VideoDecoder_Flush(s->dec);

	ff_mutex_lock(&s->input_mutex);
	ff_mutex_lock(&s->output_mutex);
	av_fifo_reset2(s->input_queue);
	av_fifo_reset2(s->output_queue);
	s->decode_status = 0;
	s->eof_sent = false;
	ff_mutex_unlock(&s->output_mutex);
	ff_mutex_unlock(&s->input_mutex);

	OH_VideoDecoder_Start(s->dec);
	}

	static const AVCodecHWConfigInternal *const oh_hw_configs[] = {
	&(const AVCodecHWConfigInternal) {
	.public = {
	.pix_fmt = AV_PIX_FMT_OHCODEC,
	.methods = AV_CODEC_HW_CONFIG_METHOD_AD_HOC \|
	AV_CODEC_HW_CONFIG_METHOD_HW_DEVICE_CTX,
	.device_type = AV_HWDEVICE_TYPE_OHCODEC,
	},
	.hwaccel = NULL,
	},
	NULL
	};

	#define VD (AV_OPT_FLAG_VIDEO_PARAM \| AV_OPT_FLAG_DECODING_PARAM)
	static const AVOption ohcodec_vdec_options[] = {
	{"codec_name", "Select codec by name",
	OFFSET(name), AV_OPT_TYPE_STRING, .flags = VD},
	{"allow_sw", "Allow software decoding",
	OFFSET(allow_sw), AV_OPT_TYPE_BOOL, {.i64 = 0}, 0, 1, VD},
	{NULL}
	};

	#define DECLARE_OHCODEC_VCLASS(short_name) \
	static const AVClass short_name##_oh_dec_class = { \
	.class_name = #short_name "_ohcodec", \
	.item_name = av_default_item_name, \
	.option = ohcodec_vdec_options, \
	.version = LIBAVUTIL_VERSION_INT, \
	};

	#define DECLARE_OHCODEC_VDEC(short_name, full_name, codec_id, bsf) \
	DECLARE_OHCODEC_VCLASS(short_name) \
	const FFCodec ff_##short_name##_oh_decoder = { \
	.p.name = #short_name "_ohcodec", \
	CODEC_LONG_NAME(full_name " OpenHarmony Codec"), \
	.p.type = AVMEDIA_TYPE_VIDEO, \
	.p.id = codec_id, \
	.p.priv_class = &short_name##_oh_dec_class, \
	.priv_data_size = sizeof(OHCodecDecContext), \
	.init = oh_decode_init, \
	FF_CODEC_RECEIVE_FRAME_CB(oh_decode_receive_frame), \
	.flush = oh_decode_flush, \
	.close = oh_decode_close, \
	.p.capabilities = AV_CODEC_CAP_DELAY \| AV_CODEC_CAP_AVOID_PROBING \| \
	AV_CODEC_CAP_HARDWARE, \
	.caps_internal = FF_CODEC_CAP_INIT_CLEANUP, \
	.bsfs = bsf, \
	.hw_configs = oh_hw_configs, \
	.p.wrapper_name = "ohcodec", \
	};

	#if CONFIG_H264_OH_DECODER
	DECLARE_OHCODEC_VDEC(h264, "H.264", AV_CODEC_ID_H264, "h264_mp4toannexb")
	#endif

	#if CONFIG_HEVC_OH_DECODER
	DECLARE_OHCODEC_VDEC(hevc, "H.265", AV_CODEC_ID_HEVC, "hevc_mp4toannexb")
	#endif