Bring in line with dependency changes

Signed-off-by: Andrew Opalach <andrew@akon.city>

4 files changed, 136 insertions, 138 deletions

diff --git a/src/codec/ffmpeg/common.c b/src/codec/ffmpeg/common.c
index c147d81..16bbeab 100644
--- a/src/codec/ffmpeg/common.c
+++ b/src/codec/ffmpeg/common.c
@@ -22,7 +22,7 @@ static void av_log_callback(void *userdata, int level, const char *fmt, va_list
     if (level < AV_LOG_DEBUG) {
         pos += al_vsnprintf(&buf[pos], CHUNK_SIZE, fmt, args);
         if (buf[pos - 1] == '\n' || pos >= CHUNK_SIZE) {
-            al_log_info("ff_log", buf);
+            al_log_info("ff", buf);
             pos = 0;
         }
     }
diff --git a/src/codec/ffmpeg/encoder.c b/src/codec/ffmpeg/encoder.c
index 6e914c8..7c7b010 100644
--- a/src/codec/ffmpeg/encoder.c
+++ b/src/codec/ffmpeg/encoder.c
@@ -99,7 +99,7 @@ void camu_ff_encoder_push(struct camu_ff_encoder *enc, u8 **data, s32 sample_cou
         return;
     }
     AVPacket pkt = { 0 };
-    do {
+    for (;;) {
         ret = avcodec_receive_packet(enc->codec_context, &pkt);
         if (ret < 0)  {
             if (!(ret = AVERROR_EOF || ret == AVERROR(EAGAIN))) {
@@ -109,7 +109,7 @@ void camu_ff_encoder_push(struct camu_ff_encoder *enc, u8 **data, s32 sample_cou
         }
         enc->callback(enc->userdata, &pkt);
         enc->frame->pts += SAMPLES_PER_FRAME;
-    } while (1);
+    }
 }
 
 void camu_ff_encoder_reset(struct camu_ff_encoder *enc)
diff --git a/src/codec/ffmpeg/packet_ext.c b/src/codec/ffmpeg/packet_ext.c
index 16f5748..759719b 100644
--- a/src/codec/ffmpeg/packet_ext.c
+++ b/src/codec/ffmpeg/packet_ext.c
@@ -1,201 +1,201 @@
 #include "packet_ext.h"
 
-void aki_packet_write_av_codec_parameters(struct aki_packet *packet, AVCodecParameters *codecpar)
+void nn_packet_write_av_codec_parameters(struct nn_packet *packet, AVCodecParameters *codecpar)
 {
-    AKI_PACKET_WRITE_TYPE(packet, enum AVMediaType, codecpar->codec_type);
-    AKI_PACKET_WRITE_TYPE(packet, enum AVCodecID, codecpar->codec_id);
-    AKI_PACKET_WRITE_TYPE(packet, u32, codecpar->codec_tag);
-    AKI_PACKET_WRITE_TYPE(packet, s32, codecpar->extradata_size);
-    AKI_PACKET_WRITE_DATA(packet, codecpar->extradata, codecpar->extradata_size);
-    AKI_PACKET_WRITE_TYPE(packet, s32, codecpar->format);
-    AKI_PACKET_WRITE_TYPE(packet, s64, codecpar->bit_rate);
-    AKI_PACKET_WRITE_TYPE(packet, s32, codecpar->bits_per_coded_sample);
-    AKI_PACKET_WRITE_TYPE(packet, s32, codecpar->bits_per_raw_sample);
-    AKI_PACKET_WRITE_TYPE(packet, s32, codecpar->profile);
-    AKI_PACKET_WRITE_TYPE(packet, s32, codecpar->level);
-    AKI_PACKET_WRITE_TYPE(packet, s32, codecpar->width);
-    AKI_PACKET_WRITE_TYPE(packet, s32, codecpar->height);
-    AKI_PACKET_WRITE_TYPE(packet, AVRational, codecpar->sample_aspect_ratio);
-    AKI_PACKET_WRITE_TYPE(packet, AVRational, codecpar->framerate);
-    AKI_PACKET_WRITE_TYPE(packet, enum AVFieldOrder, codecpar->field_order);
-    AKI_PACKET_WRITE_TYPE(packet, enum AVColorRange, codecpar->color_range);
-    AKI_PACKET_WRITE_TYPE(packet, enum AVColorPrimaries, codecpar->color_primaries);
-    AKI_PACKET_WRITE_TYPE(packet, enum AVColorTransferCharacteristic, codecpar->color_trc);
-    AKI_PACKET_WRITE_TYPE(packet, enum AVColorSpace, codecpar->color_space);
-    AKI_PACKET_WRITE_TYPE(packet, enum AVChromaLocation, codecpar->chroma_location);
-    AKI_PACKET_WRITE_TYPE(packet, s32, codecpar->video_delay);
-    AKI_PACKET_WRITE_TYPE(packet, AVChannelLayout, codecpar->ch_layout);
-    AKI_PACKET_WRITE_TYPE(packet, s32, codecpar->sample_rate);
-    AKI_PACKET_WRITE_TYPE(packet, s32, codecpar->block_align);
-    AKI_PACKET_WRITE_TYPE(packet, s32, codecpar->frame_size);
-    AKI_PACKET_WRITE_TYPE(packet, s32, codecpar->initial_padding);
-    AKI_PACKET_WRITE_TYPE(packet, s32, codecpar->trailing_padding);
-    AKI_PACKET_WRITE_TYPE(packet, s32, codecpar->seek_preroll);
+    NNWT_PACKET_WRITE_TYPE(packet, enum AVMediaType, codecpar->codec_type);
+    NNWT_PACKET_WRITE_TYPE(packet, enum AVCodecID, codecpar->codec_id);
+    NNWT_PACKET_WRITE_TYPE(packet, u32, codecpar->codec_tag);
+    NNWT_PACKET_WRITE_TYPE(packet, s32, codecpar->extradata_size);
+    NNWT_PACKET_WRITE_DATA(packet, codecpar->extradata, codecpar->extradata_size);
+    NNWT_PACKET_WRITE_TYPE(packet, s32, codecpar->format);
+    NNWT_PACKET_WRITE_TYPE(packet, s64, codecpar->bit_rate);
+    NNWT_PACKET_WRITE_TYPE(packet, s32, codecpar->bits_per_coded_sample);
+    NNWT_PACKET_WRITE_TYPE(packet, s32, codecpar->bits_per_raw_sample);
+    NNWT_PACKET_WRITE_TYPE(packet, s32, codecpar->profile);
+    NNWT_PACKET_WRITE_TYPE(packet, s32, codecpar->level);
+    NNWT_PACKET_WRITE_TYPE(packet, s32, codecpar->width);
+    NNWT_PACKET_WRITE_TYPE(packet, s32, codecpar->height);
+    NNWT_PACKET_WRITE_TYPE(packet, AVRational, codecpar->sample_aspect_ratio);
+    NNWT_PACKET_WRITE_TYPE(packet, AVRational, codecpar->framerate);
+    NNWT_PACKET_WRITE_TYPE(packet, enum AVFieldOrder, codecpar->field_order);
+    NNWT_PACKET_WRITE_TYPE(packet, enum AVColorRange, codecpar->color_range);
+    NNWT_PACKET_WRITE_TYPE(packet, enum AVColorPrimaries, codecpar->color_primaries);
+    NNWT_PACKET_WRITE_TYPE(packet, enum AVColorTransferCharacteristic, codecpar->color_trc);
+    NNWT_PACKET_WRITE_TYPE(packet, enum AVColorSpace, codecpar->color_space);
+    NNWT_PACKET_WRITE_TYPE(packet, enum AVChromaLocation, codecpar->chroma_location);
+    NNWT_PACKET_WRITE_TYPE(packet, s32, codecpar->video_delay);
+    NNWT_PACKET_WRITE_TYPE(packet, AVChannelLayout, codecpar->ch_layout);
+    NNWT_PACKET_WRITE_TYPE(packet, s32, codecpar->sample_rate);
+    NNWT_PACKET_WRITE_TYPE(packet, s32, codecpar->block_align);
+    NNWT_PACKET_WRITE_TYPE(packet, s32, codecpar->frame_size);
+    NNWT_PACKET_WRITE_TYPE(packet, s32, codecpar->initial_padding);
+    NNWT_PACKET_WRITE_TYPE(packet, s32, codecpar->trailing_padding);
+    NNWT_PACKET_WRITE_TYPE(packet, s32, codecpar->seek_preroll);
 }
 
-void aki_packet_write_av_codec_id(struct aki_packet *packet, enum AVCodecID codec_id)
+void nn_packet_write_av_codec_id(struct nn_packet *packet, enum AVCodecID codec_id)
 {
-    AKI_PACKET_WRITE_TYPE(packet, enum AVCodecID, codec_id);
+    NNWT_PACKET_WRITE_TYPE(packet, enum AVCodecID, codec_id);
 }
 
-void aki_packet_write_av_dictionary(struct aki_packet *packet, AVDictionary *dict)
+void nn_packet_write_av_dictionary(struct nn_packet *packet, AVDictionary *dict)
 {
     s32 count = av_dict_count(dict);
-    AKI_PACKET_WRITE_TYPE(packet, s32, count);
+    NNWT_PACKET_WRITE_TYPE(packet, s32, count);
     const AVDictionaryEntry *entry = NULL;
     while ((entry = av_dict_iterate(dict, entry))) {
         size_t len = al_strlen(entry->key);
         al_assert(len <= UINT32_MAX);
-        AKI_PACKET_WRITE_TYPE(packet, u32, len);
-        AKI_PACKET_WRITE_DATA(packet, entry->key, len);
+        NNWT_PACKET_WRITE_TYPE(packet, u32, len);
+        NNWT_PACKET_WRITE_DATA(packet, entry->key, len);
         len = al_strlen(entry->value);
         al_assert(len <= UINT32_MAX);
-        AKI_PACKET_WRITE_TYPE(packet, u32, len);
-        AKI_PACKET_WRITE_DATA(packet, entry->value, len);
+        NNWT_PACKET_WRITE_TYPE(packet, u32, len);
+        NNWT_PACKET_WRITE_DATA(packet, entry->value, len);
     }
 }
 
-void aki_packet_write_av_stream(struct aki_packet *packet, AVStream *stream)
+void nn_packet_write_av_stream(struct nn_packet *packet, AVStream *stream)
 {
-    AKI_PACKET_WRITE_TYPE(packet, s32, stream->index);
-    aki_packet_write_av_codec_parameters(packet, stream->codecpar);
-    AKI_PACKET_WRITE_TYPE(packet, AVRational, stream->time_base);
-    AKI_PACKET_WRITE_TYPE(packet, s64, stream->duration);
-    AKI_PACKET_WRITE_TYPE(packet, s64, stream->start_time);
-    AKI_PACKET_WRITE_TYPE(packet, s64, stream->nb_frames);
-    aki_packet_write_av_dictionary(packet, stream->metadata);
+    NNWT_PACKET_WRITE_TYPE(packet, s32, stream->index);
+    nn_packet_write_av_codec_parameters(packet, stream->codecpar);
+    NNWT_PACKET_WRITE_TYPE(packet, AVRational, stream->time_base);
+    NNWT_PACKET_WRITE_TYPE(packet, s64, stream->duration);
+    NNWT_PACKET_WRITE_TYPE(packet, s64, stream->start_time);
+    NNWT_PACKET_WRITE_TYPE(packet, s64, stream->nb_frames);
+    nn_packet_write_av_dictionary(packet, stream->metadata);
     if (stream->avg_frame_rate.den == 0) {
-        // r_frame_rate.den == 0 handled on the client.
-        AKI_PACKET_WRITE_TYPE(packet, AVRational, stream->r_frame_rate);
+        // r_frame_rate.den = 0 handled on the client.
+        NNWT_PACKET_WRITE_TYPE(packet, AVRational, stream->r_frame_rate);
     } else {
-        AKI_PACKET_WRITE_TYPE(packet, AVRational, stream->avg_frame_rate);
+        NNWT_PACKET_WRITE_TYPE(packet, AVRational, stream->avg_frame_rate);
     }
 }
 
-void aki_packet_write_av_packet(struct aki_packet *packet, AVPacket *pkt)
+void nn_packet_write_av_packet(struct nn_packet *packet, AVPacket *pkt)
 {
-    AKI_PACKET_WRITE_TYPE(packet, s64, pkt->pts);
-    AKI_PACKET_WRITE_TYPE(packet, s64, pkt->dts);
-    AKI_PACKET_WRITE_TYPE(packet, s32, pkt->size);
-    AKI_PACKET_WRITE_DATA(packet, pkt->data, pkt->size);
-    AKI_PACKET_WRITE_TYPE(packet, s32, pkt->stream_index);
-    AKI_PACKET_WRITE_TYPE(packet, s32, pkt->flags);
-    AKI_PACKET_WRITE_TYPE(packet, s32, pkt->side_data_elems);
+    NNWT_PACKET_WRITE_TYPE(packet, s64, pkt->pts);
+    NNWT_PACKET_WRITE_TYPE(packet, s64, pkt->dts);
+    NNWT_PACKET_WRITE_TYPE(packet, s32, pkt->size);
+    NNWT_PACKET_WRITE_DATA(packet, pkt->data, pkt->size);
+    NNWT_PACKET_WRITE_TYPE(packet, s32, pkt->stream_index);
+    NNWT_PACKET_WRITE_TYPE(packet, s32, pkt->flags);
+    NNWT_PACKET_WRITE_TYPE(packet, s32, pkt->side_data_elems);
     for (s32 i = 0; i < pkt->side_data_elems; i++) {
         // Possibly upcast size_t.
         s64 size = (s64)pkt->side_data[i].size;
-        AKI_PACKET_WRITE_TYPE(packet, s64, size);
-        AKI_PACKET_WRITE_DATA(packet, pkt->side_data[i].data, pkt->side_data[i].size);
-        AKI_PACKET_WRITE_TYPE(packet, enum AVPacketSideDataType, pkt->side_data[i].type);
+        NNWT_PACKET_WRITE_TYPE(packet, s64, size);
+        NNWT_PACKET_WRITE_DATA(packet, pkt->side_data[i].data, pkt->side_data[i].size);
+        NNWT_PACKET_WRITE_TYPE(packet, enum AVPacketSideDataType, pkt->side_data[i].type);
     }
-    AKI_PACKET_WRITE_TYPE(packet, s64, pkt->duration);
-    AKI_PACKET_WRITE_TYPE(packet, s64, pkt->pos);
-    AKI_PACKET_WRITE_TYPE(packet, AVRational, pkt->time_base);
+    NNWT_PACKET_WRITE_TYPE(packet, s64, pkt->duration);
+    NNWT_PACKET_WRITE_TYPE(packet, s64, pkt->pos);
+    NNWT_PACKET_WRITE_TYPE(packet, AVRational, pkt->time_base);
 }
 
-void aki_packet_read_av_codec_parameters(struct aki_packet *packet, AVCodecParameters *codecpar)
+void nn_packet_read_av_codec_parameters(struct nn_packet *packet, AVCodecParameters *codecpar)
 {
-    AKI_PACKET_READ_TYPE(packet, enum AVMediaType, codecpar->codec_type);
-    AKI_PACKET_READ_TYPE(packet, enum AVCodecID, codecpar->codec_id);
-    AKI_PACKET_READ_TYPE(packet, u32, codecpar->codec_tag);
-    AKI_PACKET_READ_TYPE(packet, s32, codecpar->extradata_size);
+    NNWT_PACKET_READ_TYPE(packet, enum AVMediaType, codecpar->codec_type);
+    NNWT_PACKET_READ_TYPE(packet, enum AVCodecID, codecpar->codec_id);
+    NNWT_PACKET_READ_TYPE(packet, u32, codecpar->codec_tag);
+    NNWT_PACKET_READ_TYPE(packet, s32, codecpar->extradata_size);
     codecpar->extradata = av_malloc(codecpar->extradata_size);
     u8 *extradata;
-    AKI_PACKET_READ_DATA(packet, codecpar->extradata_size, extradata);
+    NNWT_PACKET_READ_DATA(packet, codecpar->extradata_size, extradata);
     al_memcpy(codecpar->extradata, extradata, codecpar->extradata_size);
-    AKI_PACKET_READ_TYPE(packet, s32,  codecpar->format);
-    AKI_PACKET_READ_TYPE(packet, s64, codecpar->bit_rate);
-    AKI_PACKET_READ_TYPE(packet, s32, codecpar->bits_per_coded_sample);
-    AKI_PACKET_READ_TYPE(packet, s32, codecpar->bits_per_raw_sample);
-    AKI_PACKET_READ_TYPE(packet, s32, codecpar->profile);
-    AKI_PACKET_READ_TYPE(packet, s32, codecpar->level);
-    AKI_PACKET_READ_TYPE(packet, s32, codecpar->width);
-    AKI_PACKET_READ_TYPE(packet, s32, codecpar->height);
-    AKI_PACKET_READ_TYPE(packet, AVRational, codecpar->sample_aspect_ratio);
-    AKI_PACKET_READ_TYPE(packet, AVRational, codecpar->framerate);
-    AKI_PACKET_READ_TYPE(packet, enum AVFieldOrder, codecpar->field_order);
-    AKI_PACKET_READ_TYPE(packet, enum AVColorRange, codecpar->color_range);
-    AKI_PACKET_READ_TYPE(packet, enum AVColorPrimaries, codecpar->color_primaries);
-    AKI_PACKET_READ_TYPE(packet, enum AVColorTransferCharacteristic, codecpar->color_trc);
-    AKI_PACKET_READ_TYPE(packet, enum AVColorSpace, codecpar->color_space);
-    AKI_PACKET_READ_TYPE(packet, enum AVChromaLocation, codecpar->chroma_location);
-    AKI_PACKET_READ_TYPE(packet, s32, codecpar->video_delay);
-    AKI_PACKET_READ_TYPE(packet, AVChannelLayout, codecpar->ch_layout);
-    AKI_PACKET_READ_TYPE(packet, s32, codecpar->sample_rate);
-    AKI_PACKET_READ_TYPE(packet, s32, codecpar->block_align);
-    AKI_PACKET_READ_TYPE(packet, s32, codecpar->frame_size);
-    AKI_PACKET_READ_TYPE(packet, s32, codecpar->initial_padding);
-    AKI_PACKET_READ_TYPE(packet, s32, codecpar->trailing_padding);
-    AKI_PACKET_READ_TYPE(packet, s32, codecpar->seek_preroll);
+    NNWT_PACKET_READ_TYPE(packet, s32,  codecpar->format);
+    NNWT_PACKET_READ_TYPE(packet, s64, codecpar->bit_rate);
+    NNWT_PACKET_READ_TYPE(packet, s32, codecpar->bits_per_coded_sample);
+    NNWT_PACKET_READ_TYPE(packet, s32, codecpar->bits_per_raw_sample);
+    NNWT_PACKET_READ_TYPE(packet, s32, codecpar->profile);
+    NNWT_PACKET_READ_TYPE(packet, s32, codecpar->level);
+    NNWT_PACKET_READ_TYPE(packet, s32, codecpar->width);
+    NNWT_PACKET_READ_TYPE(packet, s32, codecpar->height);
+    NNWT_PACKET_READ_TYPE(packet, AVRational, codecpar->sample_aspect_ratio);
+    NNWT_PACKET_READ_TYPE(packet, AVRational, codecpar->framerate);
+    NNWT_PACKET_READ_TYPE(packet, enum AVFieldOrder, codecpar->field_order);
+    NNWT_PACKET_READ_TYPE(packet, enum AVColorRange, codecpar->color_range);
+    NNWT_PACKET_READ_TYPE(packet, enum AVColorPrimaries, codecpar->color_primaries);
+    NNWT_PACKET_READ_TYPE(packet, enum AVColorTransferCharacteristic, codecpar->color_trc);
+    NNWT_PACKET_READ_TYPE(packet, enum AVColorSpace, codecpar->color_space);
+    NNWT_PACKET_READ_TYPE(packet, enum AVChromaLocation, codecpar->chroma_location);
+    NNWT_PACKET_READ_TYPE(packet, s32, codecpar->video_delay);
+    NNWT_PACKET_READ_TYPE(packet, AVChannelLayout, codecpar->ch_layout);
+    NNWT_PACKET_READ_TYPE(packet, s32, codecpar->sample_rate);
+    NNWT_PACKET_READ_TYPE(packet, s32, codecpar->block_align);
+    NNWT_PACKET_READ_TYPE(packet, s32, codecpar->frame_size);
+    NNWT_PACKET_READ_TYPE(packet, s32, codecpar->initial_padding);
+    NNWT_PACKET_READ_TYPE(packet, s32, codecpar->trailing_padding);
+    NNWT_PACKET_READ_TYPE(packet, s32, codecpar->seek_preroll);
 }
 
-enum AVCodecID aki_packet_read_av_codec_id(struct aki_packet *packet)
+enum AVCodecID nn_packet_read_av_codec_id(struct nn_packet *packet)
 {
     enum AVCodecID id;
-    AKI_PACKET_READ_TYPE(packet, enum AVCodecID, id);
+    NNWT_PACKET_READ_TYPE(packet, enum AVCodecID, id);
     return id;
 }
 
-void aki_packet_read_av_dictionary(struct aki_packet *packet, AVDictionary **dict)
+void nn_packet_read_av_dictionary(struct nn_packet *packet, AVDictionary **dict)
 {
     s32 count;
-    AKI_PACKET_READ_TYPE(packet, s32, count);
+    NNWT_PACKET_READ_TYPE(packet, s32, count);
     for (s32 i = 0; i < count; i++) {
         char *key, *value;
         u32 len;
-        AKI_PACKET_READ_TYPE(packet, u32, len);
-        AKI_PACKET_READ_DATA(packet, len, key);
+        NNWT_PACKET_READ_TYPE(packet, u32, len);
+        NNWT_PACKET_READ_DATA(packet, len, key);
         // Key and value MUST be allocated with av_malloc functions
         // just like all FFmpeg structures.
         key = av_strndup(key, len);
-        AKI_PACKET_READ_TYPE(packet, u32, len);
-        AKI_PACKET_READ_DATA(packet, len, value);
+        NNWT_PACKET_READ_TYPE(packet, u32, len);
+        NNWT_PACKET_READ_DATA(packet, len, value);
         value = av_strndup(value, len);
         av_dict_set(dict, key, value, AV_DICT_DONT_STRDUP_KEY | AV_DICT_DONT_STRDUP_VAL);
     }
 }
 
-AVStream *aki_packet_read_av_stream(AVFormatContext *format_context, const AVCodec *codec, struct aki_packet *packet)
+AVStream *nn_packet_read_av_stream(AVFormatContext *format_context, const AVCodec *codec, struct nn_packet *packet)
 {
     AVStream *stream = avformat_new_stream(format_context, codec);
-    AKI_PACKET_READ_TYPE(packet, s32, stream->index);
-    aki_packet_read_av_codec_parameters(packet, stream->codecpar);
-    AKI_PACKET_READ_TYPE(packet, AVRational, stream->time_base);
-    AKI_PACKET_READ_TYPE(packet, s64, stream->duration);
-    AKI_PACKET_READ_TYPE(packet, s64, stream->start_time);
-    AKI_PACKET_READ_TYPE(packet, s64, stream->nb_frames);
+    NNWT_PACKET_READ_TYPE(packet, s32, stream->index);
+    nn_packet_read_av_codec_parameters(packet, stream->codecpar);
+    NNWT_PACKET_READ_TYPE(packet, AVRational, stream->time_base);
+    NNWT_PACKET_READ_TYPE(packet, s64, stream->duration);
+    NNWT_PACKET_READ_TYPE(packet, s64, stream->start_time);
+    NNWT_PACKET_READ_TYPE(packet, s64, stream->nb_frames);
     stream->metadata = NULL;
-    aki_packet_read_av_dictionary(packet, &stream->metadata);
-    AKI_PACKET_READ_TYPE(packet, AVRational, stream->avg_frame_rate);
+    nn_packet_read_av_dictionary(packet, &stream->metadata);
+    NNWT_PACKET_READ_TYPE(packet, AVRational, stream->avg_frame_rate);
     return stream;
 }
 
-AVPacket *aki_packet_read_av_packet(struct aki_packet *packet)
+AVPacket *nn_packet_read_av_packet(struct nn_packet *packet)
 {
     AVPacket *pkt = av_packet_alloc();
-    AKI_PACKET_READ_TYPE(packet, s64, pkt->pts);
-    AKI_PACKET_READ_TYPE(packet, s64, pkt->dts);
-    AKI_PACKET_READ_TYPE(packet, s32, pkt->size);
-    AKI_PACKET_READ_DATA(packet, pkt->size, pkt->data);
-    AKI_PACKET_READ_TYPE(packet, s32, pkt->stream_index);
-    AKI_PACKET_READ_TYPE(packet, s32, pkt->flags);
+    NNWT_PACKET_READ_TYPE(packet, s64, pkt->pts);
+    NNWT_PACKET_READ_TYPE(packet, s64, pkt->dts);
+    NNWT_PACKET_READ_TYPE(packet, s32, pkt->size);
+    NNWT_PACKET_READ_DATA(packet, pkt->size, pkt->data);
+    NNWT_PACKET_READ_TYPE(packet, s32, pkt->stream_index);
+    NNWT_PACKET_READ_TYPE(packet, s32, pkt->flags);
     s32 side_data_elems;
-    AKI_PACKET_READ_TYPE(packet, s32, side_data_elems);
+    NNWT_PACKET_READ_TYPE(packet, s32, side_data_elems);
     pkt->side_data_elems = 0;
     for (s32 i = 0; i < side_data_elems; i++) {
         u8 *data;
         enum AVPacketSideDataType type;
         s64 storage_for_size;
-        AKI_PACKET_READ_TYPE(packet, s64, storage_for_size);
+        NNWT_PACKET_READ_TYPE(packet, s64, storage_for_size);
         al_assert((sizeof(size_t) > 4 || storage_for_size <= INT32_MAX));
         size_t size = (size_t)storage_for_size;
-        AKI_PACKET_READ_DATA(packet, size, data);
-        AKI_PACKET_READ_TYPE(packet, enum AVPacketSideDataType, type);
+        NNWT_PACKET_READ_DATA(packet, size, data);
+        NNWT_PACKET_READ_TYPE(packet, enum AVPacketSideDataType, type);
         u8 *side_data = av_packet_new_side_data(pkt, type, size);
         al_memcpy(side_data, data, size);
     }
-    AKI_PACKET_READ_TYPE(packet, s64, pkt->duration);
-    AKI_PACKET_READ_TYPE(packet, s64, pkt->pos);
-    AKI_PACKET_READ_TYPE(packet, AVRational, pkt->time_base);
+    NNWT_PACKET_READ_TYPE(packet, s64, pkt->duration);
+    NNWT_PACKET_READ_TYPE(packet, s64, pkt->pos);
+    NNWT_PACKET_READ_TYPE(packet, AVRational, pkt->time_base);
     return pkt;
 }
diff --git a/src/codec/ffmpeg/packet_ext.h b/src/codec/ffmpeg/packet_ext.h
index 26a1392..91254c2 100644
--- a/src/codec/ffmpeg/packet_ext.h
+++ b/src/codec/ffmpeg/packet_ext.h
@@ -1,19 +1,17 @@
 #pragma once
 
-#include <aki/common.h>
-#include <aki/event_loop.h>
-
+#include <nnwt/packet.h>
 #include <libavcodec/packet.h>
 #include <libavcodec/codec_par.h>
 #include <libavformat/avformat.h>
 #include <libavutil/dict.h>
 
-void aki_packet_write_av_codec_parameters(struct aki_packet *packet, AVCodecParameters *codecpar);
-void aki_packet_write_av_codec_id(struct aki_packet *packet, enum AVCodecID codec_id);
-void aki_packet_write_av_stream(struct aki_packet *packet, AVStream *stream);
-void aki_packet_write_av_packet(struct aki_packet *packet, AVPacket *pkt);
+void nn_packet_write_av_codec_parameters(struct nn_packet *packet, AVCodecParameters *codecpar);
+void nn_packet_write_av_codec_id(struct nn_packet *packet, enum AVCodecID codec_id);
+void nn_packet_write_av_stream(struct nn_packet *packet, AVStream *stream);
+void nn_packet_write_av_packet(struct nn_packet *packet, AVPacket *pkt);
 
-void aki_packet_read_av_codec_parameters(struct aki_packet *packet, AVCodecParameters *codecpar);
-enum AVCodecID aki_packet_read_av_codec_id(struct aki_packet *packet);
-AVStream *aki_packet_read_av_stream(AVFormatContext *format_context, const AVCodec *codec, struct aki_packet *packet);
-AVPacket *aki_packet_read_av_packet(struct aki_packet *packet);
+void nn_packet_read_av_codec_parameters(struct nn_packet *packet, AVCodecParameters *codecpar);
+enum AVCodecID nn_packet_read_av_codec_id(struct nn_packet *packet);
+AVStream *nn_packet_read_av_stream(AVFormatContext *format_context, const AVCodec *codec, struct nn_packet *packet);
+AVPacket *nn_packet_read_av_packet(struct nn_packet *packet);