3559板子使用HI_MPI_VENC_GetStream 保存至文件，却无法播放

```cpp
void Hi3559VideoPipeline::vencStreamThread()
{
LOG_INFO(“VENC”, “begin to push stream”);

VENC_STREAM_S      stStream{};        // 编码输出
VENC_CHN_STATUS_S  stStat{};          // 编码状态
const HI_S32       TIMEOUT_MS = 200;  // GetStream 超时
VENC_RECV_PIC_PARAM_S stRecvParam{};
stRecvParam.s32RecvPicNum = -1;

HI_S32 ret = HI_MPI_VENC_StartRecvFrame(cfg_.venc_chn, &stRecvParam);
if (ret != HI_SUCCESS) {
    LOG_ERROR("VENC", "StartRecvFrame fail=0x" << std::hex << ret);
}
ret = HI_MPI_VENC_RequestIDR(cfg_.venc_chn, HI_TRUE);
if (ret != HI_SUCCESS) {
    LOG_ERROR("VENC", "RequestIDR fail=0x" << std::hex << ret);
}

FILE *fp = fopen("out.h264", "wb");
if (!fp) {
    LOG_ERROR("VENC", "open out.h264 failed");
}

bool have_seen_idr   = false;

while (streaming_started.load(std::memory_order_relaxed)) {
    ret = HI_MPI_VENC_QueryStatus(cfg_.venc_chn, &stStat);
    if (ret != HI_SUCCESS) {
        LOG_ERROR("VENC", "QueryStatus fail=0x" << std::hex << ret);
        std::this_thread::sleep_for(std::chrono::milliseconds(1));
        continue;
    }

    // 仅根据 u32CurPacks 判断是否有包可取
    if (stStat.u32CurPacks == 0) {
        std::this_thread::sleep_for(std::chrono::milliseconds(1));
        continue;
    }

    // 分配 pack 数组（容量 = 当前可取包数）
    stStream.u32PackCount = stStat.u32CurPacks;
    stStream.pstPack = (VENC_PACK_S*)malloc(sizeof(VENC_PACK_S) * stStream.u32PackCount);
    if (!stStream.pstPack) {
        LOG_ERROR("VENC", "malloc pstPack failed, count=" << stStream.u32PackCount);
        std::this_thread::sleep_for(std::chrono::milliseconds(1));
        continue;
    }

    ret = HI_MPI_VENC_GetStream(cfg_.venc_chn, &stStream, TIMEOUT_MS);
    if (ret != HI_SUCCESS) {
        // 超时或暂无数据
        free(stStream.pstPack);
        stStream.pstPack = nullptr;
        if (ret != HI_ERR_VENC_BUSY && ret != HI_ERR_VENC_NOBUF) {
            LOG_ERROR("VENC", "GetStream fail=0x" << std::hex << ret);
        }
        continue;
    }

    // 仅当见到首个 IDR 后才开始写文件，避免前面缺参考的 P 帧
    if (!have_seen_idr) {
        for (HI_U32 i = 0; i < stStream.u32PackCount && !have_seen_idr; ++i) {
            const VENC_PACK_S &pk = stStream.pstPack[i];
            if (pk.u32Len <= pk.u32Offset) continue;

            const uint8_t* p = pk.pu8Addr + pk.u32Offset;
            size_t n = (size_t)(pk.u32Len - pk.u32Offset);

            // 简易 NAL 扫描：找 00 00 01 / 00 00 00 01 + nal_unit_type==5
            for (size_t j = 0; j + 4 < n; ++j) {
                bool sc3 = (p[j]==0 && p[j+1]==0 && p[j+2]==1);
                bool sc4 = (j+3<n && p[j]==0 && p[j+1]==0 && p[j+2]==0 && p[j+3]==1);
                if (!sc3 && !sc4) continue;

                size_t k = sc3 ? (j+3) : (j+4);
                if (k < n) {
                    uint8_t nal = p[k] & 0x1F;
                    if (nal == 5) { have_seen_idr = true; break; }
                }
            }
        }
    }

    if (have_seen_idr && fp) {
        dump_stream_to_file(stStream, fp);
    }

    // 这里做你的 RTSP 发送/网络推流（务必在 ReleaseStream 前消费完 stStream 数据）

    ret = HI_MPI_VENC_ReleaseStream(cfg_.venc_chn, &stStream);
    if (ret != HI_SUCCESS) {
        LOG_ERROR("VENC", "ReleaseStream fail=0x" << std::hex << ret);
    }

    free(stStream.pstPack);
    stStream.pstPack = nullptr;
    stStream.u32PackCount = 0;
}

if (fp) fclose(fp);
LOG_INFO("VENC", "stream thread quit");

}

```有没有大佬知道为什么没办法播放呀？