diff --git a/platform/linux-generic/include/odp/api/plat/packet_types.h b/platform/linux-generic/include/odp/api/plat/packet_types.h
index 34e5dd81..999130ec 100644
--- a/platform/linux-generic/include/odp/api/plat/packet_types.h
+++ b/platform/linux-generic/include/odp/api/plat/packet_types.h
@@ -32,7 +32,7 @@ extern "C" {
 
 typedef ODP_HANDLE_T(odp_packet_t);
 
-#define ODP_PACKET_INVALID _odp_cast_scalar(odp_packet_t, 0xffffffff)
+#define ODP_PACKET_INVALID _odp_cast_scalar(odp_packet_t, 0)
 
 #define ODP_PACKET_OFFSET_INVALID (0x0fffffff)
 
diff --git a/platform/linux-generic/include/odp_packet_internal.h b/platform/linux-generic/include/odp_packet_internal.h
index 42df5ac8..d1c6d456 100644
--- a/platform/linux-generic/include/odp_packet_internal.h
+++ b/platform/linux-generic/include/odp_packet_internal.h
@@ -217,11 +217,11 @@ typedef struct odp_packet_hdr_t {
  */
 static inline odp_packet_hdr_t *odp_packet_hdr(odp_packet_t pkt)
 {
-	return (odp_packet_hdr_t *)buf_hdl_to_hdr((odp_buffer_t)pkt);
+	return (odp_packet_hdr_t *)(uintptr_t)pkt;
 }
 
-static inline odp_packet_hdr_t *odp_packet_last_hdr(odp_packet_t pkt,
-						    uint32_t *offset)
+static inline odp_packet_hdr_t *packet_last_hdr(odp_packet_t pkt,
+						uint32_t *offset)
 {
 	odp_packet_hdr_t *pkt_hdr = odp_packet_hdr(pkt);
 	odp_packet_hdr_t *prev_hdr = pkt_hdr;
@@ -242,9 +242,9 @@ static inline odp_packet_hdr_t *odp_packet_last_hdr(odp_packet_t pkt,
 	return pkt_hdr;
 }
 
-static inline odp_packet_hdr_t *odp_packet_prev_hdr(odp_packet_hdr_t *pkt_hdr,
-						    odp_packet_hdr_t *cur_hdr,
-						    uint32_t *offset)
+static inline odp_packet_hdr_t *packet_prev_hdr(odp_packet_hdr_t *pkt_hdr,
+						odp_packet_hdr_t *cur_hdr,
+						uint32_t *offset)
 {
 	uint32_t ref_offset = 0;
 	odp_packet_hdr_t *prev_hdr = pkt_hdr;
@@ -264,11 +264,6 @@ static inline odp_packet_hdr_t *odp_packet_prev_hdr(odp_packet_hdr_t *pkt_hdr,
 	return pkt_hdr;
 }
 
-static inline odp_packet_t _odp_packet_hdl(odp_packet_hdr_t *pkt_hdr)
-{
-	return (odp_packet_t)odp_hdr_to_buf(&pkt_hdr->buf_hdr);
-}
-
 static inline void copy_packet_parser_metadata(odp_packet_hdr_t *src_hdr,
 					       odp_packet_hdr_t *dst_hdr)
 {
diff --git a/platform/linux-generic/odp_packet.c b/platform/linux-generic/odp_packet.c
index 4aa99cdd..cfed3d9b 100644
--- a/platform/linux-generic/odp_packet.c
+++ b/platform/linux-generic/odp_packet.c
@@ -23,9 +23,14 @@
 /* Initial packet segment data length */
 #define BASE_LEN  CONFIG_PACKET_MAX_SEG_LEN
 
+static inline odp_packet_hdr_t *packet_hdr(odp_packet_t pkt)
+{
+	return (odp_packet_hdr_t *)(uintptr_t)pkt;
+}
+
 static inline odp_packet_t packet_handle(odp_packet_hdr_t *pkt_hdr)
 {
-	return (odp_packet_t)pkt_hdr->buf_hdr.handle.handle;
+	return (odp_packet_t)pkt_hdr;
 }
 
 static inline odp_buffer_t buffer_handle(odp_packet_hdr_t *pkt_hdr)
@@ -43,6 +48,11 @@ static inline uint32_t packet_ref_dec(odp_packet_hdr_t *pkt_hdr)
 	return odp_atomic_fetch_dec_u32(&pkt_hdr->ref_count);
 }
 
+static inline odp_packet_hdr_t *buf_to_packet_hdr(odp_buffer_t buf)
+{
+	return (odp_packet_hdr_t *)buf_hdl_to_hdr(buf);
+}
+
 static inline uint32_t packet_seg_len(odp_packet_hdr_t *pkt_hdr,
 				      uint32_t seg_idx)
 {
@@ -534,8 +544,8 @@ static inline int packet_alloc(pool_t *pool, uint32_t len, int max_pkt,
 		odp_packet_hdr_t *hdr;
 
 		/* First buffer is the packet descriptor */
-		pkt[i] = (odp_packet_t)buf[i * num_seg];
 		hdr    = pkt_hdr[i * num_seg];
+		pkt[i] = packet_handle(hdr);
 		init_segments(&pkt_hdr[i * num_seg], num_seg);
 
 		packet_init(hdr, len, parse);
@@ -669,7 +679,7 @@ static inline void packet_free(odp_packet_hdr_t *pkt_hdr)
 
 void odp_packet_free(odp_packet_t pkt)
 {
-	packet_free(odp_packet_hdr(pkt));
+	packet_free(packet_hdr(pkt));
 }
 
 void odp_packet_free_multi(const odp_packet_t pkt[], int num)
@@ -678,7 +688,7 @@ void odp_packet_free_multi(const odp_packet_t pkt[], int num)
 	odp_buffer_t buf[nbufs];
 	int nfree = 0;
 	int i = 0;
-	odp_packet_hdr_t *pkt_hdr = odp_packet_hdr(pkt[0]);
+	odp_packet_hdr_t *pkt_hdr = packet_hdr(pkt[0]);
 	uint32_t pool_id = pool_id_from_buf(pkt_hdr->buf_hdr.handle.handle);
 	uint32_t next_pool;
 
@@ -694,7 +704,7 @@ void odp_packet_free_multi(const odp_packet_t pkt[], int num)
 		if (++i == num)
 			break;
 
-		pkt_hdr = odp_packet_hdr(pkt[i]);
+		pkt_hdr = packet_hdr(pkt[i]);
 		next_pool = pool_id_from_buf(pkt_hdr->buf_hdr.handle.handle);
 
 		if (odp_unlikely(next_pool != pool_id)) {
@@ -712,7 +722,7 @@ void odp_packet_free_multi(const odp_packet_t pkt[], int num)
 
 int odp_packet_reset(odp_packet_t pkt, uint32_t len)
 {
-	odp_packet_hdr_t *const pkt_hdr = odp_packet_hdr(pkt);
+	odp_packet_hdr_t *const pkt_hdr = packet_hdr(pkt);
 	pool_t *pool = pool_entry_from_hdl(pkt_hdr->buf_hdr.pool_hdl);
 
 	if (len > pool->headroom + pool->data_size + pool->tailroom)
@@ -728,22 +738,34 @@ int odp_packet_reset(odp_packet_t pkt, uint32_t len)
 
 odp_packet_t _odp_packet_from_buffer(odp_buffer_t buf)
 {
-	return (odp_packet_t)buf;
+	if (odp_unlikely(buf == ODP_BUFFER_INVALID))
+		return ODP_PACKET_INVALID;
+
+	return (odp_packet_t)buf_to_packet_hdr(buf);
 }
 
 odp_buffer_t _odp_packet_to_buffer(odp_packet_t pkt)
 {
-	return (odp_buffer_t)pkt;
+	if (odp_unlikely(pkt == ODP_PACKET_INVALID))
+		return ODP_BUFFER_INVALID;
+
+	return buffer_handle(packet_hdr(pkt));
 }
 
 odp_packet_t odp_packet_from_event(odp_event_t ev)
 {
-	return (odp_packet_t)ev;
+	if (odp_unlikely(ev == ODP_EVENT_INVALID))
+		return ODP_PACKET_INVALID;
+
+	return (odp_packet_t)buf_to_packet_hdr((odp_buffer_t)ev);
 }
 
 odp_event_t odp_packet_to_event(odp_packet_t pkt)
 {
-	return (odp_event_t)pkt;
+	if (odp_unlikely(pkt == ODP_PACKET_INVALID))
+		return ODP_EVENT_INVALID;
+
+	return (odp_event_t)buffer_handle(packet_hdr(pkt));
 }
 
 /*
@@ -755,14 +777,14 @@ odp_event_t odp_packet_to_event(odp_packet_t pkt)
 
 void *odp_packet_head(odp_packet_t pkt)
 {
-	odp_packet_hdr_t *pkt_hdr = odp_packet_hdr(pkt);
+	odp_packet_hdr_t *pkt_hdr = packet_hdr(pkt);
 
 	return pkt_hdr->buf_hdr.seg[0].data - pkt_hdr->headroom;
 }
 
 uint32_t odp_packet_buf_len(odp_packet_t pkt)
 {
-	odp_packet_hdr_t *pkt_hdr = odp_packet_hdr(pkt);
+	odp_packet_hdr_t *pkt_hdr = packet_hdr(pkt);
 	uint32_t buf_len = 0;
 
 	do {
@@ -775,26 +797,26 @@ uint32_t odp_packet_buf_len(odp_packet_t pkt)
 
 void *odp_packet_data(odp_packet_t pkt)
 {
-	odp_packet_hdr_t *pkt_hdr = odp_packet_hdr(pkt);
+	odp_packet_hdr_t *pkt_hdr = packet_hdr(pkt);
 
 	return packet_map(pkt_hdr, 0, NULL, NULL);
 }
 
 uint32_t odp_packet_seg_len(odp_packet_t pkt)
 {
-	odp_packet_hdr_t *pkt_hdr = odp_packet_hdr(pkt);
+	odp_packet_hdr_t *pkt_hdr = packet_hdr(pkt);
 
 	return packet_first_seg_len(pkt_hdr);
 }
 
 uint32_t odp_packet_len(odp_packet_t pkt)
 {
-	return packet_len(odp_packet_hdr(pkt));
+	return packet_len(packet_hdr(pkt));
 }
 
 uint32_t odp_packet_unshared_len(odp_packet_t pkt)
 {
-	odp_packet_hdr_t *pkt_hdr = odp_packet_hdr(pkt);
+	odp_packet_hdr_t *pkt_hdr = packet_hdr(pkt);
 	uint32_t pkt_len = 0, offset = 0;
 
 	do {
@@ -819,24 +841,24 @@ uint32_t odp_packet_unshared_len(odp_packet_t pkt)
 
 uint32_t odp_packet_headroom(odp_packet_t pkt)
 {
-	return odp_packet_hdr(pkt)->headroom;
+	return packet_hdr(pkt)->headroom;
 }
 
 uint32_t odp_packet_tailroom(odp_packet_t pkt)
 {
-	return odp_packet_last_hdr(pkt, NULL)->tailroom;
+	return packet_last_hdr(pkt, NULL)->tailroom;
 }
 
 void *odp_packet_tail(odp_packet_t pkt)
 {
-	odp_packet_hdr_t *pkt_hdr = odp_packet_last_hdr(pkt, NULL);
+	odp_packet_hdr_t *pkt_hdr = packet_last_hdr(pkt, NULL);
 
 	return packet_tail(pkt_hdr);
 }
 
 void *odp_packet_push_head(odp_packet_t pkt, uint32_t len)
 {
-	odp_packet_hdr_t *pkt_hdr = odp_packet_hdr(pkt);
+	odp_packet_hdr_t *pkt_hdr = packet_hdr(pkt);
 
 	if (len > pkt_hdr->headroom)
 		return NULL;
@@ -1021,7 +1043,7 @@ static inline void reset_seg(odp_packet_hdr_t *pkt_hdr, int first, int num)
 int odp_packet_extend_head(odp_packet_t *pkt, uint32_t len,
 			   void **data_ptr, uint32_t *seg_len)
 {
-	odp_packet_hdr_t *pkt_hdr = odp_packet_hdr(*pkt);
+	odp_packet_hdr_t *pkt_hdr = packet_hdr(*pkt);
 	uint32_t frame_len = pkt_hdr->frame_len;
 	uint32_t headroom = pkt_hdr->headroom;
 	int ret = 0;
@@ -1171,7 +1193,7 @@ int odp_packet_extend_head(odp_packet_t *pkt, uint32_t len,
 
 void *odp_packet_pull_head(odp_packet_t pkt, uint32_t len)
 {
-	odp_packet_hdr_t *pkt_hdr = odp_packet_hdr(pkt);
+	odp_packet_hdr_t *pkt_hdr = packet_hdr(pkt);
 
 	if (len > pkt_hdr->frame_len)
 		return NULL;
@@ -1185,7 +1207,7 @@ void *odp_packet_pull_head(odp_packet_t pkt, uint32_t len)
 int odp_packet_trunc_head(odp_packet_t *pkt, uint32_t len,
 			  void **data_ptr, uint32_t *seg_len_out)
 {
-	odp_packet_hdr_t *pkt_hdr = odp_packet_hdr(*pkt), *nxt_hdr;
+	odp_packet_hdr_t *pkt_hdr = packet_hdr(*pkt), *nxt_hdr;
 	uint32_t seg_len = packet_first_seg_len(pkt_hdr);
 	int ret = 0;
 
@@ -1243,7 +1265,7 @@ int odp_packet_trunc_head(odp_packet_t *pkt, uint32_t len,
 
 void *odp_packet_push_tail(odp_packet_t pkt, uint32_t len)
 {
-	odp_packet_hdr_t *pkt_hdr = odp_packet_last_hdr(pkt, NULL);
+	odp_packet_hdr_t *pkt_hdr = packet_last_hdr(pkt, NULL);
 	void *old_tail;
 
 	if (len > pkt_hdr->tailroom)
@@ -1260,7 +1282,7 @@ void *odp_packet_push_tail(odp_packet_t pkt, uint32_t len)
 int odp_packet_extend_tail(odp_packet_t *pkt, uint32_t len,
 			   void **data_ptr, uint32_t *seg_len_out)
 {
-	odp_packet_hdr_t *pkt_hdr = odp_packet_last_hdr(*pkt, NULL);
+	odp_packet_hdr_t *pkt_hdr = packet_last_hdr(*pkt, NULL);
 	uint32_t frame_len = pkt_hdr->frame_len;
 	uint32_t tailroom  = pkt_hdr->tailroom;
 	uint32_t tail_off  = frame_len;
@@ -1353,7 +1375,7 @@ int odp_packet_extend_tail(odp_packet_t *pkt, uint32_t len,
 
 void *odp_packet_pull_tail(odp_packet_t pkt, uint32_t len)
 {
-	odp_packet_hdr_t *pkt_hdr = odp_packet_hdr(pkt);
+	odp_packet_hdr_t *pkt_hdr = packet_hdr(pkt);
 
 	if (len > packet_last_seg_len(pkt_hdr))
 		return NULL;
@@ -1370,18 +1392,18 @@ int odp_packet_trunc_tail(odp_packet_t *pkt, uint32_t len,
 	int last;
 	uint32_t seg_len;
 	uint32_t offset;
-	odp_packet_hdr_t *first_hdr = odp_packet_hdr(*pkt);
+	odp_packet_hdr_t *first_hdr = packet_hdr(*pkt);
 	odp_packet_hdr_t *pkt_hdr, *prev_hdr;
 
 	if (len > packet_len(first_hdr))
 		return -1;
 
-	pkt_hdr = odp_packet_last_hdr(*pkt, &offset);
+	pkt_hdr = packet_last_hdr(*pkt, &offset);
 
 	/* Special processing for references */
 	while (len >= pkt_hdr->frame_len - offset && first_hdr->ref_hdr) {
 		len -= (pkt_hdr->frame_len - offset);
-		prev_hdr = odp_packet_prev_hdr(first_hdr, pkt_hdr, &offset);
+		prev_hdr = packet_prev_hdr(first_hdr, pkt_hdr, &offset);
 		ODP_ASSERT(packet_ref_count(prev_hdr) == 1);
 		prev_hdr->ref_hdr = NULL;
 		packet_free(pkt_hdr);
@@ -1421,7 +1443,7 @@ void *odp_packet_offset(odp_packet_t pkt, uint32_t offset, uint32_t *len,
 			odp_packet_seg_t *seg)
 {
 	int seg_idx;
-	odp_packet_hdr_t *pkt_hdr = odp_packet_hdr(pkt);
+	odp_packet_hdr_t *pkt_hdr = packet_hdr(pkt);
 	void *addr = packet_map(pkt_hdr, offset, len, &seg_idx);
 
 	if (addr != NULL && seg != NULL)
@@ -1446,42 +1468,42 @@ void odp_packet_prefetch(odp_packet_t pkt ODP_UNUSED,
 
 odp_pool_t odp_packet_pool(odp_packet_t pkt)
 {
-	return odp_packet_hdr(pkt)->buf_hdr.pool_hdl;
+	return packet_hdr(pkt)->buf_hdr.pool_hdl;
 }
 
 odp_pktio_t odp_packet_input(odp_packet_t pkt)
 {
-	return odp_packet_hdr(pkt)->input;
+	return packet_hdr(pkt)->input;
 }
 
 int odp_packet_input_index(odp_packet_t pkt)
 {
-	return odp_pktio_index(odp_packet_hdr(pkt)->input);
+	return odp_pktio_index(packet_hdr(pkt)->input);
 }
 
 void *odp_packet_user_ptr(odp_packet_t pkt)
 {
-	return odp_packet_hdr(pkt)->buf_hdr.buf_ctx;
+	return packet_hdr(pkt)->buf_hdr.buf_ctx;
 }
 
 void odp_packet_user_ptr_set(odp_packet_t pkt, const void *ctx)
 {
-	odp_packet_hdr(pkt)->buf_hdr.buf_cctx = ctx;
+	packet_hdr(pkt)->buf_hdr.buf_cctx = ctx;
 }
 
 void *odp_packet_user_area(odp_packet_t pkt)
 {
-	return odp_packet_hdr(pkt)->buf_hdr.uarea_addr;
+	return packet_hdr(pkt)->buf_hdr.uarea_addr;
 }
 
 uint32_t odp_packet_user_area_size(odp_packet_t pkt)
 {
-	return odp_packet_hdr(pkt)->buf_hdr.uarea_size;
+	return packet_hdr(pkt)->buf_hdr.uarea_size;
 }
 
 void *odp_packet_l2_ptr(odp_packet_t pkt, uint32_t *len)
 {
-	odp_packet_hdr_t *pkt_hdr = odp_packet_hdr(pkt);
+	odp_packet_hdr_t *pkt_hdr = packet_hdr(pkt);
 
 	if (!packet_hdr_has_l2(pkt_hdr))
 		return NULL;
@@ -1490,7 +1512,7 @@ void *odp_packet_l2_ptr(odp_packet_t pkt, uint32_t *len)
 
 uint32_t odp_packet_l2_offset(odp_packet_t pkt)
 {
-	odp_packet_hdr_t *pkt_hdr = odp_packet_hdr(pkt);
+	odp_packet_hdr_t *pkt_hdr = packet_hdr(pkt);
 
 	if (!packet_hdr_has_l2(pkt_hdr))
 		return ODP_PACKET_OFFSET_INVALID;
@@ -1499,7 +1521,7 @@ uint32_t odp_packet_l2_offset(odp_packet_t pkt)
 
 int odp_packet_l2_offset_set(odp_packet_t pkt, uint32_t offset)
 {
-	odp_packet_hdr_t *pkt_hdr = odp_packet_hdr(pkt);
+	odp_packet_hdr_t *pkt_hdr = packet_hdr(pkt);
 
 	if (offset >= pkt_hdr->frame_len)
 		return -1;
@@ -1511,7 +1533,7 @@ int odp_packet_l2_offset_set(odp_packet_t pkt, uint32_t offset)
 
 void *odp_packet_l3_ptr(odp_packet_t pkt, uint32_t *len)
 {
-	odp_packet_hdr_t *pkt_hdr = odp_packet_hdr(pkt);
+	odp_packet_hdr_t *pkt_hdr = packet_hdr(pkt);
 
 	if (pkt_hdr->p.parsed_layers < LAYER_L3)
 		packet_parse_layer(pkt_hdr, LAYER_L3);
@@ -1520,7 +1542,7 @@ void *odp_packet_l3_ptr(odp_packet_t pkt, uint32_t *len)
 
 uint32_t odp_packet_l3_offset(odp_packet_t pkt)
 {
-	odp_packet_hdr_t *pkt_hdr = odp_packet_hdr(pkt);
+	odp_packet_hdr_t *pkt_hdr = packet_hdr(pkt);
 
 	if (pkt_hdr->p.parsed_layers < LAYER_L3)
 		packet_parse_layer(pkt_hdr, LAYER_L3);
@@ -1529,7 +1551,7 @@ uint32_t odp_packet_l3_offset(odp_packet_t pkt)
 
 int odp_packet_l3_offset_set(odp_packet_t pkt, uint32_t offset)
 {
-	odp_packet_hdr_t *pkt_hdr = odp_packet_hdr(pkt);
+	odp_packet_hdr_t *pkt_hdr = packet_hdr(pkt);
 
 	if (offset >= pkt_hdr->frame_len)
 		return -1;
@@ -1542,7 +1564,7 @@ int odp_packet_l3_offset_set(odp_packet_t pkt, uint32_t offset)
 
 void *odp_packet_l4_ptr(odp_packet_t pkt, uint32_t *len)
 {
-	odp_packet_hdr_t *pkt_hdr = odp_packet_hdr(pkt);
+	odp_packet_hdr_t *pkt_hdr = packet_hdr(pkt);
 
 	if (pkt_hdr->p.parsed_layers < LAYER_L4)
 		packet_parse_layer(pkt_hdr, LAYER_L4);
@@ -1551,7 +1573,7 @@ void *odp_packet_l4_ptr(odp_packet_t pkt, uint32_t *len)
 
 uint32_t odp_packet_l4_offset(odp_packet_t pkt)
 {
-	odp_packet_hdr_t *pkt_hdr = odp_packet_hdr(pkt);
+	odp_packet_hdr_t *pkt_hdr = packet_hdr(pkt);
 
 	if (pkt_hdr->p.parsed_layers < LAYER_L4)
 		packet_parse_layer(pkt_hdr, LAYER_L4);
@@ -1560,7 +1582,7 @@ uint32_t odp_packet_l4_offset(odp_packet_t pkt)
 
 int odp_packet_l4_offset_set(odp_packet_t pkt, uint32_t offset)
 {
-	odp_packet_hdr_t *pkt_hdr = odp_packet_hdr(pkt);
+	odp_packet_hdr_t *pkt_hdr = packet_hdr(pkt);
 
 	if (offset >= pkt_hdr->frame_len)
 		return -1;
@@ -1573,14 +1595,14 @@ int odp_packet_l4_offset_set(odp_packet_t pkt, uint32_t offset)
 
 uint32_t odp_packet_flow_hash(odp_packet_t pkt)
 {
-	odp_packet_hdr_t *pkt_hdr = odp_packet_hdr(pkt);
+	odp_packet_hdr_t *pkt_hdr = packet_hdr(pkt);
 
 	return pkt_hdr->flow_hash;
 }
 
 void odp_packet_flow_hash_set(odp_packet_t pkt, uint32_t flow_hash)
 {
-	odp_packet_hdr_t *pkt_hdr = odp_packet_hdr(pkt);
+	odp_packet_hdr_t *pkt_hdr = packet_hdr(pkt);
 
 	pkt_hdr->flow_hash = flow_hash;
 	pkt_hdr->p.input_flags.flow_hash = 1;
@@ -1588,14 +1610,14 @@ void odp_packet_flow_hash_set(odp_packet_t pkt, uint32_t flow_hash)
 
 odp_time_t odp_packet_ts(odp_packet_t pkt)
 {
-	odp_packet_hdr_t *pkt_hdr = odp_packet_hdr(pkt);
+	odp_packet_hdr_t *pkt_hdr = packet_hdr(pkt);
 
 	return pkt_hdr->timestamp;
 }
 
 void odp_packet_ts_set(odp_packet_t pkt, odp_time_t timestamp)
 {
-	odp_packet_hdr_t *pkt_hdr = odp_packet_hdr(pkt);
+	odp_packet_hdr_t *pkt_hdr = packet_hdr(pkt);
 
 	pkt_hdr->timestamp = timestamp;
 	pkt_hdr->p.input_flags.timestamp = 1;
@@ -1603,14 +1625,14 @@ void odp_packet_ts_set(odp_packet_t pkt, odp_time_t timestamp)
 
 int odp_packet_is_segmented(odp_packet_t pkt)
 {
-	odp_packet_hdr_t *pkt_hdr = odp_packet_hdr(pkt);
+	odp_packet_hdr_t *pkt_hdr = packet_hdr(pkt);
 
 	return pkt_hdr->buf_hdr.segcount > 1 || pkt_hdr->ref_hdr != NULL;
 }
 
 int odp_packet_num_segs(odp_packet_t pkt)
 {
-	odp_packet_hdr_t *pkt_hdr = odp_packet_hdr(pkt);
+	odp_packet_hdr_t *pkt_hdr = packet_hdr(pkt);
 	uint32_t segcount = 0, i;
 	uint32_t seg_offset = 0, offset;
 
@@ -1644,7 +1666,7 @@ odp_packet_seg_t odp_packet_last_seg(odp_packet_t pkt)
 
 odp_packet_seg_t odp_packet_next_seg(odp_packet_t pkt, odp_packet_seg_t seg)
 {
-	odp_packet_hdr_t *pkt_hdr = odp_packet_hdr(pkt);
+	odp_packet_hdr_t *pkt_hdr = packet_hdr(pkt);
 
 	if (odp_unlikely(seg >= packet_last_seg(pkt_hdr)))
 		return ODP_PACKET_SEG_INVALID;
@@ -1661,7 +1683,7 @@ odp_packet_seg_t odp_packet_next_seg(odp_packet_t pkt, odp_packet_seg_t seg)
 
 void *odp_packet_seg_data(odp_packet_t pkt, odp_packet_seg_t seg)
 {
-	odp_packet_hdr_t *pkt_hdr = odp_packet_hdr(pkt);
+	odp_packet_hdr_t *pkt_hdr = packet_hdr(pkt);
 	uint32_t seg_offset = 0, offset = 0, i;
 
 	while (seg >= pkt_hdr->buf_hdr.segcount - seg_offset &&
@@ -1686,7 +1708,7 @@ void *odp_packet_seg_data(odp_packet_t pkt, odp_packet_seg_t seg)
 
 uint32_t odp_packet_seg_data_len(odp_packet_t pkt, odp_packet_seg_t seg)
 {
-	odp_packet_hdr_t *pkt_hdr = odp_packet_hdr(pkt);
+	odp_packet_hdr_t *pkt_hdr = packet_hdr(pkt);
 	uint32_t seg_offset = 0, offset = 0, i;
 
 	while (seg >= pkt_hdr->buf_hdr.segcount - seg_offset &&
@@ -1719,7 +1741,7 @@ uint32_t odp_packet_seg_data_len(odp_packet_t pkt, odp_packet_seg_t seg)
 int odp_packet_add_data(odp_packet_t *pkt_ptr, uint32_t offset, uint32_t len)
 {
 	odp_packet_t pkt = *pkt_ptr;
-	odp_packet_hdr_t *pkt_hdr = odp_packet_hdr(pkt);
+	odp_packet_hdr_t *pkt_hdr = packet_hdr(pkt);
 	uint32_t pktlen = packet_len(pkt_hdr);
 	odp_packet_t newpkt;
 
@@ -1750,7 +1772,7 @@ int odp_packet_add_data(odp_packet_t *pkt_ptr, uint32_t offset, uint32_t len)
 int odp_packet_rem_data(odp_packet_t *pkt_ptr, uint32_t offset, uint32_t len)
 {
 	odp_packet_t pkt = *pkt_ptr;
-	odp_packet_hdr_t *pkt_hdr = odp_packet_hdr(pkt);
+	odp_packet_hdr_t *pkt_hdr = packet_hdr(pkt);
 	uint32_t pktlen = pkt_hdr->frame_len;
 	odp_packet_t newpkt;
 
@@ -1782,7 +1804,7 @@ int odp_packet_align(odp_packet_t *pkt, uint32_t offset, uint32_t len,
 	int rc;
 	uint32_t shift;
 	uint32_t seglen = 0;  /* GCC */
-	odp_packet_hdr_t *pkt_hdr = odp_packet_hdr(*pkt);
+	odp_packet_hdr_t *pkt_hdr = packet_hdr(*pkt);
 	void *addr = packet_map(pkt_hdr, offset, &seglen, NULL);
 	uint64_t uaddr = (uint64_t)(uintptr_t)addr;
 	uint64_t misalign;
@@ -1822,8 +1844,8 @@ int odp_packet_align(odp_packet_t *pkt, uint32_t offset, uint32_t len,
 
 int odp_packet_concat(odp_packet_t *dst, odp_packet_t src)
 {
-	odp_packet_hdr_t *dst_hdr = odp_packet_hdr(*dst);
-	odp_packet_hdr_t *src_hdr = odp_packet_hdr(src);
+	odp_packet_hdr_t *dst_hdr = packet_hdr(*dst);
+	odp_packet_hdr_t *src_hdr = packet_hdr(src);
 	int dst_segs        = dst_hdr->buf_hdr.segcount;
 	int src_segs        = src_hdr->buf_hdr.segcount;
 	odp_pool_t dst_pool = dst_hdr->buf_hdr.pool_hdl;
@@ -1922,12 +1944,12 @@ static inline odp_packet_t packet_splice(odp_packet_hdr_t *pkt_hdr,
 		pkt_hdr->unshared_len = offset;
 
 	packet_ref(pkt_hdr);
-	return _odp_packet_hdl(ref_hdr);
+	return packet_handle(ref_hdr);
 }
 
 odp_packet_t odp_packet_ref_static(odp_packet_t pkt)
 {
-	odp_packet_hdr_t *pkt_hdr = odp_packet_hdr(pkt);
+	odp_packet_hdr_t *pkt_hdr = packet_hdr(pkt);
 
 	pkt_hdr->unshared_len = 0;
 	packet_ref(pkt_hdr);
@@ -1942,7 +1964,7 @@ odp_packet_t odp_packet_ref(odp_packet_t pkt, uint32_t offset)
 	if (pkt == ODP_PACKET_INVALID)
 		return ODP_PACKET_INVALID;
 
-	pkt_hdr = odp_packet_hdr(pkt);
+	pkt_hdr = packet_hdr(pkt);
 	if (offset >= packet_len(pkt_hdr))
 		return ODP_PACKET_INVALID;
 
@@ -1951,7 +1973,7 @@ odp_packet_t odp_packet_ref(odp_packet_t pkt, uint32_t offset)
 	if (hdr == ODP_PACKET_INVALID)
 		return ODP_PACKET_INVALID;
 
-	return packet_splice(pkt_hdr, offset, odp_packet_hdr(hdr));
+	return packet_splice(pkt_hdr, offset, packet_hdr(hdr));
 }
 
 odp_packet_t odp_packet_ref_pkt(odp_packet_t pkt, uint32_t offset,
@@ -1966,16 +1988,16 @@ odp_packet_t odp_packet_ref_pkt(odp_packet_t pkt, uint32_t offset,
 
 	ODP_ASSERT(odp_packet_has_ref(hdr) == 0);
 
-	pkt_hdr = odp_packet_hdr(pkt);
+	pkt_hdr = packet_hdr(pkt);
 	if (offset >= packet_len(pkt_hdr))
 		return ODP_PACKET_INVALID;
 
-	return packet_splice(pkt_hdr, offset, odp_packet_hdr(hdr));
+	return packet_splice(pkt_hdr, offset, packet_hdr(hdr));
 }
 
 int odp_packet_has_ref(odp_packet_t pkt)
 {
-	odp_packet_hdr_t *pkt_hdr = odp_packet_hdr(pkt);
+	odp_packet_hdr_t *pkt_hdr = packet_hdr(pkt);
 
 	return pkt_hdr->ref_hdr != NULL || packet_ref_count(pkt_hdr) > 1;
 }
@@ -2026,7 +2048,7 @@ int odp_packet_copy_to_mem(odp_packet_t pkt, uint32_t offset,
 	uint32_t seglen = 0; /* GCC */
 	uint32_t cpylen;
 	uint8_t *dstaddr = (uint8_t *)dst;
-	odp_packet_hdr_t *pkt_hdr = odp_packet_hdr(pkt);
+	odp_packet_hdr_t *pkt_hdr = packet_hdr(pkt);
 
 	if (offset + len > packet_len(pkt_hdr))
 		return -1;
@@ -2050,7 +2072,7 @@ int odp_packet_copy_from_mem(odp_packet_t pkt, uint32_t offset,
 	uint32_t seglen = 0; /* GCC */
 	uint32_t cpylen;
 	const uint8_t *srcaddr = (const uint8_t *)src;
-	odp_packet_hdr_t *pkt_hdr = odp_packet_hdr(pkt);
+	odp_packet_hdr_t *pkt_hdr = packet_hdr(pkt);
 
 	if (offset + len > packet_len(pkt_hdr))
 		return -1;
@@ -2073,8 +2095,8 @@ int odp_packet_copy_from_pkt(odp_packet_t dst, uint32_t dst_offset,
 			     odp_packet_t src, uint32_t src_offset,
 			     uint32_t len)
 {
-	odp_packet_hdr_t *dst_hdr = odp_packet_hdr(dst);
-	odp_packet_hdr_t *src_hdr = odp_packet_hdr(src);
+	odp_packet_hdr_t *dst_hdr = packet_hdr(dst);
+	odp_packet_hdr_t *src_hdr = packet_hdr(src);
 	void *dst_map;
 	void *src_map;
 	uint32_t cpylen, minseg;
@@ -2153,10 +2175,11 @@ void odp_packet_print(odp_packet_t pkt)
 	char str[max_len];
 	int len = 0;
 	int n = max_len - 1;
-	odp_packet_hdr_t *hdr = odp_packet_hdr(pkt);
+	odp_packet_hdr_t *hdr = packet_hdr(pkt);
+	odp_buffer_t buf      = _odp_packet_to_buffer(pkt);
 
 	len += snprintf(&str[len], n - len, "Packet ");
-	len += odp_buffer_snprint(&str[len], n - len, (odp_buffer_t)pkt);
+	len += odp_buffer_snprint(&str[len], n - len, buf);
 	len += snprintf(&str[len], n - len, "  input_flags  0x%" PRIx64 "\n",
 			hdr->p.input_flags.all);
 	len += snprintf(&str[len], n - len, "  error_flags  0x%" PRIx32 "\n",
@@ -2201,7 +2224,7 @@ void odp_packet_print(odp_packet_t pkt)
 
 int odp_packet_is_valid(odp_packet_t pkt)
 {
-	if (odp_buffer_is_valid((odp_buffer_t)pkt) == 0)
+	if (odp_buffer_is_valid(_odp_packet_to_buffer(pkt)) == 0)
 		return 0;
 
 	if (odp_event_type(odp_packet_to_event(pkt)) != ODP_EVENT_PACKET)
@@ -2219,8 +2242,8 @@ int odp_packet_is_valid(odp_packet_t pkt)
 
 int _odp_packet_copy_md_to_packet(odp_packet_t srcpkt, odp_packet_t dstpkt)
 {
-	odp_packet_hdr_t *srchdr = odp_packet_hdr(srcpkt);
-	odp_packet_hdr_t *dsthdr = odp_packet_hdr(dstpkt);
+	odp_packet_hdr_t *srchdr = packet_hdr(srcpkt);
+	odp_packet_hdr_t *dsthdr = packet_hdr(dstpkt);
 
 	dsthdr->input = srchdr->input;
 	dsthdr->dst_queue = srchdr->dst_queue;
