I might (doubtful) want to try and sell this device, so I can't simply
take some Logitech web cam and use it due to obvious licensing issues.
So that's a huge constraint.
Basically you will be creating an IP Camera. The Raspberry Pi is probably the cheapest and easiest way to prototype this, however there are other boards like the Beagle Boards.
Once you get a prototype going, then you may consider creating your own all in one device that uses an ARM or DSP processor. For example I would probably use some type of Serial JPEG Camera Module, a cheap microphone, and the cheapest ARM processor that will fit these requirements. But for a prototype, the Raspberry Pi and a cheap usb web cam is probably the cheapest and quickest way to get started and get your software going. You may even to be able to find a cheap no-name usb camera from china that will work for this so you can resell it in small quantities.
So as far as getting the frames to the MCU, there's two main issues
here: (a) the choice of camera and microphone, and (b) the drivers for
connecting the cam/mic to the Pi's USB port.
Here is the huge list of devices that work with the Raspberry Pi: RPi Verified Peripherals. The USB Webcams section lists both working and problem units. Along with a bit of extra info. After you find a unit that fits your requirements (price, etc.) I would try to double check via Google to verify someone has used it and it does indeed work; although this is probably unnecessary.
I'm sure there are other units that work that haven't been tested, the two things that will help you is to make sure it is Linux compatible, and that there are ARM drivers available.
There's also the issue of A/V encoding as well as synchronizing the
video and the audio feeds together.
As I mentioned in my comment, the RP really won't have any issues handling this part. It has more than enough processing power to handle most all A/V formats.
the Pi (which would be running GNU/Debian linux) will have the right
drivers to ingest the streaming frames and send them off to a tool
that would then be able to forward them on to a WiFi or Ethernet
adapter
Basically the RP is just going to be a linux computer that is connected to the internet and has the camera and microphone plugged into it. You will install and configure libasound2-dev (for the audio) and FFMPEG to stream everything.
Then this will just be like any other server online (you may need to configure your router and port forwarding etc. to get it to be visible on the web,) and according to this, you and other computers will just access it by going to h**p://YOUR_WEBCAM_SERVER/webcam.mjpeg
Helpful links:
You won't save power on the 5V device and inputting closer to the minimum limit reduces your noise immunity so I'd say not.
However, if you are outputting 3V3 from a 3V3 device and that feeds a 5V device the benefit is that it will work albeit with reduced noise immunity.
Best Answer
Basically what you would need to do is reverse engineer the protocol through observation.
Let's say you wanted to use a SNES controller. The first thing you should do is take apart the controller and figure out how it's wired up internally - how many buttons? How are they connected together? What sort of sensors are used for analog sticks? Is there any sort of force feedback/vibrators/etc? How many wires interface with the controller? Which ones are obviously signal/power/ground?
Once you have some idea of what's going on in the controller, you need to observe it in action. Connect it to an SNES and connect the logic analyzer to the signal lines and ground. The ground is rather important, without a good ground your readings will be meaningless.
Then you want to fire up the SNES and start wiggling around the knobs and pushing buttons. Look at the data you see on the pins. You'll need to figure out which end is generating the signals - is the SNES querying the controller, or is it just sending data at will? You'll then need to start piecing together the protocol. It's probably serial of some sort, so you'll need to determine the baud rate. That's just a matter of measuing the width of the narrowest bit. Then you need to figure out the format. Is it something like RS232? If so, how many start and stop bits? MSB or LSB first? Or perhaps it is more akin to I2C, where you have a clock and a shared data line that can be driven by either end. Once you have a good idea what the protocol is, then you can start figuring out what the actual data is. Decent logic analyzers can decode I2C and RS232. If you don't have one that can do this, you're going to have a LOT of work to do. Once you can get consistent data out of it, then it's just a matter of figuring out what data corresponds to what button or stick. Once you have all that, then you need to implement the controller side of the protocol on something to see if you got it right. If that works, then you should be able to go ahead and write your device driver.