import { VideoEncoder, VideoFrame } from '@pproenca/node-webcodecs';

const chunks = [];

const encoder = new VideoEncoder({
  output: (chunk, metadata) => {
    chunks.push(chunk);
    if (metadata?.decoderConfig?.description) {
      // Save codec extradata for container
    }
  },
  error: (e) => console.error('Encode error:', e),
});

encoder.configure({
  codec: 'avc1.42001e',  // H.264 Baseline
  width: 1920,
  height: 1080,
  bitrate: 5_000_000,
  framerate: 30,
});

// Create frames from RGBA buffers
for (let i = 0; i < 60; i++) {
  const frame = new VideoFrame(rgbaBuffer, {
    format: 'RGBA',
    codedWidth: 1920,
    codedHeight: 1080,
    timestamp: i * (1_000_000 / 30),  // microseconds
  });

  encoder.encode(frame, { keyFrame: i === 0 });
  frame.close();
}

await encoder.flush();
encoder.close();

import { VideoDecoder, EncodedVideoChunk } from '@pproenca/node-webcodecs';

const decoder = new VideoDecoder({
  output: (frame) => {
    console.log(`Frame: ${frame.codedWidth}x${frame.codedHeight}`);
    // Process frame data...
    frame.close();
  },
  error: (e) => console.error('Decode error:', e),
});

decoder.configure({
  codec: 'avc1.42001e',
  codedWidth: 1920,
  codedHeight: 1080,
  description: codecExtradata,  // From container or encoder
});

for (const chunk of encodedChunks) {
  decoder.decode(new EncodedVideoChunk({
    type: chunk.isKeyframe ? 'key' : 'delta',
    timestamp: chunk.timestamp,
    data: chunk.data,
  }));
}

await decoder.flush();
decoder.close();

import { Muxer, VideoEncoder, VideoFrame } from '@pproenca/node-webcodecs';

const muxer = new Muxer({ filename: 'output.mp4' });
let videoTrackId;

const encoder = new VideoEncoder({
  output: (chunk, metadata) => {
    if (metadata?.decoderConfig?.description) {
      // Add video track on first keyframe
      videoTrackId = muxer.addVideoTrack({
        codec: 'avc1.42001e',
        width: 1920,
        height: 1080,
        description: metadata.decoderConfig.description,
      });
    }
    muxer.writeVideoChunk(videoTrackId, chunk);
  },
  error: console.error,
});

encoder.configure({
  codec: 'avc1.42001e',
  width: 1920,
  height: 1080,
  bitrate: 5_000_000,
  avc: { format: 'avc' },  // Use AVCC format for MP4
});

// Encode frames...
await encoder.flush();
encoder.close();
muxer.finalize();

import { Demuxer } from '@pproenca/node-webcodecs';

const demuxer = new Demuxer({
  onTrack: (track) => {
    console.log(`Track ${track.index}: ${track.type} (${track.codec})`);
    if (track.type === 'video') {
      // Configure decoder with track.extradata
    }
  },
  onChunk: (chunk, trackIndex) => {
    // Feed chunk to decoder
  },
  onError: console.error,
});

demuxer.open('input.mp4');
demuxer.demux();  // Process all chunks
demuxer.close();

import { ImageDecoder } from '@pproenca/node-webcodecs';
import { readFileSync } from 'fs';

const imageData = readFileSync('animation.gif');

const decoder = new ImageDecoder({
  type: 'image/gif',
  data: imageData,
});

await decoder.completed;

console.log(`${decoder.tracks.length} track(s)`);
console.log(`${decoder.tracks[0].frameCount} frames`);
console.log(`Animated: ${decoder.tracks[0].animated}`);

// Decode each frame
for (let i = 0; i < decoder.tracks[0].frameCount; i++) {
  const { image, complete } = await decoder.decode({ frameIndex: i });
  console.log(`Frame ${i}: ${image.codedWidth}x${image.codedHeight}`);
  image.close();
}

decoder.close();